Index: libroardsp/.cvsignore
===================================================================
--- libroardsp/.cvsignore	(revision 2802)
+++ 	(revision )
@@ -1,2 +1,0 @@
-empty.c
-*.dll
Index: libroardsp/Makefile
===================================================================
--- libroardsp/Makefile	(revision 5849)
+++ 	(revision )
@@ -1,36 +1,0 @@
-include ../Makefile.conf
-include ../Makefile.inc
-
-BASENAME=libroardsp
-SLIB=$(BASENAME)$(SHARED_SUFFIX)
-ALIB=$(BASENAME).a
-
-TARGETS=$(SLIB) $(ALIB) $(IMPLIB)
-OBJS=libroardsp.o convert.o midside.o poly.o filter.o filterchain.o remove.o transcode.o vio_transcode.o rms.o fader.o mixer.o amp.o interleave.o channels.o resampler_poly3.o float.o dtmf.o
-OLDROAR=midi.o
-FILTER=filter_lowp.o filter_highp.o filter_amp.o filter_quantify.o filter_add.o filter_clip.o filter_downmix.o filter_dcblock.o filter_swap.o filter_agc.o filter_speex_prep.o filter_responsecurve.o filter_goertzel.o
-MIDI=synth.o
-CODECS=alaw.o mulaw.o
-TRANSCODERS=transcode_mualaw.o transcode_celt.o transcode_speex.o
-
-ALLOBJS=$(OBJS) $(FILTER) $(TRANSCODERS) $(OLDROAR) $(MIDI) $(CODECS)
-
-#DEFINES        = -DDEBUG
-INCLUDE = -I../include -I../include/libroardsp
-CFLAGS += $(DEBUG_g) $(Wall) $(OPTI_O) $(DEFINES) $(INCLUDE) $(INCPATH) $(SHARED_CF) $(fPIC)
-LDFLAGS+= $(DEBUG_g) $(Wall) $(SHARED) -L../lib/ $(LDPATH)
-
-LIBS      = $(LIBROARDSP_NS)
-
-all: ${TARGETS}
-	rm -f ../lib/${SLIB} 2> /dev/null || true
-	cp $(cp_v) ${TARGETS} ../lib/
-clean:
-	rm -f ${TARGETS} *.o
-new: clean all
-
-$(SLIB): $(ALLOBJS)
-	${CC} ${LDFLAGS} -Wl,-soname,$(SLIB).$(LIBROARDSP_V) -o $(SLIB) $(ALLOBJS) $(LIBS)
-$(ALIB): $(ALLOBJS)
-	${AR} cru $(ALIB) $(ALLOBJS)
-	${RANLIB} $(ALIB)
Index: libroardsp/alaw.c
===================================================================
--- libroardsp/alaw.c	(revision 6052)
+++ 	(revision )
@@ -1,879 +1,0 @@
-//alaw.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-/*
-
- * In addition to the above copyright statement codec marked with
- * '-------- SUN --------' is under the following license as it is extracted
- * from SoX 12.17.9:
-
- * This source code is a product of Sun Microsystems, Inc. and is provided
- * for unrestricted use.  Users may copy or modify this source code without
- * charge.
- *
- * SUN SOURCE CODE IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING
- * THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
- *
- * Sun source code is provided with no support and without any obligation on
- * the part of Sun Microsystems, Inc. to assist in its use, correction,
- * modification or enhancement.
- *
- * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
- * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY THIS SOFTWARE
- * OR ANY PART THEREOF.
- *
- * In no event will Sun Microsystems, Inc. be liable for any lost revenue
- * or profits or other special, indirect and consequential damages, even if
- * Sun has been advised of the possibility of such damages.
- *
- * Sun Microsystems, Inc.
- * 2550 Garcia Avenue
- * Mountain View, California  94043
-*/
-
-#include "libroardsp.h"
-
-#ifdef ROAR_SUPPORT_ALAW
-static const int16_t _roardsp_alaw2pcm16[] = {
-/* -------- SUN -------- */
-     -5504,   -5248,   -6016,   -5760,   -4480,   -4224,   -4992,
-     -4736,   -7552,   -7296,   -8064,   -7808,   -6528,   -6272,
-     -7040,   -6784,   -2752,   -2624,   -3008,   -2880,   -2240,
-     -2112,   -2496,   -2368,   -3776,   -3648,   -4032,   -3904,
-     -3264,   -3136,   -3520,   -3392,  -22016,  -20992,  -24064,
-    -23040,  -17920,  -16896,  -19968,  -18944,  -30208,  -29184,
-    -32256,  -31232,  -26112,  -25088,  -28160,  -27136,  -11008,
-    -10496,  -12032,  -11520,   -8960,   -8448,   -9984,   -9472,
-    -15104,  -14592,  -16128,  -15616,  -13056,  -12544,  -14080,
-    -13568,    -344,    -328,    -376,    -360,    -280,    -264,
-      -312,    -296,    -472,    -456,    -504,    -488,    -408,
-      -392,    -440,    -424,     -88,     -72,    -120,    -104,
-       -24,      -8,     -56,     -40,    -216,    -200,    -248,
-      -232,    -152,    -136,    -184,    -168,   -1376,   -1312,
-     -1504,   -1440,   -1120,   -1056,   -1248,   -1184,   -1888,
-     -1824,   -2016,   -1952,   -1632,   -1568,   -1760,   -1696,
-      -688,    -656,    -752,    -720,    -560,    -528,    -624,
-      -592,    -944,    -912,   -1008,    -976,    -816,    -784,
-      -880,    -848,    5504,    5248,    6016,    5760,    4480,
-      4224,    4992,    4736,    7552,    7296,    8064,    7808,
-      6528,    6272,    7040,    6784,    2752,    2624,    3008,
-      2880,    2240,    2112,    2496,    2368,    3776,    3648,
-      4032,    3904,    3264,    3136,    3520,    3392,   22016,
-     20992,   24064,   23040,   17920,   16896,   19968,   18944,
-     30208,   29184,   32256,   31232,   26112,   25088,   28160,
-     27136,   11008,   10496,   12032,   11520,    8960,    8448,
-      9984,    9472,   15104,   14592,   16128,   15616,   13056,
-     12544,   14080,   13568,     344,     328,     376,     360,
-       280,     264,     312,     296,     472,     456,     504,
-       488,     408,     392,     440,     424,      88,      72,
-       120,     104,      24,       8,      56,      40,     216,
-       200,     248,     232,     152,     136,     184,     168,
-      1376,    1312,    1504,    1440,    1120,    1056,    1248,
-      1184,    1888,    1824,    2016,    1952,    1632,    1568,
-      1760,    1696,     688,     656,     752,     720,     560,
-       528,     624,     592,     944,     912,    1008,     976,
-       816,     784,     880,     848
-/* -------- /SUN -------- */
-};
-
-#ifdef ROAR_SUPPORT_ALAW_RW
-static const int8_t _roardsp_pcm132alaw[] = {
-/* -------- SUN -------- */
-   0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
-   0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
-   0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
-   0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
-   0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
-   0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
-   0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
-   0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
-   0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
-   0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
-   0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2b, 0x2b, 0x2b, 0x2b,
-   0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
-   0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
-   0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
-   0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
-   0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
-   0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
-   0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
-   0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
-   0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
-   0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
-   0x2b, 0x2b, 0x2b, 0x2b, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
-   0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
-   0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
-   0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
-   0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
-   0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
-   0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
-   0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
-   0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
-   0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
-   0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
-   0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
-   0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
-   0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
-   0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
-   0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
-   0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
-   0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
-   0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
-   0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
-   0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
-   0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x2e, 0x2e, 0x2e, 0x2e,
-   0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
-   0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
-   0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
-   0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
-   0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
-   0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
-   0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
-   0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
-   0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
-   0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
-   0x2e, 0x2e, 0x2e, 0x2e, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
-   0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
-   0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
-   0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
-   0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
-   0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
-   0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
-   0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
-   0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
-   0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
-   0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
-   0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
-   0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
-   0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
-   0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
-   0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
-   0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
-   0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
-   0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
-   0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
-   0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
-   0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2d, 0x2d, 0x2d, 0x2d,
-   0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-   0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-   0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-   0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-   0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-   0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-   0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-   0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-   0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-   0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-   0x2d, 0x2d, 0x2d, 0x2d, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-   0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-   0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-   0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-   0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-   0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-   0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-   0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-   0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-   0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-   0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-   0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
-   0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
-   0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
-   0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
-   0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
-   0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
-   0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
-   0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
-   0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
-   0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
-   0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x20, 0x20, 0x20, 0x20,
-   0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-   0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-   0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-   0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-   0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-   0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-   0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-   0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-   0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-   0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-   0x20, 0x20, 0x20, 0x20, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
-   0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
-   0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
-   0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
-   0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
-   0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
-   0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
-   0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
-   0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
-   0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
-   0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
-   0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
-   0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
-   0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
-   0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
-   0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
-   0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
-   0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
-   0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
-   0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
-   0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
-   0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x27, 0x27, 0x27, 0x27,
-   0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
-   0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
-   0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
-   0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
-   0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
-   0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
-   0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
-   0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
-   0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
-   0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
-   0x27, 0x27, 0x27, 0x27, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
-   0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
-   0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
-   0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
-   0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
-   0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
-   0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
-   0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
-   0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
-   0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
-   0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
-   0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
-   0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
-   0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
-   0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
-   0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
-   0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
-   0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
-   0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
-   0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
-   0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
-   0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x3a, 0x3a, 0x3a, 0x3a,
-   0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a,
-   0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a,
-   0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a,
-   0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a,
-   0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a,
-   0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b,
-   0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b,
-   0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b,
-   0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b,
-   0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b,
-   0x3b, 0x3b, 0x3b, 0x3b, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
-   0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
-   0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
-   0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
-   0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
-   0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x39, 0x39, 0x39, 0x39,
-   0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39,
-   0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39,
-   0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39,
-   0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39,
-   0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39,
-   0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e,
-   0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e,
-   0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e,
-   0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e,
-   0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e,
-   0x3e, 0x3e, 0x3e, 0x3e, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
-   0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
-   0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
-   0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
-   0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
-   0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3c, 0x3c, 0x3c, 0x3c,
-   0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c,
-   0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c,
-   0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c,
-   0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c,
-   0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c,
-   0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,
-   0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,
-   0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,
-   0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,
-   0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,
-   0x3d, 0x3d, 0x3d, 0x3d, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
-   0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
-   0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
-   0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
-   0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
-   0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x33, 0x33, 0x33, 0x33,
-   0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
-   0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
-   0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
-   0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
-   0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
-   0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
-   0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
-   0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
-   0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
-   0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
-   0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
-   0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
-   0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
-   0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
-   0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
-   0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x36, 0x36, 0x36, 0x36,
-   0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
-   0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
-   0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
-   0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
-   0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
-   0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37,
-   0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37,
-   0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37,
-   0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37,
-   0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37,
-   0x37, 0x37, 0x37, 0x37, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34,
-   0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34,
-   0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34,
-   0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34,
-   0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34,
-   0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x35, 0x35, 0x35, 0x35,
-   0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
-   0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
-   0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
-   0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
-   0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 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, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 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,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x1a, 0x1a, 0x1a, 0x1a,
-   0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
-   0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
-   0x1b, 0x1b, 0x1b, 0x1b, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-   0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x19, 0x19, 0x19, 0x19,
-   0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
-   0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
-   0x1e, 0x1e, 0x1e, 0x1e, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
-   0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1c, 0x1c, 0x1c, 0x1c,
-   0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
-   0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
-   0x1d, 0x1d, 0x1d, 0x1d, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
-   0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13,
-   0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
-   0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
-   0x10, 0x10, 0x10, 0x10, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
-   0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x16, 0x16, 0x16, 0x16,
-   0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
-   0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
-   0x17, 0x17, 0x17, 0x17, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
-   0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x15, 0x15, 0x15, 0x15,
-   0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
-   0x6a, 0x6a, 0x6a, 0x6a, 0x6a, 0x6a, 0x6a, 0x6a, 0x6b, 0x6b, 0x6b, 0x6b,
-   0x6b, 0x6b, 0x6b, 0x6b, 0x68, 0x68, 0x68, 0x68, 0x68, 0x68, 0x68, 0x68,
-   0x69, 0x69, 0x69, 0x69, 0x69, 0x69, 0x69, 0x69, 0x6e, 0x6e, 0x6e, 0x6e,
-   0x6e, 0x6e, 0x6e, 0x6e, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f,
-   0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6d, 0x6d, 0x6d, 0x6d,
-   0x6d, 0x6d, 0x6d, 0x6d, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62,
-   0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x60, 0x60, 0x60, 0x60,
-   0x60, 0x60, 0x60, 0x60, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
-   0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x67, 0x67, 0x67, 0x67,
-   0x67, 0x67, 0x67, 0x67, 0x64, 0x64, 0x64, 0x64, 0x64, 0x64, 0x64, 0x64,
-   0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x7a, 0x7a, 0x7a, 0x7a,
-   0x7b, 0x7b, 0x7b, 0x7b, 0x78, 0x78, 0x78, 0x78, 0x79, 0x79, 0x79, 0x79,
-   0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, 0x7c, 0x7c, 0x7c, 0x7c,
-   0x7d, 0x7d, 0x7d, 0x7d, 0x72, 0x72, 0x72, 0x72, 0x73, 0x73, 0x73, 0x73,
-   0x70, 0x70, 0x70, 0x70, 0x71, 0x71, 0x71, 0x71, 0x76, 0x76, 0x76, 0x76,
-   0x77, 0x77, 0x77, 0x77, 0x74, 0x74, 0x74, 0x74, 0x75, 0x75, 0x75, 0x75,
-   0x4a, 0x4a, 0x4b, 0x4b, 0x48, 0x48, 0x49, 0x49, 0x4e, 0x4e, 0x4f, 0x4f,
-   0x4c, 0x4c, 0x4d, 0x4d, 0x42, 0x42, 0x43, 0x43, 0x40, 0x40, 0x41, 0x41,
-   0x46, 0x46, 0x47, 0x47, 0x44, 0x44, 0x45, 0x45, 0x5a, 0x5a, 0x5b, 0x5b,
-   0x58, 0x58, 0x59, 0x59, 0x5e, 0x5e, 0x5f, 0x5f, 0x5c, 0x5c, 0x5d, 0x5d,
-   0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51, 0x56, 0x56, 0x57, 0x57,
-   0x54, 0x54, 0x55, 0x55, 0xd5, 0xd5, 0xd4, 0xd4, 0xd7, 0xd7, 0xd6, 0xd6,
-   0xd1, 0xd1, 0xd0, 0xd0, 0xd3, 0xd3, 0xd2, 0xd2, 0xdd, 0xdd, 0xdc, 0xdc,
-   0xdf, 0xdf, 0xde, 0xde, 0xd9, 0xd9, 0xd8, 0xd8, 0xdb, 0xdb, 0xda, 0xda,
-   0xc5, 0xc5, 0xc4, 0xc4, 0xc7, 0xc7, 0xc6, 0xc6, 0xc1, 0xc1, 0xc0, 0xc0,
-   0xc3, 0xc3, 0xc2, 0xc2, 0xcd, 0xcd, 0xcc, 0xcc, 0xcf, 0xcf, 0xce, 0xce,
-   0xc9, 0xc9, 0xc8, 0xc8, 0xcb, 0xcb, 0xca, 0xca, 0xf5, 0xf5, 0xf5, 0xf5,
-   0xf4, 0xf4, 0xf4, 0xf4, 0xf7, 0xf7, 0xf7, 0xf7, 0xf6, 0xf6, 0xf6, 0xf6,
-   0xf1, 0xf1, 0xf1, 0xf1, 0xf0, 0xf0, 0xf0, 0xf0, 0xf3, 0xf3, 0xf3, 0xf3,
-   0xf2, 0xf2, 0xf2, 0xf2, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc,
-   0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xf9, 0xf9, 0xf9, 0xf9,
-   0xf8, 0xf8, 0xf8, 0xf8, 0xfb, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, 0xfa, 0xfa,
-   0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe4, 0xe4, 0xe4, 0xe4,
-   0xe4, 0xe4, 0xe4, 0xe4, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7,
-   0xe6, 0xe6, 0xe6, 0xe6, 0xe6, 0xe6, 0xe6, 0xe6, 0xe1, 0xe1, 0xe1, 0xe1,
-   0xe1, 0xe1, 0xe1, 0xe1, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0,
-   0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe2, 0xe2, 0xe2, 0xe2,
-   0xe2, 0xe2, 0xe2, 0xe2, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed,
-   0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xef, 0xef, 0xef, 0xef,
-   0xef, 0xef, 0xef, 0xef, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee,
-   0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe8, 0xe8, 0xe8, 0xe8,
-   0xe8, 0xe8, 0xe8, 0xe8, 0xeb, 0xeb, 0xeb, 0xeb, 0xeb, 0xeb, 0xeb, 0xeb,
-   0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0x95, 0x95, 0x95, 0x95,
-   0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
-   0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
-   0x94, 0x94, 0x94, 0x94, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
-   0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x96, 0x96, 0x96, 0x96,
-   0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
-   0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
-   0x91, 0x91, 0x91, 0x91, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
-   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x93, 0x93, 0x93, 0x93,
-   0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
-   0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
-   0x92, 0x92, 0x92, 0x92, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
-   0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9c, 0x9c, 0x9c, 0x9c,
-   0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
-   0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
-   0x9f, 0x9f, 0x9f, 0x9f, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
-   0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x99, 0x99, 0x99, 0x99,
-   0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
-   0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
-   0x98, 0x98, 0x98, 0x98, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
-   0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9a, 0x9a, 0x9a, 0x9a,
-   0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0xb5, 0xb5, 0xb5, 0xb5,
-   0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5,
-   0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5,
-   0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5,
-   0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5,
-   0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5,
-   0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4,
-   0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4,
-   0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4,
-   0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4,
-   0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4,
-   0xb4, 0xb4, 0xb4, 0xb4, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7,
-   0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7,
-   0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7,
-   0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7,
-   0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7,
-   0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb6, 0xb6, 0xb6, 0xb6,
-   0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6,
-   0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6,
-   0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6,
-   0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6,
-   0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6,
-   0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1,
-   0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1,
-   0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1,
-   0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1,
-   0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1,
-   0xb1, 0xb1, 0xb1, 0xb1, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0,
-   0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0,
-   0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0,
-   0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0,
-   0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0,
-   0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb3, 0xb3, 0xb3, 0xb3,
-   0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3,
-   0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3,
-   0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3,
-   0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3,
-   0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3,
-   0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2,
-   0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2,
-   0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2,
-   0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2,
-   0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2,
-   0xb2, 0xb2, 0xb2, 0xb2, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd,
-   0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd,
-   0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd,
-   0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd,
-   0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd,
-   0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbc, 0xbc, 0xbc, 0xbc,
-   0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc,
-   0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc,
-   0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc,
-   0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc,
-   0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc,
-   0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
-   0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
-   0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
-   0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
-   0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
-   0xbf, 0xbf, 0xbf, 0xbf, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe,
-   0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe,
-   0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe,
-   0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe,
-   0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe,
-   0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xb9, 0xb9, 0xb9, 0xb9,
-   0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9,
-   0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9,
-   0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9,
-   0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9,
-   0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9,
-   0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8,
-   0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8,
-   0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8,
-   0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8,
-   0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8,
-   0xb8, 0xb8, 0xb8, 0xb8, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
-   0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
-   0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
-   0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
-   0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
-   0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xba, 0xba, 0xba, 0xba,
-   0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba,
-   0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba,
-   0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba,
-   0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba,
-   0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba,
-   0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
-   0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
-   0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
-   0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
-   0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
-   0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
-   0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
-   0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
-   0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
-   0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
-   0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa4, 0xa4, 0xa4, 0xa4,
-   0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
-   0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
-   0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
-   0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
-   0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
-   0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
-   0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
-   0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
-   0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
-   0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
-   0xa4, 0xa4, 0xa4, 0xa4, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
-   0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
-   0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
-   0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
-   0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
-   0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
-   0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
-   0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
-   0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
-   0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
-   0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
-   0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
-   0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
-   0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
-   0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
-   0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
-   0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
-   0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
-   0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
-   0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
-   0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
-   0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa1, 0xa1, 0xa1, 0xa1,
-   0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
-   0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
-   0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
-   0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
-   0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
-   0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
-   0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
-   0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
-   0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
-   0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
-   0xa1, 0xa1, 0xa1, 0xa1, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
-   0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
-   0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
-   0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
-   0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
-   0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
-   0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
-   0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
-   0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
-   0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
-   0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
-   0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
-   0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
-   0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
-   0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
-   0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
-   0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
-   0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
-   0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
-   0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
-   0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
-   0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa2, 0xa2, 0xa2, 0xa2,
-   0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
-   0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
-   0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
-   0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
-   0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
-   0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
-   0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
-   0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
-   0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
-   0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
-   0xa2, 0xa2, 0xa2, 0xa2, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
-   0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
-   0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
-   0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
-   0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
-   0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
-   0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
-   0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
-   0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
-   0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
-   0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
-   0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
-   0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
-   0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
-   0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
-   0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
-   0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
-   0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
-   0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
-   0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
-   0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
-   0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xaf, 0xaf, 0xaf, 0xaf,
-   0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
-   0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
-   0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
-   0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
-   0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
-   0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
-   0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
-   0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
-   0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
-   0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
-   0xaf, 0xaf, 0xaf, 0xaf, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
-   0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
-   0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
-   0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
-   0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
-   0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
-   0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
-   0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
-   0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
-   0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
-   0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
-   0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
-   0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
-   0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
-   0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
-   0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
-   0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
-   0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
-   0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
-   0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
-   0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
-   0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa8, 0xa8, 0xa8, 0xa8,
-   0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
-   0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
-   0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
-   0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
-   0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
-   0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
-   0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
-   0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
-   0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
-   0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
-   0xa8, 0xa8, 0xa8, 0xa8, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
-   0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
-   0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
-   0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
-   0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
-   0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
-   0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
-   0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
-   0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
-   0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
-   0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
-   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa
-/* -------- /SUN -------- */
-};
-#endif
-#endif
-
-int roardsp_conv_alaw2pcm16 (int16_t * out, char * in, size_t len) {
-#ifdef ROAR_SUPPORT_ALAW
- unsigned char * inp = (unsigned char *) in;
- ssize_t i;
-
- for (i = len-1; i > -1; i--) {
-  out[i] = _roardsp_alaw2pcm16[inp[i]];
- }
-
- return 0;
-#else
- return -1;
-#endif
-}
-
-int roardsp_conv_pcm162alaw (char * out, int16_t * in, size_t len) {
-#ifdef ROAR_SUPPORT_ALAW_RW
- unsigned int i;
-
- for (i = 0; i < len; i++) {
-  out[i] = _roardsp_pcm132alaw[(in[i] + 32768) >> 3];
- }
-
- return 0;
-#else
- return -1;
-#endif
-}
-
-int roardsp_conv_autlaw2pcm32 (int32_t * out, int16_t * in, size_t len) {
-#ifdef ROAR_SUPPORT_ALAW
- uint16_t inp;
- register unsigned char alaw, extra;
- register int bits;
- uint32_t op;
- int i;
-
- for (i = len-1; i > -1; i--) {
-  inp = ROAR_NET2HOST16(in[i]);
-  alaw = (inp & 0xFF00) >> 8;
-  extra = inp & 0x00FF;
-
-//  printf("Balaw=%u\n", (unsigned)alaw);
-
-  bits = (alaw & 0x70) >> 4;
-  if ( bits == 0 )
-   bits = 1;
-
-  op = (uint32_t)_roardsp_alaw2pcm16[(int)alaw] << 16;
-//  out[i] |= extra << (11 + bits);
-  out[i]  = op;
- }
-
- return 0;
-#else
- return -1;
-#endif
-}
-
-int roardsp_conv_pcm322autlaw (int16_t * out, int32_t * in, size_t len) {
-#ifdef ROAR_SUPPORT_ALAW_RW
- register unsigned int i;
- register uint16_t upper, r;
- register unsigned char alaw;
- register int bits;
-
- for (i = 0; i < len; i++) {
-  upper = (uint32_t)((in[i] & 0xFFFF0000L) >> 16);
-  alaw = _roardsp_pcm132alaw[(upper + 32768) >> 3];
-//  printf("Aalaw=%u\n", (unsigned)alaw);
-  bits = (alaw & 0x70) >> 4;
-  if ( bits == 0 )
-   bits = 1;
-
-  r  = ((in[i] << (6 + bits)) & 0xFF000000) >> 24;
-  r |= alaw << 8;
-
-  out[i] = ROAR_HOST2NET16(r);
- }
-
- return 0;
-#else
- return -1;
-#endif
-}
-
-//ll
Index: libroardsp/amp.c
===================================================================
--- libroardsp/amp.c	(revision 6052)
+++ 	(revision )
@@ -1,119 +1,0 @@
-//amp.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-int roar_amp_pcm(void * output, int bits, void * input, size_t samples, int channels, struct roar_mixer_settings * set) {
- switch (bits) {
-  case  8: return roar_amp_pcm_8bit (output, input, samples, channels, set); break;
-  case 16: return roar_amp_pcm_16bit(output, input, samples, channels, set); break;
-  case 32: return roar_amp_pcm_32bit(output, input, samples, channels, set); break;
-  default: return -1;
- }
-}
-
-int roar_amp_pcm_8bit  (int8_t  * output, int8_t  * input, size_t samples, int channels, struct roar_mixer_settings * set) {
- size_t   i;
- register int s;
-
- if ( !(input && output) )
-  return -1;
-
- if (set->rpg_mul == set->rpg_div) {
-  for (i = 0; i < samples; i++) {
-   s  = input[i];
-   s *= set->mixer[i % channels];
-   s /= set->scale;
-   output[i] = s;
-  }
- } else {
-  for (i = 0; i < samples; i++) {
-   s  = input[i];
-   s *= (set->mixer[i % channels] * set->rpg_mul) / set->rpg_div;
-   s /= set->scale;
-   output[i] = s;
-  }
- }
-
- return 0;
-}
-
-int roar_amp_pcm_16bit (int16_t * output, int16_t * input, size_t samples, int channels, struct roar_mixer_settings * set) {
- size_t    i;
- register int s;
-
- if ( !(input && output) )
-  return -1;
-
- if (set->rpg_mul == set->rpg_div) {
-  for (i = 0; i < samples; i++) {
-   s  = input[i];
-   s *= set->mixer[i % channels];
-   s /= set->scale;
-   output[i] = s;
-  }
- } else {
-  for (i = 0; i < samples; i++) {
-   s  = input[i];
-   s *= (set->mixer[i % channels] * set->rpg_mul) / set->rpg_div;
-   s /= set->scale;
-   output[i] = s;
-  }
- }
-
- return 0;
-}
-
-int roar_amp_pcm_32bit (int32_t * output, int32_t * input, size_t samples, int channels, struct roar_mixer_settings * set) {
-#ifdef ROAR_NATIVE_INT64
- size_t      i;
- ROAR_NATIVE_INT64 s;
-
- if ( !(input && output) )
-  return -1;
-
- if (set->rpg_mul == set->rpg_div) {
-  for (i = 0; i < samples; i++) {
-   s  = input[i];
-   s *= set->mixer[i % channels];
-   s /= set->scale;
-   output[i] = s;
-  }
- } else {
-  for (i = 0; i < samples; i++) {
-   s  = input[i];
-   s *= (set->mixer[i % channels] * set->rpg_mul) / set->rpg_div;
-   s /= set->scale;
-   output[i] = s;
-  }
- }
-
- return 0;
-#else
- return -1;
-#endif
-}
-
-//ll
Index: libroardsp/channels.c
===================================================================
--- libroardsp/channels.c	(revision 6052)
+++ 	(revision )
@@ -1,553 +1,0 @@
-//channels.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2010-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-#include "roaraudio/units.h"
-
-static struct {
- int id;
- char * name;
- char * sn;
-} _g_chans[] = {
- // general:
- {ROARDSP_CHAN_NONE,           "NONE",           "NONE"           },
- // waveform:
- {ROARDSP_CHAN_FRONT_LEFT,     "FRONT_LEFT",     "FL"             },
- {ROARDSP_CHAN_FRONT_RIGHT,    "FRONT_RIGHT",    "FR"             },
- {ROARDSP_CHAN_SIDE_LEFT,      "SIDE_LEFT",      "SL"             },
- {ROARDSP_CHAN_SIDE_RIGHT,     "SIDE_RIGHT",     "SR"             },
- {ROARDSP_CHAN_BACK_LEFT,      "BACK_LEFT",      "BL"             },
- {ROARDSP_CHAN_BACK_RIGHT,     "BACK_RIGHT",     "BR"             },
- {ROARDSP_CHAN_FRONT_CENTER,   "FRONT_CENTER",   "FC"             },
- {ROARDSP_CHAN_SIDE_CENTER,    "SIDE_CENTER",    "SC"             },
- {ROARDSP_CHAN_BACK_CENTER,    "BACK_CENTER",    "BC"             },
- {ROARDSP_CHAN_LEFT,           "LEFT",           "L"              }, // alias
- {ROARDSP_CHAN_RIGHT,          "RIGHT",          "R"              }, // alias
- {ROARDSP_CHAN_CENTER,         "CENTER",         "C"              }, // alias
- {ROARDSP_CHAN_MONO,           "MONO",           "M"              }, // alias
- {ROARDSP_CHAN_MS_MID,         "MS_MID",         "MID"            },
- {ROARDSP_CHAN_MS_SIDE,        "MS_SIDE",        "SIDE"           },
- {ROARDSP_CHAN_LFE,            "LFE",            "LFE"            },
- // midi:
- {ROARDSP_CHAN_MIDI0,           "MIDI0",         NULL             },
- {ROARDSP_CHAN_MIDI1,           "MIDI1",         NULL             },
- {ROARDSP_CHAN_MIDI2,           "MIDI2",         NULL             },
- {ROARDSP_CHAN_MIDI3,           "MIDI3",         NULL             },
- {ROARDSP_CHAN_MIDI4,           "MIDI4",         NULL             },
- {ROARDSP_CHAN_MIDI5,           "MIDI5",         NULL             },
- {ROARDSP_CHAN_MIDI6,           "MIDI6",         NULL             },
- {ROARDSP_CHAN_MIDI7,           "MIDI7",         NULL             },
- {ROARDSP_CHAN_MIDI8,           "MIDI8",         NULL             },
- {ROARDSP_CHAN_MIDI9,           "MIDI9",         NULL             },
- {ROARDSP_CHAN_MIDI10,          "MIDI10",        NULL             },
- {ROARDSP_CHAN_MIDI11,          "MIDI11",        NULL             },
- {ROARDSP_CHAN_MIDI12,          "MIDI12",        NULL             },
- {ROARDSP_CHAN_MIDI13,          "MIDI13",        NULL             },
- {ROARDSP_CHAN_MIDI14,          "MIDI14",        NULL             },
- {ROARDSP_CHAN_MIDI15,          "MIDI15",        NULL             },
- {ROARDSP_CHAN_EOL, NULL, NULL}
-};
-
-char * roardsp_chan2str (int chan) {
- int i;
-
- for (i = 0; _g_chans[i].id != ROARDSP_CHAN_EOL; i++)
-  if ( _g_chans[i].id == chan )
-   return _g_chans[i].name;
-
- return NULL;
-}
-
-int roardsp_str2chan(char * str) {
- int i;
-
- for (i = 0; _g_chans[i].id != ROARDSP_CHAN_EOL; i++)
-  if ( !strcasecmp(_g_chans[i].name, str) ||
-       (_g_chans[i].sn != NULL && !strcasecmp(_g_chans[i].sn, str)) )
-   return _g_chans[i].id;
-
- return -1;
-}
-
-int    roardsp_chanlist2str(char * list, size_t len, char * str, size_t strlen) {
- size_t i;
- char * name;
-
- if ( list == NULL && len > 0 )
-  return -1;
-
- if ( (str == NULL || strlen == 0) && len > 0 )
-  return -1;
-
- if ( len == 0 ) {
-  if ( str != NULL && strlen > 0 )
-   *str = 0;
-
-  return 0;
- }
-
- *str = 0;
-
- for (i = 0; i < len; i++) {
-  if ( i != 0 )
-   roar_mm_strlcat(str, ",", strlen);
-
-  name = roardsp_chan2str(list[i]);
-
-  if ( name == NULL ) {
-   roar_mm_strlcat(str, "<<<INVALID>>>", strlen);
-  } else {
-   roar_mm_strlcat(str, name, strlen);
-  }
- }
-
- return 0;
-}
-
-int    roardsp_chanlist_init(char * list, int channels, int map) {
- int i;
-
- if ( channels == 0 )
-  return 0;
-
- if ( list == NULL )
-  return -1;
-
- if ( channels > ROAR_MAX_CHANNELS )
-  return -1;
-
- if ( map == ROARDSP_CHANLIST_MAP_MIDI ) {
-  for (i = 0; i < channels; i++) {
-   list[i] = i+ROARDSP_CHAN_MIDI0;
-  }
- }
-
- // test for common maps:
- if ( channels == 1 ) {
-  list[0] = ROARDSP_CHAN_MONO;
-  return 0;
- }
-
- if ( channels == 2 ) {
-  list[0] = ROARDSP_CHAN_LEFT;
-  list[1] = ROARDSP_CHAN_RIGHT;
-  return 0;
- }
-
- // test for specific maps:
- switch (map) {
-  case ROARDSP_CHANLIST_MAP_ROARAUDIO:
-  case ROARDSP_CHANLIST_MAP_FLAC:
-    if ( map == ROARDSP_CHANLIST_MAP_FLAC && channels > 6 ) {
-     // FLAC only has a fixed mapping for up to 6 channels.
-     return -1;
-    }
-
-    switch (channels) {
-     // FLAC or RoarAudio:
-     case 3:
-       list[0] = ROARDSP_CHAN_LEFT;
-       list[1] = ROARDSP_CHAN_RIGHT;
-       list[2] = ROARDSP_CHAN_CENTER;
-      break;
-     case 4:
-       list[0] = ROARDSP_CHAN_FRONT_LEFT;
-       list[1] = ROARDSP_CHAN_FRONT_RIGHT;
-       list[2] = ROARDSP_CHAN_BACK_LEFT;
-       list[3] = ROARDSP_CHAN_BACK_RIGHT;
-      break;
-     case 5:
-       list[0] = ROARDSP_CHAN_FRONT_LEFT;
-       list[1] = ROARDSP_CHAN_FRONT_RIGHT;
-       list[2] = ROARDSP_CHAN_CENTER;
-       list[3] = ROARDSP_CHAN_BACK_LEFT;
-       list[4] = ROARDSP_CHAN_BACK_RIGHT;
-      break;
-     case 6:
-       list[0] = ROARDSP_CHAN_FRONT_LEFT;
-       list[1] = ROARDSP_CHAN_FRONT_RIGHT;
-       list[2] = ROARDSP_CHAN_CENTER;
-       list[3] = ROARDSP_CHAN_LFE;
-       list[4] = ROARDSP_CHAN_BACK_LEFT;
-       list[5] = ROARDSP_CHAN_BACK_RIGHT;
-      break;
-     // RoarAudio:
-     case 7:
-       list[0] = ROARDSP_CHAN_FRONT_LEFT;
-       list[1] = ROARDSP_CHAN_FRONT_RIGHT;
-       list[2] = ROARDSP_CHAN_CENTER;
-       list[3] = ROARDSP_CHAN_LFE;
-       list[4] = ROARDSP_CHAN_SIDE_LEFT;
-       list[5] = ROARDSP_CHAN_SIDE_RIGHT;
-       list[6] = ROARDSP_CHAN_BACK_CENTER;
-      break;
-     case 8:
-       list[0] = ROARDSP_CHAN_FRONT_LEFT;
-       list[1] = ROARDSP_CHAN_FRONT_RIGHT;
-       list[2] = ROARDSP_CHAN_CENTER;
-       list[3] = ROARDSP_CHAN_LFE;
-       list[4] = ROARDSP_CHAN_SIDE_LEFT;
-       list[5] = ROARDSP_CHAN_SIDE_RIGHT;
-       list[6] = ROARDSP_CHAN_BACK_LEFT;
-       list[7] = ROARDSP_CHAN_BACK_RIGHT;
-      break;
-     default:
-       return -1;
-      break;
-    }
-   break;
-  case ROARDSP_CHANLIST_MAP_VORBIS:
-    switch (channels) {
-     case 3:
-       list[0] = ROARDSP_CHAN_LEFT;
-       list[1] = ROARDSP_CHAN_CENTER;
-       list[2] = ROARDSP_CHAN_RIGHT;
-      break;
-     case 4:
-       list[0] = ROARDSP_CHAN_FRONT_LEFT;
-       list[1] = ROARDSP_CHAN_FRONT_RIGHT;
-       list[2] = ROARDSP_CHAN_BACK_LEFT;
-       list[3] = ROARDSP_CHAN_BACK_RIGHT;
-      break;
-     case 5:
-       list[0] = ROARDSP_CHAN_FRONT_LEFT;
-       list[1] = ROARDSP_CHAN_CENTER;
-       list[2] = ROARDSP_CHAN_FRONT_RIGHT;
-       list[3] = ROARDSP_CHAN_BACK_LEFT;
-       list[4] = ROARDSP_CHAN_BACK_RIGHT;
-      break;
-     case 6:
-       list[0] = ROARDSP_CHAN_FRONT_LEFT;
-       list[1] = ROARDSP_CHAN_CENTER;
-       list[2] = ROARDSP_CHAN_FRONT_RIGHT;
-       list[3] = ROARDSP_CHAN_BACK_LEFT;
-       list[4] = ROARDSP_CHAN_BACK_RIGHT;
-       list[5] = ROARDSP_CHAN_LFE;
-      break;
-     case 7:
-       list[0] = ROARDSP_CHAN_FRONT_LEFT;
-       list[1] = ROARDSP_CHAN_CENTER;
-       list[2] = ROARDSP_CHAN_FRONT_RIGHT;
-       list[3] = ROARDSP_CHAN_SIDE_LEFT;
-       list[4] = ROARDSP_CHAN_SIDE_RIGHT;
-       list[5] = ROARDSP_CHAN_BACK_CENTER;
-       list[6] = ROARDSP_CHAN_LFE;
-      break;
-     case 8:
-       list[0] = ROARDSP_CHAN_FRONT_LEFT;
-       list[1] = ROARDSP_CHAN_CENTER;
-       list[2] = ROARDSP_CHAN_FRONT_RIGHT;
-       list[3] = ROARDSP_CHAN_SIDE_LEFT;
-       list[4] = ROARDSP_CHAN_SIDE_RIGHT;
-       list[5] = ROARDSP_CHAN_BACK_LEFT;
-       list[6] = ROARDSP_CHAN_BACK_RIGHT;
-       list[7] = ROARDSP_CHAN_LFE;
-      break;
-     default:
-       return -1;
-      break;
-    }
-   break;
-  case ROARDSP_CHANLIST_MAP_OSS:
-    switch (channels) {
-     case 8:
-       list[7] = ROARDSP_CHAN_BACK_RIGHT;
-     case 7:
-       list[6] = ROARDSP_CHAN_BACK_LEFT;
-     case 6:
-       list[5] = ROARDSP_CHAN_SIDE_RIGHT;
-     case 5:
-       list[4] = ROARDSP_CHAN_SIDE_LEFT;
-     case 4:
-       list[3] = ROARDSP_CHAN_LFE;
-     case 3:
-       list[2] = ROARDSP_CHAN_CENTER;
-       list[1] = ROARDSP_CHAN_RIGHT;
-       list[0] = ROARDSP_CHAN_LEFT;
-      break;
-     default:
-       return -1;
-      break;
-    }
-   break;
-  case ROARDSP_CHANLIST_MAP_ALSA:
-    // we guess: L,R,BL,BR,C,LFE,SL,SR (really, just guessing, see ALSA plugin of libao)
-    switch (channels) {
-     case 8:
-       list[7] = ROARDSP_CHAN_BACK_RIGHT;
-     case 7:
-       list[6] = ROARDSP_CHAN_BACK_LEFT;
-     case 6:
-       list[5] = ROARDSP_CHAN_LFE;
-     case 5:
-       list[4] = ROARDSP_CHAN_CENTER;
-     case 4:
-       list[3] = ROARDSP_CHAN_BACK_RIGHT;
-     case 3:
-       list[2] = ROARDSP_CHAN_BACK_LEFT;
-       list[1] = ROARDSP_CHAN_RIGHT;
-       list[0] = ROARDSP_CHAN_LEFT;
-      break;
-     default:
-       return -1;
-      break;
-    }
-   break;
-  case ROARDSP_CHANLIST_MAP_RIFF_WAVE:
-    // here we are again, guessing:  L,R,C,LFE,BL,BR,CL,CR,BC,SL,SR
-    // strange, C, LFE on 4 channel file?
-    // return -1 to be sure....
-    switch (channels) {
-     default:
-       return -1;
-      break;
-    }
-   break;
-  default:
-    return -1;
-   break;
- }
-
- return 0;
-}
-
-int roardsp_chanmap_calc(struct roardsp_chanmap * map, int what, int err_on_none) {
- int a, b;
-
- if ( map == NULL )
-  return -1;
-
- switch (what) {
-  case ROARDSP_CHANMAP_MAP:
-    memset(map->map, (char)-1, sizeof(map->map));
-
-    for (a = 0; a < ROAR_MAX_CHANNELS; a++) {
-     if ( map->in[a] == ROARDSP_CHAN_NONE )
-      continue;
-
-     for (b = 0; b < ROAR_MAX_CHANNELS; b++) {
-      if ( map->in[a] == map->out[b] ) {
-       map->map[a] = b;
-       break;
-      }
-     }
-     if ( b == ROAR_MAX_CHANNELS ) { // src not found in dest
-      if ( err_on_none )
-       return -1;
-
-      map->map[a] = -1;
-     }
-    }
-   break;
-  case ROARDSP_CHANMAP_INVMAP:
-    memset(map->map, (char)-1, sizeof(map->map));
-
-    for (a = 0; a < ROAR_MAX_CHANNELS; a++) {
-     if ( map->out[a] == ROARDSP_CHAN_NONE )
-      continue;
-
-     for (b = 0; b < ROAR_MAX_CHANNELS; b++) {
-      if ( map->out[a] == map->in[b] ) {
-       map->map[a] = b;
-       break;
-      }
-     }
-     if ( b == ROAR_MAX_CHANNELS ) { // src not found in dest
-      if ( err_on_none )
-       return -1;
-
-      map->map[a] = -1;
-     }
-    }
-   break;
-  case ROARDSP_CHANMAP_IN:
-  case ROARDSP_CHANMAP_OUT:
-  default:
-    return -1;
-   break;
- }
-
- return 0;
-}
-
-int roardsp_chanmap_mappcm8 (char    * out, char    * in, size_t len, size_t chans, struct roardsp_chanmap * map) {
- char buf[ROAR_MAX_CHANNELS];
- size_t frame;
- size_t c;
-
- if ( len == 0 )
-  return 0;
-
- if ( out == NULL || in == NULL || map == NULL )
-  return -1;
-
- if ( chans > ROAR_MAX_CHANNELS )
-  return -1;
-
- if ( in == out ) {
-  for (frame = 0; frame < len/(chans*_8BIT); frame++) {
-   memset(buf, 0, sizeof(buf));
-
-   for (c = 0; c < chans; c++) {
-    buf[(int)map->map[c]] = in[c];
-   }
-
-   memcpy(out, buf, chans*_8BIT);
-
-   in  += chans;
-   out += chans;
-  }
- } else {
-  memset(out, 0, len); // silance channels we do not use
-  for (frame = 0; frame < len/(chans*_8BIT); frame++) {
-   for (c = 0; c < chans; c++) {
-    out[(int)map->map[c]] = in[c];
-   }
-   in  += chans;
-   out += chans;
-  }
- }
-
- return 0;
-}
-
-int roardsp_chanmap_mappcm16(int16_t * out, int16_t * in, size_t len, size_t chans, struct roardsp_chanmap * map) {
- int16_t buf[ROAR_MAX_CHANNELS];
- size_t frame;
- size_t c;
-
- if ( len == 0 )
-  return 0;
-
- if ( out == NULL || in == NULL || map == NULL )
-  return -1;
-
- if ( chans > ROAR_MAX_CHANNELS )
-  return -1;
-
- if ( in == out ) {
-  for (frame = 0; frame < len/(chans*_16BIT); frame++) {
-   memset(buf, 0, sizeof(buf));
-
-   for (c = 0; c < chans; c++) {
-    buf[(int)map->map[c]] = in[c];
-   }
-
-   memcpy(out, buf, chans*_16BIT);
-
-   in  += chans;
-   out += chans;
-  }
- } else {
-  memset(out, 0, len); // silance channels we do not use
-  for (frame = 0; frame < len/(chans*_16BIT); frame++) {
-   for (c = 0; c < chans; c++) {
-    out[(int)map->map[c]] = in[c];
-   }
-   in  += chans;
-   out += chans;
-  }
- }
-
- return 0;
-}
-
-int roardsp_chanmap_mappcm24(void    * out, void    * in, size_t len, size_t chans, struct roardsp_chanmap * map) {
- return -1;
-}
-
-int roardsp_chanmap_mappcm32(int32_t * out, int32_t * in, size_t len, size_t chans, struct roardsp_chanmap * map) {
- int32_t buf[ROAR_MAX_CHANNELS];
- size_t frame;
- size_t c;
-
- if ( len == 0 )
-  return 0;
-
- if ( out == NULL || in == NULL || map == NULL )
-  return -1;
-
- if ( chans > ROAR_MAX_CHANNELS )
-  return -1;
-
- if ( in == out ) {
-  for (frame = 0; frame < len/(chans*_32BIT); frame++) {
-   memset(buf, 0, sizeof(buf));
-
-   for (c = 0; c < chans; c++) {
-    buf[(int)map->map[c]] = in[c];
-   }
-
-   memcpy(out, buf, chans*_32BIT);
-
-   in  += chans;
-   out += chans;
-  }
- } else {
-  memset(out, 0, len); // silance channels we do not use
-  for (frame = 0; frame < len/(chans*_32BIT); frame++) {
-   for (c = 0; c < chans; c++) {
-    out[(int)map->map[c]] = in[c];
-   }
-   in  += chans;
-   out += chans;
-  }
- }
-
- return 0;
-}
-
-int roardsp_chanmap_mappcm  (void    * out, void    * in, size_t len, size_t chans, struct roardsp_chanmap * map, int bits) {
- if ( len == 0 )
-  return 0;
-
- if ( out == NULL || in == NULL || map == NULL )
-  return -1;
-
- if ( chans > ROAR_MAX_CHANNELS )
-  return -1;
-
-#if 0
- { int i;
-  printf("---- BEGIN MAP ----\n");
-  for (i = 0; i < chans; i++) {
-   printf("MAP: %i->%i\n", i, map[i]);
-  }
-  printf("---- END MAP ----\n");
- }
-#endif
-
- switch (bits) {
-  case  8: return roardsp_chanmap_mappcm8(out, in, len, chans, map);  break;
-  case 16: return roardsp_chanmap_mappcm16(out, in, len, chans, map); break;
-  case 24: return roardsp_chanmap_mappcm24(out, in, len, chans, map); break;
-  case 32: return roardsp_chanmap_mappcm32(out, in, len, chans, map); break;
-  default:
-    return -1;
-   break;
- }
-}
-
-//ll
Index: libroardsp/convert.c
===================================================================
--- libroardsp/convert.c	(revision 6052)
+++ libroardsp/convert.c	(revision 0)
@@ -1,44 +1,7 @@
 //convert.c:
 
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2015
- *      Copyright (C) Hans-Kristian 'maister' Arntzen - 2010
- *
- *  This file is part of libroar a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroar 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- *  NOTE for everyone want's to change something and send patches:
- *  read README and HACKING! There a addition information on
- *  the license of this document you need to read before you send
- *  any patches.
- *
- *  NOTE for uses of non-GPL (LGPL,...) software using libesd, libartsc
- *  or libpulse*:
- *  The libs libroaresd, libroararts and libroarpulse link this lib
- *  and are therefore GPL. Because of this it may be illigal to use
- *  them with any software that uses libesd, libartsc or libpulse*.
- */
-
-#include "libroardsp.h"
-//#define free(p) {ROAR_WARN("free(%p) = ?", (p)); free((p)); ROAR_WARN("free(%p): OK", (p));}
+#include "libroar.h"
 
 int roar_conv_bits (void * out, void * in, int samples, int from, int to) {
- int format;
-
  if ( from == to ) {
   if ( in == out )
@@ -49,18 +12,9 @@
  }
 
- format = ((from / 8) << 4) + (to / 8);
-
- switch (format) {
-  case 0x12: return roar_conv_bits_8to16( out, in, samples);
-  case 0x14: return roar_conv_bits_8to32( out, in, samples);
-  case 0x21: return roar_conv_bits_16to8( out, in, samples);
-  case 0x24: return roar_conv_bits_16to32(out, in, samples);
-  case 0x34: return roar_conv_bits_24to32(out, in, samples);
-  case 0x41: return roar_conv_bits_32to8( out, in, samples);
-  case 0x42: return roar_conv_bits_32to16(out, in, samples);
-  default:
-   errno = ENOSYS;
-   return -1;
- }
+ if ( from ==  8 && to == 16 )
+  return roar_conv_bits_8to16(out, in, samples);
+
+ if ( from == 16 && to ==  8 )
+  return roar_conv_bits_16to8(out, in, samples);
 
  return -1;
@@ -78,15 +32,4 @@
 }
 
