Bump version: 0.81 → 1.0

This reverts commit 291d7431b0.

.bumpversion.cfg

@@ -1,7 +1,7 @@
 [bumpversion]
 commit = True
 tag = True
-current_version = 0.35
+current_version = 1.0
 parse = (?P<major>\d+)\.(?P<minor>\d+)(\.(?P<patch>\d+)(\-(?P<release>[a-z]+))?)?
 serialize = 
 	{major}.{minor}
@@ -10,7 +10,11 @@ serialize =
 search = VERSION "{current_version}"
 replace = VERSION "{new_version}"
 
-[bumpversion:file:PKGBUILD]
+[bumpversion:file:pkg/arch/PKGBUILD]
 search = pkgver={current_version}
 replace = pkgver={new_version}
 
+[bumpversion:file:pkg/openwrt/Makefile]
+search = PKG_VERSION:={current_version}
+replace = PKG_VERSION:={new_version}
+

.gitignore

@@ -1,8 +1,9 @@
-/pkg/
-/src/ustreamer-*/
-/src/v*.tar.gz
-/v*.tar.gz
-/ustreamer-*.pkg.tar.xz
+/pkg/arch/pkg/
+/pkg/arch/src/
+/pkg/arch/v*.tar.gz
+/pkg/arch/ustreamer-*.pkg.tar.xz
+/config.mk
 /vgcore.*
 /ustreamer
+/*.sock
 *.o

Makefile

@@ -1,22 +1,38 @@
+-include config.mk
+
+PROG ?= ustreamer
 DESTDIR ?=
 PREFIX ?= /usr/local
+
+CC ?= gcc
 CFLAGS ?= -O3
 LDFLAGS ?=
 
+RPI_VC_HEADERS ?= /opt/vc/include
+RPI_VC_LIBS ?= /opt/vc/lib
+
 
 # =====
-CC = gcc
 LIBS = -lm -ljpeg -pthread -levent -levent_pthreads -luuid
-override CFLAGS += -c -std=c99 -Wall -Wextra -D_GNU_SOURCE
-SOURCES = $(shell ls src/*.c src/jpeg/*.c)
-OBJECTS = $(SOURCES:.c=.o)
-PROG = ustreamer
+override CFLAGS += -c -std=c11 -Wall -Wextra -D_GNU_SOURCE
+SOURCES = $(shell ls src/*.c src/http/*.c src/encoders/cpu/*.c src/encoders/hw/*.c)
 
 
-ifeq ($(shell ls -d /opt/vc/include 2>/dev/null), /opt/vc/include)
-SOURCES += $(shell ls src/omx/*.c)
-LIBS += -lbcm_host -lvcos -lopenmaxil -L/opt/vc/lib
-override CFLAGS += -DOMX_ENCODER -DOMX_SKIP64BIT -I/opt/vc/include
+define optbool
+$(filter $(shell echo $(1) | tr A-Z a-z), yes on 1)
+endef
+
+
+ifneq ($(call optbool,$(WITH_OMX)),)
+	LIBS += -lbcm_host -lvcos -lopenmaxil -L$(RPI_VC_LIBS)
+	override CFLAGS += -DWITH_OMX -DOMX_SKIP64BIT -I$(RPI_VC_HEADERS)
+	SOURCES += $(shell ls src/encoders/omx/*.c)
+endif
+
+
+ifneq ($(call optbool,$(WITH_GPIO)),)
+	LIBS += -lwiringPi
+	override CFLAGS += -DWITH_GPIO
 endif
 
 
@@ -28,17 +44,32 @@ install: $(PROG)
 	install -Dm755 $(PROG) $(DESTDIR)$(PREFIX)/bin/$(PROG)
 
 
+install-strip: install
+	strip $(DESTDIR)$(PREFIX)/bin/$(PROG)
+
+
+uninstall:
+	rm $(DESTDIR)$(PREFIX)/bin/$(PROG)
+
+
 regen:
-	tools/make-jpeg-h.py src/data/blank.jpeg src/data/blank_jpeg.h BLANK 640 480
-	tools/make-html-h.py src/data/index.html src/data/index_html.h HTML_INDEX_PAGE
+	tools/make-jpeg-h.py src/http/data/blank.jpeg src/http/data/blank_jpeg.h BLANK
+	tools/make-html-h.py src/http/data/index.html src/http/data/index_html.h INDEX
 
 
-$(PROG): $(OBJECTS)
-	$(CC) $(LIBS) $(LDFLAGS) $(OBJECTS) -o $@
+$(PROG): $(SOURCES:.c=.o)
+	$(info -- LINKING $@)
+	@ $(CC) $(SOURCES:.c=.o) -o $@ $(LDFLAGS) $(LIBS)
+	$(info ===== Build complete =====)
+	$(info == CC      = $(CC))
+	$(info == LIBS    = $(LIBS))
+	$(info == CFLAGS  = $(CFLAGS))
+	$(info == LDFLAGS = $(LDFLAGS))
 
 
 .c.o:
-	$(CC) $(LIBS) $(CFLAGS) $< -o $@
+	$(info -- CC $<)
+	@ $(CC) $< -o $@ $(CFLAGS) $(LIBS)
 
 
 release:
@@ -50,14 +81,16 @@ release:
 
 
 bump:
-	bumpversion minor
+	bumpversion $(if $(V),$(V),minor)
 
 
 push:
 	git push
 	git push --tags
 
+
 clean-all: clean
 clean:
-	rm -f src/*.o src/{jpeg,omx}/*.o vgcore.* $(PROG)
-	rm -rf pkg src/$(PROG)-* src/v*.tar.gz v*.tar.gz $(PROG)-*.pkg.tar.xz
+	find src -name '*.o' -exec rm '{}' \;
+	rm -rf pkg/arch/pkg pkg/arch/src pkg/arch/v*.tar.gz pkg/arch/ustreamer-*.pkg.tar.xz
+	rm -f vgcore.* *.sock $(PROG)

PKGBUILD

@@ -1,30 +0,0 @@
-# Contributor: Maxim Devaev <mdevaev@gmail.com>
-# Author: Maxim Devaev <mdevaev@gmail.com>
-
-
-pkgname=ustreamer
-pkgver=0.35
-pkgrel=1
-pkgdesc="Lightweight and fast MJPG-HTTP streamer"
-url="https://github.com/pi-kvm/ustreamer"
-license=(GPL)
-arch=(i686 x86_64 armv6h armv7h)
-depends=(libjpeg libevent libutil-linux)
-# optional: raspberrypi-firmware for OMX JPEG compressor
-makedepends=(gcc make)
-source=("$url/archive/v$pkgver.tar.gz")
-md5sums=(SKIP)
-
-
-build() {
-	cd $srcdir
-	rm -rf $pkgname-build
-	cp -r ustreamer-$pkgver $pkgname-build
-	cd $pkgname-build
-	make CFLAGS="$CFLAGS" LDFLAGS="$LDFLAGS" $MAKEFLAGS
-}
-
-package() {
-	cd $srcdir/$pkgname-build
-	make DESTDIR="$pkgdir" PREFIX=/usr install
-}

README.md

@@ -10,23 +10,20 @@
 |----------|---------------|-------------------|
 | Multithreaded JPEG encoding | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) No |
 | [OpenMAX IL](https://www.khronos.org/openmaxil) hardware acceleration<br>on Raspberry Pi | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) No |
-| Behavior when the device<br>is disconnected while streaming | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Shows a black screen<br>with ```NO SIGNAL``` on it<br>until reconnected | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Stops the broadcast<sup>1</sup> |
+| Behavior when the device<br>is disconnected while streaming | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Shows a black screen<br>with ```NO SIGNAL``` on it<br>until reconnected | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Stops the broadcast <sup>1</sup> |
 | [DV-timings](https://linuxtv.org/downloads/v4l-dvb-apis/uapi/v4l/dv-timings.html) support -<br>the ability to change resolution<br>on the fly by source signal | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes | ![#ffaa00](https://placehold.it/15/ffaa00/000000?text=+) Partially yes <sup>1</sup> |
 | Option to skip frames when streaming<br>static images by HTTP to save traffic | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes <sup>2</sup> | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) No |
+| Streaming via UNIX domain socket | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) No |
 | Debug logs without recompiling,<br>performance statistics log,<br>access to HTTP broadcast parameters | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) No |
-| Supported input devices | ![#ffaa00](https://placehold.it/15/ffaa00/000000?text=+) YUYV, UYVY,<br>RGB565, ~~MJPG~~ <sup>3</sup> | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) YUYV, UYVY,<br>RGB565, MJPG |
+| Option to serve files<br>with a built-in HTTP server | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes | ![#ffaa00](https://placehold.it/15/ffaa00/000000?text=+) Regular files only |
+| Signaling about the stream state to GPIO<br>on Raspberry Pi using [wiringPi](http://wiringpi.com) | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) No |
 | Access to webcam controls (focus, servos)<br>and settings such as brightness via HTTP | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) No | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes |
-| Option to serve files<br>with a built-in HTTP server, auth settings | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) No <sup>4</sup> | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes |
 
 Footnotes:
   * ```1``` Long before µStreamer, I made a [patch](https://github.com/jacksonliam/mjpg-streamer/pull/164) to add DV-timings support to mjpg-streamer and to keep it from hanging up no device disconnection. Alas, the patch is far from perfect and I can't guarantee it will work every time - mjpg-streamer's source code is very complicated and its structure is hard to understand. With this in mind, along with needing multithreading and JPEG hardware acceleration in the future, I decided to make my own stream server from scratch instead of supporting legacy code.
   
   * ```2``` This feature allows to cut down outgoing traffic several-fold when broadcasting HDMI, but it increases CPU usage a little bit. The idea is that HDMI is a fully digital interface and each captured frame can be identical to the previous one byte-wise. There's no need to broadcast the same image over the net several times a second. With the `--drop-same-frames=20` option enabled, µStreamer will drop all the matching frames (with a limit of 20 in a row). Each new frame is matched with the previous one first by length, then using ```memcmp()```.
 
-  * ```3``` As µStreamer was made mainly to be used with screencast hardware it supports video formats they usually need. MJPG input means that the screencast device can compress images to JPEG and feed it to the software, which allows to cut down CPU usage and avoid software image encoding. This video format is supported by most webcams, but I've never seen it supported by screencast hardware: neither [Auvidea B101](https://auvidea.com/b101-hdmi-to-csi-2-bridge-15-pin-fpc/), nor [EasyCap UTV 007](https://www.amazon.com/dp/B0126O0RDC) offer such support. It's not hard to add hardware MJPG sources support, it's just not done yet.
-
-  * ```4``` ...and there'll never be. µStreamer is designed UNIX-way, so if you need a small website with your broadcast, install NGINX.
-
 -----
 # TL;DR
 If you're going to live-stream from your backyard webcam and need to control it, use mjpg-streamer. If you need a high-quality image with high FPS - µStreamer for the win.
@@ -35,7 +32,7 @@ If you're going to live-stream from your backyard webcam and need to control it,
 # Building
 You'll need  ```make```, ```gcc```, ```libevent``` with ```pthreads``` support, ```libjpeg8```/```libjpeg-turbo``` and ```libuuid```.
 
-It should compile automatically with OpenMAX IL on Raspberry Pi, if the corresponding headers are present in ```/opt/vc/include```.
+On Raspberry Pi you can build the program with OpenMAX IL. To do this pass option ```WITH_OMX=1``` to ```make```. To enable GPIO support install [wiringPi](http://wiringpi.com) and pass option ```WITH_GPIO=1```.
 
 ```
 $ git clone --depth=1 https://github.com/pi-kvm/ustreamer
@@ -44,7 +41,8 @@ $ make
 $ ./ustreamer --help
 ```
 
-AUR has a package for Arch Linux: https://aur.archlinux.org/packages/ustreamer
+AUR has a package for Arch Linux: https://aur.archlinux.org/packages/ustreamer. It should compile automatically with OpenMAX IL on Raspberry Pi, if the corresponding headers are present in ```/opt/vc/include```. Same with GPIO.  
+FreeBSD port: https://www.freshports.org/multimedia/ustreamer.
 
 -----
 # Usage
@@ -58,8 +56,9 @@ The recommended way of running µStreamer with [Auvidea B101](https://www.raspbe
 $ ./ustreamer \
     --format=uyvy \ # Device input format
     --encoder=omx \ # Hardware encoding with OpenMAX
-    --dv-timings \ # use DV-timings
-    --quality=20 \ # OpenMAX has a non-linear quality scale
+    --workers=3 \ # Maximum workers for OpenMAX
+    --persistent \ # Don't re-initialize device on timeout (for example when HDMI cable was disconnected)
+    --dv-timings \ # Use DV-timings
     --drop-same-frames=30 # Save that traffic
 ```
 

README.ru.md

@@ -10,23 +10,20 @@
 |----------|---------------|-------------------|
 | Многопоточное кодирование JPEG | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет |
 | Аппаратное кодирование с помощью [OpenMAX IL](https://www.khronos.org/openmaxil) на Raspberry Pi | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет |
-| Поведение при физическом отключении устройства<br>от сервера во время работы | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Транслирует черный экран<br>с надписью ```NO SIGNAL```,<br>пока устройство не будет подключено снова | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Прерывает трансляцию <sup>1</sup> |
-| Поддержка [DV-таймингов](https://linuxtv.org/downloads/v4l-dvb-apis/uapi/v4l/dv-timings.html) - возможности изменения <br>параметров разрешения трансляции на лету<br>по сигналу источника (устройства видеозахвата) | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть | ![#ffaa00](https://placehold.it/15/ffaa00/000000?text=+) Условно есть <sup>1</sup> |
+| Поведение при физическом отключении<br>устройства от сервера во время работы | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Транслирует черный экран<br>с надписью ```NO SIGNAL```,<br>пока устройство не будет подключено снова | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Прерывает трансляцию <sup>1</sup> |
+| Поддержка [DV-таймингов](https://linuxtv.org/downloads/v4l-dvb-apis/uapi/v4l/dv-timings.html) - возможности<br>изменения  параметров разрешения<br>трансляции на лету по сигналу<br>источника (устройства видеозахвата) | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть | ![#ffaa00](https://placehold.it/15/ffaa00/000000?text=+) Условно есть <sup>1</sup> |
 | Возможность пропуска фреймов при передаче<br>статического изображения по HTTP<br>для экономии трафика | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть <sup>2</sup> | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет |
+| Стрим через UNIX domain socket | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет |
 | Дебаг-логи без перекомпиляции,<br>логгирование статистики производительности,<br>возможность получения параметров<br>трансляции по HTTP | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет |
-| Поддерживаемые входные форматы устройств | ![#ffaa00](https://placehold.it/15/ffaa00/000000?text=+) YUYV, UYVY,<br>RGB565, ~~MJPG~~ <sup>3</sup> | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) YUYV, UYVY,<br>RGB565, MJPG |
+| Возможность сервить файлы встроенным<br>HTTP-сервером  | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть | ![#ffaa00](https://placehold.it/15/ffaa00/000000?text=+) Нет каталогов |
+| Вывод сигналов о состоянии стрима на GPIO<br>на Raspberry Pi с помощью [wiringPi](http://wiringpi.com) | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет |
 | Поддержка контролов веб-камер (фокус,<br> движение сервами) и всяких настроек,<br> типа яркости, через HTTP | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть |
-| Возможность сервить файлы встроенным<br>HTTP-сервером, настройки авторизации | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет <sup>4</sup> | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть |
 
 Сносочки:
   * ```1``` Еще до написания µStreamer, я запилил [патч](https://github.com/jacksonliam/mjpg-streamer/pull/164), добавляющий в mjpg-streamer поддержку DV-таймингов и предотвращающий его зависание при отключении устройства. Однако патч, увы, далек от совершенства и я не гарантирую его стопроцентную работоспособность, поскольку код mjpg-streamer чрезвычайно запутан и очень плохо структурирован. Учитывая это, а также то, что в дальнейшем мне потребовались многопоточность и аппаратное кодирование JPEG, было принято решение написать свой стрим-сервер с нуля, чтобы не тратить силы на поддержку лишнего легаси.
   
   * ```2``` Это фича позволяет в несколько раз снизить объем исходящего трафика при трансляции HDMI, однако немного увеличивает загрузку процессора. Суть в том, что HDMI - полностью цифровой интерфейс, и новый захваченный фрейм может быть идентичен предыдущему в точности до байта. В этом случае нет нужды передавать одну и ту же картинку по сети несколько раз в секунду. При использовании опции `--drop-same-frames=20`, µStreamer будет дропать все одинаковые фреймы, но не более 20 подряд. Новый фрейм сравнивается с предыдущим сначала по длине, а затем помощью ```memcmp()```.
 
-  * ```3``` Поскольку µStreamer писался в первую очередь для устройств видеозахвата, в нем реализованы только те форматы, которые для них были нужны. MJPG в контексте входных данных означает, что устройство умеет самостоятельно сжимать картинку в JPEG и отдавать ее программе, что позволяет значительно снизить загрузку процессора и избавить его от необходимости кодировать картинку софтом. Этот формат поддерживается большинством веб-камер, но не поддерживается ни одним из встреченных мной устройств видеозахвата; его не умеет ни [Auvidea B101](https://auvidea.com/b101-hdmi-to-csi-2-bridge-15-pin-fpc/), ни [EasyCap UTV 007](https://www.amazon.com/dp/B0126O0RDC). Нет никаких технических сложностей добавить поддержку аппаратного MJPG источника, но у меня просто пока не дошли до этого руки.
-
-  * ```4``` ... и не будет. µStreamer придерживается концепции UNIX-way, так что если вам нужно нарисовать маленький сайтик со встроенной трансляцией - просто поставьте NGINX.
-
 -----
 # TL;DR
 Если вам нужно вещать стрим с уличной камеры и управлять ее параметрами - возьмите mjpg-streamer. Если же вам нужно очень качественное изображение с высоким FPS - µStreamer ваш бро.
@@ -35,7 +32,7 @@
 # Сборка
 Для сборки вам понадобятся ```make```, ```gcc```, ```libevent``` с поддержкой ```pthreads```, ```libjpeg8```/```libjpeg-turbo``` и ```libuuid```.
 
-На Raspberry Pi програма автоматически собирается с поддержкой OpenMAX IL, если обнаружит нужные хедеры в ```/opt/vc/include```.
+На Raspberry Pi программу можно собрать с поддержкой OpenMAX IL. Для этого передайте ```make``` параметр ```WITH_OMX=1```. Для включения сборки с поддержкой GPIO установите [wiringPi](http://wiringpi.com) и добавьте параметр ```WITH_GPIO=1```.
 
 ```
 $ git clone --depth=1 https://github.com/pi-kvm/ustreamer
@@ -44,7 +41,8 @@ $ make
 $ ./ustreamer --help
 ```
 
-Для Arch Linux в AUR есть готовый пакет: https://aur.archlinux.org/packages/ustreamer
+Для Arch Linux в AUR есть готовый пакет: https://aur.archlinux.org/packages/ustreamer. На Raspberry Pi програма автоматически собирается с поддержкой OpenMAX IL, если обнаружит нужные хедеры в ```/opt/vc/include```. То же самое и с GPIO.  
+Порт для FreeBSD: https://www.freshports.org/multimedia/ustreamer.
 
 -----
 # Использование
@@ -58,8 +56,9 @@ $ ./ustreamer --help
 $ ./ustreamer \
     --format=uyvy \ # Настройка входного формата устройства
     --encoder=omx \ # Использование аппаратного кодирования с помощью OpenMAX
+    --workers=3 \ # Максимум воркеров для OpenMAX
+    --persistent \ # Не переинициализировать устройство при таймауте (например, когда был отключен HDMI-кабель)
     --dv-timings \ # Включение DV-таймингов
-    --quality=20 \ # У OpenMAX нелинейная шкала качества
     --drop-same-frames=30 # Экономим трафик
 ```
 

pkg/arch/PKGBUILD

@@ -0,0 +1,36 @@
+# Contributor: Maxim Devaev <mdevaev@gmail.com>
+# Author: Maxim Devaev <mdevaev@gmail.com>
+
+
+pkgname=ustreamer
+pkgver=1.0
+pkgrel=1
+pkgdesc="Lightweight and fast MJPG-HTTP streamer"
+url="https://github.com/pi-kvm/ustreamer"
+license=(GPL)
+arch=(i686 x86_64 armv6h armv7h)
+depends=(libjpeg libevent libutil-linux)
+# optional: raspberrypi-firmware for OMX encoder
+# optional: wiringpi for GPIO support
+makedepends=(gcc make)
+source=(${pkgname}::"git+https://github.com/pi-kvm/ustreamer#commit=v${pkgver}")
+md5sums=(SKIP)
+
+
+build() {
+	cd "$srcdir"
+	rm -rf $pkgname-build
+	cp -r $pkgname $pkgname-build
+	cd $pkgname-build
+
+	local _options=""
+	[ -e /opt/vc/include/IL/OMX_Core.h ] && _options="$_options WITH_OMX=1"
+	[ -e /usr/include/wiringPi.h ] && _options="$_options WITH_GPIO=1"
+
+	make $_options CFLAGS="$CFLAGS" LDFLAGS="$LDFLAGS" $MAKEFLAGS
+}
+
+package() {
+	cd "$srcdir/$pkgname-build"
+	make DESTDIR="$pkgdir" PREFIX=/usr install
+}

pkg/gentoo/ustreamer-9999.ebuild

@@ -0,0 +1,27 @@
+# Copyright 2019 Gentoo Authors
+# Distributed under the terms of the GNU General Public License v2
+ 
+EAPI=7
+ 
+inherit git-r3
+ 
+DESCRIPTION="uStreamer - Lightweight and fast MJPG-HTTP streamer"
+HOMEPAGE="https://github.com/pi-kvm/ustreamer"
+EGIT_REPO_URI="https://github.com/pi-kvm/ustreamer.git"
+ 
+LICENSE="GPL-3"
+SLOT="0"
+KEYWORDS="~amd64"
+IUSE=""
+ 
+DEPEND="
+	>=dev-libs/libevent-2.1.8
+	>=media-libs/libjpeg-turbo-1.5.3
+	>=sys-apps/util-linux-2.33
+"
+RDEPEND="${DEPEND}"
+BDEPEND=""
+ 
+src_install() {
+	dobin ustreamer 
+}

pkg/openwrt/Makefile

@@ -0,0 +1,45 @@
+#
+# This is free software, licensed under the GNU General Public License v2.
+# See /LICENSE for more information.
+#
+
+include $(TOPDIR)/rules.mk
+
+PKG_NAME:=ustreamer
+PKG_VERSION:=1.0
+PKG_RELEASE:=1
+PKG_MAINTAINER:=Maxim Devaev <mdevaev@gmail.com>
+
+PKG_SOURCE_PROTO:=git
+PKG_SOURCE_URL:=https://github.com/pi-kvm/ustreamer.git
+PKG_SOURCE_VERSION:=v$(PKG_VERSION)
+PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.xz
+PKG_SOURCE_SUBDIR:=$(PKG_NAME)-$(PKG_VERSION)
+
+PKG_LICENSE:=GPL-3.0
+PKG_LICENSE_FILES:=LICENSE
+
+include $(INCLUDE_DIR)/package.mk
+
+define Package/ustreamer
+  SECTION:=multimedia
+  CATEGORY:=Multimedia
+  TITLE:=uStreamer
+  DEPENDS:=+libpthread +libjpeg +libv4l +libuuid +libevent2 +libevent2-core +libevent2-extra +libevent2-pthreads
+  URL:=https://github.com/pi-kvm/ustreamer
+endef
+
+define Package/ustreamer/description
+ µStreamer - Lightweight and fast MJPG-HTTP streamer
+endef
+
+define Package/ustreamer/install
+	$(INSTALL_DIR) $(1)/usr/bin
+	$(INSTALL_BIN) $(PKG_BUILD_DIR)/ustreamer $(1)/usr/bin/
+	$(INSTALL_DIR) $(1)/etc/config
+	$(CP) ./files/ustreamer.config $(1)/etc/config/ustreamer
+	$(INSTALL_DIR) $(1)/etc/init.d
+	$(INSTALL_BIN) ./files/ustreamer.init $(1)/etc/init.d/ustreamer
+endef
+
+$(eval $(call BuildPackage,ustreamer))

pkg/openwrt/files/ustreamer.config

@@ -0,0 +1,19 @@
+
+config ustreamer
+	option enabled '0'
+
+	option device '/dev/video0'
+	option device_timeout '5'
+	option input '0'
+
+	option resolution '640x480'
+	option format 'YUYV'
+	option quality '80'
+	option desired_fps '0'
+	option encoder 'CPU'
+
+	option host '::'
+	option port '8080'
+	option static ''
+	option user ''
+	option password ''

pkg/openwrt/files/ustreamer.init

@@ -0,0 +1,54 @@
+#!/bin/sh /etc/rc.common
+# Copyright (C) 2009-2019 OpenWrt.org
+
+START=90
+STOP=10
+
+USE_PROCD=1
+PROG=/usr/bin/ustreamer
+
+getcfg() {
+	config_get value ustreamer $1 $2
+	return "$value"
+}
+
+start_instance() {
+	config_get_bool enabled ustreamer enabled 0
+	[ "$enabled" -eq 0 ] && return
+
+	local options=""
+
+	options="$options --device='`getcfg device /dev/video0`'"
+	options="$options --device-timeout='`getcfg device_timeout 5`'"
+	options="$options --input='`getcfg input 0`'"
+
+	options="$options --resolution='`getcfg resolution 640x480`'"
+	options="$options --format='`getcfg format YUYV`'"
+	options="$options --quality='`getcfg quality 80`'"
+	options="$options --desired-fps='`getcfg desired_fps 0`'"
+	options="$options --encoder='`getcfg encoder CPU`'"
+
+	options="$options --host='`getcfg host '::'`'"
+	local port=`getcfg port 8080`
+	options="$options --port='$port'"
+	options="$options --static='`getcfg static ''`'"
+	options="$options --user='`getcfg user ''`'"
+	options="$options --passwd='`getcfg password ''`'"
+
+	config-get-bool opt_slowdown ustreamer slowdown 1
+	[ "$slowdown" -eq 1 ] && options="$options --slowdown"
+
+	procd_open_instance
+	procd_set_param command "$PROG" $options
+	procd_add_mdns http tcp "$port" daemon=ustreamer
+	procd_close_instance
+}
+
+start_service() {
+	config_load ustreamer
+	config_foreach start_instance ustreamer
+}
+
+service_triggers() {
+	procd_add_reload_trigger ustreamer
+}

src/config.h

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
@@ -21,4 +22,6 @@
 
 #pragma once
 
-#define VERSION "0.35"
+#ifndef VERSION
+#	define VERSION "1.0"
+#endif

src/data/blank_jpeg.h

@@ -1,688 +0,0 @@
-/*****************************************************************************
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
-#                                                                            #
-#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
-#                                                                            #
-#    This program is free software: you can redistribute it and/or modify    #
-#    it under the terms of the GNU General Public License as published by    #
-#    the Free Software Foundation, either version 3 of the License, or       #
-#    (at your option) any later version.                                     #
-#                                                                            #
-#    This program is distributed in the hope that it will be useful,         #
-#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
-#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
-#    GNU General Public License for more details.                            #
-#                                                                            #
-#    You should have received a copy of the GNU General Public License       #
-#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
-#                                                                            #
-*****************************************************************************/
-
-
-const unsigned BLANK_JPG_WIDTH = 640;
-const unsigned BLANK_JPG_HEIGHT = 480;
-
-const unsigned long BLANK_JPG_SIZE = 13845;
-
-const unsigned char BLANK_JPG_DATA[] = {
-	0xff, 0xd8, 0xff, 0xe1, 0x9, 0x50, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x6e, 0x73, 0x2e, 0x61, 0x64, 0x6f, 0x62, 0x65,
-	0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x78, 0x61, 0x70, 0x2f, 0x31, 0x2e, 0x30, 0x2f, 0x0, 0x3c, 0x3f, 0x78, 0x70, 0x61, 0x63, 0x6b,
-	0x65, 0x74, 0x20, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x3d, 0x22, 0xef, 0xbb, 0xbf, 0x22, 0x20, 0x69, 0x64, 0x3d, 0x22, 0x57, 0x35,
-	0x4d, 0x30, 0x4d, 0x70, 0x43, 0x65, 0x68, 0x69, 0x48, 0x7a, 0x72, 0x65, 0x53, 0x7a, 0x4e, 0x54, 0x63, 0x7a, 0x6b, 0x63, 0x39,
-	0x64, 0x22, 0x3f, 0x3e, 0x20, 0x3c, 0x78, 0x3a, 0x78, 0x6d, 0x70, 0x6d, 0x65, 0x74, 0x61, 0x20, 0x78, 0x6d, 0x6c, 0x6e, 0x73,
-	0x3a, 0x78, 0x3d, 0x22, 0x61, 0x64, 0x6f, 0x62, 0x65, 0x3a, 0x6e, 0x73, 0x3a, 0x6d, 0x65, 0x74, 0x61, 0x2f, 0x22, 0x20, 0x78,
-	0x3a, 0x78, 0x6d, 0x70, 0x74, 0x6b, 0x3d, 0x22, 0x41, 0x64, 0x6f, 0x62, 0x65, 0x20, 0x58, 0x4d, 0x50, 0x20, 0x43, 0x6f, 0x72,
-	0x65, 0x20, 0x35, 0x2e, 0x36, 0x2d, 0x63, 0x31, 0x33, 0x38, 0x20, 0x37, 0x39, 0x2e, 0x31, 0x35, 0x39, 0x38, 0x32, 0x34, 0x2c,
-	0x20, 0x32, 0x30, 0x31, 0x36, 0x2f, 0x30, 0x39, 0x2f, 0x31, 0x34, 0x2d, 0x30, 0x31, 0x3a, 0x30, 0x39, 0x3a, 0x30, 0x31, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x22, 0x3e, 0x20, 0x3c, 0x72, 0x64, 0x66, 0x3a, 0x52, 0x44, 0x46, 0x20, 0x78, 0x6d,
-	0x6c, 0x6e, 0x73, 0x3a, 0x72, 0x64, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x77,
-	0x33, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x31, 0x39, 0x39, 0x39, 0x2f, 0x30, 0x32, 0x2f, 0x32, 0x32, 0x2d, 0x72, 0x64, 0x66, 0x2d,
-	0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x2d, 0x6e, 0x73, 0x23, 0x22, 0x3e, 0x20, 0x3c, 0x72, 0x64, 0x66, 0x3a, 0x44, 0x65, 0x73,
-	0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x64, 0x66, 0x3a, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x3d, 0x22, 0x22,
-	0x2f, 0x3e, 0x20, 0x3c, 0x2f, 0x72, 0x64, 0x66, 0x3a, 0x52, 0x44, 0x46, 0x3e, 0x20, 0x3c, 0x2f, 0x78, 0x3a, 0x78, 0x6d, 0x70,
-	0x6d, 0x65, 0x74, 0x61, 0x3e, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3c, 0x3f, 0x78, 0x70,
-	0x61, 0x63, 0x6b, 0x65, 0x74, 0x20, 0x65, 0x6e, 0x64, 0x3d, 0x22, 0x77, 0x22, 0x3f, 0x3e, 0xff, 0xed, 0x0, 0x2c, 0x50, 0x68,
-	0x6f, 0x74, 0x6f, 0x73, 0x68, 0x6f, 0x70, 0x20, 0x33, 0x2e, 0x30, 0x0, 0x38, 0x42, 0x49, 0x4d, 0x4, 0x25, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x10, 0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x0, 0xb2, 0x4, 0xe9, 0x80, 0x9, 0x98, 0xec, 0xf8, 0x42, 0x7e, 0xff, 0xdb,
-	0x0, 0x84, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1,
-	0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1,
-	0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3,
-	0x3, 0x3, 0x3, 0x3, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1, 0x2, 0x2, 0x2, 0x1, 0x2, 0x2, 0x3,
-	0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3,
-	0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3,
-	0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0xff, 0xdd, 0x0, 0x4, 0x0, 0x50, 0xff, 0xee, 0x0, 0xe, 0x41, 0x64, 0x6f, 0x62, 0x65,
-	0x0, 0x64, 0xc0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xc0, 0x0, 0x11, 0x8, 0x1, 0xe0, 0x2, 0x80, 0x3, 0x0, 0x11, 0x0, 0x1,
-	0x11, 0x1, 0x2, 0x11, 0x1, 0xff, 0xc4, 0x0, 0x7d, 0x0, 0x1, 0x0, 0x2, 0x3, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xb, 0x7, 0x8, 0x9, 0x5, 0x6, 0x2, 0x3, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10, 0x1, 0x0, 0x1, 0x4, 0x2, 0x1, 0x3,
-	0x2, 0x3, 0x4, 0x8, 0x4, 0x6, 0x3, 0x0, 0x0, 0x0, 0x3, 0x2, 0x4, 0x5, 0x6, 0x1, 0x7, 0x8, 0x9, 0x11, 0x12,
-	0xa, 0x13, 0x14, 0x21, 0x22, 0x15, 0x37, 0x77, 0xb6, 0x16, 0x23, 0x31, 0x35, 0x39, 0x41, 0x75, 0xb4, 0x17, 0x38, 0xb5, 0xb7,
-	0x18, 0x1a, 0x24, 0x32, 0x51, 0x78, 0x56, 0x97, 0xd4, 0x11, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xda, 0x0, 0xc, 0x3, 0x0, 0x0, 0x1, 0x11, 0x2, 0x11, 0x0, 0x3f, 0x0, 0xaf,
-	0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0,
-	0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff,
-	0xd1, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7,
-	0xff, 0xd2, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x7, 0xff, 0xd3, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x7, 0xff, 0xd4, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x7, 0xff, 0xd5, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x7, 0xff, 0xd6, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd7, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd1, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd2, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd3, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd4, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd5, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd6, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd7, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0, 0xaf, 0xfc, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd1, 0xaf, 0xfc, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd2, 0xaf, 0xfc, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd3, 0xaf, 0xfc,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd4, 0xaf,
-	0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd5,
-	0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff,
-	0xd6, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7,
-	0xff, 0xd7, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x7, 0xff, 0xd0, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x7, 0xff, 0xd1, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x7, 0xff, 0xd2, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x7, 0xff, 0xd3, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x6, 0x4c, 0xe9, 0x5b, 0xb, 0x1c, 0xaf, 0x71, 0xf5, 0x2e, 0x2f, 0x29, 0x65, 0x69, 0x92, 0xc6, 0x64,
-	0xbb, 0x33, 0x43, 0xb0, 0xc8, 0xe3, 0xaf, 0xed, 0xa1, 0xbc, 0xb1, 0xbf, 0xb1, 0xbc, 0xda, 0x71, 0x56, 0xf7, 0x76, 0x57, 0xb6,
-	0x97, 0x14, 0x49, 0x6f, 0x75, 0x69, 0x75, 0x6f, 0x25, 0x54, 0x49, 0x1d, 0x74, 0xd5, 0x45, 0x74, 0x55, 0xcd, 0x35, 0x71, 0xcf,
-	0x1c, 0xf3, 0xc0, 0x24, 0x45, 0xeb, 0x5f, 0xe9, 0x19, 0x61, 0xd4, 0x3f, 0xb6, 0x7c, 0xbb, 0xf1, 0x67, 0x4e, 0xb6, 0xc6, 0x75,
-	0x4c, 0x95, 0x47, 0x71, 0xdc, 0x5d, 0x53, 0xaa, 0xe3, 0x20, 0xb3, 0xc6, 0x75, 0x94, 0xf5, 0x71, 0x15, 0xbf, 0xf4, 0xe7, 0x4d,
-	0xc2, 0x63, 0xa0, 0x8a, 0x1b, 0x1d, 0x2, 0xf6, 0x5f, 0x6e, 0x72, 0x56, 0x50, 0x51, 0xf6, 0xf0, 0xd3, 0xd7, 0xf7, 0xe2, 0xa6,
-	0x9b, 0xa, 0xeb, 0xa2, 0xc4, 0x23, 0x22, 0xd, 0xd8, 0xf4, 0xe3, 0xeb, 0xed, 0x2f, 0xb5, 0xbc, 0xe3, 0xf1, 0xa7, 0xae, 0xbb,
-	0x17, 0x5c, 0xc7, 0x6d, 0xba, 0x46, 0xdd, 0xd9, 0x36, 0x38, 0x7d, 0x97, 0x5b, 0xcb, 0x47, 0x5c, 0xb8, 0xdc, 0xc6, 0x36, 0x6b,
-	0xc, 0x85, 0x72, 0x59, 0xdd, 0xd1, 0x1c, 0x91, 0x49, 0xcc, 0x55, 0x57, 0x1d, 0x3c, 0xfe, 0x9a, 0xa9, 0xe7, 0x8e, 0x78, 0xe3,
-	0x9e, 0x39, 0x6, 0xf5, 0xfa, 0xf4, 0x78, 0xe9, 0xd2, 0x3e, 0x34, 0xf9, 0x4d, 0xd5, 0x7a, 0x6f, 0x44, 0x75, 0xbe, 0xbb, 0xd6,
-	0x3a, 0xbe, 0x6b, 0xa0, 0x30, 0xbb, 0x3e, 0x57, 0xb, 0xad, 0x45, 0x73, 0xd, 0x95, 0xee, 0x7e, 0xe3, 0xb1, 0x7b, 0x23, 0x15,
-	0x36, 0x52, 0x6a, 0x6e, 0xae, 0x6e, 0x6b, 0xe6, 0xea, 0x4c, 0x76, 0x26, 0xda, 0x2e, 0x79, 0xe2, 0xae, 0x38, 0xf8, 0x43, 0x4f,
-	0xe5, 0xff, 0x0, 0xc8, 0x6b, 0xe7, 0xa6, 0xff, 0x0, 0xa5, 0xd7, 0x6f, 0xfa, 0x83, 0xed, 0x57, 0xd7, 0xf8, 0xeb, 0xfe, 0x3a,
-	0xe7, 0xa3, 0xb5, 0x1c, 0x8c, 0x56, 0x3b, 0xcf, 0x6b, 0x64, 0x71, 0xf5, 0xe4, 0x3e, 0x59, 0xa, 0xa0, 0xa6, 0xeb, 0x8d, 0x57,
-	0x49, 0xc4, 0x73, 0x35, 0xa5, 0x1b, 0x1e, 0xd3, 0x25, 0xbc, 0x91, 0xd7, 0x3f, 0xca, 0x68, 0x6d, 0x31, 0xd6, 0xf2, 0xd3, 0x2c,
-	0xf5, 0xf3, 0x5d, 0x76, 0xf6, 0xf7, 0x1, 0xda, 0xee, 0xc7, 0x83, 0xd0, 0x8f, 0xd3, 0x7, 0x27, 0xff, 0x0, 0xe, 0x76, 0xe,
-	0xa9, 0xaf, 0xca, 0xce, 0xf4, 0xd7, 0x61, 0xae, 0xd3, 0x69, 0xc6, 0x65, 0x31, 0x98, 0xce, 0xee, 0xcb, 0x58, 0xe5, 0xe1, 0xb3,
-	0xbe, 0xb0, 0xa6, 0x1d, 0xea, 0xdf, 0x71, 0xc9, 0xe0, 0xba, 0x47, 0x57, 0xbf, 0xaa, 0x6b, 0xa9, 0x7f, 0x11, 0x8f, 0xb1, 0xb2,
-	0xfd, 0xa3, 0x67, 0x55, 0x31, 0xcd, 0x2d, 0x9f, 0xdc, 0x8e, 0xd6, 0xae, 0x43, 0x15, 0xea, 0xfe, 0xa3, 0x9e, 0x87, 0x9d, 0xd5,
-	0x2d, 0x3a, 0x2f, 0x73, 0xfa, 0x79, 0xeb, 0x1d, 0x25, 0x84, 0xca, 0xdf, 0x5b, 0xc1, 0x46, 0xe7, 0xab, 0x74, 0xdf, 0x5c, 0x5b,
-	0x59, 0x63, 0x20, 0xb8, 0xb7, 0xbb, 0xb4, 0xba, 0xbe, 0xcd, 0xec, 0x5d, 0x39, 0xce, 0xad, 0xd9, 0xd8, 0xcb, 0x7b, 0x5a, 0x2e,
-	0x7e, 0x54, 0xd1, 0x8c, 0xb4, 0xc8, 0xd7, 0x55, 0x5e, 0xd2, 0xf1, 0x4d, 0x32, 0x45, 0x1f, 0x20, 0xf1, 0xfc, 0xca, 0xf4, 0x2e,
-	0xeb, 0xad, 0xbf, 0xab, 0x6b, 0xf2, 0x77, 0xd3, 0x43, 0x7a, 0xa7, 0xb2, 0xb4, 0x6b, 0xdc, 0x3d, 0xce, 0xd3, 0x1f, 0x52, 0xf1,
-	0xb2, 0x45, 0xba, 0xc1, 0x9c, 0xc2, 0x5a, 0xd1, 0x27, 0x37, 0x55, 0x75, 0x6, 0xeb, 0x45, 0x73, 0x64, 0x32, 0xb9, 0x1b, 0xf,
-	0xc3, 0x57, 0x4d, 0x78, 0x3c, 0xbc, 0xb7, 0x59, 0x9, 0xae, 0x28, 0x96, 0x28, 0xee, 0xf9, 0xb9, 0xa6, 0x3b, 0x2a, 0xc2, 0x30,
-	0x12, 0x47, 0x24, 0x52, 0x57, 0x14, 0xb4, 0x57, 0x14, 0xb1, 0x57, 0x54, 0x72, 0x47, 0x25, 0x3c, 0xd1, 0x24, 0x72, 0x51, 0xcf,
-	0x34, 0xd7, 0x45, 0x74, 0x55, 0xc7, 0x15, 0x51, 0x5d, 0x15, 0x71, 0xcf, 0x1c, 0xf1, 0xcf, 0x1e, 0xfc, 0x72, 0xf, 0xc0, 0x3a,
-	0x19, 0xe9, 0xa3, 0xe0, 0x76, 0x6b, 0xd4, 0x3, 0xc8, 0x9b, 0x6e, 0xae, 0xe7, 0x33, 0x79, 0xaa, 0x75, 0xde, 0xab, 0x85, 0x97,
-	0x75, 0xed, 0x5d, 0xbb, 0x1f, 0x14, 0x32, 0x64, 0xf1, 0x7a, 0xad, 0xb5, 0xf5, 0x9e, 0x3a, 0x1c, 0x56, 0xbd, 0xc5, 0xe4, 0x17,
-	0x18, 0xfa, 0xb6, 0x8d, 0x8f, 0x25, 0x7d, 0x1d, 0xbd, 0xa7, 0xdf, 0xa2, 0xb8, 0xe0, 0x8b, 0x89, 0xee, 0xaa, 0x8e, 0x6a, 0x6d,
-	0xea, 0x86, 0xb0, 0x90, 0x37, 0x92, 0x7d, 0xb9, 0xe8, 0xb9, 0xe9, 0x95, 0x9b, 0x8f, 0xc7, 0x5b, 0xf, 0xc, 0x74, 0x8f, 0x21,
-	0x3b, 0x3f, 0x9, 0x69, 0x8c, 0x9f, 0x70, 0xb4, 0xcb, 0xe9, 0x1a, 0x5f, 0x67, 0xdf, 0xeb, 0x52, 0x5e, 0x5b, 0x71, 0x91, 0x86,
-	0x9d, 0xc3, 0xb1, 0x7b, 0x82, 0xbc, 0xfd, 0xf5, 0xae, 0xc9, 0x95, 0xb5, 0xc8, 0x53, 0x77, 0xc6, 0x3b, 0x19, 0xc, 0x90, 0x43,
-	0xc, 0x94, 0x53, 0x5d, 0x36, 0x91, 0xd3, 0x6f, 0x10, 0x3f, 0x5b, 0xf, 0x40, 0xfa, 0x35, 0xfa, 0x99, 0x78, 0xcf, 0xda, 0x3d,
-	0xd7, 0xd2, 0xb0, 0x6a, 0x9e, 0x21, 0x6d, 0x5d, 0x51, 0x87, 0x97, 0x2b, 0xb9, 0x6c, 0x18, 0xdd, 0x73, 0xf, 0xd6, 0x37, 0xbd,
-	0x51, 0x27, 0x18, 0xda, 0xb8, 0xc4, 0xcb, 0xd8, 0xfd, 0x51, 0xaf, 0xe4, 0xb9, 0xeb, 0xfd, 0x9b, 0x4f, 0xce, 0xf3, 0x8e, 0xa7,
-	0xed, 0x5c, 0x62, 0x6a, 0xaa, 0x6b, 0xdb, 0x88, 0xe5, 0x86, 0xd6, 0xfa, 0x3b, 0xde, 0x6e, 0xa1, 0xe4, 0x38, 0x81, 0xe8, 0xdf,
-	0xd6, 0xdd, 0x77, 0xd8, 0xfe, 0xa4, 0x7d, 0x35, 0xd7, 0xdd, 0x89, 0xaa, 0xe8, 0xfd, 0xb3, 0xa1, 0xde, 0xdb, 0x77, 0xc, 0x77,
-	0xd8, 0x3d, 0xc3, 0x56, 0xb1, 0xda, 0x74, 0xdd, 0x8e, 0x8c, 0x3f, 0x53, 0xef, 0x97, 0xd8, 0x9c, 0x8c, 0xda, 0xde, 0xe1, 0x88,
-	0xae, 0x1b, 0x88, 0x63, 0xbe, 0xb2, 0x86, 0xf2, 0xd7, 0x8b, 0xbb, 0x3a, 0x27, 0x86, 0x5a, 0x28, 0xaf, 0x9a, 0x23, 0x96, 0x9f,
-	0x6a, 0x43, 0xeb, 0xfd, 0x72, 0xfa, 0xcb, 0xad, 0xfa, 0x93, 0xcf, 0x7d, 0x8f, 0x4e, 0xea, 0x9e, 0xbe, 0xd2, 0x3a, 0xcb, 0x51,
-	0x83, 0xac, 0xfa, 0xda, 0xfe, 0xd, 0x5b, 0xaf, 0x75, 0x3c, 0xe, 0x97, 0xae, 0x43, 0x7d, 0x7d, 0x8b, 0xba, 0x92, 0xfa, 0xf6,
-	0x2c, 0x1e, 0xb9, 0x61, 0x8d, 0xc6, 0x47, 0x77, 0x79, 0x25, 0x3c, 0x55, 0x2c, 0x9c, 0x45, 0xc5, 0x72, 0x73, 0xc7, 0xbd, 0x5c,
-	0xf3, 0xc8, 0x35, 0xa7, 0xc0, 0x5f, 0x4f, 0xee, 0xe3, 0xf5, 0x1, 0xed, 0x59, 0xf4, 0x3e, 0xba, 0xae, 0xdb, 0x58, 0xd3, 0xf5,
-	0x98, 0x6d, 0x32, 0x5d, 0x99, 0xda, 0x59, 0xab, 0x39, 0xef, 0x35, 0xed, 0x17, 0x11, 0x7b, 0x24, 0xd4, 0x59, 0x51, 0xc5, 0x94,
-	0x13, 0x5a, 0xcd, 0x9f, 0xd9, 0xf3, 0x55, 0x5b, 0x4b, 0x46, 0x3b, 0x17, 0x14, 0xd0, 0xd7, 0x73, 0x54, 0x52, 0x57, 0x24, 0xb0,
-	0x5b, 0x45, 0x3d, 0xc4, 0x41, 0x22, 0xce, 0xc0, 0xea, 0xf, 0x43, 0xcf, 0x4a, 0x3b, 0x4c, 0x56, 0xa9, 0xdc, 0xda, 0x87, 0xfe,
-	0x24, 0x7b, 0xd2, 0x28, 0xac, 0xef, 0xf2, 0x9a, 0xee, 0xc5, 0x8c, 0xb0, 0xee, 0x6e, 0xc0, 0xb8, 0x8e, 0x4b, 0x39, 0x66, 0x8a,
-	0xef, 0x33, 0xa2, 0xe5, 0x32, 0x1a, 0xff, 0x0, 0x4c, 0xe8, 0xf8, 0xa9, 0x69, 0xbc, 0xf9, 0xda, 0xda, 0xe4, 0x28, 0xb3, 0xbc,
-	0xbb, 0x86, 0x68, 0xa4, 0xf7, 0xbc, 0xa6, 0x1f, 0xbf, 0x18, 0x60, 0xad, 0x2f, 0xd4, 0xd7, 0xd1, 0x2f, 0xb3, 0xaf, 0xe6, 0xd3,
-	0x3b, 0x67, 0xd3, 0x9f, 0x48, 0xe9, 0xdd, 0x77, 0x31, 0x73, 0x61, 0x4, 0x7b, 0xb6, 0x1b, 0xa1, 0x7a, 0x7f, 0x23, 0x6f, 0x8c,
-	0x8a, 0x2b, 0x9a, 0xae, 0xe6, 0xbc, 0xcc, 0xe4, 0x3a, 0xda, 0xc7, 0xb, 0xd8, 0x98, 0x4b, 0x68, 0x6b, 0xb5, 0x86, 0x9e, 0x78,
-	0xc3, 0xdb, 0xe4, 0xa6, 0xb9, 0xa2, 0x49, 0x22, 0x92, 0x8e, 0x22, 0xf9, 0x71, 0x20, 0x63, 0x8f, 0x52, 0xdf, 0x4b, 0xcf, 0x7,
-	0x35, 0x5f, 0x19, 0x24, 0xf3, 0x77, 0xc3, 0x5e, 0xee, 0xd6, 0x35, 0x8d, 0x6, 0xe3, 0x9c, 0x75, 0x38, 0x9d, 0x16, 0xf7, 0x74,
-	0x9f, 0x75, 0xd1, 0xbb, 0xa, 0xea, 0xfe, 0xea, 0x58, 0xeb, 0xc2, 0x75, 0xb6, 0xc7, 0x7d, 0x79, 0x95, 0xdb, 0x71, 0xdb, 0xd5,
-	0xad, 0x31, 0xcf, 0x54, 0xd8, 0x8b, 0xd9, 0x6f, 0x78, 0xa7, 0x9b, 0x49, 0x63, 0x93, 0xf0, 0x1c, 0xc1, 0x2f, 0x20, 0xc1, 0x3e,
-	0x85, 0x7e, 0x2d, 0x74, 0x8f, 0x97, 0x1b, 0x57, 0x96, 0x9d, 0x59, 0xdd, 0xfa, 0x46, 0x1b, 0x6a, 0xc3, 0xe4, 0x3a, 0x53, 0xb,
-	0x6f, 0x84, 0xcd, 0x4f, 0x8e, 0xc7, 0x49, 0xb5, 0xe8, 0x99, 0x6c, 0x86, 0xcf, 0x55, 0xbd, 0x1b, 0x4e, 0x85, 0x9f, 0xbb, 0xb3,
-	0xba, 0xbb, 0xd6, 0x76, 0x4b, 0x2a, 0xa9, 0xa2, 0xaa, 0x67, 0x83, 0xf4, 0x4d, 0x4d, 0x1f, 0x66, 0xe2, 0x89, 0xad, 0xeb, 0x92,
-	0x1a, 0xc3, 0x9d, 0x3e, 0x77, 0x78, 0x45, 0xda, 0x3e, 0x7, 0xf7, 0x96, 0x5b, 0xa9, 0xbb, 0x2, 0x19, 0x72, 0x9a, 0xfd, 0xf7,
-	0x17, 0x19, 0xae, 0xb2, 0xec, 0x2b, 0x7b, 0x4a, 0xe0, 0xc2, 0x76, 0xe, 0x9d, 0xcd, 0xcd, 0x51, 0x5b, 0x64, 0xed, 0x3f, 0x54,
-	0xb1, 0xd9, 0x66, 0xf1, 0xd5, 0x73, 0x4c, 0x19, 0x4c, 0x7d, 0x55, 0xd5, 0x2d, 0x95, 0xd7, 0xf9, 0xd7, 0x4, 0xb6, 0xf3, 0xcc,
-	0x1a, 0x5a, 0x9, 0x44, 0xfa, 0x3, 0xf8, 0x73, 0xe3, 0xf, 0x93, 0x7d, 0x45, 0xe4, 0x6, 0x6f, 0xbe, 0xfa, 0x5f, 0x4d, 0xed,
-	0xc, 0xb6, 0xaf, 0xd8, 0xfa, 0xc6, 0x2b, 0x5f, 0xbf, 0xd9, 0xad, 0xaf, 0x26, 0xb8, 0xc5, 0xe3, 0xaf, 0x75, 0x89, 0x6e, 0xee,
-	0xad, 0x2d, 0xab, 0xb5, 0xbc, 0xb5, 0xf6, 0x86, 0x6b, 0x9a, 0x38, 0xaf, 0x9e, 0x2a, 0xe2, 0xaf, 0xd5, 0xfd, 0x9e, 0xde, 0xfc,
-	0xfb, 0x84, 0x62, 0x33, 0x10, 0xc7, 0x6f, 0x97, 0xca, 0xc1, 0xd, 0x1c, 0x47, 0xc, 0x19, 0x2b, 0xe8, 0x62, 0x8e, 0x9f, 0x7f,
-	0x6a, 0x23, 0x8e, 0xe6, 0x5a, 0x23, 0xa3, 0x8f, 0x7f, 0x7e, 0x7d, 0xa9, 0xa6, 0x9e, 0x38, 0x7, 0x9a, 0x9, 0x48, 0xfa, 0x14,
-	0x7a, 0x66, 0xf5, 0x9f, 0x79, 0xf4, 0xf7, 0x72, 0x79, 0x5, 0xe4, 0x87, 0x5e, 0x61, 0x77, 0x3d, 0x47, 0xb2, 0xb1, 0x99, 0xde,
-	0x9b, 0xea, 0x5c, 0x5e, 0xc9, 0x88, 0xb0, 0xc8, 0xfe, 0x3, 0x1b, 0x17, 0xce, 0xdb, 0x7e, 0xec, 0xdd, 0x66, 0x4c, 0x84, 0x17,
-	0xb1, 0xe2, 0x76, 0x5b, 0x4c, 0xd5, 0x11, 0x63, 0x30, 0xd9, 0x6b, 0x7a, 0x62, 0xbf, 0xc6, 0x5d, 0x63, 0xef, 0xf9, 0x8a, 0xba,
-	0x7e, 0xe7, 0x1c, 0x82, 0x3d, 0xde, 0x53, 0x78, 0xf1, 0xb9, 0x78, 0xa7, 0xdf, 0xfd, 0x9f, 0xd0, 0x7b, 0xd4, 0x33, 0x7e, 0xd8,
-	0xeb, 0xdd, 0x9a, 0xf7, 0x17, 0x67, 0x93, 0x92, 0xd6, 0x4b, 0x4b, 0x7d, 0x9b, 0x5b, 0x96, 0xaf, 0xc5, 0xea, 0xdb, 0x6e, 0x3a,
-	0x29, 0x3d, 0xf9, 0xe3, 0x1d, 0xb3, 0xe0, 0x27, 0xb7, 0xbd, 0x8b, 0x8f, 0x7e, 0x79, 0x8f, 0x89, 0xbe, 0xdd, 0x5e, 0xd5, 0xd1,
-	0x57, 0x1c, 0x6, 0xbf, 0x82, 0x57, 0x7f, 0x4e, 0xff, 0x0, 0x8e, 0x9e, 0x3e, 0x77, 0x67, 0x4e, 0x79, 0x17, 0x94, 0xee, 0x5e,
-	0x8a, 0xe9, 0xbe, 0xdb, 0xc9, 0xe1, 0x3b, 0x33, 0x54, 0xb0, 0xc2, 0xe4, 0x7b, 0x3b, 0xac, 0x74, 0x9d, 0xf6, 0xfb, 0x11, 0x63,
-	0x71, 0xab, 0x4f, 0x71, 0x71, 0x65, 0x8b, 0xbb, 0xda, 0xb0, 0x79, 0x6b, 0x8c, 0x7d, 0xa4, 0xf7, 0x1c, 0x71, 0x5d, 0x71, 0xc5,
-	0x55, 0x14, 0x55, 0x5f, 0x1f, 0x2e, 0x78, 0xe7, 0x9f, 0xcc, 0x11, 0x57, 0xcd, 0xc7, 0x1c, 0x59, 0x9c, 0xbc, 0x51, 0x51, 0x44,
-	0x51, 0x45, 0x93, 0xbf, 0x8e, 0x38, 0xe3, 0xa7, 0x8a, 0x23, 0x8e, 0x3a, 0x2e, 0xa5, 0xa6, 0x8a, 0x28, 0xa2, 0x9e, 0x38, 0xa6,
-	0x8a, 0x28, 0xa7, 0x8e, 0x38, 0xe3, 0x8e, 0x38, 0xf6, 0xe3, 0x80, 0x79, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xd4, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0x57, 0xe8, 0x6f, 0xdf, 0x97, 0x4c, 0xff, 0x0, 0x15, 0xfa,
-	0xef, 0xf9, 0xbf, 0xe, 0xb, 0xf, 0x7c, 0xc4, 0xf3, 0x8b, 0xaa, 0x7c, 0x4d, 0xed, 0xf, 0x1b, 0x7a, 0xdb, 0xbc, 0xec, 0x31,
-	0x90, 0x75, 0x47, 0x93, 0x95, 0xf6, 0x96, 0x95, 0x9e, 0xdd, 0x33, 0x1f, 0x66, 0x6c, 0x26, 0x9f, 0x96, 0xc1, 0x45, 0xa0, 0xc1,
-	0x84, 0xe7, 0x6d, 0xb2, 0xbb, 0xa2, 0x4b, 0x9, 0x34, 0x5d, 0x82, 0x3d, 0xbe, 0xea, 0xd3, 0x29, 0x3c, 0xdc, 0x73, 0x1d, 0x9f,
-	0x15, 0x45, 0x34, 0xbe, 0xd6, 0xb4, 0xdc, 0x55, 0x48, 0x45, 0xf, 0xd6, 0x3b, 0xd2, 0xb2, 0xef, 0xc3, 0xfd, 0xba, 0x6e, 0xfe,
-	0xe8, 0xec, 0x54, 0xf9, 0x2f, 0x17, 0x7b, 0xb, 0x33, 0xf2, 0x92, 0xca, 0xc2, 0x9a, 0xee, 0xff, 0x0, 0xe0, 0xbe, 0xd1, 0x99,
-	0x9a, 0xb9, 0xad, 0xb5, 0x8b, 0xe9, 0x69, 0xaa, 0x5a, 0xeb, 0xd1, 0x33, 0x32, 0x57, 0xed, 0x83, 0xc8, 0x57, 0xcf, 0x34, 0xc3,
-	0x5f, 0x3c, 0x58, 0x5c, 0x55, 0xc4, 0xdf, 0x84, 0x96, 0xf4, 0x34, 0xc3, 0xd2, 0x8b, 0xfc, 0x46, 0x3c, 0x46, 0xfe, 0x2d, 0xe3,
-	0x3f, 0xe9, 0xd9, 0x30, 0x74, 0xff, 0x0, 0xea, 0x34, 0xd7, 0x72, 0x9b, 0x7f, 0x9e, 0x1e, 0x3b, 0x6a, 0x78, 0x48, 0xa8, 0xb8,
-	0xcd, 0x6d, 0x1e, 0x3f, 0xe9, 0x3a, 0xee, 0x22, 0x9, 0x24, 0xa6, 0x18, 0xe6, 0xca, 0x66, 0xbb, 0x93, 0xb4, 0x71, 0xb8, 0xf8,
-	0xab, 0x96, 0xaf, 0xd3, 0x15, 0x12, 0x5d, 0xdc, 0xd1, 0xc7, 0x35, 0x73, 0xf9, 0x53, 0xc7, 0x3e, 0xe0, 0xea, 0xf7, 0xa8, 0x47,
-	0x67, 0xd9, 0xfa, 0x4a, 0xfa, 0x63, 0xf5, 0xff, 0x0, 0x49, 0x78, 0xf7, 0x3c, 0x78, 0x1d, 0xeb, 0x3d, 0x6, 0x2f, 0xa5, 0xb4,
-	0xcd, 0xa2, 0xce, 0xde, 0x2b, 0x7c, 0x95, 0xae, 0x46, 0xfb, 0x15, 0x7f, 0x9e, 0xed, 0x4e, 0xd8, 0xae, 0x88, 0xfe, 0xd7, 0x1c,
-	0x6c, 0xb9, 0x4a, 0xa1, 0xbb, 0x96, 0x39, 0xe9, 0xe7, 0xe5, 0x6b, 0x95, 0xcb, 0x43, 0x35, 0x34, 0xf3, 0x44, 0x3f, 0x0, 0x41,
-	0x76, 0x69, 0xa6, 0xb9, 0x9a, 0x5b, 0x8b, 0x89, 0x64, 0x9e, 0xe2, 0x79, 0x2b, 0x9a, 0x79, 0xe6, 0xae, 0xb9, 0x66, 0x9a, 0x69,
-	0x6b, 0xe6, 0xb9, 0x65, 0x96, 0x5a, 0xf9, 0xaa, 0xb9, 0x24, 0x92, 0xba, 0xb9, 0xe6, 0xaa, 0xb9, 0xe7, 0x9e, 0x79, 0xe7, 0x9f,
-	0x7e, 0x41, 0xfc, 0xc1, 0xdf, 0xbf, 0x40, 0x9f, 0x36, 0x76, 0xbe, 0x97, 0xf2, 0x73, 0x13, 0xe3, 0xe, 0xc5, 0x99, 0xbc, 0xbc,
-	0xe9, 0xdf, 0x21, 0x6e, 0xae, 0xb1, 0xd8, 0xec, 0x3d, 0xd4, 0xf2, 0x4d, 0x65, 0xa9, 0x76, 0xbd, 0xae, 0x36, 0x7b, 0xbd, 0x73,
-	0x3f, 0x88, 0x8a, 0x49, 0x79, 0xa2, 0xc3, 0x8d, 0xae, 0x3b, 0x1e, 0x71, 0x17, 0xf1, 0xc3, 0x47, 0x1f, 0x8b, 0x96, 0x6b, 0x29,
-	0x24, 0xe7, 0xda, 0xd6, 0x90, 0x7c, 0x6f, 0xaf, 0xbf, 0x8b, 0x9a, 0xf7, 0x40, 0x79, 0x9f, 0x47, 0x60, 0x69, 0x58, 0xeb, 0x6c,
-	0x4e, 0xa9, 0xe4, 0x7e, 0xb3, 0x37, 0x65, 0xdd, 0xe3, 0x2d, 0x22, 0xae, 0x1b, 0x5b, 0x2e, 0xc5, 0xb5, 0xcb, 0x5c, 0xe2, 0xfb,
-	0xe, 0xab, 0x68, 0xfe, 0x1c, 0xc5, 0xf6, 0xf3, 0x97, 0x75, 0x5a, 0x66, 0x26, 0xe7, 0x8a, 0xf9, 0xe7, 0x9b, 0xdc, 0x9c, 0xfc,
-	0x7c, 0x28, 0xa3, 0x88, 0xf8, 0xa8, 0x38, 0x6c, 0x9, 0x2c, 0x7d, 0x34, 0x7d, 0x9b, 0xa8, 0x6b, 0x9e, 0x41, 0xf7, 0xf7, 0x58,
-	0x66, 0xb2, 0x56, 0x76, 0x1b, 0x5f, 0x66, 0xf5, 0xbe, 0xb5, 0x95, 0xd2, 0xed, 0xee, 0xe6, 0xa2, 0x9, 0x33, 0x55, 0x75, 0xf6,
-	0x5f, 0x31, 0x75, 0xb0, 0xe2, 0x71, 0xbc, 0x49, 0x4f, 0x1f, 0x8b, 0xc9, 0x51, 0x8b, 0xd8, 0xf8, 0xbe, 0xfb, 0x14, 0x55, 0xf7,
-	0x39, 0xb4, 0xb2, 0x9e, 0x5e, 0x29, 0xaa, 0x88, 0x64, 0xaa, 0x80, 0xd3, 0x5f, 0x58, 0x8f, 0x7, 0x7c, 0x87, 0xe8, 0xcf, 0x2b,
-	0xbb, 0xcb, 0xbb, 0x36, 0x2d, 0x4f, 0x66, 0xda, 0x7a, 0x67, 0xb8, 0xbb, 0x2f, 0x69, 0xec, 0x6d, 0x5f, 0xb5, 0xf1, 0x76, 0x17,
-	0xb9, 0x8d, 0x67, 0x19, 0x1e, 0xe9, 0x97, 0xb9, 0xce, 0x53, 0xa5, 0x6c, 0xf9, 0x3b, 0x68, 0xa6, 0x8b, 0x54, 0xcb, 0xeb, 0x72,
-	0xde, 0x57, 0x61, 0x69, 0x6f, 0x7d, 0xcc, 0x1c, 0x5e, 0x5a, 0x5a, 0x53, 0x25, 0xaf, 0x32, 0x51, 0x4d, 0x7f, 0x6c, 0x38, 0xe2,
-	0xe, 0xbd, 0x7a, 0x12, 0xff, 0x0, 0x89, 0xef, 0x8f, 0xbf, 0xe9, 0x3d, 0xcb, 0xff, 0x0, 0x64, 0xfb, 0x4, 0x19, 0x7, 0xea,
-	0xd, 0xff, 0x0, 0x11, 0xad, 0xa3, 0xf8, 0x51, 0xd5, 0x9f, 0xf4, 0x8b, 0xc0, 0x77, 0x77, 0x44, 0xbf, 0xc6, 0x7a, 0x47, 0xfa,
-	0x2e, 0xe3, 0xbb, 0x13, 0x5d, 0xc2, 0xd9, 0xc3, 0xdc, 0x7b, 0x2e, 0x83, 0xae, 0x6e, 0x57, 0x12, 0x5d, 0x58, 0x5b, 0xcd, 0x71,
-	0x91, 0xef, 0x7e, 0xf1, 0x87, 0x17, 0x4e, 0x1e, 0x4d, 0x82, 0x2e, 0x7d, 0xad, 0xf2, 0x36, 0x9d, 0x69, 0x8f, 0xc9, 0x5b, 0xc3,
-	0x24, 0x55, 0x57, 0xc5, 0x17, 0x16, 0x18, 0x1e, 0x63, 0xa7, 0x9e, 0x6b, 0x97, 0xde, 0xa0, 0x84, 0x2e, 0xd1, 0xb4, 0x6c, 0x9b,
-	0xbe, 0xc9, 0x9d, 0xdc, 0x37, 0xc, 0xee, 0x57, 0x67, 0xda, 0xb6, 0x7c, 0xad, 0xf6, 0x73, 0x61, 0xd8, 0x73, 0x97, 0xd7, 0x19,
-	0x2c, 0xc6, 0x6b, 0x31, 0x92, 0xb8, 0x92, 0xea, 0xff, 0x0, 0x25, 0x92, 0xbf, 0xba, 0x92, 0x5b, 0x8b, 0xbb, 0xcb, 0xbb, 0x89,
-	0x6a, 0xae, 0xba, 0xeb, 0xab, 0x9a, 0xaa, 0xab, 0x90, 0x78, 0x20, 0xf4, 0x79, 0xcc, 0x65, 0xaa, 0xc4, 0xc7, 0x80, 0xab, 0x29,
-	0x91, 0xab, 0x5, 0x16, 0x46, 0x6c, 0xc4, 0x58, 0x5e, 0x6f, 0x6e, 0x79, 0xc4, 0xc7, 0x96, 0xb8, 0xb6, 0x82, 0xca, 0x7c, 0xa4,
-	0x78, 0xee, 0x65, 0xfc, 0x1d, 0x19, 0x19, 0xec, 0xed, 0xa3, 0x8a, 0xb9, 0xf8, 0xa3, 0x89, 0x6a, 0x8a, 0x3a, 0x69, 0xe6, 0xae,
-	0x69, 0xa7, 0x8e, 0x38, 0x9, 0x2e, 0x7d, 0x32, 0x7f, 0xbf, 0x7f, 0x26, 0xff, 0x0, 0x84, 0x9a, 0x9f, 0xf3, 0x8d, 0x40, 0xeb,
-	0x6e, 0xed, 0xb1, 0xf8, 0xbf, 0xea, 0xf5, 0x8f, 0xf2, 0xb7, 0xc1, 0xae, 0xcd, 0x82, 0xcb, 0x47, 0xef, 0xbf, 0x1b, 0xbb, 0x6b,
-	0xb2, 0xf0, 0x1a, 0x96, 0x46, 0x3a, 0x60, 0xbc, 0xd8, 0xf0, 0xf6, 0x7a, 0x96, 0xdf, 0x93, 0xd6, 0x75, 0x5e, 0xe0, 0xd1, 0x3f,
-	0x15, 0x25, 0xbc, 0xd9, 0x7c, 0x3d, 0xd5, 0xbd, 0xbd, 0xbd, 0x86, 0xd1, 0x8b, 0xe2, 0x4a, 0x69, 0xe2, 0x49, 0x7e, 0x15, 0xf3,
-	0xd, 0x37, 0x16, 0x17, 0x14, 0x84, 0x28, 0x7c, 0x99, 0xf1, 0xaf, 0xb5, 0x7c, 0x4a, 0xee, 0x5d, 0xbb, 0xa3, 0xbb, 0x8b, 0x7,
-	0x56, 0x1b, 0x6d, 0xd5, 0x6e, 0xb8, 0xe6, 0xb, 0xbb, 0x7f, 0xbb, 0x36, 0xb, 0x69, 0xc0, 0x5d, 0x55, 0x25, 0x58, 0x5d, 0xbf,
-	0x55, 0xc8, 0xc9, 0x14, 0x3c, 0x65, 0x35, 0xcc, 0xed, 0xb4, 0x7c, 0xd7, 0x4, 0xbf, 0x1a, 0x24, 0x8a, 0x4a, 0x64, 0xb7, 0x9e,
-	0x88, 0x6e, 0x61, 0x9a, 0x18, 0xc2, 0x54, 0x7f, 0x4c, 0x97, 0xee, 0x37, 0xc9, 0xef, 0xe2, 0xbe, 0x9d, 0xfc, 0xa1, 0x70, 0x8,
-	0x7b, 0x67, 0xff, 0x0, 0xbf, 0x73, 0x5f, 0xea, 0xd9, 0x1f, 0xf7, 0x93, 0x3, 0x28, 0xf8, 0xed, 0xd1, 0x9b, 0x97, 0x92, 0xdd,
-	0xdf, 0xd6, 0x5d, 0x13, 0xa0, 0xc1, 0xcc, 0xbb, 0x47, 0x65, 0xed, 0x78, 0xdd, 0x72, 0xd2, 0xe3, 0x98, 0x6a, 0xb8, 0xb7, 0xc3,
-	0xd8, 0xcf, 0x5f, 0x33, 0xe7, 0x36, 0x4c, 0x84, 0x54, 0x57, 0x1d, 0x75, 0x62, 0xb5, 0x8c, 0x1d, 0xbd, 0xce, 0x42, 0xef, 0xe3,
-	0x57, 0x15, 0x7e, 0x1a, 0xda, 0xbf, 0x8f, 0xbd, 0x5e, 0xdc, 0x72, 0x12, 0xe5, 0xf5, 0x32, 0xf3, 0xa6, 0xc7, 0xd2, 0xdb, 0x59,
-	0xf0, 0xcb, 0xc4, 0xdf, 0x18, 0x78, 0x86, 0xde, 0xeb, 0xaf, 0x26, 0xd1, 0xb7, 0x2d, 0xdf, 0x9, 0xc4, 0xf1, 0xf1, 0x3d, 0xff,
-	0x0, 0x4c, 0x68, 0xd7, 0x3f, 0xb2, 0xe0, 0xd3, 0xf3, 0xf7, 0x54, 0x53, 0x54, 0x94, 0xdf, 0xf7, 0x16, 0x56, 0xda, 0xfe, 0x6c,
-	0x85, 0xdf, 0x14, 0xf1, 0x71, 0xff, 0x0, 0xa4, 0x92, 0x5e, 0x7f, 0x3b, 0x9e, 0x2a, 0xe4, 0x30, 0xe7, 0xaf, 0x17, 0x8f, 0x9a,
-	0x8f, 0x92, 0xfe, 0x35, 0xf4, 0xaf, 0xa8, 0xff, 0x0, 0x47, 0x51, 0x46, 0x77, 0x1f, 0x8c, 0xd5, 0x75, 0x8b, 0x4d, 0xc7, 0x23,
-	0x65, 0x6f, 0x4f, 0x17, 0x39, 0x7e, 0xa0, 0xdf, 0x2b, 0x8b, 0x23, 0xa5, 0x67, 0xf2, 0x50, 0xc3, 0xf7, 0x6b, 0x82, 0xfb, 0x49,
-	0xda, 0x33, 0x35, 0x59, 0x5d, 0xc5, 0x57, 0x3c, 0xcb, 0x7, 0x19, 0x6a, 0xe9, 0x97, 0x9a, 0x78, 0xb4, 0xe7, 0x8a, 0x42, 0x22,
-	0xc0, 0x98, 0xff, 0x0, 0xd3, 0x25, 0xfb, 0x8d, 0xf2, 0x7b, 0xf8, 0xaf, 0xa7, 0x7f, 0x28, 0x5c, 0x2, 0x1e, 0xd9, 0xff, 0x0,
-	0xef, 0xdc, 0xd7, 0xfa, 0xb6, 0x47, 0xfd, 0xe4, 0xc0, 0xf2, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xd5, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0x57, 0xe8, 0x6f, 0xdf, 0x97, 0x4c, 0xff, 0x0, 0x15, 0xfa, 0xef, 0xf9,
-	0xbf, 0xe, 0x9, 0x43, 0xfd, 0x4f, 0xff, 0x0, 0xdc, 0x5e, 0x17, 0x7f, 0xab, 0x77, 0xf7, 0xfb, 0x3e, 0x9d, 0x6, 0x35, 0xf4,
-	0x75, 0xf5, 0x2c, 0xd3, 0xfb, 0x1b, 0x50, 0x87, 0xd3, 0x8f, 0xcd, 0x6a, 0xf1, 0x7b, 0x76, 0x89, 0xba, 0x62, 0x64, 0xd0, 0xfa,
-	0x83, 0x66, 0xde, 0x64, 0xa6, 0xf3, 0x17, 0x90, 0xc5, 0x5f, 0xdb, 0xd1, 0x63, 0x6b, 0xd2, 0x7b, 0x75, 0xcd, 0xe5, 0x5c, 0x7c,
-	0x6d, 0xa4, 0xa3, 0x8e, 0x28, 0xd6, 0x6f, 0x2b, 0x92, 0x99, 0x20, 0x9b, 0x8a, 0x2c, 0x28, 0xae, 0x9e, 0x78, 0xb0, 0xa6, 0x80,
-	0xf8, 0x7c, 0x7f, 0xa6, 0xa6, 0xe3, 0xe0, 0x17, 0xab, 0x8f, 0x89, 0x17, 0x78, 0x58, 0xf2, 0x5b, 0x27, 0x8e, 0x9d, 0x85, 0xde,
-	0x11, 0x4b, 0xd5, 0x1b, 0xc4, 0xd4, 0x57, 0x71, 0x3e, 0x2a, 0x4e, 0x71, 0x99, 0x7b, 0xd9, 0x3a, 0xe7, 0x72, 0xb9, 0xa2, 0x2a,
-	0x61, 0x83, 0x6d, 0xc1, 0xda, 0xd3, 0x5f, 0xd8, 0x9b, 0xf4, 0xc7, 0x98, 0xb1, 0x8b, 0xf1, 0x51, 0x53, 0x4c, 0x94, 0x5d, 0x5b,
-	0xda, 0x87, 0xd9, 0x7a, 0xe9, 0x6c, 0xb8, 0x9d, 0x2f, 0xd5, 0x33, 0xc2, 0x3d, 0xc7, 0x3d, 0x2c, 0x30, 0x60, 0xf5, 0x3d, 0x17,
-	0xa4, 0xb6, 0x5c, 0xcc, 0xf7, 0x32, 0xc7, 0x5, 0xbc, 0x38, 0x9c, 0x17, 0x91, 0x5b, 0xee, 0x53, 0x23, 0x2c, 0xf3, 0x4d, 0xfd,
-	0x4c, 0x30, 0xc7, 0x67, 0x6b, 0x5f, 0x35, 0x55, 0x5f, 0xe9, 0xa6, 0x9e, 0x39, 0xe7, 0x9f, 0xc8, 0x1b, 0xf, 0xf5, 0x36, 0x68,
-	0xf9, 0xcc, 0xb7, 0x4d, 0xf8, 0xb7, 0xd9, 0x56, 0x34, 0x49, 0x36, 0xb5, 0xa8, 0x76, 0x26, 0xff, 0x0, 0xa9, 0xe6, 0x64, 0x86,
-	0x3a, 0xe5, 0x86, 0x2c, 0x87, 0x60, 0x6b, 0x9a, 0xfe, 0x57, 0x1, 0x71, 0x34, 0xb4, 0x55, 0xcc, 0x71, 0x45, 0x54, 0x3d, 0x7f,
-	0x7b, 0x45, 0x35, 0x55, 0xc7, 0xb5, 0x55, 0x49, 0xc7, 0x1c, 0x55, 0xc7, 0x3c, 0xfb, 0x54, 0x10, 0xea, 0x0, 0x1b, 0xdd, 0xe9,
-	0x87, 0xa2, 0xe7, 0xfb, 0xf, 0xd4, 0x1b, 0xc4, 0x1c, 0x1e, 0xb9, 0x1c, 0xf2, 0x5e, 0xe2, 0xfb, 0xdb, 0x41, 0xde, 0xaf, 0x79,
-	0x82, 0x89, 0xab, 0xe6, 0x2c, 0x7, 0x5a, 0x66, 0xad, 0xfb, 0xb, 0x66, 0x92, 0x5e, 0x60, 0xa6, 0xaa, 0xa8, 0x83, 0xfa, 0x3f,
-	0xac, 0x5c, 0xf1, 0x5d, 0x55, 0x7b, 0x51, 0xed, 0x57, 0xea, 0xe7, 0x8e, 0x39, 0xe4, 0x1d, 0x98, 0xfa, 0x9c, 0xf6, 0x9c, 0x35,
-	0xdf, 0x6b, 0x78, 0xa1, 0xa4, 0xc1, 0x24, 0x1c, 0xec, 0x1a, 0xff, 0x0, 0x5e, 0xf6, 0x56, 0xd3, 0x93, 0x86, 0x9f, 0x87, 0xe2,
-	0x68, 0xc3, 0x6e, 0x3b, 0x26, 0xb5, 0x89, 0xc1, 0x49, 0x2f, 0xb7, 0x3f, 0x73, 0xec, 0x4b, 0x7b, 0xa3, 0x64, 0x78, 0x8f, 0xdf,
-	0x8e, 0x29, 0xf9, 0x51, 0x5f, 0xb7, 0xbf, 0x3e, 0xfe, 0xc1, 0x17, 0x90, 0x7d, 0x36, 0x9b, 0xb9, 0xed, 0xbd, 0x77, 0xb5, 0x60,
-	0x37, 0x9d, 0x13, 0x64, 0xcc, 0xea, 0x1b, 0x8e, 0xad, 0x93, 0xb6, 0xcc, 0xeb, 0x9b, 0x36, 0xbd, 0x90, 0xb9, 0xc5, 0x66, 0xb0,
-	0xb9, 0x4b, 0x3a, 0xfe, 0xe5, 0xbd, 0xf6, 0x3f, 0x21, 0x67, 0x24, 0x57, 0x16, 0xd3, 0xc7, 0x57, 0xe5, 0xef, 0x4d, 0x5f, 0xaa,
-	0x9e, 0x79, 0xa7, 0x9f, 0x7e, 0x39, 0xe7, 0x8e, 0x42, 0x45, 0x7e, 0x34, 0x7d, 0x47, 0xdd, 0xdf, 0xa7, 0xd9, 0xe3, 0xf5, 0x4f,
-	0x2a, 0x3a, 0xa7, 0x59, 0xef, 0xc, 0x4, 0x76, 0x3f, 0xb3, 0x6f, 0x77, 0x5d, 0x42, 0xbb, 0x7d, 0xf, 0xb0, 0x2e, 0x69, 0xaa,
-	0x9a, 0x29, 0x92, 0xff, 0x0, 0x3b, 0x87, 0xaa, 0xda, 0xfb, 0x43, 0xd9, 0xa4, 0x96, 0x1e, 0x2b, 0x8a, 0xbb, 0x7b, 0x6b, 0x5c,
-	0xd, 0x15, 0xfc, 0xf8, 0xaf, 0x99, 0x39, 0xe6, 0x9e, 0x69, 0x90, 0x3a, 0x21, 0xb8, 0xf8, 0x41, 0xe9, 0xb5, 0xea, 0xfd, 0xd0,
-	0x9b, 0x17, 0x75, 0x78, 0x85, 0x8e, 0xd7, 0xba, 0x77, 0xb8, 0x21, 0xae, 0xfa, 0x9a, 0xb2, 0xfa, 0xce, 0xbb, 0x69, 0xa3, 0x5d,
-	0xe1, 0xb7, 0xd9, 0xed, 0xe8, 0xc9, 0x73, 0xad, 0xf7, 0x77, 0x59, 0xe1, 0xb9, 0xaf, 0x9, 0x77, 0x1e, 0x6e, 0x4e, 0x79, 0xaa,
-	0x4c, 0xb5, 0x8d, 0x32, 0x4f, 0x2d, 0x72, 0x57, 0x73, 0x6f, 0x7b, 0x77, 0x4d, 0x12, 0xc3, 0x28, 0x70, 0xfb, 0xd1, 0x67, 0x50,
-	0xd8, 0x7a, 0xf7, 0xd5, 0xbb, 0xaa, 0x74, 0x1d, 0xbb, 0x1d, 0x26, 0x23, 0x6b, 0xd1, 0xef, 0xfc, 0x82, 0xd4, 0x36, 0x7c, 0x4c,
-	0xd5, 0x51, 0x5c, 0xd8, 0xbd, 0x87, 0x5a, 0xea, 0x8e, 0xcb, 0xc2, 0xe6, 0xb1, 0xd2, 0xd7, 0x1d, 0x55, 0xc7, 0x54, 0x96, 0x59,
-	0x2b, 0x29, 0x62, 0xab, 0x9a, 0x79, 0xe6, 0x9e, 0x79, 0xa7, 0xf2, 0xe7, 0x9e, 0x1, 0xed, 0xfd, 0x41, 0xbf, 0xe2, 0x35, 0xb4,
-	0x7f, 0xa, 0x3a, 0xb3, 0xfe, 0x91, 0x78, 0xe, 0xdb, 0xfa, 0xd6, 0x63, 0x2e, 0x3b, 0x67, 0xd2, 0x2b, 0xaa, 0xbb, 0x13, 0x47,
-	0x8f, 0x8b, 0x9d, 0x5b, 0x5, 0x9a, 0xf1, 0xdf, 0xb5, 0xaf, 0x2b, 0xb1, 0xf6, 0x9e, 0xda, 0x8d, 0x2f, 0x62, 0xd2, 0x72, 0x5a,
-	0xbe, 0x2e, 0xe6, 0x3a, 0xed, 0x7d, 0xa1, 0xaa, 0xce, 0x9c, 0x96, 0xff, 0x0, 0x8e, 0xe7, 0x8a, 0xf8, 0xe3, 0xed, 0xfc, 0x79,
-	0xe3, 0x9e, 0x3d, 0xb8, 0xf6, 0xe7, 0x80, 0x84, 0x68, 0x24, 0x81, 0xa0, 0xfd, 0x47, 0xfd, 0xdf, 0xa0, 0xe8, 0x9a, 0x56, 0x89,
-	0x67, 0xe3, 0x7f, 0x55, 0x64, 0x2d, 0x34, 0xad, 0x4b, 0x5c, 0xd4, 0xad, 0x6f, 0xee, 0x76, 0x9d, 0xba, 0x2b, 0x9b, 0xdb, 0x6d,
-	0x73, 0xf, 0x67, 0x87, 0x82, 0xee, 0xe2, 0x38, 0xa9, 0xfb, 0x51, 0xcd, 0x73, 0x15, 0x9f, 0x15, 0xd7, 0x4d, 0x3f, 0xa7, 0x8a,
-	0xaa, 0xe7, 0x8e, 0x3f, 0x20, 0x77, 0xbb, 0xc6, 0x5f, 0x30, 0xf6, 0x5f, 0x39, 0xbd, 0x36, 0xbb, 0x9b, 0xbe, 0xb6, 0xcd, 0x3b,
-	0x7, 0xa2, 0xe6, 0x2f, 0xf4, 0xbe, 0xff, 0x0, 0xd5, 0xeb, 0xc0, 0xeb, 0xb7, 0xd7, 0xf9, 0x1c, 0x6d, 0x10, 0x6b, 0x7a, 0x8e,
-	0x4e, 0x8, 0x2e, 0xa8, 0xb9, 0xc9, 0x71, 0xc5, 0xd7, 0x32, 0xdc, 0xd3, 0x3f, 0x3c, 0xd7, 0x4f, 0x3f, 0xa7, 0x8e, 0x78, 0xfc,
-	0x81, 0xc3, 0xef, 0xa6, 0x4f, 0xf7, 0xef, 0xe4, 0xdf, 0xf0, 0x93, 0x53, 0xfe, 0x71, 0xa8, 0x1c, 0xa7, 0xf2, 0xb3, 0xb8, 0xbb,
-	0x1b, 0xa0, 0x3d, 0x50, 0x7c, 0x9c, 0xed, 0xfe, 0xa6, 0xd9, 0xaf, 0xb5, 0xd, 0xff, 0x0, 0x47, 0xf2, 0xc7, 0xba, 0x72, 0xd8,
-	0x1c, 0xd5, 0x85, 0x7f, 0x9d, 0x12, 0x71, 0xd8, 0x3b, 0x1c, 0x17, 0x76, 0x17, 0xd6, 0xf5, 0x7b, 0xc1, 0x91, 0xc3, 0xe5, 0xac,
-	0x66, 0x96, 0xd6, 0xf6, 0xd2, 0x6a, 0x6b, 0x82, 0xee, 0xd6, 0x69, 0x22, 0x92, 0x9a, 0xa8, 0xaf, 0x9e, 0x39, 0x9, 0x24, 0x66,
-	0xf1, 0xbe, 0x3f, 0xfd, 0x40, 0x3e, 0x16, 0xf1, 0x9c, 0xc1, 0x51, 0xaf, 0x75, 0xaf, 0x98, 0x7d, 0x3d, 0x67, 0xf6, 0x68, 0x86,
-	0x79, 0x2a, 0x92, 0xe7, 0x47, 0xdc, 0x2e, 0x20, 0xaa, 0x7a, 0xb0, 0x79, 0x39, 0x78, 0xa2, 0x5c, 0xc6, 0x5b, 0xa5, 0x3b, 0x32,
-	0xab, 0x4a, 0xea, 0xb4, 0xb9, 0xe2, 0x99, 0xa4, 0xc7, 0xdc, 0xd1, 0xcd, 0x7c, 0x71, 0x2d, 0xcd, 0x95, 0xcd, 0xbc, 0xe1, 0xfe,
-	0x7d, 0x3c, 0x5d, 0x61, 0xbe, 0x74, 0xbe, 0x9f, 0xe6, 0x67, 0x55, 0xf6, 0x76, 0xb5, 0x91, 0xd4, 0x37, 0xdd, 0x1b, 0xbc, 0x35,
-	0x7c, 0xe, 0xcd, 0xaf, 0x65, 0x22, 0xfb, 0x77, 0x56, 0x17, 0xf6, 0xda, 0x84, 0xb5, 0xd3, 0x55, 0x15, 0xd3, 0xcd, 0x50, 0xdd,
-	0xd8, 0xde, 0xdb, 0x49, 0x1d, 0xc5, 0xad, 0xcc, 0x35, 0x57, 0x6f, 0x77, 0x6b, 0x2c, 0x73, 0x43, 0x5d, 0x71, 0x49, 0x45, 0x75,
-	0x4, 0x2e, 0x73, 0xff, 0x0, 0xdf, 0xb9, 0xaf, 0xf5, 0x6c, 0x8f, 0xfb, 0xc9, 0x81, 0x2a, 0xdf, 0x40, 0x5f, 0x1c, 0x75, 0x4e,
-	0x94, 0xe9, 0xee, 0xeb, 0xf5, 0x22, 0xee, 0xee, 0x6d, 0xf0, 0x1a, 0xe6, 0x3f, 0x5a, 0xda, 0xb5, 0xde, 0xbf, 0xcc, 0x65, 0x21,
-	0xe7, 0xed, 0xe2, 0x3a, 0xfb, 0x4e, 0xa2, 0xbc, 0x9f, 0x6a, 0x6f, 0x36, 0x74, 0x55, 0x4d, 0x7f, 0x7e, 0xbc, 0xa6, 0x53, 0x13,
-	0x46, 0x1e, 0xce, 0xa8, 0x7e, 0x37, 0x3c, 0x55, 0x8e, 0xbe, 0x83, 0x8e, 0x2a, 0xa6, 0xe7, 0x8e, 0x2a, 0xf, 0xe9, 0xde, 0x1e,
-	0x5e, 0x7d, 0x3e, 0xbe, 0x48, 0xf6, 0x66, 0xc3, 0xdc, 0x3d, 0xd9, 0xd6, 0x5d, 0xcf, 0xbd, 0xf6, 0x36, 0xd3, 0xc6, 0x3a, 0x9c,
-	0xde, 0xc5, 0x77, 0x77, 0xe4, 0x16, 0x27, 0xf1, 0x11, 0x62, 0x31, 0x96, 0x98, 0x7c, 0x6d, 0xb5, 0xae, 0x23, 0x5e, 0xed, 0xbc,
-	0x46, 0xb, 0x15, 0x67, 0x67, 0x8e, 0xb1, 0x8a, 0x3a, 0x21, 0xb4, 0xb5, 0x82, 0x2e, 0x3e, 0x3c, 0xd5, 0xf1, 0xf9, 0xd5, 0x55,
-	0x55, 0x7, 0x4a, 0x3c, 0x1c, 0xf2, 0x83, 0xd3, 0x33, 0xc9, 0xde, 0xb9, 0xd9, 0xbc, 0x1, 0xf1, 0xa6, 0xcf, 0x6d, 0xb4, 0xeb,
-	0xd8, 0xba, 0xc7, 0x76, 0xa6, 0x4e, 0xb1, 0xec, 0x28, 0xf7, 0x69, 0xa9, 0xbb, 0xd1, 0x76, 0x5c, 0x8c, 0x96, 0x9b, 0x7d, 0x96,
-	0xbb, 0xb0, 0x76, 0x6, 0xc7, 0xb5, 0x66, 0x2e, 0xe4, 0xb5, 0xbd, 0xda, 0xf9, 0x9e, 0x8b, 0x5e, 0x2e, 0xf9, 0xae, 0xd2, 0x89,
-	0x39, 0x96, 0xde, 0x8a, 0x63, 0x86, 0xae, 0x63, 0x8, 0x4f, 0xf9, 0x71, 0xe3, 0x7e, 0xd9, 0xe2, 0x57, 0x91, 0x3d, 0xa5, 0xd0,
-	0x5b, 0x85, 0x17, 0x12, 0x5e, 0x68, 0x5b, 0x2d, 0xd5, 0xa6, 0x1b, 0x2f, 0x34, 0x15, 0x41, 0x1e, 0xcf, 0xa8, 0xde, 0xfb, 0x64,
-	0x35, 0x1d, 0xaa, 0xd7, 0x8e, 0x69, 0xa6, 0x3e, 0x60, 0xcf, 0xeb, 0xd7, 0x36, 0xf7, 0x15, 0x53, 0x47, 0x35, 0x71, 0xc, 0xd5,
-	0x57, 0x17, 0x3c, 0xfc, 0xe3, 0xab, 0x8e, 0x2, 0x52, 0x1f, 0x4c, 0x97, 0xee, 0x37, 0xc9, 0xef, 0xe2, 0xbe, 0x9d, 0xfc, 0xa1,
-	0x70, 0x8, 0x7b, 0x67, 0xff, 0x0, 0xbf, 0x73, 0x5f, 0xea, 0xd9, 0x1f, 0xf7, 0x93, 0x3, 0xc9, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd6, 0xaf, 0xfc, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0x57, 0xe8, 0x6f, 0xdf, 0x97, 0x4c,
-	0xff, 0x0, 0x15, 0xfa, 0xef, 0xf9, 0xbf, 0xe, 0x9, 0x43, 0xfd, 0x4f, 0xff, 0x0, 0xdc, 0x5e, 0x17, 0x7f, 0xab, 0x77, 0xf7,
-	0xfb, 0x3e, 0x9d, 0x4, 0x49, 0x23, 0x92, 0x48, 0xa4, 0xa2, 0x58, 0xab, 0xae, 0x29, 0x62, 0xae, 0x99, 0x23, 0x92, 0x3a, 0xb9,
-	0xa2, 0x48, 0xe4, 0xa3, 0x9e, 0x2a, 0xa2, 0xba, 0x2b, 0xa7, 0x9e, 0x2a, 0xa2, 0xba, 0x2a, 0xe3, 0x8e, 0x78, 0xe7, 0x8e, 0x7d,
-	0xf8, 0xe4, 0x13, 0x4d, 0xf4, 0x6b, 0xf5, 0x44, 0xc0, 0x79, 0x59, 0xaf, 0xea, 0xfe, 0x28, 0x79, 0x49, 0x79, 0x8d, 0xcc, 0x77,
-	0xe6, 0x85, 0x5d, 0x9e, 0x67, 0xaa, 0x37, 0x3d, 0xa2, 0x3b, 0x4b, 0x89, 0x7b, 0x52, 0xcb, 0x51, 0xa7, 0x9c, 0x8e, 0x36, 0x5e,
-	0x6e, 0x6e, 0xb8, 0xe7, 0x9e, 0x3b, 0x6b, 0x4a, 0xb3, 0xb7, 0xaa, 0x4e, 0x67, 0xa3, 0xe3, 0x73, 0x93, 0xc7, 0xc3, 0x55, 0xcf,
-	0x3c, 0xd7, 0x3c, 0x77, 0x92, 0x48, 0x1c, 0xdb, 0xfa, 0x96, 0xbf, 0xe7, 0x33, 0xa5, 0xff, 0x0, 0xfa, 0xc7, 0xaf, 0xff, 0x0,
-	0xdd, 0x5e, 0xd8, 0x7, 0x49, 0xfd, 0x3d, 0xbc, 0x99, 0xe8, 0xbf, 0x55, 0x8f, 0x8, 0x72, 0x5e, 0x8, 0x79, 0x29, 0x99, 0x8f,
-	0x8e, 0xea, 0xd6, 0xf4, 0x5b, 0x6d, 0x52, 0xfe, 0x3b, 0xc9, 0xac, 0x6d, 0x76, 0x4d, 0xab, 0x9, 0xab, 0x53, 0x4f, 0xf4, 0x1b,
-	0xb7, 0x7a, 0xfe, 0xe6, 0xf3, 0xef, 0x71, 0x91, 0xdb, 0xb4, 0xf8, 0xac, 0x2d, 0x2a, 0xca, 0xd3, 0xf0, 0x92, 0x4e, 0x2e, 0xe0,
-	0xaa, 0x6b, 0x88, 0xeb, 0xb4, 0xbc, 0xaa, 0x9e, 0x42, 0x39, 0xde, 0x64, 0xfa, 0x56, 0xf9, 0x75, 0xe1, 0xb6, 0xd1, 0x99, 0x83,
-	0x64, 0xeb, 0xbc, 0xf7, 0x62, 0xf5, 0x85, 0xbd, 0xc5, 0xd4, 0xb8, 0xe, 0xe6, 0xeb, 0xac, 0x16, 0x53, 0x3f, 0xa7, 0x64, 0xb0,
-	0xd1, 0xd7, 0x5d, 0x56, 0xb7, 0x5b, 0x1c, 0x58, 0xf8, 0xaf, 0xaf, 0x74, 0x1c, 0xbf, 0x36, 0xdc, 0x71, 0xf8, 0x8b, 0x2c, 0xa7,
-	0xdb, 0xa6, 0x99, 0xa9, 0x93, 0x8b, 0x69, 0xee, 0xe0, 0xa6, 0x9b, 0x8a, 0xc3, 0x4d, 0xba, 0x9b, 0xa1, 0xfb, 0xab, 0xbe, 0x33,
-	0xd6, 0xfa, 0xcf, 0x4c, 0x75, 0x56, 0xfd, 0xd9, 0xd9, 0xab, 0x8b, 0xb8, 0x2c, 0xbf, 0xb, 0xa5, 0xea, 0xf9, 0x7c, 0xf4, 0x76,
-	0x93, 0x4f, 0xf9, 0xd3, 0x5e, 0x56, 0xfa, 0xc6, 0xd6, 0x5b, 0xc, 0x35, 0xa4, 0x71, 0xfb, 0xc9, 0x2d, 0xc5, 0xdc, 0xb0, 0x41,
-	0xc, 0x54, 0xd5, 0x24, 0x95, 0xd3, 0x45, 0x3c, 0xd5, 0xc0, 0x4c, 0x2b, 0xd3, 0x9f, 0xc0, 0xde, 0xb7, 0xf4, 0x90, 0xea, 0xd,
-	0xff, 0x0, 0xcc, 0x8f, 0x34, 0xf7, 0x4d, 0x5b, 0x1, 0xda, 0x97, 0x9a, 0xa4, 0xf8, 0xab, 0xda, 0x22, 0xc8, 0xdb, 0xe4, 0xf0,
-	0xfd, 0x65, 0xab, 0x5c, 0xcb, 0x16, 0x47, 0x9d, 0x1f, 0x57, 0x9a, 0xf, 0x7e, 0x77, 0x4e, 0xcf, 0xdc, 0xef, 0xb1, 0xd0, 0x45,
-	0x37, 0xec, 0xfa, 0x67, 0xf9, 0xd7, 0x15, 0x16, 0x56, 0x1c, 0xcb, 0x1d, 0x57, 0x13, 0xdd, 0x84, 0x55, 0xfc, 0xe9, 0xf2, 0xcb,
-	0x63, 0xf3, 0x5b, 0xc9, 0xbe, 0xc6, 0xef, 0xdc, 0xed, 0xad, 0xc6, 0x27, 0x1d, 0xb0, 0x5e, 0xc1, 0x89, 0xd1, 0xf5, 0x9b, 0x89,
-	0xa8, 0x9e, 0xbd, 0x4f, 0xaf, 0xf0, 0x31, 0xf3, 0x63, 0xab, 0x60, 0xab, 0x92, 0x2f, 0x78, 0x2b, 0xbe, 0xa6, 0xd3, 0x8a, 0xae,
-	0xaf, 0xab, 0x8f, 0xfa, 0xb9, 0x72, 0x37, 0x57, 0x12, 0x51, 0xc7, 0x14, 0xd7, 0xc7, 0x1c, 0x6, 0xa2, 0x3, 0xb0, 0x9e, 0x93,
-	0x1e, 0x9a, 0x3a, 0x7, 0xa8, 0x66, 0xc5, 0xda, 0xb0, 0xf6, 0x7, 0x74, 0x73, 0xa0, 0xe3, 0x7a, 0xeb, 0x1, 0x1d, 0x76, 0xba,
-	0x7e, 0xa1, 0x5e, 0x3a, 0x7e, 0xcb, 0xcc, 0x65, 0x33, 0x50, 0xcd, 0x6f, 0x88, 0xda, 0x79, 0xb3, 0xce, 0x63, 0xee, 0xf1, 0x74,
-	0x68, 0x38, 0x2c, 0x97, 0x11, 0xd3, 0x7d, 0x54, 0x7c, 0x49, 0x73, 0x75, 0x35, 0x74, 0xdb, 0x71, 0x5d, 0x9f, 0x32, 0xd1, 0x72,
-	0xd, 0x27, 0xf2, 0x9f, 0xc2, 0xdf, 0x21, 0xbc, 0x3e, 0xec, 0x9c, 0x97, 0x5c, 0xf7, 0x1f, 0x5f, 0x67, 0x71, 0x9c, 0xc7, 0x97,
-	0xab, 0x19, 0xab, 0xee, 0x36, 0x38, 0xcb, 0xeb, 0xdd, 0x23, 0x7f, 0xb7, 0x9e, 0xb9, 0xf9, 0xc5, 0x64, 0x74, 0xdd, 0x8e, 0x2b,
-	0x7e, 0x6c, 0x32, 0xbc, 0x65, 0x2d, 0xa0, 0xe6, 0x4e, 0x2d, 0x3e, 0x54, 0xdf, 0xdb, 0x55, 0xc5, 0x51, 0x5c, 0x43, 0x14, 0xd1,
-	0xd7, 0x1d, 0x21, 0x28, 0x7f, 0xa7, 0x97, 0xc4, 0x9e, 0xe8, 0xe8, 0x1d, 0x1f, 0xbd, 0x3b, 0xf7, 0xba, 0x30, 0x39, 0x8e, 0xb1,
-	0xd6, 0x3b, 0x6b, 0x1b, 0xa5, 0x63, 0xb4, 0xad, 0x67, 0x6f, 0x82, 0xe7, 0x5f, 0xcb, 0xe4, 0xf0, 0x1a, 0x7f, 0x3b, 0x1e, 0x63,
-	0x21, 0xd8, 0x39, 0xac, 0x3e, 0x4e, 0x9b, 0x59, 0x70, 0xf8, 0x19, 0x28, 0xce, 0xd1, 0x16, 0x2a, 0x6b, 0xaa, 0x68, 0x92, 0xe6,
-	0xf, 0xc4, 0xdc, 0x53, 0x4d, 0x36, 0xb5, 0xdb, 0xcd, 0x70, 0x1c, 0xdf, 0xf4, 0xf6, 0xec, 0x8d, 0x67, 0xb8, 0x3d, 0x7d, 0xb2,
-	0xbd, 0xa3, 0xa5, 0xd7, 0x44, 0xda, 0x86, 0xf9, 0xdb, 0x5e, 0x58, 0xec, 0xda, 0xc5, 0xdd, 0x11, 0xd3, 0x17, 0x19, 0x1c, 0xe,
-	0x53, 0x40, 0xed, 0x5b, 0x8c, 0x4e, 0x5a, 0xa8, 0xe9, 0xfc, 0xa8, 0x97, 0x2f, 0x63, 0x55, 0x17, 0x55, 0xf1, 0xef, 0xcf, 0x3c,
-	0x57, 0x2f, 0x3e, 0xfc, 0xf3, 0xcf, 0xe7, 0xc8, 0x62, 0x7f, 0xa8, 0x37, 0xfc, 0x46, 0xb6, 0x8f, 0xe1, 0x47, 0x56, 0x7f, 0xd2,
-	0x2f, 0x1, 0xd5, 0x6f, 0x45, 0xff, 0x0, 0x33, 0xfa, 0x77, 0xca, 0x9f, 0x18, 0x72, 0x3e, 0x9b, 0x5e, 0x4b, 0xcb, 0x8a, 0xbd,
-	0xd8, 0xf1, 0xba, 0x96, 0x7f, 0x47, 0xd3, 0x31, 0x5b, 0x15, 0xcc, 0x36, 0x90, 0x76, 0xb7, 0x51, 0x64, 0x6d, 0xee, 0xe6, 0xa3,
-	0x5d, 0xc2, 0x5d, 0xfd, 0xc8, 0x25, 0xa3, 0x77, 0xeb, 0xab, 0x69, 0x64, 0xa2, 0xde, 0x3b, 0x7e, 0x63, 0xbc, 0x8f, 0x1b, 0x6d,
-	0x6d, 0x77, 0x6d, 0x55, 0x52, 0xda, 0x5c, 0xcb, 0x10, 0x71, 0x87, 0xce, 0xff, 0x0, 0x47, 0x6f, 0x28, 0xfc, 0x41, 0xdc, 0x73,
-	0x39, 0xd, 0x3f, 0x4a, 0xda, 0xfb, 0xbb, 0xa2, 0x2e, 0xb2, 0x37, 0x32, 0x6a, 0x7d, 0x91, 0xa2, 0xe0, 0xef, 0x36, 0x5c, 0xa6,
-	0x2b, 0x15, 0x24, 0xde, 0xf6, 0x78, 0xfe, 0xcb, 0xd7, 0xb0, 0x36, 0x93, 0xe4, 0x35, 0x5c, 0xc5, 0xa5, 0x12, 0x47, 0xc, 0x97,
-	0xb5, 0x41, 0x4e, 0x22, 0xf2, 0x5a, 0xa9, 0xfc, 0x3c, 0xfc, 0x49, 0x5d, 0x56, 0xd1, 0x7, 0x34, 0x3a, 0xef, 0xa8, 0xbb, 0x53,
-	0xb7, 0x36, 0x28, 0xf5, 0x1e, 0xad, 0xeb, 0x8d, 0xe3, 0xb0, 0xf6, 0x79, 0x2e, 0xa0, 0xb2, 0xfd, 0x85, 0xa6, 0x6a, 0xf9, 0x9d,
-	0x8f, 0x25, 0xd, 0xc5, 0xcd, 0x72, 0xc7, 0xd, 0x17, 0x76, 0xb8, 0xab, 0x3b, 0x99, 0x2c, 0xa9, 0xe6, 0xab, 0x79, 0x39, 0xe6,
-	0xb9, 0xb8, 0xa2, 0x8a, 0x69, 0x8e, 0xba, 0xaa, 0xe7, 0x8e, 0x28, 0xab, 0x9e, 0x2, 0x72, 0x5e, 0x13, 0xf4, 0x7, 0x60, 0x78,
-	0x5b, 0xe9, 0x1b, 0xd9, 0xfa, 0x3f, 0x91, 0x7c, 0x6b, 0xba, 0x6, 0xcd, 0xfd, 0x2, 0xef, 0xad, 0xcf, 0x33, 0x63, 0x79, 0xb1,
-	0xe3, 0x24, 0xb6, 0xd5, 0xac, 0xf7, 0xd, 0x72, 0xfe, 0x3c, 0x3e, 0x2b, 0x61, 0xcc, 0xf1, 0x2d, 0x18, 0x3b, 0x7c, 0xdd, 0x55,
-	0xf1, 0x45, 0x32, 0x45, 0x5, 0xcd, 0xc4, 0x34, 0xc9, 0x35, 0x11, 0xf1, 0x2d, 0x52, 0x73, 0x55, 0x14, 0x87, 0x25, 0xbe, 0x99,
-	0x3f, 0xdf, 0xbf, 0x93, 0x7f, 0xc2, 0x4d, 0x4f, 0xf9, 0xc6, 0xa0, 0x71, 0x6b, 0xd4, 0x47, 0xfe, 0x7d, 0x7c, 0xcb, 0xff, 0x0,
-	0xec, 0xe7, 0x76, 0xff, 0x0, 0xdc, 0x4d, 0x80, 0x1f, 0x19, 0xe2, 0x67, 0x95, 0x9d, 0xb1, 0xe1, 0xaf, 0x75, 0xeb, 0x1d, 0xdd,
-	0xd4, 0x39, 0x6f, 0xc2, 0x66, 0x70, 0xb3, 0x53, 0x69, 0x9e, 0xc0, 0x5d, 0xd7, 0x2f, 0x3a, 0xfe, 0xf3, 0xaa, 0x5c, 0x5c, 0x5b,
-	0xcb, 0x9a, 0xd3, 0x76, 0x7b, 0x48, 0xf9, 0xe3, 0x9b, 0x9c, 0x3e, 0x5e, 0x2b, 0x7a, 0x78, 0xf9, 0xd3, 0xed, 0x3d, 0xac, 0xf4,
-	0x47, 0x71, 0x5, 0x71, 0xcf, 0x14, 0x72, 0x52, 0x16, 0x1f, 0xf8, 0x61, 0xe4, 0xe7, 0x45, 0xf9, 0x95, 0xd5, 0x16, 0x9e, 0x45,
-	0xf4, 0xcc, 0x18, 0xfb, 0x4b, 0xed, 0xba, 0x2c, 0x6e, 0xf, 0xb1, 0xf1, 0x72, 0x45, 0x63, 0x1e, 0xe3, 0xac, 0x6d, 0x9a, 0xd5,
-	0xa5, 0x5e, 0xfa, 0x7e, 0xeb, 0x25, 0xad, 0x34, 0xcb, 0x75, 0x79, 0x81, 0x87, 0x2b, 0xcd, 0x56, 0x53, 0xd7, 0xfd, 0x5d, 0xcd,
-	0x85, 0xcc, 0x53, 0xc3, 0xfd, 0x54, 0xb4, 0x71, 0xc0, 0x57, 0x61, 0xd1, 0x7d, 0xf, 0xb8, 0x79, 0x3b, 0xe4, 0x9e, 0x91, 0xd0,
-	0xba, 0x24, 0x5c, 0xd5, 0xb1, 0xf6, 0x67, 0x60, 0xd5, 0xaf, 0xc3, 0x79, 0xcc, 0x35, 0xdc, 0x41, 0x84, 0xc5, 0xf3, 0x79, 0x73,
-	0x79, 0xb1, 0x6c, 0xd7, 0xd1, 0x47, 0xcd, 0x32, 0x57, 0x8c, 0xd5, 0xf5, 0xeb, 0x4b, 0xac, 0x8d, 0xcf, 0x14, 0xf3, 0xf2, 0xe6,
-	0xde, 0xda, 0xbf, 0x8f, 0xbd, 0x5e, 0xdc, 0x72, 0x12, 0x62, 0xf5, 0xd8, 0xee, 0xfd, 0x4f, 0xc5, 0x6f, 0x15, 0xfa, 0x1b, 0xd3,
-	0x87, 0xa3, 0xe7, 0x8f, 0xb, 0x8e, 0xcc, 0xea, 0xf8, 0x1b, 0xad, 0xc3, 0x1f, 0x6b, 0x73, 0x4f, 0x19, 0x3b, 0xe, 0xa3, 0xeb,
-	0xf9, 0xad, 0xec, 0x75, 0x4b, 0x1c, 0xbd, 0x50, 0xf1, 0xd, 0x53, 0xdd, 0x76, 0x1e, 0xe9, 0x8d, 0x9a, 0xfa, 0xea, 0xe3, 0x9e,
-	0x3e, 0x77, 0x32, 0x61, 0xae, 0x3e, 0xef, 0x1c, 0xf1, 0x71, 0x57, 0x35, 0x4, 0x46, 0x1, 0xb0, 0xbe, 0x28, 0xf9, 0x9, 0xb2,
-	0xf8, 0xab, 0xe4, 0x57, 0x52, 0xf7, 0xfe, 0xab, 0xf7, 0xe5, 0xc8, 0x75, 0xbe, 0xdd, 0x61, 0x97, 0xbf, 0xc6, 0xdb, 0xcf, 0xcd,
-	0xbf, 0x39, 0xfd, 0x62, 0xe3, 0x89, 0x31, 0x9b, 0x7e, 0xb1, 0x24, 0xbe, 0xfc, 0x71, 0x44, 0x3b, 0x2e, 0xaf, 0x7d, 0x77, 0x63,
-	0x55, 0x5c, 0xfb, 0xf1, 0x47, 0x13, 0xfc, 0xbf, 0xb6, 0x9e, 0x1, 0x28, 0x5f, 0x5e, 0x8f, 0x1c, 0x75, 0x5f, 0x26, 0x3c, 0x62,
-	0xea, 0xf, 0x50, 0xbe, 0x93, 0xe2, 0x1d, 0x86, 0x8d, 0x4f, 0x59, 0xd7, 0x78, 0xd9, 0xb2, 0xd8, 0xc8, 0x38, 0xae, 0x6d, 0x8f,
-	0xa3, 0x7b, 0x2, 0xb8, 0x32, 0x7a, 0xb6, 0x7a, 0xe2, 0x98, 0x63, 0x9a, 0xe2, 0xa9, 0x74, 0x7d, 0x9b, 0x35, 0x4f, 0xce, 0x2f,
-	0xd3, 0xf8, 0x7b, 0x6c, 0xc5, 0xdc, 0x93, 0x73, 0xc7, 0x16, 0xde, 0xd4, 0x87, 0xab, 0xf4, 0xc9, 0x7e, 0xe3, 0x7c, 0x9e, 0xfe,
-	0x2b, 0xe9, 0xdf, 0xca, 0x17, 0x0, 0x8d, 0x2e, 0x6f, 0xc0, 0xcf, 0x39, 0x65, 0xcc, 0xe5, 0xe5, 0x8b, 0xc3, 0x1f, 0x2b, 0xe4,
-	0x8a, 0x4c, 0x9d, 0xfc, 0x91, 0xc9, 0x1f, 0x8e, 0xbd, 0xbf, 0x5c, 0x72, 0x47, 0x5d, 0xd4, 0xb5, 0x51, 0x5d, 0x15, 0xd3, 0xa7,
-	0xf3, 0x4d, 0x74, 0x57, 0x4f, 0x3c, 0x73, 0xc7, 0x3c, 0x73, 0xed, 0xcf, 0x0, 0xc0, 0x7d, 0x99, 0xd3, 0x5d, 0xbf, 0xd2, 0xb9,
-	0x5c, 0x7e, 0xb, 0xb9, 0x3a, 0xa7, 0xb2, 0x7a, 0x97, 0x39, 0x96, 0xc7, 0xfe, 0xd6, 0xc5, 0xe1, 0xbb, 0x33, 0x46, 0xd9, 0xf4,
-	0x3c, 0xae, 0x4b, 0x15, 0xf8, 0x99, 0xac, 0xff, 0x0, 0x69, 0xe3, 0xf1, 0xdb, 0x4e, 0x2f, 0x15, 0x77, 0x79, 0x8f, 0xfc, 0x5d,
-	0xb4, 0x91, 0x7d, 0xe8, 0xe8, 0xaa, 0x3f, 0xb9, 0x1d, 0x54, 0xfc, 0xbe, 0x54, 0xf3, 0xc7, 0x1, 0x8d, 0x80, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xd7, 0xaf, 0xfc, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xb9, 0xac, 0x6c, 0x39, 0x1d,
-	0x4b, 0x64, 0xd7, 0xb6, 0xbc, 0x47, 0x30, 0xd3, 0x96, 0xd6, 0x73, 0x98, 0x9d, 0x87, 0x17, 0x55, 0xc4, 0x5f, 0x7e, 0xde, 0x9c,
-	0x8e, 0x16, 0xfe, 0xdf, 0x25, 0x65, 0xcc, 0xf0, 0xfc, 0xa9, 0xfb, 0xd0, 0xf1, 0x73, 0x6d, 0x4f, 0xca, 0x9f, 0x7e, 0x3e, 0x54,
-	0xfb, 0xf1, 0xee, 0xd, 0xc8, 0xf3, 0x1f, 0xd4, 0x3b, 0xc9, 0x1f, 0x3b, 0x2d, 0xba, 0xfa, 0xd7, 0xbf, 0xb2, 0xba, 0x96, 0x4a,
-	0x1e, 0xb2, 0x9f, 0x67, 0xb8, 0xd5, 0xb8, 0xd6, 0x35, 0x4b, 0x3d, 0x6b, 0x98, 0x64, 0xdb, 0xa3, 0xc0, 0x47, 0x99, 0xe6, 0xf6,
-	0xab, 0x59, 0xa5, 0xe6, 0xf3, 0x8a, 0xe9, 0xd6, 0xed, 0x7e, 0xdf, 0x15, 0x7b, 0x7d, 0xbf, 0x6a, 0xbd, 0xbf, 0xf7, 0x7e, 0x41,
-	0xa3, 0x60, 0xf5, 0xf5, 0xfd, 0x83, 0x39, 0xa9, 0xe7, 0xb0, 0xbb, 0x46, 0xb1, 0x97, 0xc9, 0x6b, 0xfb, 0x26, 0xb9, 0x95, 0xc7,
-	0xe7, 0x70, 0x19, 0xec, 0x35, 0xe5, 0xc6, 0x3b, 0x2d, 0x85, 0xcc, 0xe2, 0x6e, 0xe2, 0xbe, 0xc6, 0x65, 0x71, 0x97, 0xf6, 0xb2,
-	0x45, 0x73, 0x65, 0x90, 0xc7, 0xde, 0xc1, 0x44, 0xb0, 0xcb, 0x1d, 0x54, 0xd7, 0x1c, 0x94, 0x71, 0x55, 0x3c, 0xf1, 0xcf, 0x1c,
-	0x72, 0xd, 0xb6, 0xf3, 0x53, 0xcd, 0xce, 0xcc, 0xf3, 0x9f, 0x6d, 0xea, 0xfd, 0xf7, 0xb6, 0xb1, 0x58, 0x1b, 0x3d, 0xcb, 0xae,
-	0xfa, 0x87, 0x3, 0xd5, 0x37, 0xf9, 0x9c, 0x15, 0x13, 0x5b, 0xd3, 0xb9, 0x57, 0x84, 0xce, 0x6c, 0x79, 0xd9, 0x76, 0xdc, 0x9d,
-	0x85, 0x7c, 0xfe, 0x13, 0x1b, 0x97, 0xcb, 0x5d, 0x6c, 0x72, 0x73, 0x3c, 0x16, 0xbc, 0x51, 0x6b, 0x4d, 0x54, 0x7b, 0xc7, 0x45,
-	0x14, 0xf3, 0xc5, 0x14, 0x86, 0xa6, 0x6b, 0xbb, 0x26, 0xc3, 0xa8, 0x67, 0x71, 0x5b, 0x46, 0xa5, 0x9e, 0xcd, 0x6a, 0xfb, 0x36,
-	0xa, 0xf6, 0xc, 0x9e, 0xf, 0x62, 0xd7, 0x72, 0x97, 0xd8, 0x4c, 0xee, 0x1b, 0x25, 0x6b, 0x5f, 0xce, 0xdb, 0x21, 0x8a, 0xcb,
-	0xe3, 0x67, 0xb6, 0xc8, 0x63, 0xaf, 0x6d, 0xeb, 0xe3, 0xde, 0x89, 0x61, 0x92, 0x89, 0x28, 0xe7, 0xf3, 0xe3, 0x9e, 0x1, 0xdc,
-	0xce, 0x8e, 0xfa, 0x87, 0x7c, 0xe4, 0xea, 0xfc, 0x3e, 0x33, 0x5d, 0xec, 0x3c, 0x6f, 0x57, 0x77, 0xd6, 0x3b, 0x1d, 0x6f, 0xcd,
-	0xaf, 0xed, 0xcd, 0xd7, 0x3, 0x92, 0xd7, 0xf7, 0xdb, 0x88, 0x61, 0x86, 0x58, 0xec, 0x68, 0x9f, 0x63, 0xd3, 0x32, 0xb8, 0x6c,
-	0x25, 0xe5, 0x70, 0x7b, 0xc7, 0xc4, 0xb3, 0xdd, 0x62, 0x2e, 0x6f, 0x2e, 0xa9, 0x8f, 0xde, 0x59, 0xb9, 0x9a, 0xba, 0xe6, 0xa8,
-	0x33, 0x2e, 0xd3, 0xf5, 0x30, 0x79, 0x3f, 0x7f, 0x87, 0x9e, 0xd7, 0x50, 0xe8, 0x2e, 0x8d, 0xd6, 0xf3, 0x52, 0xf3, 0xf0, 0x8b,
-	0x2f, 0x99, 0xba, 0xde, 0x76, 0x9b, 0x6b, 0x58, 0xaa, 0xa2, 0x4a, 0x64, 0xae, 0x1c, 0x4d, 0xbe, 0x7b, 0x5a, 0xf9, 0xde, 0x53,
-	0x55, 0x54, 0xd5, 0x15, 0x72, 0x4f, 0x5c, 0x54, 0xd5, 0x4f, 0xeb, 0x8a, 0x4e, 0x39, 0xf6, 0xe0, 0x38, 0xad, 0xe4, 0xff, 0x0,
-	0x99, 0xde, 0x4a, 0xf9, 0x8b, 0xb4, 0xd1, 0xb4, 0xf9, 0x3, 0xda, 0x59, 0xdd, 0xd7, 0xf0, 0x53, 0x4d, 0x2e, 0xbf, 0xac, 0x51,
-	0xcc, 0x38, 0x6d, 0x17, 0x53, 0xa2, 0x6f, 0x78, 0xfe, 0xde, 0xb1, 0xa5, 0xe1, 0xe2, 0xb3, 0xd7, 0xf1, 0x73, 0x7e, 0x1b, 0xe3,
-	0xc, 0xb7, 0x9c, 0x41, 0x5e, 0x42, 0xf2, 0x88, 0xe8, 0xe6, 0xea, 0xe2, 0x7a, 0xf8, 0xf9, 0xf2, 0x1a, 0xba, 0x0, 0x32, 0x7f,
-	0x4e, 0x77, 0x4f, 0x6a, 0x78, 0xfb, 0xd8, 0x38, 0x3e, 0xd4, 0xe9, 0x8d, 0xe3, 0x39, 0xd7, 0xbb, 0xfe, 0xb9, 0x24, 0x95, 0xe2,
-	0xb6, 0x2c, 0xc, 0xf1, 0xd1, 0x3d, 0x31, 0x4f, 0x4f, 0xdb, 0xba, 0xb0, 0xbe, 0xb3, 0xba, 0x8a, 0xe7, 0x1b, 0x98, 0xc4, 0x5f,
-	0xc5, 0xfa, 0x2e, 0x6c, 0xaf, 0x21, 0x9e, 0xd2, 0xe6, 0x3f, 0xd3, 0x2c, 0x75, 0xd3, 0xf9, 0x3, 0xbe, 0x5a, 0x57, 0xd4, 0xb5,
-	0xe5, 0x3e, 0x23, 0x3, 0x6d, 0x8f, 0xde, 0x3a, 0x3b, 0xa4, 0x77, 0x4c, 0xe5, 0xb7, 0xc2, 0x2a, 0xb6, 0x1c, 0x6c, 0x9b, 0x96,
-	0xa1, 0xcd, 0xfc, 0x11, 0xdb, 0x5b, 0xc5, 0xc4, 0xd9, 0x1c, 0x4d, 0x19, 0xbc, 0xed, 0x9f, 0x39, 0x49, 0xee, 0x28, 0x96, 0x59,
-	0x64, 0xb5, 0xe6, 0xd6, 0xdb, 0x9f, 0xb9, 0xc5, 0x31, 0xdb, 0xc5, 0xc5, 0x3f, 0xa8, 0x34, 0xf3, 0xcc, 0x7f, 0x5a, 0xff, 0x0,
-	0x31, 0x7c, 0xbe, 0xd5, 0x33, 0x3d, 0x69, 0x35, 0xe6, 0xb1, 0xd3, 0x1d, 0x53, 0x9f, 0xb5, 0xe7, 0x1f, 0x9f, 0xd4, 0x3a, 0xb6,
-	0xdf, 0x29, 0x67, 0x94, 0xda, 0xb1, 0x72, 0x53, 0xed, 0x73, 0x8c, 0xdb, 0x37, 0x2c, 0xbe, 0x4b, 0x21, 0x9c, 0xbe, 0xc6, 0x5e,
-	0x7c, 0xab, 0x8e, 0xe2, 0xd2, 0xc7, 0xf6, 0x6d, 0x95, 0xdd, 0xb5, 0x5f, 0x66, 0xe6, 0x9, 0xe9, 0xf9, 0xf3, 0x58, 0x73, 0xdb,
-	0xc6, 0xcf, 0x22, 0xfb, 0x2f, 0xc5, 0x1e, 0xe3, 0xd5, 0xbb, 0xd7, 0xa8, 0x6e, 0xf1, 0x16, 0x5b, 0xfe, 0x9f, 0x6, 0x7e, 0xdf,
-	0xb, 0x73, 0x9d, 0xc4, 0xc3, 0x9c, 0xc5, 0xd1, 0x1e, 0xcb, 0xae, 0xe5, 0x35, 0x7c, 0xa7, 0x17, 0x18, 0xcb, 0x8a, 0xe3, 0x8a,
-	0x7e, 0x6b, 0xc5, 0x66, 0x26, 0xe2, 0x8e, 0x79, 0xe7, 0x8f, 0x85, 0x7c, 0xf1, 0x57, 0xf9, 0x3, 0xd6, 0xf2, 0x93, 0xca, 0x4e,
-	0xd7, 0xf3, 0xb, 0xb5, 0xee, 0xfb, 0xa3, 0xba, 0x2e, 0xf0, 0x77, 0xdb, 0xc5, 0xf6, 0xf, 0xb, 0xaf, 0x5c, 0x5c, 0x6b, 0xd8,
-	0x58, 0x70, 0x38, 0xea, 0xf1, 0xd8, 0x18, 0x65, 0x83, 0x1d, 0xc7, 0x18, 0xe8, 0x25, 0x96, 0x2a, 0x26, 0xa2, 0x29, 0x79, 0xe2,
-	0xaa, 0xb8, 0xe7, 0x8f, 0x97, 0xb7, 0x1f, 0x97, 0xbf, 0xf6, 0x86, 0x0, 0xc7, 0x64, 0x72, 0x18, 0x7c, 0x85, 0x86, 0x5f, 0x11,
-	0x7f, 0x79, 0x8b, 0xca, 0xe2, 0xef, 0x2d, 0x72, 0x38, 0xcc, 0x9e, 0x3a, 0xea, 0x7b, 0x1c, 0x86, 0x3b, 0x21, 0x63, 0x3c, 0x77,
-	0x36, 0x57, 0xf6, 0x17, 0xb6, 0xd2, 0x45, 0x73, 0x67, 0x79, 0x67, 0x73, 0x15, 0x32, 0x45, 0x2c, 0x75, 0x53, 0x5c, 0x75, 0xd3,
-	0xc5, 0x54, 0xf3, 0xc7, 0x3c, 0x71, 0xcf, 0x1, 0xdb, 0xbf, 0x1e, 0xbe, 0xa0, 0x2f, 0x3a, 0x7a, 0x5f, 0x13, 0x8e, 0xd6, 0x77,
-	0x8b, 0x8d, 0x17, 0xc8, 0x4d, 0x7e, 0xc2, 0x3a, 0x2d, 0xe3, 0xbd, 0xed, 0xc, 0x56, 0x52, 0x1d, 0xf6, 0x3b, 0x48, 0x21, 0xb9,
-	0xa6, 0x18, 0xa3, 0xde, 0x35, 0x8c, 0xb6, 0x1a, 0x5c, 0x94, 0xf5, 0x5c, 0x4b, 0x1d, 0x53, 0x5c, 0xe5, 0xec, 0xf2, 0xd7, 0x52,
-	0xd1, 0x17, 0xc7, 0xee, 0x53, 0x55, 0x5c, 0xd7, 0xc0, 0x6c, 0x9e, 0x67, 0xea, 0x67, 0xf2, 0x42, 0x7c, 0x65, 0xdc, 0x5a, 0xff,
-	0x0, 0x8e, 0x7d, 0x23, 0x8c, 0xcc, 0x57, 0x45, 0x1c, 0x58, 0xdf, 0xe6, 0x72, 0xdb, 0xe6, 0x77, 0x19, 0x6f, 0x27, 0x12, 0xd1,
-	0xcc, 0x95, 0x5d, 0xe2, 0x6c, 0xb3, 0x1a, 0xed, 0xd5, 0xe5, 0x15, 0x43, 0xc5, 0x54, 0xf1, 0x4d, 0x17, 0xb0, 0x73, 0x4d, 0x5c,
-	0xf1, 0x57, 0xbf, 0x3c, 0x71, 0xcd, 0x35, 0x7, 0x1f, 0x7c, 0xb3, 0xf5, 0xc, 0xf2, 0xcb, 0xcd, 0x5b, 0xc8, 0x69, 0xef, 0x4e,
-	0xcf, 0xbe, 0xc8, 0xea, 0x96, 0x17, 0x3c, 0x5e, 0x61, 0xfa, 0xdb, 0x59, 0xb6, 0x8b, 0x55, 0xeb, 0x9c, 0x4d, 0xcd, 0x14, 0xf1,
-	0xc4, 0x77, 0x54, 0x6b, 0x58, 0xce, 0x68, 0xa3, 0x33, 0x91, 0x83, 0x9e, 0x6b, 0xe6, 0x2b, 0xdc, 0xa4, 0xb7, 0xf7, 0xd0, 0xd3,
-	0x2d, 0x74, 0x47, 0x35, 0x31, 0xd5, 0xf0, 0xe0, 0x3c, 0x9f, 0xf, 0xbc, 0xe5, 0xef, 0xbf, 0x6, 0xb6, 0x4d, 0xc7, 0x6b, 0xe8,
-	0x4c, 0x86, 0xb1, 0x8e, 0xcc, 0x6f, 0x58, 0x3b, 0xd, 0x7b, 0x3d, 0x2e, 0xcd, 0xad, 0xdb, 0x6c, 0x90, 0xd7, 0x8d, 0xc7, 0x5f,
-	0xd5, 0x92, 0xb7, 0x8e, 0xd6, 0xb, 0x99, 0xa2, 0xa2, 0xda, 0x5f, 0xc5, 0x55, 0xef, 0x55, 0x7c, 0x7b, 0xf3, 0xcf, 0x1c, 0x7b,
-	0x7e, 0x5f, 0x9f, 0xb8, 0x6b, 0xdf, 0x6a, 0xf6, 0x56, 0xd1, 0xdc, 0x9d, 0x99, 0xbf, 0xf6, 0xd6, 0xed, 0x35, 0x9d, 0xc6, 0xe1,
-	0xd9, 0x7b, 0x8e, 0xc5, 0xbd, 0x6d, 0x13, 0xe3, 0xec, 0xe8, 0xc7, 0xd8, 0x4d, 0x9f, 0xda, 0x32, 0xb7, 0x59, 0x9c, 0xac, 0x96,
-	0x76, 0x31, 0x73, 0x54, 0x76, 0x76, 0xb5, 0xde, 0xde, 0x57, 0xcd, 0x11, 0x53, 0xcf, 0x3c, 0x51, 0x4f, 0xb7, 0x1f, 0xe4, 0xf,
-	0x81, 0x6, 0xed, 0xf8, 0x2b, 0xe7, 0x97, 0x73, 0x78, 0xd, 0xda, 0xb7, 0x3d, 0x8b, 0xd5, 0x92, 0xda, 0xe6, 0xb0, 0xbb, 0x6,
-	0x3b, 0x9c, 0x46, 0xf9, 0xd7, 0x19, 0xeb, 0x9b, 0xd8, 0xf5, 0x2d, 0xe3, 0x1f, 0xc, 0x77, 0x5c, 0xe2, 0x6b, 0xc9, 0xc5, 0x67,
-	0x25, 0x13, 0x5a, 0xe5, 0xf5, 0xfb, 0xdb, 0xaa, 0xa7, 0xb0, 0xbd, 0x8b, 0xda, 0x7b, 0x7e, 0x6b, 0x96, 0x2f, 0x7a, 0xa0, 0x9e,
-	0x78, 0xe4, 0xf, 0x94, 0xf1, 0x5f, 0xcc, 0xbe, 0xe1, 0xf0, 0xdf, 0xb3, 0x76, 0x1e, 0xdd, 0xe9, 0x58, 0xb4, 0xbb, 0x5d, 0xdf,
-	0x62, 0xc1, 0x64, 0x75, 0xb9, 0x32, 0x7b, 0x5e, 0xab, 0x67, 0xb5, 0x7e, 0xcb, 0xc4, 0xe5, 0xb2, 0x76, 0x79, 0x5c, 0x84, 0x58,
-	0x5a, 0x2f, 0xa4, 0xa3, 0xf6, 0x6d, 0xcd, 0xdc, 0xd6, 0x11, 0x47, 0x24, 0xd4, 0x73, 0xf7, 0x2a, 0x87, 0x8e, 0x63, 0xf7, 0xf8,
-	0xd7, 0x5f, 0x15, 0x7, 0xc0, 0x79, 0x19, 0xe4, 0x4f, 0x6a, 0x79, 0x55, 0xdb, 0xbb, 0x3f, 0x77, 0x77, 0x2e, 0x72, 0x2c, 0xf6,
-	0xf7, 0xb5, 0xd3, 0x8b, 0x86, 0xfa, 0x7b, 0x3b, 0x4a, 0x31, 0xb8, 0xab, 0x2b, 0x2c, 0x2e, 0x2e, 0xd3, 0xf, 0x8c, 0xc6, 0xe1,
-	0xb1, 0x30, 0xd5, 0x55, 0xb6, 0x2f, 0x1d, 0x6b, 0x67, 0x65, 0x4f, 0xb4, 0x51, 0xfb, 0x71, 0x54, 0xb5, 0x57, 0x2d, 0x5f, 0x29,
-	0x24, 0xae, 0xaa, 0x83, 0x7, 0x0, 0xe, 0x8f, 0xf5, 0x2f, 0xaa, 0xa7, 0x96, 0xfd, 0x3b, 0xe3, 0x8c, 0xfe, 0x29, 0x60, 0x73,
-	0x3a, 0x2e, 0xc5, 0xd2, 0x97, 0x18, 0x3d, 0xbb, 0x57, 0x93, 0x5a, 0xde, 0xf4, 0x7c, 0x76, 0xd7, 0x2f, 0xf4, 0x67, 0x78, 0xaf,
-	0x23, 0x26, 0xc1, 0xaf, 0x7e, 0x3a, 0xf6, 0x6a, 0x65, 0xab, 0x11, 0x34, 0x99, 0x7b, 0x9e, 0x62, 0x8a, 0xae, 0x2a, 0xe2, 0x1e,
-	0x26, 0xe6, 0x9a, 0x3d, 0xa9, 0xe2, 0x9a, 0x69, 0xf, 0x99, 0xf0, 0xfb, 0xd4, 0x9f, 0xc9, 0xef, 0x6, 0xb5, 0xbd, 0xc7, 0x54,
-	0xe8, 0x4c, 0xae, 0x9b, 0x8d, 0xc4, 0xef, 0x59, 0xcb, 0x1d, 0x87, 0x60, 0xa7, 0x66, 0xd4, 0x6c, 0xf6, 0x4b, 0x89, 0x72, 0x38,
-	0xeb, 0xe, 0x71, 0xb6, 0xbc, 0xdb, 0x4d, 0x75, 0x3c, 0x5f, 0x86, 0x86, 0x8b, 0x6a, 0xb9, 0xf7, 0xa6, 0x9e, 0x3f, 0x55, 0x5c,
-	0xfb, 0xf3, 0xcf, 0xf6, 0x7b, 0x6, 0xe1, 0x7f, 0xe6, 0xd, 0xf5, 0x1a, 0xff, 0x0, 0xf2, 0x8e, 0xa8, 0xff, 0x0, 0xf5, 0x66,
-	0x23, 0xff, 0x0, 0xeb, 0x7, 0x3e, 0x7c, 0xbe, 0xf3, 0x5f, 0xbd, 0x3c, 0xe1, 0xdd, 0x75, 0x8d, 0xfb, 0xbe, 0x72, 0x3a, 0xe6,
-	0x47, 0x61, 0xd4, 0x75, 0x7f, 0xe8, 0x7e, 0x1a, 0x4d, 0x6b, 0x5d, 0xb6, 0xd6, 0xed, 0x23, 0xc3, 0x7e, 0xd6, 0xc8, 0x66, 0xbe,
-	0x13, 0xda, 0xda, 0xcb, 0x2d, 0x33, 0xdc, 0x7e, 0x3b, 0x27, 0x2f, 0x3f, 0x73, 0x9e, 0x7d, 0xfe, 0x3e, 0xdc, 0x7f, 0x90, 0x35,
-	0x28, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0,
-	0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff,
-	0xd1, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7,
-	0xff, 0xd2, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x7, 0xff, 0xd3, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x7, 0xff, 0xd4, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x7, 0xff, 0xd5, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x7, 0xff, 0xd6, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd7, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd1, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd2, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd3, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd4, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd5, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd6, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd7, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0, 0xaf, 0xfc, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd1, 0xaf, 0xfc, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd2, 0xaf, 0xfc, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd3, 0xaf, 0xfc,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd4, 0xaf,
-	0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd5,
-	0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff,
-	0xd6, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7,
-	0xff, 0xd7, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x7, 0xff, 0xd0, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x7, 0xff, 0xd1, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x7, 0xff, 0xd2, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x7, 0xff, 0xd9
-};

src/device.c

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
@@ -19,6 +20,8 @@
 *****************************************************************************/
 
 
+#include "device.h"
+
 #include <stdlib.h>
 #include <stddef.h>
 #include <stdbool.h>
@@ -26,14 +29,16 @@
 #include <strings.h>
 #include <unistd.h>
 #include <fcntl.h>
+#include <errno.h>
+#include <assert.h>
 
+#include <sys/select.h>
 #include <sys/mman.h>
 #include <linux/videodev2.h>
 
 #include "tools.h"
 #include "logging.h"
 #include "xioctl.h"
-#include "device.h"
 
 
 static const struct {
@@ -53,6 +58,9 @@ static const struct {
 	{"YUYV",	V4L2_PIX_FMT_YUYV},
 	{"UYVY",	V4L2_PIX_FMT_UYVY},
 	{"RGB565",	V4L2_PIX_FMT_RGB565},
+	{"RGB24",	V4L2_PIX_FMT_RGB24},
+	{"JPEG",	V4L2_PIX_FMT_MJPEG},
+	{"JPEG",	V4L2_PIX_FMT_JPEG},
 };
 
 
@@ -60,18 +68,30 @@ static int _device_open_check_cap(struct device_t *dev);
 static int _device_open_dv_timings(struct device_t *dev);
 static int _device_apply_dv_timings(struct device_t *dev);
 static int _device_open_format(struct device_t *dev);
-static void _device_open_alloc_picbufs(struct device_t *dev);
+static void _device_open_hw_fps(struct device_t *dev);
 static int _device_open_mmap(struct device_t *dev);
 static int _device_open_queue_buffers(struct device_t *dev);
+static void _device_open_alloc_picbufs(struct device_t *dev);
+static int _device_apply_resolution(struct device_t *dev, unsigned width, unsigned height);
+static void _device_apply_controls(struct device_t *dev);
+static int _device_check_control(struct device_t *dev, const char *name, unsigned cid, int value, bool quiet);
+static void _device_set_control(struct device_t *dev, const char *name, unsigned cid, int value, bool quiet);
 
-static const char *_format_to_string_auto(char *buf, const size_t size, const unsigned format);
-static const char *_format_to_string_null(const unsigned format);
-static const char *_standard_to_string(const v4l2_std_id standard);
+static const char *_format_to_string_fourcc(char *buf, size_t size, unsigned format);
+static const char *_format_to_string_nullable(unsigned format);
+static const char *_format_to_string_supported(unsigned format);
+static const char *_standard_to_string(v4l2_std_id standard);
 
 
-struct device_t *device_init() {
+struct device_t *device_init(void) {
 	struct device_runtime_t *run;
 	struct device_t *dev;
+	long cores_sysconf;
+	unsigned cores_available;
+
+	cores_sysconf = sysconf(_SC_NPROCESSORS_ONLN);
+	cores_sysconf = (cores_sysconf < 0 ? 0 : cores_sysconf);
+	cores_available = max_u(min_u(cores_sysconf, 4), 1);
 
 	A_CALLOC(run, 1);
 	run->fd = -1;
@@ -82,9 +102,8 @@ struct device_t *device_init() {
 	dev->height = 480;
 	dev->format = V4L2_PIX_FMT_YUYV;
 	dev->standard = V4L2_STD_UNKNOWN;
-	dev->n_buffers = max_u(sysconf(_SC_NPROCESSORS_ONLN), 1) + 1;
-	dev->n_workers = dev->n_buffers;
-	dev->soft_fps = 30;
+	dev->n_buffers = cores_available + 1;
+	dev->n_workers = min_u(cores_available, dev->n_buffers);
 	dev->timeout = 1;
 	dev->error_delay = 1;
 	dev->run = run;
@@ -96,8 +115,8 @@ void device_destroy(struct device_t *dev) {
 	free(dev);
 }
 
-int device_parse_format(const char *const str) {
-	for (unsigned index = 0; index < sizeof(_FORMATS) / sizeof(_FORMATS[0]); ++index) {
+int device_parse_format(const char *str) {
+	for (unsigned index = 0; index < ARRAY_LEN(_FORMATS); ++index) {
 		if (!strcasecmp(str, _FORMATS[index].name)) {
 			return _FORMATS[index].format;
 		}
@@ -105,8 +124,8 @@ int device_parse_format(const char *const str) {
 	return FORMAT_UNKNOWN;
 }
 
-v4l2_std_id device_parse_standard(const char *const str) {
-	for (unsigned index = 1; index < sizeof(_STANDARDS) / sizeof(_STANDARDS[0]); ++index) {
+v4l2_std_id device_parse_standard(const char *str) {
+	for (unsigned index = 1; index < ARRAY_LEN(_STANDARDS); ++index) {
 		if (!strcasecmp(str, _STANDARDS[index].name)) {
 			return _STANDARDS[index].standard;
 		}
@@ -130,6 +149,7 @@ int device_open(struct device_t *dev) {
 	if (_device_open_format(dev) < 0) {
 		goto error;
 	}
+	_device_open_hw_fps(dev);
 	if (_device_open_mmap(dev) < 0) {
 		goto error;
 	}
@@ -137,6 +157,9 @@ int device_open(struct device_t *dev) {
 		goto error;
 	}
 	_device_open_alloc_picbufs(dev);
+	_device_apply_controls(dev);
+
+	dev->run->n_workers = min_u(dev->run->n_buffers, dev->n_workers);
 
 	LOG_DEBUG("Device fd=%d initialized", dev->run->fd);
 	return 0;
@@ -147,6 +170,8 @@ int device_open(struct device_t *dev) {
 }
 
 void device_close(struct device_t *dev) {
+	dev->run->n_workers = 0;
+
 	if (dev->run->pictures) {
 		LOG_DEBUG("Releasing picture buffers ...");
 		for (unsigned index = 0; index < dev->run->n_buffers && dev->run->pictures[index].data; ++index) {
@@ -160,11 +185,15 @@ void device_close(struct device_t *dev) {
 	if (dev->run->hw_buffers) {
 		LOG_DEBUG("Unmapping HW buffers ...");
 		for (unsigned index = 0; index < dev->run->n_buffers; ++index) {
-			if (dev->run->hw_buffers[index].start != MAP_FAILED) {
-				if (munmap(dev->run->hw_buffers[index].start, dev->run->hw_buffers[index].length) < 0) {
-					LOG_PERROR("Can't unmap device buffer %d", index);
+#			define HW_BUFFER(_next) dev->run->hw_buffers[index]._next
+
+			if (HW_BUFFER(allocated) > 0 && HW_BUFFER(data) != MAP_FAILED) {
+				if (munmap(HW_BUFFER(data), HW_BUFFER(allocated)) < 0) {
+					LOG_PERROR("Can't unmap device buffer %u", index);
 				}
 			}
+
+#			undef HW_BUFFER
 		}
 		dev->run->n_buffers = 0;
 		free(dev->run->hw_buffers);
@@ -182,6 +211,111 @@ void device_close(struct device_t *dev) {
 	}
 }
 
+int device_switch_capturing(struct device_t *dev, bool enable) {
+	if (enable != dev->run->capturing) {
+		enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+		LOG_DEBUG("Calling ioctl(%s) ...", (enable ? "VIDIOC_STREAMON" : "VIDIOC_STREAMOFF"));
+		if (xioctl(dev->run->fd, (enable ? VIDIOC_STREAMON : VIDIOC_STREAMOFF), &type) < 0) {
+			LOG_PERROR("Unable to %s capturing", (enable ? "start" : "stop"));
+			if (enable) {
+				return -1;
+			}
+		}
+
+		dev->run->capturing = enable;
+		LOG_INFO("Capturing %s", (enable ? "started" : "stopped"));
+	}
+    return 0;
+}
+
+int device_select(struct device_t *dev, bool *has_read, bool *has_write, bool *has_error) {
+	struct timeval timeout;
+	int retval;
+
+#	define INIT_FD_SET(_set) \
+		fd_set _set; FD_ZERO(&_set); FD_SET(dev->run->fd, &_set);
+
+	INIT_FD_SET(read_fds);
+	INIT_FD_SET(write_fds);
+	INIT_FD_SET(error_fds);
+
+#	undef INIT_FD_SET
+
+	timeout.tv_sec = dev->timeout;
+	timeout.tv_usec = 0;
+
+	LOG_DEBUG("Calling select() on video device ...");
+
+	retval = select(dev->run->fd + 1, &read_fds, &write_fds, &error_fds, &timeout);
+	if (retval > 0) {
+		*has_read = FD_ISSET(dev->run->fd, &read_fds);
+		*has_write = FD_ISSET(dev->run->fd, &write_fds);
+		*has_error = FD_ISSET(dev->run->fd, &error_fds);
+	} else {
+		has_read = false;
+		has_write = false;
+		has_error = false;
+	}
+
+	LOG_DEBUG("Device select() --> %d", retval);
+	return retval;
+}
+
+int device_grab_buffer(struct device_t *dev) {
+	struct v4l2_buffer buf_info;
+
+	MEMSET_ZERO(buf_info);
+	buf_info.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+	buf_info.memory = V4L2_MEMORY_MMAP;
+
+	LOG_DEBUG("Calling ioctl(VIDIOC_DQBUF) ...");
+	if (xioctl(dev->run->fd, VIDIOC_DQBUF, &buf_info) < 0) {
+		LOG_PERROR("Unable to dequeue buffer");
+		return -1;
+	}
+
+	LOG_DEBUG("Got a new frame in buffer: index=%u, bytesused=%u", buf_info.index, buf_info.bytesused);
+	if (buf_info.index >= dev->run->n_buffers) {
+		LOG_ERROR("Got invalid buffer: index=%u, nbuffers=%u", buf_info.index, dev->run->n_buffers);
+		return -1;
+	}
+
+	dev->run->hw_buffers[buf_info.index].used = buf_info.bytesused;
+	memcpy(&dev->run->hw_buffers[buf_info.index].buf_info, &buf_info, sizeof(struct v4l2_buffer));
+	dev->run->pictures[buf_info.index].grab_time = get_now_monotonic();
+	return buf_info.index;
+}
+
+int device_release_buffer(struct device_t *dev, unsigned index) {
+	LOG_DEBUG("Calling ioctl(VIDIOC_QBUF) ...");
+	if (xioctl(dev->run->fd, VIDIOC_QBUF, &dev->run->hw_buffers[index].buf_info) < 0) {
+		LOG_PERROR("Unable to requeue buffer");
+		return -1;
+	}
+	dev->run->hw_buffers[index].used = 0;
+	return 0;
+}
+
+int device_consume_event(struct device_t *dev) {
+	struct v4l2_event event;
+
+	LOG_DEBUG("Calling ioctl(VIDIOC_DQEVENT) ...");
+	if (xioctl(dev->run->fd, VIDIOC_DQEVENT, &event) == 0) {
+		switch (event.type) {
+			case V4L2_EVENT_SOURCE_CHANGE:
+				LOG_INFO("Got V4L2_EVENT_SOURCE_CHANGE: source changed");
+				return -1;
+			case V4L2_EVENT_EOS:
+				LOG_INFO("Got V4L2_EVENT_EOS: end of stream (ignored)");
+				return 0;
+		}
+	} else {
+		LOG_PERROR("Got some V4L2 device event, but where is it? ");
+	}
+	return 0;
+}
+
 static int _device_open_check_cap(struct device_t *dev) {
 	struct v4l2_capability cap;
 	int input = dev->input; // Needs pointer to int for ioctl()
@@ -195,7 +329,7 @@ static int _device_open_check_cap(struct device_t *dev) {
 	}
 
 	if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
-		LOG_ERROR("Video capture not supported by our device");
+		LOG_ERROR("Video capture not supported by the device");
 		return -1;
 	}
 
@@ -223,8 +357,9 @@ static int _device_open_check_cap(struct device_t *dev) {
 }
 
 static int _device_open_dv_timings(struct device_t *dev) {
+	_device_apply_resolution(dev, dev->width, dev->height);
 	if (dev->dv_timings) {
-		LOG_DEBUG("Using DV-timings");
+		LOG_DEBUG("Using DV timings");
 
 		if (_device_apply_dv_timings(dev) < 0) {
 			return -1;
@@ -240,36 +375,29 @@ static int _device_open_dv_timings(struct device_t *dev) {
 			LOG_PERROR("Can't subscribe to V4L2_EVENT_SOURCE_CHANGE");
 			return -1;
 		}
-
-	} else {
-		dev->run->width = dev->width;
-		dev->run->height = dev->height;
 	}
 	return 0;
 }
 
 static int _device_apply_dv_timings(struct device_t *dev) {
-	struct v4l2_dv_timings dv_timings;
+	struct v4l2_dv_timings dv;
 
-	MEMSET_ZERO(dv_timings);
+	MEMSET_ZERO(dv);
 
 	LOG_DEBUG("Calling ioctl(VIDIOC_QUERY_DV_TIMINGS) ...");
-	if (xioctl(dev->run->fd, VIDIOC_QUERY_DV_TIMINGS, &dv_timings) == 0) {
-		LOG_INFO(
-			"Got new DV timings: resolution=%dx%d; pixclk=%llu",
-			dv_timings.bt.width,
-			dv_timings.bt.height,
-			dv_timings.bt.pixelclock
-		);
+	if (xioctl(dev->run->fd, VIDIOC_QUERY_DV_TIMINGS, &dv) == 0) {
+		LOG_INFO("Got new DV timings: resolution=%ux%u, pixclk=%llu",
+			dv.bt.width, dv.bt.height, dv.bt.pixelclock);
 
 		LOG_DEBUG("Calling ioctl(VIDIOC_S_DV_TIMINGS) ...");
-		if (xioctl(dev->run->fd, VIDIOC_S_DV_TIMINGS, &dv_timings) < 0) {
+		if (xioctl(dev->run->fd, VIDIOC_S_DV_TIMINGS, &dv) < 0) {
 			LOG_PERROR("Failed to set DV timings");
 			return -1;
 		}
 
-		dev->run->width = dv_timings.bt.width;
-		dev->run->height = dv_timings.bt.height;
+		if (_device_apply_resolution(dev, dv.bt.width, dv.bt.height) < 0) {
+			return -1;
+		}
 
 	} else {
 		LOG_DEBUG("Calling ioctl(VIDIOC_QUERYSTD) ...");
@@ -297,52 +425,87 @@ static int _device_open_format(struct device_t *dev) {
 	// Set format
 	LOG_DEBUG("Calling ioctl(VIDIOC_S_FMT) ...");
 	if (xioctl(dev->run->fd, VIDIOC_S_FMT, &fmt) < 0) {
-		char format_str[8];
-
-		LOG_PERROR(
-			"Unable to set format=%s; resolution=%dx%d",
-			_format_to_string_auto(format_str, 8, dev->format),
+		LOG_PERROR("Unable to set pixelformat=%s, resolution=%ux%u",
+			_format_to_string_supported(dev->format),
 			dev->run->width,
-			dev->run->height
-		);
+			dev->run->height);
 		return -1;
 	}
 
 	// Check resolution
 	if (fmt.fmt.pix.width != dev->run->width || fmt.fmt.pix.height != dev->run->height) {
-		LOG_ERROR("Requested resolution=%dx%d is unavailable", dev->run->width, dev->run->height);
+		LOG_ERROR("Requested resolution=%ux%u is unavailable", dev->run->width, dev->run->height);
 	}
-	dev->run->width = fmt.fmt.pix.width;
-	dev->run->height = fmt.fmt.pix.height;
-	LOG_INFO("Using resolution: %dx%d", dev->run->width, dev->run->height);
+	if (_device_apply_resolution(dev, fmt.fmt.pix.width, fmt.fmt.pix.height) < 0) {
+		return -1;
+	}
+	LOG_INFO("Using resolution: %ux%u", dev->run->width, dev->run->height);
 
 	// Check format
 	if (fmt.fmt.pix.pixelformat != dev->format) {
-		char format_requested_str[8];
 		char format_obtained_str[8];
 		char *format_str_nullable;
 
-		LOG_ERROR(
-			"Could not obtain the requested pixelformat=%s; driver gave us %s",
-			_format_to_string_auto(format_requested_str, 8, dev->format),
-			_format_to_string_auto(format_obtained_str, 8, fmt.fmt.pix.pixelformat)
-		);
+		LOG_ERROR("Could not obtain the requested pixelformat=%s; driver gave us %s",
+			_format_to_string_supported(dev->format),
+			_format_to_string_supported(fmt.fmt.pix.pixelformat));
 
-		if ((format_str_nullable = (char *)_format_to_string_null(fmt.fmt.pix.pixelformat)) != NULL) {
-			LOG_INFO(
-				"Falling back to %s mode (consider using '--format=%s' option)",
-				format_str_nullable,
-				format_str_nullable
-			);
+		if ((format_str_nullable = (char *)_format_to_string_nullable(fmt.fmt.pix.pixelformat)) != NULL) {
+			LOG_INFO("Falling back to pixelformat=%s", format_str_nullable);
 		} else {
-			LOG_ERROR("Unsupported pixel format");
+			LOG_ERROR("Unsupported pixelformat=%s (fourcc)",
+				_format_to_string_fourcc(format_obtained_str, 8, fmt.fmt.pix.pixelformat));
 			return -1;
 		}
 	}
+
 	dev->run->format = fmt.fmt.pix.pixelformat;
+	LOG_INFO("Using pixelformat: %s", _format_to_string_supported(dev->run->format));
 	return 0;
 }
 
+static void _device_open_hw_fps(struct device_t *dev) {
+	struct v4l2_streamparm setfps;
+
+	MEMSET_ZERO(setfps);
+	setfps.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+	LOG_DEBUG("Calling ioctl(VIDIOC_G_PARM) ...");
+	if (xioctl(dev->run->fd, VIDIOC_G_PARM, &setfps) < 0) {
+		if (errno == ENOTTY) { // Quiet message for Auvidea B101
+			LOG_INFO("Quierying HW FPS changing is not supported");
+		} else {
+			LOG_PERROR("Unable to query HW FPS changing");
+		}
+		return;
+	}
+
+	if (!(setfps.parm.capture.capability & V4L2_CAP_TIMEPERFRAME)) {
+		LOG_INFO("Changing HW FPS is not supported");
+		return;
+	}
+
+#	define SETFPS_TPF(_next) setfps.parm.capture.timeperframe._next
+
+	MEMSET_ZERO(setfps);
+	setfps.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+	SETFPS_TPF(numerator) = 1;
+	SETFPS_TPF(denominator) = (dev->desired_fps == 0 ? 255 : dev->desired_fps);
+
+	if (xioctl(dev->run->fd, VIDIOC_S_PARM, &setfps) < 0) {
+		LOG_PERROR("Unable to set HW FPS");
+		return;
+	}
+
+	if (dev->desired_fps != SETFPS_TPF(denominator)) {
+		LOG_INFO("Using HW FPS: %u -> %u (coerced)", dev->desired_fps, SETFPS_TPF(denominator));
+	} else {
+		LOG_INFO("Using HW FPS: %u", dev->desired_fps);
+	}
+
+#	undef SETFPS_TPF
+}
+
 static int _device_open_mmap(struct device_t *dev) {
 	struct v4l2_requestbuffers req;
 
@@ -352,16 +515,16 @@ static int _device_open_mmap(struct device_t *dev) {
 	req.memory = V4L2_MEMORY_MMAP;
 
 	LOG_DEBUG("Calling ioctl(VIDIOC_REQBUFS) ...");
-	if (xioctl(dev->run->fd, VIDIOC_REQBUFS, &req)) {
+	if (xioctl(dev->run->fd, VIDIOC_REQBUFS, &req) < 0) {
 		LOG_PERROR("Device '%s' doesn't support memory mapping", dev->path);
 		return -1;
 	}
 
 	if (req.count < 1) {
-		LOG_ERROR("Insufficient buffer memory: %d", req.count);
+		LOG_ERROR("Insufficient buffer memory: %u", req.count);
 		return -1;
 	} else {
-		LOG_INFO("Requested %d HW buffers, got %d", dev->n_buffers, req.count);
+		LOG_INFO("Requested %u HW buffers, got %u", dev->n_buffers, req.count);
 	}
 
 	LOG_DEBUG("Allocating HW buffers ...");
@@ -375,19 +538,23 @@ static int _device_open_mmap(struct device_t *dev) {
 		buf_info.memory = V4L2_MEMORY_MMAP;
 		buf_info.index = dev->run->n_buffers;
 
-		LOG_DEBUG("Calling ioctl(VIDIOC_QUERYBUF) for device buffer %d ...", dev->run->n_buffers);
+		LOG_DEBUG("Calling ioctl(VIDIOC_QUERYBUF) for device buffer %u ...", dev->run->n_buffers);
 		if (xioctl(dev->run->fd, VIDIOC_QUERYBUF, &buf_info) < 0) {
 			LOG_PERROR("Can't VIDIOC_QUERYBUF");
 			return -1;
 		}
 
-		LOG_DEBUG("Mapping device buffer %d ...", dev->run->n_buffers);
-		dev->run->hw_buffers[dev->run->n_buffers].length = buf_info.length;
-		dev->run->hw_buffers[dev->run->n_buffers].start = mmap(NULL, buf_info.length, PROT_READ|PROT_WRITE, MAP_SHARED, dev->run->fd, buf_info.m.offset);
-		if (dev->run->hw_buffers[dev->run->n_buffers].start == MAP_FAILED) {
-			LOG_PERROR("Can't map device buffer %d", dev->run->n_buffers);
+#		define HW_BUFFER(_next) dev->run->hw_buffers[dev->run->n_buffers]._next
+
+		LOG_DEBUG("Mapping device buffer %u ...", dev->run->n_buffers);
+		HW_BUFFER(data) = mmap(NULL, buf_info.length, PROT_READ|PROT_WRITE, MAP_SHARED, dev->run->fd, buf_info.m.offset);
+		if (HW_BUFFER(data) == MAP_FAILED) {
+			LOG_PERROR("Can't map device buffer %u", dev->run->n_buffers);
 			return -1;
 		}
+		HW_BUFFER(allocated) = buf_info.length;
+
+#		undef HW_BUFFER
 	}
 	return 0;
 }
@@ -401,7 +568,7 @@ static int _device_open_queue_buffers(struct device_t *dev) {
 		buf_info.memory = V4L2_MEMORY_MMAP;
 		buf_info.index = index;
 
-		LOG_DEBUG("Calling ioctl(VIDIOC_QBUF) for buffer %d ...", index);
+		LOG_DEBUG("Calling ioctl(VIDIOC_QBUF) for buffer %u ...", index);
 		if (xioctl(dev->run->fd, VIDIOC_QBUF, &buf_info) < 0) {
 			LOG_PERROR("Can't VIDIOC_QBUF");
 			return -1;
@@ -414,20 +581,109 @@ static void _device_open_alloc_picbufs(struct device_t *dev) {
 	LOG_DEBUG("Allocating picture buffers ...");
 	A_CALLOC(dev->run->pictures, dev->run->n_buffers);
 
-	dev->run->max_picture_size = ((dev->run->width * dev->run->height) << 1) * 2;
+	dev->run->max_raw_image_size = ((dev->run->width * dev->run->height) << 1) * 2;
 	for (unsigned index = 0; index < dev->run->n_buffers; ++index) {
-		LOG_DEBUG("Allocating picture buffer %d sized %lu bytes... ", index, dev->run->max_picture_size);
-		A_CALLOC(dev->run->pictures[index].data, dev->run->max_picture_size);
-		dev->run->pictures[index].allocated = dev->run->max_picture_size;
+		LOG_DEBUG("Allocating picture buffer %u sized %zu bytes... ", index, dev->run->max_raw_image_size);
+		A_CALLOC(dev->run->pictures[index].data, dev->run->max_raw_image_size);
+		dev->run->pictures[index].allocated = dev->run->max_raw_image_size;
 	}
 }
 
-static const char *_format_to_string_auto(char *buf, const size_t size, const unsigned format) {
+static int _device_apply_resolution(struct device_t *dev, unsigned width, unsigned height) {
+	// Тут VIDEO_MIN_* не используются из-за странностей минимального разрешения при отсутствии сигнала
+	// у некоторых устройств, например Auvidea B101
+	if (
+		width == 0 || width > VIDEO_MAX_WIDTH
+		|| height == 0 || height > VIDEO_MAX_HEIGHT
+	) {
+		LOG_ERROR("Requested forbidden resolution=%ux%u: min=1x1, max=%ux%u",
+			width, height, VIDEO_MAX_WIDTH, VIDEO_MAX_HEIGHT);
+		return -1;
+	}
+	dev->run->width = width;
+	dev->run->height = height;
+	return 0;
+}
+
+static void _device_apply_controls(struct device_t *dev) {
+#	define SET_CID(_cid, _dest, _value, _quiet) { \
+			if (_device_check_control(dev, #_dest, _cid, _value, _quiet) == 0) { \
+				_device_set_control(dev, #_dest, _cid, _value, _quiet); \
+			} \
+		}
+
+#	define SET_CID_MANUAL(_cid, _dest) { \
+			if (dev->ctl._dest.value_set) { \
+				SET_CID(_cid, _dest, dev->ctl._dest.value, false); \
+			} \
+		}
+
+#	define SET_CID_AUTO(_cid_auto, _cid_manual, _dest) { \
+			if (dev->ctl._dest.value_set || dev->ctl._dest.auto_set) { \
+				SET_CID(_cid_auto, _dest##_auto, dev->ctl._dest.auto_set, dev->ctl._dest.value_set); \
+				SET_CID_MANUAL(_cid_manual, _dest); \
+			} \
+		}
+
+	SET_CID_AUTO	(V4L2_CID_AUTOBRIGHTNESS,		V4L2_CID_BRIGHTNESS,				brightness);
+	SET_CID_MANUAL	(								V4L2_CID_CONTRAST,					contrast);
+	SET_CID_MANUAL	(								V4L2_CID_SATURATION,				saturation);
+	SET_CID_AUTO	(V4L2_CID_HUE_AUTO,				V4L2_CID_HUE,						hue);
+	SET_CID_MANUAL	(								V4L2_CID_GAMMA,						gamma);
+	SET_CID_MANUAL	(								V4L2_CID_SHARPNESS,					sharpness);
+	SET_CID_MANUAL	(								V4L2_CID_BACKLIGHT_COMPENSATION,	backlight_compensation);
+	SET_CID_AUTO	(V4L2_CID_AUTO_WHITE_BALANCE,	V4L2_CID_WHITE_BALANCE_TEMPERATURE,	white_balance);
+	SET_CID_AUTO	(V4L2_CID_AUTOGAIN,				V4L2_CID_GAIN,						gain);
+
+#	undef SET_CID_AUTO
+#	undef SET_CID_MANUAL
+#	undef SET_CID
+}
+
+static int _device_check_control(struct device_t *dev, const char *name, unsigned cid, int value, bool quiet) {
+	struct v4l2_queryctrl query;
+
+	MEMSET_ZERO(query);
+	query.id = cid;
+
+	if (xioctl(dev->run->fd, VIDIOC_QUERYCTRL, &query) < 0 || query.flags & V4L2_CTRL_FLAG_DISABLED) {
+		if (!quiet) {
+			LOG_ERROR("Changing control %s is unsupported", name);
+		}
+		return -1;
+	}
+	if (value < query.minimum || value > query.maximum || value % query.step != 0) {
+		if (!quiet) {
+			LOG_ERROR("Invalid value %d of control %s: min=%d, max=%d, default=%d, step=%u",
+				value, name, query.minimum, query.maximum, query.default_value, query.step);
+		}
+		return -2;
+	}
+	return 0;
+}
+
+static void _device_set_control(struct device_t *dev, const char *name, unsigned cid, int value, bool quiet) {
+	struct v4l2_control ctl;
+
+	MEMSET_ZERO(ctl);
+	ctl.id = cid;
+	ctl.value = value;
+
+	if (xioctl(dev->run->fd, VIDIOC_S_CTRL, &ctl) < 0) {
+		if (!quiet) {
+			LOG_PERROR("Can't set control %s", name);
+		}
+	} else if (!quiet) {
+		LOG_INFO("Using control %s: %d", name, ctl.value);
+	}
+}
+
+static const char *_format_to_string_fourcc(char *buf, size_t size, unsigned format) {
 	assert(size >= 8);
-	buf[0] = format & 0x7f;
-	buf[1] = (format >> 8) & 0x7f;
-	buf[2] = (format >> 16) & 0x7f;
-	buf[3] = (format >> 24) & 0x7f;
+	buf[0] = format & 0x7F;
+	buf[1] = (format >> 8) & 0x7F;
+	buf[2] = (format >> 16) & 0x7F;
+	buf[3] = (format >> 24) & 0x7F;
 	if (format & (1 << 31)) {
 		buf[4] = '-';
 		buf[5] = 'B';
@@ -439,8 +695,8 @@ static const char *_format_to_string_auto(char *buf, const size_t size, const un
 	return buf;
 }
 
-static const char *_format_to_string_null(const unsigned format) {
-    for (unsigned index = 0; index < sizeof(_FORMATS) / sizeof(_FORMATS[0]); ++index) {
+static const char *_format_to_string_nullable(unsigned format) {
+    for (unsigned index = 0; index < ARRAY_LEN(_FORMATS); ++index) {
 		if (format == _FORMATS[index].format) {
 			return _FORMATS[index].name;
 		}
@@ -448,8 +704,13 @@ static const char *_format_to_string_null(const unsigned format) {
     return NULL;
 }
 
+static const char *_format_to_string_supported(unsigned format) {
+	const char *format_str = _format_to_string_nullable(format);
+	return (format_str == NULL ? "unsupported" : format_str);
+}
+
 static const char *_standard_to_string(v4l2_std_id standard) {
-	for (unsigned index = 0; index < sizeof(_STANDARDS) / sizeof(_STANDARDS[0]); ++index) {
+	for (unsigned index = 0; index < ARRAY_LEN(_STANDARDS); ++index) {
 		if (standard == _STANDARDS[index].standard) {
 			return _STANDARDS[index].name;
 		}

src/device.h

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
@@ -23,27 +24,36 @@
 
 #include <stddef.h>
 #include <stdbool.h>
-#include <signal.h>
 
 #include <linux/videodev2.h>
 
 
+#define VIDEO_MIN_WIDTH		160
+#define VIDEO_MAX_WIDTH		10240
+
+#define VIDEO_MIN_HEIGHT	120
+#define VIDEO_MAX_HEIGHT	4320
+
+#define VIDEO_MAX_FPS		120
+
 #define STANDARD_UNKNOWN	V4L2_STD_UNKNOWN
-#define STANDARDS_STR		"UNKNOWN, PAL, NTSC, SECAM"
+#define STANDARDS_STR		"PAL, NTSC, SECAM"
 
 #define FORMAT_UNKNOWN	-1
-#define FORMATS_STR		"YUYV, UYVY, RGB565"
+#define FORMATS_STR		"YUYV, UYVY, RGB565, RGB24, JPEG"
 
 
 struct hw_buffer_t {
-	void	*start;
-	size_t	length;
+	unsigned char		*data;
+	size_t				used;
+	size_t				allocated;
+	struct v4l2_buffer	buf_info;
 };
 
 struct picture_t {
 	unsigned char	*data;
-	unsigned long	size;
-	unsigned long	allocated;
+	size_t			used;
+	size_t			allocated;
 	long double		grab_time;
 	long double		encode_begin_time;
 	long double		encode_end_time;
@@ -58,10 +68,28 @@ struct device_runtime_t {
 	unsigned			n_workers;
 	struct hw_buffer_t	*hw_buffers;
 	struct picture_t	*pictures;
-	unsigned long		max_picture_size;
+	size_t				max_raw_image_size;
 	bool				capturing;
 };
 
+struct control_t {
+	int		value;
+	bool	value_set;
+	bool	auto_set;
+};
+
+struct controls_t {
+	struct control_t brightness;
+	struct control_t contrast;
+	struct control_t saturation;
+	struct control_t hue;
+	struct control_t gamma;
+	struct control_t sharpness;
+	struct control_t backlight_compensation;
+	struct control_t white_balance;
+	struct control_t gain;
+};
+
 struct device_t {
 	char			*path;
 	unsigned		input;
@@ -72,23 +100,29 @@ struct device_t {
 	bool			dv_timings;
 	unsigned		n_buffers;
 	unsigned		n_workers;
-	unsigned		soft_fps;
-	unsigned		every_frame;
-	unsigned		min_frame_size;
+	unsigned		desired_fps;
+	size_t			min_frame_size;
 	bool			persistent;
 	unsigned		timeout;
 	unsigned		error_delay;
 
+	struct controls_t ctl;
+
 	struct device_runtime_t *run;
-	sig_atomic_t volatile stop;
 };
 
 
-struct device_t *device_init();
+struct device_t *device_init(void);
 void device_destroy(struct device_t *dev);
 
-int device_parse_format(const char *const str);
-v4l2_std_id device_parse_standard(const char *const str);
+int device_parse_format(const char *str);
+v4l2_std_id device_parse_standard(const char *str);
 
 int device_open(struct device_t *dev);
 void device_close(struct device_t *dev);
+
+int device_switch_capturing(struct device_t *dev, bool enable);
+int device_select(struct device_t *dev, bool *has_read, bool *has_write, bool *has_error);
+int device_grab_buffer(struct device_t *dev);
+int device_release_buffer(struct device_t *dev, unsigned index);
+int device_consume_event(struct device_t *dev);

src/encoder.c

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
@@ -19,18 +20,23 @@
 *****************************************************************************/
 
 
+#include "encoder.h"
+
+#include <stdbool.h>
 #include <strings.h>
 #include <assert.h>
 
+#include <linux/videodev2.h>
+
 #include "tools.h"
 #include "logging.h"
 #include "device.h"
-#include "encoder.h"
 
-#include "jpeg/encoder.h"
+#include "encoders/cpu/encoder.h"
+#include "encoders/hw/encoder.h"
 
-#ifdef OMX_ENCODER
-#	include "omx/encoder.h"
+#ifdef WITH_OMX
+#	include "encoders/omx/encoder.h"
 #endif
 
 
@@ -39,80 +45,47 @@ static const struct {
 	const enum encoder_type_t type;
 } _ENCODER_TYPES[] = {
 	{"CPU",	ENCODER_TYPE_CPU},
-#	ifdef OMX_ENCODER
+	{"HW",	ENCODER_TYPE_HW},
+#	ifdef WITH_OMX
 	{"OMX",	ENCODER_TYPE_OMX},
 #	endif
 };
 
 
-struct encoder_t *encoder_init() {
+struct encoder_t *encoder_init(void) {
+	struct encoder_runtime_t *run;
 	struct encoder_t *encoder;
 
+	A_CALLOC(run, 1);
+	run->type = ENCODER_TYPE_CPU;
+	run->quality = 80;
+	A_MUTEX_INIT(&run->mutex);
+
 	A_CALLOC(encoder, 1);
-	encoder->type = ENCODER_TYPE_CPU;
-	encoder->quality = 80;
+	encoder->type = run->type;
+	encoder->quality = run->quality;
+	encoder->run = run;
 	return encoder;
 }
 
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#pragma GCC diagnostic push
-void encoder_prepare(struct encoder_t *encoder, struct device_t *dev) {
-#pragma GCC diagnostic pop
-
-	assert(encoder->type != ENCODER_TYPE_UNKNOWN);
-
-	if (encoder->type != ENCODER_TYPE_CPU) {
-		LOG_DEBUG("Initializing encoder ...");
-	}
-
-	LOG_INFO("Using JPEG quality: %d%%", encoder->quality);
-
-#	ifdef OMX_ENCODER
-	if (encoder->type == ENCODER_TYPE_OMX) {
-		if (dev->n_workers > OMX_MAX_ENCODERS) {
-			LOG_INFO(
-				"OMX-based encoder can only work with %u worker threads; forced --workers=%u",
-				OMX_MAX_ENCODERS, OMX_MAX_ENCODERS
-			);
-			dev->n_workers = OMX_MAX_ENCODERS;
-		}
-		encoder->n_omxs = dev->n_workers;
-
-		A_CALLOC(encoder->omxs, encoder->n_omxs);
-		for (unsigned index = 0; index < encoder->n_omxs; ++index) {
-			if ((encoder->omxs[index] = omx_encoder_init()) == NULL) {
-				goto use_fallback;
-			}
-		}
-	}
-#	endif
-
-	return;
-
-#	pragma GCC diagnostic ignored "-Wunused-label"
-#	pragma GCC diagnostic push
-	use_fallback:
-		LOG_ERROR("Can't initialize selected encoder, using CPU instead it");
-		encoder->type = ENCODER_TYPE_CPU;
-#	pragma GCC diagnostic pop
-}
-
 void encoder_destroy(struct encoder_t *encoder) {
-#	ifdef OMX_ENCODER
-	if (encoder->omxs) {
-		for (unsigned index = 0; index < encoder->n_omxs; ++index) {
-			if (encoder->omxs[index]) {
-				omx_encoder_destroy(encoder->omxs[index]);
+#	ifdef WITH_OMX
+	if (encoder->run->omxs) {
+		for (unsigned index = 0; index < encoder->run->n_omxs; ++index) {
+			if (encoder->run->omxs[index]) {
+				omx_encoder_destroy(encoder->run->omxs[index]);
 			}
 		}
-		free(encoder->omxs);
+		free(encoder->run->omxs);
 	}
 #	endif
+	A_MUTEX_DESTROY(&encoder->run->mutex);
+	free(encoder->run);
 	free(encoder);
 }
 
-enum encoder_type_t encoder_parse_type(const char *const str) {
-	for (unsigned index = 0; index < sizeof(_ENCODER_TYPES) / sizeof(_ENCODER_TYPES[0]); ++index) {
+enum encoder_type_t encoder_parse_type(const char *str) {
+	for (unsigned index = 0; index < ARRAY_LEN(_ENCODER_TYPES); ++index) {
 		if (!strcasecmp(str, _ENCODER_TYPES[index].name)) {
 			return _ENCODER_TYPES[index].type;
 		}
@@ -120,48 +93,123 @@ enum encoder_type_t encoder_parse_type(const char *const str) {
 	return ENCODER_TYPE_UNKNOWN;
 }
 
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#pragma GCC diagnostic push
-void encoder_prepare_live(struct encoder_t *encoder, struct device_t *dev) {
-	assert(encoder->type != ENCODER_TYPE_UNKNOWN);
+const char *encoder_type_to_string(enum encoder_type_t type) {
+	for (unsigned index = 0; index < ARRAY_LEN(_ENCODER_TYPES); ++index) {
+		if (_ENCODER_TYPES[index].type == type) {
+			return _ENCODER_TYPES[index].name;
+		}
+	}
+	return _ENCODER_TYPES[0].name;
+}
 
-#pragma GCC diagnostic pop
-#	ifdef OMX_ENCODER
-	if (encoder->type == ENCODER_TYPE_OMX) {
-		for (unsigned index = 0; index < encoder->n_omxs; ++index) {
-			if (omx_encoder_prepare_live(encoder->omxs[index], dev, encoder->quality, encoder->omx_use_ijg) < 0) {
-				goto use_fallback;
+void encoder_prepare(struct encoder_t *encoder, struct device_t *dev) {
+	enum encoder_type_t type = (encoder->run->cpu_forced ? ENCODER_TYPE_CPU : encoder->type);
+	unsigned quality = encoder->quality;
+	bool cpu_forced = false;
+
+	if ((dev->run->format == V4L2_PIX_FMT_MJPEG || dev->run->format == V4L2_PIX_FMT_JPEG) && type != ENCODER_TYPE_HW) {
+		LOG_INFO("Switching to HW encoder because the input format is (M)JPEG");
+		type = ENCODER_TYPE_HW;
+	}
+
+	if (type == ENCODER_TYPE_HW) {
+		if (dev->run->format != V4L2_PIX_FMT_MJPEG && dev->run->format != V4L2_PIX_FMT_JPEG) {
+			LOG_INFO("Switching to CPU encoder because the input format is not (M)JPEG");
+			goto use_cpu;
+		}
+
+		if (hw_encoder_prepare(dev, quality) < 0) {
+			quality = 0;
+		}
+
+		dev->run->n_workers = 1;
+	}
+#	ifdef WITH_OMX
+	else if (type == ENCODER_TYPE_OMX) {
+		for (unsigned index = 0; index < encoder->n_glitched_resolutions; ++index) {
+			if (
+				encoder->glitched_resolutions[index][0] == dev->run->width
+				&& encoder->glitched_resolutions[index][1] == dev->run->height
+			) {
+				LOG_INFO("Switching to CPU encoder the resolution %ux%u marked as glitchy for OMX",
+					dev->run->width, dev->run->height);
+				goto use_cpu;
+			}
+		}
+
+		LOG_DEBUG("Preparing OMX encoder ...");
+
+		if (dev->run->n_workers > OMX_MAX_ENCODERS) {
+			LOG_INFO("OMX encoder sets limit for worker threads: %u", OMX_MAX_ENCODERS);
+			dev->run->n_workers = OMX_MAX_ENCODERS;
+		}
+
+		if (encoder->run->omxs == NULL) {
+			A_CALLOC(encoder->run->omxs, OMX_MAX_ENCODERS);
+		}
+
+		// Начинаем с нуля и доинициализируем на следующих заходах при необходимости
+		for (; encoder->run->n_omxs < dev->run->n_workers; ++encoder->run->n_omxs) {
+			if ((encoder->run->omxs[encoder->run->n_omxs] = omx_encoder_init()) == NULL) {
+				LOG_ERROR("Can't initialize OMX encoder, falling back to CPU");
+				goto force_cpu;
+			}
+		}
+
+		for (unsigned index = 0; index < encoder->run->n_omxs; ++index) {
+			if (omx_encoder_prepare(encoder->run->omxs[index], dev, quality) < 0) {
+				LOG_ERROR("Can't prepare OMX encoder, falling back to CPU");
+				goto force_cpu;
 			}
 		}
 	}
 #	endif
 
-	return;
+	goto ok;
 
 #	pragma GCC diagnostic ignored "-Wunused-label"
 #	pragma GCC diagnostic push
-	use_fallback:
-		LOG_ERROR("Can't prepare selected encoder, falling back to CPU");
-		encoder->type = ENCODER_TYPE_CPU;
+	force_cpu:
+		cpu_forced = true;
 #	pragma GCC diagnostic pop
+
+	use_cpu:
+		type = ENCODER_TYPE_CPU;
+		quality = encoder->quality;
+
+	ok:
+		if (quality == 0) {
+			LOG_INFO("Using JPEG quality: encoder default");
+		} else {
+			LOG_INFO("Using JPEG quality: %u%%", quality);
+		}
+
+		A_MUTEX_LOCK(&encoder->run->mutex);
+		encoder->run->type = type;
+		encoder->run->quality = quality;
+		if (cpu_forced) {
+			encoder->run->cpu_forced = true;
+		}
+		A_MUTEX_UNLOCK(&encoder->run->mutex);
 }
 
-#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
 #pragma GCC diagnostic push
-int encoder_compress_buffer(struct encoder_t *encoder, struct device_t *dev,
-	const unsigned worker_number, const unsigned buf_index) {
+int encoder_compress_buffer(struct encoder_t *encoder, struct device_t *dev, unsigned worker_number, unsigned buf_index) {
 #pragma GCC diagnostic pop
 
-	assert(encoder->type != ENCODER_TYPE_UNKNOWN);
+	assert(encoder->run->type != ENCODER_TYPE_UNKNOWN);
 
 	dev->run->pictures[buf_index].encode_begin_time = get_now_monotonic();
 
-	if (encoder->type == ENCODER_TYPE_CPU) {
-		jpeg_encoder_compress_buffer(dev, buf_index, encoder->quality);
+	if (encoder->run->type == ENCODER_TYPE_CPU) {
+		cpu_encoder_compress_buffer(dev, buf_index, encoder->run->quality);
+	} else if (encoder->run->type == ENCODER_TYPE_HW) {
+		hw_encoder_compress_buffer(dev, buf_index);
 	}
-#	ifdef OMX_ENCODER
-	else if (encoder->type == ENCODER_TYPE_OMX) {
-		if (omx_encoder_compress_buffer(encoder->omxs[worker_number], dev, buf_index) < 0) {
+#	ifdef WITH_OMX
+	else if (encoder->run->type == ENCODER_TYPE_OMX) {
+		if (omx_encoder_compress_buffer(encoder->run->omxs[worker_number], dev, buf_index) < 0) {
 			goto error;
 		}
 	}
@@ -174,8 +222,10 @@ int encoder_compress_buffer(struct encoder_t *encoder, struct device_t *dev,
 #	pragma GCC diagnostic ignored "-Wunused-label"
 #	pragma GCC diagnostic push
 	error:
-		LOG_INFO("HW compressing error, falling back to CPU");
-		encoder->type = ENCODER_TYPE_CPU;
+		LOG_INFO("Error while compressing buffer, falling back to CPU");
+		A_MUTEX_LOCK(&encoder->run->mutex);
+		encoder->run->cpu_forced = true;
+		A_MUTEX_UNLOCK(&encoder->run->mutex);
 		return -1;
 #	pragma GCC diagnostic pop
 }

src/encoder.h

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
@@ -21,47 +22,68 @@
 
 #pragma once
 
+#include <stdbool.h>
+
+#include "pthread.h"
+
 #include "tools.h"
 #include "device.h"
 
-#ifdef OMX_ENCODER
-#	include "omx/encoder.h"
+#ifdef WITH_OMX
+#	include "encoders/omx/encoder.h"
+
 #	define ENCODER_TYPES_OMX_HINT ", OMX"
+
+#	ifndef MAX_GLITCHED_RESOLUTIONS
+#		define MAX_GLITCHED_RESOLUTIONS 1024
+#	endif
 #else
 #	define ENCODER_TYPES_OMX_HINT ""
 #endif
 
 
 #define ENCODER_TYPES_STR \
-	"CPU" \
+	"CPU, HW" \
 	ENCODER_TYPES_OMX_HINT
 
 enum encoder_type_t {
 	ENCODER_TYPE_UNKNOWN, // Only for encoder_parse_type() and main()
 	ENCODER_TYPE_CPU,
-#ifdef OMX_ENCODER
+	ENCODER_TYPE_HW,
+#	ifdef WITH_OMX
 	ENCODER_TYPE_OMX,
-#endif
+#	endif
+};
+
+struct encoder_runtime_t {
+	enum encoder_type_t	type;
+	unsigned			quality;
+	bool				cpu_forced;
+	pthread_mutex_t		mutex;
+
+#	ifdef WITH_OMX
+	unsigned				n_omxs;
+	struct omx_encoder_t	**omxs;
+#	endif
 };
 
 struct encoder_t {
-	enum encoder_type_t		type;
-	unsigned				quality;
-#ifdef OMX_ENCODER
-	bool					omx_use_ijg;
-	unsigned				n_omxs;
-	struct omx_encoder_t	**omxs;
-#endif
+	enum encoder_type_t	type;
+	unsigned			quality;
+#	ifdef WITH_OMX
+	unsigned	n_glitched_resolutions;
+	unsigned	glitched_resolutions[2][MAX_GLITCHED_RESOLUTIONS];
+#	endif
+
+	struct encoder_runtime_t *run;
 };
 
 
-struct encoder_t *encoder_init();
+struct encoder_t *encoder_init(void);
 void encoder_destroy(struct encoder_t *encoder);
 
-enum encoder_type_t encoder_parse_type(const char *const str);
+enum encoder_type_t encoder_parse_type(const char *str);
+const char *encoder_type_to_string(enum encoder_type_t type);
 
 void encoder_prepare(struct encoder_t *encoder, struct device_t *dev);
-void encoder_prepare_live(struct encoder_t *encoder, struct device_t *dev);
-
-int encoder_compress_buffer(struct encoder_t *encoder, struct device_t *dev,
-	const unsigned worker_number, const unsigned buf_index);
+int encoder_compress_buffer(struct encoder_t *encoder, struct device_t *dev, unsigned worker_number, unsigned buf_index);

src/encoders/cpu/encoder.c

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    This source file based on code of MJPG-Streamer.                        #
@@ -24,6 +25,8 @@
 *****************************************************************************/
 
 
+#include "encoder.h"
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -32,53 +35,51 @@
 #include <jpeglib.h>
 #include <linux/videodev2.h>
 
-#include "../tools.h"
-#include "../device.h"
-
-#include "encoder.h"
+#include "../../tools.h"
+#include "../../device.h"
 
 
-struct _mjpg_destination_mgr {
-	struct			jpeg_destination_mgr mgr; // Default manager
-	JOCTET			*buffer; // Start of buffer
-	unsigned char	*outbuffer_cursor;
-	unsigned long	*written;
+struct _jpeg_dest_manager_t {
+	struct				jpeg_destination_mgr mgr; // Default manager
+	JOCTET				*buffer; // Start of buffer
+	struct picture_t	*picture;
+	unsigned char		*picture_data_cursor;
 };
 
 
-static void _jpeg_set_dest_picture(j_compress_ptr jpeg, unsigned char *picture, unsigned long *written);
+static void _jpeg_set_picture(j_compress_ptr jpeg, struct picture_t *picture);
 
-static void _jpeg_write_scanlines_yuyv(struct jpeg_compress_struct *jpeg,
-    unsigned char *line_buffer, const unsigned char *data,
-    const unsigned width, const unsigned height);
+static void _jpeg_write_scanlines_yuyv(
+	struct jpeg_compress_struct *jpeg, const unsigned char *data,
+	unsigned width, unsigned height);
 
-static void _jpeg_write_scanlines_uyvy(struct jpeg_compress_struct *jpeg,
-	unsigned char *line_buffer, const unsigned char *data,
-	const unsigned width, const unsigned height);
+static void _jpeg_write_scanlines_uyvy(
+	struct jpeg_compress_struct *jpeg, const unsigned char *data,
+	unsigned width, unsigned height);
 
-static void _jpeg_write_scanlines_rgb565(struct jpeg_compress_struct *jpeg,
-	unsigned char *line_buffer, const unsigned char *data,
-	const unsigned width, const unsigned height);
+static void _jpeg_write_scanlines_rgb565(
+	struct jpeg_compress_struct *jpeg, const unsigned char *data,
+	unsigned width, unsigned height);
+
+static void _jpeg_write_scanlines_rgb24(
+	struct jpeg_compress_struct *jpeg, const unsigned char *data,
+	unsigned width, unsigned height);
 
 static void _jpeg_init_destination(j_compress_ptr jpeg);
 static boolean _jpeg_empty_output_buffer(j_compress_ptr jpeg);
 static void _jpeg_term_destination(j_compress_ptr jpeg);
 
 
-void jpeg_encoder_compress_buffer(struct device_t *dev, const unsigned index, const unsigned quality) {
+void cpu_encoder_compress_buffer(struct device_t *dev, unsigned index, unsigned quality) {
 	// This function based on compress_image_to_jpeg() from mjpg-streamer
 
 	struct jpeg_compress_struct jpeg;
 	struct jpeg_error_mgr jpeg_error;
-	unsigned char *line_buffer;
-
-	A_CALLOC(line_buffer, dev->run->width * 3);
 
 	jpeg.err = jpeg_std_error(&jpeg_error);
 	jpeg_create_compress(&jpeg);
 
-	dev->run->pictures[index].size = 0;
-	_jpeg_set_dest_picture(&jpeg, dev->run->pictures[index].data, &dev->run->pictures[index].size);
+	_jpeg_set_picture(&jpeg, &dev->run->pictures[index]);
 
 	jpeg.image_width = dev->run->width;
 	jpeg.image_height = dev->run->height;
@@ -90,50 +91,60 @@ void jpeg_encoder_compress_buffer(struct device_t *dev, const unsigned index, co
 
 	jpeg_start_compress(&jpeg, TRUE);
 
-#	define WRITE_SCANLINES(_func) \
-		_func(&jpeg, line_buffer, dev->run->hw_buffers[index].start, dev->run->width, dev->run->height)
+#	define WRITE_SCANLINES(_format, _func) \
+		case _format: { _func(&jpeg, dev->run->hw_buffers[index].data, dev->run->width, dev->run->height); break; }
+
 	switch (dev->run->format) {
 		// https://www.fourcc.org/yuv.php
-		case V4L2_PIX_FMT_YUYV: WRITE_SCANLINES(_jpeg_write_scanlines_yuyv); break;
-		case V4L2_PIX_FMT_UYVY: WRITE_SCANLINES(_jpeg_write_scanlines_uyvy); break;
-		case V4L2_PIX_FMT_RGB565: WRITE_SCANLINES(_jpeg_write_scanlines_rgb565); break;
-		default: assert(0 && "Unsupported input format for JPEG compressor");
+		WRITE_SCANLINES(V4L2_PIX_FMT_YUYV, _jpeg_write_scanlines_yuyv);
+		WRITE_SCANLINES(V4L2_PIX_FMT_UYVY, _jpeg_write_scanlines_uyvy);
+		WRITE_SCANLINES(V4L2_PIX_FMT_RGB565, _jpeg_write_scanlines_rgb565);
+		WRITE_SCANLINES(V4L2_PIX_FMT_RGB24, _jpeg_write_scanlines_rgb24);
+		default: assert(0 && "Unsupported input format for CPU encoder");
 	}
+
 #	undef WRITE_SCANLINES
 
-	// TODO: process jpeg errors:
-	// https://stackoverflow.com/questions/19857766/error-handling-in-libjpeg
 	jpeg_finish_compress(&jpeg);
 	jpeg_destroy_compress(&jpeg);
-	free(line_buffer);
-	assert(dev->run->pictures[index].size > 0);
-	assert(dev->run->pictures[index].size <= dev->run->max_picture_size);
+
+	assert(dev->run->pictures[index].used > 0);
 }
 
-static void _jpeg_set_dest_picture(j_compress_ptr jpeg, unsigned char *picture, unsigned long *written) {
-	struct _mjpg_destination_mgr *dest;
+static void _jpeg_set_picture(j_compress_ptr jpeg, struct picture_t *picture) {
+	struct _jpeg_dest_manager_t *dest;
 
 	if (jpeg->dest == NULL) {
 		assert((jpeg->dest = (struct jpeg_destination_mgr *)(*jpeg->mem->alloc_small)(
-			(j_common_ptr) jpeg, JPOOL_PERMANENT, sizeof(struct _mjpg_destination_mgr)
+			(j_common_ptr) jpeg, JPOOL_PERMANENT, sizeof(struct _jpeg_dest_manager_t)
 		)));
 	}
 
-	dest = (struct _mjpg_destination_mgr *) jpeg->dest;
+	dest = (struct _jpeg_dest_manager_t *)jpeg->dest;
 	dest->mgr.init_destination = _jpeg_init_destination;
 	dest->mgr.empty_output_buffer = _jpeg_empty_output_buffer;
 	dest->mgr.term_destination = _jpeg_term_destination;
-	dest->outbuffer_cursor = picture;
-	dest->written = written;
+	dest->picture = picture;
+	dest->picture_data_cursor = picture->data;
+
+	picture->used = 0;
 }
 
-static void _jpeg_write_scanlines_yuyv(struct jpeg_compress_struct *jpeg,
-	unsigned char *line_buffer, const unsigned char *data,
-	const unsigned width, const unsigned height) {
+#define YUV_R(_y, _, _v)	(((_y) + (359 * (_v))) >> 8)
+#define YUV_G(_y, _u, _v)	(((_y) - (88 * (_u)) - (183 * (_v))) >> 8)
+#define YUV_B(_y, _u, _)	(((_y) + (454 * (_u))) >> 8)
+#define NORM_COMPONENT(_x)	(((_x) > 255) ? 255 : (((_x) < 0) ? 0 : (_x)))
 
+static void _jpeg_write_scanlines_yuyv(
+	struct jpeg_compress_struct *jpeg, const unsigned char *data,
+	unsigned width, unsigned height) {
+
+	unsigned char *line_buffer;
 	JSAMPROW scanlines[1];
 	unsigned z = 0;
 
+	A_CALLOC(line_buffer, width * 3);
+
 	while (jpeg->next_scanline < height) {
 		unsigned char *ptr = line_buffer;
 
@@ -142,13 +153,13 @@ static void _jpeg_write_scanlines_yuyv(struct jpeg_compress_struct *jpeg,
 			int u = data[1] - 128;
 			int v = data[3] - 128;
 
-			int r = (y + (359 * v)) >> 8;
-			int g = (y - (88 * u) - (183 * v)) >> 8;
-			int b = (y + (454 * u)) >> 8;
+			int r = YUV_R(y, u, v);
+			int g = YUV_G(y, u, v);
+			int b = YUV_B(y, u, v);
 
-			*(ptr++) = (r > 255) ? 255 : ((r < 0) ? 0 : r);
-			*(ptr++) = (g > 255) ? 255 : ((g < 0) ? 0 : g);
-			*(ptr++) = (b > 255) ? 255 : ((b < 0) ? 0 : b);
+			*(ptr++) = NORM_COMPONENT(r);
+			*(ptr++) = NORM_COMPONENT(g);
+			*(ptr++) = NORM_COMPONENT(b);
 
 			if (z++) {
 				z = 0;
@@ -159,16 +170,21 @@ static void _jpeg_write_scanlines_yuyv(struct jpeg_compress_struct *jpeg,
 		scanlines[0] = line_buffer;
 		jpeg_write_scanlines(jpeg, scanlines, 1);
 	}
+
+	free(line_buffer);
 }
 
-static void _jpeg_write_scanlines_uyvy(struct jpeg_compress_struct *jpeg,
-	unsigned char *line_buffer, const unsigned char *data,
-	const unsigned width, const unsigned height) {
+static void _jpeg_write_scanlines_uyvy(
+	struct jpeg_compress_struct *jpeg, const unsigned char *data,
+	unsigned width, unsigned height) {
 
+	unsigned char *line_buffer;
 	JSAMPROW scanlines[1];
 	unsigned z = 0;
 
-	while(jpeg->next_scanline < height) {
+	A_CALLOC(line_buffer, width * 3);
+
+	while (jpeg->next_scanline < height) {
 		unsigned char *ptr = line_buffer;
 
 		for(unsigned x = 0; x < width; ++x) {
@@ -176,13 +192,13 @@ static void _jpeg_write_scanlines_uyvy(struct jpeg_compress_struct *jpeg,
 			int u = data[0] - 128;
 			int v = data[2] - 128;
 
-			int r = (y + (359 * v)) >> 8;
-			int g = (y - (88 * u) - (183 * v)) >> 8;
-			int b = (y + (454 * u)) >> 8;
+			int r = YUV_R(y, u, v);
+			int g = YUV_G(y, u, v);
+			int b = YUV_B(y, u, v);
 
-			*(ptr++) = (r > 255) ? 255 : ((r < 0) ? 0 : r);
-			*(ptr++) = (g > 255) ? 255 : ((g < 0) ? 0 : g);
-			*(ptr++) = (b > 255) ? 255 : ((b < 0) ? 0 : b);
+			*(ptr++) = NORM_COMPONENT(r);
+			*(ptr++) = NORM_COMPONENT(g);
+			*(ptr++) = NORM_COMPONENT(b);
 
 			if (z++) {
 				z = 0;
@@ -193,23 +209,33 @@ static void _jpeg_write_scanlines_uyvy(struct jpeg_compress_struct *jpeg,
 		scanlines[0] = line_buffer;
 		jpeg_write_scanlines(jpeg, scanlines, 1);
 	}
+
+	free(line_buffer);
 }
 
-static void _jpeg_write_scanlines_rgb565(struct jpeg_compress_struct *jpeg,
-	unsigned char *line_buffer, const unsigned char *data,
-	const unsigned width, const unsigned height) {
+#undef NORM_COMPONENT
+#undef YUV_B
+#undef YUV_G
+#undef YUV_R
 
+static void _jpeg_write_scanlines_rgb565(
+	struct jpeg_compress_struct *jpeg, const unsigned char *data,
+	unsigned width, unsigned height) {
+
+	unsigned char *line_buffer;
 	JSAMPROW scanlines[1];
 
-	while(jpeg->next_scanline < height) {
+	A_CALLOC(line_buffer, width * 3);
+
+	while (jpeg->next_scanline < height) {
 		unsigned char *ptr = line_buffer;
 
 		for(unsigned x = 0; x < width; ++x) {
 			unsigned int two_byte = (data[1] << 8) + data[0];
 
-			*(ptr++) = data[1] & 248;
-			*(ptr++) = (unsigned char)((two_byte & 2016) >> 3);
-			*(ptr++) = (data[0] & 31) * 8;
+			*(ptr++) = data[1] & 248; // Red
+			*(ptr++) = (unsigned char)((two_byte & 2016) >> 3); // Green
+			*(ptr++) = (data[0] & 31) * 8; // Blue
 
 			data += 2;
 		}
@@ -217,12 +243,26 @@ static void _jpeg_write_scanlines_rgb565(struct jpeg_compress_struct *jpeg,
 		scanlines[0] = line_buffer;
 		jpeg_write_scanlines(jpeg, scanlines, 1);
 	}
+
+	free(line_buffer);
 }
 
-#define JPEG_OUTPUT_BUFFER_SIZE  4096
+static void _jpeg_write_scanlines_rgb24(
+	struct jpeg_compress_struct *jpeg, const unsigned char *data,
+	unsigned width, unsigned height) {
+
+	JSAMPROW scanlines[1];
+
+	while (jpeg->next_scanline < height) {
+		scanlines[0] = (unsigned char *)(data + jpeg->next_scanline * width * 3);
+		jpeg_write_scanlines(jpeg, scanlines, 1);
+	}
+}
+
+#define JPEG_OUTPUT_BUFFER_SIZE 4096
 
 static void _jpeg_init_destination(j_compress_ptr jpeg) {
-	struct _mjpg_destination_mgr *dest = (struct _mjpg_destination_mgr *) jpeg->dest;
+	struct _jpeg_dest_manager_t *dest = (struct _jpeg_dest_manager_t *)jpeg->dest;
 
 	// Allocate the output buffer - it will be released when done with image
 	assert((dest->buffer = (JOCTET *)(*jpeg->mem->alloc_small)(
@@ -236,11 +276,14 @@ static void _jpeg_init_destination(j_compress_ptr jpeg) {
 static boolean _jpeg_empty_output_buffer(j_compress_ptr jpeg) {
 	// Called whenever local jpeg buffer fills up
 
-	struct _mjpg_destination_mgr *dest = (struct _mjpg_destination_mgr *) jpeg->dest;
+	struct _jpeg_dest_manager_t *dest = (struct _jpeg_dest_manager_t *)jpeg->dest;
+	size_t new_used = dest->picture->used + JPEG_OUTPUT_BUFFER_SIZE;
 
-	memcpy(dest->outbuffer_cursor, dest->buffer, JPEG_OUTPUT_BUFFER_SIZE);
-	dest->outbuffer_cursor += JPEG_OUTPUT_BUFFER_SIZE;
-	*dest->written += JPEG_OUTPUT_BUFFER_SIZE;
+	assert(new_used <= dest->picture->allocated);
+
+	memcpy(dest->picture_data_cursor, dest->buffer, JPEG_OUTPUT_BUFFER_SIZE);
+	dest->picture_data_cursor += JPEG_OUTPUT_BUFFER_SIZE;
+	dest->picture->used = new_used;
 
 	dest->mgr.next_output_byte = dest->buffer;
 	dest->mgr.free_in_buffer = JPEG_OUTPUT_BUFFER_SIZE;
@@ -252,13 +295,16 @@ static void _jpeg_term_destination(j_compress_ptr jpeg) {
 	// Called by jpeg_finish_compress after all data has been written.
 	// Usually needs to flush buffer
 
-	struct _mjpg_destination_mgr *dest = (struct _mjpg_destination_mgr *) jpeg->dest;
-	size_t data_count = JPEG_OUTPUT_BUFFER_SIZE - dest->mgr.free_in_buffer;
+	struct _jpeg_dest_manager_t *dest = (struct _jpeg_dest_manager_t *)jpeg->dest;
+	size_t final = JPEG_OUTPUT_BUFFER_SIZE - dest->mgr.free_in_buffer;
+	size_t new_used = dest->picture->used + final;
+
+	assert(new_used <= dest->picture->allocated);
 
 	// Write any data remaining in the buffer
-	memcpy(dest->outbuffer_cursor, dest->buffer, data_count);
-	dest->outbuffer_cursor += data_count;
-	*dest->written += data_count;
+	memcpy(dest->picture_data_cursor, dest->buffer, final);
+	dest->picture_data_cursor += final;
+	dest->picture->used = new_used;
 }
 
 #undef JPEG_OUTPUT_BUFFER_SIZE

src/encoders/cpu/encoder.h

@@ -0,0 +1,28 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#                                                                            #
+#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include "../../device.h"
+
+
+void cpu_encoder_compress_buffer(struct device_t *dev, unsigned index, unsigned quality);

src/encoders/hw/encoder.c

@@ -0,0 +1,117 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#                                                                            #
+#    This source file based on code of MJPG-Streamer.                        #
+#                                                                            #
+#    Copyright (C) 2005-2006  Laurent Pinchart & Michel Xhaard               #
+#    Copyright (C) 2006  Gabriel A. Devenyi                                  #
+#    Copyright (C) 2007  Tom Stöveken                                        #
+#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "encoder.h"
+
+#include <stdbool.h>
+#include <string.h>
+#include <assert.h>
+
+#include <linux/videodev2.h>
+
+#include "../../tools.h"
+#include "../../logging.h"
+#include "../../xioctl.h"
+#include "../../device.h"
+
+#include "huffman.h"
+
+
+static bool _is_huffman(const unsigned char *data);
+static size_t _memcpy_with_huffman(unsigned char *dest, const unsigned char *src, size_t size);
+
+
+int hw_encoder_prepare(struct device_t *dev, unsigned quality) {
+	struct v4l2_jpegcompression comp;
+
+	MEMSET_ZERO(comp);
+
+	if (xioctl(dev->run->fd, VIDIOC_G_JPEGCOMP, &comp) < 0) {
+		LOG_ERROR("Can't query HW encoder params and set quality (unsupported)");
+		return -1;
+	}
+	comp.quality = quality;
+	if (xioctl(dev->run->fd, VIDIOC_S_JPEGCOMP, &comp) < 0) {
+		LOG_ERROR("Can't set HW encoder quality (unsupported)");
+		return -1;
+	}
+	return 0;
+}
+
+void hw_encoder_compress_buffer(struct device_t *dev, unsigned index) {
+	if (dev->run->format != V4L2_PIX_FMT_MJPEG && dev->run->format != V4L2_PIX_FMT_JPEG) {
+		assert(0 && "Unsupported input format for HW encoder");
+	}
+
+#	define PICTURE(_next)	dev->run->pictures[index]._next
+#	define HW_BUFFER(_next)	dev->run->hw_buffers[index]._next
+
+	assert(PICTURE(allocated) >= HW_BUFFER(used) + sizeof(HUFFMAN_TABLE));
+	PICTURE(used) = _memcpy_with_huffman(PICTURE(data), HW_BUFFER(data), HW_BUFFER(used));
+
+#	undef HW_BUFFER
+#	undef PICTURE
+}
+
+static bool _is_huffman(const unsigned char *data) {
+	unsigned count = 0;
+
+	while (((data[0] << 8) | data[1]) != 0xFFDA) {
+		if (count++ > 2048) {
+			return false;
+		}
+		if (((data[0] << 8) | data[1]) == 0xFFC4) {
+			return true;
+		}
+		data += 1;
+	}
+	return false;
+}
+
+static size_t _memcpy_with_huffman(unsigned char *dest, const unsigned char *src, size_t size) {
+	if (!_is_huffman(src)) {
+		const unsigned char *src_ptr = src;
+		const unsigned char *src_end = src + size;
+		size_t paste;
+
+		while ((((src_ptr[0] << 8) | src_ptr[1]) != 0xFFC0) && (src_ptr < src_end)) {
+			src_ptr += 1;
+		}
+		if (src_ptr >= src_end) {
+			return 0;
+		}
+		paste = src_ptr - src;
+
+		memcpy(dest, src, paste);
+		memcpy(dest + paste, HUFFMAN_TABLE, sizeof(HUFFMAN_TABLE));
+		memcpy(dest + paste + sizeof(HUFFMAN_TABLE), src_ptr, size - paste);
+		return (size + sizeof(HUFFMAN_TABLE));
+	} else {
+		memcpy(dest, src, size);
+		return size;
+	}
+}

src/encoders/hw/encoder.h

@@ -0,0 +1,29 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#                                                                            #
+#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include "../../device.h"
+
+
+int hw_encoder_prepare(struct device_t *dev, unsigned quality);
+void hw_encoder_compress_buffer(struct device_t *dev, unsigned index);

src/encoders/hw/huffman.h

@@ -0,0 +1,66 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#                                                                            #
+#    This source file based on code of MJPG-Streamer.                        #
+#                                                                            #
+#    Copyright (C) 2005-2006  Laurent Pinchart & Michel Xhaard               #
+#    Copyright (C) 2006  Gabriel A. Devenyi                                  #
+#    Copyright (C) 2007  Tom Stöveken                                        #
+#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+static const unsigned char HUFFMAN_TABLE[] = {
+	0xFF, 0xC4, 0x01, 0xA2, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01,
+	0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02,
+	0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x01, 0x00, 0x03,
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+	0x0A, 0x0B, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05,
+	0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01, 0x02, 0x03, 0x00, 0x04,
+	0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22,
+	0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15,
+	0x52, 0xD1, 0xF0, 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17,
+	0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36,
+	0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
+	0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66,
+	0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A,
+	0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95,
+	0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
+	0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2,
+	0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5,
+	0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
+	0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9,
+	0xFA, 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05,
+	0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11, 0x04,
+	0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22,
+	0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33,
+	0x52, 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34, 0xE1, 0x25,
+	0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x35, 0x36,
+	0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
+	0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66,
+	0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A,
+	0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94,
+	0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,
+	0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA,
+	0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4,
+	0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
+	0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA,
+};

src/encoders/omx/component.c

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
@@ -19,22 +20,23 @@
 *****************************************************************************/
 
 
+#include "component.h"
+
 #include <unistd.h>
 
 #include <IL/OMX_Core.h>
 #include <IL/OMX_Component.h>
 
-#include "../logging.h"
+#include "../../logging.h"
 
 #include "formatters.h"
-#include "component.h"
 
 
-static int _component_wait_port_changed(OMX_HANDLETYPE *component, const OMX_U32 port, const OMX_BOOL enabled);
-static int _component_wait_state_changed(OMX_HANDLETYPE *component, const OMX_STATETYPE wanted);
+static int _component_wait_port_changed(OMX_HANDLETYPE *component, OMX_U32 port, OMX_BOOL enabled);
+static int _component_wait_state_changed(OMX_HANDLETYPE *component, OMX_STATETYPE wanted);
 
 
-int component_enable_port(OMX_HANDLETYPE *component, const OMX_U32 port) {
+int component_enable_port(OMX_HANDLETYPE *component, OMX_U32 port) {
 	OMX_ERRORTYPE error;
 
 	LOG_DEBUG("Enabling OMX port %u ...", port);
@@ -45,7 +47,7 @@ int component_enable_port(OMX_HANDLETYPE *component, const OMX_U32 port) {
 	return _component_wait_port_changed(component, port, OMX_TRUE);
 }
 
-int component_disable_port(OMX_HANDLETYPE *component, const OMX_U32 port) {
+int component_disable_port(OMX_HANDLETYPE *component, OMX_U32 port) {
 	OMX_ERRORTYPE error;
 
 	LOG_DEBUG("Disabling OMX port %u ...", port);
@@ -56,7 +58,7 @@ int component_disable_port(OMX_HANDLETYPE *component, const OMX_U32 port) {
 	return _component_wait_port_changed(component, port, OMX_FALSE);
 }
 
-int component_get_portdef(OMX_HANDLETYPE *component, OMX_PARAM_PORTDEFINITIONTYPE *portdef, const OMX_U32 port) {
+int component_get_portdef(OMX_HANDLETYPE *component, OMX_PARAM_PORTDEFINITIONTYPE *portdef, OMX_U32 port) {
 	OMX_ERRORTYPE error;
 
 	OMX_INIT_STRUCTURE(*portdef);
@@ -81,8 +83,8 @@ int component_set_portdef(OMX_HANDLETYPE *component, OMX_PARAM_PORTDEFINITIONTYP
 	return 0;
 }
 
-int component_set_state(OMX_HANDLETYPE *component, const OMX_STATETYPE state) {
-	const char *const state_str = omx_state_to_string(state);
+int component_set_state(OMX_HANDLETYPE *component, OMX_STATETYPE state) {
+	const char *state_str = omx_state_to_string(state);
 	OMX_ERRORTYPE error;
 	int retries = 50;
 
@@ -107,7 +109,7 @@ int component_set_state(OMX_HANDLETYPE *component, const OMX_STATETYPE state) {
 }
 
 
-static int _component_wait_port_changed(OMX_HANDLETYPE *component, const OMX_U32 port, const OMX_BOOL enabled) {
+static int _component_wait_port_changed(OMX_HANDLETYPE *component, OMX_U32 port, OMX_BOOL enabled) {
 	OMX_ERRORTYPE error;
 	OMX_PARAM_PORTDEFINITIONTYPE portdef;
 	int retries = 50;
@@ -132,7 +134,7 @@ static int _component_wait_port_changed(OMX_HANDLETYPE *component, const OMX_U32
 	return (portdef.bEnabled == enabled ? 0 : -1);
 }
 
-static int _component_wait_state_changed(OMX_HANDLETYPE *component, const OMX_STATETYPE wanted) {
+static int _component_wait_state_changed(OMX_HANDLETYPE *component, OMX_STATETYPE wanted) {
 	OMX_ERRORTYPE error;
 	OMX_STATETYPE state;
 	int retries = 50;

src/encoders/omx/component.h

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
@@ -38,10 +39,10 @@
 	}
 
 
-int component_enable_port(OMX_HANDLETYPE *component, const OMX_U32 port);
-int component_disable_port(OMX_HANDLETYPE *component, const OMX_U32 port);
+int component_enable_port(OMX_HANDLETYPE *component, OMX_U32 port);
+int component_disable_port(OMX_HANDLETYPE *component, OMX_U32 port);
 
-int component_get_portdef(OMX_HANDLETYPE *component, OMX_PARAM_PORTDEFINITIONTYPE *portdef, const OMX_U32 port);
+int component_get_portdef(OMX_HANDLETYPE *component, OMX_PARAM_PORTDEFINITIONTYPE *portdef, OMX_U32 port);
 int component_set_portdef(OMX_HANDLETYPE *component, OMX_PARAM_PORTDEFINITIONTYPE *portdef);
 
-int component_set_state(OMX_HANDLETYPE *component, const OMX_STATETYPE state);
+int component_set_state(OMX_HANDLETYPE *component, OMX_STATETYPE state);

src/encoders/omx/encoder.c

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
@@ -19,6 +20,8 @@
 *****************************************************************************/
 
 
+#include "encoder.h"
+
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
@@ -32,17 +35,16 @@
 #include <IL/OMX_Broadcom.h>
 #include <interface/vcos/vcos_semaphore.h>
 
-#include "../logging.h"
-#include "../tools.h"
-#include "../device.h"
+#include "../../logging.h"
+#include "../../tools.h"
+#include "../../device.h"
 
 #include "formatters.h"
 #include "component.h"
-#include "encoder.h"
 
 
-#define INPUT_PORT 340
-#define OUTPUT_PORT 341
+static const OMX_U32 _INPUT_PORT = 340;
+static const OMX_U32 _OUTPUT_PORT = 341;
 
 
 static int _i_omx = 0;
@@ -51,21 +53,24 @@ static int _i_omx = 0;
 static int _omx_init_component(struct omx_encoder_t *omx);
 static int _omx_init_disable_ports(struct omx_encoder_t *omx);
 static int _omx_setup_input(struct omx_encoder_t *omx, struct device_t *dev);
-static int _omx_setup_output(struct omx_encoder_t *omx, const unsigned quality, const bool use_ijg);
+static int _omx_setup_output(struct omx_encoder_t *omx, unsigned quality);
 static int _omx_encoder_clear_ports(struct omx_encoder_t *omx);
 
-static OMX_ERRORTYPE _omx_event_handler(UNUSED OMX_HANDLETYPE encoder,
+static OMX_ERRORTYPE _omx_event_handler(
+	UNUSED OMX_HANDLETYPE encoder,
 	OMX_PTR v_omx, OMX_EVENTTYPE event, OMX_U32 data1,
 	UNUSED OMX_U32 data2, UNUSED OMX_PTR event_data);
 
-static OMX_ERRORTYPE _omx_input_required_handler(UNUSED OMX_HANDLETYPE encoder,
+static OMX_ERRORTYPE _omx_input_required_handler(
+	UNUSED OMX_HANDLETYPE encoder,
 	OMX_PTR v_omx, UNUSED OMX_BUFFERHEADERTYPE *buffer);
 
-static OMX_ERRORTYPE _omx_output_available_handler(UNUSED OMX_HANDLETYPE encoder,
+static OMX_ERRORTYPE _omx_output_available_handler(
+	UNUSED OMX_HANDLETYPE encoder,
 	OMX_PTR v_omx, UNUSED OMX_BUFFERHEADERTYPE *buffer);
 
 
-struct omx_encoder_t *omx_encoder_init() {
+struct omx_encoder_t *omx_encoder_init(void) {
 	// Some theory:
 	//   - http://www.fourcc.org/yuv.php
 	//   - https://kwasi-ich.de/blog/2017/11/26/omx/
@@ -74,6 +79,7 @@ struct omx_encoder_t *omx_encoder_init() {
 	//   - https://github.com/gagle/raspberrypi-openmax-jpeg/blob/master/jpeg.c
 	//   - https://www.raspberrypi.org/forums/viewtopic.php?t=154790
 	//   - https://bitbucket.org/bensch128/omxjpegencode/src/master/jpeg_encoder.cpp
+	//   - http://home.nouwen.name/RaspberryPi/documentation/ilcomponents/image_encode.html
 
 	struct omx_encoder_t *omx;
 	OMX_ERRORTYPE error;
@@ -93,7 +99,7 @@ struct omx_encoder_t *omx_encoder_init() {
 	}
 	_i_omx += 1;
 
-	LOG_INFO("Initializing OMX JPEG encoder ...");
+	LOG_INFO("Initializing OMX encoder ...");
 
 	if (vcos_semaphore_create(&omx->handler_lock, "handler_lock", 0) != VCOS_SUCCESS) {
 		LOG_ERROR("Can't create VCOS semaphore");
@@ -119,7 +125,7 @@ struct omx_encoder_t *omx_encoder_init() {
 void omx_encoder_destroy(struct omx_encoder_t *omx) {
 	OMX_ERRORTYPE error;
 
-	LOG_INFO("Destroying OMX JPEG encoder ...");
+	LOG_INFO("Destroying OMX encoder ...");
 
 	component_set_state(&omx->encoder, OMX_StateIdle);
 	_omx_encoder_clear_ports(omx);
@@ -148,7 +154,7 @@ void omx_encoder_destroy(struct omx_encoder_t *omx) {
 	free(omx);
 }
 
-int omx_encoder_prepare_live(struct omx_encoder_t *omx, struct device_t *dev, const unsigned quality, const bool use_ijg) {
+int omx_encoder_prepare(struct omx_encoder_t *omx, struct device_t *dev, unsigned quality) {
 	if (component_set_state(&omx->encoder, OMX_StateIdle) < 0) {
 		return -1;
 	}
@@ -158,7 +164,7 @@ int omx_encoder_prepare_live(struct omx_encoder_t *omx, struct device_t *dev, co
 	if (_omx_setup_input(omx, dev) < 0) {
 		return -1;
 	}
-	if (_omx_setup_output(omx, quality, use_ijg) < 0) {
+	if (_omx_setup_output(omx, quality) < 0) {
 		return -1;
 	}
 	if (component_set_state(&omx->encoder, OMX_StateExecuting) < 0) {
@@ -167,16 +173,22 @@ int omx_encoder_prepare_live(struct omx_encoder_t *omx, struct device_t *dev, co
 	return 0;
 }
 
-int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev, const unsigned index) {
+int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev, unsigned index) {
+#	define PICTURE(_next)	dev->run->pictures[index]._next
+#	define HW_BUFFER(_next)	dev->run->hw_buffers[index]._next
+#	define IN(_next)		omx->input_buffer->_next
+#	define OUT(_next)		omx->output_buffer->_next
+
 	OMX_ERRORTYPE error;
-	bool loaded = false;
+	size_t slice_size = (IN(nAllocLen) < HW_BUFFER(used) ? IN(nAllocLen) : HW_BUFFER(used));
+	size_t pos = 0;
 
 	if ((error = OMX_FillThisBuffer(omx->encoder, omx->output_buffer)) != OMX_ErrorNone) {
 		LOG_OMX_ERROR(error, "Failed to request filling of the output buffer on encoder");
 		return -1;
 	}
 
-	dev->run->pictures[index].size = 0;
+	PICTURE(used) = 0;
 	omx->output_available = false;
 	omx->input_required = true;
 
@@ -188,16 +200,12 @@ int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev,
 		if (omx->output_available) {
 			omx->output_available = false;
 
-			memcpy(
-				dev->run->pictures[index].data + dev->run->pictures[index].size,
-				omx->output_buffer->pBuffer,
-				omx->output_buffer->nFilledLen
-			);
-			assert(dev->run->pictures[index].size + omx->output_buffer->nFilledLen <= dev->run->max_picture_size);
-			dev->run->pictures[index].size += omx->output_buffer->nFilledLen;
+			assert(PICTURE(used) + OUT(nFilledLen) <= PICTURE(allocated));
+			memcpy(PICTURE(data) + PICTURE(used), OUT(pBuffer) + OUT(nOffset), OUT(nFilledLen));
+			PICTURE(used) += OUT(nFilledLen);
 
-			if (omx->output_buffer->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) {
-				omx->output_buffer->nFlags = 0;
+			if (OUT(nFlags) & OMX_BUFFERFLAG_ENDOFFRAME) {
+				OUT(nFlags) = 0;
 				break;
 			}
 
@@ -209,14 +217,20 @@ int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev,
 
 		if (omx->input_required) {
 			omx->input_required = false;
-			if (loaded) {
+
+			if (pos == HW_BUFFER(used)) {
 				continue;
 			}
-			loaded = true;
 
-			memcpy(omx->input_buffer->pBuffer, dev->run->hw_buffers[index].start, dev->run->hw_buffers[index].length);
-			omx->input_buffer->nOffset = 0;
-			omx->input_buffer->nFilledLen = dev->run->hw_buffers[index].length;
+			memcpy(IN(pBuffer), HW_BUFFER(data) + pos, slice_size);
+			IN(nOffset) = 0;
+			IN(nFilledLen) = slice_size;
+
+			pos += slice_size;
+
+			if (pos + slice_size > HW_BUFFER(used)) {
+				slice_size = HW_BUFFER(used) - pos;
+			}
 
 			if ((error = OMX_EmptyThisBuffer(omx->encoder, omx->input_buffer)) != OMX_ErrorNone) {
 				LOG_OMX_ERROR(error, "Failed to request emptying of the input buffer on encoder");
@@ -226,12 +240,15 @@ int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev,
 
 		vcos_semaphore_wait(&omx->handler_lock);
 	}
+
+#	undef OUT
+#	undef IN
+#	undef HW_BUFFER
+#	undef PICTURE
 	return 0;
 }
 
 static int _omx_init_component(struct omx_encoder_t *omx) {
-	// http://home.nouwen.name/RaspberryPi/documentation/ilcomponents/image_encode.html
-
 	OMX_ERRORTYPE error;
 
 	OMX_CALLBACKTYPE callbacks;
@@ -283,7 +300,7 @@ static int _omx_setup_input(struct omx_encoder_t *omx, struct device_t *dev) {
 
 	LOG_DEBUG("Setting up OMX JPEG input port ...");
 
-	if (component_get_portdef(&omx->encoder, &portdef, INPUT_PORT) < 0) {
+	if (component_get_portdef(&omx->encoder, &portdef, _INPUT_PORT) < 0) {
 		LOG_ERROR("... first");
 		return -1;
 	}
@@ -291,51 +308,60 @@ static int _omx_setup_input(struct omx_encoder_t *omx, struct device_t *dev) {
 	portdef.format.image.nFrameWidth = dev->run->width;
 	portdef.format.image.nFrameHeight = dev->run->height;
 	portdef.format.image.nStride = 0;
-#	define ALIGN(_x, _y) (((_x) + ((_y) - 1)) & ~((_y) - 1))
-	portdef.format.image.nSliceHeight = ALIGN(dev->run->height, 16);
-#	undef ALIGN
+#	define ALIGN_HEIGHT(_x, _y) (((_x) + ((_y) - 1)) & ~((_y) - 1))
+	portdef.format.image.nSliceHeight = ALIGN_HEIGHT(dev->run->height, 16);
+#	undef ALIGN_HEIGHT
 	portdef.format.image.bFlagErrorConcealment = OMX_FALSE;
 	portdef.format.image.eCompressionFormat = OMX_IMAGE_CodingUnused;
-	portdef.nBufferSize = dev->run->max_picture_size;
+	portdef.nBufferSize = dev->run->max_raw_image_size;
+
+#	define MAP_FORMAT(_v4l2_format, _omx_format) \
+		case _v4l2_format: { portdef.format.image.eColorFormat = _omx_format; break; }
 
 	switch (dev->run->format) {
 		// https://www.fourcc.org/yuv.php
 		// Also see comments inside OMX_IVCommon.h
-		case V4L2_PIX_FMT_YUYV: portdef.format.image.eColorFormat = OMX_COLOR_FormatYCbYCr; break;
-		case V4L2_PIX_FMT_UYVY: portdef.format.image.eColorFormat = OMX_COLOR_FormatCbYCrY; break;
-		case V4L2_PIX_FMT_RGB565: portdef.format.image.eColorFormat = OMX_COLOR_Format16bitRGB565; break;
-		// TODO: Check RGB565 + OMX. I don't have any USB devices which supports it.
-		default: assert(0 && "Unsupported input format for OMX JPEG compressor");
+		MAP_FORMAT(V4L2_PIX_FMT_YUYV, OMX_COLOR_FormatYCbYCr);
+		MAP_FORMAT(V4L2_PIX_FMT_UYVY, OMX_COLOR_FormatCbYCrY);
+		MAP_FORMAT(V4L2_PIX_FMT_RGB565, OMX_COLOR_Format16bitRGB565);
+		MAP_FORMAT(V4L2_PIX_FMT_RGB24, OMX_COLOR_Format24bitRGB888);
+		// TODO: найти устройство с RGB565 и протестить его.
+		// FIXME: RGB24 не работает нормально, нижняя половина экрана зеленая.
+		// FIXME: Китайский EasyCap тоже не работает, мусор на экране.
+		// Вероятно обе проблемы вызваны некорректной реализацией OMX на пае.
+		default: assert(0 && "Unsupported input format for OMX encoder");
 	}
 
+#	undef MAP_FORMAT
+
 	if (component_set_portdef(&omx->encoder, &portdef) < 0) {
 		return -1;
 	}
 
-	if (component_get_portdef(&omx->encoder, &portdef, INPUT_PORT) < 0) {
+	if (component_get_portdef(&omx->encoder, &portdef, _INPUT_PORT) < 0) {
 		LOG_ERROR("... second");
 		return -1;
 	}
 
-	if (component_enable_port(&omx->encoder, INPUT_PORT) < 0) {
+	if (component_enable_port(&omx->encoder, _INPUT_PORT) < 0) {
 		return -1;
 	}
 	omx->i_input_port_enabled = true;
 
-	if ((error = OMX_AllocateBuffer(omx->encoder, &omx->input_buffer, INPUT_PORT, NULL, portdef.nBufferSize)) != OMX_ErrorNone) {
+	if ((error = OMX_AllocateBuffer(omx->encoder, &omx->input_buffer, _INPUT_PORT, NULL, portdef.nBufferSize)) != OMX_ErrorNone) {
 		LOG_OMX_ERROR(error, "Can't allocate OMX JPEG input buffer");
 		return -1;
 	}
 	return 0;
 }
 
-static int _omx_setup_output(struct omx_encoder_t *omx, const unsigned quality, const bool use_ijg) {
+static int _omx_setup_output(struct omx_encoder_t *omx, unsigned quality) {
 	OMX_ERRORTYPE error;
 	OMX_PARAM_PORTDEFINITIONTYPE portdef;
 
 	LOG_DEBUG("Setting up OMX JPEG output port ...");
 
-	if (component_get_portdef(&omx->encoder, &portdef, OUTPUT_PORT) < 0) {
+	if (component_get_portdef(&omx->encoder, &portdef, _OUTPUT_PORT) < 0) {
 		LOG_ERROR("... first");
 		return -1;
 	}
@@ -348,7 +374,7 @@ static int _omx_setup_output(struct omx_encoder_t *omx, const unsigned quality,
 		return -1;
 	}
 
-	if (component_get_portdef(&omx->encoder, &portdef, OUTPUT_PORT) < 0) {
+	if (component_get_portdef(&omx->encoder, &portdef, _OUTPUT_PORT) < 0) {
 		LOG_ERROR("... second");
 		return -1;
 	}
@@ -365,11 +391,11 @@ static int _omx_setup_output(struct omx_encoder_t *omx, const unsigned quality,
 		}
 	}
 
-	if (use_ijg) {
+	{
 		OMX_PARAM_IJGSCALINGTYPE ijg;
 
 		OMX_INIT_STRUCTURE(ijg);
-		ijg.nPortIndex = OUTPUT_PORT;
+		ijg.nPortIndex = _OUTPUT_PORT;
 		ijg.bEnabled = OMX_TRUE;
 
 		if ((error = OMX_SetParameter(omx->encoder, OMX_IndexParamBrcmEnableIJGTableScaling, &ijg)) != OMX_ErrorNone) {
@@ -382,7 +408,7 @@ static int _omx_setup_output(struct omx_encoder_t *omx, const unsigned quality,
 		OMX_IMAGE_PARAM_QFACTORTYPE qfactor;
 
 		OMX_INIT_STRUCTURE(qfactor);
-		qfactor.nPortIndex = OUTPUT_PORT;
+		qfactor.nPortIndex = _OUTPUT_PORT;
 		qfactor.nQFactor = quality;
 
 		if ((error = OMX_SetParameter(omx->encoder, OMX_IndexParamQFactor, &qfactor)) != OMX_ErrorNone) {
@@ -391,12 +417,12 @@ static int _omx_setup_output(struct omx_encoder_t *omx, const unsigned quality,
 		}
 	}
 
-	if (component_enable_port(&omx->encoder, OUTPUT_PORT) < 0) {
+	if (component_enable_port(&omx->encoder, _OUTPUT_PORT) < 0) {
 		return -1;
 	}
 	omx->i_output_port_enabled = true;
 
-	if ((error = OMX_AllocateBuffer(omx->encoder, &omx->output_buffer, OUTPUT_PORT, NULL, portdef.nBufferSize)) != OMX_ErrorNone) {
+	if ((error = OMX_AllocateBuffer(omx->encoder, &omx->output_buffer, _OUTPUT_PORT, NULL, portdef.nBufferSize)) != OMX_ErrorNone) {
 		LOG_OMX_ERROR(error, "Can't allocate OMX JPEG output buffer");
 		return -1;
 	}
@@ -408,23 +434,23 @@ static int _omx_encoder_clear_ports(struct omx_encoder_t *omx) {
 	int retcode = 0;
 
 	if (omx->i_output_port_enabled) {
-		retcode -= component_disable_port(&omx->encoder, OUTPUT_PORT);
+		retcode -= component_disable_port(&omx->encoder, _OUTPUT_PORT);
 		omx->i_output_port_enabled = false;
 	}
 	if (omx->i_input_port_enabled) {
-		retcode -= component_disable_port(&omx->encoder, INPUT_PORT);
+		retcode -= component_disable_port(&omx->encoder, _INPUT_PORT);
 		omx->i_input_port_enabled = false;
 	}
 
 	if (omx->input_buffer) {
-		if ((error = OMX_FreeBuffer(omx->encoder, INPUT_PORT, omx->input_buffer)) != OMX_ErrorNone) {
+		if ((error = OMX_FreeBuffer(omx->encoder, _INPUT_PORT, omx->input_buffer)) != OMX_ErrorNone) {
 			LOG_OMX_ERROR(error, "Can't free OMX JPEG input buffer");
 			// retcode -= 1;
 		}
 		omx->input_buffer = NULL;
 	}
 	if (omx->output_buffer) {
-		if ((error = OMX_FreeBuffer(omx->encoder, OUTPUT_PORT, omx->output_buffer)) != OMX_ErrorNone) {
+		if ((error = OMX_FreeBuffer(omx->encoder, _OUTPUT_PORT, omx->output_buffer)) != OMX_ErrorNone) {
 			LOG_OMX_ERROR(error, "Can't free OMX JPEG output buffer");
 			// retcode -= 1;
 		}
@@ -433,7 +459,8 @@ static int _omx_encoder_clear_ports(struct omx_encoder_t *omx) {
 	return retcode;
 }
 
-static OMX_ERRORTYPE _omx_event_handler(UNUSED OMX_HANDLETYPE encoder,
+static OMX_ERRORTYPE _omx_event_handler(
+	UNUSED OMX_HANDLETYPE encoder,
 	OMX_PTR v_omx, OMX_EVENTTYPE event, OMX_U32 data1,
 	UNUSED OMX_U32 data2, UNUSED OMX_PTR event_data) {
 
@@ -449,7 +476,8 @@ static OMX_ERRORTYPE _omx_event_handler(UNUSED OMX_HANDLETYPE encoder,
 	return OMX_ErrorNone;
 }
 
-static OMX_ERRORTYPE _omx_input_required_handler(UNUSED OMX_HANDLETYPE encoder,
+static OMX_ERRORTYPE _omx_input_required_handler(
+	UNUSED OMX_HANDLETYPE encoder,
 	OMX_PTR v_omx, UNUSED OMX_BUFFERHEADERTYPE *buffer) {
 
 	// Called by OMX when the encoder component requires
@@ -462,7 +490,8 @@ static OMX_ERRORTYPE _omx_input_required_handler(UNUSED OMX_HANDLETYPE encoder,
 	return OMX_ErrorNone;
 }
 
-static OMX_ERRORTYPE _omx_output_available_handler(UNUSED OMX_HANDLETYPE encoder,
+static OMX_ERRORTYPE _omx_output_available_handler(
+	UNUSED OMX_HANDLETYPE encoder,
 	OMX_PTR v_omx, UNUSED OMX_BUFFERHEADERTYPE *buffer) {
 
 	// Called by OMX when the encoder component has filled

src/encoders/omx/encoder.h

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
@@ -26,10 +27,11 @@
 #include <IL/OMX_Component.h>
 #include <interface/vcos/vcos_semaphore.h>
 
-#include "../device.h"
+#include "../../device.h"
 
-
-#define OMX_MAX_ENCODERS 3
+#ifndef OMX_MAX_ENCODERS
+#	define OMX_MAX_ENCODERS 3 // Raspberry Pi limitation
+#endif
 
 
 struct omx_encoder_t {
@@ -48,8 +50,8 @@ struct omx_encoder_t {
 };
 
 
-struct omx_encoder_t *omx_encoder_init();
+struct omx_encoder_t *omx_encoder_init(void);
 void omx_encoder_destroy(struct omx_encoder_t *omx);
 
-int omx_encoder_prepare_live(struct omx_encoder_t *omx, struct device_t *dev, const unsigned quality, const bool use_ijg);
-int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev, const unsigned index);
+int omx_encoder_prepare(struct omx_encoder_t *omx, struct device_t *dev, unsigned quality);
+int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev, unsigned index);

src/encoders/omx/formatters.c

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
@@ -19,14 +20,15 @@
 *****************************************************************************/
 
 
+#include "formatters.h"
+
 #include <stdio.h>
 #include <assert.h>
 
 #include <IL/OMX_IVCommon.h>
 #include <IL/OMX_Core.h>
 
-#include "../tools.h"
-#include "formatters.h"
+#include "../../tools.h"
 
 
 #define CASE_TO_STRING(_value) \
@@ -38,7 +40,7 @@
 		assert(0 && _buf); \
 	}
 
-const char *omx_error_to_string(const OMX_ERRORTYPE error) {
+const char *omx_error_to_string(OMX_ERRORTYPE error) {
 	switch (error) {
 		CASE_TO_STRING(OMX_ErrorNone);
 		CASE_TO_STRING(OMX_ErrorInsufficientResources);
@@ -69,7 +71,7 @@ const char *omx_error_to_string(const OMX_ERRORTYPE error) {
 	}
 }
 
-const char *omx_state_to_string(const OMX_STATETYPE state) {
+const char *omx_state_to_string(OMX_STATETYPE state) {
 	switch (state) {
 		CASE_TO_STRING(OMX_StateLoaded);
 		CASE_TO_STRING(OMX_StateIdle);

src/encoders/omx/formatters.h

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
@@ -29,8 +30,8 @@
 #include <IL/OMX_Core.h>
 #include <IL/OMX_Image.h>
 
-#include "../logging.h"
-#include "../tools.h"
+#include "../../logging.h"
+#include "../../tools.h"
 
 
 #define LOG_OMX_ERROR(_error, _msg, ...) { \
@@ -41,5 +42,5 @@
 	}
 
 
-const char *omx_error_to_string(const OMX_ERRORTYPE error);
-const char *omx_state_to_string(const OMX_STATETYPE state);
+const char *omx_error_to_string(OMX_ERRORTYPE error);
+const char *omx_state_to_string(OMX_STATETYPE state);

src/gpio.h

@@ -0,0 +1,92 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#                                                                            #
+#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include <stdlib.h>
+
+#include <wiringPi.h>
+
+#include "logging.h"
+
+
+int gpio_pin_prog_running;
+int gpio_pin_stream_online;
+int gpio_pin_has_http_clients;
+int gpio_pin_workers_busy_at;
+
+
+#define GPIO_INIT { \
+		gpio_pin_prog_running = -1; \
+		gpio_pin_stream_online = -1; \
+		gpio_pin_has_http_clients = -1; \
+		gpio_pin_workers_busy_at = -1; \
+	}
+
+#define GPIO_INIT_PIN(_role, _offset) { \
+		if (gpio_pin_##_role >= 0) { \
+			pinMode(gpio_pin_##_role + _offset, OUTPUT); \
+			digitalWrite(gpio_pin_##_role + _offset, LOW); \
+			if (_offset == 0) { \
+				LOG_INFO("GPIO: Using pin %d as %s", gpio_pin_##_role, #_role); \
+			} else { \
+				LOG_INFO("GPIO: Using pin %d+%d as %s", gpio_pin_##_role, _offset, #_role); \
+			} \
+		} \
+	}
+
+#define GPIO_INIT_PINOUT { \
+		if ( \
+			gpio_pin_prog_running >= 0 \
+			|| gpio_pin_stream_online >= 0 \
+			|| gpio_pin_has_http_clients >= 0 \
+			|| gpio_pin_workers_busy_at >= 0 \
+		) { \
+			LOG_INFO("GPIO: Using wiringPi"); \
+			if (wiringPiSetupGpio() < 0) { \
+				LOG_PERROR("GPIO: Can't initialize wiringPi"); \
+				exit(1); \
+			} else { \
+				GPIO_INIT_PIN(prog_running, 0); \
+				GPIO_INIT_PIN(stream_online, 0); \
+				GPIO_INIT_PIN(has_http_clients, 0); \
+				GPIO_INIT_PIN(workers_busy_at, 0); \
+			} \
+		} \
+	}
+
+#define GPIO_SET_STATE(_role, _offset, _state) { \
+		if (gpio_pin_##_role >= 0) { \
+			if (_offset == 0) { \
+				LOG_DEBUG("GPIO: Writing %d to pin %d (%s)", _state, gpio_pin_##_role, #_role); \
+			} else { \
+				LOG_DEBUG("GPIO: Writing %d to pin %d+%d (%s)", _state, gpio_pin_##_role, _offset, #_role); \
+			} \
+			digitalWrite(gpio_pin_##_role + _offset, _state); \
+		} \
+	}
+
+#define GPIO_SET_LOW(_role)		GPIO_SET_STATE(_role, 0, LOW)
+#define GPIO_SET_HIGH(_role)	GPIO_SET_STATE(_role, 0, HIGH)
+
+#define GPIO_SET_LOW_AT(_role, _offset)		GPIO_SET_STATE(_role, _offset, LOW)
+#define GPIO_SET_HIGH_AT(_role, _offset)	GPIO_SET_STATE(_role, _offset, HIGH)

src/http/base64.c

@@ -0,0 +1,72 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#                                                                            #
+#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "base64.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "../tools.h"
+
+
+static const char ENCODING_TABLE[] = {
+	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+	'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+	'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+	'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+	'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+	'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+	'w', 'x', 'y', 'z', '0', '1', '2', '3',
+	'4', '5', '6', '7', '8', '9', '+', '/',
+};
+
+static const unsigned MOD_TABLE[] = {0, 2, 1};
+
+
+char *base64_encode(const unsigned char *str) {
+	size_t str_len = strlen((const char *)str);
+	size_t encoded_size = 4 * ((str_len + 2) / 3) + 1; // +1 for '\0'
+	char *encoded;
+
+	A_CALLOC(encoded, encoded_size);
+
+	for (unsigned str_index = 0, encoded_index = 0; str_index < str_len;) {
+		unsigned octet_a = (str_index < str_len ? (unsigned char)str[str_index++] : 0);
+		unsigned octet_b = (str_index < str_len ? (unsigned char)str[str_index++] : 0);
+		unsigned octet_c = (str_index < str_len ? (unsigned char)str[str_index++] : 0);
+
+		unsigned triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;
+
+		encoded[encoded_index++] = ENCODING_TABLE[(triple >> 3 * 6) & 0x3F];
+		encoded[encoded_index++] = ENCODING_TABLE[(triple >> 2 * 6) & 0x3F];
+		encoded[encoded_index++] = ENCODING_TABLE[(triple >> 1 * 6) & 0x3F];
+		encoded[encoded_index++] = ENCODING_TABLE[(triple >> 0 * 6) & 0x3F];
+	}
+
+	for (unsigned index = 0; index < MOD_TABLE[str_len % 3]; index++) {
+		encoded[encoded_size - 2 - index] = '=';
+	}
+
+	encoded[encoded_size - 1] = '\0';
+	return encoded;
+}

src/http/base64.h

@@ -0,0 +1,28 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#                                                                            #
+#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include <stdlib.h>
+
+
+char *base64_encode(const unsigned char *str);

src/http/blank.c

@@ -0,0 +1,174 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#                                                                            #
+#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "blank.h"
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+#include <setjmp.h>
+
+#include <jpeglib.h>
+
+#include "../tools.h"
+#include "../logging.h"
+
+#include "data/blank_jpeg.h"
+
+
+struct _jpeg_error_manager_t {
+	struct jpeg_error_mgr	mgr; // Default manager
+	jmp_buf					jmp;
+};
+
+
+static struct blank_t *_blank_init_internal(void);
+static struct blank_t *_blank_init_external(const char *path);
+static int _jpeg_read_geometry(FILE *fp, unsigned *width, unsigned *height);
+static void _jpeg_error_handler(j_common_ptr jpeg);
+
+
+struct blank_t *blank_init(const char *path) {
+	struct blank_t *blank = NULL;
+
+	if (path) {
+		blank = _blank_init_external(path);
+	}
+
+	if (blank) {
+		LOG_INFO("Using external blank placeholder: %s", path);
+	} else {
+		blank = _blank_init_internal();
+		LOG_INFO("Using internal blank placeholder");
+	}
+	return blank;
+}
+
+void blank_destroy(struct blank_t *blank) {
+	free(blank->picture.data);
+	free(blank);
+}
+
+static struct blank_t *_blank_init_internal(void) {
+	struct blank_t *blank;
+
+	A_CALLOC(blank, 1);
+
+	A_CALLOC(blank->picture.data, ARRAY_LEN(BLANK_JPEG_DATA));
+	memcpy(blank->picture.data, BLANK_JPEG_DATA, ARRAY_LEN(BLANK_JPEG_DATA));
+
+	blank->picture.used = ARRAY_LEN(BLANK_JPEG_DATA);
+	blank->picture.allocated = ARRAY_LEN(BLANK_JPEG_DATA);
+
+	blank->width = BLANK_JPEG_WIDTH;
+	blank->height = BLANK_JPEG_HEIGHT;
+
+	return blank;
+}
+
+static struct blank_t *_blank_init_external(const char *path) {
+	FILE *fp = NULL;
+	struct blank_t *blank;
+
+	A_CALLOC(blank, 1);
+
+	if ((fp = fopen(path, "rb")) == NULL) {
+		LOG_PERROR("Can't open blank placeholder '%s'", path);
+		goto error;
+	}
+
+	if (_jpeg_read_geometry(fp, &blank->width, &blank->height) < 0) {
+		goto error;
+	}
+
+	if (fseek(fp, 0, SEEK_SET) < 0) {
+		LOG_PERROR("Can't seek to begin of the blank placeholder");
+		goto error;
+	}
+
+#	define CHUNK_SIZE (100 * 1024)
+	while (true) {
+		if (blank->picture.used + CHUNK_SIZE >= blank->picture.allocated) {
+			blank->picture.allocated = blank->picture.used + CHUNK_SIZE * 2;
+			A_REALLOC(blank->picture.data, blank->picture.allocated);
+		}
+
+		size_t readed = fread(blank->picture.data + blank->picture.used, 1, CHUNK_SIZE, fp);
+		blank->picture.used += readed;
+
+		if (readed < CHUNK_SIZE) {
+			if (feof(fp)) {
+				goto ok;
+			} else {
+				LOG_PERROR("Can't read blank placeholder");
+				goto error;
+			}
+		}
+	}
+#	undef CHUNK_SIZE
+
+	error:
+		free(blank->picture.data);
+		free(blank);
+		blank = NULL;
+
+	ok:
+		if (fp) {
+			fclose(fp);
+		}
+
+	return blank;
+}
+
+static int _jpeg_read_geometry(FILE *fp, unsigned *width, unsigned *height) {
+	struct jpeg_decompress_struct jpeg;
+	struct _jpeg_error_manager_t jpeg_error;
+
+	jpeg_create_decompress(&jpeg);
+
+	// https://stackoverflow.com/questions/19857766/error-handling-in-libjpeg
+	jpeg.err = jpeg_std_error((struct jpeg_error_mgr *)&jpeg_error);
+	jpeg_error.mgr.error_exit = _jpeg_error_handler;
+	if (setjmp(jpeg_error.jmp) < 0) {
+		jpeg_destroy_decompress(&jpeg);
+		return -1;
+	}
+
+	jpeg_stdio_src(&jpeg, fp);
+	jpeg_read_header(&jpeg, TRUE);
+	jpeg_start_decompress(&jpeg);
+
+	*width = jpeg.output_width;
+	*height = jpeg.output_height;
+
+	jpeg_destroy_decompress(&jpeg);
+	return 0;
+}
+
+static void _jpeg_error_handler(j_common_ptr jpeg) {
+	struct _jpeg_error_manager_t *jpeg_error = (struct _jpeg_error_manager_t *)jpeg->err;
+	char msg[JMSG_LENGTH_MAX];
+
+	(*jpeg_error->mgr.format_message)(jpeg, msg);
+	LOG_ERROR("Invalid blank placeholder: %s", msg);
+	longjmp(jpeg_error->jmp, -1);
+}

src/http/blank.h

@@ -0,0 +1,38 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#                                                                            #
+#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include <stdlib.h>
+
+#include "../device.h"
+
+
+struct blank_t {
+	struct picture_t	picture;
+	unsigned			width;
+	unsigned			height;
+};
+
+
+struct blank_t *blank_init(const char *path);
+void blank_destroy(struct blank_t *blank);

src/http/data/blank_jpeg.h

@@ -0,0 +1,723 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#                                                                            #
+#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+
+const unsigned BLANK_JPEG_WIDTH = 640;
+const unsigned BLANK_JPEG_HEIGHT = 480;
+
+const unsigned char BLANK_JPEG_DATA[] = {
+	0xFF, 0xD8, 0xFF, 0xE1, 0x09, 0x50, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, 0x62,
+	0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x78, 0x61, 0x70, 0x2F, 0x31, 0x2E, 0x30, 0x2F, 0x00, 0x3C, 0x3F, 0x78, 0x70, 0x61,
+	0x63, 0x6B, 0x65, 0x74, 0x20, 0x62, 0x65, 0x67, 0x69, 0x6E, 0x3D, 0x22, 0xEF, 0xBB, 0xBF, 0x22, 0x20, 0x69, 0x64, 0x3D,
+	0x22, 0x57, 0x35, 0x4D, 0x30, 0x4D, 0x70, 0x43, 0x65, 0x68, 0x69, 0x48, 0x7A, 0x72, 0x65, 0x53, 0x7A, 0x4E, 0x54, 0x63,
+	0x7A, 0x6B, 0x63, 0x39, 0x64, 0x22, 0x3F, 0x3E, 0x20, 0x3C, 0x78, 0x3A, 0x78, 0x6D, 0x70, 0x6D, 0x65, 0x74, 0x61, 0x20,
+	0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x78, 0x3D, 0x22, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x3A, 0x6E, 0x73, 0x3A, 0x6D, 0x65,
+	0x74, 0x61, 0x2F, 0x22, 0x20, 0x78, 0x3A, 0x78, 0x6D, 0x70, 0x74, 0x6B, 0x3D, 0x22, 0x41, 0x64, 0x6F, 0x62, 0x65, 0x20,
+	0x58, 0x4D, 0x50, 0x20, 0x43, 0x6F, 0x72, 0x65, 0x20, 0x35, 0x2E, 0x36, 0x2D, 0x63, 0x31, 0x33, 0x38, 0x20, 0x37, 0x39,
+	0x2E, 0x31, 0x35, 0x39, 0x38, 0x32, 0x34, 0x2C, 0x20, 0x32, 0x30, 0x31, 0x36, 0x2F, 0x30, 0x39, 0x2F, 0x31, 0x34, 0x2D,
+	0x30, 0x31, 0x3A, 0x30, 0x39, 0x3A, 0x30, 0x31, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x22, 0x3E, 0x20, 0x3C,
+	0x72, 0x64, 0x66, 0x3A, 0x52, 0x44, 0x46, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x72, 0x64, 0x66, 0x3D, 0x22, 0x68,
+	0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x77, 0x33, 0x2E, 0x6F, 0x72, 0x67, 0x2F, 0x31, 0x39, 0x39,
+	0x39, 0x2F, 0x30, 0x32, 0x2F, 0x32, 0x32, 0x2D, 0x72, 0x64, 0x66, 0x2D, 0x73, 0x79, 0x6E, 0x74, 0x61, 0x78, 0x2D, 0x6E,
+	0x73, 0x23, 0x22, 0x3E, 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6F,
+	0x6E, 0x20, 0x72, 0x64, 0x66, 0x3A, 0x61, 0x62, 0x6F, 0x75, 0x74, 0x3D, 0x22, 0x22, 0x2F, 0x3E, 0x20, 0x3C, 0x2F, 0x72,
+	0x64, 0x66, 0x3A, 0x52, 0x44, 0x46, 0x3E, 0x20, 0x3C, 0x2F, 0x78, 0x3A, 0x78, 0x6D, 0x70, 0x6D, 0x65, 0x74, 0x61, 0x3E,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x3F, 0x78, 0x70, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x20, 0x65,
+	0x6E, 0x64, 0x3D, 0x22, 0x77, 0x22, 0x3F, 0x3E, 0xFF, 0xED, 0x00, 0x2C, 0x50, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F,
+	0x70, 0x20, 0x33, 0x2E, 0x30, 0x00, 0x38, 0x42, 0x49, 0x4D, 0x04, 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xD4, 0x1D,
+	0x8C, 0xD9, 0x8F, 0x00, 0xB2, 0x04, 0xE9, 0x80, 0x09, 0x98, 0xEC, 0xF8, 0x42, 0x7E, 0xFF, 0xDB, 0x00, 0x84, 0x00, 0x01,
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+	0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+	0x03, 0x03, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x01, 0x01, 0x02, 0x02, 0x02, 0x01, 0x02, 0x02, 0x03,
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0xFF, 0xDD, 0x00, 0x04, 0x00, 0x50, 0xFF, 0xEE, 0x00, 0x0E, 0x41, 0x64,
+	0x6F, 0x62, 0x65, 0x00, 0x64, 0xC0, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x01, 0xE0, 0x02, 0x80, 0x03,
+	0x00, 0x11, 0x00, 0x01, 0x11, 0x01, 0x02, 0x11, 0x01, 0xFF, 0xC4, 0x00, 0x7D, 0x00, 0x01, 0x00, 0x02, 0x03, 0x01, 0x01,
+	0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x0B, 0x07, 0x08, 0x09, 0x05, 0x06, 0x02, 0x03,
+	0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
+	0x01, 0x00, 0x01, 0x04, 0x02, 0x01, 0x03, 0x02, 0x03, 0x04, 0x08, 0x04, 0x06, 0x03, 0x00, 0x00, 0x00, 0x03, 0x02, 0x04,
+	0x05, 0x06, 0x01, 0x07, 0x08, 0x09, 0x11, 0x12, 0x0A, 0x13, 0x14, 0x21, 0x22, 0x15, 0x37, 0x77, 0xB6, 0x16, 0x23, 0x31,
+	0x35, 0x39, 0x41, 0x75, 0xB4, 0x17, 0x38, 0xB5, 0xB7, 0x18, 0x1A, 0x24, 0x32, 0x51, 0x78, 0x56, 0x97, 0xD4, 0x11, 0x01,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xDA, 0x00, 0x0C,
+	0x03, 0x00, 0x00, 0x01, 0x11, 0x02, 0x11, 0x00, 0x3F, 0x00, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD0, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD1, 0xAF, 0xFC,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
+	0xFF, 0xD2, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD3, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 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, 0xFF, 0xD4, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD5, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD6, 0xAF, 0xFC,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
+	0xFF, 0xD7, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD0, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 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, 0xFF, 0xD1, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD2, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD3, 0xAF, 0xFC,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
+	0xFF, 0xD4, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD5, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 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, 0xFF, 0xD6, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD7, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD0, 0xAF, 0xFC,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
+	0xFF, 0xD1, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD2, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 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, 0xFF, 0xD3, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD4, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD5, 0xAF, 0xFC,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
+	0xFF, 0xD6, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD7, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 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, 0xFF, 0xD0, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD1, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD2, 0xAF, 0xFC,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
+	0xFF, 0xD3, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x06, 0x4C, 0xE9, 0x5B, 0x0B, 0x1C, 0xAF, 0x71, 0xF5, 0x2E, 0x2F, 0x29, 0x65, 0x69, 0x92, 0xC6, 0x64, 0xBB, 0x33,
+	0x43, 0xB0, 0xC8, 0xE3, 0xAF, 0xED, 0xA1, 0xBC, 0xB1, 0xBF, 0xB1, 0xBC, 0xDA, 0x71, 0x56, 0xF7, 0x76, 0x57, 0xB6, 0x97,
+	0x14, 0x49, 0x6F, 0x75, 0x69, 0x75, 0x6F, 0x25, 0x54, 0x49, 0x1D, 0x74, 0xD5, 0x45, 0x74, 0x55, 0xCD, 0x35, 0x71, 0xCF,
+	0x1C, 0xF3, 0xC0, 0x24, 0x45, 0xEB, 0x5F, 0xE9, 0x19, 0x61, 0xD4, 0x3F, 0xB6, 0x7C, 0xBB, 0xF1, 0x67, 0x4E, 0xB6, 0xC6,
+	0x75, 0x4C, 0x95, 0x47, 0x71, 0xDC, 0x5D, 0x53, 0xAA, 0xE3, 0x20, 0xB3, 0xC6, 0x75, 0x94, 0xF5, 0x71, 0x15, 0xBF, 0xF4,
+	0xE7, 0x4D, 0xC2, 0x63, 0xA0, 0x8A, 0x1B, 0x1D, 0x02, 0xF6, 0x5F, 0x6E, 0x72, 0x56, 0x50, 0x51, 0xF6, 0xF0, 0xD3, 0xD7,
+	0xF7, 0xE2, 0xA6, 0x9B, 0x0A, 0xEB, 0xA2, 0xC4, 0x23, 0x22, 0x0D, 0xD8, 0xF4, 0xE3, 0xEB, 0xED, 0x2F, 0xB5, 0xBC, 0xE3,
+	0xF1, 0xA7, 0xAE, 0xBB, 0x17, 0x5C, 0xC7, 0x6D, 0xBA, 0x46, 0xDD, 0xD9, 0x36, 0x38, 0x7D, 0x97, 0x5B, 0xCB, 0x47, 0x5C,
+	0xB8, 0xDC, 0xC6, 0x36, 0x6B, 0x0C, 0x85, 0x72, 0x59, 0xDD, 0xD1, 0x1C, 0x91, 0x49, 0xCC, 0x55, 0x57, 0x1D, 0x3C, 0xFE,
+	0x9A, 0xA9, 0xE7, 0x8E, 0x78, 0xE3, 0x9E, 0x39, 0x06, 0xF5, 0xFA, 0xF4, 0x78, 0xE9, 0xD2, 0x3E, 0x34, 0xF9, 0x4D, 0xD5,
+	0x7A, 0x6F, 0x44, 0x75, 0xBE, 0xBB, 0xD6, 0x3A, 0xBE, 0x6B, 0xA0, 0x30, 0xBB, 0x3E, 0x57, 0x0B, 0xAD, 0x45, 0x73, 0x0D,
+	0x95, 0xEE, 0x7E, 0xE3, 0xB1, 0x7B, 0x23, 0x15, 0x36, 0x52, 0x6A, 0x6E, 0xAE, 0x6E, 0x6B, 0xE6, 0xEA, 0x4C, 0x76, 0x26,
+	0xDA, 0x2E, 0x79, 0xE2, 0xAE, 0x38, 0xF8, 0x43, 0x4F, 0xE5, 0xFF, 0x00, 0xC8, 0x6B, 0xE7, 0xA6, 0xFF, 0x00, 0xA5, 0xD7,
+	0x6F, 0xFA, 0x83, 0xED, 0x57, 0xD7, 0xF8, 0xEB, 0xFE, 0x3A, 0xE7, 0xA3, 0xB5, 0x1C, 0x8C, 0x56, 0x3B, 0xCF, 0x6B, 0x64,
+	0x71, 0xF5, 0xE4, 0x3E, 0x59, 0x0A, 0xA0, 0xA6, 0xEB, 0x8D, 0x57, 0x49, 0xC4, 0x73, 0x35, 0xA5, 0x1B, 0x1E, 0xD3, 0x25,
+	0xBC, 0x91, 0xD7, 0x3F, 0xCA, 0x68, 0x6D, 0x31, 0xD6, 0xF2, 0xD3, 0x2C, 0xF5, 0xF3, 0x5D, 0x76, 0xF6, 0xF7, 0x01, 0xDA,
+	0xEE, 0xC7, 0x83, 0xD0, 0x8F, 0xD3, 0x07, 0x27, 0xFF, 0x00, 0x0E, 0x76, 0x0E, 0xA9, 0xAF, 0xCA, 0xCE, 0xF4, 0xD7, 0x61,
+	0xAE, 0xD3, 0x69, 0xC6, 0x65, 0x31, 0x98, 0xCE, 0xEE, 0xCB, 0x58, 0xE5, 0xE1, 0xB3, 0xBE, 0xB0, 0xA6, 0x1D, 0xEA, 0xDF,
+	0x71, 0xC9, 0xE0, 0xBA, 0x47, 0x57, 0xBF, 0xAA, 0x6B, 0xA9, 0x7F, 0x11, 0x8F, 0xB1, 0xB2, 0xFD, 0xA3, 0x67, 0x55, 0x31,
+	0xCD, 0x2D, 0x9F, 0xDC, 0x8E, 0xD6, 0xAE, 0x43, 0x15, 0xEA, 0xFE, 0xA3, 0x9E, 0x87, 0x9D, 0xD5, 0x2D, 0x3A, 0x2F, 0x73,
+	0xFA, 0x79, 0xEB, 0x1D, 0x25, 0x84, 0xCA, 0xDF, 0x5B, 0xC1, 0x46, 0xE7, 0xAB, 0x74, 0xDF, 0x5C, 0x5B, 0x59, 0x63, 0x20,
+	0xB8, 0xB7, 0xBB, 0xB4, 0xBA, 0xBE, 0xCD, 0xEC, 0x5D, 0x39, 0xCE, 0xAD, 0xD9, 0xD8, 0xCB, 0x7B, 0x5A, 0x2E, 0x7E, 0x54,
+	0xD1, 0x8C, 0xB4, 0xC8, 0xD7, 0x55, 0x5E, 0xD2, 0xF1, 0x4D, 0x32, 0x45, 0x1F, 0x20, 0xF1, 0xFC, 0xCA, 0xF4, 0x2E, 0xEB,
+	0xAD, 0xBF, 0xAB, 0x6B, 0xF2, 0x77, 0xD3, 0x43, 0x7A, 0xA7, 0xB2, 0xB4, 0x6B, 0xDC, 0x3D, 0xCE, 0xD3, 0x1F, 0x52, 0xF1,
+	0xB2, 0x45, 0xBA, 0xC1, 0x9C, 0xC2, 0x5A, 0xD1, 0x27, 0x37, 0x55, 0x75, 0x06, 0xEB, 0x45, 0x73, 0x64, 0x32, 0xB9, 0x1B,
+	0x0F, 0xC3, 0x57, 0x4D, 0x78, 0x3C, 0xBC, 0xB7, 0x59, 0x09, 0xAE, 0x28, 0x96, 0x28, 0xEE, 0xF9, 0xB9, 0xA6, 0x3B, 0x2A,
+	0xC2, 0x30, 0x12, 0x47, 0x24, 0x52, 0x57, 0x14, 0xB4, 0x57, 0x14, 0xB1, 0x57, 0x54, 0x72, 0x47, 0x25, 0x3C, 0xD1, 0x24,
+	0x72, 0x51, 0xCF, 0x34, 0xD7, 0x45, 0x74, 0x55, 0xC7, 0x15, 0x51, 0x5D, 0x15, 0x71, 0xCF, 0x1C, 0xF1, 0xCF, 0x1E, 0xFC,
+	0x72, 0x0F, 0xC0, 0x3A, 0x19, 0xE9, 0xA3, 0xE0, 0x76, 0x6B, 0xD4, 0x03, 0xC8, 0x9B, 0x6E, 0xAE, 0xE7, 0x33, 0x79, 0xAA,
+	0x75, 0xDE, 0xAB, 0x85, 0x97, 0x75, 0xED, 0x5D, 0xBB, 0x1F, 0x14, 0x32, 0x64, 0xF1, 0x7A, 0xAD, 0xB5, 0xF5, 0x9E, 0x3A,
+	0x1C, 0x56, 0xBD, 0xC5, 0xE4, 0x17, 0x18, 0xFA, 0xB6, 0x8D, 0x8F, 0x25, 0x7D, 0x1D, 0xBD, 0xA7, 0xDF, 0xA2, 0xB8, 0xE0,
+	0x8B, 0x89, 0xEE, 0xAA, 0x8E, 0x6A, 0x6D, 0xEA, 0x86, 0xB0, 0x90, 0x37, 0x92, 0x7D, 0xB9, 0xE8, 0xB9, 0xE9, 0x95, 0x9B,
+	0x8F, 0xC7, 0x5B, 0x0F, 0x0C, 0x74, 0x8F, 0x21, 0x3B, 0x3F, 0x09, 0x69, 0x8C, 0x9F, 0x70, 0xB4, 0xCB, 0xE9, 0x1A, 0x5F,
+	0x67, 0xDF, 0xEB, 0x52, 0x5E, 0x5B, 0x71, 0x91, 0x86, 0x9D, 0xC3, 0xB1, 0x7B, 0x82, 0xBC, 0xFD, 0xF5, 0xAE, 0xC9, 0x95,
+	0xB5, 0xC8, 0x53, 0x77, 0xC6, 0x3B, 0x19, 0x0C, 0x90, 0x43, 0x0C, 0x94, 0x53, 0x5D, 0x36, 0x91, 0xD3, 0x6F, 0x10, 0x3F,
+	0x5B, 0x0F, 0x40, 0xFA, 0x35, 0xFA, 0x99, 0x78, 0xCF, 0xDA, 0x3D, 0xD7, 0xD2, 0xB0, 0x6A, 0x9E, 0x21, 0x6D, 0x5D, 0x51,
+	0x87, 0x97, 0x2B, 0xB9, 0x6C, 0x18, 0xDD, 0x73, 0x0F, 0xD6, 0x37, 0xBD, 0x51, 0x27, 0x18, 0xDA, 0xB8, 0xC4, 0xCB, 0xD8,
+	0xFD, 0x51, 0xAF, 0xE4, 0xB9, 0xEB, 0xFD, 0x9B, 0x4F, 0xCE, 0xF3, 0x8E, 0xA7, 0xED, 0x5C, 0x62, 0x6A, 0xAA, 0x6B, 0xDB,
+	0x88, 0xE5, 0x86, 0xD6, 0xFA, 0x3B, 0xDE, 0x6E, 0xA1, 0xE4, 0x38, 0x81, 0xE8, 0xDF, 0xD6, 0xDD, 0x77, 0xD8, 0xFE, 0xA4,
+	0x7D, 0x35, 0xD7, 0xDD, 0x89, 0xAA, 0xE8, 0xFD, 0xB3, 0xA1, 0xDE, 0xDB, 0x77, 0x0C, 0x77, 0xD8, 0x3D, 0xC3, 0x56, 0xB1,
+	0xDA, 0x74, 0xDD, 0x8E, 0x8C, 0x3F, 0x53, 0xEF, 0x97, 0xD8, 0x9C, 0x8C, 0xDA, 0xDE, 0xE1, 0x88, 0xAE, 0x1B, 0x88, 0x63,
+	0xBE, 0xB2, 0x86, 0xF2, 0xD7, 0x8B, 0xBB, 0x3A, 0x27, 0x86, 0x5A, 0x28, 0xAF, 0x9A, 0x23, 0x96, 0x9F, 0x6A, 0x43, 0xEB,
+	0xFD, 0x72, 0xFA, 0xCB, 0xAD, 0xFA, 0x93, 0xCF, 0x7D, 0x8F, 0x4E, 0xEA, 0x9E, 0xBE, 0xD2, 0x3A, 0xCB, 0x51, 0x83, 0xAC,
+	0xFA, 0xDA, 0xFE, 0x0D, 0x5B, 0xAF, 0x75, 0x3C, 0x0E, 0x97, 0xAE, 0x43, 0x7D, 0x7D, 0x8B, 0xBA, 0x92, 0xFA, 0xF6, 0x2C,
+	0x1E, 0xB9, 0x61, 0x8D, 0xC6, 0x47, 0x77, 0x79, 0x25, 0x3C, 0x55, 0x2C, 0x9C, 0x45, 0xC5, 0x72, 0x73, 0xC7, 0xBD, 0x5C,
+	0xF3, 0xC8, 0x35, 0xA7, 0xC0, 0x5F, 0x4F, 0xEE, 0xE3, 0xF5, 0x01, 0xED, 0x59, 0xF4, 0x3E, 0xBA, 0xAE, 0xDB, 0x58, 0xD3,
+	0xF5, 0x98, 0x6D, 0x32, 0x5D, 0x99, 0xDA, 0x59, 0xAB, 0x39, 0xEF, 0x35, 0xED, 0x17, 0x11, 0x7B, 0x24, 0xD4, 0x59, 0x51,
+	0xC5, 0x94, 0x13, 0x5A, 0xCD, 0x9F, 0xD9, 0xF3, 0x55, 0x5B, 0x4B, 0x46, 0x3B, 0x17, 0x14, 0xD0, 0xD7, 0x73, 0x54, 0x52,
+	0x57, 0x24, 0xB0, 0x5B, 0x45, 0x3D, 0xC4, 0x41, 0x22, 0xCE, 0xC0, 0xEA, 0x0F, 0x43, 0xCF, 0x4A, 0x3B, 0x4C, 0x56, 0xA9,
+	0xDC, 0xDA, 0x87, 0xFE, 0x24, 0x7B, 0xD2, 0x28, 0xAC, 0xEF, 0xF2, 0x9A, 0xEE, 0xC5, 0x8C, 0xB0, 0xEE, 0x6E, 0xC0, 0xB8,
+	0x8E, 0x4B, 0x39, 0x66, 0x8A, 0xEF, 0x33, 0xA2, 0xE5, 0x32, 0x1A, 0xFF, 0x00, 0x4C, 0xE8, 0xF8, 0xA9, 0x69, 0xBC, 0xF9,
+	0xDA, 0xDA, 0xE4, 0x28, 0xB3, 0xBC, 0xBB, 0x86, 0x68, 0xA4, 0xF7, 0xBC, 0xA6, 0x1F, 0xBF, 0x18, 0x60, 0xAD, 0x2F, 0xD4,
+	0xD7, 0xD1, 0x2F, 0xB3, 0xAF, 0xE6, 0xD3, 0x3B, 0x67, 0xD3, 0x9F, 0x48, 0xE9, 0xDD, 0x77, 0x31, 0x73, 0x61, 0x04, 0x7B,
+	0xB6, 0x1B, 0xA1, 0x7A, 0x7F, 0x23, 0x6F, 0x8C, 0x8A, 0x2B, 0x9A, 0xAE, 0xE6, 0xBC, 0xCC, 0xE4, 0x3A, 0xDA, 0xC7, 0x0B,
+	0xD8, 0x98, 0x4B, 0x68, 0x6B, 0xB5, 0x86, 0x9E, 0x78, 0xC3, 0xDB, 0xE4, 0xA6, 0xB9, 0xA2, 0x49, 0x22, 0x92, 0x8E, 0x22,
+	0xF9, 0x71, 0x20, 0x63, 0x8F, 0x52, 0xDF, 0x4B, 0xCF, 0x07, 0x35, 0x5F, 0x19, 0x24, 0xF3, 0x77, 0xC3, 0x5E, 0xEE, 0xD6,
+	0x35, 0x8D, 0x06, 0xE3, 0x9C, 0x75, 0x38, 0x9D, 0x16, 0xF7, 0x74, 0x9F, 0x75, 0xD1, 0xBB, 0x0A, 0xEA, 0xFE, 0xEA, 0x58,
+	0xEB, 0xC2, 0x75, 0xB6, 0xC7, 0x7D, 0x79, 0x95, 0xDB, 0x71, 0xDB, 0xD5, 0xAD, 0x31, 0xCF, 0x54, 0xD8, 0x8B, 0xD9, 0x6F,
+	0x78, 0xA7, 0x9B, 0x49, 0x63, 0x93, 0xF0, 0x1C, 0xC1, 0x2F, 0x20, 0xC1, 0x3E, 0x85, 0x7E, 0x2D, 0x74, 0x8F, 0x97, 0x1B,
+	0x57, 0x96, 0x9D, 0x59, 0xDD, 0xFA, 0x46, 0x1B, 0x6A, 0xC3, 0xE4, 0x3A, 0x53, 0x0B, 0x6F, 0x84, 0xCD, 0x4F, 0x8E, 0xC7,
+	0x49, 0xB5, 0xE8, 0x99, 0x6C, 0x86, 0xCF, 0x55, 0xBD, 0x1B, 0x4E, 0x85, 0x9F, 0xBB, 0xB3, 0xBA, 0xBB, 0xD6, 0x76, 0x4B,
+	0x2A, 0xA9, 0xA2, 0xAA, 0x67, 0x83, 0xF4, 0x4D, 0x4D, 0x1F, 0x66, 0xE2, 0x89, 0xAD, 0xEB, 0x92, 0x1A, 0xC3, 0x9D, 0x3E,
+	0x77, 0x78, 0x45, 0xDA, 0x3E, 0x07, 0xF7, 0x96, 0x5B, 0xA9, 0xBB, 0x02, 0x19, 0x72, 0x9A, 0xFD, 0xF7, 0x17, 0x19, 0xAE,
+	0xB2, 0xEC, 0x2B, 0x7B, 0x4A, 0xE0, 0xC2, 0x76, 0x0E, 0x9D, 0xCD, 0xCD, 0x51, 0x5B, 0x64, 0xED, 0x3F, 0x54, 0xB1, 0xD9,
+	0x66, 0xF1, 0xD5, 0x73, 0x4C, 0x19, 0x4C, 0x7D, 0x55, 0xD5, 0x2D, 0x95, 0xD7, 0xF9, 0xD7, 0x04, 0xB6, 0xF3, 0xCC, 0x1A,
+	0x5A, 0x09, 0x44, 0xFA, 0x03, 0xF8, 0x73, 0xE3, 0x0F, 0x93, 0x7D, 0x45, 0xE4, 0x06, 0x6F, 0xBE, 0xFA, 0x5F, 0x4D, 0xED,
+	0x0C, 0xB6, 0xAF, 0xD8, 0xFA, 0xC6, 0x2B, 0x5F, 0xBF, 0xD9, 0xAD, 0xAF, 0x26, 0xB8, 0xC5, 0xE3, 0xAF, 0x75, 0x89, 0x6E,
+	0xEE, 0xAD, 0x2D, 0xAB, 0xB5, 0xBC, 0xB5, 0xF6, 0x86, 0x6B, 0x9A, 0x38, 0xAF, 0x9E, 0x2A, 0xE2, 0xAF, 0xD5, 0xFD, 0x9E,
+	0xDE, 0xFC, 0xFB, 0x84, 0x62, 0x33, 0x10, 0xC7, 0x6F, 0x97, 0xCA, 0xC1, 0x0D, 0x1C, 0x47, 0x0C, 0x19, 0x2B, 0xE8, 0x62,
+	0x8E, 0x9F, 0x7F, 0x6A, 0x23, 0x8E, 0xE6, 0x5A, 0x23, 0xA3, 0x8F, 0x7F, 0x7E, 0x7D, 0xA9, 0xA6, 0x9E, 0x38, 0x07, 0x9A,
+	0x09, 0x48, 0xFA, 0x14, 0x7A, 0x66, 0xF5, 0x9F, 0x79, 0xF4, 0xF7, 0x72, 0x79, 0x05, 0xE4, 0x87, 0x5E, 0x61, 0x77, 0x3D,
+	0x47, 0xB2, 0xB1, 0x99, 0xDE, 0x9B, 0xEA, 0x5C, 0x5E, 0xC9, 0x88, 0xB0, 0xC8, 0xFE, 0x03, 0x1B, 0x17, 0xCE, 0xDB, 0x7E,
+	0xEC, 0xDD, 0x66, 0x4C, 0x84, 0x17, 0xB1, 0xE2, 0x76, 0x5B, 0x4C, 0xD5, 0x11, 0x63, 0x30, 0xD9, 0x6B, 0x7A, 0x62, 0xBF,
+	0xC6, 0x5D, 0x63, 0xEF, 0xF9, 0x8A, 0xBA, 0x7E, 0xE7, 0x1C, 0x82, 0x3D, 0xDE, 0x53, 0x78, 0xF1, 0xB9, 0x78, 0xA7, 0xDF,
+	0xFD, 0x9F, 0xD0, 0x7B, 0xD4, 0x33, 0x7E, 0xD8, 0xEB, 0xDD, 0x9A, 0xF7, 0x17, 0x67, 0x93, 0x92, 0xD6, 0x4B, 0x4B, 0x7D,
+	0x9B, 0x5B, 0x96, 0xAF, 0xC5, 0xEA, 0xDB, 0x6E, 0x3A, 0x29, 0x3D, 0xF9, 0xE3, 0x1D, 0xB3, 0xE0, 0x27, 0xB7, 0xBD, 0x8B,
+	0x8F, 0x7E, 0x79, 0x8F, 0x89, 0xBE, 0xDD, 0x5E, 0xD5, 0xD1, 0x57, 0x1C, 0x06, 0xBF, 0x82, 0x57, 0x7F, 0x4E, 0xFF, 0x00,
+	0x8E, 0x9E, 0x3E, 0x77, 0x67, 0x4E, 0x79, 0x17, 0x94, 0xEE, 0x5E, 0x8A, 0xE9, 0xBE, 0xDB, 0xC9, 0xE1, 0x3B, 0x33, 0x54,
+	0xB0, 0xC2, 0xE4, 0x7B, 0x3B, 0xAC, 0x74, 0x9D, 0xF6, 0xFB, 0x11, 0x63, 0x71, 0xAB, 0x4F, 0x71, 0x71, 0x65, 0x8B, 0xBB,
+	0xDA, 0xB0, 0x79, 0x6B, 0x8C, 0x7D, 0xA4, 0xF7, 0x1C, 0x71, 0x5D, 0x71, 0xC5, 0x55, 0x14, 0x55, 0x5F, 0x1F, 0x2E, 0x78,
+	0xE7, 0x9F, 0xCC, 0x11, 0x57, 0xCD, 0xC7, 0x1C, 0x59, 0x9C, 0xBC, 0x51, 0x51, 0x44, 0x51, 0x45, 0x93, 0xBF, 0x8E, 0x38,
+	0xE3, 0xA7, 0x8A, 0x23, 0x8E, 0x3A, 0x2E, 0xA5, 0xA6, 0x8A, 0x28, 0xA2, 0x9E, 0x38, 0xA6, 0x8A, 0x28, 0xA7, 0x8E, 0x38,
+	0xE3, 0x8E, 0x38, 0xF6, 0xE3, 0x80, 0x79, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xD4, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x57, 0xE8, 0x6F, 0xDF, 0x97, 0x4C, 0xFF, 0x00, 0x15, 0xFA, 0xEF, 0xF9,
+	0xBF, 0x0E, 0x0B, 0x0F, 0x7C, 0xC4, 0xF3, 0x8B, 0xAA, 0x7C, 0x4D, 0xED, 0x0F, 0x1B, 0x7A, 0xDB, 0xBC, 0xEC, 0x31, 0x90,
+	0x75, 0x47, 0x93, 0x95, 0xF6, 0x96, 0x95, 0x9E, 0xDD, 0x33, 0x1F, 0x66, 0x6C, 0x26, 0x9F, 0x96, 0xC1, 0x45, 0xA0, 0xC1,
+	0x84, 0xE7, 0x6D, 0xB2, 0xBB, 0xA2, 0x4B, 0x09, 0x34, 0x5D, 0x82, 0x3D, 0xBE, 0xEA, 0xD3, 0x29, 0x3C, 0xDC, 0x73, 0x1D,
+	0x9F, 0x15, 0x45, 0x34, 0xBE, 0xD6, 0xB4, 0xDC, 0x55, 0x48, 0x45, 0x0F, 0xD6, 0x3B, 0xD2, 0xB2, 0xEF, 0xC3, 0xFD, 0xBA,
+	0x6E, 0xFE, 0xE8, 0xEC, 0x54, 0xF9, 0x2F, 0x17, 0x7B, 0x0B, 0x33, 0xF2, 0x92, 0xCA, 0xC2, 0x9A, 0xEE, 0xFF, 0x00, 0xE0,
+	0xBE, 0xD1, 0x99, 0x9A, 0xB9, 0xAD, 0xB5, 0x8B, 0xE9, 0x69, 0xAA, 0x5A, 0xEB, 0xD1, 0x33, 0x32, 0x57, 0xED, 0x83, 0xC8,
+	0x57, 0xCF, 0x34, 0xC3, 0x5F, 0x3C, 0x58, 0x5C, 0x55, 0xC4, 0xDF, 0x84, 0x96, 0xF4, 0x34, 0xC3, 0xD2, 0x8B, 0xFC, 0x46,
+	0x3C, 0x46, 0xFE, 0x2D, 0xE3, 0x3F, 0xE9, 0xD9, 0x30, 0x74, 0xFF, 0x00, 0xEA, 0x34, 0xD7, 0x72, 0x9B, 0x7F, 0x9E, 0x1E,
+	0x3B, 0x6A, 0x78, 0x48, 0xA8, 0xB8, 0xCD, 0x6D, 0x1E, 0x3F, 0xE9, 0x3A, 0xEE, 0x22, 0x09, 0x24, 0xA6, 0x18, 0xE6, 0xCA,
+	0x66, 0xBB, 0x93, 0xB4, 0x71, 0xB8, 0xF8, 0xAB, 0x96, 0xAF, 0xD3, 0x15, 0x12, 0x5D, 0xDC, 0xD1, 0xC7, 0x35, 0x73, 0xF9,
+	0x53, 0xC7, 0x3E, 0xE0, 0xEA, 0xF7, 0xA8, 0x47, 0x67, 0xD9, 0xFA, 0x4A, 0xFA, 0x63, 0xF5, 0xFF, 0x00, 0x49, 0x78, 0xF7,
+	0x3C, 0x78, 0x1D, 0xEB, 0x3D, 0x06, 0x2F, 0xA5, 0xB4, 0xCD, 0xA2, 0xCE, 0xDE, 0x2B, 0x7C, 0x95, 0xAE, 0x46, 0xFB, 0x15,
+	0x7F, 0x9E, 0xED, 0x4E, 0xD8, 0xAE, 0x88, 0xFE, 0xD7, 0x1C, 0x6C, 0xB9, 0x4A, 0xA1, 0xBB, 0x96, 0x39, 0xE9, 0xE7, 0xE5,
+	0x6B, 0x95, 0xCB, 0x43, 0x35, 0x34, 0xF3, 0x44, 0x3F, 0x00, 0x41, 0x76, 0x69, 0xA6, 0xB9, 0x9A, 0x5B, 0x8B, 0x89, 0x64,
+	0x9E, 0xE2, 0x79, 0x2B, 0x9A, 0x79, 0xE6, 0xAE, 0xB9, 0x66, 0x9A, 0x69, 0x6B, 0xE6, 0xB9, 0x65, 0x96, 0x5A, 0xF9, 0xAA,
+	0xB9, 0x24, 0x92, 0xBA, 0xB9, 0xE6, 0xAA, 0xB9, 0xE7, 0x9E, 0x79, 0xE7, 0x9F, 0x7E, 0x41, 0xFC, 0xC1, 0xDF, 0xBF, 0x40,
+	0x9F, 0x36, 0x76, 0xBE, 0x97, 0xF2, 0x73, 0x13, 0xE3, 0x0E, 0xC5, 0x99, 0xBC, 0xBC, 0xE9, 0xDF, 0x21, 0x6E, 0xAE, 0xB1,
+	0xD8, 0xEC, 0x3D, 0xD4, 0xF2, 0x4D, 0x65, 0xA9, 0x76, 0xBD, 0xAE, 0x36, 0x7B, 0xBD, 0x73, 0x3F, 0x88, 0x8A, 0x49, 0x79,
+	0xA2, 0xC3, 0x8D, 0xAE, 0x3B, 0x1E, 0x71, 0x17, 0xF1, 0xC3, 0x47, 0x1F, 0x8B, 0x96, 0x6B, 0x29, 0x24, 0xE7, 0xDA, 0xD6,
+	0x90, 0x7C, 0x6F, 0xAF, 0xBF, 0x8B, 0x9A, 0xF7, 0x40, 0x79, 0x9F, 0x47, 0x60, 0x69, 0x58, 0xEB, 0x6C, 0x4E, 0xA9, 0xE4,
+	0x7E, 0xB3, 0x37, 0x65, 0xDD, 0xE3, 0x2D, 0x22, 0xAE, 0x1B, 0x5B, 0x2E, 0xC5, 0xB5, 0xCB, 0x5C, 0xE2, 0xFB, 0x0E, 0xAB,
+	0x68, 0xFE, 0x1C, 0xC5, 0xF6, 0xF3, 0x97, 0x75, 0x5A, 0x66, 0x26, 0xE7, 0x8A, 0xF9, 0xE7, 0x9B, 0xDC, 0x9C, 0xFC, 0x7C,
+	0x28, 0xA3, 0x88, 0xF8, 0xA8, 0x38, 0x6C, 0x09, 0x2C, 0x7D, 0x34, 0x7D, 0x9B, 0xA8, 0x6B, 0x9E, 0x41, 0xF7, 0xF7, 0x58,
+	0x66, 0xB2, 0x56, 0x76, 0x1B, 0x5F, 0x66, 0xF5, 0xBE, 0xB5, 0x95, 0xD2, 0xED, 0xEE, 0xE6, 0xA2, 0x09, 0x33, 0x55, 0x75,
+	0xF6, 0x5F, 0x31, 0x75, 0xB0, 0xE2, 0x71, 0xBC, 0x49, 0x4F, 0x1F, 0x8B, 0xC9, 0x51, 0x8B, 0xD8, 0xF8, 0xBE, 0xFB, 0x14,
+	0x55, 0xF7, 0x39, 0xB4, 0xB2, 0x9E, 0x5E, 0x29, 0xAA, 0x88, 0x64, 0xAA, 0x80, 0xD3, 0x5F, 0x58, 0x8F, 0x07, 0x7C, 0x87,
+	0xE8, 0xCF, 0x2B, 0xBB, 0xCB, 0xBB, 0x36, 0x2D, 0x4F, 0x66, 0xDA, 0x7A, 0x67, 0xB8, 0xBB, 0x2F, 0x69, 0xEC, 0x6D, 0x5F,
+	0xB5, 0xF1, 0x76, 0x17, 0xB9, 0x8D, 0x67, 0x19, 0x1E, 0xE9, 0x97, 0xB9, 0xCE, 0x53, 0xA5, 0x6C, 0xF9, 0x3B, 0x68, 0xA6,
+	0x8B, 0x54, 0xCB, 0xEB, 0x72, 0xDE, 0x57, 0x61, 0x69, 0x6F, 0x7D, 0xCC, 0x1C, 0x5E, 0x5A, 0x5A, 0x53, 0x25, 0xAF, 0x32,
+	0x51, 0x4D, 0x7F, 0x6C, 0x38, 0xE2, 0x0E, 0xBD, 0x7A, 0x12, 0xFF, 0x00, 0x89, 0xEF, 0x8F, 0xBF, 0xE9, 0x3D, 0xCB, 0xFF,
+	0x00, 0x64, 0xFB, 0x04, 0x19, 0x07, 0xEA, 0x0D, 0xFF, 0x00, 0x11, 0xAD, 0xA3, 0xF8, 0x51, 0xD5, 0x9F, 0xF4, 0x8B, 0xC0,
+	0x77, 0x77, 0x44, 0xBF, 0xC6, 0x7A, 0x47, 0xFA, 0x2E, 0xE3, 0xBB, 0x13, 0x5D, 0xC2, 0xD9, 0xC3, 0xDC, 0x7B, 0x2E, 0x83,
+	0xAE, 0x6E, 0x57, 0x12, 0x5D, 0x58, 0x5B, 0xCD, 0x71, 0x91, 0xEF, 0x7E, 0xF1, 0x87, 0x17, 0x4E, 0x1E, 0x4D, 0x82, 0x2E,
+	0x7D, 0xAD, 0xF2, 0x36, 0x9D, 0x69, 0x8F, 0xC9, 0x5B, 0xC3, 0x24, 0x55, 0x57, 0xC5, 0x17, 0x16, 0x18, 0x1E, 0x63, 0xA7,
+	0x9E, 0x6B, 0x97, 0xDE, 0xA0, 0x84, 0x2E, 0xD1, 0xB4, 0x6C, 0x9B, 0xBE, 0xC9, 0x9D, 0xDC, 0x37, 0x0C, 0xEE, 0x57, 0x67,
+	0xDA, 0xB6, 0x7C, 0xAD, 0xF6, 0x73, 0x61, 0xD8, 0x73, 0x97, 0xD7, 0x19, 0x2C, 0xC6, 0x6B, 0x31, 0x92, 0xB8, 0x92, 0xEA,
+	0xFF, 0x00, 0x25, 0x92, 0xBF, 0xBA, 0x92, 0x5B, 0x8B, 0xBB, 0xCB, 0xBB, 0x89, 0x6A, 0xAE, 0xBA, 0xEB, 0xAB, 0x9A, 0xAA,
+	0xAB, 0x90, 0x78, 0x20, 0xF4, 0x79, 0xCC, 0x65, 0xAA, 0xC4, 0xC7, 0x80, 0xAB, 0x29, 0x91, 0xAB, 0x05, 0x16, 0x46, 0x6C,
+	0xC4, 0x58, 0x5E, 0x6F, 0x6E, 0x79, 0xC4, 0xC7, 0x96, 0xB8, 0xB6, 0x82, 0xCA, 0x7C, 0xA4, 0x78, 0xEE, 0x65, 0xFC, 0x1D,
+	0x19, 0x19, 0xEC, 0xED, 0xA3, 0x8A, 0xB9, 0xF8, 0xA3, 0x89, 0x6A, 0x8A, 0x3A, 0x69, 0xE6, 0xAE, 0x69, 0xA7, 0x8E, 0x38,
+	0x09, 0x2E, 0x7D, 0x32, 0x7F, 0xBF, 0x7F, 0x26, 0xFF, 0x00, 0x84, 0x9A, 0x9F, 0xF3, 0x8D, 0x40, 0xEB, 0x6E, 0xED, 0xB1,
+	0xF8, 0xBF, 0xEA, 0xF5, 0x8F, 0xF2, 0xB7, 0xC1, 0xAE, 0xCD, 0x82, 0xCB, 0x47, 0xEF, 0xBF, 0x1B, 0xBB, 0x6B, 0xB2, 0xF0,
+	0x1A, 0x96, 0x46, 0x3A, 0x60, 0xBC, 0xD8, 0xF0, 0xF6, 0x7A, 0x96, 0xDF, 0x93, 0xD6, 0x75, 0x5E, 0xE0, 0xD1, 0x3F, 0x15,
+	0x25, 0xBC, 0xD9, 0x7C, 0x3D, 0xD5, 0xBD, 0xBD, 0xBD, 0x86, 0xD1, 0x8B, 0xE2, 0x4A, 0x69, 0xE2, 0x49, 0x7E, 0x15, 0xF3,
+	0x0D, 0x37, 0x16, 0x17, 0x14, 0x84, 0x28, 0x7C, 0x99, 0xF1, 0xAF, 0xB5, 0x7C, 0x4A, 0xEE, 0x5D, 0xBB, 0xA3, 0xBB, 0x8B,
+	0x07, 0x56, 0x1B, 0x6D, 0xD5, 0x6E, 0xB8, 0xE6, 0x0B, 0xBB, 0x7F, 0xBB, 0x36, 0x0B, 0x69, 0xC0, 0x5D, 0x55, 0x25, 0x58,
+	0x5D, 0xBF, 0x55, 0xC8, 0xC9, 0x14, 0x3C, 0x65, 0x35, 0xCC, 0xED, 0xB4, 0x7C, 0xD7, 0x04, 0xBF, 0x1A, 0x24, 0x8A, 0x4A,
+	0x64, 0xB7, 0x9E, 0x88, 0x6E, 0x61, 0x9A, 0x18, 0xC2, 0x54, 0x7F, 0x4C, 0x97, 0xEE, 0x37, 0xC9, 0xEF, 0xE2, 0xBE, 0x9D,
+	0xFC, 0xA1, 0x70, 0x08, 0x7B, 0x67, 0xFF, 0x00, 0xBF, 0x73, 0x5F, 0xEA, 0xD9, 0x1F, 0xF7, 0x93, 0x03, 0x28, 0xF8, 0xED,
+	0xD1, 0x9B, 0x97, 0x92, 0xDD, 0xDF, 0xD6, 0x5D, 0x13, 0xA0, 0xC1, 0xCC, 0xBB, 0x47, 0x65, 0xED, 0x78, 0xDD, 0x72, 0xD2,
+	0xE3, 0x98, 0x6A, 0xB8, 0xB7, 0xC3, 0xD8, 0xCF, 0x5F, 0x33, 0xE7, 0x36, 0x4C, 0x84, 0x54, 0x57, 0x1D, 0x75, 0x62, 0xB5,
+	0x8C, 0x1D, 0xBD, 0xCE, 0x42, 0xEF, 0xE3, 0x57, 0x15, 0x7E, 0x1A, 0xDA, 0xBF, 0x8F, 0xBD, 0x5E, 0xDC, 0x72, 0x12, 0xE5,
+	0xF5, 0x32, 0xF3, 0xA6, 0xC7, 0xD2, 0xDB, 0x59, 0xF0, 0xCB, 0xC4, 0xDF, 0x18, 0x78, 0x86, 0xDE, 0xEB, 0xAF, 0x26, 0xD1,
+	0xB7, 0x2D, 0xDF, 0x09, 0xC4, 0xF1, 0xF1, 0x3D, 0xFF, 0x00, 0x4C, 0x68, 0xD7, 0x3F, 0xB2, 0xE0, 0xD3, 0xF3, 0xF7, 0x54,
+	0x53, 0x54, 0x94, 0xDF, 0xF7, 0x16, 0x56, 0xDA, 0xFE, 0x6C, 0x85, 0xDF, 0x14, 0xF1, 0x71, 0xFF, 0x00, 0xA4, 0x92, 0x5E,
+	0x7F, 0x3B, 0x9E, 0x2A, 0xE4, 0x30, 0xE7, 0xAF, 0x17, 0x8F, 0x9A, 0x8F, 0x92, 0xFE, 0x35, 0xF4, 0xAF, 0xA8, 0xFF, 0x00,
+	0x47, 0x51, 0x46, 0x77, 0x1F, 0x8C, 0xD5, 0x75, 0x8B, 0x4D, 0xC7, 0x23, 0x65, 0x6F, 0x4F, 0x17, 0x39, 0x7E, 0xA0, 0xDF,
+	0x2B, 0x8B, 0x23, 0xA5, 0x67, 0xF2, 0x50, 0xC3, 0xF7, 0x6B, 0x82, 0xFB, 0x49, 0xDA, 0x33, 0x35, 0x59, 0x5D, 0xC5, 0x57,
+	0x3C, 0xCB, 0x07, 0x19, 0x6A, 0xE9, 0x97, 0x9A, 0x78, 0xB4, 0xE7, 0x8A, 0x42, 0x22, 0xC0, 0x98, 0xFF, 0x00, 0xD3, 0x25,
+	0xFB, 0x8D, 0xF2, 0x7B, 0xF8, 0xAF, 0xA7, 0x7F, 0x28, 0x5C, 0x02, 0x1E, 0xD9, 0xFF, 0x00, 0xEF, 0xDC, 0xD7, 0xFA, 0xB6,
+	0x47, 0xFD, 0xE4, 0xC0, 0xF2, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x01, 0xFF, 0xD5, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x57, 0xE8, 0x6F, 0xDF, 0x97, 0x4C, 0xFF, 0x00, 0x15, 0xFA, 0xEF, 0xF9, 0xBF, 0x0E,
+	0x09, 0x43, 0xFD, 0x4F, 0xFF, 0x00, 0xDC, 0x5E, 0x17, 0x7F, 0xAB, 0x77, 0xF7, 0xFB, 0x3E, 0x9D, 0x06, 0x35, 0xF4, 0x75,
+	0xF5, 0x2C, 0xD3, 0xFB, 0x1B, 0x50, 0x87, 0xD3, 0x8F, 0xCD, 0x6A, 0xF1, 0x7B, 0x76, 0x89, 0xBA, 0x62, 0x64, 0xD0, 0xFA,
+	0x83, 0x66, 0xDE, 0x64, 0xA6, 0xF3, 0x17, 0x90, 0xC5, 0x5F, 0xDB, 0xD1, 0x63, 0x6B, 0xD2, 0x7B, 0x75, 0xCD, 0xE5, 0x5C,
+	0x7C, 0x6D, 0xA4, 0xA3, 0x8E, 0x28, 0xD6, 0x6F, 0x2B, 0x92, 0x99, 0x20, 0x9B, 0x8A, 0x2C, 0x28, 0xAE, 0x9E, 0x78, 0xB0,
+	0xA6, 0x80, 0xF8, 0x7C, 0x7F, 0xA6, 0xA6, 0xE3, 0xE0, 0x17, 0xAB, 0x8F, 0x89, 0x17, 0x78, 0x58, 0xF2, 0x5B, 0x27, 0x8E,
+	0x9D, 0x85, 0xDE, 0x11, 0x4B, 0xD5, 0x1B, 0xC4, 0xD4, 0x57, 0x71, 0x3E, 0x2A, 0x4E, 0x71, 0x99, 0x7B, 0xD9, 0x3A, 0xE7,
+	0x72, 0xB9, 0xA2, 0x2A, 0x61, 0x83, 0x6D, 0xC1, 0xDA, 0xD3, 0x5F, 0xD8, 0x9B, 0xF4, 0xC7, 0x98, 0xB1, 0x8B, 0xF1, 0x51,
+	0x53, 0x4C, 0x94, 0x5D, 0x5B, 0xDA, 0x87, 0xD9, 0x7A, 0xE9, 0x6C, 0xB8, 0x9D, 0x2F, 0xD5, 0x33, 0xC2, 0x3D, 0xC7, 0x3D,
+	0x2C, 0x30, 0x60, 0xF5, 0x3D, 0x17, 0xA4, 0xB6, 0x5C, 0xCC, 0xF7, 0x32, 0xC7, 0x05, 0xBC, 0x38, 0x9C, 0x17, 0x91, 0x5B,
+	0xEE, 0x53, 0x23, 0x2C, 0xF3, 0x4D, 0xFD, 0x4C, 0x30, 0xC7, 0x67, 0x6B, 0x5F, 0x35, 0x55, 0x5F, 0xE9, 0xA6, 0x9E, 0x39,
+	0xE7, 0x9F, 0xC8, 0x1B, 0x0F, 0xF5, 0x36, 0x68, 0xF9, 0xCC, 0xB7, 0x4D, 0xF8, 0xB7, 0xD9, 0x56, 0x34, 0x49, 0x36, 0xB5,
+	0xA8, 0x76, 0x26, 0xFF, 0x00, 0xA9, 0xE6, 0x64, 0x86, 0x3A, 0xE5, 0x86, 0x2C, 0x87, 0x60, 0x6B, 0x9A, 0xFE, 0x57, 0x01,
+	0x71, 0x34, 0xB4, 0x55, 0xCC, 0x71, 0x45, 0x54, 0x3D, 0x7F, 0x7B, 0x45, 0x35, 0x55, 0xC7, 0xB5, 0x55, 0x49, 0xC7, 0x1C,
+	0x55, 0xC7, 0x3C, 0xFB, 0x54, 0x10, 0xEA, 0x00, 0x1B, 0xDD, 0xE9, 0x87, 0xA2, 0xE7, 0xFB, 0x0F, 0xD4, 0x1B, 0xC4, 0x1C,
+	0x1E, 0xB9, 0x1C, 0xF2, 0x5E, 0xE2, 0xFB, 0xDB, 0x41, 0xDE, 0xAF, 0x79, 0x82, 0x89, 0xAB, 0xE6, 0x2C, 0x07, 0x5A, 0x66,
+	0xAD, 0xFB, 0x0B, 0x66, 0x92, 0x5E, 0x60, 0xA6, 0xAA, 0xA8, 0x83, 0xFA, 0x3F, 0xAC, 0x5C, 0xF1, 0x5D, 0x55, 0x7B, 0x51,
+	0xED, 0x57, 0xEA, 0xE7, 0x8E, 0x39, 0xE4, 0x1D, 0x98, 0xFA, 0x9C, 0xF6, 0x9C, 0x35, 0xDF, 0x6B, 0x78, 0xA1, 0xA4, 0xC1,
+	0x24, 0x1C, 0xEC, 0x1A, 0xFF, 0x00, 0x5E, 0xF6, 0x56, 0xD3, 0x93, 0x86, 0x9F, 0x87, 0xE2, 0x68, 0xC3, 0x6E, 0x3B, 0x26,
+	0xB5, 0x89, 0xC1, 0x49, 0x2F, 0xB7, 0x3F, 0x73, 0xEC, 0x4B, 0x7B, 0xA3, 0x64, 0x78, 0x8F, 0xDF, 0x8E, 0x29, 0xF9, 0x51,
+	0x5F, 0xB7, 0xBF, 0x3E, 0xFE, 0xC1, 0x17, 0x90, 0x7D, 0x36, 0x9B, 0xB9, 0xED, 0xBD, 0x77, 0xB5, 0x60, 0x37, 0x9D, 0x13,
+	0x64, 0xCC, 0xEA, 0x1B, 0x8E, 0xAD, 0x93, 0xB6, 0xCC, 0xEB, 0x9B, 0x36, 0xBD, 0x90, 0xB9, 0xC5, 0x66, 0xB0, 0xB9, 0x4B,
+	0x3A, 0xFE, 0xE5, 0xBD, 0xF6, 0x3F, 0x21, 0x67, 0x24, 0x57, 0x16, 0xD3, 0xC7, 0x57, 0xE5, 0xEF, 0x4D, 0x5F, 0xAA, 0x9E,
+	0x79, 0xA7, 0x9F, 0x7E, 0x39, 0xE7, 0x8E, 0x42, 0x45, 0x7E, 0x34, 0x7D, 0x47, 0xDD, 0xDF, 0xA7, 0xD9, 0xE3, 0xF5, 0x4F,
+	0x2A, 0x3A, 0xA7, 0x59, 0xEF, 0x0C, 0x04, 0x76, 0x3F, 0xB3, 0x6F, 0x77, 0x5D, 0x42, 0xBB, 0x7D, 0x0F, 0xB0, 0x2E, 0x69,
+	0xAA, 0x9A, 0x29, 0x92, 0xFF, 0x00, 0x3B, 0x87, 0xAA, 0xDA, 0xFB, 0x43, 0xD9, 0xA4, 0x96, 0x1E, 0x2B, 0x8A, 0xBB, 0x7B,
+	0x6B, 0x5C, 0x0D, 0x15, 0xFC, 0xF8, 0xAF, 0x99, 0x39, 0xE6, 0x9E, 0x69, 0x90, 0x3A, 0x21, 0xB8, 0xF8, 0x41, 0xE9, 0xB5,
+	0xEA, 0xFD, 0xD0, 0x9B, 0x17, 0x75, 0x78, 0x85, 0x8E, 0xD7, 0xBA, 0x77, 0xB8, 0x21, 0xAE, 0xFA, 0x9A, 0xB2, 0xFA, 0xCE,
+	0xBB, 0x69, 0xA3, 0x5D, 0xE1, 0xB7, 0xD9, 0xED, 0xE8, 0xC9, 0x73, 0xAD, 0xF7, 0x77, 0x59, 0xE1, 0xB9, 0xAF, 0x09, 0x77,
+	0x1E, 0x6E, 0x4E, 0x79, 0xAA, 0x4C, 0xB5, 0x8D, 0x32, 0x4F, 0x2D, 0x72, 0x57, 0x73, 0x6F, 0x7B, 0x77, 0x4D, 0x12, 0xC3,
+	0x28, 0x70, 0xFB, 0xD1, 0x67, 0x50, 0xD8, 0x7A, 0xF7, 0xD5, 0xBB, 0xAA, 0x74, 0x1D, 0xBB, 0x1D, 0x26, 0x23, 0x6B, 0xD1,
+	0xEF, 0xFC, 0x82, 0xD4, 0x36, 0x7C, 0x4C, 0xD5, 0x51, 0x5C, 0xD8, 0xBD, 0x87, 0x5A, 0xEA, 0x8E, 0xCB, 0xC2, 0xE6, 0xB1,
+	0xD2, 0xD7, 0x1D, 0x55, 0xC7, 0x54, 0x96, 0x59, 0x2B, 0x29, 0x62, 0xAB, 0x9A, 0x79, 0xE6, 0x9E, 0x79, 0xA7, 0xF2, 0xE7,
+	0x9E, 0x01, 0xED, 0xFD, 0x41, 0xBF, 0xE2, 0x35, 0xB4, 0x7F, 0x0A, 0x3A, 0xB3, 0xFE, 0x91, 0x78, 0x0E, 0xDB, 0xFA, 0xD6,
+	0x63, 0x2E, 0x3B, 0x67, 0xD2, 0x2B, 0xAA, 0xBB, 0x13, 0x47, 0x8F, 0x8B, 0x9D, 0x5B, 0x05, 0x9A, 0xF1, 0xDF, 0xB5, 0xAF,
+	0x2B, 0xB1, 0xF6, 0x9E, 0xDA, 0x8D, 0x2F, 0x62, 0xD2, 0x72, 0x5A, 0xBE, 0x2E, 0xE6, 0x3A, 0xED, 0x7D, 0xA1, 0xAA, 0xCE,
+	0x9C, 0x96, 0xFF, 0x00, 0x8E, 0xE7, 0x8A, 0xF8, 0xE3, 0xED, 0xFC, 0x79, 0xE3, 0x9E, 0x3D, 0xB8, 0xF6, 0xE7, 0x80, 0x84,
+	0x68, 0x24, 0x81, 0xA0, 0xFD, 0x47, 0xFD, 0xDF, 0xA0, 0xE8, 0x9A, 0x56, 0x89, 0x67, 0xE3, 0x7F, 0x55, 0x64, 0x2D, 0x34,
+	0xAD, 0x4B, 0x5C, 0xD4, 0xAD, 0x6F, 0xEE, 0x76, 0x9D, 0xBA, 0x2B, 0x9B, 0xDB, 0x6D, 0x73, 0x0F, 0x67, 0x87, 0x82, 0xEE,
+	0xE2, 0x38, 0xA9, 0xFB, 0x51, 0xCD, 0x73, 0x15, 0x9F, 0x15, 0xD7, 0x4D, 0x3F, 0xA7, 0x8A, 0xAA, 0xE7, 0x8E, 0x3F, 0x20,
+	0x77, 0xBB, 0xC6, 0x5F, 0x30, 0xF6, 0x5F, 0x39, 0xBD, 0x36, 0xBB, 0x9B, 0xBE, 0xB6, 0xCD, 0x3B, 0x07, 0xA2, 0xE6, 0x2F,
+	0xF4, 0xBE, 0xFF, 0x00, 0xD5, 0xEB, 0xC0, 0xEB, 0xB7, 0xD7, 0xF9, 0x1C, 0x6D, 0x10, 0x6B, 0x7A, 0x8E, 0x4E, 0x08, 0x2E,
+	0xA8, 0xB9, 0xC9, 0x71, 0xC5, 0xD7, 0x32, 0xDC, 0xD3, 0x3F, 0x3C, 0xD7, 0x4F, 0x3F, 0xA7, 0x8E, 0x78, 0xFC, 0x81, 0xC3,
+	0xEF, 0xA6, 0x4F, 0xF7, 0xEF, 0xE4, 0xDF, 0xF0, 0x93, 0x53, 0xFE, 0x71, 0xA8, 0x1C, 0xA7, 0xF2, 0xB3, 0xB8, 0xBB, 0x1B,
+	0xA0, 0x3D, 0x50, 0x7C, 0x9C, 0xED, 0xFE, 0xA6, 0xD9, 0xAF, 0xB5, 0x0D, 0xFF, 0x00, 0x47, 0xF2, 0xC7, 0xBA, 0x72, 0xD8,
+	0x1C, 0xD5, 0x85, 0x7F, 0x9D, 0x12, 0x71, 0xD8, 0x3B, 0x1C, 0x17, 0x76, 0x17, 0xD6, 0xF5, 0x7B, 0xC1, 0x91, 0xC3, 0xE5,
+	0xAC, 0x66, 0x96, 0xD6, 0xF6, 0xD2, 0x6A, 0x6B, 0x82, 0xEE, 0xD6, 0x69, 0x22, 0x92, 0x9A, 0xA8, 0xAF, 0x9E, 0x39, 0x09,
+	0x24, 0x66, 0xF1, 0xBE, 0x3F, 0xFD, 0x40, 0x3E, 0x16, 0xF1, 0x9C, 0xC1, 0x51, 0xAF, 0x75, 0xAF, 0x98, 0x7D, 0x3D, 0x67,
+	0xF6, 0x68, 0x86, 0x79, 0x2A, 0x92, 0xE7, 0x47, 0xDC, 0x2E, 0x20, 0xAA, 0x7A, 0xB0, 0x79, 0x39, 0x78, 0xA2, 0x5C, 0xC6,
+	0x5B, 0xA5, 0x3B, 0x32, 0xAB, 0x4A, 0xEA, 0xB4, 0xB9, 0xE2, 0x99, 0xA4, 0xC7, 0xDC, 0xD1, 0xCD, 0x7C, 0x71, 0x2D, 0xCD,
+	0x95, 0xCD, 0xBC, 0xE1, 0xFE, 0x7D, 0x3C, 0x5D, 0x61, 0xBE, 0x74, 0xBE, 0x9F, 0xE6, 0x67, 0x55, 0xF6, 0x76, 0xB5, 0x91,
+	0xD4, 0x37, 0xDD, 0x1B, 0xBC, 0x35, 0x7C, 0x0E, 0xCD, 0xAF, 0x65, 0x22, 0xFB, 0x77, 0x56, 0x17, 0xF6, 0xDA, 0x84, 0xB5,
+	0xD3, 0x55, 0x15, 0xD3, 0xCD, 0x50, 0xDD, 0xD8, 0xDE, 0xDB, 0x49, 0x1D, 0xC5, 0xAD, 0xCC, 0x35, 0x57, 0x6F, 0x77, 0x6B,
+	0x2C, 0x73, 0x43, 0x5D, 0x71, 0x49, 0x45, 0x75, 0x04, 0x2E, 0x73, 0xFF, 0x00, 0xDF, 0xB9, 0xAF, 0xF5, 0x6C, 0x8F, 0xFB,
+	0xC9, 0x81, 0x2A, 0xDF, 0x40, 0x5F, 0x1C, 0x75, 0x4E, 0x94, 0xE9, 0xEE, 0xEB, 0xF5, 0x22, 0xEE, 0xEE, 0x6D, 0xF0, 0x1A,
+	0xE6, 0x3F, 0x5A, 0xDA, 0xB5, 0xDE, 0xBF, 0xCC, 0x65, 0x21, 0xE7, 0xED, 0xE2, 0x3A, 0xFB, 0x4E, 0xA2, 0xBC, 0x9F, 0x6A,
+	0x6F, 0x36, 0x74, 0x55, 0x4D, 0x7F, 0x7E, 0xBC, 0xA6, 0x53, 0x13, 0x46, 0x1E, 0xCE, 0xA8, 0x7E, 0x37, 0x3C, 0x55, 0x8E,
+	0xBE, 0x83, 0x8E, 0x2A, 0xA6, 0xE7, 0x8E, 0x2A, 0x0F, 0xE9, 0xDE, 0x1E, 0x5E, 0x7D, 0x3E, 0xBE, 0x48, 0xF6, 0x66, 0xC3,
+	0xDC, 0x3D, 0xD9, 0xD6, 0x5D, 0xCF, 0xBD, 0xF6, 0x36, 0xD3, 0xC6, 0x3A, 0x9C, 0xDE, 0xC5, 0x77, 0x77, 0xE4, 0x16, 0x27,
+	0xF1, 0x11, 0x62, 0x31, 0x96, 0x98, 0x7C, 0x6D, 0xB5, 0xAE, 0x23, 0x5E, 0xED, 0xBC, 0x46, 0x0B, 0x15, 0x67, 0x67, 0x8E,
+	0xB1, 0x8A, 0x3A, 0x21, 0xB4, 0xB5, 0x82, 0x2E, 0x3E, 0x3C, 0xD5, 0xF1, 0xF9, 0xD5, 0x55, 0x55, 0x07, 0x4A, 0x3C, 0x1C,
+	0xF2, 0x83, 0xD3, 0x33, 0xC9, 0xDE, 0xB9, 0xD9, 0xBC, 0x01, 0xF1, 0xA6, 0xCF, 0x6D, 0xB4, 0xEB, 0xD8, 0xBA, 0xC7, 0x76,
+	0xA6, 0x4E, 0xB1, 0xEC, 0x28, 0xF7, 0x69, 0xA9, 0xBB, 0xD1, 0x76, 0x5C, 0x8C, 0x96, 0x9B, 0x7D, 0x96, 0xBB, 0xB0, 0x76,
+	0x06, 0xC7, 0xB5, 0x66, 0x2E, 0xE4, 0xB5, 0xBD, 0xDA, 0xF9, 0x9E, 0x8B, 0x5E, 0x2E, 0xF9, 0xAE, 0xD2, 0x89, 0x39, 0x96,
+	0xDE, 0x8A, 0x63, 0x86, 0xAE, 0x63, 0x08, 0x4F, 0xF9, 0x71, 0xE3, 0x7E, 0xD9, 0xE2, 0x57, 0x91, 0x3D, 0xA5, 0xD0, 0x5B,
+	0x85, 0x17, 0x12, 0x5E, 0x68, 0x5B, 0x2D, 0xD5, 0xA6, 0x1B, 0x2F, 0x34, 0x15, 0x41, 0x1E, 0xCF, 0xA8, 0xDE, 0xFB, 0x64,
+	0x35, 0x1D, 0xAA, 0xD7, 0x8E, 0x69, 0xA6, 0x3E, 0x60, 0xCF, 0xEB, 0xD7, 0x36, 0xF7, 0x15, 0x53, 0x47, 0x35, 0x71, 0x0C,
+	0xD5, 0x57, 0x17, 0x3C, 0xFC, 0xE3, 0xAB, 0x8E, 0x02, 0x52, 0x1F, 0x4C, 0x97, 0xEE, 0x37, 0xC9, 0xEF, 0xE2, 0xBE, 0x9D,
+	0xFC, 0xA1, 0x70, 0x08, 0x7B, 0x67, 0xFF, 0x00, 0xBF, 0x73, 0x5F, 0xEA, 0xD9, 0x1F, 0xF7, 0x93, 0x03, 0xC9, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD6, 0xAF,
+	0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x57,
+	0xE8, 0x6F, 0xDF, 0x97, 0x4C, 0xFF, 0x00, 0x15, 0xFA, 0xEF, 0xF9, 0xBF, 0x0E, 0x09, 0x43, 0xFD, 0x4F, 0xFF, 0x00, 0xDC,
+	0x5E, 0x17, 0x7F, 0xAB, 0x77, 0xF7, 0xFB, 0x3E, 0x9D, 0x04, 0x49, 0x23, 0x92, 0x48, 0xA4, 0xA2, 0x58, 0xAB, 0xAE, 0x29,
+	0x62, 0xAE, 0x99, 0x23, 0x92, 0x3A, 0xB9, 0xA2, 0x48, 0xE4, 0xA3, 0x9E, 0x2A, 0xA2, 0xBA, 0x2B, 0xA7, 0x9E, 0x2A, 0xA2,
+	0xBA, 0x2A, 0xE3, 0x8E, 0x78, 0xE7, 0x8E, 0x7D, 0xF8, 0xE4, 0x13, 0x4D, 0xF4, 0x6B, 0xF5, 0x44, 0xC0, 0x79, 0x59, 0xAF,
+	0xEA, 0xFE, 0x28, 0x79, 0x49, 0x79, 0x8D, 0xCC, 0x77, 0xE6, 0x85, 0x5D, 0x9E, 0x67, 0xAA, 0x37, 0x3D, 0xA2, 0x3B, 0x4B,
+	0x89, 0x7B, 0x52, 0xCB, 0x51, 0xA7, 0x9C, 0x8E, 0x36, 0x5E, 0x6E, 0x6E, 0xB8, 0xE7, 0x9E, 0x3B, 0x6B, 0x4A, 0xB3, 0xB7,
+	0xAA, 0x4E, 0x67, 0xA3, 0xE3, 0x73, 0x93, 0xC7, 0xC3, 0x55, 0xCF, 0x3C, 0xD7, 0x3C, 0x77, 0x92, 0x48, 0x1C, 0xDB, 0xFA,
+	0x96, 0xBF, 0xE7, 0x33, 0xA5, 0xFF, 0x00, 0xFA, 0xC7, 0xAF, 0xFF, 0x00, 0xDD, 0x5E, 0xD8, 0x07, 0x49, 0xFD, 0x3D, 0xBC,
+	0x99, 0xE8, 0xBF, 0x55, 0x8F, 0x08, 0x72, 0x5E, 0x08, 0x79, 0x29, 0x99, 0x8F, 0x8E, 0xEA, 0xD6, 0xF4, 0x5B, 0x6D, 0x52,
+	0xFE, 0x3B, 0xC9, 0xAC, 0x6D, 0x76, 0x4D, 0xAB, 0x09, 0xAB, 0x53, 0x4F, 0xF4, 0x1B, 0xB7, 0x7A, 0xFE, 0xE6, 0xF3, 0xEF,
+	0x71, 0x91, 0xDB, 0xB4, 0xF8, 0xAC, 0x2D, 0x2A, 0xCA, 0xD3, 0xF0, 0x92, 0x4E, 0x2E, 0xE0, 0xAA, 0x6B, 0x88, 0xEB, 0xB4,
+	0xBC, 0xAA, 0x9E, 0x42, 0x39, 0xDE, 0x64, 0xFA, 0x56, 0xF9, 0x75, 0xE1, 0xB6, 0xD1, 0x99, 0x83, 0x64, 0xEB, 0xBC, 0xF7,
+	0x62, 0xF5, 0x85, 0xBD, 0xC5, 0xD4, 0xB8, 0x0E, 0xE6, 0xEB, 0xAC, 0x16, 0x53, 0x3F, 0xA7, 0x64, 0xB0, 0xD1, 0xD7, 0x5D,
+	0x56, 0xB7, 0x5B, 0x1C, 0x58, 0xF8, 0xAF, 0xAF, 0x74, 0x1C, 0xBF, 0x36, 0xDC, 0x71, 0xF8, 0x8B, 0x2C, 0xA7, 0xDB, 0xA6,
+	0x99, 0xA9, 0x93, 0x8B, 0x69, 0xEE, 0xE0, 0xA6, 0x9B, 0x8A, 0xC3, 0x4D, 0xBA, 0x9B, 0xA1, 0xFB, 0xAB, 0xBE, 0x33, 0xD6,
+	0xFA, 0xCF, 0x4C, 0x75, 0x56, 0xFD, 0xD9, 0xD9, 0xAB, 0x8B, 0xB8, 0x2C, 0xBF, 0x0B, 0xA5, 0xEA, 0xF9, 0x7C, 0xF4, 0x76,
+	0x93, 0x4F, 0xF9, 0xD3, 0x5E, 0x56, 0xFA, 0xC6, 0xD6, 0x5B, 0x0C, 0x35, 0xA4, 0x71, 0xFB, 0xC9, 0x2D, 0xC5, 0xDC, 0xB0,
+	0x41, 0x0C, 0x54, 0xD5, 0x24, 0x95, 0xD3, 0x45, 0x3C, 0xD5, 0xC0, 0x4C, 0x2B, 0xD3, 0x9F, 0xC0, 0xDE, 0xB7, 0xF4, 0x90,
+	0xEA, 0x0D, 0xFF, 0x00, 0xCC, 0x8F, 0x34, 0xF7, 0x4D, 0x5B, 0x01, 0xDA, 0x97, 0x9A, 0xA4, 0xF8, 0xAB, 0xDA, 0x22, 0xC8,
+	0xDB, 0xE4, 0xF0, 0xFD, 0x65, 0xAB, 0x5C, 0xCB, 0x16, 0x47, 0x9D, 0x1F, 0x57, 0x9A, 0x0F, 0x7E, 0x77, 0x4E, 0xCF, 0xDC,
+	0xEF, 0xB1, 0xD0, 0x45, 0x37, 0xEC, 0xFA, 0x67, 0xF9, 0xD7, 0x15, 0x16, 0x56, 0x1C, 0xCB, 0x1D, 0x57, 0x13, 0xDD, 0x84,
+	0x55, 0xFC, 0xE9, 0xF2, 0xCB, 0x63, 0xF3, 0x5B, 0xC9, 0xBE, 0xC6, 0xEF, 0xDC, 0xED, 0xAD, 0xC6, 0x27, 0x1D, 0xB0, 0x5E,
+	0xC1, 0x89, 0xD1, 0xF5, 0x9B, 0x89, 0xA8, 0x9E, 0xBD, 0x4F, 0xAF, 0xF0, 0x31, 0xF3, 0x63, 0xAB, 0x60, 0xAB, 0x92, 0x2F,
+	0x78, 0x2B, 0xBE, 0xA6, 0xD3, 0x8A, 0xAE, 0xAF, 0xAB, 0x8F, 0xFA, 0xB9, 0x72, 0x37, 0x57, 0x12, 0x51, 0xC7, 0x14, 0xD7,
+	0xC7, 0x1C, 0x06, 0xA2, 0x03, 0xB0, 0x9E, 0x93, 0x1E, 0x9A, 0x3A, 0x07, 0xA8, 0x66, 0xC5, 0xDA, 0xB0, 0xF6, 0x07, 0x74,
+	0x73, 0xA0, 0xE3, 0x7A, 0xEB, 0x01, 0x1D, 0x76, 0xBA, 0x7E, 0xA1, 0x5E, 0x3A, 0x7E, 0xCB, 0xCC, 0x65, 0x33, 0x50, 0xCD,
+	0x6F, 0x88, 0xDA, 0x79, 0xB3, 0xCE, 0x63, 0xEE, 0xF1, 0x74, 0x68, 0x38, 0x2C, 0x97, 0x11, 0xD3, 0x7D, 0x54, 0x7C, 0x49,
+	0x73, 0x75, 0x35, 0x74, 0xDB, 0x71, 0x5D, 0x9F, 0x32, 0xD1, 0x72, 0x0D, 0x27, 0xF2, 0x9F, 0xC2, 0xDF, 0x21, 0xBC, 0x3E,
+	0xEC, 0x9C, 0x97, 0x5C, 0xF7, 0x1F, 0x5F, 0x67, 0x71, 0x9C, 0xC7, 0x97, 0xAB, 0x19, 0xAB, 0xEE, 0x36, 0x38, 0xCB, 0xEB,
+	0xDD, 0x23, 0x7F, 0xB7, 0x9E, 0xB9, 0xF9, 0xC5, 0x64, 0x74, 0xDD, 0x8E, 0x2B, 0x7E, 0x6C, 0x32, 0xBC, 0x65, 0x2D, 0xA0,
+	0xE6, 0x4E, 0x2D, 0x3E, 0x54, 0xDF, 0xDB, 0x55, 0xC5, 0x51, 0x5C, 0x43, 0x14, 0xD1, 0xD7, 0x1D, 0x21, 0x28, 0x7F, 0xA7,
+	0x97, 0xC4, 0x9E, 0xE8, 0xE8, 0x1D, 0x1F, 0xBD, 0x3B, 0xF7, 0xBA, 0x30, 0x39, 0x8E, 0xB1, 0xD6, 0x3B, 0x6B, 0x1B, 0xA5,
+	0x63, 0xB4, 0xAD, 0x67, 0x6F, 0x82, 0xE7, 0x5F, 0xCB, 0xE4, 0xF0, 0x1A, 0x7F, 0x3B, 0x1E, 0x63, 0x21, 0xD8, 0x39, 0xAC,
+	0x3E, 0x4E, 0x9B, 0x59, 0x70, 0xF8, 0x19, 0x28, 0xCE, 0xD1, 0x16, 0x2A, 0x6B, 0xAA, 0x68, 0x92, 0xE6, 0x0F, 0xC4, 0xDC,
+	0x53, 0x4D, 0x36, 0xB5, 0xDB, 0xCD, 0x70, 0x1C, 0xDF, 0xF4, 0xF6, 0xEC, 0x8D, 0x67, 0xB8, 0x3D, 0x7D, 0xB2, 0xBD, 0xA3,
+	0xA5, 0xD7, 0x44, 0xDA, 0x86, 0xF9, 0xDB, 0x5E, 0x58, 0xEC, 0xDA, 0xC5, 0xDD, 0x11, 0xD3, 0x17, 0x19, 0x1C, 0x0E, 0x53,
+	0x40, 0xED, 0x5B, 0x8C, 0x4E, 0x5A, 0xA8, 0xE9, 0xFC, 0xA8, 0x97, 0x2F, 0x63, 0x55, 0x17, 0x55, 0xF1, 0xEF, 0xCF, 0x3C,
+	0x57, 0x2F, 0x3E, 0xFC, 0xF3, 0xCF, 0xE7, 0xC8, 0x62, 0x7F, 0xA8, 0x37, 0xFC, 0x46, 0xB6, 0x8F, 0xE1, 0x47, 0x56, 0x7F,
+	0xD2, 0x2F, 0x01, 0xD5, 0x6F, 0x45, 0xFF, 0x00, 0x33, 0xFA, 0x77, 0xCA, 0x9F, 0x18, 0x72, 0x3E, 0x9B, 0x5E, 0x4B, 0xCB,
+	0x8A, 0xBD, 0xD8, 0xF1, 0xBA, 0x96, 0x7F, 0x47, 0xD3, 0x31, 0x5B, 0x15, 0xCC, 0x36, 0x90, 0x76, 0xB7, 0x51, 0x64, 0x6D,
+	0xEE, 0xE6, 0xA3, 0x5D, 0xC2, 0x5D, 0xFD, 0xC8, 0x25, 0xA3, 0x77, 0xEB, 0xAB, 0x69, 0x64, 0xA2, 0xDE, 0x3B, 0x7E, 0x63,
+	0xBC, 0x8F, 0x1B, 0x6D, 0x6D, 0x77, 0x6D, 0x55, 0x52, 0xDA, 0x5C, 0xCB, 0x10, 0x71, 0x87, 0xCE, 0xFF, 0x00, 0x47, 0x6F,
+	0x28, 0xFC, 0x41, 0xDC, 0x73, 0x39, 0x0D, 0x3F, 0x4A, 0xDA, 0xFB, 0xBB, 0xA2, 0x2E, 0xB2, 0x37, 0x32, 0x6A, 0x7D, 0x91,
+	0xA2, 0xE0, 0xEF, 0x36, 0x5C, 0xA6, 0x2B, 0x15, 0x24, 0xDE, 0xF6, 0x78, 0xFE, 0xCB, 0xD7, 0xB0, 0x36, 0x93, 0xE4, 0x35,
+	0x5C, 0xC5, 0xA5, 0x12, 0x47, 0x0C, 0x97, 0xB5, 0x41, 0x4E, 0x22, 0xF2, 0x5A, 0xA9, 0xFC, 0x3C, 0xFC, 0x49, 0x5D, 0x56,
+	0xD1, 0x07, 0x34, 0x3A, 0xEF, 0xA8, 0xBB, 0x53, 0xB7, 0x36, 0x28, 0xF5, 0x1E, 0xAD, 0xEB, 0x8D, 0xE3, 0xB0, 0xF6, 0x79,
+	0x2E, 0xA0, 0xB2, 0xFD, 0x85, 0xA6, 0x6A, 0xF9, 0x9D, 0x8F, 0x25, 0x0D, 0xC5, 0xCD, 0x72, 0xC7, 0x0D, 0x17, 0x76, 0xB8,
+	0xAB, 0x3B, 0x99, 0x2C, 0xA9, 0xE6, 0xAB, 0x79, 0x39, 0xE6, 0xB9, 0xB8, 0xA2, 0x8A, 0x69, 0x8E, 0xBA, 0xAA, 0xE7, 0x8E,
+	0x28, 0xAB, 0x9E, 0x02, 0x72, 0x5E, 0x13, 0xF4, 0x07, 0x60, 0x78, 0x5B, 0xE9, 0x1B, 0xD9, 0xFA, 0x3F, 0x91, 0x7C, 0x6B,
+	0xBA, 0x06, 0xCD, 0xFD, 0x02, 0xEF, 0xAD, 0xCF, 0x33, 0x63, 0x79, 0xB1, 0xE3, 0x24, 0xB6, 0xD5, 0xAC, 0xF7, 0x0D, 0x72,
+	0xFE, 0x3C, 0x3E, 0x2B, 0x61, 0xCC, 0xF1, 0x2D, 0x18, 0x3B, 0x7C, 0xDD, 0x55, 0xF1, 0x45, 0x32, 0x45, 0x05, 0xCD, 0xC4,
+	0x34, 0xC9, 0x35, 0x11, 0xF1, 0x2D, 0x52, 0x73, 0x55, 0x14, 0x87, 0x25, 0xBE, 0x99, 0x3F, 0xDF, 0xBF, 0x93, 0x7F, 0xC2,
+	0x4D, 0x4F, 0xF9, 0xC6, 0xA0, 0x71, 0x6B, 0xD4, 0x47, 0xFE, 0x7D, 0x7C, 0xCB, 0xFF, 0x00, 0xEC, 0xE7, 0x76, 0xFF, 0x00,
+	0xDC, 0x4D, 0x80, 0x1F, 0x19, 0xE2, 0x67, 0x95, 0x9D, 0xB1, 0xE1, 0xAF, 0x75, 0xEB, 0x1D, 0xDD, 0xD4, 0x39, 0x6F, 0xC2,
+	0x66, 0x70, 0xB3, 0x53, 0x69, 0x9E, 0xC0, 0x5D, 0xD7, 0x2F, 0x3A, 0xFE, 0xF3, 0xAA, 0x5C, 0x5C, 0x5B, 0xCB, 0x9A, 0xD3,
+	0x76, 0x7B, 0x48, 0xF9, 0xE3, 0x9B, 0x9C, 0x3E, 0x5E, 0x2B, 0x7A, 0x78, 0xF9, 0xD3, 0xED, 0x3D, 0xAC, 0xF4, 0x47, 0x71,
+	0x05, 0x71, 0xCF, 0x14, 0x72, 0x52, 0x16, 0x1F, 0xF8, 0x61, 0xE4, 0xE7, 0x45, 0xF9, 0x95, 0xD5, 0x16, 0x9E, 0x45, 0xF4,
+	0xCC, 0x18, 0xFB, 0x4B, 0xED, 0xBA, 0x2C, 0x6E, 0x0F, 0xB1, 0xF1, 0x72, 0x45, 0x63, 0x1E, 0xE3, 0xAC, 0x6D, 0x9A, 0xD5,
+	0xA5, 0x5E, 0xFA, 0x7E, 0xEB, 0x25, 0xAD, 0x34, 0xCB, 0x75, 0x79, 0x81, 0x87, 0x2B, 0xCD, 0x56, 0x53, 0xD7, 0xFD, 0x5D,
+	0xCD, 0x85, 0xCC, 0x53, 0xC3, 0xFD, 0x54, 0xB4, 0x71, 0xC0, 0x57, 0x61, 0xD1, 0x7D, 0x0F, 0xB8, 0x79, 0x3B, 0xE4, 0x9E,
+	0x91, 0xD0, 0xBA, 0x24, 0x5C, 0xD5, 0xB1, 0xF6, 0x67, 0x60, 0xD5, 0xAF, 0xC3, 0x79, 0xCC, 0x35, 0xDC, 0x41, 0x84, 0xC5,
+	0xF3, 0x79, 0x73, 0x79, 0xB1, 0x6C, 0xD7, 0xD1, 0x47, 0xCD, 0x32, 0x57, 0x8C, 0xD5, 0xF5, 0xEB, 0x4B, 0xAC, 0x8D, 0xCF,
+	0x14, 0xF3, 0xF2, 0xE6, 0xDE, 0xDA, 0xBF, 0x8F, 0xBD, 0x5E, 0xDC, 0x72, 0x12, 0x62, 0xF5, 0xD8, 0xEE, 0xFD, 0x4F, 0xC5,
+	0x6F, 0x15, 0xFA, 0x1B, 0xD3, 0x87, 0xA3, 0xE7, 0x8F, 0x0B, 0x8E, 0xCC, 0xEA, 0xF8, 0x1B, 0xAD, 0xC3, 0x1F, 0x6B, 0x73,
+	0x4F, 0x19, 0x3B, 0x0E, 0xA3, 0xEB, 0xF9, 0xAD, 0xEC, 0x75, 0x4B, 0x1C, 0xBD, 0x50, 0xF1, 0x0D, 0x53, 0xDD, 0x76, 0x1E,
+	0xE9, 0x8D, 0x9A, 0xFA, 0xEA, 0xE3, 0x9E, 0x3E, 0x77, 0x32, 0x61, 0xAE, 0x3E, 0xEF, 0x1C, 0xF1, 0x71, 0x57, 0x35, 0x04,
+	0x46, 0x01, 0xB0, 0xBE, 0x28, 0xF9, 0x09, 0xB2, 0xF8, 0xAB, 0xE4, 0x57, 0x52, 0xF7, 0xFE, 0xAB, 0xF7, 0xE5, 0xC8, 0x75,
+	0xBE, 0xDD, 0x61, 0x97, 0xBF, 0xC6, 0xDB, 0xCF, 0xCD, 0xBF, 0x39, 0xFD, 0x62, 0xE3, 0x89, 0x31, 0x9B, 0x7E, 0xB1, 0x24,
+	0xBE, 0xFC, 0x71, 0x44, 0x3B, 0x2E, 0xAF, 0x7D, 0x77, 0x63, 0x55, 0x5C, 0xFB, 0xF1, 0x47, 0x13, 0xFC, 0xBF, 0xB6, 0x9E,
+	0x01, 0x28, 0x5F, 0x5E, 0x8F, 0x1C, 0x75, 0x5F, 0x26, 0x3C, 0x62, 0xEA, 0x0F, 0x50, 0xBE, 0x93, 0xE2, 0x1D, 0x86, 0x8D,
+	0x4F, 0x59, 0xD7, 0x78, 0xD9, 0xB2, 0xD8, 0xC8, 0x38, 0xAE, 0x6D, 0x8F, 0xA3, 0x7B, 0x02, 0xB8, 0x32, 0x7A, 0xB6, 0x7A,
+	0xE2, 0x98, 0x63, 0x9A, 0xE2, 0xA9, 0x74, 0x7D, 0x9B, 0x35, 0x4F, 0xCE, 0x2F, 0xD3, 0xF8, 0x7B, 0x6C, 0xC5, 0xDC, 0x93,
+	0x73, 0xC7, 0x16, 0xDE, 0xD4, 0x87, 0xAB, 0xF4, 0xC9, 0x7E, 0xE3, 0x7C, 0x9E, 0xFE, 0x2B, 0xE9, 0xDF, 0xCA, 0x17, 0x00,
+	0x8D, 0x2E, 0x6F, 0xC0, 0xCF, 0x39, 0x65, 0xCC, 0xE5, 0xE5, 0x8B, 0xC3, 0x1F, 0x2B, 0xE4, 0x8A, 0x4C, 0x9D, 0xFC, 0x91,
+	0xC9, 0x1F, 0x8E, 0xBD, 0xBF, 0x5C, 0x72, 0x47, 0x5D, 0xD4, 0xB5, 0x51, 0x5D, 0x15, 0xD3, 0xA7, 0xF3, 0x4D, 0x74, 0x57,
+	0x4F, 0x3C, 0x73, 0xC7, 0x3C, 0x73, 0xED, 0xCF, 0x00, 0xC0, 0x7D, 0x99, 0xD3, 0x5D, 0xBF, 0xD2, 0xB9, 0x5C, 0x7E, 0x0B,
+	0xB9, 0x3A, 0xA7, 0xB2, 0x7A, 0x97, 0x39, 0x96, 0xC7, 0xFE, 0xD6, 0xC5, 0xE1, 0xBB, 0x33, 0x46, 0xD9, 0xF4, 0x3C, 0xAE,
+	0x4B, 0x15, 0xF8, 0x99, 0xAC, 0xFF, 0x00, 0x69, 0xE3, 0xF1, 0xDB, 0x4E, 0x2F, 0x15, 0x77, 0x79, 0x8F, 0xFC, 0x5D, 0xB4,
+	0x91, 0x7D, 0xE8, 0xE8, 0xAA, 0x3F, 0xB9, 0x1D, 0x54, 0xFC, 0xBE, 0x54, 0xF3, 0xC7, 0x01, 0x8D, 0x80, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xD7, 0xAF, 0xFC, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xB9, 0xAC, 0x6C,
+	0x39, 0x1D, 0x4B, 0x64, 0xD7, 0xB6, 0xBC, 0x47, 0x30, 0xD3, 0x96, 0xD6, 0x73, 0x98, 0x9D, 0x87, 0x17, 0x55, 0xC4, 0x5F,
+	0x7E, 0xDE, 0x9C, 0x8E, 0x16, 0xFE, 0xDF, 0x25, 0x65, 0xCC, 0xF0, 0xFC, 0xA9, 0xFB, 0xD0, 0xF1, 0x73, 0x6D, 0x4F, 0xCA,
+	0x9F, 0x7E, 0x3E, 0x54, 0xFB, 0xF1, 0xEE, 0x0D, 0xC8, 0xF3, 0x1F, 0xD4, 0x3B, 0xC9, 0x1F, 0x3B, 0x2D, 0xBA, 0xFA, 0xD7,
+	0xBF, 0xB2, 0xBA, 0x96, 0x4A, 0x1E, 0xB2, 0x9F, 0x67, 0xB8, 0xD5, 0xB8, 0xD6, 0x35, 0x4B, 0x3D, 0x6B, 0x98, 0x64, 0xDB,
+	0xA3, 0xC0, 0x47, 0x99, 0xE6, 0xF6, 0xAB, 0x59, 0xA5, 0xE6, 0xF3, 0x8A, 0xE9, 0xD6, 0xED, 0x7E, 0xDF, 0x15, 0x7B, 0x7D,
+	0xBF, 0x6A, 0xBD, 0xBF, 0xF7, 0x7E, 0x41, 0xA3, 0x60, 0xF5, 0xF5, 0xFD, 0x83, 0x39, 0xA9, 0xE7, 0xB0, 0xBB, 0x46, 0xB1,
+	0x97, 0xC9, 0x6B, 0xFB, 0x26, 0xB9, 0x95, 0xC7, 0xE7, 0x70, 0x19, 0xEC, 0x35, 0xE5, 0xC6, 0x3B, 0x2D, 0x85, 0xCC, 0xE2,
+	0x6E, 0xE2, 0xBE, 0xC6, 0x65, 0x71, 0x97, 0xF6, 0xB2, 0x45, 0x73, 0x65, 0x90, 0xC7, 0xDE, 0xC1, 0x44, 0xB0, 0xCB, 0x1D,
+	0x54, 0xD7, 0x1C, 0x94, 0x71, 0x55, 0x3C, 0xF1, 0xCF, 0x1C, 0x72, 0x0D, 0xB6, 0xF3, 0x53, 0xCD, 0xCE, 0xCC, 0xF3, 0x9F,
+	0x6D, 0xEA, 0xFD, 0xF7, 0xB6, 0xB1, 0x58, 0x1B, 0x3D, 0xCB, 0xAE, 0xFA, 0x87, 0x03, 0xD5, 0x37, 0xF9, 0x9C, 0x15, 0x13,
+	0x5B, 0xD3, 0xB9, 0x57, 0x84, 0xCE, 0x6C, 0x79, 0xD9, 0x76, 0xDC, 0x9D, 0x85, 0x7C, 0xFE, 0x13, 0x1B, 0x97, 0xCB, 0x5D,
+	0x6C, 0x72, 0x73, 0x3C, 0x16, 0xBC, 0x51, 0x6B, 0x4D, 0x54, 0x7B, 0xC7, 0x45, 0x14, 0xF3, 0xC5, 0x14, 0x86, 0xA6, 0x6B,
+	0xBB, 0x26, 0xC3, 0xA8, 0x67, 0x71, 0x5B, 0x46, 0xA5, 0x9E, 0xCD, 0x6A, 0xFB, 0x36, 0x0A, 0xF6, 0x0C, 0x9E, 0x0F, 0x62,
+	0xD7, 0x72, 0x97, 0xD8, 0x4C, 0xEE, 0x1B, 0x25, 0x6B, 0x5F, 0xCE, 0xDB, 0x21, 0x8A, 0xCB, 0xE3, 0x67, 0xB6, 0xC8, 0x63,
+	0xAF, 0x6D, 0xEB, 0xE3, 0xDE, 0x89, 0x61, 0x92, 0x89, 0x28, 0xE7, 0xF3, 0xE3, 0x9E, 0x01, 0xDC, 0xCE, 0x8E, 0xFA, 0x87,
+	0x7C, 0xE4, 0xEA, 0xFC, 0x3E, 0x33, 0x5D, 0xEC, 0x3C, 0x6F, 0x57, 0x77, 0xD6, 0x3B, 0x1D, 0x6F, 0xCD, 0xAF, 0xED, 0xCD,
+	0xD7, 0x03, 0x92, 0xD7, 0xF7, 0xDB, 0x88, 0x61, 0x86, 0x58, 0xEC, 0x68, 0x9F, 0x63, 0xD3, 0x32, 0xB8, 0x6C, 0x25, 0xE5,
+	0x70, 0x7B, 0xC7, 0xC4, 0xB3, 0xDD, 0x62, 0x2E, 0x6F, 0x2E, 0xA9, 0x8F, 0xDE, 0x59, 0xB9, 0x9A, 0xBA, 0xE6, 0xA8, 0x33,
+	0x2E, 0xD3, 0xF5, 0x30, 0x79, 0x3F, 0x7F, 0x87, 0x9E, 0xD7, 0x50, 0xE8, 0x2E, 0x8D, 0xD6, 0xF3, 0x52, 0xF3, 0xF0, 0x8B,
+	0x2F, 0x99, 0xBA, 0xDE, 0x76, 0x9B, 0x6B, 0x58, 0xAA, 0xA2, 0x4A, 0x64, 0xAE, 0x1C, 0x4D, 0xBE, 0x7B, 0x5A, 0xF9, 0xDE,
+	0x53, 0x55, 0x54, 0xD5, 0x15, 0x72, 0x4F, 0x5C, 0x54, 0xD5, 0x4F, 0xEB, 0x8A, 0x4E, 0x39, 0xF6, 0xE0, 0x38, 0xAD, 0xE4,
+	0xFF, 0x00, 0x99, 0xDE, 0x4A, 0xF9, 0x8B, 0xB4, 0xD1, 0xB4, 0xF9, 0x03, 0xDA, 0x59, 0xDD, 0xD7, 0xF0, 0x53, 0x4D, 0x2E,
+	0xBF, 0xAC, 0x51, 0xCC, 0x38, 0x6D, 0x17, 0x53, 0xA2, 0x6F, 0x78, 0xFE, 0xDE, 0xB1, 0xA5, 0xE1, 0xE2, 0xB3, 0xD7, 0xF1,
+	0x73, 0x7E, 0x1B, 0xE3, 0x0C, 0xB7, 0x9C, 0x41, 0x5E, 0x42, 0xF2, 0x88, 0xE8, 0xE6, 0xEA, 0xE2, 0x7A, 0xF8, 0xF9, 0xF2,
+	0x1A, 0xBA, 0x00, 0x32, 0x7F, 0x4E, 0x77, 0x4F, 0x6A, 0x78, 0xFB, 0xD8, 0x38, 0x3E, 0xD4, 0xE9, 0x8D, 0xE3, 0x39, 0xD7,
+	0xBB, 0xFE, 0xB9, 0x24, 0x95, 0xE2, 0xB6, 0x2C, 0x0C, 0xF1, 0xD1, 0x3D, 0x31, 0x4F, 0x4F, 0xDB, 0xBA, 0xB0, 0xBE, 0xB3,
+	0xBA, 0x8A, 0xE7, 0x1B, 0x98, 0xC4, 0x5F, 0xC5, 0xFA, 0x2E, 0x6C, 0xAF, 0x21, 0x9E, 0xD2, 0xE6, 0x3F, 0xD3, 0x2C, 0x75,
+	0xD3, 0xF9, 0x03, 0xBE, 0x5A, 0x57, 0xD4, 0xB5, 0xE5, 0x3E, 0x23, 0x03, 0x6D, 0x8F, 0xDE, 0x3A, 0x3B, 0xA4, 0x77, 0x4C,
+	0xE5, 0xB7, 0xC2, 0x2A, 0xB6, 0x1C, 0x6C, 0x9B, 0x96, 0xA1, 0xCD, 0xFC, 0x11, 0xDB, 0x5B, 0xC5, 0xC4, 0xD9, 0x1C, 0x4D,
+	0x19, 0xBC, 0xED, 0x9F, 0x39, 0x49, 0xEE, 0x28, 0x96, 0x59, 0x64, 0xB5, 0xE6, 0xD6, 0xDB, 0x9F, 0xB9, 0xC5, 0x31, 0xDB,
+	0xC5, 0xC5, 0x3F, 0xA8, 0x34, 0xF3, 0xCC, 0x7F, 0x5A, 0xFF, 0x00, 0x31, 0x7C, 0xBE, 0xD5, 0x33, 0x3D, 0x69, 0x35, 0xE6,
+	0xB1, 0xD3, 0x1D, 0x53, 0x9F, 0xB5, 0xE7, 0x1F, 0x9F, 0xD4, 0x3A, 0xB6, 0xDF, 0x29, 0x67, 0x94, 0xDA, 0xB1, 0x72, 0x53,
+	0xED, 0x73, 0x8C, 0xDB, 0x37, 0x2C, 0xBE, 0x4B, 0x21, 0x9C, 0xBE, 0xC6, 0x5E, 0x7C, 0xAB, 0x8E, 0xE2, 0xD2, 0xC7, 0xF6,
+	0x6D, 0x95, 0xDD, 0xB5, 0x5F, 0x66, 0xE6, 0x09, 0xE9, 0xF9, 0xF3, 0x58, 0x73, 0xDB, 0xC6, 0xCF, 0x22, 0xFB, 0x2F, 0xC5,
+	0x1E, 0xE3, 0xD5, 0xBB, 0xD7, 0xA8, 0x6E, 0xF1, 0x16, 0x5B, 0xFE, 0x9F, 0x06, 0x7E, 0xDF, 0x0B, 0x73, 0x9D, 0xC4, 0xC3,
+	0x9C, 0xC5, 0xD1, 0x1E, 0xCB, 0xAE, 0xE5, 0x35, 0x7C, 0xA7, 0x17, 0x18, 0xCB, 0x8A, 0xE3, 0x8A, 0x7E, 0x6B, 0xC5, 0x66,
+	0x26, 0xE2, 0x8E, 0x79, 0xE7, 0x8F, 0x85, 0x7C, 0xF1, 0x57, 0xF9, 0x03, 0xD6, 0xF2, 0x93, 0xCA, 0x4E, 0xD7, 0xF3, 0x0B,
+	0xB5, 0xEE, 0xFB, 0xA3, 0xBA, 0x2E, 0xF0, 0x77, 0xDB, 0xC5, 0xF6, 0x0F, 0x0B, 0xAF, 0x5C, 0x5C, 0x6B, 0xD8, 0x58, 0x70,
+	0x38, 0xEA, 0xF1, 0xD8, 0x18, 0x65, 0x83, 0x1D, 0xC7, 0x18, 0xE8, 0x25, 0x96, 0x2A, 0x26, 0xA2, 0x29, 0x79, 0xE2, 0xAA,
+	0xB8, 0xE7, 0x8F, 0x97, 0xB7, 0x1F, 0x97, 0xBF, 0xF6, 0x86, 0x00, 0xC7, 0x64, 0x72, 0x18, 0x7C, 0x85, 0x86, 0x5F, 0x11,
+	0x7F, 0x79, 0x8B, 0xCA, 0xE2, 0xEF, 0x2D, 0x72, 0x38, 0xCC, 0x9E, 0x3A, 0xEA, 0x7B, 0x1C, 0x86, 0x3B, 0x21, 0x63, 0x3C,
+	0x77, 0x36, 0x57, 0xF6, 0x17, 0xB6, 0xD2, 0x45, 0x73, 0x67, 0x79, 0x67, 0x73, 0x15, 0x32, 0x45, 0x2C, 0x75, 0x53, 0x5C,
+	0x75, 0xD3, 0xC5, 0x54, 0xF3, 0xC7, 0x3C, 0x71, 0xCF, 0x01, 0xDB, 0xBF, 0x1E, 0xBE, 0xA0, 0x2F, 0x3A, 0x7A, 0x5F, 0x13,
+	0x8E, 0xD6, 0x77, 0x8B, 0x8D, 0x17, 0xC8, 0x4D, 0x7E, 0xC2, 0x3A, 0x2D, 0xE3, 0xBD, 0xED, 0x0C, 0x56, 0x52, 0x1D, 0xF6,
+	0x3B, 0x48, 0x21, 0xB9, 0xA6, 0x18, 0xA3, 0xDE, 0x35, 0x8C, 0xB6, 0x1A, 0x5C, 0x94, 0xF5, 0x5C, 0x4B, 0x1D, 0x53, 0x5C,
+	0xE5, 0xEC, 0xF2, 0xD7, 0x52, 0xD1, 0x17, 0xC7, 0xEE, 0x53, 0x55, 0x5C, 0xD7, 0xC0, 0x6C, 0x9E, 0x67, 0xEA, 0x67, 0xF2,
+	0x42, 0x7C, 0x65, 0xDC, 0x5A, 0xFF, 0x00, 0x8E, 0x7D, 0x23, 0x8C, 0xCC, 0x57, 0x45, 0x1C, 0x58, 0xDF, 0xE6, 0x72, 0xDB,
+	0xE6, 0x77, 0x19, 0x6F, 0x27, 0x12, 0xD1, 0xCC, 0x95, 0x5D, 0xE2, 0x6C, 0xB3, 0x1A, 0xED, 0xD5, 0xE5, 0x15, 0x43, 0xC5,
+	0x54, 0xF1, 0x4D, 0x17, 0xB0, 0x73, 0x4D, 0x5C, 0xF1, 0x57, 0xBF, 0x3C, 0x71, 0xCD, 0x35, 0x07, 0x1F, 0x7C, 0xB3, 0xF5,
+	0x0C, 0xF2, 0xCB, 0xCD, 0x5B, 0xC8, 0x69, 0xEF, 0x4E, 0xCF, 0xBE, 0xC8, 0xEA, 0x96, 0x17, 0x3C, 0x5E, 0x61, 0xFA, 0xDB,
+	0x59, 0xB6, 0x8B, 0x55, 0xEB, 0x9C, 0x4D, 0xCD, 0x14, 0xF1, 0xC4, 0x77, 0x54, 0x6B, 0x58, 0xCE, 0x68, 0xA3, 0x33, 0x91,
+	0x83, 0x9E, 0x6B, 0xE6, 0x2B, 0xDC, 0xA4, 0xB7, 0xF7, 0xD0, 0xD3, 0x2D, 0x74, 0x47, 0x35, 0x31, 0xD5, 0xF0, 0xE0, 0x3C,
+	0x9F, 0x0F, 0xBC, 0xE5, 0xEF, 0xBF, 0x06, 0xB6, 0x4D, 0xC7, 0x6B, 0xE8, 0x4C, 0x86, 0xB1, 0x8E, 0xCC, 0x6F, 0x58, 0x3B,
+	0x0D, 0x7B, 0x3D, 0x2E, 0xCD, 0xAD, 0xDB, 0x6C, 0x90, 0xD7, 0x8D, 0xC7, 0x5F, 0xD5, 0x92, 0xB7, 0x8E, 0xD6, 0x0B, 0x99,
+	0xA2, 0xA2, 0xDA, 0x5F, 0xC5, 0x55, 0xEF, 0x55, 0x7C, 0x7B, 0xF3, 0xCF, 0x1C, 0x7B, 0x7E, 0x5F, 0x9F, 0xB8, 0x6B, 0xDF,
+	0x6A, 0xF6, 0x56, 0xD1, 0xDC, 0x9D, 0x99, 0xBF, 0xF6, 0xD6, 0xED, 0x35, 0x9D, 0xC6, 0xE1, 0xD9, 0x7B, 0x8E, 0xC5, 0xBD,
+	0x6D, 0x13, 0xE3, 0xEC, 0xE8, 0xC7, 0xD8, 0x4D, 0x9F, 0xDA, 0x32, 0xB7, 0x59, 0x9C, 0xAC, 0x96, 0x76, 0x31, 0x73, 0x54,
+	0x76, 0x76, 0xB5, 0xDE, 0xDE, 0x57, 0xCD, 0x11, 0x53, 0xCF, 0x3C, 0x51, 0x4F, 0xB7, 0x1F, 0xE4, 0x0F, 0x81, 0x06, 0xED,
+	0xF8, 0x2B, 0xE7, 0x97, 0x73, 0x78, 0x0D, 0xDA, 0xB7, 0x3D, 0x8B, 0xD5, 0x92, 0xDA, 0xE6, 0xB0, 0xBB, 0x06, 0x3B, 0x9C,
+	0x46, 0xF9, 0xD7, 0x19, 0xEB, 0x9B, 0xD8, 0xF5, 0x2D, 0xE3, 0x1F, 0x0C, 0x77, 0x5C, 0xE2, 0x6B, 0xC9, 0xC5, 0x67, 0x25,
+	0x13, 0x5A, 0xE5, 0xF5, 0xFB, 0xDB, 0xAA, 0xA7, 0xB0, 0xBD, 0x8B, 0xDA, 0x7B, 0x7E, 0x6B, 0x96, 0x2F, 0x7A, 0xA0, 0x9E,
+	0x78, 0xE4, 0x0F, 0x94, 0xF1, 0x5F, 0xCC, 0xBE, 0xE1, 0xF0, 0xDF, 0xB3, 0x76, 0x1E, 0xDD, 0xE9, 0x58, 0xB4, 0xBB, 0x5D,
+	0xDF, 0x62, 0xC1, 0x64, 0x75, 0xB9, 0x32, 0x7B, 0x5E, 0xAB, 0x67, 0xB5, 0x7E, 0xCB, 0xC4, 0xE5, 0xB2, 0x76, 0x79, 0x5C,
+	0x84, 0x58, 0x5A, 0x2F, 0xA4, 0xA3, 0xF6, 0x6D, 0xCD, 0xDC, 0xD6, 0x11, 0x47, 0x24, 0xD4, 0x73, 0xF7, 0x2A, 0x87, 0x8E,
+	0x63, 0xF7, 0xF8, 0xD7, 0x5F, 0x15, 0x07, 0xC0, 0x79, 0x19, 0xE4, 0x4F, 0x6A, 0x79, 0x55, 0xDB, 0xBB, 0x3F, 0x77, 0x77,
+	0x2E, 0x72, 0x2C, 0xF6, 0xF7, 0xB5, 0xD3, 0x8B, 0x86, 0xFA, 0x7B, 0x3B, 0x4A, 0x31, 0xB8, 0xAB, 0x2B, 0x2C, 0x2E, 0x2E,
+	0xD3, 0x0F, 0x8C, 0xC6, 0xE1, 0xB1, 0x30, 0xD5, 0x55, 0xB6, 0x2F, 0x1D, 0x6B, 0x67, 0x65, 0x4F, 0xB4, 0x51, 0xFB, 0x71,
+	0x54, 0xB5, 0x57, 0x2D, 0x5F, 0x29, 0x24, 0xAE, 0xAA, 0x83, 0x07, 0x00, 0x0E, 0x8F, 0xF5, 0x2F, 0xAA, 0xA7, 0x96, 0xFD,
+	0x3B, 0xE3, 0x8C, 0xFE, 0x29, 0x60, 0x73, 0x3A, 0x2E, 0xC5, 0xD2, 0x97, 0x18, 0x3D, 0xBB, 0x57, 0x93, 0x5A, 0xDE, 0xF4,
+	0x7C, 0x76, 0xD7, 0x2F, 0xF4, 0x67, 0x78, 0xAF, 0x23, 0x26, 0xC1, 0xAF, 0x7E, 0x3A, 0xF6, 0x6A, 0x65, 0xAB, 0x11, 0x34,
+	0x99, 0x7B, 0x9E, 0x62, 0x8A, 0xAE, 0x2A, 0xE2, 0x1E, 0x26, 0xE6, 0x9A, 0x3D, 0xA9, 0xE2, 0x9A, 0x69, 0x0F, 0x99, 0xF0,
+	0xFB, 0xD4, 0x9F, 0xC9, 0xEF, 0x06, 0xB5, 0xBD, 0xC7, 0x54, 0xE8, 0x4C, 0xAE, 0x9B, 0x8D, 0xC4, 0xEF, 0x59, 0xCB, 0x1D,
+	0x87, 0x60, 0xA7, 0x66, 0xD4, 0x6C, 0xF6, 0x4B, 0x89, 0x72, 0x38, 0xEB, 0x0E, 0x71, 0xB6, 0xBC, 0xDB, 0x4D, 0x75, 0x3C,
+	0x5F, 0x86, 0x86, 0x8B, 0x6A, 0xB9, 0xF7, 0xA6, 0x9E, 0x3F, 0x55, 0x5C, 0xFB, 0xF3, 0xCF, 0xF6, 0x7B, 0x06, 0xE1, 0x7F,
+	0xE6, 0x0D, 0xF5, 0x1A, 0xFF, 0x00, 0xF2, 0x8E, 0xA8, 0xFF, 0x00, 0xF5, 0x66, 0x23, 0xFF, 0x00, 0xEB, 0x07, 0x3E, 0x7C,
+	0xBE, 0xF3, 0x5F, 0xBD, 0x3C, 0xE1, 0xDD, 0x75, 0x8D, 0xFB, 0xBE, 0x72, 0x3A, 0xE6, 0x47, 0x61, 0xD4, 0x75, 0x7F, 0xE8,
+	0x7E, 0x1A, 0x4D, 0x6B, 0x5D, 0xB6, 0xD6, 0xED, 0x23, 0xC3, 0x7E, 0xD6, 0xC8, 0x66, 0xBE, 0x13, 0xDA, 0xDA, 0xCB, 0x2D,
+	0x33, 0xDC, 0x7E, 0x3B, 0x27, 0x2F, 0x3F, 0x73, 0x9E, 0x7D, 0xFE, 0x3E, 0xDC, 0x7F, 0x90, 0x35, 0x28, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD0, 0xAF, 0xFC, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF,
+	0xD1, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD2, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 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, 0xFF, 0xD3, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD4, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD5, 0xAF, 0xFC, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF,
+	0xD6, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD7, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 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, 0xFF, 0xD0, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD1, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD2, 0xAF, 0xFC, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF,
+	0xD3, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD4, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 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, 0xFF, 0xD5, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD6, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD7, 0xAF, 0xFC, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF,
+	0xD0, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD1, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 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, 0xFF, 0xD2, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD3, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD4, 0xAF, 0xFC, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF,
+	0xD5, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD6, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 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, 0xFF, 0xD7, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD0, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD1, 0xAF, 0xFC, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF,
+	0xD2, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xFF, 0xD9,
+};

src/http/data/index.html

@@ -11,7 +11,7 @@
 	<hr>
 	<ul>
 		<li>
-			<a href="/ping"><b><samp>/ping</samp></b></a><br>
+			<a href="/state"><b><samp>/state</samp></b></a><br>
 			Get JSON structure with state of the server.
 		</li>
 		<br>
@@ -25,6 +25,12 @@
 			Get a live stream. Query params:<br>
 			<br>
 			<ul>
+				<li>
+					<b><samp>key=abc123</samp></b><br>
+					User-defined key, which is part of cookie <samp>stream_client</samp>, which allows<br>
+					the stream client to determine its identifier and view statistics using <a href="/state"><samp>/state</samp></a>.
+				</li>
+				<br>
 				<li>
 					<b><samp>extra_headers=1</samp></b><br>
 					Add <samp>X-UStreamer-*</samp> headers to /stream handle (like on <a href="/snapshot"><samp>/snapshot</samp></a>).
@@ -40,7 +46,7 @@
 					<b><samp>dual_final_frames=1</samp></b><br>
 					Enable workaround for Safari/WebKit bug when using option <samp>--drop-same-frames</samp>.<br>
 					Without this option, when the frame series is completed, WebKit-based browsers<br>
-					renders the last one with a delay.
+					renders the last frame with a delay.
 				</li>
 			</ul>
 		</li>

src/http/data/index_html.h

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
@@ -21,10 +22,10 @@
 
 #pragma once
 
-#include "../config.h"
+#include "../../config.h"
 
 
-const char *HTML_INDEX_PAGE = " \
+const char HTML_INDEX_PAGE[] = " \
 	<!DOCTYPE html> \
 	\
 	<html> \
@@ -38,7 +39,7 @@ const char *HTML_INDEX_PAGE = " \
 		<hr> \
 		<ul> \
 			<li> \
-				<a href=\"/ping\"><b><samp>/ping</samp></b></a><br> \
+				<a href=\"/state\"><b><samp>/state</samp></b></a><br> \
 				Get JSON structure with state of the server. \
 			</li> \
 			<br> \
@@ -52,6 +53,12 @@ const char *HTML_INDEX_PAGE = " \
 				Get a live stream. Query params:<br> \
 				<br> \
 				<ul> \
+					<li> \
+						<b><samp>key=abc123</samp></b><br> \
+						User-defined key, which is part of cookie <samp>stream_client</samp>, which allows<br> \
+						the stream client to determine its identifier and view statistics using <a href=\"/state\"><samp>/state</samp></a>. \
+					</li> \
+					<br> \
 					<li> \
 						<b><samp>extra_headers=1</samp></b><br> \
 						Add <samp>X-UStreamer-*</samp> headers to /stream handle (like on <a href=\"/snapshot\"><samp>/snapshot</samp></a>). \
@@ -67,7 +74,7 @@ const char *HTML_INDEX_PAGE = " \
 						<b><samp>dual_final_frames=1</samp></b><br> \
 						Enable workaround for Safari/WebKit bug when using option <samp>--drop-same-frames</samp>.<br> \
 						Without this option, when the frame series is completed, WebKit-based browsers<br> \
-						renders the last one with a delay. \
+						renders the last frame with a delay. \
 					</li> \
 				</ul> \
 			</li> \

src/http/mime.c

@@ -0,0 +1,73 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#                                                                            #
+#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "mime.h"
+
+#include <string.h>
+
+#include <event2/util.h>
+
+#include "../tools.h"
+
+
+static const struct {
+	const char *ext;
+	const char *mime;
+} _MIME_TYPES[] = {
+	{"html",	"text/html"},
+	{"htm",		"text/html"},
+	{"css",		"text/css"},
+	{"js",		"text/javascript"},
+	{"txt",		"text/plain"},
+	{"jpg",		"image/jpeg"},
+	{"jpeg",	"image/jpeg"},
+	{"png",		"image/png"},
+	{"gif",		"image/gif"},
+	{"ico",		"image/x-icon"},
+	{"bmp",		"image/bmp"},
+	{"svg",		"image/svg+xml"},
+	{"swf",		"application/x-shockwave-flash"},
+	{"cab",		"application/x-shockwave-flash"},
+	{"jar",		"application/java-archive"},
+	{"json",	"application/json"},
+};
+
+
+const char *guess_mime_type(const char *path) {
+	char *dot;
+	char *ext;
+
+	dot = strchr(path, '.');
+	if (dot == NULL || strchr(dot, '/') != NULL) {
+		goto misc;
+	}
+
+	ext = dot + 1;
+	for (unsigned index = 0; index < ARRAY_LEN(_MIME_TYPES); ++index) {
+		if (!evutil_ascii_strcasecmp(ext, _MIME_TYPES[index].ext)) {
+			return _MIME_TYPES[index].mime;
+		}
+	}
+
+	misc:
+		return "application/misc";
+}

src/http/mime.h

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
@@ -21,7 +22,5 @@
 
 #pragma once
 
-#include "../device.h"
 
-
-void jpeg_encoder_compress_buffer(struct device_t *dev, const unsigned index, const unsigned quality);
+const char *guess_mime_type(const char *str);

src/http/path.c

@@ -0,0 +1,183 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#                                                                            #
+#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "path.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "../tools.h"
+
+
+char *simplify_request_path(const char *str) {
+	// Based on Lighttpd sources:
+	//   - https://github.com/lighttpd/lighttpd1.4/blob/b31e7840d5403bc640579135b7004793b9ccd6c0/src/buffer.c#L840
+	//   - https://github.com/lighttpd/lighttpd1.4/blob/77c01f981725512653c01cde5ca74c11633dfec4/src/t/test_buffer.c
+
+	char ch; // Current character
+	char pre1; // The one before
+	char pre2; // The one before that
+	char *simplified;
+	char *start;
+	char *out;
+	char *slash;
+
+	A_CALLOC(simplified, strlen(str) + 1);
+
+	if (str[0] == '\0') {
+		simplified[0] = '\0';
+		return simplified;
+	}
+
+	start = simplified;
+	out = simplified;
+	slash = simplified;
+
+	// Skip leading spaces
+	for (; *str == ' '; ++str);
+
+	if (*str == '.') {
+		if (str[1] == '/' || str[1] == '\0') {
+			++str;
+		} else if (str[1] == '.' && (str[2] == '/' || str[2] == '\0')) {
+			str += 2;
+		}
+	}
+
+	pre1 = '\0';
+	ch = *(str++);
+
+	while (ch != '\0') {
+		pre2 = pre1;
+		pre1 = ch;
+
+		// Possibly: out == str - need to read first
+		ch = *str;
+		*out = pre1;
+
+		out++;
+		str++;
+		// (out <= str) still true; also now (slash < out)
+
+		if (ch == '/' || ch == '\0') {
+			size_t toklen = out - slash;
+
+			if (toklen == 3 && pre2 == '.' && pre1 == '.' && *slash == '/') {
+				// "/../" or ("/.." at end of string)
+				out = slash;
+				// If there is something before "/..", there is at least one
+				// component, which needs to be removed
+				if (out > start) {
+					--out;
+					for (; out > start && *out != '/'; --out);
+				}
+
+				// Don't kill trailing '/' at end of path
+				if (ch == '\0') {
+					++out;
+				}
+				// slash < out before, so out_new <= slash + 1 <= out_before <= str
+			} else if (toklen == 1 || (pre2 == '/' && pre1 == '.')) {
+				// "//" or "/./" or (("/" or "/.") at end of string)
+				out = slash;
+				// Don't kill trailing '/' at end of path
+				if (ch == '\0') {
+					++out;
+				}
+				// Slash < out before, so out_new <= slash + 1 <= out_before <= str
+			}
+
+			slash = out;
+		}
+	}
+
+	*out = '\0';
+	return simplified;
+}
+
+#if 0
+
+int test_simplify_request_path(const char *sample, const char *expected) {
+	char *result = simplify_request_path(sample);
+	int retval = -!!strcmp(result, expected);
+
+	printf("Testing '%s' -> '%s' ... ", sample, expected);
+	if (retval == 0) {
+		printf("ok\n");
+	} else {
+		printf("FAILED; got '%s'\n", result);
+	}
+	free(result);
+	return retval;
+}
+
+int main(void) {
+	int retval = 0;
+
+#	define TEST_SIMPLIFY_REQUEST_PATH(_sample, _expected) { \
+			retval += test_simplify_request_path(_sample, _expected); \
+		}
+
+	TEST_SIMPLIFY_REQUEST_PATH("", "");
+	TEST_SIMPLIFY_REQUEST_PATH("   ", "");
+	TEST_SIMPLIFY_REQUEST_PATH("/", "/");
+	TEST_SIMPLIFY_REQUEST_PATH("//", "/");
+	TEST_SIMPLIFY_REQUEST_PATH("abc", "abc");
+	TEST_SIMPLIFY_REQUEST_PATH("abc//", "abc/");
+	TEST_SIMPLIFY_REQUEST_PATH("abc/./xyz", "abc/xyz");
+	TEST_SIMPLIFY_REQUEST_PATH("abc/.//xyz", "abc/xyz");
+	TEST_SIMPLIFY_REQUEST_PATH("abc/../xyz", "/xyz");
+	TEST_SIMPLIFY_REQUEST_PATH("/abc/./xyz", "/abc/xyz");
+	TEST_SIMPLIFY_REQUEST_PATH("/abc//./xyz", "/abc/xyz");
+	TEST_SIMPLIFY_REQUEST_PATH("/abc/../xyz", "/xyz");
+	TEST_SIMPLIFY_REQUEST_PATH("abc/../xyz/.", "/xyz/");
+	TEST_SIMPLIFY_REQUEST_PATH("/abc/../xyz/.", "/xyz/");
+	TEST_SIMPLIFY_REQUEST_PATH("abc/./xyz/..", "abc/");
+	TEST_SIMPLIFY_REQUEST_PATH("/abc/./xyz/..", "/abc/");
+	TEST_SIMPLIFY_REQUEST_PATH(".", "");
+	TEST_SIMPLIFY_REQUEST_PATH("..", "");
+	TEST_SIMPLIFY_REQUEST_PATH("...", "...");
+	TEST_SIMPLIFY_REQUEST_PATH("....", "....");
+	TEST_SIMPLIFY_REQUEST_PATH(".../", ".../");
+	TEST_SIMPLIFY_REQUEST_PATH("./xyz/..", "/");
+	TEST_SIMPLIFY_REQUEST_PATH(".//xyz/..", "/");
+	TEST_SIMPLIFY_REQUEST_PATH("/./xyz/..", "/");
+	TEST_SIMPLIFY_REQUEST_PATH(".././xyz/..", "/");
+	TEST_SIMPLIFY_REQUEST_PATH("/.././xyz/..", "/");
+	TEST_SIMPLIFY_REQUEST_PATH("/.././xyz/..", "/");
+	TEST_SIMPLIFY_REQUEST_PATH("../../../etc/passwd", "/etc/passwd");
+	TEST_SIMPLIFY_REQUEST_PATH("/../../../etc/passwd", "/etc/passwd");
+	TEST_SIMPLIFY_REQUEST_PATH("   ../../../etc/passwd", "/etc/passwd");
+	TEST_SIMPLIFY_REQUEST_PATH("   /../../../etc/passwd", "/etc/passwd");
+	TEST_SIMPLIFY_REQUEST_PATH("   /foo/bar/../../../etc/passwd", "/etc/passwd");
+
+#	undef TEST_SIMPLIFY_REQUEST_PATH
+
+	if (retval < 0) {
+		printf("===== TEST FAILED =====\n");
+	}
+	return retval;
+}
+
+#endif

src/http/path.h

@@ -0,0 +1,26 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#                                                                            #
+#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+
+char *simplify_request_path(const char *str);

src/http/server.c

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
@@ -19,12 +20,22 @@
 *****************************************************************************/
 
 
+#include "server.h"
+
 #include <stdlib.h>
 #include <stdbool.h>
+#include <stdatomic.h>
 #include <string.h>
 #include <strings.h>
+#include <unistd.h>
+#include <fcntl.h>
 #include <assert.h>
 
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/stat.h>
+
 #include <event2/event.h>
 #include <event2/thread.h>
 #include <event2/http.h>
@@ -38,20 +49,29 @@
 #	error Required libevent-pthreads support
 #endif
 
-#include "tools.h"
-#include "logging.h"
-#include "stream.h"
-#include "http.h"
+#include "../tools.h"
+#include "../logging.h"
+#include "../encoder.h"
+#include "../stream.h"
+#ifdef WITH_GPIO
+#	include "../gpio.h"
+#endif
+
+#include "blank.h"
+#include "base64.h"
+#include "mime.h"
+#include "static.h"
 
 #include "data/index_html.h"
-#include "data/blank_jpeg.h"
 
 
 static bool _http_get_param_true(struct evkeyvalq *params, const char *key);
 static char *_http_get_param_uri(struct evkeyvalq *params, const char *key);
+static int _http_preprocess_request(struct evhttp_request *request, struct http_server_t *server);
 
-static void _http_callback_root(struct evhttp_request *request, void *arg);
-static void _http_callback_ping(struct evhttp_request *request, void *v_server);
+static void _http_callback_root(struct evhttp_request *request, void *v_server);
+static void _http_callback_static(struct evhttp_request *request, void *v_server);
+static void _http_callback_state(struct evhttp_request *request, void *v_server);
 static void _http_callback_snapshot(struct evhttp_request *request, void *v_server);
 
 static void _http_callback_stream(struct evhttp_request *request, void *v_server);
@@ -59,9 +79,9 @@ static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_c
 static void _http_callback_stream_error(struct bufferevent *buf_event, short what, void *v_ctx);
 
 static void _http_exposed_refresh(int fd, short event, void *v_server);
-static void _http_queue_send_stream(struct http_server_t *server, const bool stream_updated, const bool picture_updated);
+static void _http_queue_send_stream(struct http_server_t *server, bool stream_updated, bool picture_updated);
 
-static bool _expose_new_picture(struct http_server_t *server);
+static bool _expose_new_picture_unsafe(struct http_server_t *server);
 static bool _expose_blank_picture(struct http_server_t *server);
 
 
@@ -80,21 +100,17 @@ struct http_server_t *http_server_init(struct stream_t *stream) {
 	A_CALLOC(server, 1);
 	server->host = "127.0.0.1";
 	server->port = 8080;
+	server->unix_path = "";
+	server->user = "";
+	server->passwd = "";
+	server->static_path = "";
 	server->timeout = 10;
 	server->run = run;
 
-	_expose_blank_picture(server);
-
 	assert(!evthread_use_pthreads());
 	assert((run->base = event_base_new()));
 	assert((run->http = evhttp_new(run->base)));
 	evhttp_set_allowed_methods(run->http, EVHTTP_REQ_GET|EVHTTP_REQ_HEAD);
-
-	assert(!evhttp_set_cb(run->http, "/", _http_callback_root, NULL));
-	assert(!evhttp_set_cb(run->http, "/ping", _http_callback_ping, (void *)server));
-	assert(!evhttp_set_cb(run->http, "/snapshot", _http_callback_snapshot, (void *)server));
-	assert(!evhttp_set_cb(run->http, "/stream", _http_callback_stream, (void *)server));
-
 	return server;
 }
 
@@ -105,8 +121,30 @@ void http_server_destroy(struct http_server_t *server) {
 	}
 
 	evhttp_free(server->run->http);
+	if (server->run->unix_fd) {
+		close(server->run->unix_fd);
+	}
 	event_base_free(server->run->base);
+
+#	if LIBEVENT_VERSION_NUMBER >= 0x02010100
 	libevent_global_shutdown();
+#	endif
+
+	for (struct stream_client_t *client = server->run->stream_clients; client != NULL;) {
+		struct stream_client_t *next = client->next;
+
+		free(client->key);
+		free(client);
+		client = next;
+	}
+
+	if (server->run->auth_token) {
+		free(server->run->auth_token);
+	}
+
+	if (server->run->blank) {
+		blank_destroy(server->run->blank);
+	}
 
 	free(server->run->exposed->picture.data);
 	free(server->run->exposed);
@@ -115,24 +153,112 @@ void http_server_destroy(struct http_server_t *server) {
 }
 
 int http_server_listen(struct http_server_t *server) {
-	struct timeval refresh_interval;
-
-	refresh_interval.tv_sec = 0;
-	refresh_interval.tv_usec = 1000000 / (server->run->stream->dev->soft_fps * 2);
-	assert((server->run->refresh = event_new(server->run->base, -1, EV_PERSIST, _http_exposed_refresh, server)));
-	assert(!event_add(server->run->refresh, &refresh_interval));
-
-	server->run->drop_same_frames_blank = max_u(server->drop_same_frames, server->run->drop_same_frames_blank);
-
-	LOG_DEBUG("Binding HTTP to [%s]:%d ...", server->host, server->port);
-	evhttp_set_timeout(server->run->http, server->timeout);
-
-	if (evhttp_bind_socket(server->run->http, server->host, server->port) < 0) {
-		LOG_PERROR("Can't listen HTTP on [%s]:%d", server->host, server->port)
-		return -1;
+	{
+		if (server->static_path[0] != '\0') {
+			evhttp_set_gencb(server->run->http, _http_callback_static, (void *)server);
+		} else {
+			assert(!evhttp_set_cb(server->run->http, "/", _http_callback_root, (void *)server));
+		}
+		assert(!evhttp_set_cb(server->run->http, "/state", _http_callback_state, (void *)server));
+		assert(!evhttp_set_cb(server->run->http, "/snapshot", _http_callback_snapshot, (void *)server));
+		assert(!evhttp_set_cb(server->run->http, "/stream", _http_callback_stream, (void *)server));
+	}
+
+	server->run->drop_same_frames_blank = max_u(server->drop_same_frames, server->run->drop_same_frames_blank);
+	server->run->blank = blank_init(server->blank_path);
+	_expose_blank_picture(server);
+
+	{
+		struct timeval refresh_interval;
+
+		refresh_interval.tv_sec = 0;
+		if (server->run->stream->dev->desired_fps > 0) {
+			refresh_interval.tv_usec = 1000000 / (server->run->stream->dev->desired_fps * 2);
+		} else {
+			refresh_interval.tv_usec = 16000; // ~60fps
+		}
+
+		assert((server->run->refresh = event_new(server->run->base, -1, EV_PERSIST, _http_exposed_refresh, server)));
+		assert(!event_add(server->run->refresh, &refresh_interval));
+	}
+
+	if (server->slowdown) {
+		stream_switch_slowdown(server->run->stream, true);
+	}
+
+	evhttp_set_timeout(server->run->http, server->timeout);
+
+	if (server->user[0] != '\0') {
+		char *raw_token;
+		char *encoded_token;
+
+		A_CALLOC(raw_token, strlen(server->user) + strlen(server->passwd) + 2);
+		sprintf(raw_token, "%s:%s", server->user, server->passwd);
+		encoded_token = base64_encode((unsigned char *)raw_token);
+		free(raw_token);
+
+		A_CALLOC(server->run->auth_token, strlen(encoded_token) + 16);
+		sprintf(server->run->auth_token, "Basic %s", encoded_token);
+		free(encoded_token);
+
+		LOG_INFO("Using HTTP basic auth");
+	}
+
+	if (server->unix_path[0] != '\0') {
+		struct sockaddr_un unix_addr;
+
+		LOG_DEBUG("Binding HTTP to UNIX socket '%s' ...", server->unix_path);
+
+#		define MAX_SUN_PATH (sizeof(unix_addr.sun_path) - 1)
+
+		if (strlen(server->unix_path) > MAX_SUN_PATH) {
+			LOG_ERROR("UNIX socket path is too long; max=%zu", MAX_SUN_PATH);
+			return -1;
+		}
+
+		MEMSET_ZERO(unix_addr);
+		strncpy(unix_addr.sun_path, server->unix_path, MAX_SUN_PATH);
+		unix_addr.sun_family = AF_UNIX;
+
+#		undef MAX_SUN_PATH
+
+		assert((server->run->unix_fd = socket(AF_UNIX, SOCK_STREAM, 0)) >= 0);
+		assert(!evutil_make_socket_nonblocking(server->run->unix_fd));
+
+		if (server->unix_rm && unlink(server->unix_path) < 0) {
+			if (errno != ENOENT) {
+				LOG_PERROR("Can't remove old UNIX socket '%s'", server->unix_path);
+				return -1;
+			}
+		}
+		if (bind(server->run->unix_fd, (struct sockaddr *)&unix_addr, sizeof(struct sockaddr_un)) < 0) {
+			LOG_PERROR("Can't bind HTTP to UNIX socket '%s'", server->unix_path);
+			return -1;
+		}
+		if (server->unix_mode && chmod(server->unix_path, server->unix_mode) < 0) {
+			LOG_PERROR("Can't set permissions %o to UNIX socket '%s'", server->unix_mode, server->unix_path);
+			return -1;
+		}
+		if (listen(server->run->unix_fd, 128) < 0) {
+			LOG_PERROR("Can't listen UNIX socket '%s'", server->unix_path);
+			return -1;
+		}
+		if (evhttp_accept_socket(server->run->http, server->run->unix_fd) < 0) {
+			LOG_PERROR("Can't evhttp_accept_socket() UNIX socket '%s'", server->unix_path);
+			return -1;
+		}
+
+		LOG_INFO("Listening HTTP on UNIX socket '%s'", server->unix_path);
+
+	} else {
+		LOG_DEBUG("Binding HTTP to [%s]:%u ...", server->host, server->port);
+		if (evhttp_bind_socket(server->run->http, server->host, server->port) < 0) {
+			LOG_PERROR("Can't bind HTTP on [%s]:%u", server->host, server->port)
+			return -1;
+		}
+		LOG_INFO("Listening HTTP on [%s]:%u", server->host, server->port);
 	}
 
-	LOG_INFO("Listening HTTP on [%s]:%d", server->host, server->port);
 	return 0;
 }
 
@@ -151,7 +277,11 @@ static bool _http_get_param_true(struct evkeyvalq *params, const char *key) {
 	const char *value_str;
 
 	if ((value_str = evhttp_find_header(params, key)) != NULL) {
-		if (!strcasecmp(value_str, "true") || !strcasecmp(value_str, "yes") || value_str[0] == '1') {
+		if (
+			value_str[0] == '1'
+			|| !evutil_ascii_strcasecmp(value_str, "true")
+			|| !evutil_ascii_strcasecmp(value_str, "yes")
+		) {
 			return true;
 		}
 	}
@@ -170,56 +300,166 @@ static char *_http_get_param_uri(struct evkeyvalq *params, const char *key) {
 #define ADD_HEADER(_key, _value) \
 	assert(!evhttp_add_header(evhttp_request_get_output_headers(request), _key, _value))
 
-#define PROCESS_HEAD_REQUEST { \
-		if (evhttp_request_get_command(request) == EVHTTP_REQ_HEAD) { \
-			evhttp_send_reply(request, HTTP_OK, "OK", NULL); \
+static int _http_preprocess_request(struct evhttp_request *request, struct http_server_t *server) {
+	if (server->run->auth_token) {
+		const char *token = evhttp_find_header(evhttp_request_get_input_headers(request), "Authorization");
+
+		if (token == NULL || strcmp(token, server->run->auth_token) != 0) {
+			ADD_HEADER("WWW-Authenticate", "Basic realm=\"Restricted area\"");
+			evhttp_send_reply(request, 401, "Unauthorized", NULL);
+			return -1;
+		}
+	}
+
+	if (evhttp_request_get_command(request) == EVHTTP_REQ_HEAD) { \
+		evhttp_send_reply(request, HTTP_OK, "OK", NULL); \
+		return -1;
+	}
+
+	return 0;
+}
+
+#define PREPROCESS_REQUEST { \
+		if (_http_preprocess_request(request, server) < 0) { \
 			return; \
 		} \
 	}
 
-static void _http_callback_root(struct evhttp_request *request, UNUSED void *arg) {
+static void _http_callback_root(struct evhttp_request *request, void *v_server) {
+	struct http_server_t *server = (struct http_server_t *)v_server;
 	struct evbuffer *buf;
 
-	PROCESS_HEAD_REQUEST;
+	PREPROCESS_REQUEST;
 
 	assert((buf = evbuffer_new()));
-	assert(evbuffer_add_printf(buf, HTML_INDEX_PAGE));
+	assert(evbuffer_add_printf(buf, "%s", HTML_INDEX_PAGE));
 	ADD_HEADER("Content-Type", "text/html");
 	evhttp_send_reply(request, HTTP_OK, "OK", buf);
 	evbuffer_free(buf);
 }
 
-static void _http_callback_ping(struct evhttp_request *request, void *v_server) {
+static void _http_callback_static(struct evhttp_request *request, void *v_server) {
 	struct http_server_t *server = (struct http_server_t *)v_server;
-	struct evbuffer *buf;
+	struct evbuffer *buf = NULL;
+	struct evhttp_uri *uri = NULL;
+	char *uri_path;
+	char *decoded_path = NULL;
+	char *static_path = NULL;
+	int fd = -1;
+	struct stat st;
 
-	PROCESS_HEAD_REQUEST;
+	PREPROCESS_REQUEST;
+
+	if ((uri = evhttp_uri_parse(evhttp_request_get_uri(request))) == NULL) {
+		goto bad_request;
+	}
+	if ((uri_path = (char *)evhttp_uri_get_path(uri)) == NULL) {
+		uri_path = "/";
+	}
+
+	if ((decoded_path = evhttp_uridecode(uri_path, 0, NULL)) == NULL) {
+		goto bad_request;
+	}
 
 	assert((buf = evbuffer_new()));
+
+	if ((static_path = find_static_file_path(server->static_path, decoded_path)) == NULL) {
+		goto not_found;
+	}
+
+	if ((fd = open(static_path, O_RDONLY)) < 0) {
+		LOG_PERROR("HTTP: Can't open found static file %s", static_path);
+		goto not_found;
+	}
+
+	if (fstat(fd, &st) < 0) {
+		LOG_PERROR("HTTP: Can't stat() found static file %s", static_path);
+		goto not_found;
+	}
+
+	if (evbuffer_add_file(buf, fd, 0, st.st_size) < 0) {
+		LOG_ERROR("HTTP: Can't serve static file %s", static_path);
+		goto not_found;
+	}
+	ADD_HEADER("Content-Type", guess_mime_type(static_path));
+	evhttp_send_reply(request, HTTP_OK, "OK", buf);
+	goto cleanup;
+
+	bad_request:
+		evhttp_send_error(request, HTTP_BADREQUEST, NULL);
+		goto cleanup;
+
+	not_found:
+		evhttp_send_error(request, HTTP_NOTFOUND, NULL);
+		goto cleanup;
+
+	cleanup:
+		if (fd >= 0) {
+			close(fd);
+		}
+		if (static_path) {
+			free(static_path);
+		}
+		if (buf) {
+			evbuffer_free(buf);
+		}
+		if (decoded_path) {
+			free(decoded_path);
+		}
+		if (uri) {
+			evhttp_uri_free(uri);
+		}
+}
+
+static void _http_callback_state(struct evhttp_request *request, void *v_server) {
+	struct http_server_t *server = (struct http_server_t *)v_server;
+	struct evbuffer *buf;
+	enum encoder_type_t encoder_run_type;
+	unsigned encoder_run_quality;
+
+	PREPROCESS_REQUEST;
+
+#	define ENCODER(_next) server->run->stream->encoder->_next
+
+	A_MUTEX_LOCK(&ENCODER(run->mutex));
+	encoder_run_type = ENCODER(run->type);
+	encoder_run_quality = ENCODER(run->quality);
+	A_MUTEX_UNLOCK(&ENCODER(run->mutex));
+
+	assert((buf = evbuffer_new()));
+
 	assert(evbuffer_add_printf(buf,
-		"{\"source\": {\"resolution\": {\"width\": %u, \"height\": %u},"
-		" \"online\": %s, \"quality\": %u, \"soft_fps\": %u, \"captured_fps\": %u},"
-		" \"stream\": {\"queued_fps\": %u,  \"clients\": %u, \"clients_stat\": {",
+		"{\"ok\": true, \"result\": {"
+		" \"encoder\": {\"type\": \"%s\", \"quality\": %u},"
+		" \"source\": {\"resolution\": {\"width\": %u, \"height\": %u},"
+		" \"online\": %s, \"desired_fps\": %u, \"captured_fps\": %u},"
+		" \"stream\": {\"queued_fps\": %u, \"clients\": %u, \"clients_stat\": {",
+		encoder_type_to_string(encoder_run_type),
+		encoder_run_quality,
 		(server->fake_width ? server->fake_width : server->run->exposed->width),
 		(server->fake_height ? server->fake_height : server->run->exposed->height),
 		bool_to_string(server->run->exposed->online),
-		server->run->stream->encoder->quality,
-		server->run->stream->dev->soft_fps,
+		server->run->stream->dev->desired_fps,
 		server->run->exposed->captured_fps,
 		server->run->exposed->queued_fps,
 		server->run->stream_clients_count
 	));
+
+#	undef ENCODER
+
 	for (struct stream_client_t * client = server->run->stream_clients; client != NULL; client = client->next) {
 		assert(evbuffer_add_printf(buf,
-			"\"%s\": {\"fps\": %u, \"advance_headers\": %s, \"dual_final_frames\": %s}%s",
+			"\"%s\": {\"fps\": %u, \"extra_headers\": %s, \"advance_headers\": %s, \"dual_final_frames\": %s}%s",
 			client->id,
 			client->fps,
+			bool_to_string(client->extra_headers),
 			bool_to_string(client->advance_headers),
 			bool_to_string(client->dual_final_frames),
 			(client->next ? ", " : "")
 		));
 	}
-	assert(evbuffer_add_printf(buf, "}}}"));
+
+	assert(evbuffer_add_printf(buf, "}}}}"));
 
 	ADD_HEADER("Content-Type", "application/json");
 	evhttp_send_reply(request, HTTP_OK, "OK", buf);
@@ -231,27 +471,32 @@ static void _http_callback_snapshot(struct evhttp_request *request, void *v_serv
 	struct evbuffer *buf;
 	char header_buf[64];
 
-	PROCESS_HEAD_REQUEST;
+	PREPROCESS_REQUEST;
 
 #	define EXPOSED(_next) server->run->exposed->_next
 
 	assert((buf = evbuffer_new()));
-	assert(!evbuffer_add(buf, (const void *)EXPOSED(picture.data), EXPOSED(picture.size)));
+	assert(!evbuffer_add(buf, (const void *)EXPOSED(picture.data), EXPOSED(picture.used)));
 
 	ADD_HEADER("Access-Control-Allow-Origin:", "*");
-	ADD_HEADER("Cache-Control", "no-store, no-cache, must-revalidate, pre-check=0, post-check=0, max-age=0");
+	ADD_HEADER("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate, pre-check=0, post-check=0, max-age=0");
 	ADD_HEADER("Pragma", "no-cache");
 	ADD_HEADER("Expires", "Mon, 3 Jan 2000 12:34:56 GMT");
 
-#	define ADD_TIME_HEADER(_key, _value) \
-		{ sprintf(header_buf, "%.06Lf", _value); ADD_HEADER(_key, header_buf); }
+#	define ADD_TIME_HEADER(_key, _value) { \
+			sprintf(header_buf, "%.06Lf", _value); \
+			ADD_HEADER(_key, header_buf); \
+		}
 
-#	define ADD_UNSIGNED_HEADER(_key, _value) \
-		{ sprintf(header_buf, "%u", _value); ADD_HEADER(_key, header_buf); }
+#	define ADD_UNSIGNED_HEADER(_key, _value) { \
+			sprintf(header_buf, "%u", _value); \
+			ADD_HEADER(_key, header_buf); \
+		}
 
 	ADD_TIME_HEADER("X-Timestamp", get_now_real());
 
 	ADD_HEADER("X-UStreamer-Online",					bool_to_string(EXPOSED(online)));
+	ADD_UNSIGNED_HEADER("X-UStreamer-Dropped",			EXPOSED(dropped));
 	ADD_UNSIGNED_HEADER("X-UStreamer-Width",			EXPOSED(width));
 	ADD_UNSIGNED_HEADER("X-UStreamer-Height",			EXPOSED(height));
 	ADD_TIME_HEADER("X-UStreamer-Grab-Time",			EXPOSED(picture.grab_time));
@@ -291,10 +536,10 @@ static void _http_callback_stream(struct evhttp_request *request, void *v_server
 	unsigned short client_port;
 	uuid_t uuid;
 
-	PROCESS_HEAD_REQUEST;
+	PREPROCESS_REQUEST;
 
 	conn = evhttp_request_get_connection(request);
-	if (conn != NULL) {
+	if (conn) {
 		A_CALLOC(client, 1);
 		client->server = server;
 		client->request = request;
@@ -322,17 +567,19 @@ static void _http_callback_stream(struct evhttp_request *request, void *v_server
 		}
 		server->run->stream_clients_count += 1;
 
+		if (server->run->stream_clients_count == 1) {
+			if (server->slowdown) {
+				stream_switch_slowdown(server->run->stream, false);
+			}
+
+#			ifdef WITH_GPIO
+			GPIO_SET_HIGH(has_http_clients);
+#			endif
+		}
+
 		evhttp_connection_get_peer(conn, &client_addr, &client_port);
-		LOG_INFO(
-			"HTTP: Registered the new stream client: [%s]:%u; id=%s;"
-			" advance_headers=%s; dual_final_frames=%s; clients now: %u",
-			client_addr,
-			client_port,
-			client->id,
-			bool_to_string(client->advance_headers),
-			bool_to_string(client->dual_final_frames),
-			server->run->stream_clients_count
-		);
+		LOG_INFO("HTTP: Registered the new stream client: [%s]:%u, id=%s; clients now: %u",
+			client_addr, client_port, client->id, server->run->stream_clients_count);
 
 		buf_event = evhttp_connection_get_bufferevent(conn);
 		bufferevent_setcb(buf_event, NULL, NULL, _http_callback_stream_error, (void *)client);
@@ -342,7 +589,7 @@ static void _http_callback_stream(struct evhttp_request *request, void *v_server
 	}
 }
 
-#undef PROCESS_HEAD_REQUEST
+#undef PREPROCESS_REQUEST
 
 static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_client) {
 #	define BOUNDARY "boundarydonotcross"
@@ -382,17 +629,17 @@ static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_c
 	// по тем же причинам, по которым у нас нет Content-Length.
 
 #	define ADD_ADVANCE_HEADERS \
-		{ assert(evbuffer_add_printf(buf, \
-		"Content-Type: image/jpeg" RN "X-Timestamp: %.06Lf" RN RN, get_now_real())); }
+		assert(evbuffer_add_printf(buf, \
+			"Content-Type: image/jpeg" RN "X-Timestamp: %.06Lf" RN RN, get_now_real()))
 
 	if (client->need_initial) {
 		assert(evbuffer_add_printf(buf,
 			"HTTP/1.0 200 OK" RN
 			"Access-Control-Allow-Origin: *" RN
-			"Cache-Control: no-store, no-cache, must-revalidate, pre-check=0, post-check=0, max-age=0" RN
+			"Cache-Control: no-store, no-cache, must-revalidate, proxy-revalidate, pre-check=0, post-check=0, max-age=0" RN
 			"Pragma: no-cache" RN
 			"Expires: Mon, 3 Jan 2000 12:34:56 GMT" RN
-			"Set-Cookie: stream_client_key=%s; stream_client_id=%s; path=/; max-age=30" RN
+			"Set-Cookie: stream_client=%s/%s; path=/; max-age=30" RN
 			"Content-Type: multipart/x-mixed-replace;boundary=" BOUNDARY RN
 			RN
 			"--" BOUNDARY RN,
@@ -413,15 +660,17 @@ static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_c
 	if (!client->advance_headers) {
 		assert(evbuffer_add_printf(buf,
 			"Content-Type: image/jpeg" RN
-			"Content-Length: %lu" RN
+			"Content-Length: %zu" RN
 			"X-Timestamp: %.06Lf" RN
 			"%s",
-			EXPOSED(picture.size) * sizeof(*EXPOSED(picture.data)),
-			get_now_real(), (client->extra_headers ? "" : RN)
+			EXPOSED(picture.used),
+			get_now_real(),
+			(client->extra_headers ? "" : RN)
 		));
 		if (client->extra_headers) {
 			assert(evbuffer_add_printf(buf,
 				"X-UStreamer-Online: %s" RN
+				"X-UStreamer-Dropped: %u" RN
 				"X-UStreamer-Width: %u" RN
 				"X-UStreamer-Height: %u" RN
 				"X-UStreamer-Client-FPS: %u" RN
@@ -434,6 +683,7 @@ static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_c
 				"X-UStreamer-Send-Time: %.06Lf" RN
 				RN,
 				bool_to_string(EXPOSED(online)),
+				EXPOSED(dropped),
 				EXPOSED(width),
 				EXPOSED(height),
 				client->fps,
@@ -448,10 +698,7 @@ static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_c
 		}
 	}
 
-	assert(!evbuffer_add(buf,
-		(void *)EXPOSED(picture.data),
-		EXPOSED(picture.size) * sizeof(*EXPOSED(picture.data))
-	));
+	assert(!evbuffer_add(buf, (void *)EXPOSED(picture.data), EXPOSED(picture.used)));
 	assert(evbuffer_add_printf(buf, RN "--" BOUNDARY RN));
 
 	if (client->advance_headers) {
@@ -476,22 +723,32 @@ static void _http_callback_stream_error(UNUSED struct bufferevent *buf_event, UN
 	char *client_addr = "???";
 	unsigned short client_port = 0;
 
-	client->server->run->stream_clients_count -= 1;
+#	define RUN(_next) client->server->run->_next
+
+	RUN(stream_clients_count) -= 1;
+
+	if (RUN(stream_clients_count) <= 0) {
+		if (client->server->slowdown) {
+			stream_switch_slowdown(RUN(stream), true);
+		}
+
+#		ifdef WITH_GPIO
+		GPIO_SET_LOW(has_http_clients);
+#		endif
+	}
 
 	conn = evhttp_request_get_connection(client->request);
-	if (conn != NULL) {
+	if (conn) {
 		evhttp_connection_get_peer(conn, &client_addr, &client_port);
 	}
-	LOG_INFO(
-		"HTTP: Disconnected the stream client: [%s]:%u; clients now: %u",
-		client_addr, client_port, client->server->run->stream_clients_count
-	);
-	if (conn != NULL) {
+	LOG_INFO("HTTP: Disconnected the stream client: [%s]:%u; clients now: %u",
+		client_addr, client_port, RUN(stream_clients_count));
+	if (conn) {
 		evhttp_connection_free(conn);
 	}
 
 	if (client->prev == NULL) {
-		client->server->run->stream_clients = client->next;
+		RUN(stream_clients) = client->next;
 	} else {
 		client->prev->next = client->next;
 	}
@@ -500,9 +757,11 @@ static void _http_callback_stream_error(UNUSED struct bufferevent *buf_event, UN
 	}
 	free(client->key);
 	free(client);
+
+#	undef RUN
 }
 
-static void _http_queue_send_stream(struct http_server_t *server, const bool stream_updated, const bool picture_updated) {
+static void _http_queue_send_stream(struct http_server_t *server, bool stream_updated, bool picture_updated) {
 	struct evhttp_connection *conn;
 	struct bufferevent *buf_event;
 	long long now;
@@ -512,7 +771,7 @@ static void _http_queue_send_stream(struct http_server_t *server, const bool str
 
 	for (struct stream_client_t *client = server->run->stream_clients; client != NULL; client = client->next) {
 		conn = evhttp_request_get_connection(client->request);
-		if (conn != NULL) {
+		if (conn) {
 			// Фикс для бага WebKit. При включенной опции дропа одинаковых фреймов,
 			// WebKit отрисовывает последний фрейм в серии с некоторой задержкой,
 			// и нужно послать два фрейма, чтобы серия была вовремя завершена.
@@ -556,14 +815,16 @@ static void _http_exposed_refresh(UNUSED int fd, UNUSED short what, void *v_serv
 	bool stream_updated = false;
 	bool picture_updated = false;
 
-#	define UNLOCK_STREAM \
-		{ server->run->stream->updated = false; A_PTHREAD_M_UNLOCK(&server->run->stream->mutex); }
+#	define UNLOCK_STREAM { \
+			atomic_store(&server->run->stream->updated, false); \
+			A_MUTEX_UNLOCK(&server->run->stream->mutex); \
+		}
 
-	if (server->run->stream->updated) {
+	if (atomic_load(&server->run->stream->updated)) {
 		LOG_DEBUG("Refreshing HTTP exposed ...");
-		A_PTHREAD_M_LOCK(&server->run->stream->mutex);
-		if (server->run->stream->picture.size > 0) { // If online
-			picture_updated = _expose_new_picture(server);
+		A_MUTEX_LOCK(&server->run->stream->mutex);
+		if (server->run->stream->picture.used > 0) { // If online
+			picture_updated = _expose_new_picture_unsafe(server);
 			UNLOCK_STREAM;
 		} else {
 			UNLOCK_STREAM;
@@ -581,39 +842,34 @@ static void _http_exposed_refresh(UNUSED int fd, UNUSED short what, void *v_serv
 	_http_queue_send_stream(server, stream_updated, picture_updated);
 }
 
-static bool _expose_new_picture(struct http_server_t *server) {
+static bool _expose_new_picture_unsafe(struct http_server_t *server) {
 #	define STREAM(_next) server->run->stream->_next
 #	define EXPOSED(_next) server->run->exposed->_next
 
-	assert(STREAM(picture.size) > 0);
+	assert(STREAM(picture.used) > 0);
 	EXPOSED(captured_fps) = STREAM(captured_fps);
 	EXPOSED(expose_begin_time) = get_now_monotonic();
 
 #	define MEM_STREAM_TO_EXPOSED \
-		EXPOSED(picture.data), STREAM(picture.data), \
-		STREAM(picture.size) * sizeof(*STREAM(picture.data))
+		EXPOSED(picture.data), STREAM(picture.data), STREAM(picture.used)
 
 	if (server->drop_same_frames) {
 		if (
 			EXPOSED(online)
 			&& EXPOSED(dropped) < server->drop_same_frames
-			&& EXPOSED(picture.size) == STREAM(picture.size)
+			&& EXPOSED(picture.used) == STREAM(picture.used)
 			&& !memcmp(MEM_STREAM_TO_EXPOSED)
 		) {
 			EXPOSED(expose_cmp_time) = get_now_monotonic();
 			EXPOSED(expose_end_time) = EXPOSED(expose_cmp_time);
-			LOG_VERBOSE(
-				"HTTP: dropped same frame number %u; comparsion time = %.06Lf",
-				EXPOSED(dropped), EXPOSED(expose_cmp_time) - EXPOSED(expose_begin_time)
-			);
+			LOG_VERBOSE("HTTP: dropped same frame number %u; cmp_time=%.06Lf",
+				EXPOSED(dropped), EXPOSED(expose_cmp_time) - EXPOSED(expose_begin_time));
 			EXPOSED(dropped) += 1;
 			return false; // Not updated
 		} else {
 			EXPOSED(expose_cmp_time) = get_now_monotonic();
-			LOG_VERBOSE(
-				"HTTP: passed same frame check (frames are differ); comparsion time = %.06Lf",
-				EXPOSED(expose_cmp_time) - EXPOSED(expose_begin_time)
-			);
+			LOG_VERBOSE("HTTP: passed same frame check (frames are differ); cmp_time=%.06Lf",
+				EXPOSED(expose_cmp_time) - EXPOSED(expose_begin_time));
 		}
 	}
 
@@ -626,7 +882,7 @@ static bool _expose_new_picture(struct http_server_t *server) {
 
 #	undef MEM_STREAM_TO_EXPOSED
 
-	EXPOSED(picture.size) = STREAM(picture.size);
+	EXPOSED(picture.used) = STREAM(picture.used);
 
 	EXPOSED(picture.grab_time) = STREAM(picture.grab_time);
 	EXPOSED(picture.encode_begin_time) = STREAM(picture.encode_begin_time);
@@ -639,10 +895,8 @@ static bool _expose_new_picture(struct http_server_t *server) {
 	EXPOSED(expose_cmp_time) = EXPOSED(expose_begin_time);
 	EXPOSED(expose_end_time) = get_now_monotonic();
 
-	LOG_VERBOSE(
-		"HTTP: exposed new frame; full exposition time =  %.06Lf",
-		 EXPOSED(expose_end_time) - EXPOSED(expose_begin_time)
-	);
+	LOG_VERBOSE("HTTP: exposed new frame; full exposition time =  %.06Lf",
+		 EXPOSED(expose_end_time) - EXPOSED(expose_begin_time));
 
 #	undef EXPOSED
 #	undef STREAM
@@ -650,30 +904,28 @@ static bool _expose_new_picture(struct http_server_t *server) {
 }
 
 static bool _expose_blank_picture(struct http_server_t *server) {
-#	define EXPOSED(_next) server->run->exposed->_next
+#	define BLANK(_next)		server->run->blank->_next
+#	define EXPOSED(_next)	server->run->exposed->_next
 
 	EXPOSED(expose_begin_time) = get_now_monotonic();
 	EXPOSED(expose_cmp_time) = EXPOSED(expose_begin_time);
 
-	if (EXPOSED(online) || EXPOSED(picture.size) == 0) {
-		if (EXPOSED(picture.allocated) < BLANK_JPG_SIZE) {
-			A_REALLOC(EXPOSED(picture.data), BLANK_JPG_SIZE);
-			EXPOSED(picture.allocated) = BLANK_JPG_SIZE;
+	if (EXPOSED(online) || EXPOSED(picture.used) == 0) {
+		if (EXPOSED(picture.allocated) < BLANK(picture.used)) {
+			A_REALLOC(EXPOSED(picture.data), BLANK(picture.used));
+			EXPOSED(picture.allocated) = BLANK(picture.used);
 		}
 
-		memcpy(
-			EXPOSED(picture.data), BLANK_JPG_DATA,
-			BLANK_JPG_SIZE * sizeof(*EXPOSED(picture.data))
-		);
+		memcpy(EXPOSED(picture.data), BLANK(picture.data), BLANK(picture.used));
 
-		EXPOSED(picture.size) = BLANK_JPG_SIZE;
+		EXPOSED(picture.used) = BLANK(picture.used);
 
 		EXPOSED(picture.grab_time) = 0;
 		EXPOSED(picture.encode_begin_time) = 0;
 		EXPOSED(picture.encode_end_time) = 0;
 
-		EXPOSED(width) = BLANK_JPG_WIDTH;
-		EXPOSED(height) = BLANK_JPG_HEIGHT;
+		EXPOSED(width) = BLANK(width);
+		EXPOSED(height) = BLANK(height);
 		EXPOSED(captured_fps) = 0;
 		EXPOSED(online) = false;
 		goto updated;
@@ -692,4 +944,5 @@ static bool _expose_blank_picture(struct http_server_t *server) {
 		return true; // Updated
 
 #	undef EXPOSED
+#	undef BLANK
 }

src/http/server.h

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
@@ -19,13 +20,20 @@
 *****************************************************************************/
 
 
+#pragma once
+
 #include <stdbool.h>
 
+#include <sys/stat.h>
+
 #include <event2/event.h>
 #include <event2/http.h>
+#include <event2/util.h>
 
-#include "tools.h"
-#include "stream.h"
+#include "../tools.h"
+#include "../stream.h"
+
+#include "blank.h"
 
 
 struct stream_client_t {
@@ -65,21 +73,34 @@ struct exposed_t {
 struct http_server_runtime_t {
 	struct event_base		*base;
 	struct evhttp			*http;
+	evutil_socket_t			unix_fd;
+	char					*auth_token;
 	struct event			*refresh;
 	struct stream_t			*stream;
 	struct exposed_t		*exposed;
 	struct stream_client_t	*stream_clients;
 	unsigned				stream_clients_count;
+	struct blank_t			*blank;
 	unsigned				drop_same_frames_blank;
 };
 
 struct http_server_t {
 	char		*host;
 	unsigned	port;
+	char		*unix_path;
+	bool		unix_rm;
+	mode_t		unix_mode;
+	unsigned	timeout;
+
+	char		*user;
+	char		*passwd;
+	char		*static_path;
+
+	char		*blank_path;
 	unsigned	drop_same_frames;
+	bool		slowdown;
 	unsigned	fake_width;
 	unsigned	fake_height;
-	unsigned	timeout;
 
 	struct http_server_runtime_t *run;
 };

src/http/static.c

@@ -0,0 +1,89 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#                                                                            #
+#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "static.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "../tools.h"
+#include "../logging.h"
+
+#include "path.h"
+
+
+char *find_static_file_path(const char *root_path, const char *request_path) {
+	char *simplified_path;
+	char *path = NULL;
+	struct stat st;
+
+	simplified_path = simplify_request_path(request_path);
+	if (simplified_path[0] == '\0') {
+		goto error;
+	}
+
+	A_CALLOC(path, strlen(root_path) + strlen(simplified_path) + 32);
+	sprintf(path, "%s/%s", root_path, simplified_path);
+
+#	define LOAD_STAT { \
+			if (lstat(path, &st) < 0) { \
+				/* LOG_PERROR("Can't stat() file %s", path); */ \
+				goto error; \
+			} \
+		}
+
+	LOAD_STAT;
+	if (S_ISDIR(st.st_mode)) {
+		strcat(path, "/index.html");
+		LOAD_STAT;
+	}
+
+#	undef LOAD_STAT
+
+	if (!S_ISREG(st.st_mode)) {
+		// LOG_ERROR("Not a regulary file: %s", path);
+		goto error;
+	}
+
+	if (access(path, R_OK) < 0) {
+		// LOG_PERROR("Can't access() R_OK file %s", path);
+		goto error;
+	}
+
+	goto ok;
+
+	error:
+		if (path) {
+			free(path);
+		}
+		path = NULL;
+
+	ok:
+		free(simplified_path);
+
+	return path;
+}

src/http/static.h

@@ -0,0 +1,26 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#                                                                            #
+#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+
+char *find_static_file_path(const char *root_path, const char *request_path);

src/logging.h

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
@@ -24,16 +25,12 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
 #include <errno.h>
 #include <time.h>
 #include <assert.h>
 
 #include <pthread.h>
 
-#include <sys/types.h>
-#include <sys/syscall.h>
-
 #include "tools.h"
 
 
@@ -47,8 +44,12 @@ pthread_mutex_t log_mutex;
 #define LOG_LEVEL_DEBUG		3
 
 
-#define LOGGING_INIT	assert(!pthread_mutex_init(&log_mutex, NULL))
-#define LOGGING_DESTROY	assert(!pthread_mutex_destroy(&log_mutex))
+#define LOGGING_INIT { \
+		log_level = LOG_LEVEL_INFO; \
+		assert(!pthread_mutex_init(&log_mutex, NULL)); \
+	}
+
+#define LOGGING_DESTROY assert(!pthread_mutex_destroy(&log_mutex))
 
 #define LOGGING_LOCK	assert(!pthread_mutex_lock(&log_mutex))
 #define LOGGING_UNLOCK	assert(!pthread_mutex_unlock(&log_mutex))
@@ -71,7 +72,7 @@ pthread_mutex_t log_mutex;
 	}
 
 #define LOG_PRINTF_NOLOCK(_label, _msg, ...) { \
-		printf("-- " _label " [%.03Lf tid=%ld] -- " _msg "\n", get_now_monotonic(), syscall(SYS_gettid), ##__VA_ARGS__); \
+		printf("-- " _label " [%.03Lf tid=%d] -- " _msg "\n", get_now_monotonic(), get_thread_id(), ##__VA_ARGS__); \
 		fflush(stdout); \
 	}
 
@@ -83,9 +84,9 @@ pthread_mutex_t log_mutex;
 
 #define LOG_PERROR(_msg, ...) { \
 		char _buf[1024] = ""; \
-		char *_ptr = strerror_r(errno, _buf, 1024); \
+		char *_ptr = errno_to_string(_buf, 1024); \
 		LOGGING_LOCK; \
-		printf("-- ERROR [%.03Lf tid=%ld] -- " _msg ": %s\n", get_now_monotonic(), syscall(SYS_gettid), ##__VA_ARGS__, _ptr); \
+		printf("-- ERROR [%.03Lf tid=%d] -- " _msg ": %s\n", get_now_monotonic(), get_thread_id(), ##__VA_ARGS__, _ptr); \
 		fflush(stdout); \
 		LOGGING_UNLOCK; \
 	}
@@ -123,3 +124,13 @@ pthread_mutex_t log_mutex;
 			LOGGING_UNLOCK; \
 		} \
 	}
+
+
+INLINE char *errno_to_string(char *buf, size_t size) {
+#	if defined(__GLIBC__) && defined(_GNU_SOURCE)
+	return strerror_r(errno, buf, size);
+#	else
+	strerror_r(errno, buf, size);
+	return buf;
+#	endif
+}

src/main.c

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
@@ -26,6 +27,8 @@
 
 #include <stdio.h>
 #include <stdbool.h>
+#include <string.h>
+#include <limits.h>
 #include <signal.h>
 #include <getopt.h>
 
@@ -37,52 +40,92 @@
 #include "device.h"
 #include "encoder.h"
 #include "stream.h"
-#include "http.h"
+#include "http/server.h"
+#ifdef WITH_GPIO
+#	include "gpio.h"
+#endif
 
 
-static const char _short_opts[] = "d:i:x:y:f:a:e:z:tn:w:q:c:s:p:r:h";
-static const struct option _long_opts[] = {
+static const char _SHORT_OPTS[] = "d:i:r:x:y:m:a:f:z:ntb:w:q:c:s:p:U:DM:k:e:lR:hv"
+#ifdef WITH_OMX
+	"g:"
+#endif
+;
+static const struct option _LONG_OPTS[] = {
 	{"device",					required_argument,	NULL,	'd'},
 	{"input",					required_argument,	NULL,	'i'},
+	{"resolution",				required_argument,	NULL,	'r'},
 	{"width",					required_argument,	NULL,	'x'},
 	{"height",					required_argument,	NULL,	'y'},
-	{"format",					required_argument,	NULL,	'f'},
+	{"format",					required_argument,	NULL,	'm'},
 	{"tv-standard",				required_argument,	NULL,	'a'},
-	{"soft-fps",				required_argument,	NULL,	'm'},
-	{"every-frame",				required_argument,	NULL,	'e'},
+	{"desired-fps",				required_argument,	NULL,	'f'},
 	{"min-frame-size",			required_argument,	NULL,	'z'},
+	{"persistent",				no_argument,		NULL,	'n'},
 	{"dv-timings",				no_argument,		NULL,	't'},
 	{"buffers",					required_argument,	NULL,	'b'},
 	{"workers",					required_argument,	NULL,	'w'},
 	{"quality",					required_argument,	NULL,	'q'},
 	{"encoder",					required_argument,	NULL,	'c'},
-#	ifdef OMX_ENCODER
-	{"encoder-omx-use-ijg",		required_argument,	NULL,	500},
+#	ifdef WITH_OMX
+	{"glitched-resolutions",	required_argument,	NULL,	'g'},
 #	endif
 	{"device-timeout",			required_argument,	NULL,	1000},
-	{"device-persistent",		no_argument,		NULL,	1001},
-	{"device-error-delay",		required_argument,	NULL,	1002},
+	{"device-error-delay",		required_argument,	NULL,	1001},
+
+	{"brightness",				required_argument,	NULL,	2000},
+	{"brightness-auto",			no_argument,		NULL,	2001},
+	{"contrast",				required_argument,	NULL,	2002},
+	{"saturation",				required_argument,	NULL,	2003},
+	{"hue",						required_argument,	NULL,	2004},
+	{"hue-auto",				no_argument,		NULL,	2005},
+	{"gamma",					required_argument,	NULL,	2006},
+	{"sharpness",				required_argument,	NULL,	2007},
+	{"backlight-compensation",	required_argument,	NULL,	2008},
+	{"white-balance",			required_argument,	NULL,	2009},
+	{"white-balance-auto",		no_argument,		NULL,	2010},
+	{"gain",					required_argument,	NULL,	2011},
+	{"gain-auto",				no_argument,		NULL,	2012},
 
 	{"host",					required_argument,	NULL,	's'},
 	{"port",					required_argument,	NULL,	'p'},
-	{"drop-same-frames",		required_argument,	NULL,	'r'},
-	{"fake-width",				required_argument,	NULL,	2001},
-	{"fake-height",				required_argument,	NULL,	2002},
-	{"server-timeout",			required_argument,	NULL,	2003},
+	{"unix",					required_argument,	NULL,	'U'},
+	{"unix-rm",					no_argument,		NULL,	'D'},
+	{"unix-mode",				required_argument,	NULL,	'M'},
+	{"user",					required_argument,	NULL,	3000},
+	{"passwd",					required_argument,	NULL,	3001},
+	{"static",					required_argument,	NULL,	3002},
+	{"blank",					required_argument,	NULL,	'k'},
+	{"drop-same-frames",		required_argument,	NULL,	'e'},
+	{"slowdown",				no_argument,		NULL,	'l'},
+	{"fake-resolution",			required_argument,	NULL,	'R'},
+	{"fake-width",				required_argument,	NULL,	3003},
+	{"fake-height",				required_argument,	NULL,	3004},
+	{"server-timeout",			required_argument,	NULL,	3005},
+
+#ifdef WITH_GPIO
+	{"gpio-prog-running",		required_argument,	NULL,	4000},
+	{"gpio-stream-online",		required_argument,	NULL,	4001},
+	{"gpio-has-http-clients",	required_argument,	NULL,	4002},
+	{"gpio-workers-busy-at",	required_argument,	NULL,	4003},
+#endif
 
 	{"perf",					no_argument,		NULL,	5000},
 	{"verbose",					no_argument,		NULL,	5001},
 	{"debug",					no_argument,		NULL,	5002},
 	{"log-level",				required_argument,	NULL,	5010},
 	{"help",					no_argument,		NULL,	'h'},
-	{"version",					no_argument,		NULL,	6000},
+	{"version",					no_argument,		NULL,	'v'},
 	{NULL, 0, NULL, 0},
 };
 
 static void _version(bool nl) {
 	printf(VERSION);
-#	ifdef OMX_ENCODER
+#	ifdef WITH_OMX
 	printf(" + OMX");
+#	endif
+#	ifdef WITH_GPIO
+	printf(" + GPIO");
 #	endif
 	if (nl) {
 		putchar('\n');
@@ -91,130 +134,324 @@ static void _version(bool nl) {
 
 static void _help(struct device_t *dev, struct encoder_t *encoder, struct http_server_t *server) {
 	printf("\nuStreamer - Lightweight and fast MJPG-HTTP streamer\n");
-	printf("===================================================\n\n");
+	printf("═══════════════════════════════════════════════════\n\n");
 	printf("Version: ");
 	_version(false);
 	printf("; license: GPLv3\n");
 	printf("Copyright (C) 2018 Maxim Devaev <mdevaev@gmail.com>\n\n");
 	printf("Capturing options:\n");
-	printf("------------------\n");
-	printf("    -d|--device </dev/path>          -- Path to V4L2 device. Default: %s.\n\n", dev->path);
-	printf("    -i|--input <N>                   -- Input channel. Default: %u.\n\n", dev->input);
-	printf("    -x|--width <N>                   -- Initial image width. Default: %d.\n\n", dev->width);
-	printf("    -y|--height <N>                  -- Initial image height. Default: %d.\n\n", dev->height);
-	printf("    -f|--format <fmt>                -- Image format.\n");
-	printf("                                        Available: %s; default: YUYV.\n\n", FORMATS_STR);
-	printf("    -a|--tv-standard <std>           -- Force TV standard.\n");
-	printf("                                        Available: %s; default: disabled.\n\n", STANDARDS_STR);
-	printf("    -m|--soft-fps <N>                -- Soft FPS limit; default: %u.\n\n", dev->soft_fps);
-	printf("    -e|--every-frame <N>             -- Drop all input frames except specified. Default: disabled.\n\n");
-	printf("    -z|--min-frame-size <N>          -- Drop frames smaller then this limit.\n");
-	printf("                                        Useful if the device produces small-sized garbage frames.\n\n");
-	printf("    -t|--dv-timings                  -- Enable DV timings queriyng and events processing.\n");
-	printf("                                        Supports automatic resolution changing. Default: disabled.\n\n");
-	printf("    -b|--buffers <N>                 -- The number of buffers to receive data from the device.\n");
-	printf("                                        Each buffer may processed using an intermediate thread.\n");
-	printf("                                        Default: %d (number of CPU cores + 1)\n\n", dev->n_buffers);
-	printf("    -w|--workers <N>                 -- The number of compressing threads. Default: %d (== --buffers).\n\n", dev->n_workers);
-	printf("    -q|--quality <N>                 -- Set quality of JPEG encoding from 1 to 100 (best). Default: %d.\n\n", encoder->quality);
-	printf("    --encoder <type>                 -- Use specified encoder. It may affects to workers number.\n");
-	printf("                                     -- Available: %s; default: CPU.\n\n", ENCODER_TYPES_STR);
-#	ifdef OMX_ENCODER
-	printf("    --encoder-omx-use-ijg            -- Use the standard IJG quality tables when encoding images using OMX.\n");
-	printf("                                        Default: disabled.\n\n");
+	printf("══════════════════\n");
+	printf("    -d|--device </dev/path>  ───────────── Path to V4L2 device. Default: %s.\n\n", dev->path);
+	printf("    -i|--input <N>  ────────────────────── Input channel. Default: %u.\n\n", dev->input);
+	printf("    -r|--resolution <WxH>  ─────────────── Initial image resolution. Default: %ux%u.\n\n", dev->width, dev->height);
+	printf("    -m|--format <fmt>  ─────────────────── Image format.\n");
+	printf("                                           Available: %s; default: YUYV.\n\n", FORMATS_STR);
+	printf("    -a|--tv-standard <std>  ────────────── Force TV standard.\n");
+	printf("                                           Available: %s; default: disabled.\n\n", STANDARDS_STR);
+	printf("    -f|--desired-fps <N>  ──────────────── Desired FPS. Default: maximum possible.\n\n");
+	printf("    -z|--min-frame-size <N>  ───────────── Drop frames smaller then this limit. Useful if the device\n");
+	printf("                                           produces small-sized garbage frames. Default: disabled.\n\n");
+	printf("    -n|--persistent  ───────────────────── Don't re-initialize device on timeout. Default: disabled.\n\n");
+	printf("    -t|--dv-timings  ───────────────────── Enable DV timings querying and events processing\n");
+	printf("                                           to automatic resolution change. Default: disabled.\n\n");
+	printf("    -b|--buffers <N>  ──────────────────── The number of buffers to receive data from the device.\n");
+	printf("                                           Each buffer may processed using an independent thread.\n");
+	printf("                                           Default: %u (the number of CPU cores (but not more than 4) + 1).\n\n", dev->n_buffers);
+	printf("    -w|--workers <N>  ──────────────────── The number of worker threads but not more than buffers.\n");
+	printf("                                           Default: %u (the number of CPU cores (but not more than 4)).\n\n", dev->n_workers);
+	printf("    -q|--quality <N>  ──────────────────── Set quality of JPEG encoding from 1 to 100 (best). Default: %u.\n\n", encoder->quality);
+	printf("    -c|--encoder <type>  ───────────────── Use specified encoder. It may affect the number of workers.\n\n");
+#	ifdef WITH_OMX
+	printf("    -g|--glitched-resolutions <WxH,...>  ─ Comma-separated list of resolutions that require forced\n");
 #	endif
-	printf("    --device-timeout <seconds>       -- Timeout for device querying. Default: %d\n\n", dev->timeout);
-	printf("    --device-persistent              -- Don't re-initialize device on timeout. Default: disabled.\n\n");
-	printf("    --device-error-delay <seconds>   -- Delay before trying to connect to the device again\n");
-	printf("                                        after a timeout. Default: %d\n\n", dev->error_delay);
+	printf("                                           encoding on CPU instead of OMX. Default: disabled.\n");
+	printf("                                           Available: %s; default: CPU.\n\n", ENCODER_TYPES_STR);
+	printf("    --device-timeout <seconds>  ────────── Timeout for device querying. Default: %u.\n\n", dev->timeout);
+	printf("    --device-error-delay <seconds>  ────── Delay before trying to connect to the device again\n");
+	printf("                                           after an error (timeout for example). Default: %u.\n\n", dev->error_delay);
+	printf("Image control options:\n");
+	printf("══════════════════════\n");
+	printf("    --brightness <N>  ───────────── Set brightness. Default: no change.\n\n");
+	printf("    --brightness-auto  ──────────── Enable automatic brightness control. Default: no change.\n\n");
+	printf("    --contrast <N>  ─────────────── Set contrast. Default: no change.\n\n");
+	printf("    --saturation <N>  ───────────── Set saturation. Default: no change.\n\n");
+	printf("    --hue <N>  ──────────────────── Set hue. Default: no change.\n\n");
+	printf("    --hue-auto  ─────────────────── Enable automatic hue control. Default: no change.\n\n");
+	printf("    --gamma <N>  ────────────────── Set gamma. Default: no change.\n\n");
+	printf("    --sharpness <N>  ────────────── Set sharpness. Default: no change.\n\n");
+	printf("    --backlight-compensation <N>  ─ Set backlight compensation. Default: no change.\n\n");
+	printf("    --white-balance <N>  ────────── Set white balance. Default: no change.\n\n");
+	printf("    --white-balance-auto  ───────── Enable automatic white balance control. Default: no change.\n\n");
+	printf("    --gain <N>  ─────────────────── Set gain. Default: no change.\n\n");
+	printf("    --gain-auto  ────────────────── Enable automatic gain control. Default: no change.\n\n");
 	printf("HTTP server options:\n");
-	printf("--------------------\n");
-	printf("    --host <address>           -- Listen on Hostname or IP. Default: %s\n\n", server->host);
-	printf("    --port <N>                 -- Bind to this TCP port. Default: %d\n\n", server->port);
-	printf("    --drop-same-frames <N>     -- Don't send same frames to clients, but no more than specified number.\n");
+	printf("════════════════════\n");
+	printf("    -s|--host <address>  ──────── Listen on Hostname or IP. Default: %s.\n\n", server->host);
+	printf("    -p|--port <N>  ────────────── Bind to this TCP port. Default: %u.\n\n", server->port);
+	printf("    -U|--unix <path>  ─────────── Bind to UNIX domain socket. Default: disabled.\n\n");
+	printf("    -D|--unix-rm  ─────────────── Try to remove old UNIX socket file before binding. Default: disabled.\n\n");
+	printf("    -M|--unix-mode <mode>  ────── Set UNIX socket file permissions (like 777). Default: disabled.\n\n");
+	printf("    --user <name>  ────────────── HTTP basic auth user. Default: disabled.\n\n");
+	printf("    --passwd <str>  ───────────── HTTP basic auth passwd. Default: empty.\n\n");
+	printf("    --static <path> ───────────── Path to dir with static files instead of embedded root index page.\n");
+	printf("                                  Symlinks are not supported for security reasons. Default: disabled.\n\n");
+	printf("    -k|--blank <path> ─────────── Path to JPEG file that will be shown when the device is disconnected\n");
+	printf("                                  during the streaming. Default: black screen 640x480 with 'NO SIGNAL'.\n\n");
+	printf("    -e|--drop-same-frames <N>  ── Don't send identical frames to clients, but no more than specified number.\n");
 	printf("                                  It can significantly reduce the outgoing traffic, but will increase\n");
 	printf("                                  the CPU loading. Don't use this option with analog signal sources\n");
 	printf("                                  or webcams, it's useless. Default: disabled.\n\n");
-	printf("    --fake-width <N>           -- Override image width for /ping. Default: disabled\n\n");
-	printf("    --fake-height <N>          -- Override image height for /ping. Default: disabled.\n\n");
-	printf("    --server-timeout <seconds> -- Timeout for client connections. Default: %d\n\n", server->timeout);
+	printf("    -l|--slowdown  ────────────── Slowdown capturing to 1 FPS or less when no stream clients are connected.\n");
+	printf("                                  Useful to reduce CPU consumption. Default: disabled.\n\n");
+	printf("    -R|--fake-resolution <WxH>  ─ Override image resolution for state. Default: disabled.\n\n");
+	printf("    --server-timeout <seconds>  ─ Timeout for client connections. Default: %u.\n\n", server->timeout);
+#ifdef WITH_GPIO
+	printf("GPIO options:\n");
+	printf("═════════════\n");
+	printf("    --gpio-prog-running <pin>  ───── Set 1 on GPIO pin while uStreamer is running. Default: disabled.\n\n");
+	printf("    --gpio-stream-online <pin>  ──── Set 1 while streaming. Default: disabled\n\n");
+	printf("    --gpio-has-http-clients <pin>  ─ Set 1 while stream has at least one client. Default: disabled.\n\n");
+	printf("    --gpio-workers-busy-at <pin>  ── Set 1 on (pin + N) while worker with number N has a job.\n");
+	printf("                                     The worker's numbering starts from 0. Default: disabled\n\n");
+#endif
 	printf("Misc options:\n");
-	printf("-------------\n");
-	printf("    --log-level <N> -- Verbosity level of messages from 0 (info) to 3 (debug).\n");
+	printf("═════════════\n");
+	printf("    --log-level <N>  ─ Verbosity level of messages from 0 (info) to 3 (debug).\n");
 	printf("                       Enabling debugging messages can slow down the program.\n");
-	printf("                       Available levels: 0=info, 1=performance, 2=verbose, 3=debug.\n");
-	printf("                       Default: %d.\n\n", log_level);
-	printf("    --perf          -- Enable performance messages (same as log-level=1). Default: disabled.\n\n");
-	printf("    --verbose       -- Enable verbose messages and lower (same as log-level=2). Default: disabled.\n\n");
-	printf("    --debug         -- Enable debug messages and lower (same as --log-level=3). Default: disabled.\n\n");
-	printf("    -h|--help       -- Print this messages and exit.\n\n");
+	printf("                       Available levels: 0 (info), 1 (performance), 2 (verbose), 3 (debug).\n");
+	printf("                       Default: %u.\n\n", log_level);
+	printf("    --perf  ────────── Enable performance messages (same as --log-level=1). Default: disabled.\n\n");
+	printf("    --verbose  ─────── Enable verbose messages and lower (same as --log-level=2). Default: disabled.\n\n");
+	printf("    --debug  ───────── Enable debug messages and lower (same as --log-level=3). Default: disabled.\n\n");
+	printf("    -h|--help  ─────── Print this text and exit.\n\n");
+	printf("    -v|--version  ──── Print version and exit.\n\n");
 }
 
+static int _parse_resolution(const char *str, unsigned *width, unsigned *height, bool limited) {
+	unsigned tmp_width;
+	unsigned tmp_height;
+
+	if (sscanf(str, "%ux%u", &tmp_width, &tmp_height) != 2) {
+		return -1;
+	}
+	if (limited) {
+		if (tmp_width < VIDEO_MIN_WIDTH || tmp_width > VIDEO_MAX_WIDTH) {
+			return -2;
+		}
+		if (tmp_height < VIDEO_MIN_HEIGHT || tmp_height > VIDEO_MAX_HEIGHT) {
+			return -3;
+		}
+	}
+	*width = tmp_width;
+	*height = tmp_height;
+	return 0;
+}
+
+#ifdef WITH_OMX
+static int _parse_glitched_resolutions(const char *str, struct encoder_t *encoder) {
+	char *str_copy;
+	char *ptr;
+	unsigned count = 0;
+	unsigned width;
+	unsigned height;
+
+	assert((str_copy = strdup(str)) != NULL);
+
+	ptr = strtok(str_copy, ",;:\n\t ");
+	while (ptr != NULL) {
+		if (count >= MAX_GLITCHED_RESOLUTIONS) {
+			printf("Too big '--glitched-resolutions' list: maxlen=%u\n", MAX_GLITCHED_RESOLUTIONS);
+			goto error;
+		}
+
+		switch (_parse_resolution(ptr, &width, &height, true)) {
+			case -1:
+				printf("Invalid resolution format of '%s' in '--glitched-resolutions=%s\n", ptr, str_copy);
+				goto error;
+			case -2:
+				printf("Invalid width of '%s' in '--glitched-resolutions=%s: min=%u, max=%u\n",
+					ptr, str_copy, VIDEO_MIN_WIDTH, VIDEO_MIN_HEIGHT);
+				goto error;
+			case -3:
+				printf("Invalid width of '%s' in '--glitched-resolutions=%s: min=%u, max=%u\n",
+					ptr, str_copy, VIDEO_MIN_WIDTH, VIDEO_MIN_HEIGHT);
+				goto error;
+			case 0: break;
+			default: assert(0 && "Unknown error");
+		}
+
+		encoder->glitched_resolutions[count][0] = width;
+		encoder->glitched_resolutions[count][1] = height;
+		count += 1;
+
+		ptr = strtok(NULL, ",;:\n\t ");
+	}
+
+	encoder->n_glitched_resolutions = count;
+	free(str_copy);
+	return 0;
+
+	error:
+		free(str_copy);
+		return -1;
+}
+#endif
+
 static int _parse_options(int argc, char *argv[], struct device_t *dev, struct encoder_t *encoder, struct http_server_t *server) {
-#	define OPT_SET(_dest, _value) \
-		{ _dest = _value; break; }
+#	define OPT_SET(_dest, _value) { \
+			_dest = _value; \
+			break; \
+		}
 
-#	define OPT_UNSIGNED(_dest, _name, _min, _max) \
-		{ errno = 0; int _tmp = strtol(optarg, NULL, 0); \
-		if (errno || _tmp < _min || _tmp > _max) \
-		{ printf("Invalid value for '%s=%u'; min=%u; max=%u\n", _name, _tmp, _min, _max); return -1; } \
-		_dest = _tmp; break; }
+#	define OPT_NUMBER(_name, _dest, _min, _max, _base) { \
+			errno = 0; char *_end = NULL; long long _tmp = strtoll(optarg, &_end, _base); \
+			if (errno || *_end || _tmp < _min || _tmp > _max) { \
+				printf("Invalid value for '%s=%s': min=%u, max=%u\n", _name, optarg, _min, _max); \
+				return -1; \
+			} \
+			_dest = _tmp; \
+			break; \
+		}
 
-#	define OPT_PARSE(_dest, _func, _invalid, _name) \
-		{ if ((_dest = _func(optarg)) == _invalid) \
-		{ printf("Unknown " _name ": %s\n", optarg); return -1; } \
-		break; }
+#	define OPT_RESOLUTION(_name, _dest_width, _dest_height, _limited) { \
+			switch (_parse_resolution(optarg, &_dest_width, &_dest_height, _limited)) { \
+				case -1: \
+					printf("Invalid resolution format for '%s=%s'\n", _name, optarg); \
+					return -1; \
+				case -2: \
+					printf("Invalid width of '%s=%s': min=%u, max=%u\n", _name, optarg, VIDEO_MIN_WIDTH, VIDEO_MAX_WIDTH); \
+					return -1; \
+				case -3: \
+					printf("Invalid height of '%s=%s': min=%u, max=%u\n", _name, optarg, VIDEO_MIN_HEIGHT, VIDEO_MAX_HEIGHT); \
+					return -1; \
+				case 0: break; \
+				default: assert(0 && "Unknown error"); \
+			} \
+			break; \
+		}
+
+#	define OPT_RESOLUTION_OBSOLETE(_name, _replace, _dest, _min, _max) { \
+			printf("\n=== WARNING! The option '%s' is obsolete; use '%s' instead it ===\n\n", _name, _replace); \
+			OPT_NUMBER(_name, _dest, _min, _max, 0); \
+		}
+
+#	ifdef WITH_OMX
+#		define OPT_GLITCHED_RESOLUTIONS { \
+				if (_parse_glitched_resolutions(optarg, encoder) < 0) { \
+					return -1; \
+				} \
+				break; \
+			}
+#	endif
+
+#	define OPT_PARSE(_name, _dest, _func, _invalid) { \
+			if ((_dest = _func(optarg)) == _invalid) { \
+				printf("Unknown " _name ": %s\n", optarg); \
+				return -1; \
+			} \
+			break; \
+		}
+
+#	define OPT_CTL(_dest) { \
+			dev->ctl._dest.value_set = true; \
+			dev->ctl._dest.auto_set = false; \
+			OPT_NUMBER("--"#_dest, dev->ctl._dest.value, INT_MIN, INT_MAX, 0); \
+			break; \
+		}
+
+#	define OPT_CTL_AUTO(_dest) { \
+			dev->ctl._dest.value_set = false; \
+			dev->ctl._dest.auto_set = true; \
+			break; \
+		}
 
 	int index;
 	int ch;
 
 	log_level = LOG_LEVEL_INFO;
-	while ((ch = getopt_long(argc, argv, _short_opts, _long_opts, &index)) >= 0) {
+	while ((ch = getopt_long(argc, argv, _SHORT_OPTS, _LONG_OPTS, &index)) >= 0) {
 		switch (ch) {
 			case 'd':	OPT_SET(dev->path, optarg);
-			case 'i':	OPT_UNSIGNED(dev->input, "--input", 0, 128);
-			case 'x':	OPT_UNSIGNED(dev->width, "--width", 320, 1920);
-			case 'y':	OPT_UNSIGNED(dev->height, "--height", 180, 1200);
+			case 'i':	OPT_NUMBER("--input", dev->input, 0, 128, 0);
+			case 'r':	OPT_RESOLUTION("--resolution", dev->width, dev->height, true);
+			case 'x':	OPT_RESOLUTION_OBSOLETE("--width", "--resolution", dev->width, VIDEO_MIN_WIDTH, VIDEO_MAX_WIDTH);
+			case 'y':	OPT_RESOLUTION_OBSOLETE("--height", "--resolution", dev->height, VIDEO_MIN_HEIGHT, VIDEO_MAX_HEIGHT);
 #			pragma GCC diagnostic ignored "-Wsign-compare"
 #			pragma GCC diagnostic push
-			case 'f':	OPT_PARSE(dev->format, device_parse_format, FORMAT_UNKNOWN, "pixel format");
+			case 'm':	OPT_PARSE("pixel format", dev->format, device_parse_format, FORMAT_UNKNOWN);
 #			pragma GCC diagnostic pop
-			case 'a':	OPT_PARSE(dev->standard, device_parse_standard, STANDARD_UNKNOWN, "TV standard");
-			case 'm':	OPT_UNSIGNED(dev->soft_fps, "--soft-fps", 1, 30);
-			case 'e':	OPT_UNSIGNED(dev->every_frame, "--every-frame", 1, 30);
-			case 'z':	OPT_UNSIGNED(dev->min_frame_size, "--min-frame-size", 0, 8192);
+			case 'a':	OPT_PARSE("TV standard", dev->standard, device_parse_standard, STANDARD_UNKNOWN);
+			case 'f':	OPT_NUMBER("--desired-fps", dev->desired_fps, 0, VIDEO_MAX_FPS, 0);
+			case 'z':	OPT_NUMBER("--min-frame-size", dev->min_frame_size, 0, 8192, 0);
+			case 'n':	OPT_SET(dev->persistent, true);
 			case 't':	OPT_SET(dev->dv_timings, true);
-			case 'b':	OPT_UNSIGNED(dev->n_buffers, "--buffers", 1, 32);
-			case 'w':	OPT_UNSIGNED(dev->n_workers, "--workers", 1, 32);
-			case 'q':	OPT_UNSIGNED(encoder->quality, "--quality", 1, 100);
-			case 'c':	OPT_PARSE(encoder->type, encoder_parse_type, ENCODER_TYPE_UNKNOWN, "encoder type");
-#			ifdef OMX_ENCODER
-			case 500:	OPT_SET(encoder->omx_use_ijg, true);
+			case 'b':	OPT_NUMBER("--buffers", dev->n_buffers, 1, 32, 0);
+			case 'w':	OPT_NUMBER("--workers", dev->n_workers, 1, 32, 0);
+			case 'q':	OPT_NUMBER("--quality", encoder->quality, 1, 100, 0);
+			case 'c':	OPT_PARSE("encoder type", encoder->type, encoder_parse_type, ENCODER_TYPE_UNKNOWN);
+#			ifdef WITH_OMX
+			case 'g':	OPT_GLITCHED_RESOLUTIONS;
 #			endif
-			case 1000:	OPT_UNSIGNED(dev->timeout, "--device-timeout", 1, 60);
-			case 1001:	OPT_SET(dev->persistent, true);
-			case 1002:	OPT_UNSIGNED(dev->error_delay, "--device-error-delay", 1, 60);
+			case 1000:	OPT_NUMBER("--device-timeout", dev->timeout, 1, 60, 0);
+			case 1001:	OPT_NUMBER("--device-error-delay", dev->error_delay, 1, 60, 0);
+
+			case 2000:	OPT_CTL(brightness);
+			case 2001:	OPT_CTL_AUTO(brightness);
+			case 2002:	OPT_CTL(contrast);
+			case 2003:	OPT_CTL(saturation);
+			case 2004:	OPT_CTL(hue);
+			case 2005:	OPT_CTL_AUTO(hue);
+			case 2006:	OPT_CTL(gamma);
+			case 2007:	OPT_CTL(sharpness);
+			case 2008:	OPT_CTL(backlight_compensation);
+			case 2009:	OPT_CTL(white_balance);
+			case 2010:	OPT_CTL_AUTO(white_balance);
+			case 2011:	OPT_CTL(gain);
+			case 2012:	OPT_CTL_AUTO(gain);
 
 			case 's':	OPT_SET(server->host, optarg);
-			case 'p':	OPT_UNSIGNED(server->port, "--port", 1, 65535);
-			case 'r':	OPT_UNSIGNED(server->drop_same_frames, "--drop-same-frames", 0, 30);
-			case 2001:	OPT_UNSIGNED(server->fake_width, "--fake-width", 0, 1920);
-			case 2002:	OPT_UNSIGNED(server->fake_height, "--fake-height", 0, 1200);
-			case 2003:	OPT_UNSIGNED(server->timeout, "--server-timeout", 1, 60);
+			case 'p':	OPT_NUMBER("--port", server->port, 1, 65535, 0);
+			case 'U':	OPT_SET(server->unix_path, optarg);
+			case 'D':	OPT_SET(server->unix_rm, true);
+			case 'M':	OPT_NUMBER("--unix-mode", server->unix_mode, INT_MIN, INT_MAX, 8);
+			case 3000:	OPT_SET(server->user, optarg);
+			case 3001:	OPT_SET(server->passwd, optarg);
+			case 3002:	OPT_SET(server->static_path, optarg);
+			case 'k':	OPT_SET(server->blank_path, optarg);
+			case 'e':	OPT_NUMBER("--drop-same-frames", server->drop_same_frames, 0, VIDEO_MAX_FPS, 0);
+			case 'l':	OPT_SET(server->slowdown, true);
+			case 'R':	OPT_RESOLUTION("--fake-resolution", server->fake_width, server->fake_height, false);
+			case 3003:	OPT_RESOLUTION_OBSOLETE("--fake-width", "--fake-resolution", server->fake_width, 0, UINT_MAX);
+			case 3004:	OPT_RESOLUTION_OBSOLETE("--fake-height", "--fake-resolution", server->fake_height, 0, UINT_MAX);
+			case 3005:	OPT_NUMBER("--server-timeout", server->timeout, 1, 60, 0);
+
+#			ifdef WITH_GPIO
+			case 4000:	OPT_NUMBER("--gpio-prog-running", gpio_pin_prog_running, 0, 256, 0);
+			case 4001:	OPT_NUMBER("--gpio-stream-online", gpio_pin_stream_online, 0, 256, 0);
+			case 4002:	OPT_NUMBER("--gpio-has-http-clients", gpio_pin_has_http_clients, 0, 256, 0);
+			case 4003:	OPT_NUMBER("--gpio-workers-busy-at", gpio_pin_workers_busy_at, 0, 256, 0);
+#			endif
 
 			case 5000:	OPT_SET(log_level, LOG_LEVEL_PERF);
 			case 5001:	OPT_SET(log_level, LOG_LEVEL_VERBOSE);
 			case 5002:	OPT_SET(log_level, LOG_LEVEL_DEBUG);
-			case 5010:	OPT_UNSIGNED(log_level, "--log-level", 0, 3);
+			case 5010:	OPT_NUMBER("--log-level", log_level, 0, 3, 0);
 			case 'h':	_help(dev, encoder, server); return 1;
-			case 6000:	_version(true); return 1;
+			case 'v':	_version(true); return 1;
 			case 0:		break;
 			default:	_help(dev, encoder, server); return -1;
 		}
 	}
 
+#	undef OPT_CTL_AUTO
+#	undef OPT_CTL
 #	undef OPT_PARSE
-#	undef OPT_UNSIGNED
+#	ifdef WITH_OMX
+#		undef OPT_GLITCHED_RESOLUTIONS
+#	endif
+#	undef OPT_RESOLUTION_OBSOLETE
+#	undef OPT_RESOLUTION
+#	undef OPT_NUMBER
 #	undef OPT_SET
 	return 0;
 }
@@ -226,7 +463,7 @@ struct main_context_t {
 
 static struct main_context_t *_ctx;
 
-static void _block_thread_signals() {
+static void _block_thread_signals(void) {
 	sigset_t mask;
 	assert(!sigemptyset(&mask));
 	assert(!sigaddset(&mask, SIGINT));
@@ -252,7 +489,7 @@ static void _signal_handler(int signum) {
 	http_server_loop_break(_ctx->server);
 }
 
-static void _install_signal_handlers() {
+static void _install_signal_handlers(void) {
 	struct sigaction sig_act;
 
 	MEMSET_ZERO(sig_act);
@@ -280,14 +517,21 @@ int main(int argc, char *argv[]) {
 
 	LOGGING_INIT;
 
+#	ifdef WITH_GPIO
+	GPIO_INIT;
+#	endif
+
 	dev = device_init();
 	encoder = encoder_init();
 	stream = stream_init(dev, encoder);
 	server = http_server_init(stream);
 
 	if ((exit_code = _parse_options(argc, argv, dev, encoder, server)) == 0) {
+#		ifdef WITH_GPIO
+		GPIO_INIT_PINOUT;
+#		endif
+
 		_install_signal_handlers();
-		encoder_prepare(encoder, dev);
 
 		pthread_t stream_loop_tid;
 		pthread_t server_loop_tid;
@@ -298,10 +542,14 @@ int main(int argc, char *argv[]) {
 		_ctx = &ctx;
 
 		if ((exit_code = http_server_listen(server)) == 0) {
-			A_PTHREAD_CREATE(&stream_loop_tid, _stream_loop_thread, NULL);
-			A_PTHREAD_CREATE(&server_loop_tid, _server_loop_thread, NULL);
-			A_PTHREAD_JOIN(stream_loop_tid);
-			A_PTHREAD_JOIN(server_loop_tid);
+#			ifdef WITH_GPIO
+			GPIO_SET_HIGH(prog_running);
+#			endif
+
+			A_THREAD_CREATE(&stream_loop_tid, _stream_loop_thread, NULL);
+			A_THREAD_CREATE(&server_loop_tid, _server_loop_thread, NULL);
+			A_THREAD_JOIN(server_loop_tid);
+			A_THREAD_JOIN(stream_loop_tid);
 		}
 	}
 
@@ -310,6 +558,10 @@ int main(int argc, char *argv[]) {
 	encoder_destroy(encoder);
 	device_destroy(dev);
 
+#	ifdef WITH_GPIO
+	GPIO_SET_LOW(prog_running);
+#	endif
+
 	LOGGING_DESTROY;
 	return (exit_code < 0 ? 1 : 0);
 }

src/stream.c

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
@@ -19,13 +20,17 @@
 *****************************************************************************/
 
 
+#include "stream.h"
+
+#include <stdbool.h>
+#include <stdatomic.h>
+#include <unistd.h>
 #include <errno.h>
 #include <time.h>
 #include <assert.h>
 
 #include <pthread.h>
 
-#include <sys/select.h>
 #include <linux/videodev2.h>
 
 #include "tools.h"
@@ -33,135 +38,161 @@
 #include "xioctl.h"
 #include "device.h"
 #include "encoder.h"
-#include "stream.h"
-
-#include "jpeg/encoder.h"
+#ifdef WITH_GPIO
+#	include "gpio.h"
+#endif
 
 
-static long double _stream_get_fluency_delay(struct device_t *dev, struct workers_pool_t *pool);
-static void _stream_expose_picture(struct stream_t *stream, unsigned buf_index);
+struct _worker_t {
+	pthread_t			tid;
+	unsigned			number;
+	atomic_bool			*proc_stop;
+	atomic_bool			*workers_stop;
 
-static int _stream_init_loop(struct device_t *dev, struct workers_pool_t *pool);
-static int _stream_init(struct device_t *dev, struct workers_pool_t *pool);
+	long double			last_comp_time;
 
-static void _stream_init_workers(struct device_t *dev, struct workers_pool_t *pool);
-static void *_stream_worker_thread(void *v_ctx);
-static void _stream_destroy_workers(struct device_t *dev, struct workers_pool_t *pool);
+	pthread_mutex_t		has_job_mutex;
+	int					buf_index;
+	atomic_bool			has_job;
+	bool				job_timely;
+	bool				job_failed;
+	long double			job_start_time;
+	pthread_cond_t		has_job_cond;
 
-static int _stream_control(struct device_t *dev, const bool enable);
-static int _stream_grab_buffer(struct device_t *dev, struct v4l2_buffer *buf_info);
-static int _stream_release_buffer(struct device_t *dev, struct v4l2_buffer *buf_info);
-static int _stream_handle_event(struct device_t *dev);
+	pthread_mutex_t		*free_workers_mutex;
+	unsigned			*free_workers;
+	pthread_cond_t		*free_workers_cond;
+
+	struct _worker_t	*order_prev;
+	struct _worker_t	*order_next;
+
+	struct device_t		*dev;
+	struct encoder_t	*encoder;
+};
+
+struct _workers_pool_t {
+	unsigned			n_workers;
+	struct _worker_t	*workers;
+	struct _worker_t	*oldest_worker;
+	struct _worker_t	*latest_worker;
+
+	long double			approx_comp_time;
+
+	pthread_mutex_t		free_workers_mutex;
+	unsigned			free_workers;
+	pthread_cond_t		free_workers_cond;
+
+	atomic_bool			workers_stop;
+
+	long double			desired_frames_interval;
+};
+
+
+static struct _workers_pool_t *_stream_init_loop(struct stream_t *stream);
+static struct _workers_pool_t *_stream_init(struct stream_t *stream);
+static void _stream_expose_picture(struct stream_t *stream, unsigned buf_index, unsigned captured_fps);
+
+static struct _workers_pool_t *_workers_pool_init(struct stream_t *stream);
+static void _workers_pool_destroy(struct _workers_pool_t *pool);
+
+static void *_worker_thread(void *v_worker);
+
+static struct _worker_t *_workers_pool_wait(struct _workers_pool_t *pool);
+static void _workers_pool_assign(struct _workers_pool_t *pool, struct _worker_t *ready_worker, unsigned buf_index);
+static long double _workers_pool_get_fluency_delay(struct _workers_pool_t *pool, struct _worker_t *ready_worker);
 
 
 struct stream_t *stream_init(struct device_t *dev, struct encoder_t *encoder) {
+	struct process_t *proc;
 	struct stream_t *stream;
 
+	A_CALLOC(proc, 1);
+	atomic_init(&proc->stop, false);
+	atomic_init(&proc->slowdown, false);
+
 	A_CALLOC(stream, 1);
 	stream->dev = dev;
 	stream->encoder = encoder;
-	A_PTHREAD_M_INIT(&stream->mutex);
+	atomic_init(&stream->updated, false);
+	A_MUTEX_INIT(&stream->mutex);
+	stream->proc = proc;
 	return stream;
 }
 
 void stream_destroy(struct stream_t *stream) {
-	A_PTHREAD_M_DESTROY(&stream->mutex);
+	A_MUTEX_DESTROY(&stream->mutex);
+	free(stream->proc);
 	free(stream);
 }
 
 void stream_loop(struct stream_t *stream) {
-	struct workers_pool_t pool;
-	bool workers_stop;
-
-	MEMSET_ZERO(pool);
-	pool.encoder = stream->encoder;
-	pool.workers_stop = &workers_stop;
+	struct _workers_pool_t *pool;
 
 	LOG_INFO("Using V4L2 device: %s", stream->dev->path);
+	LOG_INFO("Using desired FPS: %u", stream->dev->desired_fps);
 
-	while (_stream_init_loop(stream->dev, &pool) == 0) {
-		struct worker_t *oldest_worker = NULL;
-		struct worker_t *last_worker = NULL;
-		unsigned frames_count = 0;
+	while ((pool = _stream_init_loop(stream)) != NULL) {
 		long double grab_after = 0;
 		unsigned fluency_passed = 0;
+		unsigned captured_fps = 0;
 		unsigned captured_fps_accum = 0;
 		long long captured_fps_second = 0;
 		bool persistent_timeout_reported = false;
 
 		LOG_DEBUG("Allocation memory for stream picture ...");
-		A_CALLOC(stream->picture.data, stream->dev->run->max_picture_size);
+		A_CALLOC(stream->picture.data, stream->dev->run->max_raw_image_size);
 
 		LOG_INFO("Capturing ...");
 
-		while (!stream->dev->stop) {
-			int free_worker_number = -1;
+		while (!atomic_load(&stream->proc->stop)) {
+			struct _worker_t *ready_worker;
 
 			SEP_DEBUG('-');
+			LOG_DEBUG("Waiting for worker ...");
 
-			LOG_DEBUG("Waiting for workers ...");
-			A_PTHREAD_M_LOCK(&pool.free_workers_mutex);
-			A_PTHREAD_C_WAIT_TRUE(pool.free_workers, &pool.free_workers_cond, &pool.free_workers_mutex);
-			A_PTHREAD_M_UNLOCK(&pool.free_workers_mutex);
+			ready_worker = _workers_pool_wait(pool);
 
-			if (oldest_worker && !oldest_worker->has_job && oldest_worker->ctx.buf_index >= 0) {
-				if (oldest_worker->job_failed) {
-					break;
+			if (!ready_worker->job_failed) {
+				if (ready_worker->job_timely) {
+					_stream_expose_picture(stream, ready_worker->buf_index, captured_fps);
+					LOG_PERF("##### Encoded picture exposed; worker=%u", ready_worker->number);
+				} else {
+					LOG_PERF("----- Encoded picture dropped; worker=%u", ready_worker->number);
 				}
-
-				_stream_expose_picture(stream, oldest_worker->ctx.buf_index);
-
-				free_worker_number = oldest_worker->ctx.number;
-				oldest_worker = oldest_worker->order_next;
-
-				LOG_PERF("##### Raw frame accepted; worker = %u", free_worker_number);
 			} else {
-				for (unsigned number = 0; number < stream->dev->n_workers; ++number) {
-					if (!pool.workers[number].has_job && (free_worker_number == -1
-						|| pool.workers[free_worker_number].job_start_time < pool.workers[number].job_start_time
-					)) {
-						free_worker_number = number;
-						break;
-					}
-				}
-
-				assert(free_worker_number >= 0);
-				assert(!pool.workers[free_worker_number].has_job);
-
-				LOG_PERF("----- Raw frame dropped;  worker = %u", free_worker_number);
-			}
-
-			if (stream->dev->stop) {
 				break;
 			}
 
-#	define INIT_FD_SET(_set) \
-		fd_set _set; FD_ZERO(&_set); FD_SET(stream->dev->run->fd, &_set);
-			INIT_FD_SET(read_fds);
-			INIT_FD_SET(write_fds);
-			INIT_FD_SET(error_fds);
-#	undef INIT_FD_SET
+			if (atomic_load(&stream->proc->stop)) {
+				break;
+			}
 
-			struct timeval timeout;
-			timeout.tv_sec = stream->dev->timeout;
-			timeout.tv_usec = 0;
+			if (atomic_load(&stream->proc->slowdown)) {
+				usleep(1000000);
+			}
 
-			LOG_DEBUG("Calling select() on video device ...");
-			int retval = select(stream->dev->run->fd + 1, &read_fds, &write_fds, &error_fds, &timeout);
-			LOG_DEBUG("Device select() --> %d", retval);
+			bool has_read;
+			bool has_write;
+			bool has_error;
+			int selected = device_select(stream->dev, &has_read, &has_write, &has_error);
 
-			if (retval < 0) {
+			if (selected < 0) {
 				if (errno != EINTR) {
 					LOG_PERROR("Mainloop select() error");
 					break;
 				}
 
-			} else if (retval == 0) {
+			} else if (selected == 0) {
+#				ifdef WITH_GPIO
+				GPIO_SET_LOW(stream_online);
+#				endif
+
 				if (stream->dev->persistent) {
 					if (!persistent_timeout_reported) {
 						LOG_ERROR("Mainloop select() timeout, polling ...")
 						persistent_timeout_reported = true;
 					}
+
 					continue;
 				} else {
 					LOG_ERROR("Mainloop select() timeout");
@@ -171,395 +202,374 @@ void stream_loop(struct stream_t *stream) {
 			} else {
 				persistent_timeout_reported = false;
 
-				if (FD_ISSET(stream->dev->run->fd, &read_fds)) {
+				if (has_read) {
 					LOG_DEBUG("Frame is ready");
 
-					struct v4l2_buffer buf_info;
+#					ifdef WITH_GPIO
+					GPIO_SET_HIGH(stream_online);
+#					endif
+
+					int buf_index;
 					long double now = get_now_monotonic();
 					long long now_second = floor_ms(now);
 
-					if (_stream_grab_buffer(stream->dev, &buf_info) < 0) {
+					if ((buf_index = device_grab_buffer(stream->dev)) < 0) {
 						break;
 					}
-					stream->dev->run->pictures[buf_info.index].grab_time = now;
-
-					if (stream->dev->every_frame) {
-						if (frames_count < stream->dev->every_frame - 1) {
-							frames_count += 1;
-							LOG_DEBUG("Dropping frame %d for option --every-frame=%d", frames_count, stream->dev->every_frame);
-							goto pass_frame;
-						}
-						frames_count = 0;
-					}
 
 					// Workaround for broken, corrupted frames:
 					// Under low light conditions corrupted frames may get captured.
 					// The good thing is such frames are quite small compared to the regular pictures.
 					// For example a VGA (640x480) webcam picture is normally >= 8kByte large,
 					// corrupted frames are smaller.
-					if (buf_info.bytesused < stream->dev->min_frame_size) {
-						LOG_DEBUG("Dropping too small frame sized %d bytes, assuming it as broken", buf_info.bytesused);
+					if (stream->dev->run->hw_buffers[buf_index].used < stream->dev->min_frame_size) {
+						LOG_DEBUG("Dropped too small frame sized %zu bytes, assuming it was broken",
+							stream->dev->run->hw_buffers[buf_index].used);
 						goto pass_frame;
 					}
 
 					{
 						if (now < grab_after) {
 							fluency_passed += 1;
-							LOG_VERBOSE("Passed %u frames for fluency: now=%.03Lf; grab_after=%.03Lf", fluency_passed, now, grab_after);
+							LOG_VERBOSE("Passed %u frames for fluency: now=%.03Lf, grab_after=%.03Lf", fluency_passed, now, grab_after);
 							goto pass_frame;
 						}
 						fluency_passed = 0;
 
 						if (now_second != captured_fps_second) {
-							stream->captured_fps = captured_fps_accum;
+							captured_fps = captured_fps_accum;
 							captured_fps_accum = 0;
 							captured_fps_second = now_second;
-							LOG_PERF("Oldest worker complete, Captured-FPS = %u", stream->captured_fps);
+							LOG_PERF("A new second has come; captured_fps=%u", captured_fps);
 						}
 						captured_fps_accum += 1;
 
-						long double fluency_delay = _stream_get_fluency_delay(stream->dev, &pool);
+						long double fluency_delay = _workers_pool_get_fluency_delay(pool, ready_worker);
 
 						grab_after = now + fluency_delay;
-						LOG_VERBOSE("Fluency: delay=%.03Lf; grab_after=%.03Lf", fluency_delay, grab_after);
+						LOG_VERBOSE("Fluency: delay=%.03Lf, grab_after=%.03Lf", fluency_delay, grab_after);
 					}
 
-					LOG_DEBUG("Grabbed a new frame to buffer %d", buf_info.index);
-					pool.workers[free_worker_number].ctx.buf_info = buf_info;
-
-					if (!oldest_worker) {
-						oldest_worker = &pool.workers[free_worker_number];
-						last_worker = oldest_worker;
-					} else {
-						if (pool.workers[free_worker_number].order_next) {
-							pool.workers[free_worker_number].order_next->order_prev = pool.workers[free_worker_number].order_prev;
-						}
-						if (pool.workers[free_worker_number].order_prev) {
-							pool.workers[free_worker_number].order_prev->order_next = pool.workers[free_worker_number].order_next;
-						}
-						pool.workers[free_worker_number].order_prev = last_worker;
-						last_worker->order_next = &pool.workers[free_worker_number];
-						last_worker = &pool.workers[free_worker_number];
-					}
-					last_worker->order_next = NULL;
-
-					A_PTHREAD_M_LOCK(&pool.workers[free_worker_number].has_job_mutex);
-					pool.workers[free_worker_number].ctx.buf_index = buf_info.index;
-					pool.workers[free_worker_number].has_job = true;
-					A_PTHREAD_M_UNLOCK(&pool.workers[free_worker_number].has_job_mutex);
-					A_PTHREAD_C_SIGNAL(&pool.workers[free_worker_number].has_job_cond);
-
-					A_PTHREAD_M_LOCK(&pool.free_workers_mutex);
-					pool.free_workers -= 1;
-					A_PTHREAD_M_UNLOCK(&pool.free_workers_mutex);
+					_workers_pool_assign(pool, ready_worker, buf_index);
 
 					goto next_handlers; // Поток сам освободит буфер
 
 					pass_frame:
 
-					if (_stream_release_buffer(stream->dev, &buf_info) < 0) {
+					if (device_release_buffer(stream->dev, buf_index) < 0) {
 						break;
 					}
 				}
 
 				next_handlers:
 
-				if (FD_ISSET(stream->dev->run->fd, &write_fds)) {
+				if (has_write) {
 					LOG_ERROR("Got unexpected writing event, seems device was disconnected");
 					break;
 				}
 
-				if (FD_ISSET(stream->dev->run->fd, &error_fds)) {
+				if (has_error) {
 					LOG_INFO("Got V4L2 event");
-					if (_stream_handle_event(stream->dev) < 0) {
+					if (device_consume_event(stream->dev) < 0) {
 						break;
 					}
 				}
 			}
 		}
 
-		A_PTHREAD_M_LOCK(&stream->mutex);
-		stream->picture.size = 0; // On stream offline
+		A_MUTEX_LOCK(&stream->mutex);
+		stream->picture.used = 0; // On stream offline
 		free(stream->picture.data);
 		stream->width = 0;
 		stream->height = 0;
-		stream->updated = true;
-		A_PTHREAD_M_UNLOCK(&stream->mutex);
-	}
+		atomic_store(&stream->updated, true);
+		A_MUTEX_UNLOCK(&stream->mutex);
 
-	_stream_destroy_workers(stream->dev, &pool);
-	_stream_control(stream->dev, false);
-	device_close(stream->dev);
+		_workers_pool_destroy(pool);
+		device_switch_capturing(stream->dev, false);
+		device_close(stream->dev);
+
+#		ifdef WITH_GPIO
+		GPIO_SET_LOW(stream_online);
+#		endif
+	}
 }
 
 void stream_loop_break(struct stream_t *stream) {
-	stream->dev->stop = 1;
+	atomic_store(&stream->proc->stop, true);
 }
 
-static void _stream_expose_picture(struct stream_t *stream, unsigned buf_index) {
+void stream_switch_slowdown(struct stream_t *stream, bool slowdown) {
+	atomic_store(&stream->proc->slowdown, slowdown);
+}
+
+static struct _workers_pool_t *_stream_init_loop(struct stream_t *stream) {
+	struct _workers_pool_t *pool = NULL;
+
+	LOG_DEBUG("%s: stream->proc->stop=%d", __FUNCTION__, atomic_load(&stream->proc->stop));
+
+	while (!atomic_load(&stream->proc->stop)) {
+		SEP_INFO('=');
+
+		if ((pool = _stream_init(stream)) == NULL) {
+			LOG_INFO("Sleeping %u seconds before new stream init ...", stream->dev->error_delay);
+			sleep(stream->dev->error_delay);
+		} else {
+			break;
+		}
+	}
+	return pool;
+}
+
+static struct _workers_pool_t *_stream_init(struct stream_t *stream) {
+	if (device_open(stream->dev) < 0) {
+		goto error;
+	}
+	if (device_switch_capturing(stream->dev, true) < 0) {
+		goto error;
+	}
+
+	encoder_prepare(stream->encoder, stream->dev);
+	return _workers_pool_init(stream);
+
+	error:
+		device_close(stream->dev);
+		return NULL;
+}
+
+static void _stream_expose_picture(struct stream_t *stream, unsigned buf_index, unsigned captured_fps) {
 #	define PICTURE(_next) stream->dev->run->pictures[buf_index]._next
 
-	A_PTHREAD_M_LOCK(&stream->mutex);
+	A_MUTEX_LOCK(&stream->mutex);
 
-	stream->picture.size = PICTURE(size);
+	stream->picture.used = PICTURE(used);
 	stream->picture.allocated = PICTURE(allocated);
-	memcpy(
-		stream->picture.data, PICTURE(data),
-		stream->picture.size * sizeof(*stream->picture.data)
-	);
+
+	memcpy(stream->picture.data, PICTURE(data), stream->picture.used);
+
 	stream->picture.grab_time = PICTURE(grab_time);
 	stream->picture.encode_begin_time = PICTURE(encode_begin_time);
 	stream->picture.encode_end_time = PICTURE(encode_end_time);
 
 	stream->width = stream->dev->run->width;
 	stream->height = stream->dev->run->height;
-	stream->updated = true;
+	stream->captured_fps = captured_fps;
+	atomic_store(&stream->updated, true);
 
-	A_PTHREAD_M_UNLOCK(&stream->mutex);
+	A_MUTEX_UNLOCK(&stream->mutex);
 
 #	undef PICTURE
 }
 
-static long double _stream_get_fluency_delay(struct device_t *dev, struct workers_pool_t *pool) {
-	long double comp_time = 0;
-	long double min_delay;
-	long double soft_delay;
+static struct _workers_pool_t *_workers_pool_init(struct stream_t *stream) {
+	struct _workers_pool_t *pool;
 
-	for (unsigned number = 0; number < dev->n_workers; ++number) {
-		A_PTHREAD_M_LOCK(&pool->workers[number].last_comp_time_mutex);
-		if (pool->workers[number].last_comp_time > 0) {
-			comp_time += pool->workers[number].last_comp_time;
-		}
-		A_PTHREAD_M_UNLOCK(&pool->workers[number].last_comp_time_mutex);
-	}
-	comp_time = comp_time / dev->n_workers; // Среднее время работы воркеров
+	LOG_INFO("Creating pool with %u workers ...", stream->dev->run->n_workers);
 
-	min_delay = comp_time / dev->n_workers; // Минимальное время работы размазывается на N воркеров
-	soft_delay = ((long double)1) / dev->soft_fps; // Искусственное время задержки на основе желаемого FPS
+	A_CALLOC(pool, 1);
 
-	if (min_delay > 0) {
-		return (min_delay > soft_delay ? min_delay : soft_delay);
-	}
-	return min_delay;
-}
+	pool->n_workers = stream->dev->run->n_workers;
+	A_CALLOC(pool->workers, pool->n_workers);
 
-static int _stream_init_loop(struct device_t *dev, struct workers_pool_t *pool) {
-	int retval = -1;
+	A_MUTEX_INIT(&pool->free_workers_mutex);
+	A_COND_INIT(&pool->free_workers_cond);
 
-	LOG_DEBUG("%s: *dev->stop = %d", __FUNCTION__, dev->stop);
-	while (!dev->stop) {
-		if ((retval = _stream_init(dev, pool)) < 0) {
-			LOG_INFO("Sleeping %d seconds before new stream init ...", dev->error_delay);
-			sleep(dev->error_delay);
-		} else {
-			break;
-		}
-	}
-	return retval;
-}
+	atomic_init(&pool->workers_stop, false);
 
-static int _stream_init(struct device_t *dev, struct workers_pool_t *pool) {
-	SEP_INFO('=');
-
-	_stream_destroy_workers(dev, pool);
-	_stream_control(dev, false);
-	device_close(dev);
-
-	if (device_open(dev) < 0) {
-		goto error;
-	}
-	if (_stream_control(dev, true) < 0) {
-		goto error;
+	if (stream->dev->desired_fps > 0) {
+		pool->desired_frames_interval = (long double)1 / stream->dev->desired_fps;
 	}
 
-	encoder_prepare_live(pool->encoder, dev);
+	for (unsigned number = 0; number < pool->n_workers; ++number) {
+#		define WORKER(_next) pool->workers[number]._next
 
-	_stream_init_workers(dev, pool);
+		A_MUTEX_INIT(&WORKER(has_job_mutex));
+		atomic_init(&WORKER(has_job), false);
+		A_COND_INIT(&WORKER(has_job_cond));
 
-	return 0;
+		WORKER(number) = number;
+		WORKER(proc_stop) = &stream->proc->stop;
+		WORKER(workers_stop) = &pool->workers_stop;
 
-	error:
-		device_close(dev);
-		return -1;
-}
+		WORKER(free_workers_mutex) = &pool->free_workers_mutex;
+		WORKER(free_workers) = &pool->free_workers;
+		WORKER(free_workers_cond) = &pool->free_workers_cond;
 
-static void _stream_init_workers(struct device_t *dev, struct workers_pool_t *pool) {
-	LOG_INFO("Spawning %d workers ...", dev->n_workers);
+		WORKER(dev) = stream->dev;
+		WORKER(encoder) = stream->encoder;
 
-	*pool->workers_stop = false;
-	A_CALLOC(pool->workers, dev->n_workers);
+		A_THREAD_CREATE(&WORKER(tid), _worker_thread, (void *)&(pool->workers[number]));
 
-	A_PTHREAD_M_INIT(&pool->free_workers_mutex);
-	A_PTHREAD_C_INIT(&pool->free_workers_cond);
-
-	for (unsigned number = 0; number < dev->n_workers; ++number) {
 		pool->free_workers += 1;
 
-		A_PTHREAD_M_INIT(&pool->workers[number].has_job_mutex);
-		A_PTHREAD_C_INIT(&pool->workers[number].has_job_cond);
-
-#	define CTX(_next) pool->workers[number].ctx._next
-
-		CTX(number)			= number;
-		CTX(dev)			= dev;
-		CTX(dev_stop)		= (sig_atomic_t *volatile)&dev->stop;
-		CTX(workers_stop)	= pool->workers_stop;
-
-		CTX(encoder) = pool->encoder;
-
-		CTX(last_comp_time_mutex)	= &pool->workers[number].last_comp_time_mutex;
-		CTX(last_comp_time)			= &pool->workers[number].last_comp_time;
-
-		CTX(has_job_mutex)	= &pool->workers[number].has_job_mutex;
-		CTX(has_job)		= &pool->workers[number].has_job;
-		CTX(job_failed)		= &pool->workers[number].job_failed;
-		CTX(job_start_time)	= &pool->workers[number].job_start_time;
-		CTX(has_job_cond)	= &pool->workers[number].has_job_cond;
-
-		CTX(free_workers_mutex)	= &pool->free_workers_mutex;
-		CTX(free_workers)		= &pool->free_workers;
-		CTX(free_workers_cond)	= &pool->free_workers_cond;
-
-#	undef CTX
-
-		A_PTHREAD_CREATE(&pool->workers[number].tid, _stream_worker_thread, (void *)&pool->workers[number].ctx);
+#		undef WORKER
 	}
+	return pool;
 }
 
-static void *_stream_worker_thread(void *v_ctx) {
-	struct worker_context_t *ctx = (struct worker_context_t *)v_ctx;
+static void _workers_pool_destroy(struct _workers_pool_t *pool) {
+	LOG_INFO("Destroying workers pool ...");
 
-	LOG_DEBUG("Hello! I am a worker #%u ^_^", ctx->number);
+	atomic_store(&pool->workers_stop, true);
+	for (unsigned number = 0; number < pool->n_workers; ++number) {
+#		define WORKER(_next) pool->workers[number]._next
 
-	while (!*ctx->dev_stop && !*ctx->workers_stop) {
-		LOG_DEBUG("Worker %u waiting for a new job ...", ctx->number);
-		A_PTHREAD_M_LOCK(ctx->has_job_mutex);
-		A_PTHREAD_C_WAIT_TRUE(*ctx->has_job, ctx->has_job_cond, ctx->has_job_mutex);
-		A_PTHREAD_M_UNLOCK(ctx->has_job_mutex);
+		A_MUTEX_LOCK(&WORKER(has_job_mutex));
+		atomic_store(&WORKER(has_job), true); // Final job: die
+		A_MUTEX_UNLOCK(&WORKER(has_job_mutex));
+		A_COND_SIGNAL(&WORKER(has_job_cond));
 
-		if (!*ctx->workers_stop) {
-			LOG_DEBUG("Worker %u compressing JPEG from buffer %d ...", ctx->number, ctx->buf_index);
+		A_THREAD_JOIN(WORKER(tid));
+		A_MUTEX_DESTROY(&WORKER(has_job_mutex));
+		A_COND_DESTROY(&WORKER(has_job_cond));
 
-			if (encoder_compress_buffer(ctx->encoder, ctx->dev, ctx->number, ctx->buf_index) < 0) {
-				*ctx->job_failed = true;
-			}
-
-			if (_stream_release_buffer(ctx->dev, &ctx->buf_info) == 0) {
-				*ctx->job_start_time = ctx->dev->run->pictures[ctx->buf_index].encode_begin_time;
-				*ctx->has_job = false;
-
-				long double last_comp_time = ctx->dev->run->pictures[ctx->buf_index].encode_end_time - *ctx->job_start_time;
-
-				A_PTHREAD_M_LOCK(ctx->last_comp_time_mutex);
-				*ctx->last_comp_time = last_comp_time;
-				A_PTHREAD_M_UNLOCK(ctx->last_comp_time_mutex);
-
-				LOG_VERBOSE(
-					"Compressed JPEG size=%ld; time=%0.3Lf; worker=%u; buffer=%d",
-					ctx->dev->run->pictures[ctx->buf_index].size, last_comp_time, ctx->number, ctx->buf_index
-				);
-			} else {
-				*ctx->job_failed = true;
-				*ctx->has_job = false;
-			}
-		}
-
-		A_PTHREAD_M_LOCK(ctx->free_workers_mutex);
-		*ctx->free_workers += 1;
-		A_PTHREAD_M_UNLOCK(ctx->free_workers_mutex);
-		A_PTHREAD_C_SIGNAL(ctx->free_workers_cond);
+#		undef WORKER
 	}
 
-	LOG_DEBUG("Bye-bye (worker %d)", ctx->number);
+	A_MUTEX_DESTROY(&pool->free_workers_mutex);
+	A_COND_DESTROY(&pool->free_workers_cond);
+
+	free(pool->workers);
+	free(pool);
+}
+
+static void *_worker_thread(void *v_worker) {
+	struct _worker_t *worker = (struct _worker_t *)v_worker;
+
+	LOG_DEBUG("Hello! I am a worker #%u ^_^", worker->number);
+
+#	ifdef WITH_GPIO
+	GPIO_INIT_PIN(workers_busy_at, worker->number);
+#	endif
+
+	while (!atomic_load(worker->proc_stop) && !atomic_load(worker->workers_stop)) {
+		LOG_DEBUG("Worker %u waiting for a new job ...", worker->number);
+
+#		ifdef WITH_GPIO
+		GPIO_SET_LOW_AT(workers_busy_at, worker->number);
+#		endif
+
+		A_MUTEX_LOCK(&worker->has_job_mutex);
+		A_COND_WAIT_TRUE(atomic_load(&worker->has_job), &worker->has_job_cond, &worker->has_job_mutex);
+		A_MUTEX_UNLOCK(&worker->has_job_mutex);
+
+		if (!atomic_load(worker->workers_stop)) {
+#			define PICTURE(_next) worker->dev->run->pictures[worker->buf_index]._next
+
+			LOG_DEBUG("Worker %u compressing JPEG from buffer %u ...", worker->number, worker->buf_index);
+
+#			ifdef WITH_GPIO
+			GPIO_SET_HIGH_AT(workers_busy_at, worker->number);
+#			endif
+
+			if (encoder_compress_buffer(worker->encoder, worker->dev, worker->number, worker->buf_index) < 0) {
+				worker->job_failed = false;
+			}
+
+			if (device_release_buffer(worker->dev, worker->buf_index) == 0) {
+				worker->job_start_time = PICTURE(encode_begin_time);
+				atomic_store(&worker->has_job, false);
+
+				worker->last_comp_time = PICTURE(encode_end_time) - worker->job_start_time;
+
+				LOG_VERBOSE("Compressed new JPEG: size=%zu, time=%0.3Lf, worker=%u, buffer=%u",
+					PICTURE(used), worker->last_comp_time, worker->number, worker->buf_index);
+			} else {
+				worker->job_failed = true;
+				atomic_store(&worker->has_job, false);
+			}
+
+#			undef PICTURE
+		}
+
+		A_MUTEX_LOCK(worker->free_workers_mutex);
+		*worker->free_workers += 1;
+		A_MUTEX_UNLOCK(worker->free_workers_mutex);
+		A_COND_SIGNAL(worker->free_workers_cond);
+	}
+
+	LOG_DEBUG("Bye-bye (worker %u)", worker->number);
+#	ifdef WITH_GPIO
+	GPIO_SET_LOW_AT(workers_busy_at, worker->number);
+#	endif
 	return NULL;
 }
 
-static void _stream_destroy_workers(struct device_t *dev, struct workers_pool_t *pool) {
-	if (pool->workers) {
-		LOG_INFO("Destroying workers ...");
+static struct _worker_t *_workers_pool_wait(struct _workers_pool_t *pool) {
+	struct _worker_t *ready_worker = NULL;
 
-		*pool->workers_stop = true;
-		for (unsigned number = 0; number < dev->n_workers; ++number) {
-			A_PTHREAD_M_LOCK(&pool->workers[number].has_job_mutex);
-			pool->workers[number].has_job = true; // Final job: die
-			A_PTHREAD_M_UNLOCK(&pool->workers[number].has_job_mutex);
-			A_PTHREAD_C_SIGNAL(&pool->workers[number].has_job_cond);
+	A_MUTEX_LOCK(&pool->free_workers_mutex);
+	A_COND_WAIT_TRUE(pool->free_workers, &pool->free_workers_cond, &pool->free_workers_mutex);
+	A_MUTEX_UNLOCK(&pool->free_workers_mutex);
 
-			A_PTHREAD_JOIN(pool->workers[number].tid);
-			A_PTHREAD_M_DESTROY(&pool->workers[number].has_job_mutex);
-			A_PTHREAD_C_DESTROY(&pool->workers[number].has_job_cond);
-		}
-
-		A_PTHREAD_M_DESTROY(&pool->free_workers_mutex);
-		A_PTHREAD_C_DESTROY(&pool->free_workers_cond);
-
-		free(pool->workers);
-	}
-	pool->free_workers = 0;
-	pool->workers = NULL;
-}
-
-static int _stream_control(struct device_t *dev, const bool enable) {
-	if (enable != dev->run->capturing) {
-		enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
-		LOG_DEBUG("Calling ioctl(%s) ...", (enable ? "VIDIOC_STREAMON" : "VIDIOC_STREAMOFF"));
-		if (xioctl(dev->run->fd, (enable ? VIDIOC_STREAMON : VIDIOC_STREAMOFF), &type) < 0) {
-			LOG_PERROR("Unable to %s capturing", (enable ? "start" : "stop"));
-			if (enable) {
-				return -1;
+	if (pool->oldest_worker && !atomic_load(&pool->oldest_worker->has_job) && pool->oldest_worker->buf_index >= 0) {
+		ready_worker = pool->oldest_worker;
+		ready_worker->job_timely = true;
+		pool->oldest_worker = pool->oldest_worker->order_next;
+	} else {
+		for (unsigned number = 0; number < pool->n_workers; ++number) {
+			if (
+				!atomic_load(&pool->workers[number].has_job) && (
+					ready_worker == NULL
+					|| ready_worker->job_start_time < pool->workers[number].job_start_time
+				)
+			) {
+				ready_worker = &pool->workers[number];
+				break;
 			}
 		}
-
-		dev->run->capturing = enable;
-		LOG_INFO("Capturing %s", (enable ? "started" : "stopped"));
+		assert(ready_worker != NULL);
+		ready_worker->job_timely = false; // Освободился воркер, получивший задание позже (или самый первый при самом первом захвате)
 	}
-    return 0;
+	return ready_worker;
 }
 
-static int _stream_grab_buffer(struct device_t *dev, struct v4l2_buffer *buf_info) {
-	MEMSET_ZERO_PTR(buf_info);
-	buf_info->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-	buf_info->memory = V4L2_MEMORY_MMAP;
-
-	LOG_DEBUG("Calling ioctl(VIDIOC_DQBUF) ...");
-	if (xioctl(dev->run->fd, VIDIOC_DQBUF, buf_info) < 0) {
-		LOG_PERROR("Unable to dequeue buffer");
-		return -1;
-	}
-
-	LOG_DEBUG("Got a new frame in buffer index=%d; bytesused=%d", buf_info->index, buf_info->bytesused);
-	if (buf_info->index >= dev->run->n_buffers) {
-		LOG_ERROR("Got invalid buffer index=%d; nbuffers=%d", buf_info->index, dev->run->n_buffers);
-		return -1;
-	}
-	return 0;
-}
-
-static int _stream_release_buffer(struct device_t *dev, struct v4l2_buffer *buf_info) {
-	LOG_DEBUG("Calling ioctl(VIDIOC_QBUF) ...");
-	if (xioctl(dev->run->fd, VIDIOC_QBUF, buf_info) < 0) {
-		LOG_PERROR("Unable to requeue buffer");
-		return -1;
-	}
-	return 0;
-}
-
-static int _stream_handle_event(struct device_t *dev) {
-	struct v4l2_event event;
-
-	LOG_DEBUG("Calling ioctl(VIDIOC_DQEVENT) ...");
-	if (!xioctl(dev->run->fd, VIDIOC_DQEVENT, &event)) {
-		switch (event.type) {
-			case V4L2_EVENT_SOURCE_CHANGE:
-				LOG_INFO("Got V4L2_EVENT_SOURCE_CHANGE: source changed");
-				return -1;
-			case V4L2_EVENT_EOS:
-				LOG_INFO("Got V4L2_EVENT_EOS: end of stream (ignored)");
-				return 0;
-		}
+static void _workers_pool_assign(struct _workers_pool_t *pool, struct _worker_t *ready_worker, unsigned buf_index) {
+	if (pool->oldest_worker == NULL) {
+		pool->oldest_worker = ready_worker;
+		pool->latest_worker = pool->oldest_worker;
 	} else {
-		LOG_PERROR("Got some V4L2 device event, but where is it? ");
+		if (ready_worker->order_next) {
+			ready_worker->order_next->order_prev = ready_worker->order_prev;
+		}
+		if (ready_worker->order_prev) {
+			ready_worker->order_prev->order_next = ready_worker->order_next;
+		}
+		ready_worker->order_prev = pool->latest_worker;
+		pool->latest_worker->order_next = ready_worker;
+		pool->latest_worker = ready_worker;
 	}
-	return 0;
+	pool->latest_worker->order_next = NULL;
+
+	A_MUTEX_LOCK(&ready_worker->has_job_mutex);
+	ready_worker->buf_index = buf_index;
+	atomic_store(&ready_worker->has_job, true);
+	A_MUTEX_UNLOCK(&ready_worker->has_job_mutex);
+	A_COND_SIGNAL(&ready_worker->has_job_cond);
+
+	A_MUTEX_LOCK(&pool->free_workers_mutex);
+	pool->free_workers -= 1;
+	A_MUTEX_UNLOCK(&pool->free_workers_mutex);
+
+	LOG_DEBUG("Assigned new frame in buffer %u to worker %u", buf_index, ready_worker->number);
+}
+
+static long double _workers_pool_get_fluency_delay(struct _workers_pool_t *pool, struct _worker_t *ready_worker) {
+	long double approx_comp_time;
+	long double min_delay;
+
+	approx_comp_time = pool->approx_comp_time * 0.9 + ready_worker->last_comp_time * 0.1;
+
+	LOG_VERBOSE("Correcting approx_comp_time: %.3Lf -> %.3Lf (last_comp_time=%.3Lf)",
+		pool->approx_comp_time, approx_comp_time, ready_worker->last_comp_time);
+
+	pool->approx_comp_time = approx_comp_time;
+
+	min_delay = pool->approx_comp_time / pool->n_workers; // Среднее время работы размазывается на N воркеров
+
+	if (pool->desired_frames_interval > 0 && min_delay > 0 && pool->desired_frames_interval > min_delay) {
+		// Искусственное время задержки на основе желаемого FPS, если включен --desired-fps
+		return pool->desired_frames_interval;
+	}
+	return min_delay;
 }

src/stream.h

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
@@ -21,65 +22,15 @@
 
 #pragma once
 
-#include <stdbool.h>
-#include <signal.h>
-
-#include <pthread.h>
+#include <stdatomic.h>
 
 #include "device.h"
 #include "encoder.h"
 
 
-struct worker_context_t {
-	unsigned			number;
-	struct device_t		*dev;
-	int					buf_index;
-	struct v4l2_buffer	buf_info;
-	sig_atomic_t		*volatile dev_stop;
-	bool				*workers_stop;
-
-	struct encoder_t	*encoder;
-
-	pthread_mutex_t		*last_comp_time_mutex;
-	long double			*last_comp_time;
-
-	pthread_mutex_t		*has_job_mutex;
-	bool				*has_job;
-	bool				*job_failed;
-	long double			*job_start_time;
-	pthread_cond_t		*has_job_cond;
-
-	pthread_mutex_t		*free_workers_mutex;
-	unsigned			*free_workers;
-	pthread_cond_t		*free_workers_cond;
-};
-
-struct worker_t {
-	struct worker_context_t	ctx;
-	pthread_t				tid;
-
-	pthread_mutex_t			last_comp_time_mutex;
-	long double				last_comp_time;
-
-	pthread_mutex_t			has_job_mutex;
-	bool					has_job;
-	bool					job_failed;
-	long double				job_start_time;
-	pthread_cond_t			has_job_cond;
-
-	struct worker_t			*order_prev;
-	struct worker_t			*order_next;
-};
-
-struct workers_pool_t {
-	struct worker_t		*workers;
-	bool				*workers_stop;
-
-	pthread_mutex_t		free_workers_mutex;
-	unsigned			free_workers;
-	pthread_cond_t		free_workers_cond;
-
-	struct encoder_t	*encoder;
+struct process_t {
+	atomic_bool stop;
+	atomic_bool slowdown;
 };
 
 struct stream_t {
@@ -87,8 +38,10 @@ struct stream_t {
 	unsigned			width;
 	unsigned			height;
 	unsigned			captured_fps;
-	bool				updated;
+	atomic_bool			updated;
 	pthread_mutex_t		mutex;
+
+	struct process_t	*proc;
 	struct device_t		*dev;
 	struct encoder_t	*encoder;
 };
@@ -99,3 +52,4 @@ void stream_destroy(struct stream_t *stream);
 
 void stream_loop(struct stream_t *stream);
 void stream_loop_break(struct stream_t *stream);
+void stream_switch_slowdown(struct stream_t *stream, bool slowdown);

src/tools.h

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
@@ -24,50 +25,55 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdbool.h>
+#include <unistd.h>
 #include <errno.h>
 #include <math.h>
 #include <pthread.h>
 #include <time.h>
 #include <assert.h>
 
+#include <sys/types.h>
 #include <sys/ioctl.h>
 #include <sys/syscall.h>
 
 
-#define A_PTHREAD_CREATE(_tid, _func, _arg)	assert(!pthread_create(_tid, NULL, _func, _arg))
-#define A_PTHREAD_JOIN(_tid)				assert(!pthread_join(_tid, NULL))
+#define A_THREAD_CREATE(_tid, _func, _arg)	assert(!pthread_create(_tid, NULL, _func, _arg))
+#define A_THREAD_JOIN(_tid)					assert(!pthread_join(_tid, NULL))
 
-#define A_PTHREAD_M_INIT(_mutex)	assert(!pthread_mutex_init(_mutex, NULL))
-#define A_PTHREAD_M_DESTROY(_mutex)	assert(!pthread_mutex_destroy(_mutex))
-#define A_PTHREAD_M_LOCK(_mutex)	assert(!pthread_mutex_lock(_mutex))
-#define A_PTHREAD_M_UNLOCK(_mutex)	assert(!pthread_mutex_unlock(_mutex))
-
-#define A_PTHREAD_C_INIT(_cond)		assert(!pthread_cond_init(_cond, NULL))
-#define A_PTHREAD_C_DESTROY(_cond)	assert(!pthread_cond_destroy(_cond))
-#define A_PTHREAD_C_SIGNAL(...)		assert(!pthread_cond_signal(__VA_ARGS__))
-#define A_PTHREAD_C_WAIT_TRUE(_var, _cond, _mutex) { while(!_var) assert(!pthread_cond_wait(_cond, _mutex)); }
+#define A_MUTEX_INIT(_mutex)	assert(!pthread_mutex_init(_mutex, NULL))
+#define A_MUTEX_DESTROY(_mutex)	assert(!pthread_mutex_destroy(_mutex))
+#define A_MUTEX_LOCK(_mutex)	assert(!pthread_mutex_lock(_mutex))
+#define A_MUTEX_UNLOCK(_mutex)	assert(!pthread_mutex_unlock(_mutex))
 
+#define A_COND_INIT(_cond)		assert(!pthread_cond_init(_cond, NULL))
+#define A_COND_DESTROY(_cond)	assert(!pthread_cond_destroy(_cond))
+#define A_COND_SIGNAL(...)		assert(!pthread_cond_signal(__VA_ARGS__))
+#define A_COND_WAIT_TRUE(_var, _cond, _mutex) { while(!_var) assert(!pthread_cond_wait(_cond, _mutex)); }
 
 #define A_CALLOC(_dest, _nmemb)		assert((_dest = calloc(_nmemb, sizeof(*(_dest)))))
 #define A_REALLOC(_dest, _nmemb)	assert((_dest = realloc(_dest, _nmemb * sizeof(*(_dest)))))
 #define MEMSET_ZERO(_obj)			memset(&(_obj), 0, sizeof(_obj))
-#define MEMSET_ZERO_PTR(_ptr)		memset(_ptr, 0, sizeof(*(_ptr)))
 
+#define ARRAY_LEN(_array) (sizeof(_array) / sizeof(_array[0]))
 
 #define INLINE inline __attribute__((always_inline))
 #define UNUSED __attribute__((unused))
 
 
-INLINE char *bool_to_string(const bool flag) {
+INLINE char *bool_to_string(bool flag) {
 	return (flag ? "true" : "false");
 }
 
+INLINE unsigned min_u(unsigned a, unsigned b) {
+	return (a < b ? a : b);
+}
+
 INLINE unsigned max_u(unsigned a, unsigned b) {
 	return (a > b ? a : b);
 }
 
 INLINE long long floor_ms(long double now) {
-	return (long long) now - (now < (long long) now); // floor()
+	return (long long)now - (now < (long long)now); // floor()
 }
 
 INLINE void get_now(clockid_t clk_id, time_t *sec, long *msec) {
@@ -98,3 +104,7 @@ INLINE long double get_now_real(void) {
 	get_now(CLOCK_REALTIME, &sec, &msec);
 	return (long double)sec + ((long double)msec) / 1000;
 }
+
+INLINE pid_t get_thread_id(void) {
+	return syscall(SYS_gettid);
+}

src/xioctl.h

@@ -1,4 +1,5 @@
 /*****************************************************************************
+#                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
 #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
@@ -29,10 +30,12 @@
 #include "logging.h"
 
 
-#define XIOCTL_RETRIES 4
+#ifndef XIOCTL_RETRIES
+#	define XIOCTL_RETRIES 4
+#endif
 
 
-INLINE int xioctl(const int fd, const int request, void *arg) {
+INLINE int xioctl(int fd, int request, void *arg) {
 	int retries = XIOCTL_RETRIES;
 	int retval = -1;
 

tools/common.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+#============================================================================#
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#                                                                            #
+#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+#============================================================================#
+
+
+import textwrap
+
+
+# =====
+C_PREPEND = textwrap.dedent("""
+        /*****************************************************************************
+        #                                                                            #
+        #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+        #                                                                            #
+        #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+        #                                                                            #
+        #    This program is free software: you can redistribute it and/or modify    #
+        #    it under the terms of the GNU General Public License as published by    #
+        #    the Free Software Foundation, either version 3 of the License, or       #
+        #    (at your option) any later version.                                     #
+        #                                                                            #
+        #    This program is distributed in the hope that it will be useful,         #
+        #    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+        #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+        #    GNU General Public License for more details.                            #
+        #                                                                            #
+        #    You should have received a copy of the GNU General Public License       #
+        #    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+        #                                                                            #
+        *****************************************************************************/
+
+
+        #pragma once
+    """).strip() + "\n"

tools/make-html-h.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+#!/usr/bin/env -S python3 -B
 #============================================================================#
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
@@ -24,53 +24,33 @@
 import sys
 import textwrap
 
+import common
+
 
 # =====
-def main():
-    assert len(sys.argv) == 4, "%s <src> <dest> <name>" % (sys.argv[0])
-
-    src = sys.argv[1]
-    dest = sys.argv[2]
+def main() -> None:
+    assert len(sys.argv) == 4, f"{sys.argv[0]} <file.html> <file.h> <name>"
+    html_path = sys.argv[1]
+    header_path = sys.argv[2]
     name = sys.argv[3]
 
-    with open(src, "r") as html_file:
-        text = html_file.read()
+    with open(html_path, "r") as html_file:
+        html = html_file.read()
 
-    text = text.strip()
-    text = text.replace("\"", "\\\"")
-    text = text.replace("%VERSION%", "\" VERSION \"")
-    text = textwrap.indent(text, "\t", (lambda line: True))
-    text = "\n".join(("%s \\" if line.strip() else "%s\\") % (line) for line in text.split("\n"))
-    text = "const char *%s = \" \\\n%s\n\";\n" % (name, text)
-    text = textwrap.dedent("""
-        /*****************************************************************************
-        #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
-        #                                                                            #
-        #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
-        #                                                                            #
-        #    This program is free software: you can redistribute it and/or modify    #
-        #    it under the terms of the GNU General Public License as published by    #
-        #    the Free Software Foundation, either version 3 of the License, or       #
-        #    (at your option) any later version.                                     #
-        #                                                                            #
-        #    This program is distributed in the hope that it will be useful,         #
-        #    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
-        #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
-        #    GNU General Public License for more details.                            #
-        #                                                                            #
-        #    You should have received a copy of the GNU General Public License       #
-        #    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
-        #                                                                            #
-        *****************************************************************************/
+    html = html.strip()
+    html = html.replace("\"", "\\\"")
+    html = html.replace("%VERSION%", "\" VERSION \"")
+    html = textwrap.indent(html, "\t", (lambda line: True))
+    html = "\n".join(
+        (f"{line} \\" if line.strip() else f"{line}\\")
+        for line in html.split("\n")
+    )
 
+    text = f"{common.C_PREPEND}\n#include \"../../config.h\"\n\n\n"
+    text += f"const char HTML_{name}_PAGE[] = \" \\\n{html}\n\";\n"
 
-        #pragma once
-
-        #include "../config.h"
-    """).strip() + "\n\n\n" + text
-
-    with open(dest, "w") as h_file:
-        h_file.write(text)
+    with open(header_path, "w") as header_file:
+        header_file.write(text)
 
 
 # =====

tools/make-jpeg-h.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+#!/usr/bin/env -S python3 -B
 #============================================================================#
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
@@ -22,57 +22,69 @@
 
 
 import sys
-import textwrap
+import io
+import struct
+
+from typing import Tuple
+from typing import List
+
+import common
 
 
 # =====
-def main():
-    assert len(sys.argv) == 6, "%s <src> <dest> <prefix> <width> <height>" % (sys.argv[0])
+def _get_jpeg_size(data: bytes) -> Tuple[int, int]:
+    # https://sheep.horse/2013/9/finding_the_dimensions_of_a_jpeg_file_in_python.html
 
-    src = sys.argv[1]
-    dest = sys.argv[2]
-    prefix = sys.argv[3]
-    width = int(sys.argv[4])
-    height = int(sys.argv[5])
+    stream = io.BytesIO(data)
+    while True:
+        marker = struct.unpack(">H", stream.read(2))[0]
+        if (
+            marker == 0xFFD8  # Start of image
+            or marker == 0xFF01  # Private marker
+            or (marker >= 0xFFD0 and marker <= 0xFFD7)  # Restart markers
+        ):
+            continue
+        elif marker == 0xFFD9:
+            raise RuntimeError("Can't find jpeg size")
 
-    with open(src, "rb") as jpg_file:
-        jpg_data = jpg_file.read()
+        # All other markers specify chunks with lengths
+        length = struct.unpack(">H", stream.read(2))[0]
 
-    rows = [[]]
-    for ch in jpg_data:
-        if len(rows[-1]) > 20:
-            rows.append([])
-        rows[-1].append(hex(ch))
+        if marker == 0xFFC0:  # Baseline DCT chunk, has the info we want
+            (_, height, width) = struct.unpack(">BHH", stream.read(5))
+            return (width, height)
 
-    text = ",\n\t".join(", ".join(row) for row in rows)
-    text = "const unsigned char %s_JPG_DATA[] = {\n\t%s\n};\n" % (prefix, text)
-    text = "const unsigned long %s_JPG_SIZE = %d;\n\n" % (prefix, len(jpg_data)) + text
-    text = "const unsigned %s_JPG_HEIGHT = %d;\n\n" % (prefix, height) + text
-    text = "const unsigned %s_JPG_WIDTH = %d;\n" % (prefix, width) + text
-    text = textwrap.dedent("""
-        /*****************************************************************************
-        #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
-        #                                                                            #
-        #    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
-        #                                                                            #
-        #    This program is free software: you can redistribute it and/or modify    #
-        #    it under the terms of the GNU General Public License as published by    #
-        #    the Free Software Foundation, either version 3 of the License, or       #
-        #    (at your option) any later version.                                     #
-        #                                                                            #
-        #    This program is distributed in the hope that it will be useful,         #
-        #    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
-        #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
-        #    GNU General Public License for more details.                            #
-        #                                                                            #
-        #    You should have received a copy of the GNU General Public License       #
-        #    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
-        #                                                                            #
-        *****************************************************************************/
-    """).strip() + "\n\n\n" + text
+        # Not the chunk we want, skip it
+        stream.seek(length - 2, 1)
 
-    with open(dest, "w") as h_file:
-        h_file.write(text)
+
+# =====
+def main() -> None:
+    assert len(sys.argv) == 4, f"{sys.argv[0]} <file.jpeg> <file.h> <name>"
+    jpeg_path = sys.argv[1]
+    header_path = sys.argv[2]
+    name = sys.argv[3]
+
+    with open(jpeg_path, "rb") as jpeg_file:
+        jpeg_data = jpeg_file.read()
+
+    (width, height) = _get_jpeg_size(jpeg_data)
+
+    jpeg_data_text = "{\n\t" + ",\n\t".join(
+        ", ".join(
+            f"0x{ch:02X}"
+            for ch in jpeg_data[index:index + 20]
+        )
+        for index in range(0, len(jpeg_data), 20)
+    ) + ",\n}"
+
+    text = f"{common.C_PREPEND}\n\n"
+    text += f"const unsigned {name}_JPEG_WIDTH = {width};\n"
+    text += f"const unsigned {name}_JPEG_HEIGHT = {height};\n\n"
+    text += f"const unsigned char {name}_JPEG_DATA[] = {jpeg_data_text};\n"
+
+    with open(header_path, "w") as header_file:
+        header_file.write(text)
 
 
 # =====