-int roar_conv_bits_8to32  (void * out, void * in, int samples) {
- char    * ip = (char   *)in;
- int32_t * op = (int32_t*)out;
- int i;
-
- for (i = samples - 1; i >= 0; i--)
-  op[i] = (int32_t) ip[i] << 24;
-
- return 0;
-}
-
 int roar_conv_bits_16to8 (void * out, void * in, int samples) {
  int16_t * ip = (int16_t*)in;
@@ -94,6 +37,4 @@
  int i;
 
- ROAR_DBG("roar_conv_bits_16to8(out=%p, in=%p, samples=%i) = ?", out, in, samples);
-
  for (i = 0; i < samples; i++)
   op[i] = ip[i] >> 8;
@@ -102,154 +43,14 @@
 }
 
-int roar_conv_bits_16to32 (void * out, void * in, int samples) {
- int16_t * ip = (int16_t*)in;
- int32_t * op = (int32_t*)out;
- int i;
-
- for (i = samples - 1; i >= 0; i--)
-  op[i] = (int32_t) ip[i] << 16;
-
- return 0;
-}
-
-int roar_conv_bits_24to32 (void * out, void * in, int samples) {
- uint8_t * ip = (uint8_t*)in;
- int32_t * op = (int32_t*)out;
- int i;
- union {
-  int32_t i;
-  uint8_t c[4];
- } t;
-
- ROAR_DBG("roar_conv_bits_24to32(out=%p, in=%p, samples=%i) = ?", out, in, samples);
-
-#if (BYTE_ORDER == BIG_ENDIAN) || (BYTE_ORDER == LITTLE_ENDIAN)
- t.i = 0;
-#else
-  ROAR_DBG("roar_conv_bits_24to32(out=%p, in=%p, samples=%i) = -1", out, in, samples);
-  return -1;
-#endif
-
- samples--;
- ip += 3 * samples;
-
- for (i = samples; i >= 0; i--) {
-#if BYTE_ORDER == BIG_ENDIAN
-  t.c[0] = *(ip--);
-  t.c[1] = *(ip--);
-  t.c[2] = *(ip--);
-#elif BYTE_ORDER == LITTLE_ENDIAN
-  t.c[2] = *(ip--);
-  t.c[3] = *(ip--);
-  t.c[1] = *(ip--);
-#endif
-  ROAR_DBG("roar_conv_bits_24to32(*): i=%i, t.i=0x%.8X", i, t.i);
-  op[i] = t.i;
- }
-
- ROAR_DBG("roar_conv_bits_24to32(out=%p, in=%p, samples=%i) = 0", out, in, samples);
- return 0;
-}
-
-int roar_conv_bits_32to8 (void * out, void * in, int samples) {
- int32_t * ip = (int32_t*)in;
- char    * op = (char   *)out;
- int i;
-
- for (i = 0; i < samples; i++)
-  op[i] = ip[i] >> 24;
-
- return 0;
-}
-
-int roar_conv_bits_32to16 (void * out, void * in, int samples) {
- int32_t * ip = (int32_t*)in;
- int16_t * op = (int16_t*)out;
- int i;
-
- for (i = 0; i < samples; i++)
-  op[i] = ip[i] >> 16;
-
- return 0;
-}
 
 int roar_conv_chans (void * out, void * in, int samples, int from, int to, int bits) {
- if ( from == to ) {
-  if ( in == out )
-   return 0;
-
-  memcpy(out, in, samples * from * bits / 8);
-  return 0;
- }
-
- switch (bits) {
-  case 8:
-   switch (from) {
-    case 1:
-     switch (to) {
-      case  2: return roar_conv_chans_1to28(out, in, samples);
-      default: return roar_conv_chans_1ton8(out, in, samples, to);
-     }
-     break;
-    case 2:
-     switch (to) {
-      case  1: return roar_conv_chans_2to18(out, in, samples);
-      default: return -1;
-     }
-     break;
-    default:
-     switch (to) {
-      case  1: return roar_conv_chans_nto18(out, in, samples, from);
-      default: return -1;
-     }
-   }
-  break;
-  case 16:
-   switch (from) {
-    case 1:
-     switch (to) {
-      case  2: return roar_conv_chans_1to216(out, in, samples);
-      default: return roar_conv_chans_1ton16(out, in, samples, to);
-     }
-     break;
-    case 2:
-     switch (to) {
-      case  1: return roar_conv_chans_2to116(out, in, samples);
-      case  3: return roar_conv_chans_2to316(out, in, samples);
-      case  4: return roar_conv_chans_2to416(out, in, samples);
-      case  5: return roar_conv_chans_2to516(out, in, samples);
-      case  6: return roar_conv_chans_2to616(out, in, samples);
-      default: return -1;
-     }
-     break;
-    case 4:
-     switch (to) {
-      case  1: return roar_conv_chans_nto116(out, in, samples, 4);
-      case  2: return roar_conv_chans_4to216(out, in, samples);
-      default: return -1;
-     }
-     break;
-    default:
-     switch (to) {
-      case  1: return roar_conv_chans_nto116(out, in, samples, from);
-      default: return -1;
-     }
-   }
-  break;
-  case 32:
-   switch (from) {
-    case 1:
-     switch (to) {
-      default: return roar_conv_chans_1ton32(out, in, samples, to);
-     }
-     break;
-    default:
-     switch (to) {
-      case  1: return roar_conv_chans_nto132(out, in, samples, from);
-      default: return -1;
-     }
-   }
-  break;
-  default: return -1;
+ if ( from == 1 ) {
+  if ( bits == 8 ) {
+   return roar_conv_chans_1ton8(out, in, samples, to);
+  } else if ( bits == 16 ) {
+   return roar_conv_chans_1ton16(out, in, samples, to);
+  } else {
+   return -1;
+  }
  }
 
@@ -269,18 +70,4 @@
 }
 
-int roar_conv_chans_1to28  (void * out, void * in, int samples) {
- char * ip = (char*) in, * op = (char*) out;
- int i, h;
-
- samples--;
-
- for (i = (h = samples) * 2; i >= 0; i -= 2, h--) {
-  op[i + 0] = ip[h];
-  op[i + 1] = ip[h];
- }
-
- return 0;
-}
-
 int roar_conv_chans_1ton16 (void * out, void * in, int samples, int to) {
  int16_t * ip = (int16_t*) in, * op = (int16_t*) out;
@@ -295,226 +82,5 @@
 }
 
-int roar_conv_chans_1ton32 (void * out, void * in, int samples, int to) {
- int32_t * ip = (int32_t*) in, * op = (int32_t*) out;
- int i;
- int c;
-
- for (i = samples - 1; i >= 0; i--)
-  for (c = to - 1; c >= 0; c--)
-   op[i*to + c] = ip[i];
-
- return 0;
-}
-
-int roar_conv_chans_1to216 (void * out, void * in, int samples) {
- int16_t * ip = (int16_t*) in, * op = (int16_t*) out;
- int i, h;
-
- samples--;
-
- for (i = (h = samples) * 2; i >= 0; i -= 2, h--) {
-  op[i + 0] = ip[h];
-  op[i + 1] = ip[h];
- }
-
- return 0;
-}
-
-int roar_conv_chans_nto18  (void * out, void * in, int samples, int from) {
- int8_t * ip = (int8_t*) in, * op = (int8_t*) out;
- int i;
- int c;
- register int s;
-
- samples /= from;
-
- for (i = 0; i < samples; i++) {
-  s  = 0;
-
-  for (c = 0; c < from; c++)
-   s += ip[i*from + c];
-
-  s /= from;
-  op[i] = s;
- }
-
- return 0;
-}
-
-int roar_conv_chans_2to18  (void * out, void * in, int samples) {
- int8_t * ip = (int8_t*) in, * op = (int8_t*) out;
- int i, h;
-
- for (h = i = 0; i < samples; i += 2, h++)
-  op[h] = ((int)ip[i + 0] + (int)ip[i + 1]) / 2;
-
- return 0;
-}
-
-int roar_conv_chans_nto116 (void * out, void * in, int samples, int from) {
- int16_t * ip = (int16_t*) in, * op = (int16_t*) out;
- int i;
- int c;
- register int s;
-
- samples /= from;
-
- for (i = 0; i < samples; i++) {
-  s  = 0;
-
-  for (c = 0; c < from; c++)
-   s += ip[i*from + c];
-
-  s /= from;
-  op[i] = s;
- }
-
- return 0;
-}
-
-int roar_conv_chans_nto132 (void * out, void * in, int samples, int from) {
- int32_t * ip = (int32_t*) in, * op = (int32_t*) out;
- int i;
- int c;
- register int s;
-
- samples /= from;
-
- for (i = 0; i < samples; i++) {
-  s  = 0;
-
-  for (c = 0; c < from; c++)
-   s += ip[i*from + c];
-
-  s /= from;
-  op[i] = s;
- }
-
- return 0;
-}
-
-int roar_conv_chans_2to116  (void * out, void * in, int samples) {
- int16_t * ip = (int16_t*) in, * op = (int16_t*) out;
- int i, h;
-
- ROAR_DBG("roar_conv_chans_2to116(out=%p, in=%p, samples=%i) = ?", out, in, samples);
-
- for (h = i = 0; i < samples; i += 2, h++) {
-  ROAR_DBG("roar_conv_chans_2to116(out=%p, in=%p, samples=%i): op[%i] = (ip[%i] + ip[%i])/2", out, in, samples, h, i, i+1);
-  op[h] = ((int)ip[i + 0] + (int)ip[i + 1]) / 2;
- }
-
- return 0;
-}
-
-int roar_conv_chans_2to38  (void * out, void * in, int samples);
-int roar_conv_chans_2to316 (void * out, void * in, int samples) {
- int16_t * ip = (int16_t*) in, * op = (int16_t*) out;
- int i, h;
-
- samples -= 2;
-
- i  = samples;
- h  = (samples / 2) * 3;
-
- for (; i >= 0; i -= 2, h -= 3) {
-  op[h+0] = ip[i+0];
-  op[h+1] = ip[i+1];
-  op[h+2] = ((int)ip[i + 0] + (int)ip[i + 1]) / 2;
- }
-
- return 0;
-}
-
-int roar_conv_chans_2to48  (void * out, void * in, int samples);
-int roar_conv_chans_2to416 (void * out, void * in, int samples) {
- int16_t * ip = (int16_t*) in, * op = (int16_t*) out;
- int i, h;
-
- samples -= 2;
-
- i  = samples;
- h  = (samples / 2) * 4;
-
- for (; i >= 0; i -= 2, h -= 4) {
-  op[h+0] = ip[i+0];
-  op[h+1] = ip[i+1];
-  op[h+2] = ip[i+0];
-  op[h+3] = ip[i+1];
- }
-
- return 0;
-}
-
-int roar_conv_chans_2to58  (void * out, void * in, int samples);
-int roar_conv_chans_2to516 (void * out, void * in, int samples) {
- int16_t * ip = (int16_t*) in, * op = (int16_t*) out;
- int i, h;
-
- samples -= 2;
-
- i  = samples;
- h  = (samples / 2) * 5;
-
- for (; i >= 0; i -= 2, h -= 5) {
-  op[h+0] = ip[i+0];
-  op[h+1] = ip[i+1];
-  op[h+2] = ((int)ip[i + 0] + (int)ip[i + 1]) / 2;
-  op[h+3] = ip[i+0];
-  op[h+4] = ip[i+1];
- }
-
- return 0;
-}
-int roar_conv_chans_2to68  (void * out, void * in, int samples);
-int roar_conv_chans_2to616 (void * out, void * in, int samples) {
- int16_t * ip = (int16_t*) in, * op = (int16_t*) out;
- int i, h;
-
- samples -= 2;
-
- i  = samples;
- h  = (samples / 2) * 6;
-
- for (; i >= 0; i -= 2, h -= 6) {
-  op[h+0] = ip[i+0];
-  op[h+1] = ip[i+1];
-  op[h+2] = ((int)ip[i + 0] + (int)ip[i + 1]) / 2;
-  op[h+3] = op[h+2];
-  op[h+4] = ip[i+0];
-  op[h+5] = ip[i+1];
- }
-
- return 0;
-}
-
-int roar_conv_chans_3to28  (void * out, void * in, int samples);
-int roar_conv_chans_3to216 (void * out, void * in, int samples);
-int roar_conv_chans_4to28  (void * out, void * in, int samples);
-int roar_conv_chans_4to216 (void * out, void * in, int samples) {
- int16_t * ip = (int16_t*) in, * op = (int16_t*) out;
- int i, h;
-
- samples -= 4;
-
- for (i = h = 0; i < samples; i += 4, h += 2) {
-  op[h+0] = ((int)ip[i + 0] + (int)ip[i + 2]) / 2;
-  op[h+1] = ((int)ip[i + 1] + (int)ip[i + 3]) / 2;
- }
-
- return 0;
-}
-
-int roar_conv_chans_5to28  (void * out, void * in, int samples);
-int roar_conv_chans_5to216 (void * out, void * in, int samples);
-int roar_conv_chans_6to28  (void * out, void * in, int samples);
-int roar_conv_chans_6to216 (void * out, void * in, int samples);
-
-
-
 int roar_conv_rate (void * out, void * in, int samples, int from, int to, int bits, int channels) {
-#ifdef ROAR_HAVE_LIBSAMPLERATE
- return roar_conv_rate_SRC(out, in, samples, from, to, bits, channels);
-#else
  if ( bits == 8  )
   return roar_conv_rate_8(out, in, samples, from, to, channels);
@@ -524,5 +90,4 @@
 
  return -1;
-#endif
 }
 
@@ -530,208 +95,75 @@
  return -1;
 }
-
 int roar_conv_rate_16 (void * out, void * in, int samples, int from, int to, int channels) {
- if ( from > to ) {
-  switch (channels) {
-   case 1:
-     return roar_conv_rate_161zoh(out, in, samples, from, to);
-   case 2:
-     return roar_conv_rate_162zoh(out, in, samples, from, to);
-   default:
-     return -1;
-  }
+ int16_t * ip = in, * op = out;
+ int16_t avg;
+ int i, j, c;
+ float scale = to/from;
+ int step;
+
+
+ if ( scale > 1 ) {
+  if ( scale - (int)scale != (float)0 )
+   return -1;
+
+  step = scale;
+/*
+  for (i = 0; i < samples/step; i++)
+   for (j = 0; j < step; j++)
+    for (c = 0; c < channels; c++)
+     op[i + j*channels + c] = ip[i + c];
+*/
+  if ( step == 2 ) {
+   for (i = 0; i < samples/step; i += channels) {
+    for (j = 0; j < step; j++) {
+     for (c = 0; c < channels; c++) {
+      op[i*step + j*channels + c] = ip[i+c];
+     }
+    }
+   }
+   return 0;
+  }
+  return -1;
  } else {
-  if ( channels == 1 ) {
-   printf("roar_conv_rate_16(): samples=%i -> %i, rate=%i -> %i\n", samples*from/to, samples, from, to);
-   return roar_conv_poly4_16s((int16_t*) out, (int16_t*) in, samples, samples*from/to, (float)from/to);
- //  return roar_conv_poly4_16((int16_t*) out, (int16_t*) in, samples*to/from, samples);
-  }
- }
-
- return -1;
-}
-
-int roar_conv_rate_161zoh(void * out, void * in, int samples, int from, int to) {
- int16_t * ip = in;
- int16_t * op = out;
- float t = 0;
- float step = (float)to/from;
- int i;
-
- for (i= 0; i < samples; i++) {
-  op[(int)t] = ip[i];
-  t += step;
- }
-
- return 0;
-}
-
-int roar_conv_rate_162zoh(void * out, void * in, int samples, int from, int to) {
- int16_t * ip = in;
- int16_t * op = out;
- float t = 0;
- float step = (float)to/from;
- int i;
-
- ROAR_DBG("roar_conv_rate_162zoh(*): samples=%i", samples);
- samples /= 2;
-// samples -= 1;
- ROAR_DBG("roar_conv_rate_162zoh(*): samples=%i", samples);
-
- for (i= 0; i < samples; i++) {
-  ROAR_DBG("roar_conv_rate_162zoh(*): t=%f, i=%i // op[%i] = ip[%i]", t, i, 2*(int)t, 2*i);
-  op[2*(int)t    ] = ip[2*i    ];
-  op[2*(int)t + 1] = ip[2*i + 1];
-  t += step;
- }
-
- return 0;
-}
-
-int roar_conv_rate_SRC   (void * out, void * in, int samples, int from, int to, int bits, int channels) {
-#ifdef ROAR_HAVE_LIBSAMPLERATE
- double radio = (double) to / (double) from;
- int outsamples = radio * samples;
- float * inf  = roar_mm_malloc(samples*sizeof(float));
- float * outf = roar_mm_malloc(outsamples*sizeof(float));
- int i;
- SRC_DATA srcdata;
-
- ROAR_DBG("roar_conv_rate_SRC(*): radio=%lf, samples=%i, outsamples=%i", radio, samples, outsamples);
-
- if ( inf == NULL ) {
-  if ( outf != NULL )
-   roar_mm_free(outf);
-
+  scale = 1/scale;
+
+  if ( scale - (int)scale != (float)0 )
+   return -1;
+
+  step = scale;
+
+  for (i = 0; i < samples/step; i++) {
+   avg = 0;
+   for (j = 0; j < step; j++)
+    avg += ip[i*step + j];
+
+   op[i] = avg/step;
+  }
+  return 0;
+ } 
+
+ return -1;
+}
+
+int raor_conv_codec (void * out, void * in, int samples, int from, int to, int bits) {
+ int inbo = ROAR_CODEC_BYTE_ORDER(from), outbo = ROAR_CODEC_BYTE_ORDER(to);
+ int ins  = ROAR_CODEC_IS_SIGNED(from),  outs  = ROAR_CODEC_IS_SIGNED(to);
+
+ if ( inbo != outbo )
   return -1;
- }
-
- if ( outf == NULL ) {
-  if ( inf != NULL )
-   roar_mm_free(inf);
-
-  return -1;
- }
-
- switch (bits) {
-  case  8:
-    for (i = 0; i < samples; i++)
-     inf[i] = *(((int8_t *)in)+i) / 128.0;
-   break;
-  case 16:
-    for (i = 0; i < samples; i++)
-     inf[i] = *(((int16_t*)in)+i) / 32768.0;
-   break;
-  case 32:
-    for (i = 0; i < samples; i++)
-     inf[i] = *(((int32_t*)in)+i) / 2147483648.0;
-   break;
-  default:
-    roar_mm_free(outf);
-    roar_mm_free(inf);
+
+ if ( ins != outs ) {
+  if ( ins && !outs ) {
+   if ( bits == 8 ) {
+    roar_conv_codec_s2u8(out, in, samples);
+   } else {
     return -1;
- }
-
- srcdata.data_in       = inf;
- srcdata.data_out      = outf;
- srcdata.input_frames  = samples/channels;
- srcdata.output_frames = outsamples/channels;
- srcdata.src_ratio     = radio;
-
- if ( src_simple(&srcdata, SRC_ZERO_ORDER_HOLD, channels) != 0 ) {
-  roar_mm_free(outf);
-  roar_mm_free(inf);
-  return -1;
- }
-
- switch (bits) {
-  case  8:
-    for (i = 0; i < outsamples; i++)
-     *(((int8_t *)out)+i) = outf[i] * 128.0;
-   break;
-  case 16:
-    for (i = 0; i < outsamples; i++)
-     *(((int16_t*)out)+i) = outf[i] * 32768.0;
-   break;
-  case 32:
-    for (i = 0; i < outsamples; i++)
-     *(((int32_t*)out)+i) = outf[i] * 2147483648.0;
-   break;
-   // no errors here, they are handled above
- }
-
- roar_mm_free(outf);
- roar_mm_free(inf);
-
- return 0;
-#else
- return -1;
-#endif
-}
-
-int roar_conv_rate2      (void * out, void * in, int outsamples, int samples, int bits, int channels) {
- ROAR_DBG("roar_conv_rate2(out=%p, in=%p, samples=%i, outsamples=%i, bits=%i, channels=%i) = ?", out, in, samples, outsamples, bits, channels);
- switch (bits) {
-  case  8:
-    return roar_conv_poly3_8(out, in, outsamples, samples, channels);
-   break;
-  case 16:
-    return roar_conv_poly3_16(out, in, outsamples, samples, channels);
-   break;
-  case 32:
-    return roar_conv_poly3_32(out, in, outsamples, samples, channels);
-   break;
- }
- return -1;
-}
-
-int roar_conv_signedness  (void * out, void * in, int samples, int from, int to, int bits) {
-
- if ( from != to ) {
-  if ( from && !to ) {
-   switch (bits) {
-    case  8: roar_conv_codec_s2u8( out, in, samples); break;
-    case 16: roar_conv_codec_s2u16(out, in, samples); break;
-    case 32: roar_conv_codec_s2u32(out, in, samples); break;
-    default:
-     errno = ENOSYS;
-     return -1;
-   }
-  } else if ( !from && to ) {
-   switch (bits) {
-    case  8: roar_conv_codec_u2s8( out, in, samples); break;
-    case 16: roar_conv_codec_u2s16(out, in, samples); break;
-    case 32: roar_conv_codec_u2s32(out, in, samples); break;
-    default:
-     errno = ENOSYS;
-     return -1;
    }
   } else {
    return -1;
   }
- } else {
-  if ( out == in )
-   return 0;
-
-  memcpy(out, in, samples * bits / 8);
-  return 0;
- }
-
- return 0;
-}
-
-int roar_conv_codec (void * out, void * in, int samples, int from, int to, int bits) {
- int inbo = ROAR_CODEC_BYTE_ORDER(from), outbo = ROAR_CODEC_BYTE_ORDER(to);
- int ins  = ROAR_CODEC_IS_SIGNED(from),  outs  = ROAR_CODEC_IS_SIGNED(to);
- void * nin = in;
-
-
- ROAR_DBG("roar_conv_codec(out=%p, in=%p, samples=%i, from=%i(%s), to=%i(%s), bits=%i) = ?",
-              out, in, samples, from, roar_codec2str(from), to, roar_codec2str(to), bits);
-
- roar_conv_endian(out, in, samples, inbo, outbo, bits);
- nin = out;
-
- return roar_conv_signedness(out, in, samples, ins, outs, bits);
+ }
+
+ return 0;
 }
 
@@ -747,204 +179,7 @@
 }
 
-int roar_conv_codec_s2u16 (void * out, void * in, int samples) {
- int16_t  * ip = in;
- uint16_t * op = out;
- int i;
-
- for(i = 0; i < samples; i++)
-  op[i] = ip[i] + 32768;
-
- return 0;
-}
-
-int roar_conv_codec_s2u32 (void * out, void * in, int samples) {
- int32_t  * ip = in;
- uint32_t * op = out;
- int i;
-
- for(i = 0; i < samples; i++)
-  op[i] = ip[i] + 2147483648U;
-
- return 0;
-}
-
-int roar_conv_codec_u2s8 (void * out, void * in, int samples) {
- unsigned char * ip = in;
-          char * op = out;
- int i;
-
- for(i = 0; i < samples; i++)
-  op[i] = ip[i] - 128;
-
- return 0;
-}
-
-int roar_conv_codec_u2s16 (void * out, void * in, int samples) {
- uint16_t  * ip = in;
- int16_t   * op = out;
- int i;
-
- for(i = 0; i < samples; i++)
-  op[i] = ip[i] - 32768;
-
- return 0;
-}
-
-int roar_conv_codec_u2s32 (void * out, void * in, int samples) {
- uint32_t  * ip = in;
- int32_t   * op = out;
- int i;
-
- for(i = 0; i < samples; i++)
-  op[i] = ip[i] - 2147483648U;
-
- return 0;
-}
-
-
-int roar_conv_endian      (void * out, void * in, int samples, int from, int to, int bits) {
-
- if ( bits == 8 ) {
-  from = to = ROAR_CODEC_NATIVE_ENDIAN;
-
- } else if ( bits == 16 ) {
-  if ( from  == ROAR_CODEC_PDP )
-   from = ROAR_CODEC_LE;
-  if ( to    == ROAR_CODEC_PDP )
-   to   = ROAR_CODEC_LE;
- }
-
- ROAR_DBG("roar_conv_endian(out=%p, in=%p, samples=%i, from=%i, to=%i, bits=%i) = ?", out, in, samples, from, to, bits);
-
- if ( from == to ) {
-  if ( in != out ) {
-   memcpy(out, in, samples * bits / 8);
-  }
-  return 0;
- } else {
-  switch (bits) {
-   case 16:
-     // in this case we can only have LE vs. BE, so, only need to swap:
-     ROAR_DBG("roar_conv_endian(*): Doing 16 bit byteswap");
-     return roar_conv_endian_16(out, in, samples);
-    break;
-   case 24:
-     if ( (from == ROAR_CODEC_LE || from == ROAR_CODEC_BE) && (to == ROAR_CODEC_LE || to == ROAR_CODEC_BE) ) {
-      return roar_conv_endian_24(out, in, samples);
-     } else { // what the hell is PDP eddines in 24 bit mode?
-      return -1;
-     }
-    break;
-   case 32:
-    if ( (from == ROAR_CODEC_LE || from == ROAR_CODEC_BE) && (to == ROAR_CODEC_LE || to == ROAR_CODEC_BE) ) {
-     return roar_conv_endian_32(out, in, samples);
-    } else { // need to handle 32 PDP eddines here?
-     if ( from == ROAR_CODEC_BE )
-      if ( roar_conv_endian_32(out, in, samples) == -1 )
-       return -1;
-
-     if ( roar_conv_endian_16(out, in, samples*2) == -1 )
-      return -1;
-
-     if ( to == ROAR_CODEC_BE )
-      if ( roar_conv_endian_32(out, in, samples) == -1 )
-       return -1;
-
-     return 0;
-    }
-    break;
-   default:
-     return -1;
-    break;
-  }
- }
-
- return -1;
-}
-
-
-int roar_conv_endian_16   (void * out, void * in, int samples) {
- char          * ip = in;
- char          * op = out;
- register char   c;
- int             i;
-
- samples *= 2;
-
- if ( out != in ) {
-//  printf("out != in\n");
-  for(i = 0; i < samples; i += 2) {
-//   printf("op[%i] = ip[%i]\nop[%i] = ip[%i]\n", i, i+1, i+1, i);
-   op[i  ] = ip[i+1];
-   op[i+1] = ip[i  ];
-  }
- } else {
-//  printf("out == in\n");
-  for(i = 0; i < samples; i += 2) {
-   c       = ip[i+1];
-   op[i+1] = ip[i  ];
-   op[i  ] = c;
-  }
- }
-
- return 0;
-}
-
-int roar_conv_endian_24   (void * out, void * in, int samples) {
- char          * ip = in;
- char          * op = out;
- register char   c;
- int             i;
-
- samples *= 3;
-
- if ( out != in ) {
-//  printf("out != in\n");
-  for(i = 0; i < samples; i += 3) {
-//   printf("op[%i] = ip[%i]\nop[%i] = ip[%i]\n", i, i+1, i+1, i);
-   op[i  ] = ip[i+2];
-   op[i+2] = ip[i  ];
-  }
- } else {
-//  printf("out == in\n");
-  for(i = 0; i < samples; i += 3) {
-   c       = ip[i+2];
-   op[i+2] = ip[i  ];
-   op[i  ] = c;
-  }
- }
-
- return 0;
-}
-
-int roar_conv_endian_32   (void * out, void * in, int samples) {
- int32_t       * ip = in;
- int32_t       * op = out;
- union {
-  int32_t val;
-  char    data[4];
- }               c, h;
- int             i;
-
- // may the holly optimizer save our souls!
-
- ROAR_DBG("roar_conv_endian_32(out=%p, in=%p, samples=%i) = ?", out, in, samples);
-
- for (i = 0; i < samples; i++) {
-  c.val     = ip[i];
-  h.data[0] = c.data[3];
-  h.data[1] = c.data[2];
-  h.data[2] = c.data[1];
-  h.data[3] = c.data[0];
-  op[i]     = h.val;
- }
-
- return 0;
-}
 
 int roar_conv       (void * out, void * in, int samples, struct roar_audio_info * from, struct roar_audio_info * to) {
  void * ip = in;
- void * real_out = NULL;
- size_t from_size, to_size;
 
  // TODO: decide how to work around both in and out beeing to small to hold all
@@ -952,320 +187,27 @@
  //       for the moment: guess out >= in
 
- from_size = (from->bits * samples) / 8;
- to_size   = (  to->bits * samples * to->rate * to->channels) / (8 * from->rate * from->channels);
-
- ROAR_DBG("roar_conv(*): size: %i->%i", from_size, to_size);
-
- if ( to_size < from_size ) {
-  real_out = out;
-
-  if ( (out = roar_mm_malloc(from_size)) == NULL )
-   return -1;
-
-  ROAR_DBG("roar_conv(*): roar_mm_malloc(%i)=%p", (int)from_size, out);
- }
-
- ROAR_DBG("roar_conv(*): bo conv: %i->%i(native)", ROAR_CODEC_BYTE_ORDER(from->codec), ROAR_CODEC_NATIVE_ENDIAN);
-
- if ( ROAR_CODEC_BYTE_ORDER(from->codec) != ROAR_CODEC_NATIVE_ENDIAN ) {
-  ROAR_DBG("roar_conv(*): doing bo input conv");
-  if ( roar_conv_endian(out, ip, samples, ROAR_CODEC_BYTE_ORDER(from->codec), ROAR_CODEC_NATIVE_ENDIAN, from->bits) == -1 ) {
-   if ( to_size < from_size )
-    roar_mm_free(out);
-   return -1;
-  } else {
-   ip = out;
-  }
- }
-
  if ( from->bits != to->bits ) {
-  if ( roar_conv_bits(out, ip, samples, from->bits, to->bits) == -1 ) {
-   if ( to_size < from_size )
-    roar_mm_free(out);
-   return -1;
-  } else {
-   ip = out;
-  }
- }
-
- if ( ROAR_CODEC_IS_SIGNED(from->codec) != ROAR_CODEC_IS_SIGNED(to->codec) ) {
-  if ( roar_conv_signedness(out, ip, samples, ROAR_CODEC_IS_SIGNED(from->codec), ROAR_CODEC_IS_SIGNED(to->codec), to->bits) == -1 ) {
-   if ( to_size < from_size )
-    roar_mm_free(out);
-   return -1;
-  } else {
-   ip = out;
-  }
- }
-
-/*
- if ( from->codec != to->codec ) {
-  if ( roar_conv_codec (out, ip, samples, from->codec, to->codec, to->bits) == -1 )
+  if ( roar_conv_bits(out, ip, samples, from->bits, to->bits) == -1 )
    return -1;
   else
    ip = out;
  }
-*/
+
+ if ( from->channels != to->channels ) {
+  if ( roar_conv_chans(out, ip, samples, from->channels, to->channels, to->bits) == -1 )
+   return -1;
+  else
+   ip = out;
+ }
 
  if ( from->rate != to->rate ) {
-  if ( roar_conv_rate(out, ip, samples, from->rate, to->rate, to->bits, from->channels) == -1 ) {
-   ROAR_DBG("roar_conv(*): failed to convert rate %i->%i (%ich%ibits)", from->rate, to->rate, to->bits, from->channels);
-   if ( to_size < from_size )
-    roar_mm_free(out);
-   return -1;
-  } else {
+  if ( roar_conv_rate(out, ip, samples, from->rate, to->rate, to->bits, to->channels) == -1 )
+   return -1;
+  else
    ip = out;
-   samples = (samples * to->rate) / from->rate;
-  }
- }
-
- if ( from->channels != to->channels ) {
-  if ( roar_conv_chans(out, ip, samples, from->channels, to->channels, to->bits) == -1 ) {
-   if ( to_size < from_size )
-    roar_mm_free(out);
-   return -1;
-  } else {
-   ip = out;
-  }
- }
-
- if ( ROAR_CODEC_BYTE_ORDER(to->codec) != ROAR_CODEC_NATIVE_ENDIAN ) {
-  if ( roar_conv_endian(out, ip, samples, ROAR_CODEC_NATIVE_ENDIAN, ROAR_CODEC_BYTE_ORDER(to->codec), to->bits) == -1 ) {
-   if ( to_size < from_size )
-    roar_mm_free(out);
-   return -1;
-  } else {
-   ip = out;
-  }
- }
-
- if ( to_size < from_size ) {
-  ROAR_DBG("roar_conv(*): memcpy(%p, %p, %i) = ?", real_out, out, (int)to_size);
-  memcpy(real_out, out, to_size);
-  roar_mm_free(out);
-  ROAR_DBG("roar_conv(*): free(%p): OK!", out);
- }
-
- return 0;
-}
-
-int roar_conv2(void * out, void * in,
-               size_t inlen,
-               struct roar_audio_info * from, struct roar_audio_info * to,
-               size_t bufsize) {
- size_t samples;
-// size_t needed_buffer;
- void   * cin = in;
- struct roar_audio_info cinfo;
- int    need_signed = 0;
- size_t outsamples;
-
- memcpy(&cinfo, from, sizeof(cinfo));
-
- ROAR_DBG("roar_conv2(out=%p, in=%p, inlen=%lu, from=%p{...}, to=%p{...}, bufsize=%lu", out, in, (unsigned long int)inlen, from, to, (unsigned long int)bufsize);
-
-/*
- if ( in != out ) {
-  memset(out, 0xA0, bufsize);
- } else {
-  ROAR_WARN("roar_conv2(*): in==out!");
-  memset(out+inlen, 0xA0, bufsize-inlen);
- }
-*/
-
- // calculate number of input samples:
- samples = (inlen * 8) / (from->bits);
-
- ROAR_DBG("roar_conv2(*): input samples: %i", samples);
-
-#if 0
- // calculate size per frame
- needed_buffer  = ROAR_MAX(from->channels, to->channels) * ROAR_MAX(from->bits, to->bits) / 8;
-
- needed_buffer *= samples;
- needed_buffer /= from->channels;
-
- if ( from->rate < to->rate )
-  needed_buffer *= (float)to->rate/(float)from->rate;
-
- ROAR_DBG("roar_conv2(*): needed_buffer=%u, bufsize=%u", needed_buffer, bufsize);
-
- // check if we have enogth RAM to convert
- if ( needed_buffer > bufsize )
+ }
+
+ if ( from->codec != to->codec )
   return -1;
-#endif
-
- if ( from->rate != to->rate || from->channels != to->channels )
-  need_signed = 1;
-
-  ROAR_DBG("roar_conv2(*): need_signed=%i", need_signed);
-
- if ( ROAR_CODEC_BYTE_ORDER(from->codec) != ROAR_CODEC_NATIVE_ENDIAN ) {
-  ROAR_DBG("roar_conv2(*): doing bo input conv");
-  if ( roar_conv_endian(out, cin, samples,
-       ROAR_CODEC_BYTE_ORDER(from->codec), ROAR_CODEC_NATIVE_ENDIAN, from->bits) == -1 ) {
-   return -1;
-  }
-  cin = out;
- }
-
- if ( to->bits > from->bits ) {
-  ROAR_DBG("roar_conv2(*): bits: %i->%i", from->bits, to->bits);
-  if ( roar_conv_bits(out, cin, samples, from->bits, to->bits) == -1 )
-   return -1;
-
-  cin        = out;
-  cinfo.bits = to->bits;
- }
-
- if ( need_signed && ! ROAR_CODEC_IS_SIGNED(from->codec) ) {
-  ROAR_DBG("roar_conv2(*): sign: unsigned->signed");
-  if ( roar_conv_signedness(out, cin, samples,
-                            ROAR_CODEC_IS_SIGNED(from->codec), ROAR_CODEC_IS_SIGNED(to->codec),
-                            cinfo.bits) == -1 )
-   return -1;
-
-  cin            = out;
-  cinfo.codec    = ROAR_CODEC_PCM_S_LE; // just a signed PCM, which is of no intrest
- }
-
- if ( to->channels > from->channels ) {
-  ROAR_DBG("roar_conv2(*): channels: %i->%i", from->channels, to->channels);
-  if ( roar_conv_chans(out, cin, samples, from->channels, to->channels, cinfo.bits) == -1 )
-   return -1;
-
-  cin            = out;
-  samples        = (samples * to->channels) / cinfo.channels;
-  cinfo.channels = to->channels;
- }
-
-//--//
- if ( from->rate != to->rate ) {
-  outsamples = bufsize;
-
-  ROAR_DBG("roar_conv2(*): outsamples=%llu", (long long unsigned int)outsamples);
-
-  if ( cinfo.channels != to->channels ) {
-   outsamples *= cinfo.channels;
-   outsamples /= to->channels;
-  }
-
-  if ( cinfo.bits != to->bits ) {
-   outsamples *= cinfo.bits;
-   outsamples /= to->bits;
-  }
-
-  outsamples /= cinfo.bits/8;
-
-  ROAR_DBG("roar_conv2(*): outsamples=%llu", (long long unsigned int)outsamples);
-
-  if ( roar_conv_rate2(out, cin, outsamples, samples, cinfo.bits, cinfo.channels) == -1 )
-   return -1;
-
-  cin            = out;
-  samples        = outsamples;
-  cinfo.rate     = to->rate;
- }
-
- if ( cinfo.channels != to->channels ) {
-  ROAR_DBG("roar_conv2(*): channels: %i->%i", cinfo.channels, to->channels);
-  if ( roar_conv_chans(out, cin, samples, cinfo.channels, to->channels, cinfo.bits) == -1 )
-   return -1;
-
-  cin            = out;
-  samples        = (samples * to->channels) / cinfo.channels;
-  cinfo.channels = to->channels;
- }
-
- if ( ROAR_CODEC_IS_SIGNED(cinfo.codec) != ROAR_CODEC_IS_SIGNED(to->codec) ) {
-  ROAR_DBG("roar_conv2(*): sign: ?(%i)->?(%i)", ROAR_CODEC_IS_SIGNED(cinfo.codec), ROAR_CODEC_IS_SIGNED(to->codec));
-  if ( roar_conv_signedness(out, cin, samples,
-                            ROAR_CODEC_IS_SIGNED(cinfo.codec), ROAR_CODEC_IS_SIGNED(to->codec),
-                            cinfo.bits) == -1 )
-   return -1;
-
-  cin            = out;
-  cinfo.codec    = to->codec;
- }
-
- if ( cinfo.bits != to->bits ) {
-  ROAR_DBG("roar_conv2(*): bits: %i->%i", cinfo.bits, to->bits);
-  if ( roar_conv_bits(out, cin, samples, cinfo.bits, to->bits) == -1 )
-   return -1;
-
-  cin        = out;
-  cinfo.bits = to->bits;
- }
-
- if ( ROAR_CODEC_BYTE_ORDER(to->codec) != ROAR_CODEC_NATIVE_ENDIAN ) {
-  ROAR_DBG("roar_conv2(*): doing bo output conv");
-  if ( roar_conv_endian(out, cin, samples,
-       ROAR_CODEC_NATIVE_ENDIAN, ROAR_CODEC_BYTE_ORDER(to->codec), to->bits) == -1 ) {
-   return -1;
-  }
-  cin = out;
- }
-
- ROAR_DBG("roar_conv2(*): samples=%llu", (long long unsigned int)samples);
-
- ROAR_DBG("roar_conv2(*) = 0");
- return 0;
-}
-
-int roar_conv_poly4_16 (int16_t * out, int16_t * in, size_t olen, size_t ilen) {
- return roar_conv_poly4_16s(out, in, olen, ilen, (float)ilen/olen);
-}
-
-int roar_conv_poly4_16s (int16_t * out, int16_t * in, size_t olen, size_t ilen, float step) {
- float poly[4];
- float data[4];
- float t    = 0;
- int16_t * ci = in;
- int io, ii = 0;
- int i;
-
-// printf("step=%f\n", step);
-
- // we can not make a poly4 with less than 4 points ;)
- if ( ilen < 4 )
-  return -1;
-
- for (i = 0; i < 4; i++)
-  data[i] = ci[i];
- roar_math_mkpoly_4x4(poly, data);
-/*
- printf("new poly: data[4] = {%f, %f, %f, %f}, poly[4] = {%f, %f, %f, %f}\n",
-         data[0], data[1], data[2], data[3],
-         poly[0], poly[1], poly[2], poly[3]
-       );
-*/
-
- //0 1 2 3
-
- for (io = 0; io < olen; io++) {
-//  printf("t=%f\n", t);
-  out[io] = roar_math_cvpoly_4x4(poly, t);
-  t += step;
-  if ( t > 2 ) { // we need a new ploynome
- //  printf("t > 2, need new data\n");
-   if ( (ii + 4) < ilen ) { // else: end of block.
-    t -= 1;
-//    printf("new data: ii=%i\n", ii);
-    ii++;
-    ci++;
-    for (i = 0; i < 4; i++)
-     data[i] = ci[i];
-    roar_math_mkpoly_4x4(poly, data);
-/* 
-   printf("new poly: data[4] = {%f, %f, %f, %f}, poly[4] = {%f, %f, %f, %f}\n",
-           data[0], data[1], data[2], data[3],
-           poly[0], poly[1], poly[2], poly[3]
-          );
-*/
-   }
-  }
- }
-
-// printf("io=%i\n", io);
 
  return 0;
Index: libroardsp/dtmf.c
===================================================================
--- libroardsp/dtmf.c	(revision 6052)
+++ 	(revision )
@@ -1,260 +1,0 @@
-//dtmf.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2012-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-#include "libroardsp.h"
-
-ssize_t roar_dtmf_mus2samples(const int_least32_t t, const uint32_t rate) {
- int64_t ret = t;
-
- if ( t < 0 || rate == 0 ) {
-  roar_err_set(ROAR_ERROR_INVAL);
-  return -1;
- }
-
- ret *= (int64_t)rate;
- ret /= (int64_t)1000000;
-
- return ret;
-}
-
-int roar_dtmf_break(int16_t * samples, const size_t len, const uint32_t rate, const int options) {
- (void)rate, (void)options;
-
- ROAR_DBG("roar_dtmf_break(samples=%p, len=%llu, rate=%lu, options=%i) = ?", samples, (long long unsigned int)len, (long unsigned int)rate, options);
-
- if ( samples == NULL ) {
-  roar_err_set(ROAR_ERROR_FAULT);
-  return -1;
- }
-
- memset(samples, 0, len*sizeof(int16_t));
-
- return 0;
-}
-
-#define _FQL0 697
-#define _FQL1 770
-#define _FQL2 852
-#define _FQL3 941
-#define _FQH0 1209
-#define _FQH1 1336
-#define _FQH2 1477
-#define _FQH3 1633
-
-#define _FRL0 571
-#define _FRL1 631
-#define _FRL2 _FQL0
-#define _FRL3 _FQL1
-#define _FRL4 _FQL2
-#define _FRL5 _FQL3
-#define _FRL6 1040
-#define _FRH0 _FQH0
-#define _FRH1 _FQH1
-#define _FRH2 _FQH2
-#define _FRH3 _FQH3
-#define _FRH4 1805
-#define _FRH5 1995
-#define _FRH6 2205
-
-static const struct tone {
- const uint16_t c;
- const float f0;
- const float f1;
-} _roardsp_tones[] = {
- {ROAR_DTMF_CHAR_DTMF('1'), _FQL0, _FQH0},
- {ROAR_DTMF_CHAR_DTMF('2'), _FQL0, _FQH1},
- {ROAR_DTMF_CHAR_DTMF('3'), _FQL0, _FQH2},
- {ROAR_DTMF_CHAR_DTMF('A'), _FQL0, _FQH3},
-
- {ROAR_DTMF_CHAR_DTMF('4'), _FQL1, _FQH0},
- {ROAR_DTMF_CHAR_DTMF('5'), _FQL1, _FQH1},
- {ROAR_DTMF_CHAR_DTMF('6'), _FQL1, _FQH2},
- {ROAR_DTMF_CHAR_DTMF('B'), _FQL1, _FQH3},
-
- {ROAR_DTMF_CHAR_DTMF('7'), _FQL2, _FQH0},
- {ROAR_DTMF_CHAR_DTMF('8'), _FQL2, _FQH1},
- {ROAR_DTMF_CHAR_DTMF('9'), _FQL2, _FQH2},
- {ROAR_DTMF_CHAR_DTMF('C'), _FQL2, _FQH3},
-
- {ROAR_DTMF_CHAR_DTMF('*'), _FQL3, _FQH0},
- {ROAR_DTMF_CHAR_DTMF('0'), _FQL3, _FQH1},
- {ROAR_DTMF_CHAR_DTMF('#'), _FQL3, _FQH2},
- {ROAR_DTMF_CHAR_DTMF('D'), _FQL3, _FQH3},
-
-
- {ROAR_DTMF_CHAR_NOOP,   _FRL0, _FRH0},
- {ROAR_DTMF_CHAR_ESCAPE, _FRL0, _FRH1},
-
- {ROAR_DTMF_CHAR_ROAR('"'), _FRL0, _FRH2},
- {ROAR_DTMF_CHAR_ROAR(' '), _FRL0, _FRH3},
- {ROAR_DTMF_CHAR_ROAR('F'), _FRL0, _FRH4},
- {ROAR_DTMF_CHAR_ROAR('M'), _FRL0, _FRH5},
- {ROAR_DTMF_CHAR_ROAR('T'), _FRL0, _FRH6},
- {ROAR_DTMF_CHAR_ROAR('.'), _FRL1, _FRH0},
- {ROAR_DTMF_CHAR_ROAR('?'), _FRL1, _FRH1},
- {ROAR_DTMF_CHAR_ROAR('!'), _FRL1, _FRH2},
- {ROAR_DTMF_CHAR_ROAR(','), _FRL1, _FRH3},
- {ROAR_DTMF_CHAR_ROAR('G'), _FRL1, _FRH4},
- {ROAR_DTMF_CHAR_ROAR('N'), _FRL1, _FRH5},
- {ROAR_DTMF_CHAR_ROAR('U'), _FRL1, _FRH6},
- {ROAR_DTMF_CHAR_ROAR('1'), _FRL2, _FRH0},
- {ROAR_DTMF_CHAR_ROAR('2'), _FRL2, _FRH1},
- {ROAR_DTMF_CHAR_ROAR('3'), _FRL2, _FRH2},
- {ROAR_DTMF_CHAR_ROAR('A'), _FRL2, _FRH3},
- {ROAR_DTMF_CHAR_ROAR('H'), _FRL2, _FRH4},
- {ROAR_DTMF_CHAR_ROAR('O'), _FRL2, _FRH5},
- {ROAR_DTMF_CHAR_ROAR('V'), _FRL2, _FRH6},
- {ROAR_DTMF_CHAR_ROAR('4'), _FRL3, _FRH0},
- {ROAR_DTMF_CHAR_ROAR('5'), _FRL3, _FRH1},
- {ROAR_DTMF_CHAR_ROAR('6'), _FRL3, _FRH2},
- {ROAR_DTMF_CHAR_ROAR('B'), _FRL3, _FRH3},
- {ROAR_DTMF_CHAR_ROAR('I'), _FRL3, _FRH4},
- {ROAR_DTMF_CHAR_ROAR('P'), _FRL3, _FRH5},
- {ROAR_DTMF_CHAR_ROAR('W'), _FRL3, _FRH6},
- {ROAR_DTMF_CHAR_ROAR('7'), _FRL4, _FRH0},
- {ROAR_DTMF_CHAR_ROAR('8'), _FRL4, _FRH1},
- {ROAR_DTMF_CHAR_ROAR('9'), _FRL4, _FRH2},
- {ROAR_DTMF_CHAR_ROAR('C'), _FRL4, _FRH3},
- {ROAR_DTMF_CHAR_ROAR('J'), _FRL4, _FRH4},
- {ROAR_DTMF_CHAR_ROAR('Q'), _FRL4, _FRH5},
- {ROAR_DTMF_CHAR_ROAR('X'), _FRL4, _FRH6},
- {ROAR_DTMF_CHAR_ROAR('*'), _FRL5, _FRH0},
- {ROAR_DTMF_CHAR_ROAR('0'), _FRL5, _FRH1},
- {ROAR_DTMF_CHAR_ROAR('#'), _FRL5, _FRH2},
- {ROAR_DTMF_CHAR_ROAR('D'), _FRL5, _FRH3},
- {ROAR_DTMF_CHAR_ROAR('K'), _FRL5, _FRH4},
- {ROAR_DTMF_CHAR_ROAR('R'), _FRL5, _FRH5},
- {ROAR_DTMF_CHAR_ROAR('Y'), _FRL5, _FRH6},
- {ROAR_DTMF_CHAR_ROAR('@'), _FRL6, _FRH0},
- {ROAR_DTMF_CHAR_ROAR('+'), _FRL6, _FRH1},
- {ROAR_DTMF_CHAR_ROAR('-'), _FRL6, _FRH2},
- {ROAR_DTMF_CHAR_ROAR('E'), _FRL6, _FRH3},
- {ROAR_DTMF_CHAR_ROAR('L'), _FRL6, _FRH4},
- {ROAR_DTMF_CHAR_ROAR('S'), _FRL6, _FRH5},
- {ROAR_DTMF_CHAR_ROAR('Z'), _FRL6, _FRH6},
-
- {0, -1, -1}
-};
-
-static const struct tone * __lookup_tone_by_char(const int options, uint16_t c) {
- size_t i;
-
- (void)options;
-
- if ( (c >= ROAR_DTMF_CHAR_DTMF('a') && c <= ROAR_DTMF_CHAR_DTMF('z')) ||
-      (c >= ROAR_DTMF_CHAR_ROAR('a') && c <= ROAR_DTMF_CHAR_ROAR('z'))
-    )
-  c -= 'a' - 'A';
-
- for (i = 0; _roardsp_tones[i].c != 0; i++) {
-  if ( _roardsp_tones[i].c == c ) {
-   return &(_roardsp_tones[i]);
-  }
- }
-
- roar_err_set(ROAR_ERROR_NOENT);
- return NULL;
-}
-
-static const struct tone * __lookup_tone_by_freq(const int options, float f0, float f1) {
- const struct tone * ct;
- size_t i;
- float tmp;
-
- (void)options;
-
- if ( f0 > f1 ) {
-  tmp = f0;
-  f0 = f1;
-  f1 = tmp;
- }
-
- for (i = 0; _roardsp_tones[i].c != 0; i++) {
-  ct = &(_roardsp_tones[i]);
-
-  // allow 3.5% freq error as defined in ITU-T Q.23 and Q.24.
-
-  if ( ct->f0 < f0*.965 || ct->f0 > f0*1.035 )
-   continue;
-  if ( ct->f1 < f1*.965 || ct->f1 > f1*1.035 )
-   continue;
-  return ct;
- }
-
- roar_err_set(ROAR_ERROR_NOENT);
- return NULL;
-}
-
-int roar_dtmf_tone (int16_t * samples, const size_t len, const uint32_t rate, const int options, const uint16_t c) {
- const struct tone * ct = NULL;
-#ifdef ROAR_HAVE_LIBM
- size_t i;
- float t;
- float t_inc = 1./rate;
- float fc0, fc1;
-#endif
-
- ROAR_DBG("roar_dtmf_tone(samples=%p, len=%llu, rate=%lu, options=%i, c=%i) = ?", samples, (long long unsigned int)len, (long unsigned int)rate, options, (int)c);
-
- if ( samples == NULL ) {
-  roar_err_set(ROAR_ERROR_FAULT);
-  return -1;
- }
-
- if ( c == ROAR_DTMF_CHAR_BREAK )
-  return roar_dtmf_break(samples, len, rate, options);
-
- ct = __lookup_tone_by_char(options, c);
-
- if ( ct == NULL ) {
-  roar_err_set(ROAR_ERROR_NOENT);
-  return -1;
- }
-
-#ifdef ROAR_HAVE_LIBM
- fc0 = 2. * M_PI * ct->f0;
- fc1 = 2. * M_PI * ct->f1;
-
-// memset(samples, 0, len);
-
- for (i = 0, t = 0.; i < len; t += t_inc, i++) {
-  samples[i] = (sinf(fc0*t) + sinf(fc1*t))*8192.0;
- }
-#else
- roar_err_set(ROAR_ERROR_NOTSUP);
- return -1;
-#endif
-
- return 0;
-}
-
-uint16_t roar_dtmf_freqs2char(const int options, float f0, float f1) {
- const struct tone * ct = __lookup_tone_by_freq(options, f0, f1);
-
- if ( ct == NULL )
-  return ROAR_DTMF_CHAR_BREAK;
- return ct->c;
-}
-
-//ll
Index: libroardsp/fader.c
===================================================================
--- libroardsp/fader.c	(revision 6052)
+++ 	(revision )
@@ -1,165 +1,0 @@
-//fader.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2009-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-#define _CHECK_BASIC()   if ( state == NULL ) return -1
-#define _CHECK_CALCPCM() _CHECK_BASIC(); if ( frames == 0 ) return 0; if ( data == NULL ) return -1;
-
-int roar_fader_init         (struct roar_fader_state * state, const float * poly, int coeff) {
- _CHECK_BASIC();
-
- if ( poly == NULL )
-  return -1;
-
- if ( coeff < 2 )
-  return -1;
-
- if ( coeff > ROAR_FADER_MAX_COEFF )
-  return -1;
-
- memset(state, 0, sizeof(struct roar_fader_state));
-
- state->rate  = -1;
- state->coeff = coeff;
-
- state->start = -1;
- state->stop  = -1;
-
- memcpy(state->poly, poly, sizeof(float)*coeff);
-
- return 0;
-}
-
-int roar_fader_set_rate     (struct roar_fader_state * state, int rate) {
- _CHECK_BASIC();
-
- state->rate = rate;
-
- return 0;
-}
-
-int roar_fader_set_startstop(struct roar_fader_state * state, ssize_t start, ssize_t stop) {
- _CHECK_BASIC();
-
- if ( start >= 0 )
-  state->start = start;
-
- if ( stop  >= 0 )
-  state->stop  = stop;
-
- return 0;
-}
-
-int roar_fader_has_started  (struct roar_fader_state * state) {
- if ( state == NULL )
-  return -1;
-
- if ( state->start == -1 )
-  return 0;
-
- if ( state->start <= state->pcmoffset )
-  return 1;
-
- return 0;
-}
-
-int roar_fader_has_ended    (struct roar_fader_state * state) {
- if ( state == NULL )
-  return -1;
-
- if ( state->stop == -1 )
-  return 0;
-
- if ( state->stop > state->pcmoffset )
-  return 1;
-
- return 0;
-}
-
-int roar_fader_calcpcm_i16n(struct roar_fader_state * state, int16_t * data, size_t frames, int channels) {
- _CHECK_CALCPCM();
-
- switch (channels) {
-  case 1: return roar_fader_calcpcm_i161(state, data, frames);
- }
-
- return -1;
-}
-
-int roar_fader_calcpcm_i161(struct roar_fader_state * state, int16_t * data, size_t frames) {
- size_t start, stop, cur;
- int i, i_s, i_e;
- float t_cur, t_step;
- float g_cur;
-
- _CHECK_BASIC();
-
- if ( state->start == -1 ) {
-  start = state->pcmoffset;
- } else {
-  start = state->start;
- }
-
- if ( state->stop == -1 ) {
-  stop = state->pcmoffset + frames;
- } else {
-  stop = state->stop;
- }
-
- cur = state->pcmoffset;
-
- i_s = 0;
- i_e = frames;
-
- if ( start > cur )
-  i_s = start - cur;
-
- if ( stop < (cur + frames) )
-  i_e = stop  - cur;
-
- t_step = (float)(state->coeff - 1)/(float)(stop - start);
-
- if ( start < cur ) {
-  t_cur = (cur - start)*t_step;
- } else {
-  t_cur = 0;
- }
-
- ROAR_DBG("roar_fader_calcpcm_i161(*): i_s->i_e: %i->%i", i_s, i_e);
-
- for (i = i_s; i < i_e; i++, cur++) {
-  t_cur  += t_step;
-  g_cur   = roar_math_cvpoly(state->poly, t_cur, state->coeff);
-//  ROAR_DBG("roar_fader_calcpcm_i161(*): i=%i, g_cur=%f", i, g_cur);
-  data[i] = (float)data[i] * g_cur;
- }
-
- state->pcmoffset = cur;
-
- return -1;
-}
-
-//ll
Index: libroardsp/filter.c
===================================================================
--- libroardsp/filter.c	(revision 6052)
+++ 	(revision )
@@ -1,274 +1,0 @@
-//filter.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-static struct _roardsp_filterlist {
- int id;
- char * name;
- int (*  init      )(struct roardsp_filter * filter, struct roar_stream * stream, int id);
- int (*uninit      )(struct roardsp_filter * filter);
- int (*ctl         )(struct roardsp_filter * filter, int cmd, void * data);
- int (*reset       )(struct roardsp_filter * filter, int what);
- int (*calc  [5][3])(struct roardsp_filter * filter, void * data, size_t samples);
-} _roardsp_filterlist[] = {
- {ROARDSP_FILTER_AMP, "AMP", roardsp_amp_init, roardsp_amp_uninit, roardsp_amp_ctl, roardsp_amp_reset, {
-           {NULL, NULL, NULL},{roardsp_amp_calc8, NULL, NULL},{roardsp_amp_calc16, NULL, NULL},
-           {NULL, NULL, NULL},{roardsp_amp_calc32, NULL, NULL}}},
- {ROARDSP_FILTER_ADD, "Add", roardsp_amp_init, roardsp_amp_uninit, roardsp_amp_ctl, roardsp_add_reset, {
-           {NULL, NULL, NULL},{roardsp_add_calc8, NULL, NULL},{roardsp_add_calc16, NULL, NULL},
-           {NULL, NULL, NULL},{roardsp_add_calc32, NULL, NULL}}},
-#ifdef ROAR_HAVE_LIBM
- {ROARDSP_FILTER_LOWP, "Lowpass", roardsp_lowp_init, roardsp_lowp_uninit, roardsp_lowp_ctl, roardsp_lowp_reset, {
-           {NULL, NULL, NULL},{roardsp_lowp_calc8, NULL, NULL},{roardsp_lowp_calc16, NULL, NULL},
-           {NULL, NULL, NULL},{roardsp_lowp_calc32, NULL, NULL}}},
- {ROARDSP_FILTER_HIGHP, "Highpass", roardsp_highp_init, roardsp_highp_uninit, roardsp_highp_ctl, roardsp_highp_reset, {
-           {NULL, NULL, NULL},{roardsp_highp_calc8, NULL, NULL},{roardsp_highp_calc16, NULL, NULL},
-           {NULL, NULL, NULL},{roardsp_highp_calc32, NULL, NULL}}},
-#endif
- {ROARDSP_FILTER_QUANTIFY, "Quantifier", roardsp_quantify_init, NULL, roardsp_quantify_ctl, roardsp_quantify_reset, {
-           {NULL, NULL, NULL},{roardsp_quantify_calc8, NULL, NULL},{roardsp_quantify_calc16, NULL, NULL},
-           {NULL, NULL, NULL},{roardsp_quantify_calc32, NULL, NULL}}},
- {ROARDSP_FILTER_CLIP, "Clip", roardsp_clip_init, roardsp_clip_uninit, roardsp_clip_ctl, roardsp_clip_reset, {
-           {NULL, NULL, NULL},{roardsp_clip_calc8, NULL, NULL},{roardsp_clip_calc16, NULL, NULL},
-           {NULL, NULL, NULL},{roardsp_clip_calc32, NULL, NULL}}},
- {ROARDSP_FILTER_DOWNMIX, "downmix", roardsp_quantify_init, NULL, roardsp_downmix_ctl, roardsp_downmix_reset, {
-           {NULL, NULL, NULL},{NULL, NULL, NULL},{NULL, NULL, roardsp_downmix_calc162},{NULL, NULL, NULL},{NULL, NULL, NULL}}},
- {ROARDSP_FILTER_DCBLOCK, "DCBlock", roardsp_dcblock_init, NULL, NULL, roardsp_dcblock_reset, {
-           {NULL, NULL, NULL},{NULL, NULL, NULL},{roardsp_dcblock_calc16, NULL, NULL},{NULL, NULL, NULL},{NULL, NULL, NULL}}},
- {ROARDSP_FILTER_SWAP, "Swap", roardsp_swap_init, roardsp_swap_uninit, roardsp_swap_ctl, roardsp_swap_reset, {
-           {NULL, NULL, NULL},{NULL, NULL, roardsp_swap_calc82},{NULL, NULL, roardsp_swap_calc162},
-           {NULL, NULL, NULL},{NULL, NULL, roardsp_swap_calc322}}},
- {ROARDSP_FILTER_AGC, "AGC", roardsp_agc_init, roardsp_agc_uninit, roardsp_agc_ctl, roardsp_agc_reset, {
-           {NULL, NULL, NULL},{NULL, NULL, NULL},{NULL, NULL, NULL},{NULL, NULL, NULL},{NULL, NULL, NULL}}},
-#ifdef ROAR_HAVE_SPEEX_FILTER
- {ROARDSP_FILTER_SPEEX_PREP, "SpeexPrep", roardsp_speex_prep_init, roardsp_speex_prep_uninit,
-                                          roardsp_speex_prep_ctl,  roardsp_speex_prep_reset, {
-           {NULL, NULL, NULL},{NULL, NULL, NULL},{NULL, roardsp_speex_prep_calc161, NULL},{NULL, NULL, NULL},{NULL, NULL, NULL}}},
-#endif
-#ifdef ROAR_HAVE_LIBM
- {ROARDSP_FILTER_RESPONSE_CURVE, "ResponseCurve", roardsp_responsecurve_init, roardsp_responsecurve_uninit,
-                                                  roardsp_responsecurve_ctl, roardsp_responsecurve_reset, {
-           {NULL, NULL, NULL},{roardsp_responsecurve_calc8, NULL, NULL},{roardsp_responsecurve_calc16, NULL, NULL},
-           {NULL, NULL, NULL},{roardsp_responsecurve_calc32, NULL, NULL}
- }},
- {ROARDSP_FILTER_GOERTZEL, "Goertzel", roardsp_goertzel_init, roardsp_goertzel_uninit,
-                                       roardsp_goertzel_ctl, roardsp_goertzel_reset, {
-           {NULL, NULL, NULL},{roardsp_goertzel_calc8, NULL, NULL},{roardsp_goertzel_calc16, NULL, NULL},
-           {NULL, NULL, NULL},{roardsp_goertzel_calc32, NULL, NULL}
- }},
-#endif
- {-1, NULL, NULL, NULL, NULL, NULL, {
-      // ?                  8Bit               16Bit              24Bit              32Bit
-      // 0B:n     1     2   1B:n     1     2   2B:n     1     2   3B:n     1    2    4B:n     1     2
-           {NULL, NULL, NULL},{NULL, NULL, NULL},{NULL, NULL, NULL},{NULL, NULL, NULL},{NULL, NULL, NULL}}}
-};
-
-int    roardsp_filter_str2id(const char * str) {
- struct _roardsp_filterlist * l = _roardsp_filterlist;
-
- while ( l->id != -1 ) {
-  if ( strcasecmp(l->name, str) == 0 )
-   return l->id;
-  l++;
- }
-
- roar_err_set(ROAR_ERROR_NOENT);
- return -1;
-}
-
-const char * roardsp_filter_id2str(const int id) {
- struct _roardsp_filterlist * l = _roardsp_filterlist;
-
- while ( l->id != -1 ) {
-  if ( l->id == id )
-   return l->name;
-  l++;
- }
-
- roar_err_set(ROAR_ERROR_NOENT);
- return NULL;
-}
-
-int    roardsp_filter_new   (struct roardsp_filter ** filter, struct roar_stream * stream, int id) {
- struct roardsp_filter * n;
- int ret;
- int error;
-
- if ( filter == NULL || stream == NULL ) {
-  roar_err_set(ROAR_ERROR_FAULT);
-  return -1;
- }
-
- *filter = NULL; // just to be sure
-
- n = roar_mm_malloc(sizeof(struct roardsp_filter));
-
- if ( n == NULL )
-  return -1;
-
- if ( (ret = roardsp_filter_init(n, stream, id)) == -1 ) {
-  error = roar_error;
-  roar_mm_free(n);
-  roar_err_set(error);
-  return -1;
- }
-
- n->flags |= ROARDSP_FFLAG_FREE;
-
- *filter = n;
-
- return ret;
-}
-
-int roardsp_filter_init  (struct roardsp_filter * filter, struct roar_stream * stream, int id) {
- struct _roardsp_filterlist * l = _roardsp_filterlist;
- int bytes;
- int (*calc)(struct roardsp_filter * filter, void * data, size_t samples) = NULL;
-
- if ( filter == NULL || stream == NULL ) {
-  ROAR_DBG("roardsp_filter_init(*) = -1 // filter or stream is NULL");
-  roar_err_set(ROAR_ERROR_FAULT);
-  return -1;
- }
-
- if ( id < 0 ) {
-  roar_err_set(ROAR_ERROR_INVAL);
-  return -1;
- }
-
- ROAR_DBG("roardsp_filter_init(filter=%p, stream=%p, id=%i) = ?", filter, stream, id);
-
- memset(filter, 0, sizeof(struct roardsp_filter));
-
- filter->channels = stream->info.channels;
- filter->bits     = stream->info.bits;
- filter->rate     = stream->info.rate;
-
- bytes            = stream->info.bits / 8;
-
- while ( l->id != id ) {
-  if ( l->id == -1 ) {
-   roar_err_set(ROAR_ERROR_NOENT);
-   return -1;
-  }
-  l++;
- }
-
- filter->uninit = l->uninit;
- filter->ctl    = l->ctl;
- filter->reset  = l->reset;
-
- ROAR_DBG("roardsp_filter_init(filter=%p, stream=%p, id=%i): bytes=%i", filter, stream, id, bytes);
-
- if ( filter->channels < 3 )
-  calc = l->calc[bytes][filter->channels];
-
- if ( calc == NULL )
-  calc = l->calc[bytes][0]; // for n channels
-
- if ( calc == NULL ) {
-  ROAR_DBG("roardsp_filter_init(*) = -1 // no calc code");
-  roar_err_set(ROAR_ERROR_NOTSUP);
-  return -1;
- }
-
- filter->calc = calc;
-
- if ( l->init != NULL ) {
-  ROAR_DBG("roardsp_filter_init(*) = ? // execing init");
-  return l->init(filter, stream, id);
- }
-
- ROAR_DBG("roardsp_filter_init(*) = 0 // no init");
- return 0;
-}
-
-int roardsp_filter_uninit(struct roardsp_filter * filter) {
- int ret = 0;
-
- if ( filter == NULL ) {
-  roar_err_set(ROAR_ERROR_FAULT);
-  return -1;
- }
-
- if ( filter->uninit != NULL )
-  ret = filter->uninit(filter);
-
- if ( filter->flags & ROARDSP_FFLAG_FREE ) {
-  roar_mm_free(filter);
- } else  {
-  memset(filter, 0, sizeof(struct roardsp_filter));
- }
-
- return ret;
-}
-
-int roardsp_filter_calc  (struct roardsp_filter * filter, void * data, size_t len) {
- int ret = 0;
-
- if ( filter == NULL ) {
-  roar_err_set(ROAR_ERROR_FAULT);
-  return -1;
- }
-
- if ( data == NULL && len != 0 ) {
-  roar_err_set(ROAR_ERROR_FAULT);
-  return -1;
- }
-
- if ( filter->calc != NULL )
-  ret = filter->calc(filter, data, len);
-
- return ret;
-}
-
-int    roardsp_filter_ctl   (struct roardsp_filter * filter, int cmd, void * data) {
- if ( filter == NULL ) {
-  roar_err_set(ROAR_ERROR_FAULT);
-  return -1;
- }
-
- if ( filter->ctl != NULL )
-  return filter->ctl(filter, cmd, data);
-
- roar_err_set(ROAR_ERROR_NOSYS);
- return -1;
-}
-
-int    roardsp_filter_reset (struct roardsp_filter * filter, int what) {
- if ( filter == NULL ) {
-  roar_err_set(ROAR_ERROR_FAULT);
-  return -1;
- }
-
- if ( filter->reset != NULL )
-  return filter->reset(filter, what);
-
- roar_err_set(ROAR_ERROR_NOSYS);
- return -1;
-}
-
-//ll
Index: libroardsp/filter_add.c
===================================================================
--- libroardsp/filter_add.c	(revision 6052)
+++ 	(revision )
@@ -1,73 +1,0 @@
-//filter_add.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-#define _calcX(bits) \
-int roardsp_add_calc##bits  (struct roardsp_filter * filter, void * data, size_t samples) { \
- struct roardsp_amp * self = (struct roardsp_amp *) filter->inst; \
- int##bits##_t * samp = (int##bits##_t *) data; \
- size_t i; \
-\
- for (i = 0; i < samples; i++) { \
-  samp[i] += self->mul / self->div; \
- }; \
-\
- return 0; \
-}
-
-_calcX(8)
-_calcX(16)
-_calcX(32)
-
-int roardsp_add_reset (struct roardsp_filter * filter, int what) {
- struct roardsp_amp * self;
-
- if ( filter == NULL )
-  return -1;
-
- if ( filter->inst == NULL )
-  return -1;
-
- self = filter->inst;
-
- switch (what) {
-  case ROARDSP_RESET_NONE:
-  case ROARDSP_RESET_STATE:
-    return  0;
-   break;
-  case ROARDSP_RESET_FULL:
-    self->mul = 0;
-    self->div = 1;
-    return  0;
-   break;
-  default:
-    return -1;
- }
-
- return -1;
-}
-
-//ll
Index: libroardsp/filter_agc.c
===================================================================
--- libroardsp/filter_agc.c	(revision 6052)
+++ 	(revision )
@@ -1,98 +1,0 @@
-//filter_agc.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2009-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-int roardsp_agc_init   (struct roardsp_filter * filter, struct roar_stream * stream, int id) {
- struct roardsp_agc * self = roar_mm_malloc(sizeof(struct roardsp_agc));
-
- (void)id;
-
- if ( self == NULL )
-  return -1;
-
- memset(self, 0, sizeof(struct roardsp_agc));
-
- if ( roardsp_filter_new(&(self->amp), stream, ROARDSP_FILTER_AMP) == -1 ) {
-  roar_mm_free(self);
-  return -1;
- }
-
- filter->inst = (void*) self;
-
- if ( roardsp_filter_reset(filter, ROARDSP_RESET_FULL) == -1 ) {
-  roardsp_agc_uninit(filter);
-  return -1;
- }
-
- return 0;
-}
-
-int roardsp_agc_uninit (struct roardsp_filter * filter) {
- struct roardsp_agc * self = filter->inst;
-
- roardsp_filter_free(self->amp);
- roar_mm_free(self);
- return 0;
-}
-
-int roardsp_agc_ctl    (struct roardsp_filter * filter, int cmd, void * data) {
- struct roardsp_agc * self = filter->inst;
-
- (void)self;
-
- return -1;
-}
-
-int roardsp_agc_reset  (struct roardsp_filter * filter, int what) {
- struct roardsp_agc * self = filter->inst;
-
- switch (what) {
-  case ROARDSP_RESET_NONE:
-    return 0;
-   break;
-  case ROARDSP_RESET_FULL:
-    if ( filter->bits < 4 )
-     return -1;
-
-    self->target_amp = 1 << (filter->bits - 3);
-
-    if ( roardsp_filter_reset(self->amp, ROARDSP_RESET_FULL) == -1 )
-     return -1;
-
-    return -1;
-   break;
-  case ROARDSP_RESET_STATE:
-    if ( roardsp_filter_reset(self->amp, ROARDSP_RESET_STATE) == -1 )
-     return -1;
-    return -1;
-   break;
-  default: return -1;
- }
-
- return 0;
-}
-
-//ll
Index: libroardsp/filter_amp.c
===================================================================
--- libroardsp/filter_amp.c	(revision 6052)
+++ 	(revision )
@@ -1,120 +1,0 @@
-//filter_amp.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-int roardsp_amp_init  (struct roardsp_filter * filter, struct roar_stream * stream, int id) {
- struct roardsp_amp * self = roar_mm_malloc(sizeof(struct roardsp_amp));
-
- (void)stream, (void)id;
-
- if ( self == NULL )
-  return -1;
-
- memset(self, 0, sizeof(struct roardsp_amp));
-
- filter->inst = (void*) self;
-
- roardsp_filter_reset(filter, ROARDSP_RESET_FULL);
-
- return 0;
-}
-
-int roardsp_amp_uninit(struct roardsp_filter * filter) {
-
- roar_mm_free(filter->inst);
- return 0;
-}
-
-#define _calcX(bits,twobits) \
-int roardsp_amp_calc##bits  (struct roardsp_filter * filter, void * data, size_t samples) { \
- struct roardsp_amp * self = (struct roardsp_amp *) filter->inst; \
- int##bits##_t * samp = (int##bits##_t *) data; \
- register int##twobits##_t s; \
- size_t i; \
-\
- for (i = 0; i < samples; i++) { \
-  s        = samp[i]; \
-  s       *= self->mul; \
-  s       /= self->div; \
-  samp[i]  = s; \
- }; \
-\
- return 0; \
-}
-
-_calcX(8,16)
-_calcX(16,32)
-_calcX(32,64)
-
-int roardsp_amp_ctl   (struct roardsp_filter * filter, int cmd, void * data) {
- struct roardsp_amp * self = (struct roardsp_amp *) filter->inst;
- int32_t old;
-
- if ( cmd == ROARDSP_FCTL_MUL ) {
-  old = self->div;
-  self->mul = *(int32_t*)data;
-  *(int32_t*)data = old;
- } else if ( cmd == ROARDSP_FCTL_DIV ) {
-  old = self->div;
-  self->div = *(int32_t*)data;
-  *(int32_t*)data = old;
- } else {
-  return -1;
- }
-
-
- return 0;
-}
-
-int roardsp_amp_reset (struct roardsp_filter * filter, int what) {
- struct roardsp_amp * self;
-
- if ( filter == NULL )
-  return -1;
-
- if ( filter->inst == NULL )
-  return -1;
-
- self = filter->inst;
-
- switch (what) {
-  case ROARDSP_RESET_NONE:
-  case ROARDSP_RESET_STATE:
-    return  0;
-   break;
-  case ROARDSP_RESET_FULL:
-    self->mul = 1;
-    self->div = 1;
-    return  0;
-   break;
-  default:
-    return -1;
- }
-
- return -1;
-}
-
-//ll
Index: libroardsp/filter_clip.c
===================================================================
--- libroardsp/filter_clip.c	(revision 6052)
+++ 	(revision )
@@ -1,154 +1,0 @@
-//filter_clip.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-int roardsp_clip_init  (struct roardsp_filter * filter, struct roar_stream * stream, int id) {
- (void)stream, (void)id;
-
- if ( (filter->inst = roar_mm_malloc(sizeof(struct roardsp_clip))) == NULL )
-  return -1;
-
- return roardsp_filter_reset(filter, ROARDSP_RESET_FULL);
-}
-
-int roardsp_clip_uninit(struct roardsp_filter * filter) {
- roar_mm_free(filter->inst);
- return 0;
-}
-
-#define _clipX(bits) \
-static inline int##bits##_t _clip##bits (int##bits##_t s, struct roardsp_clip * self) { \
- switch (self->mode) { \
-  case ROARDSP_CLIP_MODE_LIMIT: \
-    return s > 0 ? self->limit : -self->limit; \
-   break; \
-  case ROARDSP_CLIP_MODE_ZERO: \
-    return 0; \
-   break; \
-  case ROARDSP_CLIP_MODE_WARP: \
-    if ( s > 0 ) { \
-     return s - 2*self->limit; \
-    } else { \
-     return s + 2*self->limit; \
-    } \
-   break; \
-  case ROARDSP_CLIP_MODE_NOISE: \
-    return (s > 0 ? 1 : -1) * (self->limit - (roar_random_uint16() & 0xFF)); \
-   break; \
- } \
-\
- ROAR_WARN("_clip16(s=%i, self=%p{.mode=%i, ...}) = 0 // ERROR: Bad mode", (int)s, self, (int)self->mode); \
- return 0; \
-}
-
-#define _calcX(bits) \
-int roardsp_clip_calc##bits  (struct roardsp_filter * filter, void * data, size_t samples) { \
- struct roardsp_clip * self = filter->inst; \
- int##bits##_t * samp = (int##bits##_t *) data; \
- register int32_t s = self->limit; \
- size_t i; \
-\
- for (i = 0; i < samples; i++) { \
-  if ( samp[i] > s ) { \
-   samp[i]  = _clip##bits (samp[i], self); \
-  } else if ( -samp[i] > s ) { \
-   samp[i]  = _clip##bits (samp[i], self); \
-  } \
- } \
-\
- ROAR_DBG("roardsp_quantify_calc16(*) = 0"); \
- return 0; \
-}
-
-#define _setX(bits) \
- _clipX(bits) \
- _calcX(bits)
-
-_setX(8)
-_setX(16)
-_setX(32)
-
-int roardsp_clip_ctl   (struct roardsp_filter * filter, int cmd, void * data) {
- struct roardsp_clip * self = filter->inst;
- int32_t old;
-
- switch (cmd) {
-  case ROARDSP_FCTL_LIMIT:
-    old = self->limit;
-    self->limit = labs(*(int32_t*)data);
-    *(int32_t*)data = old;
-   break;
-  case ROARDSP_FCTL_MODE:
-    old = self->mode;
-    self->mode = *(int32_t*)data;
-    *(int32_t*)data = old;
-   break;
-  default:
-    ROAR_DBG("roardsp_clip_ctl(*) = -1");
-    return -1;
-   break;
- }
-
-
- ROAR_DBG("roardsp_clip_ctl(*) = 0");
- return 0;
-}
-
-int roardsp_clip_reset (struct roardsp_filter * filter, int what) {
- int32_t mode = ROARDSP_CLIP_MODE_LIMIT;
- int32_t n;
-
- if ( filter == NULL )
-  return -1;
-
- switch (filter->bits) {
-  case  8: n =         64L; break;
-  case 16: n =      16384L; break;
-  case 32: n = 1073741824L; break;
-  default:
-    roar_err_set(ROAR_ERROR_NOTSUP);
-    return -1;
-   break;
- }
-
- switch (what) {
-  case ROARDSP_RESET_NONE:
-  case ROARDSP_RESET_STATE:
-    return  0;
-   break;
-  case ROARDSP_RESET_FULL:
-    roardsp_clip_ctl(filter, ROARDSP_FCTL_LIMIT, &n);
-    roardsp_clip_ctl(filter, ROARDSP_FCTL_MODE, &mode);
-    return  0;
-   break;
-  default:
-    return -1;
- }
-
- return -1;
-}
-
-//ll
Index: libroardsp/filter_dcblock.c
===================================================================
--- libroardsp/filter_dcblock.c	(revision 6052)
+++ 	(revision )
@@ -1,129 +1,0 @@
-//filter_dcblock.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-int roardsp_dcblock_init  (struct roardsp_filter * filter, struct roar_stream * stream, int id) {
- struct roardsp_dcblock * inst = roar_mm_malloc(sizeof(struct roardsp_dcblock));
-// roardsp_downmix_ctl(filter, ROARDSP_FCTL_MODE, &mode);
-
- (void)stream, (void)id;
-
- if ( inst == NULL ) {
-  ROAR_ERR("roardsp_dcblock_init(*): Can not alloc memory for filter dcblock: %s", strerror(errno));
-  filter->inst = NULL;
-  return -1;
- }
-
- memset(inst, 0, sizeof(struct roardsp_dcblock));
-
- filter->inst = inst;
-
- return 0;
-}
-
-int roardsp_dcblock_uninit (struct roardsp_filter * filter) {
- if ( filter == NULL )
-  return -1;
-
- if ( filter->inst == NULL )
-  return -1;
-
- roar_mm_free(filter->inst);
-
- return 0;
-}
-
-int roardsp_dcblock_reset  (struct roardsp_filter * filter, int what) {
- if ( filter == NULL )
-  return -1;
-
- if ( filter->inst == NULL )
-  return -1;
-
- ROAR_DBG("roardsp_dcblock_reset(filter=%p, what=%i) = ?", filter, what);
-
- switch (what) {
-  case ROARDSP_RESET_NONE:
-    return  0;
-   break;
-  case ROARDSP_RESET_FULL:
-    memset(filter->inst, 0, sizeof(struct roardsp_dcblock));
-    return  0;
-   break;
-  case ROARDSP_RESET_STATE:
-    memset(((struct roardsp_dcblock*)filter->inst)->dc, 0, sizeof(int32_t)*ROARDSP_DCBLOCK_NUMBLOCKS);
-    ((struct roardsp_dcblock*)filter->inst)->cur = 0;
-    return  0;
-   break;
-  default:
-    return -1;
- }
-
- return -1;
-}
-
-int roardsp_dcblock_calc16  (struct roardsp_filter * filter, void * data, size_t samples) {
- struct roardsp_dcblock * inst = filter->inst;
- int16_t * samp = (int16_t *) data;
- register int64_t s = 0;
- size_t i;
-
- for (i = 0; i < samples; i++) {
-//  ROAR_WARN("roardsp_dcblock_calc16(*): s=%i, samp[i=%i]=%i", s, i, samp[i]);
-  s += samp[i];
- }
-
- ROAR_DBG("roardsp_dcblock_calc16(*): s=%li (current block of %lu samples)", (long int)s, (unsigned long int)samples);
-
- s = (float)(s / samples);
-
- ROAR_DBG("roardsp_dcblock_calc16(*): inst=%p, inst->cur=%i", inst, inst->cur);
- inst->dc[(inst->cur)++] = s;
-
- if ( inst->cur == ROARDSP_DCBLOCK_NUMBLOCKS )
-  inst->cur = 0;
-
- s = 0;
-
- for (i = 0; i < ROARDSP_DCBLOCK_NUMBLOCKS; i++)
-  s += inst->dc[i];
-
- s /= ROARDSP_DCBLOCK_NUMBLOCKS;
-
-// s += (ROAR_INSTINT)filter->inst;
-
- ROAR_DBG("roardsp_dcblock_calc16(*): new DC value: %li", (long int)s);
-
- for (i = 0; i < samples; i++)
-  samp[i] -= s;
-
- ROAR_DBG("roardsp_downmix_calc16(*) = 0");
- return 0;
-}
-
-
-
-//ll
Index: libroardsp/filter_downmix.c
===================================================================
--- libroardsp/filter_downmix.c	(revision 6052)
+++ 	(revision )
@@ -1,129 +1,0 @@
-//filter_downmix.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-int roardsp_downmix_calc162  (struct roardsp_filter * filter, void * data, size_t samples) {
- int16_t * samp = (int16_t *) data;
- register int32_t mode = (ROAR_INSTINT)filter->inst;
- register union {
-//  int16_t i16;
-  int32_t i32;
-  int64_t i64;
- } s;
- size_t i;
-
- ROAR_DBG("roardsp_downmix_calc162(*): mode=%i", mode);
-
- switch (mode) {
-  case ROARDSP_DOWNMIX_LEFT:
-    for (i = 0; i < samples; i += 2)
-     samp[i+1] = samp[i];
-   break;
-  case ROARDSP_DOWNMIX_RIGHT:
-    for (i = 0; i < samples; i += 2)
-     samp[i] = samp[i+1];
-   break;
-  case ROARDSP_DOWNMIX_ARITHMETIC:
-    for (i = 0; i < samples; i += 2) {
-     s.i32     = (samp[i] + samp[i+1])/2;
-     samp[i  ] = s.i32;
-     samp[i+1] = s.i32;
-    }
-   break;
-  case ROARDSP_DOWNMIX_ARITHMETIC_INVERSE:
-    for (i = 0; i < samples; i += 2) {
-     s.i32     = (float)(samp[i] + samp[i+1])/2.1;
-     samp[i  ] = s.i32;
-     samp[i+1] = -s.i32;
-    }
-   break;
-#ifdef ROAR_HAVE_LIBM
-  case ROARDSP_DOWNMIX_RMS:
-    for (i = 0; i < samples; i += 2) {
-     s.i64      = (int64_t)samp[i]*samp[i] + (int64_t)samp[i+1]*samp[i+1];
-#ifdef ROAR_HAVE_SQRTL
-     s.i64      = sqrtl((long double)s.i64/2.0);
-#else
-     s.i64      = sqrt((double)s.i64/2.0);
-#endif
-//     s.i64     /=  2;
-
-     if ( (samp[i] + samp[i+1]) < 0 )
-      s.i64    *= -1;
-
-     samp[i  ]  = s.i64;
-     samp[i+1]  = s.i64;
-    }
-   break;
-#endif
-  default:
-   ROAR_DBG("roardsp_downmix_calc162(*) = -1 // unknown mode");
-   return -1;
-  break;
- }
-
- ROAR_DBG("roardsp_downmix_calc162(*) = 0");
- return 0;
-}
-
-int roardsp_downmix_ctl   (struct roardsp_filter * filter, int cmd, void * data) {
- int32_t old;
-
- if ( cmd == ROARDSP_FCTL_MODE ) {
-  old = (ROAR_INSTINT)filter->inst;
-  filter->inst = (void*)(ROAR_INSTINT)*(int32_t*)data;
-  *(int32_t*)data = old;
- } else {
-  return -1;
- }
-
-
- return 0;
-}
-
-int roardsp_downmix_reset  (struct roardsp_filter * filter, int what) {
- int32_t mode = ROARDSP_DOWNMIX_ARITHMETIC;
-
- if ( filter == NULL )
-  return -1;
-
- switch (what) {
-  case ROARDSP_RESET_NONE:
-  case ROARDSP_RESET_STATE:
-    return  0;
-   break;
-  case ROARDSP_RESET_FULL:
-    roardsp_downmix_ctl(filter, ROARDSP_FCTL_MODE, &mode);
-    return  0;
-   break;
-  default:
-    return -1;
- }
-
- return -1;
-}
-
-//ll
Index: libroardsp/filter_goertzel.c
===================================================================
--- libroardsp/filter_goertzel.c	(revision 6052)
+++ 	(revision )
@@ -1,162 +1,0 @@
-//filter_goertzel.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-#ifdef ROAR_HAVE_LIBM
-
-#define DEFAULT_FREQ 1000.0
-
-struct roardsp_goertzel {
- float   freq;
- int32_t coeff;
- int32_t old[ROAR_MAX_CHANNELS][2];
-};
-
-int roardsp_goertzel_init  (struct roardsp_filter * filter, struct roar_stream * stream, int id) {
- struct roardsp_goertzel * self = roar_mm_malloc(sizeof(struct roardsp_goertzel));
-
- (void)stream, (void)id;
-
- if ( self == NULL )
-  return -1;
-
- memset(self, 0, sizeof(struct roardsp_goertzel));
-
- filter->inst = (void*) self;
-
- roardsp_goertzel_reset(filter, ROARDSP_RESET_FULL);
-
- return 0;
-}
-
-int roardsp_goertzel_uninit(struct roardsp_filter * filter) {
- roar_mm_free(filter->inst);
- return 0;
-}
-
-#define _calcX(bits,twobits,limit) \
-int roardsp_goertzel_calc##bits  (struct roardsp_filter * filter, void * data, size_t samples) { \
- struct roardsp_goertzel * self = (struct roardsp_goertzel *) filter->inst; \
- int##bits##_t * samp = (int##bits##_t *) data; \
- /*register int##twobits##_t s, g, h;*/ \
- register float s, g, h; \
- /*register int64_t s, g, h;*/ \
- int channel; \
- size_t i; \
-\
- roardsp_goertzel_reset(filter, ROARDSP_RESET_STATE); \
-\
- for (i = 0, channel = 0; i < samples; i++, channel = channel == (filter->channels - 1) ? 0 : channel + 1) { \
-  g        = self->old[channel][0]; \
-  g       *= self->coeff; \
-  g       /= 32767; \
-  s        = samp[i]; \
-  ROAR_DBG("roardsp_goertzel_calc*(*): channel=%i, g=%f, s=%f, old[0]=%li, old[1]=%li", channel, g, s, (long int)self->old[channel][0], (long int)self->old[channel][1]); \
-  s       += g; \
-  s       -= self->old[channel][1]; \
-  self->old[channel][1] = self->old[channel][0]; \
-  self->old[channel][0] = s; \
-  /* samp[i]  = s; */ \
-  g  = s; \
-  g *= self->old[channel][1]; \
-  g *= self->coeff; \
-  g /= 32767; \
-  h  = self->old[channel][1]; \
-  h *= self->old[channel][1]; \
-  s  *= s; \
-  s  += h; \
-  s  -= g; \
-  s  *= 0.0001; \
-  s  /= (float)((i+1)*(i+1)); \
-  if ( s > (limit) ) \
-   s = (limit); \
-  samp[i]  = s; \
- } \
-\
- return 0; \
-}
-
-_calcX(8,16,127.)
-_calcX(16,32,32767.)
-_calcX(32,64,2147483647.)
-
-int roardsp_goertzel_ctl   (struct roardsp_filter * filter, int cmd, void * data) {
- struct roardsp_goertzel * self = (struct roardsp_goertzel *) filter->inst;
- float old;
-
- switch (cmd) {
-  case ROARDSP_FCTL_FREQ:
-    old = self->freq;
-    self->freq = *(float*)data;
-    *(float*)data = old;
-    old = 2.*cos(2.*M_PI*self->freq/(float)filter->rate);
-    self->coeff = old*32767.;
-    ROAR_DBG("roardsp_goertzel_ctl(filter=%p, cmd=%i, data=%p): self->coeff=%li (%f)", filter, cmd, data, (long int)self->coeff, old);
-   break;
-  default:
-    roar_err_set(ROAR_ERROR_BADRQC);
-    return -1;
-   break;
- }
-
- return 0;
-}
-
-int roardsp_goertzel_reset (struct roardsp_filter * filter, int what) {
- struct roardsp_goertzel * self;
- float freq;
-
- if ( filter == NULL )
-  return -1;
-
- if ( filter->inst == NULL )
-  return -1;
-
- self = filter->inst;
-
- switch (what) {
-  case ROARDSP_RESET_NONE:
-    return 0;
-   break;
-  case ROARDSP_RESET_FULL:
-    freq = self->freq = DEFAULT_FREQ;
-    roardsp_goertzel_ctl(filter, ROARDSP_FCTL_FREQ, &freq);
-  case ROARDSP_RESET_STATE:
-    memset(self->old, 0, sizeof(self->old));
-    return 0;
-   break;
-  default:
-    roar_err_set(ROAR_ERROR_BADRQC);
-    return -1;
-   break;
- }
-
- return -1;
-}
-
-#endif
-
-//ll
Index: libroardsp/filter_highp.c
===================================================================
--- libroardsp/filter_highp.c	(revision 6052)
+++ 	(revision )
@@ -1,150 +1,0 @@
-//filter_highp.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-#ifdef ROAR_HAVE_LIBM
-
-int roardsp_highp_init  (struct roardsp_filter * filter, struct roar_stream * stream, int id) {
- struct roardsp_highp * self = roar_mm_malloc(sizeof(struct roardsp_highp));
-
- (void)stream, (void)id;
-
- if ( self == NULL )
-  return -1;
-
- memset(self, 0, sizeof(struct roardsp_highp));
-
- filter->inst = (void*) self;
-
- return roardsp_filter_reset(filter, ROARDSP_RESET_FULL);
-}
-
-int roardsp_highp_uninit(struct roardsp_filter * filter) {
-
- roar_mm_free(filter->inst);
- return 0;
-}
-
-#define _calcX(bits,twobits) \
-int roardsp_highp_calc##bits (struct roardsp_filter * filter, void * data, size_t samples) { \
- struct roardsp_highp * self = (struct roardsp_highp *) filter->inst; \
- int##bits##_t * samp = (int##bits##_t *) data; \
- register int##twobits##_t s, h; \
- size_t i, c; \
- size_t channels = filter->channels; \
-\
- if ( channels > ROAR_MAX_CHANNELS ) \
-  return -1; \
-\
- samples /= channels; \
-\
- ROAR_DBG("roardsp_highp_calc16(*): filtering %i frames of %i channels...", samples, channels); \
-\
-/* *      output[N] = A0 * input[N] + A1 * input[N-1] + B1 * output[N-1] */ \
-\
-\
- for (i = 0; i < samples; i++) { \
-  for (c = 0; c < channels; c++) { \
-   h = samp[i*channels + c]; \
-   s = (int##twobits##_t)samp[i*channels + c] * self->a + (int##twobits##_t)self->oldin[c] * self->b + (int##twobits##_t)self->oldout[c] * self->c; \
-\
-   s /= 65536; \
-\
-   self->oldin[      c] = h; \
-   samp[i*channels + c] = s; \
-   self->oldout[     c] = s; \
-  } \
- } \
-\
- return 0; \
-}
-
-_calcX(8,32) /* we need 32 bit not 16 bit here as we multiplay with 65536 internally */
-_calcX(16,32)
-_calcX(32,64)
-
-int roardsp_highp_ctl   (struct roardsp_filter * filter, int cmd, void * data) {
- struct roardsp_highp * self = (struct roardsp_highp *) filter->inst;
- float lp;
- float oldfreq;
- float newfreq;
-
- if ( cmd != ROARDSP_FCTL_FREQ )
-  return -1;
-
- newfreq = *(float*)data;
-
- lp = exp(-2.0 * M_PI * newfreq / (float) filter->rate) * 65536.;
-
- self->a =  (65536 + lp)/2.0;
- self->b = -(65536 + lp)/2.0;
- self->c =           lp;
-
-
- oldfreq = self->freq / 1000;
- self->freq = newfreq * 1000;
-
- *(float*)data = oldfreq;
-
- ROAR_DBG("roardsp_highp_ctl(*): oldfreq=%f, newfreq=%f", oldfreq, newfreq);
- ROAR_DBG("roardsp_highp_ctl(*): a=%i, b=%i, c=%i", self->a, self->b, self->c);
-
- return 0;
-}
-
-int roardsp_highp_reset (struct roardsp_filter * filter, int what) {
- struct roardsp_highp * self;
- float freq = 25.;
-
- if ( filter == NULL )
-  return -1;
-
- if ( filter->inst == NULL )
-  return -1;
-
- self = filter->inst;
-
- switch (what) {
-  case ROARDSP_RESET_NONE:
-    return  0;
-   break;
-  case ROARDSP_RESET_FULL:
-    roardsp_highp_ctl(filter, ROARDSP_FCTL_FREQ, &freq);
-  case ROARDSP_RESET_STATE:
-    memset(self->oldin,  0, sizeof(int32_t)*ROAR_MAX_CHANNELS);
-    memset(self->oldout, 0, sizeof(int32_t)*ROAR_MAX_CHANNELS);
-    return  0;
-   break;
-  default:
-    return -1;
- }
-
- return -1;
-}
-
-#endif
-
-//ll
Index: libroardsp/filter_lowp.c
===================================================================
--- libroardsp/filter_lowp.c	(revision 6052)
+++ 	(revision )
@@ -1,147 +1,0 @@
-//filter_lowp.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-#ifdef ROAR_HAVE_LIBM
-
-int roardsp_lowp_init  (struct roardsp_filter * filter, struct roar_stream * stream, int id) {
- struct roardsp_lowp * self = roar_mm_malloc(sizeof(struct roardsp_lowp));
-
- (void)stream, (void)id;
-
- ROAR_DBG("roardsp_lowp_init(*): self=%p", self);
-
- if ( self == NULL )
-  return -1;
-
- memset(self, 0, sizeof(struct roardsp_lowp));
-
- filter->inst = (void*) self;
-
- return roardsp_filter_reset(filter, ROARDSP_RESET_FULL);
-}
-
-int roardsp_lowp_uninit(struct roardsp_filter * filter) {
- roar_mm_free(filter->inst);
- return 0;
-}
-
-#define _calcX(bits,twobits) \
-int roardsp_lowp_calc##bits  (struct roardsp_filter * filter, void * data, size_t samples) { \
- struct roardsp_lowp * self = (struct roardsp_lowp *) filter->inst; \
- int##bits##_t * samp = (int##bits##_t *) data; \
- register int##twobits##_t s; \
- size_t i, c; \
- size_t channels = filter->channels; \
-\
- if ( channels > ROAR_MAX_CHANNELS ) \
-  return -1; \
-\
- samples /= channels; \
-\
- ROAR_DBG("roardsp_lowp_calc16(*): filtering %i frames of %i channels...", samples, channels); \
-\
-/*  *      output[N] = input[N] * A + output[N-1] * B */ \
-\
- for (i = 0; i < samples; i++) { \
-  for (c = 0; c < channels; c++) { \
-   s = (int##twobits##_t)samp[i*channels + c] * self->a + (int##twobits##_t)self->old[c] * self->b; \
-\
-   s /= 65536; \
-\
-   samp[i*channels + c] = s; \
-   self->old[        c] = s; \
-  } \
- } \
-\
- return 0; \
-}
-
-_calcX(8,32) /* we need 32 bit not 16 bit here as we multiplay with 65536 internally */
-_calcX(16,32)
-_calcX(32,64)
-
-int roardsp_lowp_ctl   (struct roardsp_filter * filter, int cmd, void * data) {
- struct roardsp_lowp * self = (struct roardsp_lowp *) filter->inst;
- float lp;
- float oldfreq;
- float newfreq;
-
- if ( cmd != ROARDSP_FCTL_FREQ ) {
-  roar_err_set(ROAR_ERROR_BADRQC);
-  return -1;
- }
-
- newfreq = *(float*)data;
-
- lp = exp(-2.0 * M_PI * newfreq / (float) filter->rate) * 65536.;
-
- self->b = lp;
- self->a = 65536. - lp;
-
- oldfreq = self->freq / 1000.;
- self->freq = newfreq * 1000.;
-
- *(float*)data = oldfreq;
-
- ROAR_DBG("roardsp_lowp_ctl(*): oldfreq=%f, newfreq=%f", oldfreq, newfreq);
-
- return 0;
-}
-
-int roardsp_lowp_reset (struct roardsp_filter * filter, int what) {
- struct roardsp_lowp * self;
- float freq;
-
- if ( filter == NULL )
-  return -1;
-
- if ( filter->inst == NULL )
-  return -1;
-
- self = filter->inst;
- freq = filter->rate/2.45;
-
- switch (what) {
-  case ROARDSP_RESET_NONE:
-    return  0;
-   break;
-  case ROARDSP_RESET_FULL:
-    roardsp_lowp_ctl(filter, ROARDSP_FCTL_FREQ, &freq);
-  case ROARDSP_RESET_STATE:
-    memset(self->old, 0, sizeof(int32_t)*ROAR_MAX_CHANNELS);
-    return  0;
-   break;
-  default:
-    return -1;
- }
-
- return -1;
-}
-
-#endif
-
-//ll
Index: libroardsp/filter_quantify.c
===================================================================
--- libroardsp/filter_quantify.c	(revision 6052)
+++ 	(revision )
@@ -1,105 +1,0 @@
-//filter_quantify.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-int roardsp_quantify_init  (struct roardsp_filter * filter, struct roar_stream * stream, int id) {
-
- (void)stream, (void)id;
-
- roardsp_filter_reset(filter, ROARDSP_RESET_FULL);
-
- return 0;
-}
-
-static inline int16_t _calc(int16_t val, void * inst) {
- register float s = val;
- s       /= 32768;
- s       *= (ROAR_INSTINT)inst;
- s        = (int16_t)s;
- s       /= (ROAR_INSTINT)inst;
- s       *= 32768;
- return s;
-}
-
-#define _calcX(bits,rshift,lshift,ibits) \
-/* this code is buggy for 8 bit filters */ \
-int roardsp_quantify_calc##bits  (struct roardsp_filter * filter, void * data, size_t samples) { \
- int##bits##_t * samp = (int##bits##_t *) data; \
- size_t i; \
-\
- for (i = 0; i < samples; i++) { \
-  samp[i]  = (int##ibits##_t)_calc((int##ibits##_t)samp[i] rshift, filter->inst) lshift; \
- } \
-\
- ROAR_DBG("roardsp_quantify_calc%i(*) = 0", bits); \
- return 0; \
-}
-
-/* look at our nice parameters ;) */
-_calcX(8,<< 8,>> 8,16)
-_calcX(16,,,16)
-_calcX(32,>> 16,<< 16,32)
-
-int roardsp_quantify_ctl   (struct roardsp_filter * filter, int cmd, void * data) {
- int32_t old;
-
- if ( cmd == ROARDSP_FCTL_N ) {
-  old = (ROAR_INSTINT)filter->inst;
-  filter->inst = (void*)(ROAR_INSTINT)*(int32_t*)data;
-  *(int32_t*)data = old;
- } else {
-  ROAR_DBG("roardsp_quantify_ctl(*) = -1");
-  return -1;
- }
-
-
- ROAR_DBG("roardsp_quantify_ctl(*) = 0");
- return 0;
-}
-
-int roardsp_quantify_reset (struct roardsp_filter * filter, int what) {
- int n = 64;
-
- if ( filter == NULL )
-  return -1;
-
- switch (what) {
-  case ROARDSP_RESET_NONE:
-  case ROARDSP_RESET_STATE:
-    return  0;
-   break;
-  case ROARDSP_RESET_FULL:
-    roardsp_quantify_ctl(filter, ROARDSP_FCTL_N, &n);
-    return  0;
-   break;
-  default:
-    return -1;
- }
-
- return -1;
-}
-
-//ll
Index: libroardsp/filter_responsecurve.c
===================================================================
--- libroardsp/filter_responsecurve.c	(revision 6052)
+++ 	(revision )
@@ -1,192 +1,0 @@
-//filter_amp.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-#ifdef ROAR_HAVE_LIBM
-int roardsp_responsecurve_init  (struct roardsp_filter * filter, struct roar_stream * stream, int id) {
- struct roardsp_responsecurve * self = roar_mm_malloc(sizeof(struct roardsp_responsecurve));
-
- (void)stream, (void)id;
-
- ROAR_DBG("roardsp_responsecurve_init(filter=%p, stream=%p, id=%i) = ?", filter, stream, id);
-
- if ( self == NULL )
-  return -1;
-
- memset(self, 0, sizeof(struct roardsp_responsecurve));
-
- filter->inst = (void*) self;
-
- roardsp_filter_reset(filter, ROARDSP_RESET_FULL);
-
- return 0;
-}
-
-int roardsp_responsecurve_uninit(struct roardsp_filter * filter) {
-
- roar_mm_free(filter->inst);
- return 0;
-}
-
-static double __func_pass(double i, double N) {
- (void)N;
- return i;
-}
-
-static double __func_linear(double i, double N) {
- return -pow(1. - i, N + 1.) + 1.;
-}
-
-static double __func_ilinear(double i, double N) {
- return pow(i, N + 1.);
-}
-
-static double __func_sin(double i, double N) {
- return pow(sin(M_PI_2 * i), N);
-}
-
-static double __func_isin(double i, double N) {
- return 1. - pow(sin((1. - i) * M_PI_2), N);
-}
-
-static double __func_cos(double i, double N) {
- (void)N;
- return 0.5 - cos(i * M_PI)/2.;
-}
-
-static double __func_icos(double i, double N) {
- (void)N;
- return 2.*i - 0.5 + cos(i * M_PI)/2.;
-}
-
-static inline double _oddify(double x, double N, double (*func)(double, double)) {
- if ( x < 0. ) {
-  return -func(0. - x, N);
- } else {
-  return func(x, N);
- }
-}
-
-static inline double _calc(double x, struct roardsp_responsecurve * self, double N) {
- double (*func)(double, double) = NULL;
- enum roardsp_responsecurve_mode mode;
-
- if ( x > 0. ) {
-  mode = self->mode_pos;
- } else {
-  mode = self->mode_neg;
- }
-
- switch (mode) {
-  case ROARDSP_RESPONSECURVE_MODE_PASS: func = __func_pass; break;
-  case ROARDSP_RESPONSECURVE_MODE_LIN:  func = __func_linear; break;
-  case ROARDSP_RESPONSECURVE_MODE_ILIN: func = __func_ilinear; break;
-  case ROARDSP_RESPONSECURVE_MODE_SIN:  func = __func_sin; break;
-  case ROARDSP_RESPONSECURVE_MODE_ISIN: func = __func_isin; break;
-  case ROARDSP_RESPONSECURVE_MODE_COS:  func = __func_cos; break;
-  case ROARDSP_RESPONSECURVE_MODE_ICOS: func = __func_icos; break;
-  default: func = __func_linear; break;
- }
-
- return _oddify(x, N, func);
-}
-
-#define _calcX(bits,fact) \
-int roardsp_responsecurve_calc##bits  (struct roardsp_filter * filter, void * data, size_t samples) { \
- struct roardsp_responsecurve * self = (struct roardsp_responsecurve *) filter->inst; \
- int##bits##_t * samp = (int##bits##_t *) data; \
- register double s; \
- size_t i; \
-\
- for (i = 0; i < samples; i++) { \
-  s        = samp[i]; \
-  s       /= (double)(fact); \
-  s        = _calc(s, self, self->N); \
-  s       *= (double)(fact); \
-  samp[i]  = s; \
- }; \
-\
- return 0; \
-}
-
-_calcX(8,128.)
-_calcX(16,32768.)
-_calcX(32,2147483648.)
-
-int roardsp_responsecurve_ctl   (struct roardsp_filter * filter, int cmd, void * data) {
- struct roardsp_responsecurve * self = (struct roardsp_responsecurve *) filter->inst;
- int32_t old;
-
- if ( cmd == ROARDSP_FCTL_N ) {
-  old = self->N;
-  self->N = *(int32_t*)data;
-  *(int32_t*)data = old;
- } else if ( cmd == ROARDSP_FCTL_MODE ) {
-  old = self->mode_pos;
-  self->mode_pos = *(int32_t*)data;
-  *(int32_t*)data = old;
- } else if ( cmd == ROARDSP_FCTL_Q ) {
-  old = self->mode_neg;
-  self->mode_neg = *(int32_t*)data;
-  *(int32_t*)data = old;
- } else {
-  return -1;
- }
-
-
- return 0;
-}
-
-int roardsp_responsecurve_reset (struct roardsp_filter * filter, int what) {
- struct roardsp_responsecurve * self;
-
- if ( filter == NULL )
-  return -1;
-
- if ( filter->inst == NULL )
-  return -1;
-
- self = filter->inst;
-
- switch (what) {
-  case ROARDSP_RESET_NONE:
-  case ROARDSP_RESET_STATE:
-    return  0;
-   break;
-  case ROARDSP_RESET_FULL:
-    self->mode_pos = self->mode_neg = ROARDSP_RESPONSECURVE_MODE_LIN;
-    self->N    = 1;
-    return  0;
-   break;
-  default:
-    return -1;
- }
-
- return -1;
-}
-#endif
-
-//ll
Index: libroardsp/filter_speex_prep.c
===================================================================
--- libroardsp/filter_speex_prep.c	(revision 6052)
+++ 	(revision )
@@ -1,171 +1,0 @@
-//filter_speex_prep.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2009-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-#ifdef _SPEEX_TYPES_H
-
-#if defined(ROAR_HAVE_LIBSPEEX) && !defined(ROAR_HAVE_LIBSPEEXDSP)
-#define _SPEEX_API_OLD
-#define _SPEEX_INT int
-#elif defined(ROAR_HAVE_LIBSPEEX) && defined(ROAR_HAVE_LIBSPEEXDSP)
-#define _SPEEX_API_NEW
-#define _SPEEX_INT spx_int32_t
-#endif
-
-#define _on  1
-#define _off 2
-
-#define _CBVM(opt) (ROARDSP_SPEEX_PREP_CBV((opt), ROARDSP_SPEEX_PREP_MASK))
-
-// TODO: check parameters we allready know:
-int roardsp_speex_prep_init   (struct roardsp_filter * filter, struct roar_stream * stream, int id) {
- struct roardsp_speex_prep * self;
-
- if ( filter->channels != 1 )
-  return -1;
-
- if ( filter->bits != 16 )
-  return -1;
-
- self = roar_mm_malloc(sizeof(struct roardsp_speex_prep));
-
- if ( self == NULL )
-  return -1;
-
- memset(self, 0, sizeof(struct roardsp_speex_prep));
-
- filter->inst = self;
-
- return 0;
-}
-
-int roardsp_speex_prep_uninit (struct roardsp_filter * filter) {
- struct roardsp_speex_prep * self = filter->inst;
-
- if ( self->preprocess != NULL )
-  speex_preprocess_state_destroy(self->preprocess);
-
- roar_mm_free(self);
-
- return 0;
-}
-
-int roardsp_speex_prep_calc161(struct roardsp_filter * filter, void * data, size_t samples) {
- struct roardsp_speex_prep * self = filter->inst;
-
- if ( self->preprocess == NULL )
-  return -1;
-
- if ( samples != ((self->frame_size * filter->bits) / 8) )
-  return -1;
-
-#ifdef _SPEEX_API_OLD
- speex_preprocess(self->preprocess, data, NULL);
-#elif defined(_SPEEX_API_NEW)
- speex_preprocess_run(self->preprocess, data);
-#else
- return -1;
-#endif
-
- return 0;
-}
-
-int roardsp_speex_prep_ctl    (struct roardsp_filter * filter, int cmd, void * data) {
- struct roardsp_speex_prep * self = filter->inst;
- union {
-  size_t  size;
-  int32_t i32;
- } * val = data;
- _SPEEX_INT si;
-
- switch (cmd) {
-  case ROARDSP_FCTL_MODE:
-    if ( self->preprocess == NULL )
-     return -1;
-
-    ROAR_DBG("roardsp_speex_prep_ctl(*): val->i32 = 0x%.8x", val->i32);
-    ROAR_DBG("roardsp_speex_prep_ctl(*): _CBVM(ROARDSP_SPEEX_PREP_DENOISE) = 0x%.8x", _CBVM(ROARDSP_SPEEX_PREP_DENOISE));
-
-    if ( val->i32 & _CBVM(ROARDSP_SPEEX_PREP_DENOISE) ) {
-     ROAR_DBG("roardsp_speex_prep_ctl(*): ROARDSP_SPEEX_PREP_CTB(ROARDSP_SPEEX_PREP_DENOISE, val->i32) = 0x%.8x", ROARDSP_SPEEX_PREP_CTB(ROARDSP_SPEEX_PREP_DENOISE, val->i32));
-     switch (ROARDSP_SPEEX_PREP_CTB(ROARDSP_SPEEX_PREP_DENOISE, val->i32)) {
-      case ROARDSP_SPEEX_PREP_ON:  si = _on;  break;
-      case ROARDSP_SPEEX_PREP_OFF: si = _off; break;
-      default: return -1;
-     }
-     speex_preprocess_ctl(self->preprocess, SPEEX_PREPROCESS_SET_DENOISE, &si);
-     val->i32 -= val->i32 & _CBVM(ROARDSP_SPEEX_PREP_DENOISE);
-    }
-
-    if ( val->i32 & _CBVM(ROARDSP_SPEEX_PREP_AGC) ) {
-     switch (ROARDSP_SPEEX_PREP_CTB(ROARDSP_SPEEX_PREP_DENOISE, val->i32)) {
-      case ROARDSP_SPEEX_PREP_ON:  si = _on;  break;
-      case ROARDSP_SPEEX_PREP_OFF: si = _off; break;
-      default: return -1;
-     }
-     speex_preprocess_ctl(self->preprocess, SPEEX_PREPROCESS_SET_AGC, &si);
-     val->i32 -= val->i32 & _CBVM(ROARDSP_SPEEX_PREP_AGC);
-    }
-
-    if ( val->i32 & _CBVM(ROARDSP_SPEEX_PREP_VAD) ) {
-     switch (ROARDSP_SPEEX_PREP_CTB(ROARDSP_SPEEX_PREP_DENOISE, val->i32)) {
-      case ROARDSP_SPEEX_PREP_ON:  si = _on;  break;
-      case ROARDSP_SPEEX_PREP_OFF: si = _off; break;
-      default: return -1;
-     }
-     speex_preprocess_ctl(self->preprocess, SPEEX_PREPROCESS_SET_VAD, &si);
-     val->i32 -= val->i32 & _CBVM(ROARDSP_SPEEX_PREP_VAD);
-    }
-
-    // any other options left? error:
-    if ( val->i32 )
-     return -1;
-
-    return 0;
-   break;
-  case ROARDSP_FCTL_PACKET_SIZE:
-    self->frame_size = val->size;
-
-    self->preprocess = speex_preprocess_state_init(self->frame_size, filter->rate);
-    if ( self->preprocess == NULL )
-     return -1;
-
-    return 0;
-   break;
- }
-
- return -1;
-}
-
-int roardsp_speex_prep_reset  (struct roardsp_filter * filter, int what) {
- if ( what == ROARDSP_RESET_NONE )
-  return 0;
-
- return -1;
-}
-#endif
-
-//ll
Index: libroardsp/filter_swap.c
===================================================================
--- libroardsp/filter_swap.c	(revision 6052)
+++ 	(revision )
@@ -1,118 +1,0 @@
-//filter_swap.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2009-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-int roardsp_swap_init   (struct roardsp_filter * filter, struct roar_stream * stream, int id) {
- struct roardsp_swap * inst = roar_mm_malloc(sizeof(struct roardsp_swap));
-
- (void)stream, (void)id;
-
- ROAR_DBG("roardsp_swap_init(*): inst=%p", inst);
-
- if ( inst == NULL ) {
-  ROAR_ERR("roardsp_swap_init(*): Can not alloc memory for filter swap: %s", strerror(errno));
-  filter->inst = NULL;
-  return -1;
- }
-
- filter->inst = inst;
-
- return roardsp_swap_reset(filter, ROARDSP_RESET_FULL);
-}
-
-int roardsp_swap_uninit (struct roardsp_filter * filter) {
- if ( filter == NULL )
-  return -1;
-
- if ( filter->inst == NULL )
-  return -1;
-
- roar_mm_free(filter->inst);
-
- return 0;
-}
-
-#define _calcX2(bits) \
-int roardsp_swap_calc##bits##2(struct roardsp_filter * filter, void * data, size_t samples) { \
- int##bits##_t * d = data; \
- register int##bits##_t s; \
- size_t i; \
-\
- (void)filter; \
-\
- for (i = 0; i < samples; i += 2) { \
-  ROAR_DBG("roardsp_swap_calc*2(*): d[i]=%i, d[i+1]=%i", d[i], d[i+1]); \
-  s      = d[i]; \
-  d[i]   = d[i+1]; \
-  d[i+1] = s; \
- } \
-\
- return 0; \
-}
-
-_calcX2(8)
-_calcX2(16)
-_calcX2(32)
-
-int roardsp_swap_ctl    (struct roardsp_filter * filter, int cmd, void * data) {
- (void)filter, (void)cmd, (void)data;
- roar_err_set(ROAR_ERROR_NOSYS);
- return -1;
-}
-
-int roardsp_swap_reset  (struct roardsp_filter * filter, int what) {
- struct roardsp_swap * inst = NULL;
- int i;
-
- if ( filter == NULL )
-  return -1;
-
- if ( (inst = filter->inst) == NULL )
-  return -1;
-
- switch (what) {
-  case ROARDSP_RESET_NONE:
-  case ROARDSP_RESET_STATE:
-    return  0;
-   break;
-  case ROARDSP_RESET_FULL:
-    memset(inst, 0, sizeof(struct roardsp_swap));
-
-    for (i = 0; i < ROAR_MAX_CHANNELS; i++)
-     inst->map[i] = i;
-
-    inst->map[0] = 1;
-    inst->map[1] = 0;
-    return  0;
-   break;
-  default:
-    return -1;
- }
-
- return -1;
-}
-
-//ll
Index: libroardsp/filterchain.c
===================================================================
--- libroardsp/filterchain.c	(revision 6052)
+++ 	(revision )
@@ -1,121 +1,0 @@
-//filterchain.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-int roardsp_fchain_init  (struct roardsp_filterchain * chain) {
- if ( chain == NULL )
-  return -1;
-
- memset((void*)chain, 0, sizeof(struct roardsp_filterchain));
- return 0;
-}
-
-int roardsp_fchain_uninit(struct roardsp_filterchain * chain) {
- int i;
- int ret = 0;
-
- if ( chain == NULL )
-  return -1;
-
- for (i = 0; i < chain->filters; i++) {
-  if ( roardsp_filter_uninit(chain->filter[i]) == -1 )
-   ret = -1;
- }
-
- if ( roardsp_fchain_init(chain) == -1 )
-  ret = -1;
-
- return ret;
-}
-
-int roardsp_fchain_add   (struct roardsp_filterchain * chain, struct roardsp_filter * filter) {
- if ( chain == NULL )
-  return -1;
-
- if ( chain->filters < ROARDSP_MAX_FILTERS_PER_CHAIN ) {
-  chain->filter[chain->filters++] = filter;
-  return 0;
- }
-
- return -1;
-}
-
-int roardsp_fchain_calc  (struct roardsp_filterchain * chain, void * data, size_t len) {
- int i;
- int ret = 0;
-
- if ( chain == NULL )
-  return -1;
-
- for (i = 0; i < chain->filters; i++) {
-  if ( roardsp_filter_calc(chain->filter[i], data, len) == -1 )
-   ret = -1;
- }
-
- return ret;
-}
-
-int roardsp_fchain_reset (struct roardsp_filterchain * chain, int what) {
- int i;
- int ret = 0;
-/*
- struct roardsp_filterchain backup[1];
-*/
-
- if ( chain == NULL )
-  return -1;
-
-/*
- if ( what == ROARDSP_RESET_FULL ) {
-  if ( roardsp_fchain_init(backup) == -1 )
-   return -1;
-
-  if ( roardsp_fchain_uninit(chain) == -1 )
-   return -1;
-
-  if ( roardsp_fchain_init(chain) == -1 )
-   return -1;
- } else {
-*/
-  for (i = 0; i < chain->filters; i++) {
-   if ( roardsp_filter_reset(chain->filter[i], what) == -1 )
-    ret = -1;
-  }
-/*
- }
-*/
-
- return ret;
-}
-
-int roardsp_fchain_num   (struct roardsp_filterchain * chain) {
- if ( chain == NULL )
-  return -1;
-
- return chain->filters;
-}
-
-//ll
Index: libroardsp/float.c
===================================================================
--- libroardsp/float.c	(revision 6052)
+++ 	(revision )
@@ -1,158 +1,0 @@
-//float.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2009-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-#include "libroardsp.h"
-
-static inline float   _si32_to_float (int32_t src) {
- if ( src > 0 ) {
-  return (float)src / 2147483647.f;
- } else {
-  return (float)src / 2147483648.f;
- }
-}
-
-static inline int32_t _float_to_si32 (float   src) {
- if ( src > 0 ) {
-  return (src * 2147483647.f);
- } else {
-  return (src * 2147483648.f);
- }
-}
-
-int roar_conv_int32_float(float   * dst, const int32_t * src, size_t len) {
- size_t i;
-
- if ( len == 0 )
-  return 0;
-
- if ( dst == NULL || src == NULL )
-  return -1;
-
- for (i = 0; i < len; i++)
-  dst[i] = _si32_to_float(src[i]);
-
- return 0;
-}
-
-int roar_conv_float_int32(int32_t * dst, const float   * src, size_t len) {
- size_t i;
-
- if ( len == 0 )
-  return 0;
-
- if ( dst == NULL || src == NULL )
-  return -1;
-
- for (i = 0; i < len; i++)
-  dst[i] = _float_to_si32(src[i]);
-
- return 0;
-}
-
-int roar_conv_int32_float_deint(float   ** dst, const int32_t * src, size_t len, size_t channels) {
- register size_t i, c, o;
-
- ROAR_DBG("roar_conv_int32_float_deint(*) = ?");
-
- if ( len == 0 )
-  return 0;
-
- ROAR_DBG("roar_conv_int32_float_deint(*) = ?");
-
- if ( dst == NULL || src == NULL )
-  return -1;
-
- ROAR_DBG("roar_conv_int32_float_deint(*) = ?");
-
- // check if len is a multiple of channels:
- if ( (len % channels) != 0 )
-  return -1;
-
- ROAR_DBG("roar_conv_int32_float_deint(*) = ?");
-
- for (c = 0; c < channels; c++)
-  if ( dst[c] == NULL )
-   return -1;
-
- ROAR_DBG("roar_conv_int32_float_deint(*) = ?");
-
- switch (channels) {
-  case  1:
-    return roar_conv_int32_float(dst[0], src, len);
-   break;
-  case  2:
-    for (i = o = 0; i < len; i += 2, o += 1) {
-     dst[0][o] = _si32_to_float(src[i+0]);
-     dst[1][o] = _si32_to_float(src[i+1]);
-    }
-   break;
-  default:
-    for (i = c = o = 0; i < len; i++) {
-     dst[c][o] = _si32_to_float(src[i]);
-     c++;
-     if ( c == channels ) {
-      c = 0;
-      o++;
-     }
-    }
-   break;
- }
-
- return 0;
-}
-
-int roar_conv_float_int32_enint(int32_t  * dst, const float   ** src, size_t len, size_t channels) {
- size_t i, c, o;
-
- if ( len == 0 )
-  return 0;
-
- if ( dst == NULL || src == NULL )
-  return -1;
-
- // check if len is a multiple of channels:
- if ( (len % channels) != 0 )
-  return -1;
-
- for (c = 0; c < channels; c++)
-  if ( src[c] == NULL )
-   return -1;
-
- switch (channels) {
-  default:
-    for (i = c = o = 0; o < len; o++) {
-     dst[o] = _float_to_si32(src[c][i]);
-     c++;
-     if ( c == channels ) {
-      c = 0;
-      i++;
-     }
-    }
-   break;
- }
-
- return 0;
-}
-
-//ll
Index: libroardsp/interleave.c
===================================================================
--- libroardsp/interleave.c	(revision 6052)
+++ 	(revision )
@@ -1,148 +1,0 @@
-//interleave.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2009-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-int roar_interl_init  (struct roar_interleave * state, size_t channels, size_t bits) {
- if ( state == NULL ) {
-  roar_err_set(ROAR_ERROR_FAULT);
-  return -1;
- }
-
- // we can currently only hanle full bytes:
- if ( bits % 8 )
-  return -1;
-
- // currently we have a channel limit
- if ( channels > ROAR_INTERLEAVE_MAX_CHANNELS ) {
-  roar_err_set(ROAR_ERROR_RANGE);
-  return -1;
- }
-
- memset(state, 0, sizeof(struct roar_interleave));
-
- state->channels = channels;
- state->bits     = bits;
-
- return 0;
-}
-
-int roar_interl_uninit(struct roar_interleave * state) {
- if ( state == NULL ) {
-  roar_err_set(ROAR_ERROR_FAULT);
-  return -1;
- }
-
- memset(state, 0, sizeof(struct roar_interleave));
-
- return 0;
-}
-
-int roar_interl_ctl   (struct roar_interleave * state, int cmd, void * data) {
- if ( state == NULL ) {
-  roar_err_set(ROAR_ERROR_FAULT);
-  return -1;
- }
-
- (void)state, (void)cmd, (void)data;
-
- roar_err_set(ROAR_ERROR_NOSYS);
- return -1;
-}
-
-int roar_interl_encode_ext(struct roar_interleave * state, void ** in, void  * out, size_t len) {
- size_t chan = 0;
- size_t oc;
- size_t bc   = 0; // bit counter
- char   * ip[ROAR_INTERLEAVE_MAX_CHANNELS]; // output pointer
-
- if ( state == NULL ) {
-  roar_err_set(ROAR_ERROR_FAULT);
-  return -1;
- }
-
- if ( in == NULL || out == NULL ) {
-  roar_err_set(ROAR_ERROR_FAULT);
-  return -1;
- }
-
- if ( len == 0 )
-  return 0;
-
- memcpy(ip, in, sizeof(void*)*state->channels);
-
- for (oc = 0; oc < len; oc++) {
-  ((char*)out)[oc] = *(ip[chan]);
-  ip[chan]++;
-
-  bc += 8;
-
-  if ( bc == state->bits ) {
-   bc = 0;
-   chan++;
-   if ( chan == state->channels )
-    chan = 0;
-  }
- }
-
- return -1;
-}
-
-int roar_interl_decode_ext(struct roar_interleave * state, void * in, void ** out, size_t len) {
- size_t chan = 0;
- size_t ic;       // input counter
- size_t bc   = 0; // bit counter
- char   * op[ROAR_INTERLEAVE_MAX_CHANNELS]; // output pointer
-
- if ( state == NULL )
-  return -1;
-
- if ( in == NULL || out == NULL )
-  return -1;
-
- if ( len == 0 )
-  return 0;
-
- memcpy(op, out, sizeof(void*)*state->channels);
-
- for (ic = 0; ic < len; ic++) {
-  // get char and copy it
-  *(op[chan]) = ((char*)in)[ic];
-  op[chan]++;
-
-  bc += 8;
-
-  if ( bc == state->bits ) {
-   bc = 0;
-   chan++;
-   if ( chan == state->channels )
-    chan = 0;
-  }
- }
-
- return -1;
-}
-
-//ll
Index: libroardsp/libroardsp.c
===================================================================
--- libroardsp/libroardsp.c	(revision 6052)
+++ 	(revision )
@@ -1,28 +1,0 @@
-//libroardsp.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-//ll
Index: libroardsp/midi.c
===================================================================
--- libroardsp/midi.c	(revision 6052)
+++ 	(revision )
@@ -1,243 +1,0 @@
-//midi.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-struct {
- uint16_t id;
- unsigned char midiid;
- float freq;
- char * name;
-} _libroar_notes[] = {
- {ROAR_MIDI_NOTE_C , 60, 261.625565, "C" },
- {ROAR_MIDI_NOTE_Cs, 61, 277.182631, "C#"},
- {ROAR_MIDI_NOTE_D , 62, 293.664768, "D" },
- {ROAR_MIDI_NOTE_Ds, 63, 311.126984, "D#"},
- {ROAR_MIDI_NOTE_E , 64, 329.627557, "E" },
- {ROAR_MIDI_NOTE_F , 65, 349.228231, "F" },
- {ROAR_MIDI_NOTE_Fs, 66, 369.994423, "F#"},
- {ROAR_MIDI_NOTE_G , 67, 391.995436, "G" },
- {ROAR_MIDI_NOTE_Gs, 68, 415.304698, "G#"},
- {ROAR_MIDI_NOTE_A , 69, 440.000000, "A" },
- {ROAR_MIDI_NOTE_As, 70, 466.163762, "A#"},
- {ROAR_MIDI_NOTE_B , 71, 493.883301, "B" },
- {0, 0, 0, NULL}
-};
-
-char         * roar_midi_note2name   (uint16_t note) {
- int i;
-
- for (i = 0; _libroar_notes[i].name != NULL; i++)
-  if ( _libroar_notes[i].id == note )
-   return _libroar_notes[i].name;
-
- return NULL;
-}
-
-uint16_t   roar_midi_name2note   (char * note) {
- int i;
-
- for (i = 0; _libroar_notes[i].name != NULL; i++)
-  if ( strcasecmp(_libroar_notes[i].name, note) == 0 )
-   return _libroar_notes[i].id;
-
- return ROAR_MIDI_NOTE_NONE;
-}
-
-uint16_t       roar_midi_midi2note   (unsigned char midiid) {
- int i;
-
- for (i = 0; _libroar_notes[i].name != NULL; i++)
-  if ( _libroar_notes[i].midiid == midiid )
-   return _libroar_notes[i].id;
-
- return ROAR_MIDI_NOTE_NONE;
-}
-
-float          roar_midi_note2freq   (uint16_t note) {
- int i;
-
- for (i = 0; _libroar_notes[i].name != NULL; i++)
-  if ( _libroar_notes[i].id == note )
-   return _libroar_notes[i].freq;
-
- return -1;
-}
-
-int            roar_midi_note_from_midiid(struct roar_note_octave * note, unsigned char midiid) {
- int oct;
-
- if ( note == NULL || midiid > 127 )
-  return -1;
-
- memset(note, 0, sizeof(struct roar_note_octave));
-
- note->octave = ((int) midiid/12) - 5;
- note->note   = roar_midi_midi2note((midiid % 12) + 60);
-
- oct = 1 << abs(note->octave);
-
- note->freq = roar_midi_note2freq(note->note);
-
- if ( note->octave < 0 ) {
-  note->freq /= oct;
- } else {
-  note->freq *= oct;
- }
-
- return 0;
-}
-
-int            roar_midi_find_octave (char * note);
-int            roar_midi_add_octave  (struct roar_note_octave * note) {
- note->name[0] = 0;
- return -1;
-}
-
-int            roar_midi_notefill    (struct roar_note_octave * note) {
- int oct;
-
- if ( !note )
-  return -1;
-
- if ( note->note && note->name[0] == 0 ) {
-  roar_midi_add_octave(note);
- } else if ( !note->note && note->name[0] != 0 ) {
-  return -1;
- }
-
- oct = 1 << abs(note->octave);
-
- note->freq = roar_midi_note2freq(note->note);
-
- // TODO: fix this: freq is freq*2^octave
- if ( note->octave < 0 ) {
-  note->freq /= oct;
- } else {
-  note->freq *= oct;
- }
-
- return 0;
-}
-
-int roar_midi_gen_tone (struct roar_note_octave * note, int16_t * samples, float t, int rate, int channels, int type, void * opts) {
-#ifdef ROAR_HAVE_LIBM
- int i, c;
- float ct;
- float step = 1.0/rate;
- int16_t s;
- float (*op)(float x) = NULL;
-
-/*
- rate: 1/s
- t   : 1s
- freq: 1/s
- rew : 1s
-*/
-
- if ( type == ROAR_MIDI_TYPE_SINE ) {
-  op = sinf;
- } else {
-  return -1;
- }
-
- if ( op == NULL )
-  return -1;
-
- ROAR_DBG("roar_midi_gen_tone(*): t=%f", t);
-
- for (ct = 0, i = 0; ct <= t; ct += step, i += channels) {
-  s = 32767*op(2.0*M_PI*note->freq*ct);
-
-//  ROAR_DBG("roar_midi_gen_tone(*): t=%f, ct=%f, i=%i", t, ct, i);
-
-  for (c = 0; c < channels; c++)
-   samples[i+c] = s;
- }
-
- ROAR_DBG("roar_midi_gen_tone(*): t=%f, ct=%f, i=%i", t, ct, i);
-
- return 0;
-#else
- return -1;
-#endif
-}
-
-
-int roar_midi_play_note  (struct roar_stream * stream, struct roar_note_octave * note, float len) {
- return -1;
-}
-
-int roar_midi_basic_init (struct roar_midi_basic_state * state) {
- if (!state)
-  return -1;
-
- state->len.mul = 1;
- state->len.div = 60;
-
- state->note.note   = ROAR_MIDI_NOTE_NONE;
- state->note.octave = 0;
-
- return 0;
-}
-
-int roar_midi_basic_play (struct roar_stream * stream, struct roar_midi_basic_state * state, char * notes) {
- struct roar_midi_basic_state is;
-#if 0
- char   cn[ROAR_MIDI_MAX_NOTENAME_LEN+1] = {0};
- int i;
-#endif
- int have = 0;
- struct roar_note_octave * n;
-
- if ( !notes )
-  return -1;
-
- if ( state == NULL ) {
-  state = &is;
-  roar_midi_basic_init(state);
- }
-
- n = &(state->note);
-
- for (; *notes != 0; notes++) {
-  if ( *notes == '>' ) {
-   n->octave++;
-  } else if ( *notes == '<' ) {
-   n->octave--;
-  } else if ( *notes != ' ' ) {
-   have++;
-  }
-
-  if (have) {
-   roar_midi_play_note(stream, n, 60 * state->len.mul / state->len.div);
-   have = 0;
-  }
- }
-
- return 0;
-}
-
-//ll
Index: libroardsp/midside.c
===================================================================
--- libroardsp/midside.c	(revision 6052)
+++ 	(revision )
@@ -1,131 +1,0 @@
-//midside.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2009-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-int roar_conv_s2ms_8      (void * out, void * in, int samples) {
- char * ip = in;
- char * op = out;
- register int i;
- register char mid;
- register char side;
-
- for (i = 0; i < samples; i += 2) {
-  mid     = (ip[i] + ip[i+1])/2;
-  side    = (ip[i] - ip[i+1])/2;
-  op[i  ] = mid;
-  op[i+1] = side;
- }
-
- return 0;
-}
-
-int roar_conv_s2ms_16     (void * out, void * in, int samples) {
- int16_t * ip = in;
- int16_t * op = out;
- register int i;
- register int16_t mid;
- register int16_t side;
-
- for (i = 0; i < samples; i += 2) {
-  mid     = (ip[i] + ip[i+1])/2;
-  side    = (ip[i] - ip[i+1])/2;
-  op[i  ] = mid;
-  op[i+1] = side;
- }
-
- return 0;
-}
-
-int roar_conv_s2ms_32     (void * out, void * in, int samples) {
- int32_t * ip = in;
- int32_t * op = out;
- register int i;
- register int32_t mid;
- register int32_t side;
-
- for (i = 0; i < samples; i += 2) {
-  mid     = (ip[i] + ip[i+1])/2;
-  side    = (ip[i] - ip[i+1])/2;
-  op[i  ] = mid;
-  op[i+1] = side;
- }
-
- return 0;
-}
-
-int roar_conv_ms2s_8      (void * out, void * in, int samples) {
- char * ip = in;
- char * op = out;
- register int i;
- register char mid;
- register char side;
-
- for (i = 0; i < samples; i += 2) {
-  mid     = ip[i];
-  side    = ip[i+1];
-  op[i  ] = mid + side;
-  op[i+1] = mid - side;
- }
-
- return 0;
-}
-
-int roar_conv_ms2s_16     (void * out, void * in, int samples) {
- int16_t * ip = in;
- int16_t * op = out;
- register int i;
- register int16_t mid;
- register int16_t side;
-
- for (i = 0; i < samples; i += 2) {
-  mid     = ip[i];
-  side    = ip[i+1];
-  op[i  ] = mid + side;
-  op[i+1] = mid - side;
- }
-
- return 0;
-}
-
-int roar_conv_ms2s_32     (void * out, void * in, int samples) {
- int32_t * ip = in;
- int32_t * op = out;
- register int i;
- register int32_t mid;
- register int32_t side;
-
- for (i = 0; i < samples; i += 2) {
-  mid     = ip[i];
-  side    = ip[i+1];
-  op[i  ] = mid + side;
-  op[i+1] = mid - side;
- }
-
- return 0;
-}
-
-
-//ll
Index: libroardsp/mixer.c
===================================================================
--- libroardsp/mixer.c	(revision 6052)
+++ 	(revision )
@@ -1,108 +1,0 @@
-//mixer.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-int roar_mix_pcm       (void    * output, int bits, void ** input, int samples) {
- switch (bits) {
-  case  8: return roar_mix_pcm_8bit (output, (int8_t  **)input, samples); break;
-  case 16: return roar_mix_pcm_16bit(output, (int16_t **)input, samples); break;
-  case 32: return roar_mix_pcm_32bit(output, (int32_t **)input, samples); break;
-  default: return -1;
- }
-}
-
-int roar_mix_pcm_8bit  (int8_t  * output, int8_t  ** input, int samples) {
- int i, s;
- register int c;
-
- for (s = 0; s < samples; s++) {
-  c = 0;
-
-  for (i = 0; input[i] != NULL; i++)
-   c += input[i][s];
-
-  if ( c > 127 )
-   c = 127;
-  else if ( c < -128 )
-   c = -128;
-  output[s] = (char)c;
- }
-
- return 0;
-}
-
-int roar_mix_pcm_16bit (int16_t * output, int16_t ** input, int samples) {
- int i, s;
- register int_least32_t c;
-
-#ifdef DEBUG
- for (i = 0; input[i] != NULL; i++)
-  ROAR_DBG("mix_clients_16bit(*): input[%i] = %p", i, input[i]);
-#endif
-
- for (s = 0; s < samples; s++) {
-  c = 0;
-  for (i = 0; input[i] != NULL; i++) {
-   c += input[i][s];
-  }
-
-  if ( c > 32767 )
-   c = 32767;
-  else if ( c < -32768 )
-   c = -32768;
-
-  output[s] = c;
- }
-
- return 0;
-}
-
-int roar_mix_pcm_32bit (int32_t * output, int32_t ** input, int samples) {
-#ifdef ROAR_NATIVE_INT64
- int i, s;
- ROAR_NATIVE_INT64 c;
-
- for (s = 0; s < samples; s++) {
-  c = 0;
-
-  for (i = 0; input[i]; i++)
-   c += input[i][s];
-
-  if ( c > 21474836487LL )
-   c = 2147483647LL;
-  else if ( c < -2147483648LL )
-   c = -2147483648LL;
-  output[s] = (int32_t)c;
- }
-
- return  0;
-#else
- return -1;
-#endif
-}
-
-
-//ll
Index: libroardsp/mulaw.c
===================================================================
--- libroardsp/mulaw.c	(revision 6052)
+++ 	(revision )
@@ -1,1505 +1,0 @@
-//mulaw.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-/*
-
- * In addition to the above copyright statement codec marked with
- * '-------- SUN --------' is under the following license as it is extracted
- * from SoX 12.17.9:
-
- * This source code is a product of Sun Microsystems, Inc. and is provided
- * for unrestricted use.  Users may copy or modify this source code without
- * charge.
- *
- * SUN SOURCE CODE IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING
- * THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
- *
- * Sun source code is provided with no support and without any obligation on
- * the part of Sun Microsystems, Inc. to assist in its use, correction,
- * modification or enhancement.
- *
- * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
- * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY THIS SOFTWARE
- * OR ANY PART THEREOF.
- *
- * In no event will Sun Microsystems, Inc. be liable for any lost revenue
- * or profits or other special, indirect and consequential damages, even if
- * Sun has been advised of the possibility of such damages.
- *
- * Sun Microsystems, Inc.
- * 2550 Garcia Avenue
- * Mountain View, California  94043
-*/
-
-#include "libroardsp.h"
-
-#ifdef ROAR_SUPPORT_MULAW
-static const int16_t _roardsp_mulaw2pcm16[] = {
-/* -------- SUN -------- */
-    -32124,  -31100,  -30076,  -29052,  -28028,  -27004,  -25980,
-    -24956,  -23932,  -22908,  -21884,  -20860,  -19836,  -18812,
-    -17788,  -16764,  -15996,  -15484,  -14972,  -14460,  -13948,
-    -13436,  -12924,  -12412,  -11900,  -11388,  -10876,  -10364,
-     -9852,   -9340,   -8828,   -8316,   -7932,   -7676,   -7420,
-     -7164,   -6908,   -6652,   -6396,   -6140,   -5884,   -5628,
-     -5372,   -5116,   -4860,   -4604,   -4348,   -4092,   -3900,
-     -3772,   -3644,   -3516,   -3388,   -3260,   -3132,   -3004,
-     -2876,   -2748,   -2620,   -2492,   -2364,   -2236,   -2108,
-     -1980,   -1884,   -1820,   -1756,   -1692,   -1628,   -1564,
-     -1500,   -1436,   -1372,   -1308,   -1244,   -1180,   -1116,
-     -1052,    -988,    -924,    -876,    -844,    -812,    -780,
-      -748,    -716,    -684,    -652,    -620,    -588,    -556,
-      -524,    -492,    -460,    -428,    -396,    -372,    -356,
-      -340,    -324,    -308,    -292,    -276,    -260,    -244,
-      -228,    -212,    -196,    -180,    -164,    -148,    -132,
-      -120,    -112,    -104,     -96,     -88,     -80,     -72,
-       -64,     -56,     -48,     -40,     -32,     -24,     -16,
-        -8,       0,   32124,   31100,   30076,   29052,   28028,
-     27004,   25980,   24956,   23932,   22908,   21884,   20860,
-     19836,   18812,   17788,   16764,   15996,   15484,   14972,
-     14460,   13948,   13436,   12924,   12412,   11900,   11388,
-     10876,   10364,    9852,    9340,    8828,    8316,    7932,
-      7676,    7420,    7164,    6908,    6652,    6396,    6140,
-      5884,    5628,    5372,    5116,    4860,    4604,    4348,
-      4092,    3900,    3772,    3644,    3516,    3388,    3260,
-      3132,    3004,    2876,    2748,    2620,    2492,    2364,
-      2236,    2108,    1980,    1884,    1820,    1756,    1692,
-      1628,    1564,    1500,    1436,    1372,    1308,    1244,
-      1180,    1116,    1052,     988,     924,     876,     844,
-       812,     780,     748,     716,     684,     652,     620,
-       588,     556,     524,     492,     460,     428,     396,
-       372,     356,     340,     324,     308,     292,     276,
-       260,     244,     228,     212,     196,     180,     164,
-       148,     132,     120,     112,     104,      96,      88,
-        80,      72,      64,      56,      48,      40,      32,
-        24,      16,       8,       0
-/* -------- /SUN -------- */
-};
-
-#ifdef ROAR_SUPPORT_MULAW_RW
-static const int8_t _roardsp_pcm142mulaw[] = {
-/* -------- SUN -------- */
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 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, 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, 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, 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, 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, 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, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 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, 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,
-   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, 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, 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, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
-   0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-   0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-   0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-   0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-   0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-   0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
-   0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
-   0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-   0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
-   0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-   0x0f, 0x0f, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
-   0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
-   0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
-   0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
-   0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
-   0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
-   0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
-   0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
-   0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
-   0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
-   0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x11, 0x11,
-   0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
-   0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
-   0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
-   0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
-   0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
-   0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
-   0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
-   0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
-   0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
-   0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
-   0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
-   0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
-   0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
-   0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
-   0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
-   0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
-   0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
-   0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
-   0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
-   0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
-   0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
-   0x12, 0x12, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
-   0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
-   0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
-   0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
-   0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
-   0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
-   0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
-   0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
-   0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
-   0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
-   0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x14, 0x14,
-   0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
-   0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
-   0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
-   0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
-   0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
-   0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
-   0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
-   0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
-   0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
-   0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
-   0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
-   0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
-   0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
-   0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
-   0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
-   0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
-   0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
-   0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
-   0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
-   0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
-   0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
-   0x15, 0x15, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
-   0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
-   0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
-   0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
-   0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
-   0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
-   0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
-   0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
-   0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
-   0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
-   0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x17, 0x17,
-   0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
-   0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
-   0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
-   0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
-   0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
-   0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
-   0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
-   0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
-   0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
-   0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
-   0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-   0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-   0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-   0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-   0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-   0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-   0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-   0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-   0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-   0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-   0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-   0x18, 0x18, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
-   0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
-   0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
-   0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
-   0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
-   0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
-   0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
-   0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
-   0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
-   0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
-   0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x1a, 0x1a,
-   0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
-   0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
-   0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
-   0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
-   0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
-   0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
-   0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
-   0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
-   0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
-   0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
-   0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
-   0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
-   0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
-   0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
-   0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
-   0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
-   0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
-   0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
-   0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
-   0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
-   0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
-   0x1b, 0x1b, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
-   0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
-   0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
-   0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
-   0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
-   0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
-   0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
-   0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
-   0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
-   0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
-   0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1d, 0x1d,
-   0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
-   0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
-   0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
-   0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
-   0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
-   0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
-   0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
-   0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
-   0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
-   0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
-   0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
-   0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
-   0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
-   0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
-   0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
-   0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
-   0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
-   0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
-   0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
-   0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
-   0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
-   0x1e, 0x1e, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
-   0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
-   0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
-   0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
-   0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
-   0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
-   0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
-   0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
-   0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
-   0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
-   0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x20, 0x20,
-   0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-   0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-   0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-   0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-   0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-   0x20, 0x20, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
-   0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
-   0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
-   0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
-   0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
-   0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-   0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-   0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-   0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-   0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-   0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x23, 0x23,
-   0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
-   0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
-   0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
-   0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
-   0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
-   0x23, 0x23, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
-   0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
-   0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
-   0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
-   0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
-   0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
-   0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
-   0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
-   0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
-   0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
-   0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x26, 0x26,
-   0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
-   0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
-   0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
-   0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
-   0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
-   0x26, 0x26, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
-   0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
-   0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
-   0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
-   0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
-   0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
-   0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
-   0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
-   0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
-   0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
-   0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x29, 0x29,
-   0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
-   0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
-   0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
-   0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
-   0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
-   0x29, 0x29, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
-   0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
-   0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
-   0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
-   0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
-   0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
-   0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
-   0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
-   0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
-   0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
-   0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2c, 0x2c,
-   0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
-   0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
-   0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
-   0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
-   0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
-   0x2c, 0x2c, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-   0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-   0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-   0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-   0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-   0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
-   0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
-   0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
-   0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
-   0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
-   0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2f, 0x2f,
-   0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
-   0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
-   0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
-   0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
-   0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
-   0x2f, 0x2f, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
-   0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
-   0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31,
-   0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
-   0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
-   0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
-   0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
-   0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
-   0x32, 0x32, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
-   0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
-   0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x34, 0x34,
-   0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34,
-   0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34,
-   0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
-   0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
-   0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
-   0x35, 0x35, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
-   0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
-   0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x37,
-   0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37,
-   0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37,
-   0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
-   0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
-   0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
-   0x38, 0x38, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39,
-   0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39,
-   0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x3a, 0x3a,
-   0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a,
-   0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a,
-   0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b,
-   0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b,
-   0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b,
-   0x3b, 0x3b, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c,
-   0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c,
-   0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3d, 0x3d,
-   0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,
-   0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,
-   0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e,
-   0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e,
-   0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e,
-   0x3e, 0x3e, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
-   0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
-   0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x40, 0x40,
-   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-   0x40, 0x40, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,
-   0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
-   0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x43, 0x43,
-   0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43,
-   0x43, 0x43, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
-   0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45,
-   0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x46, 0x46,
-   0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46,
-   0x46, 0x46, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47,
-   0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48,
-   0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x49, 0x49,
-   0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49,
-   0x49, 0x49, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a,
-   0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b,
-   0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4c, 0x4c,
-   0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c,
-   0x4c, 0x4c, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d,
-   0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x4e, 0x4e, 0x4e, 0x4e, 0x4e, 0x4e,
-   0x4e, 0x4e, 0x4e, 0x4e, 0x4e, 0x4e, 0x4e, 0x4e, 0x4e, 0x4e, 0x4f, 0x4f,
-   0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f,
-   0x4f, 0x4f, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x51, 0x51,
-   0x51, 0x51, 0x51, 0x51, 0x51, 0x51, 0x52, 0x52, 0x52, 0x52, 0x52, 0x52,
-   0x52, 0x52, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x54, 0x54,
-   0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
-   0x55, 0x55, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x57, 0x57,
-   0x57, 0x57, 0x57, 0x57, 0x57, 0x57, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58,
-   0x58, 0x58, 0x59, 0x59, 0x59, 0x59, 0x59, 0x59, 0x59, 0x59, 0x5a, 0x5a,
-   0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b,
-   0x5b, 0x5b, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5d, 0x5d,
-   0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5e, 0x5e, 0x5e, 0x5e, 0x5e, 0x5e,
-   0x5e, 0x5e, 0x5f, 0x5f, 0x5f, 0x5f, 0x5f, 0x5f, 0x5f, 0x5f, 0x60, 0x60,
-   0x60, 0x60, 0x61, 0x61, 0x61, 0x61, 0x62, 0x62, 0x62, 0x62, 0x63, 0x63,
-   0x63, 0x63, 0x64, 0x64, 0x64, 0x64, 0x65, 0x65, 0x65, 0x65, 0x66, 0x66,
-   0x66, 0x66, 0x67, 0x67, 0x67, 0x67, 0x68, 0x68, 0x68, 0x68, 0x69, 0x69,
-   0x69, 0x69, 0x6a, 0x6a, 0x6a, 0x6a, 0x6b, 0x6b, 0x6b, 0x6b, 0x6c, 0x6c,
-   0x6c, 0x6c, 0x6d, 0x6d, 0x6d, 0x6d, 0x6e, 0x6e, 0x6e, 0x6e, 0x6f, 0x6f,
-   0x6f, 0x6f, 0x70, 0x70, 0x71, 0x71, 0x72, 0x72, 0x73, 0x73, 0x74, 0x74,
-   0x75, 0x75, 0x76, 0x76, 0x77, 0x77, 0x78, 0x78, 0x79, 0x79, 0x7a, 0x7a,
-   0x7b, 0x7b, 0x7c, 0x7c, 0x7d, 0x7d, 0x7e, 0x7e, 0xff, 0xfe, 0xfe, 0xfd,
-   0xfd, 0xfc, 0xfc, 0xfb, 0xfb, 0xfa, 0xfa, 0xf9, 0xf9, 0xf8, 0xf8, 0xf7,
-   0xf7, 0xf6, 0xf6, 0xf5, 0xf5, 0xf4, 0xf4, 0xf3, 0xf3, 0xf2, 0xf2, 0xf1,
-   0xf1, 0xf0, 0xf0, 0xef, 0xef, 0xef, 0xef, 0xee, 0xee, 0xee, 0xee, 0xed,
-   0xed, 0xed, 0xed, 0xec, 0xec, 0xec, 0xec, 0xeb, 0xeb, 0xeb, 0xeb, 0xea,
-   0xea, 0xea, 0xea, 0xe9, 0xe9, 0xe9, 0xe9, 0xe8, 0xe8, 0xe8, 0xe8, 0xe7,
-   0xe7, 0xe7, 0xe7, 0xe6, 0xe6, 0xe6, 0xe6, 0xe5, 0xe5, 0xe5, 0xe5, 0xe4,
-   0xe4, 0xe4, 0xe4, 0xe3, 0xe3, 0xe3, 0xe3, 0xe2, 0xe2, 0xe2, 0xe2, 0xe1,
-   0xe1, 0xe1, 0xe1, 0xe0, 0xe0, 0xe0, 0xe0, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf,
-   0xdf, 0xdf, 0xdf, 0xde, 0xde, 0xde, 0xde, 0xde, 0xde, 0xde, 0xde, 0xdd,
-   0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc,
-   0xdc, 0xdc, 0xdc, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xda,
-   0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xd9, 0xd9, 0xd9, 0xd9, 0xd9,
-   0xd9, 0xd9, 0xd9, 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0xd7,
-   0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6,
-   0xd6, 0xd6, 0xd6, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd4,
-   0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3,
-   0xd3, 0xd3, 0xd3, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd1,
-   0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd0, 0xd0, 0xd0, 0xd0, 0xd0,
-   0xd0, 0xd0, 0xd0, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf,
-   0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xce, 0xce, 0xce, 0xce, 0xce,
-   0xce, 0xce, 0xce, 0xce, 0xce, 0xce, 0xce, 0xce, 0xce, 0xce, 0xce, 0xcd,
-   0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
-   0xcd, 0xcd, 0xcd, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
-   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb,
-   0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xca,
-   0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca,
-   0xca, 0xca, 0xca, 0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xc9,
-   0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xc8, 0xc8, 0xc8, 0xc8, 0xc8,
-   0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc7,
-   0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7,
-   0xc7, 0xc7, 0xc7, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,
-   0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5,
-   0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc4,
-   0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4,
-   0xc4, 0xc4, 0xc4, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3,
-   0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc2, 0xc2, 0xc2, 0xc2, 0xc2,
-   0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xc1,
-   0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1,
-   0xc1, 0xc1, 0xc1, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0,
-   0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
-   0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
-   0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
-   0xbf, 0xbf, 0xbf, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe,
-   0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe,
-   0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbd,
-   0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd,
-   0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd,
-   0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc,
-   0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc,
-   0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc,
-   0xbc, 0xbc, 0xbc, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
-   0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
-   0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xba,
-   0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba,
-   0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba,
-   0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9,
-   0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9,
-   0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9,
-   0xb9, 0xb9, 0xb9, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8,
-   0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8,
-   0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb7,
-   0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7,
-   0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7,
-   0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6,
-   0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6,
-   0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6,
-   0xb6, 0xb6, 0xb6, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5,
-   0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5,
-   0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb4,
-   0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4,
-   0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4,
-   0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3,
-   0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3,
-   0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3,
-   0xb3, 0xb3, 0xb3, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2,
-   0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2,
-   0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb1,
-   0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1,
-   0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1,
-   0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0,
-   0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0,
-   0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0,
-   0xb0, 0xb0, 0xb0, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
-   0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
-   0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
-   0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
-   0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
-   0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xae, 0xae, 0xae, 0xae, 0xae,
-   0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
-   0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
-   0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
-   0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
-   0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xad,
-   0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
-   0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
-   0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
-   0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
-   0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
-   0xad, 0xad, 0xad, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
-   0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
-   0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
-   0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
-   0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
-   0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xab, 0xab, 0xab, 0xab, 0xab,
-   0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
-   0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
-   0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
-   0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
-   0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xaa,
-   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-   0xaa, 0xaa, 0xaa, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
-   0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
-   0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
-   0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
-   0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
-   0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
-   0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
-   0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
-   0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
-   0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
-   0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa7,
-   0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
-   0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
-   0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
-   0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
-   0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
-   0xa7, 0xa7, 0xa7, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
-   0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
-   0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
-   0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
-   0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
-   0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
-   0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
-   0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
-   0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
-   0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
-   0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa4,
-   0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
-   0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
-   0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
-   0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
-   0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
-   0xa4, 0xa4, 0xa4, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
-   0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
-   0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
-   0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
-   0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
-   0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
-   0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
-   0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
-   0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
-   0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
-   0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa1,
-   0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
-   0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
-   0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
-   0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
-   0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
-   0xa1, 0xa1, 0xa1, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
-   0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
-   0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
-   0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
-   0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
-   0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
-   0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
-   0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
-   0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
-   0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
-   0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
-   0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
-   0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
-   0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
-   0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
-   0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
-   0x9f, 0x9f, 0x9f, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
-   0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
-   0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
-   0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
-   0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
-   0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
-   0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
-   0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
-   0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
-   0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
-   0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9d,
-   0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
-   0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
-   0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
-   0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
-   0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
-   0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
-   0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
-   0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
-   0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
-   0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
-   0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
-   0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
-   0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
-   0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
-   0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
-   0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
-   0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
-   0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
-   0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
-   0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
-   0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
-   0x9c, 0x9c, 0x9c, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
-   0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
-   0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
-   0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
-   0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
-   0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
-   0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
-   0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
-   0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
-   0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
-   0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9a,
-   0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
-   0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
-   0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
-   0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
-   0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
-   0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
-   0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
-   0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
-   0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
-   0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
-   0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x99, 0x99, 0x99, 0x99, 0x99,
-   0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
-   0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
-   0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
-   0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
-   0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
-   0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
-   0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
-   0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
-   0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
-   0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
-   0x99, 0x99, 0x99, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
-   0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
-   0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
-   0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
-   0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
-   0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
-   0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
-   0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
-   0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
-   0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
-   0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x97,
-   0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
-   0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
-   0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
-   0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
-   0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
-   0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
-   0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
-   0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
-   0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
-   0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
-   0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x96, 0x96, 0x96, 0x96, 0x96,
-   0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
-   0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
-   0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
-   0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
-   0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
-   0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
-   0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
-   0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
-   0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
-   0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
-   0x96, 0x96, 0x96, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
-   0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
-   0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
-   0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
-   0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
-   0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
-   0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
-   0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
-   0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
-   0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
-   0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x94,
-   0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
-   0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
-   0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
-   0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
-   0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
-   0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
-   0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
-   0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
-   0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
-   0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
-   0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x93, 0x93, 0x93, 0x93, 0x93,
-   0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
-   0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
-   0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
-   0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
-   0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
-   0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
-   0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
-   0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
-   0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
-   0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
-   0x93, 0x93, 0x93, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
-   0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
-   0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
-   0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
-   0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
-   0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
-   0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
-   0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
-   0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
-   0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
-   0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x91,
-   0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
-   0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
-   0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
-   0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
-   0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
-   0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
-   0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
-   0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
-   0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
-   0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
-   0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x90, 0x90, 0x90, 0x90, 0x90,
-   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
-   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
-   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
-   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
-   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
-   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
-   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
-   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
-   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
-   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
-   0x90, 0x90, 0x90, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
-   0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
-   0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
-   0x8d, 0x8d, 0x8d, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
-   0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
-   0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
-   0x8a, 0x8a, 0x8a, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
-   0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
-   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
-   0x87, 0x87, 0x87, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
-   0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
-   0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
-   0x84, 0x84, 0x84, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-   0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-   0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
-   0x81, 0x81, 0x81, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-   0x80, 0x80, 0x80, 0x80
-/* -------- /SUN -------- */
-};
-#endif
-#endif
-
-int roardsp_conv_mulaw2pcm16 (int16_t * out, char * in, size_t len) {
-#ifdef ROAR_SUPPORT_MULAW
- unsigned char * inp = (unsigned char *) in;
- ssize_t i;
-
- for (i = len-1; i > -1; i--) {
-  out[i] = _roardsp_mulaw2pcm16[inp[i]];
- }
-
- return 0;
-#else
- return -1;
-#endif
-}
-
-int roardsp_conv_pcm162mulaw (char * out, int16_t * in, size_t len) {
-#ifdef ROAR_SUPPORT_MULAW_RW
- unsigned int i;
-
- for (i = 0; i < len; i++) {
-  out[i] = _roardsp_pcm142mulaw[(in[i] + 32768) >> 2];
- }
-
- return 0;
-#else
- return -1;
-#endif
-}
-
-//ll
Index: libroardsp/poly.c
===================================================================
--- libroardsp/poly.c	(revision 6052)
+++ 	(revision )
@@ -1,190 +1,0 @@
-//poly.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2015
- *
- *  This file is part of libroar a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroar 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- *  NOTE for everyone want's to change something and send patches:
- *  read README and HACKING! There a addition information on
- *  the license of this document you need to read before you send
- *  any patches.
- *
- *  NOTE for uses of non-GPL (LGPL,...) software using libesd, libartsc
- *  or libpulse*:
- *  The libs libroaresd, libroararts and libroarpulse link this lib
- *  and are therefore GPL. Because of this it may be illigal to use
- *  them with any software that uses libesd, libartsc or libpulse*.
- */
-
-#include "libroardsp.h"
-
-int roar_math_mkpoly (float * poly, float * data, int len) {
- if ( len == 2 )
-  return roar_math_mkpoly_2x2(poly, data);
- if ( len == 3 )
-  return roar_math_mkpoly_3x3(poly, data);
- if ( len == 4 )
-  return roar_math_mkpoly_4x4(poly, data);
- if ( len == 5 )
-  return roar_math_mkpoly_5x5(poly, data);
-
- return -1;
-}
-
-int roar_math_mkpoly_2x2 (float * poly, float * data) {
-/*
- A B
- 0 1 x
- 1 1 y
-
-B = x
-A = y - x
-*/
-
- poly[0] =           data[0];
- poly[1] = data[1] - data[0];
-
- return 0;
-}
-
-int roar_math_mkpoly_3x3 (float * poly, float * data) {
-/*
- A B C
- 0 0 1 x
- 1 1 1 y
- 4 2 1 z
-*/
-
- poly[0] = data[0];
- poly[1] = 2*data[1] - 2*data[0] - (data[2]-data[0])/2;
- poly[2] = (data[2]-data[0])/2 - data[1] + data[0];
-
-
- return 0;
-}
-
-int roar_math_mkpoly_4x4 (float * poly, float * data) {
-/*
-   a    b    c    d
-   0    0    0    1  A X 0
-   1    1    1    1  B Y 1
-   8    4    2    1  C Z 2
-  27    9    3    1  D Q 3
-*/
-
-
-// { a = -(3z-3y+x-q)/6, b = (4z-5y+2x-q)/2, c = -(9z-18y+11x-2q)/6, d = x }.
-
- poly[0] =      data[0];
- poly[1] = -(11*data[0] - 18*data[1] + 9*data[2] - 2*data[3])/6;
- poly[2] =  (2 *data[0] -  5*data[1] + 4*data[2] -   data[3])/2;
- poly[3] = -(   data[0] -  3*data[1] + 3*data[2] -   data[3])/6;
-
- return 0;
-}
-
-int roar_math_mkpoly_5x5 (float * poly, float * data) {
- roar_err_set(ROAR_ERROR_NOSYS);
- return -1;
-}
-
-
-float roar_math_cvpoly     (float * poly, float t, int len) {
- float ret = 0;
- float ct  = 1;
- int i;
-
- if ( poly == NULL )
-  return 0;
-
- switch (len) {
-  case 4: return roar_math_cvpoly_4x4(poly, t);
- }
-
- for (i = 0; i < len; i++) {
-  ret += poly[i] * ct;
-  ct  *= t;
- }
-
- return ret;
-}
-
-float roar_math_cvpoly_4x4 (float * poly, float t) {
- float ret = poly[0];
- float ct  = t;
-
- ret += poly[1] * ct;
- ct  *= t;
- ret += poly[2] * ct;
- ct  *= t;
- ret += poly[3] * ct;
-
-// printf("ret=%f\n", ret);
-
- return ret;
-}
-
-int roar_math_diffpoly(float * poly, int len) {
- int i;
-
- for (i = 1; i < len; i++) {
-  poly[i-1] = poly[i]*(i+1);
- }
-
- poly[len-1] = 0;
-
- return 0;
-}
-
-int roar_math_intpoly(float * poly, int len, float c) {
- int i;
-
- for (i = len; i > 0; i--) {
-  poly[i] = poly[i-1]/i;
- }
-
- poly[0] = c;
-
- return 0;
-}
-
-float roar_math_numintpoly(float * poly, int len, float st, float et) {
- float ipoly[8];
- float upper, lower;
-
- if (len > 7) {
-  roar_err_set(ROAR_ERROR_RANGE);
-  return -1.;
- }
-
- memcpy(ipoly, poly, sizeof(float)*len);
- roar_math_intpoly(ipoly, len, 0);
-
-// printf("{%f, %f, %f}\n", ipoly[0], ipoly[1], ipoly[2]);
-
- lower = roar_math_cvpoly(ipoly, st, len+1);
- upper = roar_math_cvpoly(ipoly, et, len+1);
-
-// printf("lower(%f)=%f, upper(%f)=%f\n", st, lower, et, upper);
-
- return upper-lower;
-}
-
-//ll
Index: libroardsp/remove.c
===================================================================
--- libroardsp/remove.c	(revision 6052)
+++ 	(revision )
@@ -1,263 +1,0 @@
-//remove.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2009-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-int roar_remove_init (struct roar_remove_state * state) {
- if ( state == NULL )
-  return -1;
-
- memset(state, 0, sizeof(struct roar_remove_state));
-
- state->old = 65535;
-
- return 0;
-}
-
-int roar_remove      (void * inout, void * subs, int samples, int bits, struct roar_remove_state * state) {
- if ( inout == NULL || subs == NULL || samples < 0 )
-  return -1;
-
- switch (bits) {
-  case  8: return roar_remove_8 (inout, subs, samples, state); break;
-  case 16: return roar_remove_16(inout, subs, samples, state); break;
-  case 32: return roar_remove_32(inout, subs, samples, state); break;
- }
-
- return -1;
-}
-
-int roar_remove_8    (int8_t  * inout, int8_t  * subs, int samples, struct roar_remove_state * state) {
- int i;
- register int_least16_t s;
- register int_least16_t peak;
-
- if ( state == NULL ) {
-  for (i = 0; i < samples; i++) {
-   s  = inout[i];
-   s -= subs[i];
-   inout[i] = s;
-  }
- } else {
-  peak = 127;
-  for (i = 0; i < samples; i++) {
-   s  = inout[i];
-   s -= subs[i];
-   s  = s < 0 ? -s : s; // we true 32 bit, not int operation here
-   if ( s > peak )
-    peak = s;
-  }
-
-  for (i = 0; i < samples; i++) {
-   s  = -subs[i];
-   s *=  127;
-   s /=  peak;
-   s +=  inout[i];
-   inout[i] = s;
-  }
- }
-
- return 0;
-}
-
-int roar_remove_16   (int16_t * inout, int16_t * subs, int samples, struct roar_remove_state * state) {
- int i;
- register int32_t s;
- register int32_t peak;
-
- if ( state == NULL ) {
-  for (i = 0; i < samples; i++) {
-   s  = inout[i];
-   s -= subs[i];
-   inout[i] = s;
-  }
- } else {
-  peak = 65535;
-  for (i = 0; i < samples; i++) {
-   s  = inout[i];
-   s -= subs[i];
-   s  = s < 0 ? -s : s; // we true 32 bit, not int operation here
-   if ( s > peak )
-    peak = s;
-  }
-
-  for (i = 0; i < samples; i++) {
-   s  = -subs[i];
-   s *=  65535;
-   s /=  peak;
-   s +=  inout[i];
-   inout[i] = s;
-  }
- }
-
- return 0;
-}
-
-int roar_remove_32   (int32_t * inout, int32_t * subs, int samples, struct roar_remove_state * state) {
- int i;
- register int64_t s;
- register int64_t peak;
-
- if ( state == NULL ) {
-  for (i = 0; i < samples; i++) {
-   s  = inout[i];
-   s -= subs[i];
-   inout[i] = s;
-  }
- } else {
-  peak = 4294967295UL;
-  for (i = 0; i < samples; i++) {
-   s  = inout[i];
-   s -= subs[i];
-   s  = s < 0 ? -s : s; // we true 32 bit, not int operation here
-   if ( s > peak )
-    peak = s;
-  }
-
-  for (i = 0; i < samples; i++) {
-   s  = -subs[i];
-   s *=  4294967295UL;
-   s /=  peak;
-   s +=  inout[i];
-   inout[i] = s;
-  }
- }
-
- return 0;
-}
-
-int roar_remove_so   (void    * subout, void   * in, int samples, int bits, struct roar_remove_state * state) {
- if ( subout == NULL || in == NULL || samples < 0 )
-  return -1;
-
- switch (bits) {
-  case  8: return roar_remove_so8 (subout, in, samples, state); break;
-  case 16: return roar_remove_so16(subout, in, samples, state); break;
-  case 32: return roar_remove_so32(subout, in, samples, state); break;
- }
-
- return -1;
-}
-
-int roar_remove_so8  (int8_t  * subout, int8_t  * in, int samples, struct roar_remove_state * state) {
- int i;
- register int_least16_t s;
- register int_least16_t peak;
-
- if ( state == NULL ) {
-  for (i = 0; i < samples; i++) {
-   s  = -subout[i];
-   s +=  in[i];
-   subout[i] = s;
-  }
- } else {
-  peak = 127;
-  for (i = 0; i < samples; i++) {
-   s  = -subout[i];
-   s +=  in[i];
-   s  = s < 0 ? -s : s; // we true 32 bit, not int operation here
-   if ( s > peak )
-    peak = s;
-  }
-
-  for (i = 0; i < samples; i++) {
-   s  = -subout[i];
-   s *=  127;
-   s /=  peak;
-   s +=  in[i];
-   subout[i] = s;
-  }
- }
-
- return 0;
-}
-
-int roar_remove_so16 (int16_t * subout, int16_t * in, int samples, struct roar_remove_state * state) {
- int i;
- register int32_t s;
- register int32_t peak;
-
- if ( state == NULL ) {
-  for (i = 0; i < samples; i++) {
-   s  = -subout[i];
-   s +=  in[i];
-   subout[i] = s;
-  }
- } else {
-  peak = 65535;
-  for (i = 0; i < samples; i++) {
-   s  = -subout[i];
-   s +=  in[i];
-   s  = s < 0 ? -s : s; // we true 32 bit, not int operation here
-   if ( s > peak )
-    peak = s;
-  }
-
-  for (i = 0; i < samples; i++) {
-   s  = -subout[i];
-   s *=  65535;
-   s /=  peak;
-   s +=  in[i];
-   subout[i] = s;
-  }
- }
-
- return 0;
-}
-
-int roar_remove_so32 (int32_t * subout, int32_t * in, int samples, struct roar_remove_state * state) {
- int i;
- register int64_t s;
- register int64_t peak;
-
- if ( state == NULL ) {
-  for (i = 0; i < samples; i++) {
-   s  = -subout[i];
-   s +=  in[i];
-   subout[i] = s;
-  }
- } else {
-  peak = 2147483647UL;
-  for (i = 0; i < samples; i++) {
-   s  = -subout[i];
-   s +=  in[i];
-   s  = s < 0 ? -s : s; // we true 32 bit, not int operation here
-   if ( s > peak )
-    peak = s;
-  }
-
-  for (i = 0; i < samples; i++) {
-   s  = -subout[i];
-   s *=  2147483647UL;
-   s /=  peak;
-   s +=  in[i];
-   subout[i] = s;
-  }
- }
-
- return 0;
-}
-
-//ll
Index: libroardsp/resampler_poly3.c
===================================================================
--- libroardsp/resampler_poly3.c	(revision 6052)
+++ 	(revision )
@@ -1,239 +1,0 @@
-//resampler_poly3.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2010-2015
- *      Copyright (C) Hans-Kristian 'maister' Arntzen - 2010
- *
- *  This file is part of libroar a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroar 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- *  NOTE for everyone want's to change something and send patches:
- *  read README and HACKING! There a addition information on
- *  the license of this document you need to read before you send
- *  any patches.
- *
- *  NOTE for uses of non-GPL (LGPL,...) software using libesd, libartsc
- *  or libpulse*:
- *  The libs libroaresd, libroararts and libroarpulse link this lib
- *  and are therefore GPL. Because of this it may be illigal to use
- *  them with any software that uses libesd, libartsc or libpulse*.
- */
-
-#include "libroardsp.h"
-
-int roar_conv_poly3_8 (int8_t * out, int8_t * in, size_t olen, size_t ilen, int channels) {
- float ratio = (float)olen / (float)ilen;
- int8_t *ip;
- int c, x;
- float pos_in;
- float poly[3];
- float y[3];
- float x_val;
- int_least16_t temp;
-
- /* Can't create poly out of less than 3 samples in each channel. */
- if ( ilen < 3 * channels )
-  return -1;
-
- ip = roar_mm_malloc(ilen * sizeof(int8_t));
- if ( ip == NULL )
-  return -1;
-
- memcpy(ip, in, ilen * sizeof(int8_t));
-
- olen /= channels;
-
- for (x = 0; x < olen; x++) {
-  for (c = 0; c < channels; c++) {
-   pos_in = (float)x / ratio;
-
-   if ( (int)pos_in == 0 ) {
-    y[0] = ip[0 * channels + c];
-    y[1] = ip[1 * channels + c];
-    y[2] = ip[2 * channels + c];
-    x_val = pos_in;
-    roar_math_mkpoly_3x3(poly, y);
-   } else if ( (int)pos_in + 1 >= ilen/channels ) {
-    /* If we're at the end of the block, we will need to interpolate against a value that is not yet known.
-     * We will assume this value, by linearly extrapolating the two preceding values. From causual testing, this is not audible. */
-    y[0] = ip[((int)pos_in - 1) * channels + c];
-    y[1] = ip[((int)pos_in    ) * channels + c];
-
-    // we create a 2x2 poly here and set the 3rd coefficient to zero to build a 3x3 poly
-    roar_math_mkpoly_2x2(poly, y);
-    poly[2] = 0;
-    x_val = pos_in - (int)pos_in + 1.0;
-   } else {
-    y[0] = ip[((int)pos_in - 1) * channels + c];
-    y[1] = ip[((int)pos_in    ) * channels + c];
-    y[2] = ip[((int)pos_in + 1) * channels + c];
-    x_val = pos_in - (int)pos_in + 1.0;
-    roar_math_mkpoly_3x3(poly, y);
-   }
-
-
-   temp = (float)(poly[2]*x_val*x_val + poly[1]*x_val + poly[0] + 0.5);
-   /* temp could be out of bounds, so need to check this */
-   if ( temp > 0x7E ) {
-    out[x * channels + c] =  0x7E;
-   } else if (temp < -0x7F) {
-    out[x * channels + c] = -0x7F;
-   } else {
-    out[x * channels + c] = (int8_t)temp;
-   }
-  }
- }
-
- roar_mm_free(ip);
- return 0;
-}
-
-int roar_conv_poly3_16 (int16_t * out, int16_t * in, size_t olen, size_t ilen, int channels) {
- float ratio = (float)olen / (float)ilen;
- int16_t *ip;
- int c, x;
- float pos_in;
- float poly[3];
- float y[3];
- float x_val;
- int_least32_t temp;
-
- /* Can't create poly out of less than 3 samples in each channel. */
- if ( ilen < 3 * channels )
-  return -1;
-
- ip = roar_mm_malloc(ilen * sizeof(int16_t));
- if ( ip == NULL )
-  return -1;
-
- memcpy(ip, in, ilen * sizeof(int16_t));
-
- olen /= channels;
-
- for (x = 0; x < olen; x++) {
-  for (c = 0; c < channels; c++) {
-   pos_in = (float)x / ratio;
-
-   if ( (int)pos_in == 0 ) {
-    y[0] = ip[0 * channels + c];
-    y[1] = ip[1 * channels + c];
-    y[2] = ip[2 * channels + c];
-    x_val = pos_in;
-    roar_math_mkpoly_3x3(poly, y);
-   } else if ( (int)pos_in + 1 >= ilen/channels ) {
-    /* If we're at the end of the block, we will need to interpolate against a value that is not yet known.
-     * We will assume this value, by linearly extrapolating the two preceding values. From causual testing, this is not audible. */
-    y[0] = ip[((int)pos_in - 1) * channels + c];
-    y[1] = ip[((int)pos_in    ) * channels + c];
-
-    // we create a 2x2 poly here and set the 3rd coefficient to zero to build a 3x3 poly
-    roar_math_mkpoly_2x2(poly, y);
-    poly[2] = 0;
-    x_val = pos_in - (int)pos_in + 1.0;
-   } else {
-    y[0] = ip[((int)pos_in - 1) * channels + c];
-    y[1] = ip[((int)pos_in    ) * channels + c];
-    y[2] = ip[((int)pos_in + 1) * channels + c];
-    x_val = pos_in - (int)pos_in + 1.0;
-    roar_math_mkpoly_3x3(poly, y);
-   }
-
-
-   temp = (float)(poly[2]*x_val*x_val + poly[1]*x_val + poly[0] + 0.5);
-   /* temp could be out of bounds, so need to check this */
-   if (temp > 0x7FFE ) {
-    out[x * channels + c] =  0x7FFE;
-   } else if (temp < -0x7FFF) {
-    out[x * channels + c] = -0x7FFF;
-   } else {
-    out[x * channels + c] = (int16_t)temp;
-   }
-  }
- }
-
- roar_mm_free(ip);
- return 0;
-}
-
-int roar_conv_poly3_32 (int32_t * out, int32_t * in, size_t olen, size_t ilen, int channels) {
- float ratio = (float)olen / (float)ilen;
- int32_t *ip;
- int c, x;
- float pos_in;
- float poly[3];
- float y[3];
- float x_val;
- int_least64_t temp;
-
- /* Can't create poly out of less than 3 samples in each channel. */
- if ( ilen < 3 * channels )
-  return -1;
-
- ip = roar_mm_malloc(ilen * sizeof(int32_t));
- if ( ip == NULL )
-  return -1;
-
- memcpy(ip, in, ilen * sizeof(int32_t));
-
- olen /= channels;
-
- for (x = 0; x < olen; x++) {
-  for (c = 0; c < channels; c++) {
-   pos_in = (float)x / ratio;
-
-   if ( (int)pos_in == 0 ) {
-    y[0] = ip[0 * channels + c];
-    y[1] = ip[1 * channels + c];
-    y[2] = ip[2 * channels + c];
-    x_val = pos_in;
-    roar_math_mkpoly_3x3(poly, y);
-   } else if ( (int)pos_in + 1 >= ilen/channels ) {
-    /* If we're at the end of the block, we will need to interpolate against a value that is not yet known.
-     * We will assume this value, by linearly extrapolating the two preceding values. From causual testing, this is not audible. */
-    y[0] = ip[((int)pos_in - 1) * channels + c];
-    y[1] = ip[((int)pos_in    ) * channels + c];
-
-    // we create a 2x2 poly here and set the 3rd coefficient to zero to build a 3x3 poly
-    roar_math_mkpoly_2x2(poly, y);
-    poly[2] = 0;
-    x_val = pos_in - (int)pos_in + 1.0;
-   } else {
-    y[0] = ip[((int)pos_in - 1) * channels + c];
-    y[1] = ip[((int)pos_in    ) * channels + c];
-    y[2] = ip[((int)pos_in + 1) * channels + c];
-    x_val = pos_in - (int)pos_in + 1.0;
-    roar_math_mkpoly_3x3(poly, y);
-   }
-
-
-   temp = (float)(poly[2]*x_val*x_val + poly[1]*x_val + poly[0] + 0.5);
-   /* temp could be out of bounds, so need to check this */
-   if ( temp > 0x7FFFFFFE ) {
-    out[x * channels + c] =  0x7FFFFFFE;
-   } else if (temp < -0x7FFFFFFF) {
-    out[x * channels + c] = -0x7FFFFFFF;
-   } else {
-    out[x * channels + c] = (int32_t)temp;
-   }
-  }
- }
-
- roar_mm_free(ip);
- return 0;
-}
-
Index: libroardsp/rms.c
===================================================================
--- libroardsp/rms.c	(revision 6052)
+++ 	(revision )
@@ -1,209 +1,0 @@
-//rms.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2009-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-int64_t roar_rms2_1_8  (int8_t  * data, size_t samples) {
- register int64_t s = 0;
- register size_t  i;
-
- for (i = 0; i < samples; i++)
-  s += data[i] * data[i];
-
- s /= samples;
-
- return s;
-}
-
-int64_t roar_rms2_1_16 (int16_t * data, size_t samples) {
- register int64_t s = 0;
- register size_t  i;
-
- for (i = 0; i < samples; i++)
-  s += data[i] * data[i];
-
- s /= samples;
-
- return s;
-}
-
-int64_t roar_rms2_1_32 (int32_t * data, size_t samples) {
- register int64_t s = 0;
- register size_t  i;
-
- for (i = 0; i < samples; i++)
-  s += data[i] * data[i];
-
- s /= samples;
-
- return s;
-}
-
-
-int roar_rms2_1_8_2    (int8_t  * data, size_t samples, int64_t * rms) {
- register int64_t a0 = 0, a1 = 0;
- register size_t  i;
-
- if ( samples == 0 )
-  return 0;
-
- if ( data == NULL )
-  return -1;
-
- if ( samples & 0x1 ) /* odd */
-  return -1;
-
- for (i = 0; i < samples; i += 2) {
-  a0 += data[i+0] * data[i+0];
-  a1 += data[i+1] * data[i+1];
- }
-
- samples /= 2;
-
- a0 /= samples;
- a1 /= samples;
-
- rms[0] = a0;
- rms[1] = a1;
-
- return 0;
-}
-
-int roar_rms2_1_16_2   (int16_t * data, size_t samples, int64_t * rms) {
- register int64_t a0 = 0, a1 = 0;
- register size_t  i;
-
- if ( samples == 0 )
-  return 0;
-
- if ( data == NULL )
-  return -1;
-
- if ( samples & 0x1 ) /* odd */
-  return -1;
-
- for (i = 0; i < samples; i += 2) {
-  a0 += data[i+0] * data[i+0];
-  a1 += data[i+1] * data[i+1];
- }
-
- samples /= 2;
-
- a0 /= samples;
- a1 /= samples;
-
- rms[0] = a0;
- rms[1] = a1;
-
- return 0;
-}
-
-int roar_rms2_1_32_2   (int32_t * data, size_t samples, int64_t * rms) {
- register int64_t a0 = 0, a1 = 0;
- register size_t  i;
-
- if ( samples == 0 )
-  return 0;
-
- if ( data == NULL )
-  return -1;
-
- if ( samples & 0x1 ) /* odd */
-  return -1;
-
- for (i = 0; i < samples; i += 2) {
-  a0 += data[i+0] * data[i+0];
-  a1 += data[i+1] * data[i+1];
- }
-
- samples /= 2;
-
- a0 /= samples;
- a1 /= samples;
-
- rms[0] = a0;
- rms[1] = a1;
-
- return 0;
-}
-
-
-int roar_rms2_1_8_n    (int8_t  * data, size_t samples, int64_t * rms, size_t n) {
- if ( n == 0 )
-  return 0;
-
- if ( rms == NULL )
-  return -1;
-
- switch (n) {
-  case 1: return *rms = roar_rms2_1_8(data, samples); return *rms == -1 ? -1 : 0; break;
-  case 2: return roar_rms2_1_8_2(data, samples, rms); break;
-  default:
-   return -1;
- }
-}
-
-int roar_rms2_1_16_n   (int16_t * data, size_t samples, int64_t * rms, size_t n) {
- if ( n == 0 )
-  return 0;
-
- if ( rms == NULL )
-  return -1;
-
- switch (n) {
-  case 1: return *rms = roar_rms2_1_16(data, samples); return *rms == -1 ? -1 : 0; break;
-  case 2: return roar_rms2_1_16_2(data, samples, rms); break;
-  default:
-   return -1;
- }
-}
-
-int roar_rms2_1_32_n   (int32_t * data, size_t samples, int64_t * rms, size_t n) {
- if ( n == 0 )
-  return 0;
-
- if ( rms == NULL )
-  return -1;
-
- switch (n) {
-  case 1: return *rms = roar_rms2_1_32(data, samples); return *rms == -1 ? -1 : 0; break;
-  case 2: return roar_rms2_1_32_2(data, samples, rms); break;
-  default:
-   return -1;
- }
-}
-
-
-int roar_rms2_1_b_n    (void    * data, size_t samples, int64_t * rms, size_t n, size_t bits) {
- switch (bits) {
-  case  8: return roar_rms2_1_8_n(data, samples, rms, n);  break;
-  case 16: return roar_rms2_1_16_n(data, samples, rms, n); break;
-  case 32: return roar_rms2_1_32_n(data, samples, rms, n); break;
-  default:
-    return -1;
- }
-}
-
-//ll
Index: libroardsp/synth.c
===================================================================
--- libroardsp/synth.c	(revision 6052)
+++ 	(revision )
@@ -1,194 +1,0 @@
-//synth.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2009-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-#if !defined(ROAR_HAVE_LIBM) && !defined(M_PI)
-#define M_PI 3.141592
-#endif
-
-#define _CHECK_BASIC() if ( state == NULL ) return -1
-#define _CHECK_PCMOUT() _CHECK_BASIC(); if ( frames == 0 ) return 0; if ( out == NULL ) return -1
-
-int roar_synth_init(struct roar_synth_state * state, struct roar_note_octave * note, int rate) {
- _CHECK_BASIC();
-
- if ( rate <= 0 )
-  return -1;
-
- memset(state, 0, sizeof(struct roar_synth_state));
-
- state->note   = note; // NULL is valid here!
- state->rate   = rate;
- state->volume = 1;
-
- state->func = ROAR_SYNTH_SYNF_DEFAULT;
-
- return 0;
-}
-
-int roar_synth_set_offset(struct roar_synth_state * state, size_t offset) {
- _CHECK_BASIC();
-
- state->pcmoffset = offset;
-
- return 0;
-}
-
-int roar_synth_set_func  (struct roar_synth_state * state, ROAR_SYNTH_FUNC_TYPE(func)) {
- _CHECK_BASIC();
-
- if ( func == NULL )
-  return -1;
-
- state->func = func;
-
- return 0;
-}
-
-int roar_synth_set_volume(struct roar_synth_state * state, float volume) {
- _CHECK_BASIC();
-
- state->volume = volume;
-
- return 0;
-}
-
-int roar_synth_pcmout_i16n(struct roar_synth_state * state, int16_t * out, size_t frames, int channels) {
- _CHECK_PCMOUT();
-
- switch (channels) {
-  case 1: return roar_synth_pcmout_i161(state, out, frames);
-  default:
-    return -1;
- }
-
- return 0;
-}
-
-int roar_synth_pcmout_i161(struct roar_synth_state * state, int16_t * out, size_t frames) {
- float t_step;
- float t_cur;
- float freq;
-#ifdef DEBUG
- float cv0, cv1;
-#endif
- size_t i;
-
- _CHECK_PCMOUT();
-
- t_step = 1.0/state->rate;
-
- ROAR_DBG("roar_synth_pcmout_i161(*): state->pcmoffset=%lu", (unsigned long)state->pcmoffset);
-
- t_cur  = (float)state->pcmoffset/(float)state->rate;
-
- freq   = state->note->freq;
-
- ROAR_DBG("roar_synth_pcmout_i161(*): t_cur=%f, freq=%f", t_cur, freq);
-
-#ifdef DEBUG
- cv0 = 2.0*M_PI*freq*t_cur;
-#endif
- for (i = 0; i < frames; i++, t_cur += t_step) {
-  out[i] = 32767.0*state->volume*state->func(2.0*M_PI*freq*t_cur, state);
- }
-#ifdef DEBUG
- cv1 = 2.0*M_PI*freq*t_cur;
-#endif
-
-#ifdef DEBUG
- ROAR_DBG("roar_synth_pcmout_i161(*): cv0=%f, cv1=%f, cv1-cv0=%f", cv0, cv1, cv1-cv0);
-#endif
-
- state->pcmoffset += frames;
-
- ROAR_DBG("roar_synth_pcmout_i161(*): state->pcmoffset=%lu", (unsigned long)state->pcmoffset);
-
- return 0;
-}
-
-// basic SINFs:
-float roar_synth_synf_rect (float t, struct roar_synth_state * state) {
- (void)state;
-
- t /= 2*M_PI;
- t -= (int)t;
-
- if ( t < 0.5 )
-  return  1;
- else
-  return -1;
-}
-
-float roar_synth_synf_saw  (float t, struct roar_synth_state * state) {
- (void)state;
-
- t /= 2*M_PI;
- t -= (int)t;
-
- return 2*t - 1;
-}
-
-float roar_synth_synf_tri  (float t, struct roar_synth_state * state) {
- (void)state;
-
- t /= 2*M_PI;
- t -= (int)t;
-
- if ( t < 0.5 )
-  return   4* t      - 1;
- else
-  return  -4*(t-0.5) + 1;
-}
-
-float roar_synth_synf_trap (float t, struct roar_synth_state * state) {
- (void)state;
-
- t /= 2*M_PI;
- t -= (int)t;
-
- if ( t < 0.125 || t > 0.875 ) {
-  return -1;
- } else if ( t < 0.625 && t > 0.375 ) {
-  return  1;
- } else if ( t < 0.5 ) {
-  return  8*(t-0.375) + 1;
- } else {
-  return -8*(t-0.625) + 1;
- }
-}
-
-#ifdef ROAR_HAVE_LIBM
-float roar_synth_synf_s2s  (float t, struct roar_synth_state * state) {
- (void)state;
-
- float sin2 = sinf(t/1.2);
-
- return sin2*sin2 * sin(t*1.2);
-}
-#endif
-
-//ll
Index: libroardsp/transcode.c
===================================================================
--- libroardsp/transcode.c	(revision 6052)
+++ 	(revision )
@@ -1,423 +1,0 @@
-//transcode.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2009-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-#define _FUNC(func)        (state->entry->func)
-#define _CHECK_STATE()     (!(state == NULL || state->entry == NULL))
-#define _CHECK_FUNC(func)  (_CHECK_STATE() && _FUNC(func) != NULL)
-#define _CHECK_BASIC(func) if ( !_CHECK_FUNC(func) ) return -1
-#define _CHECK()           if ( !_CHECK_STATE() ) return -1
-
-static struct roar_xcoder_entry g_xcoders[] = {
- {ROAR_CODEC_ALAW,  roar_xcoder_dummy_inituninit, roar_xcoder_dummy_inituninit, roar_xcoder_dummy_packet_size_any,
-                     roar_xcoder_alaw_encode,  roar_xcoder_alaw_decode, roar_xcoder_dummy_proc_header},
- {ROAR_CODEC_MULAW, roar_xcoder_dummy_inituninit, roar_xcoder_dummy_inituninit, roar_xcoder_dummy_packet_size_any,
-                     roar_xcoder_mulaw_encode, roar_xcoder_mulaw_decode, roar_xcoder_dummy_proc_header},
-#ifdef ROAR_HAVE_LIBCELT
- {ROAR_CODEC_ROAR_CELT, roar_xcoder_celt_init, roar_xcoder_celt_uninit, roar_xcoder_celt_packet_size,
-                     roar_xcoder_celt_encode,  roar_xcoder_celt_decode, NULL},
-#endif
-#ifdef ROAR_HAVE_LIBSPEEX
- {ROAR_CODEC_ROAR_SPEEX, roar_xcoder_speex_init, roar_xcoder_speex_uninit, roar_xcoder_speex_packet_size,
-                     roar_xcoder_speex_encode, roar_xcoder_speex_decode, roar_xcoder_speex_proc_header},
-#endif
- {-1, NULL, NULL, NULL, NULL, NULL, NULL}
-};
-
-int roar_xcoder_init(struct roar_xcoder * state, int encoder, struct roar_audio_info * info, struct roar_vio_calls * vio) {
- int i;
-
- if ( state == NULL || info == NULL )
-  return -1;
-
- memset(state, 0, sizeof(struct roar_xcoder));
-
- for (i = 0; g_xcoders[i].codec != -1; i++) {
-  if ( g_xcoders[i].codec == (int)info->codec ) {
-   state->entry = &(g_xcoders[i]);
-   break;
-  }
- }
-
- if ( state->entry == NULL )
-  return -1;
-
- state->stage      = ROAR_XCODER_STAGE_NONE;
- state->encode     = encoder;
- state->packet_len = -1;
-
- if ( roar_xcoder_set_backend(state, vio) == -1 )
-  return -1;
-
- memcpy(&(state->info.coded), info, sizeof(struct roar_audio_info));
- memcpy(&(state->info.pcm  ), info, sizeof(struct roar_audio_info));
-
- state->info.pcm.codec = ROAR_CODEC_DEFAULT;
-
- if ( _FUNC(init) == NULL )
-  return -1;
-
- if ( _FUNC(init)(state) != 0 )
-  return -1;
-
- state->stage      = ROAR_XCODER_STAGE_INITED;
-
- return 0;
-}
-
-int roar_xcoder_set_backend(struct roar_xcoder * state, struct roar_vio_calls * vio) {
- _CHECK();
-
- if ( vio == NULL && state->backend != NULL )
-  return -1;
-
- state->backend = vio;
-
- return 0;
-}
-int roar_xcoder_packet_size(struct roar_xcoder * state, int samples) {
- _CHECK_BASIC(packet_size);
-
- state->packet_len = state->entry->packet_size(state, samples);
-
- if ( state->packet_len == 0 ) {
-  if ( samples < 1 ) {
-   return ROAR_RATE_DEFAULT/100;
-  } else {
-   return samples;
-  }
- }
-
- return state->packet_len;
-}
-
-int roar_xcoder_close      (struct roar_xcoder * state) {
- _CHECK_BASIC(uninit);
-
-
- if ( state->iobuffer != NULL ) {
-  roar_xcoder_proc(state, NULL, 0); // try to flush
-  roar_buffer_free(state->iobuffer);
- }
-
- return _FUNC(uninit)(state);
-}
-
-int roar_xcoder_proc_header(struct roar_xcoder * state) {
- _CHECK_BASIC(proc_header);
-
- return _FUNC(proc_header)(state);
-}
-
-int roar_xcoder_proc_packet(struct roar_xcoder * state, void * buf, size_t len) {
- _CHECK();
-
- ROAR_DBG("roar_xcoder_proc_packet(state=%p, buf=%p, len=%lu) = ?", state, buf, (unsigned long)len);
-
- if ( state->backend == NULL )
-  return -1;
-
- if ( state->packet_len > 0 && state->packet_len != (ssize_t)len )
-  return -1;
-
- ROAR_DBG("roar_xcoder_proc_packet(state=%p, buf=%p, len=%lu) = ?", state, buf, (unsigned long)len);
-
- if ( state->encode ) {
-  _CHECK_BASIC(encode);
-  ROAR_DBG("roar_xcoder_proc_packet(state=%p, buf=%p, len=%lu) = ? // _CHECK_BASIC(encode) -> OK", state, buf, (unsigned long)len);
-  return _FUNC(encode)(state, buf, len);
- } else {
-  _CHECK_BASIC(decode);
-  ROAR_DBG("roar_xcoder_proc_packet(state=%p, buf=%p, len=%lu) = ? // _CHECK_BASIC(decode) -> OK", state, buf, (unsigned long)len);
-  return _FUNC(decode)(state, buf, len);
- }
-}
-
-int roar_xcoder_proc       (struct roar_xcoder * state, void * buf, size_t len) {
- struct roar_buffer_stats ringstats;
- struct roar_buffer * bufbuf;
- void               * bufdata;
- size_t               curlen;
-
- ROAR_DBG("roar_xcoder_proc(state=%p, buf=%p, len=%lu) = ?", state, buf, (unsigned long)len);
-
- if ( state == NULL )
-  return -1;
-
- if ( buf == NULL && len != 0 )
-  return -1;
-
- if ( state->packet_len == -1 )
-  if ( roar_xcoder_packet_size(state, -1) == -1 )
-   return -1;
-
- ROAR_DBG("roar_xcoder_proc(state=%p, buf=%p, len=%lu) = ?", state, buf, (unsigned long)len);
-
- if ( state->packet_len == 0 )
-  return roar_xcoder_proc_packet(state, buf, len);
-
- ROAR_DBG("roar_xcoder_proc(state=%p, buf=%p, len=%lu): state->packet_len=%li", state, buf, (unsigned long)len, (long int) state->packet_len);
-
- if ( state->iobuffer == NULL ) {
-  while ( (ssize_t)len >= state->packet_len ) {
-   if ( roar_xcoder_proc_packet(state, buf, state->packet_len) == -1 ) {
-    ROAR_DBG("roar_xcoder_proc(state=%p, buf=%p, len=%lu) = -1 // roar_xcoder_proc_packet() error", state, buf, (unsigned long)len);
-    return -1;
-   }
-
-   buf += state->packet_len;
-   len -= state->packet_len;
-  }
-
-  if ( !len ) {
-   ROAR_DBG("roar_xcoder_proc(state=%p, buf=%p, len=%lu) = 0", state, buf, (unsigned long)len);
-   return 0;
-  }
-
-  ROAR_DBG("roar_xcoder_proc(state=%p, buf=%p, len=%lu) = ?", state, buf, (unsigned long)len);
-
-  if ( state->encode ) {
-   curlen = len;
-  } else {
-   curlen = state->packet_len;
-  }
-
-  if ( roar_buffer_new_data(&bufbuf, curlen, &bufdata) == -1 )
-   return -1;
-
-  if ( state->encode ) {
-   memcpy(bufdata, buf, len);
-  } else {
-   if ( roar_xcoder_proc_packet(state, bufdata, state->packet_len) == -1 ) {
-    roar_buffer_free(bufbuf);
-    return -1;
-   }
-
-   curlen = len;
-
-   if ( roar_buffer_shift_out(&bufbuf, buf, &curlen) == -1 ) {
-    roar_buffer_free(bufbuf);
-    return -1;
-   }
-
-   if ( curlen < len ) { // this should never happen!
-    roar_buffer_free(bufbuf);
-    return -1;
-   }
-  }
-
-  state->iobuffer = bufbuf;
- } else {
-  if ( state->encode ) {
-   if ( roar_buffer_new_data(&bufbuf, len, &bufdata) == -1 )
-    return -1;
-
-   memcpy(bufdata, buf, len);
-
-   if ( roar_buffer_moveinto(state->iobuffer, &bufbuf) == -1 ) {
-    roar_buffer_free(bufbuf);
-    return -1;
-   }
-
-   if ( roar_buffer_ring_stats(state->iobuffer, &ringstats) == -1 )
-    return -1;
-
-   if ( roar_buffer_new_data(&bufbuf, state->packet_len, &bufdata) == -1 )
-    return -1;
-
-   while ( (ssize_t)ringstats.bytes > state->packet_len ) {
-    curlen = state->packet_len;
-    if ( roar_buffer_shift_out(&(state->iobuffer), bufdata, &curlen) == -1 ) {
-     roar_buffer_free(bufbuf);
-     return -1;
-    }
-
-    if ( (ssize_t)curlen < state->packet_len ) { // this should not happen...
-     roar_buffer_free(bufbuf);
-     return -1;
-    }
-
-    if ( roar_xcoder_proc_packet(state, bufdata, state->packet_len) == -1 ) {
-     roar_buffer_free(bufbuf);
-     return -1;
-    }
-
-    if ( roar_buffer_ring_stats(state->iobuffer, &ringstats) == -1 ) {
-     roar_buffer_free(bufbuf);
-     return -1;
-    }
-   }
-
-   if ( roar_buffer_free(bufbuf) == -1 )
-    return -1;
-  } else {
-   curlen = len;
-
-   if ( roar_buffer_shift_out(&(state->iobuffer), buf, &curlen) == -1 ) {
-    return -1;
-   }
-
-   if ( curlen == len )
-    return -1;
-
-   // we now have curlen < len and state->iobuffer == NULL
-   // as no data is left in the buffer, need to get some new data.
-   // we simply call ourself to get some more data...
-
-   if ( state->iobuffer == NULL ) {
-    ROAR_WARN("roar_xcoder_proc(state=%p, buf=%p, len=%lu): iobuffer != NULL, "
-                                "This is a bug in libroar{dsp,} or some hardware is broken",
-                   state, buf, (unsigned long)len);
-    return -1;
-   }
-
-   len -= curlen;
-   buf += curlen;
-
-   return roar_xcoder_proc(state, buf, len);
-  }
- }
-
- return 0;
-}
-
-int roar_bixcoder_init(struct roar_bixcoder * state, struct roar_audio_info * info, struct roar_vio_calls * vio) {
- if ( state == NULL || info == NULL || vio == NULL )
-  return -1;
-
- memset(state, 0, sizeof(struct roar_bixcoder));
-
- if ( roar_xcoder_init(&(state->encoder), 1, info, vio) == -1 )
-  return -1;
-
- if ( roar_xcoder_init(&(state->decoder), 0, info, vio) == -1 ) {
-  roar_xcoder_close(&(state->encoder));
-  return -1;
- }
-
- return 0;
-}
-
-int roar_bixcoder_packet_size (struct roar_bixcoder * state, int samples) {
- int ret;
-
- ROAR_DBG("roar_bixcoder_packet_size(state=%p, samples=%i) = ?", state, samples);
-
- if ( state == NULL )
-  return -1;
-
- if ( (ret = roar_xcoder_packet_size(&(state->encoder), samples)) == -1 )
-  return -1;
-
- ROAR_DBG("roar_bixcoder_packet_size(state=%p, samples=%i): ret=%i", state, samples, ret);
-
-// TODO: we need a lot hope here...
-/*
- if ( roar_xcoder_packet_size(&(state->decoder), ret) != ret )
-  return -1;
-*/
-
- ROAR_DBG("roar_bixcoder_packet_size(state=%p, samples=%i) = %i", state, samples, ret);
- return ret;
-}
-
-int roar_bixcoder_close       (struct roar_bixcoder * state) {
- int ret = 0;
-
- if ( state == NULL )
-  return -1;
-
- ret = roar_xcoder_close(&(state->encoder));
-
- if ( roar_xcoder_close(&(state->decoder)) == -1 )
-  return -1;
-
- return ret;
-}
-
-int roar_bixcoder_read_header (struct roar_bixcoder * state) {
- if ( state == NULL )
-  return -1;
-
- return roar_xcoder_proc_header(&(state->decoder));
-}
-
-int roar_bixcoder_read_packet (struct roar_bixcoder * state, void * buf, size_t len) {
-
- ROAR_DBG("roar_bixcoder_read_packet(state=%p, buf=%p, len=%lu) = ?", state, buf, (unsigned long)len);
-
- if ( state == NULL )
-  return -1;
-
- return roar_xcoder_proc_packet(&(state->decoder), buf, len);
-}
-
-int roar_bixcoder_read        (struct roar_bixcoder * state, void * buf, size_t len) {
- if ( state == NULL )
-  return -1;
-
- return roar_xcoder_proc(&(state->decoder), buf, len);
-}
-
-int roar_bixcoder_write_header(struct roar_bixcoder * state) {
- if ( state == NULL )
-  return -1;
-
- return roar_xcoder_proc_header(&(state->decoder));
-}
-
-int roar_bixcoder_write_packet(struct roar_bixcoder * state, void * buf, size_t len) {
- if ( state == NULL )
-  return -1;
-
- return roar_xcoder_proc_packet(&(state->encoder), buf, len);
-}
-
-int roar_bixcoder_write       (struct roar_bixcoder * state, void * buf, size_t len) {
- if ( state == NULL )
-  return -1;
-
- return roar_xcoder_proc(&(state->encoder), buf, len);
-}
-
-// dummy functions used by some de/encoders:
-int roar_xcoder_dummy_inituninit(struct roar_xcoder * state) {
- (void)state;
- return 0;
-}
-
-int roar_xcoder_dummy_packet_size_any(struct roar_xcoder * state, int samples) {
- // the case samples=-1/samples!=-1 based things are done in the general func
- (void)state, (void)samples;
- return 0;
-}
-
-int roar_xcoder_dummy_proc_header(struct roar_xcoder * state) {
- (void)state;
- return 0;
-}
-
-//ll
Index: libroardsp/transcode_celt.c
===================================================================
--- libroardsp/transcode_celt.c	(revision 6052)
+++ 	(revision )
@@ -1,205 +1,0 @@
-//transcode_celt.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2009-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-#ifdef ROAR_HAVE_LIBCELT
-
-#define _16BIT (16/8)
-#define _SIZE_LEN 2
-
-#ifdef ROAR_HAVE_CELT_VERSION_0_7_1
-typedef celt_int16 celt_int16_t;
-#endif
-
-int roar_xcoder_celt_init       (struct roar_xcoder * state) {
- struct roar_xcoder_celt * self = roar_mm_malloc(sizeof(struct roar_xcoder_celt));
- struct roar_audio_info  * info = &(state->info.pcm);
-
- if ( self == NULL )
-  return -1;
-
- // curruntly only 16 bit mode is supported
- if ( info->bits != 16 ) {
-  roar_mm_free(self);
-  return -1;
- }
-
- memset(self, 0, sizeof(struct roar_xcoder_celt));
-
- state->inst = self;
-
- self->frame_size           = 256;
-
- self->bufferlen            = info->channels * 32 + _SIZE_LEN;
- self->iobuffer             = roar_mm_malloc(self->bufferlen);
-
- if ( self->iobuffer == NULL ) {
-  roar_mm_free(self);
-  return -1;
- }
-
-#ifdef ROAR_HAVE_CELT_VERSION_0_7_1
- self->mode                 = celt_mode_create(info->rate, self->frame_size, NULL);
-#else
- self->mode                 = celt_mode_create(info->rate, info->channels, self->frame_size, NULL);
-#endif
-
- if ( self->mode == NULL ) {
-  roar_mm_free(self->iobuffer);
-  roar_mm_free(self);
-  return -1;
- }
-
- if (state->encode) {
-#ifdef ROAR_HAVE_CELT_VERSION_0_7_1
-  self->encoder = celt_encoder_create(self->mode, info->channels, NULL);
-#else
-  self->encoder = celt_encoder_create(self->mode);
-#endif
-  if ( self->encoder == NULL ) {
-   roar_xcoder_celt_uninit(state);
-   return -1;
-  }
- } else {
-#ifdef ROAR_HAVE_CELT_VERSION_0_7_1
-  self->decoder = celt_decoder_create(self->mode, info->channels, NULL);
-#else
-  self->decoder = celt_decoder_create(self->mode);
-#endif
-  if ( self->decoder == NULL ) {
-   roar_xcoder_celt_uninit(state);
-   return -1;
-  }
- }
-
- ROAR_DBG("roar_xcoder_celt_init(*) = 0");
-
- return 0;
-}
-
-int roar_xcoder_celt_uninit     (struct roar_xcoder * state) {
- struct roar_xcoder_celt * self = state->inst;
-
- if ( self->iobuffer )
-  roar_mm_free(self->iobuffer);
-
- if ( self->encoder )
-  celt_encoder_destroy(self->encoder);
-
- if ( self->decoder )
-  celt_decoder_destroy(self->decoder);
-
- if ( self->mode )
-  celt_mode_destroy(self->mode);
-
- roar_mm_free(self);
-
- ROAR_DBG("roar_xcoder_celt_uninit(*) = 0");
-
- return 0;
-}
-
-int roar_xcoder_celt_packet_size(struct roar_xcoder * state, int samples) {
- struct roar_xcoder_celt * self = state->inst;
- register int ret = self->frame_size * _16BIT * state->info.pcm.channels;
-
- ROAR_DBG("roar_xcoder_celt_packet_size(state=%p, samples=%i) = %i", state, samples, ret);
-
- return ret;
-}
-
-int roar_xcoder_celt_encode     (struct roar_xcoder * state, void * buf, size_t len) {
- struct roar_xcoder_celt * self = state->inst;
- uint16_t * lenp = self->iobuffer;
- void     * cp   = self->iobuffer + _SIZE_LEN;
- uint16_t   pkglen;
-
- ROAR_DBG("roar_xcoder_celt_encode(*): test if we are in encoding mode...");
-
- if (!state->encode)
-  return -1;
-
- ROAR_DBG("roar_xcoder_celt_encode(*): Encoding...");
-
- if ( state->stage == ROAR_XCODER_STAGE_INITED ) {
-  if ( roar_vio_write(state->backend, ROAR_CELT_MAGIC, ROAR_CELT_MAGIC_LEN) != ROAR_CELT_MAGIC_LEN )
-   return -1;
-  state->stage = ROAR_XCODER_STAGE_MAGIC;
-  ROAR_DBG("roar_xcoder_celt_encode(*): Wrote MAGIC");
- }
-
- pkglen  = celt_encode(self->encoder, (celt_int16_t *) buf, NULL, cp, self->bufferlen - _SIZE_LEN);
- *lenp   = ROAR_HOST2NET16(pkglen);
-
- if ( roar_vio_write(state->backend, self->iobuffer, pkglen+2) == -1 )
-  return -1;
-
- return 0;
-}
-
-int roar_xcoder_celt_decode     (struct roar_xcoder * state, void * buf, size_t len) {
- struct roar_xcoder_celt * self = state->inst;
- uint16_t * lenp = self->iobuffer;
- void     * cp   = self->iobuffer + _SIZE_LEN;
- uint16_t   pkglen;
- char       magic[ROAR_CELT_MAGIC_LEN];
-
- ROAR_DBG("roar_xcoder_celt_decode(*): test if we are in decoding mode...");
-
- if (state->encode)
-  return -1;
-
- if ( state->stage == ROAR_XCODER_STAGE_INITED ) {
-  if ( roar_vio_read(state->backend, magic, ROAR_CELT_MAGIC_LEN) != ROAR_CELT_MAGIC_LEN )
-   return -1;
-
-  if ( memcmp(magic, ROAR_CELT_MAGIC, ROAR_CELT_MAGIC_LEN) != 0 )
-   return -1;
-
-  state->stage = ROAR_XCODER_STAGE_MAGIC;
-  ROAR_DBG("roar_xcoder_celt_decode(*): Found valid Magic");
- }
-
- if ( roar_vio_read(state->backend, lenp, _SIZE_LEN) != _SIZE_LEN )
-  return -1;
-
- pkglen = ROAR_NET2HOST16(*lenp);
-
- if ( pkglen > (self->bufferlen - _SIZE_LEN) )
-  return -1;
-
- if ( roar_vio_read(state->backend, cp, pkglen) != pkglen )
-  return -1;
-
- if ( celt_decode(self->decoder, cp, pkglen, (celt_int16_t *) buf) < 0 )
-  return -1;
-
- return 0;
-}
-
-#endif
-
-//ll
Index: libroardsp/transcode_mualaw.c
===================================================================
--- libroardsp/transcode_mualaw.c	(revision 6052)
+++ 	(revision )
@@ -1,123 +1,0 @@
-//transcode_mualaw.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2009-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-#define _CHECK() if ( state == NULL || state->info.pcm.bits != 16 || buf == NULL ) return -1
-
-#define _CHECK_BUF(len) \
-                        void * iobuf; \
-                        size_t outbyte = (len)/2; \
-                        _CHECK();     \
-                        if ( (len) & 0x01 ) return -1; \
-                        if ( provide_buffer(&iobuf, outbyte) == -1 ) \
-                         return -1;
-
-#define _SEND_RETURN()  if ( roar_vio_write(state->backend, iobuf, outbyte) != (ssize_t)outbyte ) \
-                         return -1; \
-                        return 0;
-
-#define _READ()         if ( roar_vio_read(state->backend, iobuf, outbyte) != (ssize_t)outbyte ) \
-                         return -1;
-
-static int provide_buffer(void ** buf, size_t len) {
- static struct roar_buffer * bufbuf = NULL;
- size_t buflen;
-
- ROAR_DBG("provide_buffer(*) = ?");
-
- if ( bufbuf != NULL ) {
-  if ( roar_buffer_get_len(bufbuf, &buflen) == -1 )
-   return -1;
-
-  if ( buflen >= len ) {
-   if ( roar_buffer_get_data(bufbuf, buf) == -1 )
-    return -1;
-
-   ROAR_DBG("provide_buffer(*) = 0");
-   return 0;
-  } else {
-   if ( roar_buffer_free(bufbuf) == -1 )
-    return -1;
-
-   bufbuf = NULL;
-  }
- }
-
- if ( roar_buffer_new_data(&bufbuf, len, buf) == -1 )
-  return -1;
-
- ROAR_DBG("provide_buffer(*) = 0");
- return 0;
-}
-
-int roar_xcoder_alaw_encode(struct roar_xcoder * state, void * buf, size_t len) {
- _CHECK_BUF(len);
-
- ROAR_DBG("roar_xcoder_alaw_encode(*) = ?");
-
- if ( roardsp_conv_pcm162alaw(iobuf, buf, outbyte) == -1 )
-  return -1;
-
- ROAR_DBG("roar_xcoder_alaw_encode(*) = ?");
-
- _SEND_RETURN();
-}
-
-int roar_xcoder_alaw_decode(struct roar_xcoder * state, void * buf, size_t len) {
- _CHECK_BUF(len);
-
- _READ();
-
- ROAR_DBG("roar_xcoder_alaw_decode(*): Start decoding..");
-
- if ( roardsp_conv_alaw2pcm16(buf, iobuf, outbyte) == -1 )
-  return -1;
-
- ROAR_DBG("roar_xcoder_alaw_decode(*): Decoding sucessful");
- return 0;
-}
-
-int roar_xcoder_mulaw_encode(struct roar_xcoder * state, void * buf, size_t len) {
- _CHECK_BUF(len);
-
- if ( roardsp_conv_pcm162mulaw(iobuf, buf, outbyte) == -1 )
-  return -1;
-
- _SEND_RETURN();
-}
-
-int roar_xcoder_mulaw_decode(struct roar_xcoder * state, void * buf, size_t len) {
- _CHECK_BUF(len);
-
- _READ();
-
- if ( roardsp_conv_mulaw2pcm16(buf, iobuf, outbyte) == -1 )
-  return -1;
-
- return 0;
-}
-
-//ll
Index: libroardsp/transcode_speex.c
===================================================================
--- libroardsp/transcode_speex.c	(revision 6052)
+++ 	(revision )
@@ -1,308 +1,0 @@
-//transcode_speex.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2009-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-#ifdef ROAR_HAVE_LIBSPEEX
-
-#define _16BIT (16/8)
-#define _SIZE_LEN 2
-
-#define _HAVE_CCFG(x) (self->codec_config != NULL && (self->codec_config->para_set & (x)))
-
-int roar_xcoder_speex_init       (struct roar_xcoder * state) {
- struct roar_xcoder_speex * self = roar_mm_malloc(sizeof(struct roar_xcoder_speex));
- struct roar_audio_info  * info = &(state->info.pcm);
- int tmp;
-
- ROAR_DBG("roar_xcoder_speex_init(*): sizeof(*self) = %lu", (unsigned long)sizeof(*self));
-
- if ( self == NULL )
-  return -1;
-
- // curruntly only 16 bit mode is supported
- if ( info->bits != 16 ) {
-  roar_mm_free(self);
-  return -1;
- }
-
- // only mono/stereo mode is supported
- switch (info->channels) {
-  case 1: self->stereo = 0; break;
-  case 2: self->stereo = 1; break;
-  default:
-    roar_mm_free(self);
-    return -1;
- }
-
- memset(self, 0, sizeof(struct roar_xcoder_speex));
-
- state->inst = self;
-
- self->mode  = ROAR_SPEEX_MODE_UWB;
-
- if (state->encode) {
-  self->codec_config = roar_libroar_config_codec_get(ROAR_CODEC_ROAR_SPEEX, 0);
-  self->max_cc = ROAR_SPEEX_MAX_CC;
-
-  ROAR_DBG("roar_xcoder_speex_init(*): self->codec_config=%p", self->codec_config);
-
-  if ( _HAVE_CCFG(ROAR_LIBROAR_CONFIG_PSET_MAX_CC) ) {
-   self->max_cc = self->codec_config->max_cc;
-  }
-
-  if ( info->rate < 12000 ) {
-   self->mode = ROAR_SPEEX_MODE_NB;  // optimized for 8kHz
-  } else if ( info->rate < 24000 ) {
-   self->mode = ROAR_SPEEX_MODE_WB;  // optimized for 16kHz
-  } else {
-   self->mode = ROAR_SPEEX_MODE_UWB; // optimized for 32kHz
-  }
-
-  if ( _HAVE_CCFG(ROAR_LIBROAR_CONFIG_PSET_MODE) ) {
-   // NB, WB and UWB mode numbers are the same for Speex and codec config.
-   self->mode   = self->codec_config->mode;
-  }
-
-  switch (self->mode) {
-   case ROAR_SPEEX_MODE_NB:  self->xcoder = speex_encoder_init(&speex_nb_mode);  break;
-   case ROAR_SPEEX_MODE_WB:  self->xcoder = speex_encoder_init(&speex_wb_mode);  break;
-   case ROAR_SPEEX_MODE_UWB: self->xcoder = speex_encoder_init(&speex_uwb_mode); break;
-   default: return -1;
-  }
-
-  if ( _HAVE_CCFG(ROAR_LIBROAR_CONFIG_PSET_COMPLEXITY) ) {
-   tmp = self->codec_config->complexity / 256;
-  } else {
-   tmp = 8;
-  }
-  speex_encoder_ctl(self->xcoder, SPEEX_SET_COMPLEXITY,    &tmp);
-
-  if ( _HAVE_CCFG(ROAR_LIBROAR_CONFIG_PSET_Q) ) {
-   tmp = self->codec_config->q / 256;
-   speex_encoder_ctl(self->xcoder, SPEEX_SET_QUALITY,      &tmp);
-  }
-
-  if ( _HAVE_CCFG(ROAR_LIBROAR_CONFIG_PSET_VBR) ) {
-   tmp = self->codec_config->vbr ? 1 : 0;
-   speex_encoder_ctl(self->xcoder, SPEEX_SET_VBR,          &tmp);
-  }
-
-  if ( _HAVE_CCFG(ROAR_LIBROAR_CONFIG_PSET_DTX) ) {
-   tmp = self->codec_config->dtx ? 1 : 0;
-   speex_encoder_ctl(self->xcoder, SPEEX_SET_DTX,          &tmp);
-  }
-
-  tmp = info->rate;
-  speex_encoder_ctl(self->xcoder, SPEEX_SET_SAMPLING_RATE, &tmp);
-  speex_encoder_ctl(self->xcoder, SPEEX_GET_FRAME_SIZE,    &(self->frame_size));
- } else {
-  self->xcoder = NULL;
- }
-
- speex_bits_init(&(self->bits));
-
- return 0;
-}
-
-int roar_xcoder_speex_uninit     (struct roar_xcoder * state) {
- struct roar_xcoder_speex * self = state->inst;
-
- if ( self->xcoder != NULL ) {
-  if (state->encode) {
-   speex_encoder_destroy(self->xcoder);
-  } else {
-   speex_decoder_destroy(self->xcoder);
-  }
- }
-
- speex_bits_destroy(&(self->bits));
-
- roar_mm_free(self);
-
- return 0;
-}
-
-int roar_xcoder_speex_packet_size(struct roar_xcoder * state, int samples) {
- struct roar_xcoder_speex * self = state->inst;
-
- if (!state->encode)
-  if (state->stage != ROAR_XCODER_STAGE_OPENED)
-   return -1;
-
- return _16BIT * self->frame_size * (self->stereo ? 2 : 1);
-}
-
-int roar_xcoder_speex_proc_header(struct roar_xcoder * state) {
- struct roar_xcoder_speex * self = state->inst;
- uint16_t tmp_net;
- int tmp;
- SpeexStereoState stereo = SPEEX_STEREO_STATE_INIT;
- SpeexCallback callback;
- char magic[ROAR_SPEEX_MAGIC_LEN];
-
- // we do allready open streams not considder an error.
- if ( state->stage == ROAR_XCODER_STAGE_OPENED )
-  return 0;
-
- // everything else expected an INITED stream (OPENING, MAGIC,..)
- // is an error...
- if ( state->stage != ROAR_XCODER_STAGE_INITED )
-  return -1;
-
- if ( state->encode ) {
-  if ( roar_vio_write(state->backend, ROAR_SPEEX_MAGIC, ROAR_SPEEX_MAGIC_LEN) != ROAR_SPEEX_MAGIC_LEN )
-   return -1;
-  state->stage = ROAR_XCODER_STAGE_MAGIC;
-  ROAR_DBG("roar_xcoder_speex_proc_header(*): Wrote MAGIC");
-
-  state->stage = ROAR_XCODER_STAGE_OPENING;
-
-  tmp_net = ROAR_HOST2NET16(self->mode);
-  if ( roar_vio_write(state->backend, &tmp_net, 2) != 2 )
-   return -1;
-
-  state->stage = ROAR_XCODER_STAGE_OPENED;
- } else {
-  if ( roar_vio_read(state->backend, magic, ROAR_SPEEX_MAGIC_LEN) != ROAR_SPEEX_MAGIC_LEN )
-   return -1;
-
-  if ( memcmp(magic, ROAR_SPEEX_MAGIC, ROAR_SPEEX_MAGIC_LEN) != 0 )
-   return -1;
-
-  state->stage = ROAR_XCODER_STAGE_MAGIC;
-
-  if ( roar_vio_read(state->backend, &tmp_net, 2) != 2 )
-   return -1;
-
-  self->mode = ROAR_NET2HOST16(tmp_net);
-
-  state->stage = ROAR_XCODER_STAGE_OPENING;
-
-  switch (self->mode) {
-   case ROAR_SPEEX_MODE_NB:  self->xcoder = speex_decoder_init(&speex_nb_mode);  break;
-   case ROAR_SPEEX_MODE_WB:  self->xcoder = speex_decoder_init(&speex_wb_mode);  break;
-   case ROAR_SPEEX_MODE_UWB: self->xcoder = speex_decoder_init(&speex_uwb_mode); break;
-   default: return -1;
-  }
-
-  tmp=1;
-  speex_decoder_ctl(self->xcoder, SPEEX_SET_ENH, &tmp);
-  tmp = state->info.pcm.rate;
-  speex_decoder_ctl(self->xcoder, SPEEX_SET_SAMPLING_RATE, &tmp);
-  speex_decoder_ctl(self->xcoder, SPEEX_GET_FRAME_SIZE, &(self->frame_size));
-
-  if ( self->stereo ) {
-   memcpy(&(self->stereo_state), &stereo, sizeof(self->stereo_state));
-
-   callback.callback_id = SPEEX_INBAND_STEREO;
-   callback.func = speex_std_stereo_request_handler;
-   callback.data = &(self->stereo_state);
-
-   speex_decoder_ctl(self->xcoder, SPEEX_SET_HANDLER, &callback);
-  }
-
-  state->stage = ROAR_XCODER_STAGE_OPENED;
- }
-
- // on no error...
- return 0;
-}
-
-int roar_xcoder_speex_encode     (struct roar_xcoder * state, void * buf, size_t len) {
- struct roar_xcoder_speex * self = state->inst;
- int pkg_len;
-
- if (!state->encode)
-  return -1;
-
- ROAR_DBG("roar_xcoder_speex_encode(*): Encoding...");
-
- if ( state->stage == ROAR_XCODER_STAGE_INITED )
-  if ( roar_xcoder_speex_proc_header(state) == -1 )
-   return -1;
-
- speex_bits_reset(&(self->bits));
-
- if ( self->stereo )
-  speex_encode_stereo_int((spx_int16_t *) buf, self->frame_size, &(self->bits));
-
- speex_encode_int(self->xcoder, (spx_int16_t *) buf, &(self->bits));
-
- pkg_len = speex_bits_write(&(self->bits), self->cc + 2, self->max_cc);
-
- self->cc[0] = (pkg_len & 0xFF00) >> 8;
- self->cc[1] =  pkg_len & 0x00FF;
-
- if ( roar_vio_write(state->backend, self->cc, pkg_len + 2) != (pkg_len + 2) )
-   return -1;
-
- return 0;
-}
-
-// TODO: move all the init thingys into a seperate function
-int roar_xcoder_speex_decode     (struct roar_xcoder * state, void * buf, size_t len) {
- struct roar_xcoder_speex * self = state->inst;
- uint16_t tmp_net;
- int pkg_len;
-
- ROAR_DBG("roar_xcoder_speex_decode(state=%p, buf=%p, len=%lu) = ?", state, buf, (unsigned long)len);
-
- if ( state->stage == ROAR_XCODER_STAGE_INITED )
-  if ( roar_xcoder_speex_proc_header(state) == -1 )
-   return -1;
-
- ROAR_DBG("roar_xcoder_speex_decode(state=%p, buf=%p, len=%lu): state->stage = %s", state, buf, (unsigned long)len,
-          state->stage == ROAR_XCODER_STAGE_OPENED ? "OPENED" : "???"
-         );
-
- if ( roar_vio_read(state->backend, &tmp_net, 2) != 2 )
-  return -1;
-
- pkg_len = ROAR_NET2HOST16(tmp_net);
-
- if ( pkg_len > ROAR_SPEEX_MAX_CC )
-  return -1;
-
- ROAR_DBG("roar_xcoder_speex_decode(state=%p, buf=%p, len=%lu) = ?", state, buf, (unsigned long)len);
-
- if ( roar_vio_read(state->backend, self->cc, pkg_len) != pkg_len )
-  return -1;
-
- speex_bits_read_from(&(self->bits), self->cc, pkg_len);
-
- speex_decode_int(self->xcoder, &(self->bits), buf);
-
- if ( self->stereo ) {
-  speex_decode_stereo_int(buf, self->frame_size, &(self->stereo_state));
- }
-
- ROAR_DBG("roar_xcoder_speex_decode(state=%p, buf=%p, len=%lu) = 0", state, buf, (unsigned long)len);
- return 0;
-}
-
-#endif
-
-//ll
Index: libroardsp/vio_transcode.c
===================================================================
--- libroardsp/vio_transcode.c	(revision 6052)
+++ 	(revision )
@@ -1,171 +1,0 @@
-//vio_transcode.c:
-
-/*
- *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2009-2015
- *
- *  This file is part of libroardsp a part of RoarAudio,
- *  a cross-platform sound system for both, home and professional use.
- *  See README for details.
- *
- *  This file is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3
- *  as published by the Free Software Foundation.
- *
- *  libroardsp 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 software; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "libroardsp.h"
-
-int     roar_vio_open_xcode    (struct roar_vio_calls * calls, int encoder, struct roar_audio_info * info,
-                                struct roar_vio_calls * dst) {
- struct roar_xcoder * xcoder = roar_mm_malloc(sizeof(struct roar_xcoder));
-
- if ( xcoder == NULL )
-  return -1;
-
- if ( calls == NULL || info == NULL || dst == NULL ) {
-  roar_mm_free(xcoder);
-  return -1;
- }
-
- if ( roar_xcoder_init(xcoder, encoder, info, dst) == -1 ) {
-  roar_mm_free(xcoder);
-  return -1;
- }
-
- memset(calls, 0, sizeof(struct roar_vio_calls));
- calls->flags  = ROAR_VIO_FLAGS_NONE;
- calls->refc   = 1;
-
- calls->inst   = (void*)xcoder;
-
- calls->close  = roar_vio_xcode_close;
-
- if ( encoder ) {
-  calls->write = roar_vio_xcode_proc;
- } else {
-  calls->read  = roar_vio_xcode_proc;
- }
-
- return 0;
-}
-
-ssize_t roar_vio_xcode_proc    (struct roar_vio_calls * vio, void *buf, size_t count) {
-#ifdef DEBUG
- int ret;
-#endif
-
- if ( vio == NULL )
-  return -1;
-
- if ( buf == NULL && count != 0 )
-  return -1;
-
-#ifdef DEBUG
- ret = roar_xcoder_proc(vio->inst, buf, count);
-
- ROAR_DBG("roar_vio_xcode_proc(vio=%p, buf=%p, count=%lu): ret=%i", vio, buf, (unsigned long) count, ret);
-
- return !ret ? count : -1;
-#else
- return !roar_xcoder_proc(vio->inst, buf, count) ? (ssize_t)count : -1;
-#endif
-}
-
-int     roar_vio_xcode_sync    (struct roar_vio_calls * vio);
-
-int     roar_vio_xcode_close   (struct roar_vio_calls * vio) {
- int ret = 0;
-
- if ( vio == NULL )
-  return -1;
-
- if ( roar_xcoder_close(vio->inst) == -1 )
-  ret = -1;
-
- if ( vio->inst != NULL )
-  roar_mm_free(vio->inst);
-
- return ret;
-}
-
-int     roar_vio_open_bixcode    (struct roar_vio_calls * calls, struct roar_audio_info * info,
-                                  struct roar_vio_calls * dst) {
- struct roar_bixcoder * bixcoder = roar_mm_malloc(sizeof(struct roar_bixcoder));
-
- if ( bixcoder == NULL )
-  return -1;
-
- if ( calls == NULL || info == NULL || dst == NULL ) {
-  roar_mm_free(bixcoder);
-  return -1;
- }
-
- if ( roar_bixcoder_init(bixcoder, info, dst) == -1 ) {
-  roar_mm_free(bixcoder);
-  return -1;
- }
-
- memset(calls, 0, sizeof(struct roar_vio_calls));
- calls->flags = ROAR_VIO_FLAGS_NONE;
- calls->refc  = 1;
-
- calls->inst  = (void*)bixcoder;
-
- calls->close = roar_vio_bixcode_close;
-
- calls->read  = roar_vio_bixcode_read;
- calls->write = roar_vio_bixcode_write;
-
- return 0;
-}
-
-ssize_t roar_vio_bixcode_read    (struct roar_vio_calls * vio, void *buf, size_t count) {
-
- if ( vio == NULL )
-  return -1;
-
- if ( buf == NULL && count != 0 )
-  return -1;
-
- return !roar_bixcoder_read(vio->inst, buf, count) ? (ssize_t)count : -1;
-}
-
-ssize_t roar_vio_bixcode_write   (struct roar_vio_calls * vio, void *buf, size_t count) {
-
- if ( vio == NULL )
-  return -1;
-
- if ( buf == NULL && count != 0 )
-  return -1;
-
- return !roar_bixcoder_write(vio->inst, buf, count) ? (ssize_t)count : -1;
-}
-
-int     roar_vio_bixcode_sync    (struct roar_vio_calls * vio);
-
-int     roar_vio_bixcode_close   (struct roar_vio_calls * vio) {
- int ret = 0;
-
- if ( vio == NULL )
-  return -1;
-
- if ( roar_bixcoder_close(vio->inst) == -1 )
-  ret = -1;
-
- if ( vio->inst != NULL )
-  roar_mm_free(vio->inst);
-
- return ret;
-}
-
-//ll
