Kizarm/Banner
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

add files

Browse source
This commit is contained in:
Kizarm 2023-12-08 17:20:48 +01:00
parent 6735761561
commit 8a067fe04f
13 changed files with 1472 additions and 1 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
.gitignore vendored Normal file
View file

@ -0,0 +1,7 @@
# kdevelop
.kde*
*.kdev4
# other
bld/*
banner
mkfont

51
Makefile Normal file
View file

@ -0,0 +1,51 @@
PR = banner
VPATH = .
PREFIX =
CC = $(PREFIX)gcc
CX = $(PREFIX)g++
AS = $(PREFIX)as
AR = $(PREFIX)ar
LD = $(PREFIX)ld
SIZE = $(PREFIX)size
DUMP = $(PREFIX)objdump
COPY = $(PREFIX)objcopy
BLD= ./bld/
AFLAGS = -adhlns=$(@:%.o=%.lst)
#CFLAGS =
CFLAGS = -Os -Wall
CFLAGS+= -fno-exceptions -fno-unwind-tables -fno-stack-check
CFLAGS+= -Wa,-adhlns=$(@:%.o=%.lst)
XFLAGS = $(CFLAGS)
XFLAGS+= -fno-rtti
LFLAGS = -lsndfile
LDLIBS =
# startup musí být linkován první
SOURCES = banner.c fft.cpp main.cpp
WIDTH = 80
OBJS = $(addsuffix .o,$(basename $(SOURCES)))
BOBJS = $(addprefix $(BLD),$(OBJS))
all: $(BLD) $(PR)
banner.c: font.h
font.h: ./mkfont
./mkfont --width $(WIDTH) --font /usr/share/fonts/truetype/liberation/LiberationSerif-Bold.ttf
./mkfont:
gcc -Os -Wall -I/usr/include/freetype2 mkfont.c -o mkfont -lfreetype
$(BLD):
mkdir $(BLD)
# build native application
$(PR): $(BOBJS)
$(CX) -o $(PR) $(BOBJS) $(LFLAGS)
$(BLD)%.o: %.c
$(CC) -std=c11 -c $(CFLAGS) -o $@ $<
$(BLD)%.o: %.cpp
$(CX) -c $(XFLAGS) -o $@ $<
$(BLD)%.o: %.s
$(AS) $(AFLAGS) -o $@ $<
clean:
rm -f $(BLD)* $(PR)
distclean: clean
rm -f ./mkfont font.h
rm -f *.vaw *.mp3

13
README.md
View file

@ -1,3 +1,14 @@
# Banner
Text to spectrum
## Text to spectrum
Manipulace s fonty je vzata z hodně starého projektu, kdy se ještě
tiskly velké nápisy na nekonečný papír (traktor). Tady je to jen
převedeno z kmitočtové oblasti pomocí FFT do časové a zapsáno jako
zvuk do souboru. Výsledek je např. v audacity cca takový :
![Náhled](./screen.png)
První stopa je časový průběh, druhá (copy) spektrum.
Jakákoli ztrátová komprese nebo filtrace signálu samozřejmě spektrum
více či méně poškodí, ale zpravidla to zůstane čitelné.

128
banner.c Normal file
View file

@ -0,0 +1,128 @@
/*//////////////////////////////////////////////////////////////////////////
// BANNER PRINTING PROGRAM
//
// Martin Renters, March/2020
// KIZARM :
// Upraveno tak, aby to šlo přeložit i v RSX11M+ (zkrácení názvů).
// Pak jsou potřeba i soubory font.h, banner.odl, banner.cmd
//////////////////////////////////////////////////////////////////////////*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "banner.h"
/*
#define cputc putchar
void cputs (char *s) {
while (*s) cputc (* (s++));
}
unsigned char cgetc() {
unsigned char c = getchar();
if (c == '\n') c = '\r';
return c;
}
void cgets (char *buf, int n) {
char * i;
i = fgets (buf, n, stdin);
(void) i;
buf[strlen (buf)-1] = 0;
}
*/
#define PAGESIZE 66
#define MAXLINE 80
/*//////////////////////////////////////////////////////////////////////////
// Include font data generated by mkfont
//////////////////////////////////////////////////////////////////////////*/
#include "font.h"
/*//////////////////////////////////////////////////////////////////////////
// Output buffer
//////////////////////////////////////////////////////////////////////////*/
static char outbuf[FONT_MAXWIDTH+3]; /* Account for CR, LF, NUL */
static char *obfnex;
/*//////////////////////////////////////////////////////////////////////////
// A bit pointer, includes pointer to byte and a bit mask for the bit
//////////////////////////////////////////////////////////////////////////*/
struct bitpointer {
unsigned char *byte;
int bit;
};
/*//////////////////////////////////////////////////////////////////////////
// gbits: get next n bits
//////////////////////////////////////////////////////////////////////////*/
static unsigned int gbits (struct bitpointer *bp, int n) {
unsigned int v = 0;
unsigned char byte = *bp->byte;
for (byte = *bp->byte; n>0; n--) {
v <<= 1;
if (byte & bp->bit) v |= 1;
bp->bit >>= 1;
if (!bp->bit) {
byte = * (++bp->byte);
bp->bit = 0x80;
}
}
return v;
}
/*//////////////////////////////////////////////////////////////////////////
// gopcod: get the next opcode. See font.h for details of encoding
//////////////////////////////////////////////////////////////////////////*/
static unsigned char gopcod (struct bitpointer *bp) {
unsigned int v;
v = gbits (bp, 2);
if (v == 1) v = gbits (bp, 3) + 1;
else if (v == 2) v = gbits (bp, 4) + 9;
else if (v == 3) v = gbits (bp, 6) + 25;
return flut[v];
}
/*//////////////////////////////////////////////////////////////////////////
// findch: find beginning of character opcodes
//////////////////////////////////////////////////////////////////////////*/
static void findch (char c, struct bitpointer *bp) {
bp->byte = &mfont[foffs[c-32]];
bp->bit = 0x80;
}
/*//////////////////////////////////////////////////////////////////////////
// banchr: prints large character
//////////////////////////////////////////////////////////////////////////*/
void banchr (const char c) {
char colors[] = " #";
struct bitpointer bp;
int color;
unsigned char opcode;
color = 0;
findch (c, &bp);
obfnex = outbuf;
do {
opcode = gopcod (&bp);
if (opcode == OPCODE_EOL) {
* (obfnex++) = '\r';
* (obfnex++) = '\n';
* (obfnex++) = 0;
cputs (outbuf);
if (FONT_DOUBLED) cputs (outbuf);
obfnex = outbuf;
color = 0;
} else if (opcode == OPCODE_REPEAT) {
cputs (outbuf);
if (FONT_DOUBLED) cputs (outbuf);
} else if (opcode != OPCODE_EOC) {
while (opcode) {
* (obfnex++) = colors[color];
if (FONT_DOUBLED) * (obfnex++) = colors[color];
opcode--;
}
color = (color + 1) & 1; /* No native XOR on PDP11/05 */
}
} while (opcode != OPCODE_EOC);
cputs ("\r\n");
}

11
banner.h Normal file
View file

@ -0,0 +1,11 @@
#ifndef _BANNER_H_
#define _BANNER_H_
#ifdef __cplusplus
extern "C" {
#endif //__cplusplus
extern void banchr (const char c);
extern void cputs (const char * s);
#ifdef __cplusplus
};
#endif //__cplusplus
#endif // _BANNER_H_

201
complex.h Normal file
View file

@ -0,0 +1,201 @@
// complex.h - declaration of class
// of complex number
//
// The code is property of LIBROW
// You can use it on your own
// When utilizing credit LIBROW site
#ifndef _COMPLEX_H_
#define _COMPLEX_H_
typedef double real;
class complex {
protected:
// Internal presentation - real and imaginary parts
real m_re;
real m_im;
public:
// Imaginary unity
//static const complex i;
//static const complex j;
// Constructors
complex() : m_re (0.), m_im (0.) {}
complex (real re, real im) : m_re (re), m_im (im) {}
complex (real val) : m_re (val), m_im (0.) {}
// Assignment
complex& operator= (const real val) {
m_re = val;
m_im = 0.;
return *this;
}
// Basic operations - taking parts
real re() const { return m_re; }
real im() const { return m_im; }
// Conjugate number
complex conjugate() const {
return complex (m_re, -m_im);
}
// Norm
real norm() const {
return m_re * m_re + m_im * m_im;
}
// Arithmetic operations
complex operator+ (const complex& other) const {
return complex (m_re + other.m_re, m_im + other.m_im);
}
complex operator- (const complex& other) const {
return complex (m_re - other.m_re, m_im - other.m_im);
}
complex operator* (const complex& other) const {
return complex (m_re * other.m_re - m_im * other.m_im,
m_re * other.m_im + m_im * other.m_re);
}
complex operator/ (const complex& other) const {
const real denominator = other.m_re * other.m_re + other.m_im * other.m_im;
return complex ( (m_re * other.m_re + m_im * other.m_im) / denominator,
(m_im * other.m_re - m_re * other.m_im) / denominator);
}
complex& operator+= (const complex& other) {
m_re += other.m_re;
m_im += other.m_im;
return *this;
}
complex& operator-= (const complex& other) {
m_re -= other.m_re;
m_im -= other.m_im;
return *this;
}
complex& operator*= (const complex& other) {
const real temp = m_re;
m_re = m_re * other.m_re - m_im * other.m_im;
m_im = m_im * other.m_re + temp * other.m_im;
return *this;
}
complex& operator/= (const complex& other) {
const real denominator = other.m_re * other.m_re + other.m_im * other.m_im;
const real temp = m_re;
m_re = (m_re * other.m_re + m_im * other.m_im) / denominator;
m_im = (m_im * other.m_re - temp * other.m_im) / denominator;
return *this;
}
complex& operator++ () {
++m_re;
return *this;
}
complex operator++ (int) {
complex temp (*this);
++m_re;
return temp;
}
complex& operator-- () {
--m_re;
return *this;
}
complex operator-- (int) {
complex temp (*this);
--m_re;
return temp;
}
complex operator+ (const real val) const {
return complex (m_re + val, m_im);
}
complex operator- (const real val) const {
return complex (m_re - val, m_im);
}
complex operator* (const real val) const {
return complex (m_re * val, m_im * val);
}
complex operator/ (const real val) const {
return complex (m_re / val, m_im / val);
}
complex& operator+= (const real val) {
m_re += val;
return *this;
}
complex& operator-= (const real val) {
m_re -= val;
return *this;
}
complex& operator*= (const real val) {
m_re *= val;
m_im *= val;
return *this;
}
complex& operator/= (const real val) {
m_re /= val;
m_im /= val;
return *this;
}
friend complex operator+ (const real left, const complex& right) {
return complex (left + right.m_re, right.m_im);
}
friend complex operator- (const real left, const complex& right) {
return complex (left - right.m_re, -right.m_im);
}
friend complex operator* (const real left, const complex& right) {
return complex (left * right.m_re, left * right.m_im);
}
friend complex operator/ (const real left, const complex& right) {
const real denominator = right.m_re * right.m_re + right.m_im * right.m_im;
return complex (left * right.m_re / denominator,
-left * right.m_im / denominator);
}
// Boolean operators
bool operator== (const complex &other) const {
return m_re == other.m_re && m_im == other.m_im;
}
bool operator!= (const complex &other) const {
return m_re != other.m_re || m_im != other.m_im;
}
bool operator== (const real val) const {
return m_re == val && m_im == 0.;
}
bool operator!= (const real val) const {
return m_re != val || m_im != 0.;
}
friend bool operator== (const real left, const complex& right) {
return left == right.m_re && right.m_im == 0.;
}
friend bool operator!= (const real left, const complex& right) {
return left != right.m_re || right.m_im != 0.;
}
};
#endif

105
fft.cpp Normal file
View file

@ -0,0 +1,105 @@
// fft.cpp - impelementation of class
// of fast Fourier transform - FFT
//
#include "fft.h"
#include <math.h>
// FORWARD FOURIER TRANSFORM, INPLACE VERSION
// Data - both input data and output
// N - length of input data
bool CFFT::Forward (complex * const Data) const {
// Check input parameters
if (!Data || N < 1 || N & (N - 1)) return false;
// Rearrange
Rearrange (Data);
// Call FFT implementation
Perform (Data);
// Succeeded
return true;
}
// INVERSE FOURIER TRANSFORM, INPLACE VERSION
// Data - both input data and output
// N - length of both input data and result
// Scale - if to scale result
bool CFFT::Inverse (complex * const Data, const bool Sc /* = true */) const {
// Check input parameters
if (!Data || N < 1 || N & (N - 1)) return false;
// Rearrange
Rearrange (Data);
// Call FFT implementation
Perform (Data, true);
// Scale if necessary
if (Sc) Scale (Data);
// Succeeded
return true;
}
// Inplace version of rearrange function
void CFFT::Rearrange (complex * const Data) const {
// Swap position
unsigned int Target = 0;
// Process all positions of input signal
for (unsigned int Position = 0; Position < N; ++Position) {
// Only for not yet swapped entries
if (Target > Position) {
// Swap entries
const complex Temp (Data[Target]);
Data[Target] = Data[Position];
Data[Position] = Temp;
}
// Výpočet Target (v podstatě reverzace pořadí bitů Position)
unsigned int Mask = N;
// While bit is set
while (Target & (Mask >>= 1))
// Drop bit
Target &= ~Mask;
// The current bit is 0 - set it
Target |= Mask;
}
}
// FFT implementation
void CFFT::Perform (complex * const Data, const bool Inverse /* = false */) const {
complex Product;
unsigned int Step;
const real pi = Inverse ? 3.14159265358979323846 : -3.14159265358979323846;
// Iteration through dyads, quadruples, octads and so on...
for (Step = 1; Step < N; Step <<= 1) { // 1,2,...N/2
// Jump to the next entry of the same transform factor Jump = Step * 2
const unsigned int Jump = Step << 1; // 2,4,...N
// Angle increment
const real delta = pi / real (Step);
const real incr = 1.0 / real (Step);
// Multiplier for trigonometric recurrence
const complex Multiplier (cos (delta), sin (delta));
// Start value for transform factor, fi = 0
complex Factor (1.0);
real rot = 0.0;
// Iteration through groups of different transform factor
for (unsigned int Group = 0; Group < Step; ++Group) {
// Iteration within group
for (unsigned int Pair = Group; Pair < N; Pair += Jump) {
// Match position
const unsigned int Match = Pair + Step;
// Second term of two-point transform
Product = Factor * Data[Match];
// Transform for fi + pi
Data[Match] = Data[Pair] - Product;
// Transform for fi
Data[Pair] = Data[Pair] + Product;
}
// Successive transform factor via trigonometric recurrence
// Factor = Multiplier * Factor + Factor;
Factor *= Multiplier;
rot += incr;
}
}
}
// Scaling of inverse FFT result
void CFFT::Scale (complex *const Data) const {
const real Factor = 1.0 / real (N);
// Scale all data entries
for (unsigned int Position = 0; Position < N; ++Position)
Data[Position] *= Factor;
}

33
fft.h Normal file
View file

@ -0,0 +1,33 @@
// fft.h - declaration of class
// of fast Fourier transform - FFT
//
#ifndef _FFT_H_
#define _FFT_H_
// Include complex numbers header
#include "complex.h"
class CFFT {
public:
CFFT (const unsigned order) : N(1<<order) {};
// FORWARD FOURIER TRANSFORM, INPLACE VERSION
// Data - both input data and output
// N - length of input data
bool Forward (complex * const Data) const;
// INVERSE FOURIER TRANSFORM, INPLACE VERSION
// Data - both input data and output
// N - length of both input data and result
// Scale - if to scale result
bool Inverse (complex * const Data, const bool Scale = true) const;
protected:
void Rearrange (complex * const Data) const;
// FFT implementation
void Perform (complex * const Data, const bool Inverse = false) const;
// Scaling of inverse FFT result
void Scale (complex * const Data) const;
private:
const unsigned N;
};
#endif

455
font.h Normal file
View file

@ -0,0 +1,455 @@
/********************************************************************
* Font File format:
* 2 bits: =0, opcode lut index 0
* =1, opcode lut index is in next 3 bits + 1
* =2, opcode lut index is in next 4 bits + 9
* =3, opcode lut index is in next 6 bits + 25
********************************************************************/
unsigned char mfont[] = {
0xDE, 0x00, 0x00, 0x00, 0xB0, 0x00, 0x9A, 0x0C, 0x58, 0x04, 0x43, 0x35,
0xA3, 0x63, 0x5E, 0x98, 0xA5, 0x29, 0x10, 0xC5, 0x59, 0x34, 0x18, 0xB0,
0x00, 0x16, 0x00, 0x00, 0x38, 0x56, 0x6D, 0xD2, 0x6B, 0xC4, 0x2B, 0x6E,
0x93, 0x85, 0x66, 0xF0, 0xA5, 0x2B, 0x85, 0x66, 0xDD, 0x26, 0xBC, 0x42,
0xB6, 0xE9, 0x38, 0x56, 0x00, 0x16, 0x00, 0x33, 0x9D, 0x43, 0x85, 0x21,
0x30, 0xBA, 0x87, 0x08, 0x8E, 0x77, 0x50, 0xE1, 0x16, 0xD0, 0xE2, 0xBC,
0x9C, 0x67, 0x19, 0x79, 0x26, 0x73, 0xB1, 0xB2, 0x4C, 0xE7, 0x3E, 0xB3,
0x39, 0xD4, 0x3A, 0x78, 0xCC, 0xE7, 0x50, 0xE8, 0x52, 0x21, 0x30, 0xBA,
0x87, 0x08, 0x8E, 0x77, 0x50, 0xE1, 0x15, 0xBD, 0xC5, 0x79, 0x38, 0xCE,
0x32, 0xF2, 0x4C, 0xEC, 0xE3, 0x39, 0xCF, 0xAC, 0xCE, 0x75, 0x0E, 0x9E,
0x33, 0x39, 0xD4, 0x3A, 0x14, 0x99, 0xCE, 0xA1, 0xC2, 0x8B, 0x00, 0x08,
0xA3, 0x8A, 0x12, 0x28, 0xE9, 0x68, 0x88, 0x5B, 0x68, 0x87, 0x5B, 0x8E,
0x21, 0x73, 0x64, 0x8D, 0x5C, 0xD5, 0x41, 0x00, 0xD5, 0xCD, 0x2C, 0x2B,
0x1A, 0x99, 0xA5, 0x8D, 0x63, 0x53, 0x14, 0x75, 0x24, 0x97, 0xAC, 0x53,
0x52, 0xD9, 0x5A, 0x91, 0xAB, 0xA6, 0x56, 0xA4, 0x42, 0x6F, 0x95, 0xAB,
0x10, 0xE9, 0x65, 0x6B, 0x88, 0xA0, 0x92, 0xAA, 0x5C, 0x4D, 0x83, 0x2C,
0x25, 0xB8, 0x51, 0xC2, 0x57, 0x5D, 0xF0, 0x98, 0x08, 0x2E, 0x84, 0x2C,
0x00, 0x35, 0xA3, 0x32, 0xAD, 0x36, 0x71, 0xCD, 0xFC, 0x11, 0x5A, 0x50,
0x5F, 0x01, 0xA4, 0x9B, 0x52, 0x37, 0x1B, 0x01, 0x36, 0xA4, 0x6A, 0x6D,
0x5C, 0x4B, 0x1A, 0xE8, 0xA0, 0xBE, 0x01, 0xB2, 0x23, 0x04, 0x89, 0xF4,
0xE4, 0x95, 0xC9, 0x7E, 0x39, 0x80, 0xFA, 0xA6, 0x32, 0x5F, 0x7C, 0x66,
0x23, 0xCC, 0xB7, 0x99, 0x92, 0x18, 0xAF, 0x33, 0xDE, 0x6A, 0x3C, 0xDF,
0x79, 0x95, 0x21, 0xB4, 0xF3, 0x0A, 0x38, 0xE4, 0x2D, 0xB6, 0x17, 0x93,
0x63, 0xCA, 0xF1, 0x18, 0x31, 0xC8, 0x23, 0x06, 0xF7, 0x8D, 0x82, 0xF8,
0x1B, 0x20, 0xD4, 0xDA, 0x98, 0x9C, 0x35, 0x36, 0xA6, 0xD4, 0x8D, 0x5C,
0x4B, 0xC0, 0xC6, 0x1B, 0x05, 0xF0, 0x08, 0xC1, 0x22, 0xC9, 0x26, 0xC7,
0x2B, 0x98, 0xC2, 0x8C, 0x00, 0xB0, 0x03, 0x26, 0x13, 0x1D, 0xA5, 0xB6,
0x93, 0x60, 0x11, 0x64, 0xBE, 0x82, 0x2C, 0x14, 0xB4, 0x43, 0xE1, 0x7E,
0x34, 0xC2, 0x1C, 0xDB, 0x86, 0xBA, 0x6C, 0x11, 0xAB, 0x9A, 0xE1, 0xA9,
0x9A, 0xF7, 0xB8, 0x6A, 0x51, 0x55, 0x49, 0x1A, 0x96, 0xC7, 0x4A, 0x46,
0xA6, 0xFA, 0x6F, 0x48, 0xD4, 0xC7, 0x6D, 0x0E, 0x1A, 0xB8, 0x63, 0x9F,
0x1C, 0x42, 0x5F, 0x1A, 0xED, 0x10, 0xB8, 0x25, 0x92, 0x22, 0x25, 0xA6,
0x3A, 0x10, 0x44, 0xEC, 0x68, 0xE3, 0xBC, 0x99, 0x0D, 0x79, 0x6D, 0xE5,
0x71, 0xCB, 0x39, 0x33, 0x5E, 0xC2, 0x2C, 0x31, 0x19, 0x62, 0x28, 0x9E,
0x21, 0x0F, 0x75, 0x22, 0x20, 0x96, 0x51, 0x0B, 0x8A, 0x01, 0x09, 0xC0,
0x60, 0x86, 0x61, 0x30, 0x43, 0x32, 0x67, 0x11, 0x38, 0x16, 0x00, 0x00,
0xE1, 0x59, 0xB7, 0x49, 0xAF, 0x10, 0xAD, 0xBA, 0x4E, 0x15, 0x80, 0x58,
0x0C, 0x9A, 0xC9, 0xB3, 0x0A, 0x74, 0x88, 0xF6, 0x88, 0x74, 0x07, 0xF2,
0x10, 0x53, 0x75, 0x23, 0xA8, 0xD2, 0xA0, 0x5C, 0x1A, 0xD0, 0x0C, 0x83,
0x6E, 0x02, 0x77, 0x73, 0x38, 0xC6, 0x5F, 0x42, 0xC0, 0xB0, 0x31, 0x97,
0xD0, 0xB2, 0x77, 0x73, 0x38, 0x4B, 0xB6, 0xDC, 0x2E, 0x4D, 0xA9, 0x07,
0x43, 0xA9, 0x41, 0x03, 0x70, 0x69, 0x1F, 0xC8, 0x43, 0xA0, 0x47, 0xB4,
0x53, 0xA4, 0x4D, 0x98, 0x64, 0xD6, 0x01, 0x60, 0x0D, 0x69, 0xDD, 0x39,
0x94, 0xE7, 0x38, 0xC8, 0x7A, 0x5E, 0x6C, 0xC8, 0x99, 0x0E, 0x08, 0x27,
0x80, 0xDA, 0x74, 0xEE, 0x35, 0xA8, 0x35, 0x53, 0x04, 0x90, 0x24, 0xD5,
0xC3, 0x14, 0xAD, 0x54, 0xC1, 0x24, 0x09, 0x37, 0x61, 0x36, 0x9D, 0x3B,
0x8E, 0x08, 0x27, 0x80, 0xD9, 0x91, 0x32, 0x19, 0x0F, 0x4B, 0xCC, 0xA7,
0x39, 0xC6, 0xB4, 0xEE, 0x9C, 0x02, 0xC0, 0x0D, 0x47, 0x0A, 0x52, 0x94,
0xA5, 0x29, 0x4A, 0xC2, 0xCF, 0x14, 0xAD, 0x47, 0x0A, 0x52, 0x94, 0xA5,
0x29, 0x4A, 0x0B, 0x00, 0x20, 0x49, 0x22, 0x61, 0x71, 0x22, 0xE4, 0x78,
0xF7, 0x2E, 0x12, 0x8B, 0x48, 0x66, 0x23, 0x69, 0x7D, 0x42, 0x1E, 0x05,
0x80, 0x0C, 0xE8, 0x05, 0x29, 0x4A, 0x52, 0x94, 0xA5, 0x29, 0x41, 0x60,
0x09, 0xA0, 0x11, 0x08, 0xD8, 0xC5, 0x29, 0x48, 0x84, 0x9A, 0x00, 0x2C,
0x6B, 0x06, 0xC8, 0x36, 0xA2, 0x6A, 0x4C, 0x2A, 0x4C, 0x36, 0x98, 0xB4,
0x9A, 0x8D, 0x38, 0x29, 0x34, 0x29, 0x3A, 0x6A, 0x39, 0x64, 0x3B, 0x98,
0x58, 0x0C, 0xEA, 0xCC, 0x1C, 0xC3, 0x03, 0x54, 0xAF, 0x20, 0x9B, 0x68,
0x8B, 0x58, 0x46, 0x80, 0xD8, 0x73, 0x68, 0x1A, 0xBC, 0x85, 0x8D, 0x4E,
0x52, 0x45, 0x35, 0xDA, 0x4E, 0x11, 0x0E, 0x1C, 0xA2, 0x34, 0x08, 0xB5,
0x89, 0xB6, 0x8A, 0xF2, 0x0C, 0x0D, 0x53, 0x07, 0x30, 0xCC, 0xB4, 0x0B,
0x00, 0x00, 0x43, 0x34, 0x52, 0x21, 0x99, 0xE9, 0x10, 0x9C, 0xF4, 0x88,
0x4E, 0x7A, 0xC4, 0x27, 0x61, 0x62, 0x37, 0x44, 0x6B, 0x08, 0xD7, 0x11,
0xA0, 0x29, 0x4A, 0x42, 0x45, 0x29, 0x0C, 0x14, 0x05, 0x80, 0x04, 0x48,
0x22, 0x8C, 0x39, 0x44, 0x4B, 0x74, 0xA2, 0x23, 0xC3, 0x78, 0x8B, 0xF3,
0x92, 0x21, 0xF3, 0xBB, 0x2D, 0x62, 0x1E, 0xC7, 0x65, 0xA4, 0x43, 0xD3,
0x06, 0x22, 0x44, 0x3D, 0xD0, 0x60, 0xA4, 0x43, 0xE0, 0x93, 0x09, 0x22,
0x1F, 0x23, 0xEB, 0x58, 0x87, 0xBE, 0x14, 0x38, 0x43, 0xE1, 0x8E, 0x17,
0x88, 0x7C, 0xB9, 0x62, 0x1F, 0x56, 0x20, 0x87, 0xDF, 0x82, 0x21, 0xED,
0xC0, 0x10, 0xF8, 0xAD, 0x10, 0xFB, 0x5A, 0x21, 0xF8, 0x54, 0x08, 0x78,
0x58, 0x04, 0x46, 0x22, 0x3C, 0x19, 0x44, 0x51, 0x87, 0x28, 0x85, 0xE7,
0xBC, 0x6A, 0xF2, 0x16, 0x35, 0x35, 0xAD, 0x0B, 0x1A, 0x9A, 0xD7, 0x12,
0x45, 0x29, 0xAB, 0x9A, 0x06, 0xAC, 0x6B, 0xA2, 0x92, 0xF7, 0x0D, 0x82,
0x98, 0xE8, 0x90, 0x43, 0xE1, 0xCD, 0x11, 0x83, 0x8D, 0x80, 0x45, 0x93,
0x3D, 0x64, 0x58, 0x4C, 0xAC, 0x9B, 0x1D, 0x73, 0x15, 0xCD, 0x25, 0x26,
0x03, 0x65, 0xA0, 0xC1, 0x84, 0x0B, 0x00, 0x2E, 0x90, 0xBA, 0x82, 0xE8,
0xCB, 0xAF, 0x2E, 0x92, 0x79, 0x0B, 0xA4, 0x5C, 0x05, 0xD2, 0x41, 0x21,
0x74, 0x94, 0x40, 0x5D, 0x24, 0xB2, 0x17, 0x49, 0x7C, 0x05, 0xD2, 0x36,
0x42, 0xE9, 0x26, 0x80, 0xBA, 0x4A, 0xE4, 0x11, 0xAC, 0x23, 0x40, 0x52,
0x94, 0xAB, 0xA4, 0x14, 0xA2, 0xC0, 0x11, 0x18, 0xA4, 0x43, 0x56, 0x08,
0x85, 0xCD, 0x82, 0x35, 0x75, 0xE4, 0x8D, 0x5D, 0x69, 0x8D, 0xE3, 0x53,
0x80, 0xC8, 0xDE, 0x35, 0x38, 0x09, 0x95, 0xE2, 0x94, 0xD5, 0xD6, 0xB9,
0x5E, 0x29, 0xB0, 0x22, 0x09, 0x5E, 0x21, 0xF2, 0xD1, 0x2B, 0xC4, 0x61,
0xC6, 0xF2, 0x2C, 0x48, 0xDE, 0x4D, 0x83, 0x53, 0xCB, 0x70, 0xAF, 0x79,
0x5E, 0x3D, 0x2F, 0x30, 0x22, 0x2E, 0x84, 0x0B, 0x00, 0x0C, 0xC8, 0x8B,
0xB0, 0xCC, 0x2D, 0x12, 0xBD, 0x22, 0xDD, 0x92, 0x6D, 0xA2, 0x2D, 0x61,
0x12, 0xD4, 0x98, 0x2A, 0x1B, 0x05, 0xA9, 0x95, 0xE3, 0x57, 0x8E, 0xBA,
0xA0, 0x1A, 0x9C, 0x05, 0xD2, 0xB1, 0xA9, 0xC0, 0x5B, 0x52, 0x35, 0x76,
0xC0, 0xD4, 0x8D, 0x92, 0xFA, 0x1A, 0x91, 0x19, 0xB4, 0xAC, 0x46, 0x5B,
0x56, 0x45, 0x87, 0x2B, 0xC9, 0xAE, 0xA2, 0x52, 0xBC, 0x09, 0x65, 0x30,
0x26, 0x2E, 0x94, 0x2C, 0x03, 0x8A, 0xF1, 0x48, 0x9F, 0x3E, 0x51, 0x0B,
0xCF, 0x78, 0x89, 0x34, 0xDE, 0x22, 0x1C, 0xD7, 0x88, 0xAB, 0x11, 0xE4,
0xD4, 0xE1, 0x3C, 0xC0, 0xBE, 0xB7, 0x98, 0x37, 0xC4, 0xF3, 0x2E, 0xAA,
0x5E, 0x69, 0xC7, 0x1B, 0xCD, 0x89, 0x68, 0x79, 0xA5, 0x1B, 0x9E, 0x65,
0x4A, 0xC7, 0x9A, 0xD3, 0x1B, 0x74, 0x9D, 0x31, 0x9D, 0xAF, 0x38, 0x56,
0x16, 0x00, 0x0C, 0x99, 0x4C, 0x74, 0x4B, 0x41, 0x6D, 0x70, 0x52, 0x4D,
0x80, 0x99, 0x88, 0xB2, 0x67, 0xAC, 0x46, 0x80, 0xA6, 0xC9, 0x7E, 0x58,
0xD5, 0xDB, 0x05, 0x50, 0x0D, 0x4E, 0x3A, 0x62, 0x48, 0xA6, 0xA7, 0x1D,
0x6D, 0x58, 0xD5, 0xDB, 0x24, 0x70, 0x0D, 0x92, 0xFC, 0xB1, 0x1A, 0x02,
0x35, 0xC8, 0xB2, 0x67, 0xAC, 0x9B, 0x01, 0x31, 0x16, 0xD7, 0x05, 0x26,
0x3A, 0x25, 0xA0, 0xC9, 0x84, 0x2C, 0x36, 0xA3, 0x11, 0x2D, 0x53, 0x08,
0x96, 0x5C, 0x01, 0x0F, 0xAB, 0x04, 0x6B, 0x9B, 0x88, 0x35, 0x6D, 0xCB,
0x1A, 0x96, 0xE6, 0x8D, 0x4B, 0x5F, 0x7B, 0xC6, 0xA5, 0xAE, 0xAD, 0x63,
0x52, 0xD5, 0xE0, 0x24, 0x6A, 0xE9, 0x5E, 0x02, 0x44, 0x3A, 0xA5, 0xE3,
0xAC, 0x43, 0xE5, 0x4D, 0x6E, 0x22, 0xA9, 0xCB, 0xAA, 0x52, 0x2D, 0x72,
0xDD, 0xA2, 0xBC, 0xA3, 0x03, 0x7C, 0xC9, 0xCF, 0x31, 0x33, 0x4D, 0x39,
0x80, 0xB0, 0x00, 0x9A, 0x04, 0x40, 0x22, 0x1A, 0xA1, 0x1B, 0x1C, 0xB1,
0x8A, 0x52, 0x91, 0x0D, 0x50, 0x93, 0x40, 0x88, 0x00, 0x0B, 0x00, 0x02,
0x04, 0x92, 0x26, 0x17, 0x53, 0x01, 0x22, 0xE4, 0x7C, 0x70, 0x8F, 0x72,
0xE1, 0x86, 0x32, 0x8B, 0x61, 0x8C, 0x86, 0x68, 0x63, 0x23, 0x6C, 0xB1,
0x97, 0xD5, 0x54, 0x22, 0x1E, 0x88, 0x00, 0x0B, 0x00, 0x0D, 0x25, 0x8A,
0xD4, 0x80, 0xD5, 0x79, 0xB0, 0xBC, 0x65, 0x99, 0xEE, 0xC6, 0x71, 0x9E,
0xB6, 0x2C, 0xD1, 0x5A, 0xD6, 0x62, 0xAE, 0x05, 0x9A, 0x6B, 0x7A, 0xCC,
0xC7, 0x3D, 0xC6, 0x73, 0xA1, 0x71, 0x9C, 0xB8, 0xD6, 0x66, 0xAE, 0xF5,
0x99, 0x6B, 0x6A, 0xCC, 0x37, 0x35, 0xC6, 0x23, 0xA2, 0x71, 0x88, 0xBB,
0x56, 0x5C, 0xBC, 0x75, 0x98, 0x2B, 0xC2, 0x59, 0x92, 0xEC, 0x27, 0x18,
0x4E, 0xC1, 0x70, 0x05, 0x80, 0x0C, 0xE7, 0x50, 0xE1, 0x4A, 0x52, 0x94,
0xA5, 0x29, 0x4A, 0x52, 0x94, 0xA5, 0x29, 0x4A, 0x52, 0x94, 0x05, 0x80,
0x0C, 0x27, 0x60, 0xB8, 0xC9, 0x76, 0x13, 0x8C, 0x15, 0xE1, 0x2C, 0xB9,
0x78, 0xEB, 0x31, 0x17, 0x6A, 0xCC, 0x47, 0x44, 0xE3, 0x0D, 0xCD, 0x71,
0x96, 0xB6, 0xAC, 0xCD, 0x5D, 0xEB, 0x33, 0x97, 0x1A, 0xCC, 0xE7, 0x42,
0xE3, 0x31, 0xCF, 0x71, 0xA6, 0xB7, 0xAC, 0xC5, 0x5C, 0x0B, 0x34, 0x56,
0xB5, 0x99, 0xEB, 0x62, 0xCC, 0xF7, 0x63, 0x38, 0xD8, 0x5E, 0x32, 0xCD,
0x57, 0x9A, 0x90, 0x1A, 0x4B, 0x14, 0x05, 0x80, 0x03, 0x9A, 0x51, 0x5D,
0x12, 0x1B, 0x8B, 0x26, 0x83, 0x55, 0x22, 0x21, 0x92, 0x4A, 0xD2, 0x36,
0x36, 0x47, 0x6A, 0x45, 0x36, 0x37, 0xC9, 0x12, 0xC6, 0xC7, 0x0C, 0x0D,
0x70, 0x88, 0x63, 0x7C, 0xB2, 0x13, 0x41, 0x7D, 0xC6, 0xFE, 0x09, 0x91,
0x84, 0x6C, 0xE3, 0x99, 0x56, 0x9B, 0x48, 0x34, 0x28, 0x00, 0xB0, 0x0C,
0x06, 0x91, 0x5C, 0x53, 0xA6, 0x47, 0xA8, 0x4B, 0x1D, 0x37, 0x94, 0x51,
0x83, 0x08, 0xF9, 0x33, 0x1E, 0x41, 0x26, 0x7B, 0xC7, 0x41, 0xBF, 0x00,
0xE5, 0xC7, 0x2D, 0x6E, 0x16, 0xB8, 0x62, 0x89, 0xC2, 0x57, 0x0E, 0x3A,
0x16, 0x25, 0x74, 0x64, 0xB5, 0x62, 0x53, 0x0D, 0xD4, 0xAC, 0x62, 0xE1,
0xC3, 0xBD, 0x63, 0x13, 0x2C, 0x12, 0xCB, 0x7A, 0x46, 0x26, 0x35, 0xA2,
0x4A, 0x96, 0x31, 0x35, 0x26, 0xD7, 0x54, 0x91, 0x89, 0xBD, 0x35, 0xA6,
0xA4, 0x8C, 0x4D, 0x29, 0xAD, 0x35, 0x24, 0x62, 0x6A, 0x7C, 0x49, 0xA9,
0x22, 0x59, 0x2C, 0x50, 0xAE, 0x34, 0x89, 0x4C, 0x38, 0x2C, 0x5C, 0x69,
0x12, 0x98, 0x74, 0xE3, 0x48, 0xB6, 0x43, 0xA7, 0x1A, 0x45, 0xA6, 0x8D,
0x38, 0xD2, 0x39, 0x34, 0x26, 0x4A, 0xE5, 0x59, 0x03, 0x28, 0x4D, 0x35,
0x4A, 0x92, 0x04, 0xD0, 0xCC, 0x78, 0x21, 0x59, 0x22, 0x68, 0x66, 0xC2,
0xCA, 0x12, 0xF6, 0x68, 0xB8, 0x86, 0x78, 0x53, 0x98, 0xE3, 0x09, 0x78,
0x70, 0x19, 0x32, 0x60, 0x48, 0x5D, 0x0D, 0xF0, 0x98, 0x79, 0xC6, 0x75,
0xC6, 0x2E, 0x39, 0xAB, 0x50, 0x05, 0x80, 0x43, 0x04, 0x24, 0x43, 0x84,
0x50, 0x22, 0xF1, 0x09, 0x9E, 0x31, 0x09, 0x82, 0x51, 0x0C, 0x96, 0x51,
0x0C, 0xBE, 0xA3, 0x15, 0x33, 0xCA, 0x62, 0xA5, 0xD2, 0x98, 0xA9, 0xA2,
0x33, 0x15, 0x37, 0xCA, 0x62, 0xA6, 0x29, 0x4C, 0x54, 0xE3, 0xC8, 0x62,
0xA6, 0x29, 0x4C, 0x54, 0xDF, 0x49, 0x8A, 0x98, 0x66, 0x31, 0x53, 0x06,
0x01, 0x8A, 0x96, 0x60, 0x98, 0xB8, 0x62, 0x19, 0x56, 0x08, 0x86, 0x51,
0x82, 0x21, 0x2B, 0xB8, 0x42, 0x71, 0xAE, 0x11, 0x88, 0x23, 0x08, 0x45,
0xA2, 0x1A, 0x22, 0xA1, 0x14, 0x08, 0x70, 0x84, 0x88, 0x61, 0x60, 0x10,
0xCC, 0xA6, 0x0A, 0x42, 0x72, 0x12, 0x29, 0x1A, 0x02, 0x94, 0xA5, 0x29,
0x48, 0x4D, 0x69, 0x42, 0x45, 0x29, 0x4A, 0x42, 0x6B, 0x5D, 0x2B, 0x10,
0x9B, 0x60, 0xBD, 0x62, 0x17, 0x33, 0xE8, 0x90, 0x43, 0x9B, 0x88, 0x21,
0xF2, 0xE1, 0x91, 0x60, 0xE3, 0x56, 0x45, 0x83, 0x8D, 0x69, 0x36, 0x13,
0x26, 0x26, 0xC2, 0x4A, 0x0B, 0x71, 0xE0, 0xA8, 0xC7, 0x9A, 0x17, 0x98,
0x54, 0x97, 0x50, 0x16, 0x00, 0x0C, 0x5A, 0x4C, 0xBC, 0x92, 0xEC, 0xE3,
0x0B, 0x3C, 0xC0, 0xD4, 0x2B, 0xC8, 0x2D, 0xCA, 0x26, 0xDA, 0x22, 0xA5,
0x14, 0x91, 0x43, 0x74, 0x22, 0x1F, 0x98, 0xF1, 0x10, 0x67, 0xC0, 0x36,
0x0D, 0x45, 0x8D, 0x76, 0xFA, 0xC6, 0xAF, 0x21, 0x63, 0x53, 0x94, 0x91,
0x4A, 0x52, 0x94, 0x84, 0xE4, 0x2C, 0x42, 0x72, 0x12, 0x21, 0x7A, 0x4B,
0x22, 0x5E, 0xAB, 0x88, 0x9F, 0x99, 0x01, 0x15, 0x58, 0xF1, 0x93, 0x47,
0x8F, 0x18, 0x01, 0x60, 0x10, 0xCC, 0xA6, 0x0A, 0x42, 0x72, 0x12, 0x29,
0x1A, 0x02, 0x94, 0xA5, 0x29, 0x48, 0x4E, 0x42, 0x45, 0x29, 0x4A, 0x42,
0x77, 0xD6, 0x21, 0x7A, 0x4B, 0x10, 0xBD, 0x47, 0x08, 0x76, 0xC3, 0x88,
0x9D, 0x8B, 0x21, 0x13, 0xF0, 0xE1, 0x26, 0x8E, 0x6B, 0xC9, 0xB8, 0x0B,
0x72, 0x8A, 0xF2, 0x0C, 0x7D, 0x43, 0x0B, 0x3C, 0xC1, 0xCC, 0x30, 0xEE,
0x34, 0xD0, 0x05, 0x80, 0x10, 0xCC, 0xA6, 0x0A, 0x42, 0x72, 0x12, 0x29,
0x1A, 0x02, 0x94, 0xA5, 0x29, 0x48, 0x4D, 0xA9, 0x89, 0x22, 0x94, 0xA5,
0x29, 0x4A, 0x42, 0x62, 0x91, 0xA9, 0x10, 0x9B, 0xE9, 0x8D, 0x22, 0x90,
0x9C, 0x84, 0x88, 0x4E, 0xA4, 0x02, 0x17, 0x99, 0x18, 0x88, 0x6E, 0x8C,
0x45, 0x42, 0x82, 0xC0, 0x10, 0xCC, 0xA6, 0x0A, 0x42, 0x72, 0x12, 0x29,
0x1A, 0x02, 0x94, 0xA5, 0x29, 0x48, 0x4C, 0x49, 0xB5, 0x22, 0x90, 0xC9,
0x93, 0x6A, 0x45, 0x2B, 0x51, 0x36, 0xA4, 0x56, 0xC4, 0x91, 0x24, 0xCC,
0x45, 0x49, 0x15, 0xB8, 0x93, 0x96, 0x03, 0x92, 0xA1, 0x41, 0x60, 0x0C,
0x5A, 0x4C, 0xBC, 0x92, 0xEC, 0xD3, 0x27, 0x14, 0xC0, 0xD5, 0x31, 0xF4,
0x8B, 0x72, 0x89, 0xB6, 0x89, 0xAF, 0x45, 0xE4, 0x50, 0xE2, 0x50, 0x21,
0xFA, 0x72, 0x08, 0x83, 0x3E, 0x01, 0x0E, 0xD4, 0x58, 0xD7, 0x6F, 0xAC,
0x6A, 0xF2, 0x16, 0x35, 0x39, 0x49, 0x14, 0xA5, 0x35, 0x28, 0x66, 0x12,
0x45, 0x21, 0x34, 0xA7, 0x01, 0x62, 0x13, 0x4A, 0x70, 0x12, 0x23, 0x03,
0x1D, 0x62, 0xA2, 0xC7, 0xAD, 0x64, 0x58, 0xF3, 0x40, 0x45, 0x8F, 0x54,
0xA4, 0xD5, 0xD5, 0x29, 0x35, 0x66, 0x7A, 0x4D, 0x86, 0x0A, 0x0B, 0x00,
0x10, 0xCC, 0xA6, 0x0A, 0x42, 0x72, 0x12, 0x29, 0x1A, 0x02, 0x94, 0xA5,
0x29, 0x48, 0x4D, 0xA9, 0x89, 0x22, 0x90, 0xCA, 0xD3, 0x33, 0x05, 0x6F,
0xA4, 0x52, 0x94, 0xA4, 0x32, 0xB4, 0xCC, 0xC1, 0x48, 0x4D, 0xA9, 0x89,
0x22, 0x91, 0xA0, 0x29, 0x4A, 0x52, 0x94, 0x84, 0xE4, 0x24, 0x52, 0x19,
0x94, 0xC1, 0x45, 0x80, 0x10, 0xCC, 0xA6, 0x0A, 0x42, 0x72, 0x12, 0x29,
0x1A, 0x02, 0x94, 0xA5, 0x29, 0x48, 0x4E, 0x42, 0x45, 0x21, 0x99, 0x4C,
0x14, 0x16, 0x00, 0x01, 0x12, 0x8A, 0x6C, 0x03, 0x56, 0x35, 0x23, 0x53,
0x94, 0xC1, 0x4D, 0x5E, 0x42, 0x46, 0xC1, 0xA4, 0x91, 0x1A, 0x02, 0xA2,
0xD7, 0x26, 0xD6, 0x2B, 0xDA, 0x30, 0x32, 0x8B, 0xB4, 0x8D, 0xC4, 0x8A,
0xE3, 0x60, 0x16, 0x00, 0x10, 0xCC, 0xA6, 0x0A, 0x42, 0x72, 0x12, 0x29,
0x1A, 0x02, 0x94, 0xA5, 0x29, 0x48, 0x4A, 0x1D, 0x32, 0x44, 0x26, 0x27,
0x44, 0x91, 0x0C, 0xAD, 0xC8, 0x60, 0x86, 0x63, 0xB9, 0xAC, 0x37, 0xE4,
0x35, 0x25, 0x36, 0x2F, 0x34, 0x50, 0x69, 0xDF, 0x8C, 0xE3, 0x36, 0x95,
0xAC, 0xC3, 0xA6, 0x47, 0x17, 0x53, 0x0B, 0x8C, 0x9A, 0x6F, 0x5A, 0xD8,
0x60, 0x52, 0x87, 0x31, 0x85, 0x74, 0xD6, 0xBC, 0x64, 0x93, 0x53, 0x84,
0xF1, 0x14, 0xDD, 0x20, 0x88, 0xF3, 0x9C, 0x22, 0x1C, 0x55, 0x88, 0x7E,
0xC2, 0x44, 0x41, 0xA4, 0xC1, 0x0B, 0xC8, 0x60, 0x84, 0x88, 0x60, 0xAB,
0x00, 0x10, 0xCC, 0xA6, 0x0A, 0x42, 0x72, 0x12, 0x29, 0x1A, 0x02, 0x94,
0xA5, 0x29, 0x48, 0x4E, 0x42, 0x45, 0x21, 0x3B, 0x2C, 0x14, 0xA4, 0x24,
0x52, 0x94, 0xA5, 0x29, 0x0B, 0x11, 0x00, 0x88, 0xC4, 0x52, 0x60, 0x50,
0x05, 0x80, 0x10, 0xCC, 0xA6, 0x0A, 0x42, 0x72, 0x12, 0x29, 0x1A, 0x02,
0x94, 0x84, 0xE7, 0xD0, 0x21, 0x39, 0x95, 0x08, 0x66, 0x5A, 0x04, 0x33,
0x06, 0xB3, 0x23, 0x24, 0xD5, 0xC4, 0x34, 0xF0, 0xCC, 0xBC, 0x33, 0x07,
0x0C, 0xC7, 0xC4, 0x22, 0xC4, 0x11, 0x92, 0x5B, 0x11, 0x85, 0x09, 0x74,
0x26, 0x6C, 0x26, 0x9C, 0xA6, 0xC4, 0x26, 0xFC, 0x26, 0x54, 0x22, 0x19,
0x89, 0x08, 0x86, 0x66, 0xC2, 0x21, 0x3A, 0x70, 0x88, 0x4E, 0x7D, 0x02,
0x34, 0x05, 0x29, 0x4A, 0x52, 0x90, 0x9C, 0x84, 0x8A, 0x43, 0x32, 0x98,
0x28, 0xB0, 0x10, 0xCC, 0xA6, 0x0A, 0x42, 0x72, 0x12, 0x29, 0x1A, 0x02,
0x94, 0x84, 0xE7, 0xD0, 0x21, 0x38, 0xB2, 0x88, 0x66, 0x9D, 0x42, 0x19,
0x9A, 0xD3, 0x5D, 0xA6, 0xEB, 0x4E, 0x06, 0x99, 0x0D, 0x34, 0x9A, 0x6A,
0xB4, 0xCF, 0x69, 0xA6, 0xD3, 0x39, 0xA6, 0x5B, 0x4C, 0x46, 0x99, 0x2D,
0xC0, 0x61, 0x80, 0xDC, 0x96, 0x15, 0xB7, 0x05, 0x24, 0xCD, 0xC4, 0x48,
0x8D, 0x01, 0x4A, 0xDC, 0x48, 0xAE, 0x36, 0x0A, 0xB0, 0x0C, 0x56, 0x99,
0x78, 0x26, 0x0E, 0x61, 0x85, 0x9E, 0x63, 0xE9, 0x15, 0xE4, 0x16, 0xE5,
0x13, 0x6D, 0x11, 0x55, 0x5D, 0x44, 0x4F, 0xCD, 0x78, 0x88, 0x33, 0xE0,
0x10, 0xED, 0x57, 0x0D, 0x5E, 0x42, 0xC5, 0x35, 0x39, 0x49, 0x14, 0xA5,
0x29, 0xAB, 0xC8, 0x58, 0x84, 0xE4, 0x2C, 0x43, 0xB5, 0x5C, 0x22, 0x0C,
0xF8, 0x08, 0x9F, 0x9A, 0xF2, 0x2B, 0xED, 0xA8, 0x9B, 0x68, 0xB7, 0x28,
0xAF, 0x20, 0xC7, 0xD2, 0x30, 0xB3, 0xCC, 0x1C, 0xC3, 0x2F, 0x04, 0xC5,
0xA4, 0x0B, 0x00, 0x10, 0xCC, 0xA6, 0x0A, 0x42, 0x72, 0x12, 0x29, 0x1A,
0x02, 0x94, 0xA5, 0x29, 0x48, 0x4B, 0x53, 0x8E, 0x91, 0x48, 0x62, 0x13,
0x8E, 0x91, 0x48, 0x62, 0x17, 0x6A, 0xCD, 0x85, 0xDA, 0xB3, 0x62, 0x04,
0x38, 0xD5, 0x7C, 0xB2, 0x1A, 0xB8, 0x86, 0xAD, 0xC6, 0xA6, 0x09, 0xA5,
0x84, 0x6F, 0xE3, 0x9B, 0x31, 0x1B, 0xB0, 0x85, 0x80, 0x0C, 0x56, 0x99,
0x78, 0x26, 0x0E, 0x61, 0x85, 0x9E, 0x63, 0xE9, 0x15, 0xE4, 0x16, 0xE5,
0x13, 0x6D, 0x11, 0x55, 0x5D, 0x44, 0x4F, 0xCD, 0x78, 0x88, 0x33, 0xE0,
0x10, 0xED, 0x57, 0x0D, 0x5E, 0x42, 0xC5, 0x35, 0x39, 0x49, 0x15, 0x4A,
0xF2, 0x92, 0x55, 0x06, 0x52, 0x49, 0x5F, 0x94, 0x92, 0x18, 0x72, 0x16,
0x3E, 0x3C, 0x85, 0x92, 0x53, 0xAA, 0xE2, 0x04, 0x67, 0xC0, 0x3A, 0xBC,
0xD7, 0x8E, 0x97, 0x1A, 0xFB, 0x6A, 0x17, 0x0A, 0x76, 0x85, 0xD0, 0xEC,
0xA1, 0x72, 0x3F, 0x20, 0x5C, 0x10, 0xE9, 0x0B, 0x75, 0x59, 0xE3, 0x92,
0xDC, 0xC1, 0xC9, 0xB7, 0x04, 0x72, 0x72, 0x69, 0x02, 0xC0, 0x10, 0xCC,
0xA6, 0x0A, 0x42, 0x72, 0x12, 0x29, 0x1A, 0x02, 0x94, 0xA5, 0x29, 0x48,
0x4A, 0x13, 0x5A, 0x45, 0x21, 0x91, 0x26, 0xB4, 0x8A, 0xCF, 0x75, 0x69,
0x34, 0xDF, 0x5A, 0x4C, 0xE9, 0x66, 0x59, 0x87, 0x7C, 0xCB, 0x30, 0x66,
0x6A, 0xCC, 0x2C, 0x09, 0x64, 0x2B, 0xE0, 0x22, 0x9A, 0x7C, 0x11, 0x11,
0x2F, 0x24, 0x45, 0x2F, 0xC0, 0x11, 0x1C, 0x76, 0x88, 0x85, 0xA8, 0x11,
0x26, 0x04, 0x22, 0x16, 0x21, 0x22, 0x90, 0xC1, 0x56, 0x00, 0x02, 0x2B,
0xDB, 0x09, 0x15, 0xF5, 0x34, 0x44, 0x2D, 0xB4, 0x44, 0x11, 0x60, 0x08,
0x5C, 0xD9, 0x22, 0x13, 0x35, 0xEE, 0x80, 0x6A, 0xE2, 0xAA, 0x85, 0x8D,
0x4C, 0xD1, 0xCA, 0xB1, 0xA9, 0x8A, 0x3A, 0x92, 0x35, 0x31, 0x4B, 0x7A,
0x46, 0xA5, 0x11, 0xDE, 0x91, 0xA9, 0x6C, 0x74, 0xA4, 0x6A, 0xE9, 0x95,
0xA9, 0x10, 0x9B, 0xE3, 0xA5, 0x62, 0x1D, 0x2C, 0x6D, 0x59, 0x14, 0x12,
0x54, 0xD5, 0x91, 0x5D, 0x53, 0xC9, 0xB2, 0x61, 0x8C, 0xAF, 0x1E, 0x58,
0xCC, 0x08, 0x8C, 0x19, 0x40, 0xB0, 0xE4, 0xA8, 0x57, 0x44, 0x87, 0x0A,
0xCD, 0xC4, 0x8A, 0x52, 0x19, 0xB2, 0x91, 0x4A, 0x42, 0x72, 0x12, 0x29,
0x1A, 0x02, 0x94, 0xA5, 0x29, 0x48, 0x4E, 0x42, 0x45, 0x21, 0x9B, 0x29,
0x14, 0xAD, 0xC4, 0x8A, 0x57, 0x0A, 0xCE, 0x58, 0x0E, 0x4A, 0x85, 0x58,
0x0E, 0x36, 0x1B, 0x89, 0x15, 0x89, 0xA8, 0x64, 0xE4, 0x18, 0xFC, 0x05,
0x7B, 0x44, 0xDA, 0xC4, 0x5A, 0xE2, 0x91, 0x0E, 0x8A, 0x44, 0x49, 0xAA,
0x91, 0xB0, 0x6F, 0xB0, 0x6B, 0xB2, 0x18, 0x35, 0xC3, 0x56, 0x29, 0x4A,
0x42, 0x44, 0x2C, 0x42, 0xF2, 0x18, 0x44, 0xBD, 0xF6, 0x13, 0x3B, 0x55,
0x25, 0xB2, 0x68, 0xA4, 0xC7, 0xE0, 0x30, 0xB6, 0x4C, 0x4D, 0x43, 0x71,
0x22, 0xB8, 0xD8, 0x16, 0x00, 0x38, 0xD8, 0x6E, 0x24, 0xEB, 0x71, 0xCF,
0x41, 0xD3, 0x19, 0xD8, 0xD3, 0x76, 0xD3, 0x2B, 0x00, 0xD2, 0xB8, 0xCF,
0xC1, 0xC6, 0x49, 0xA7, 0x82, 0x94, 0x99, 0x78, 0x2F, 0x61, 0x83, 0x83,
0x1B, 0x0C, 0x7B, 0x89, 0xB0, 0x46, 0xE4, 0x8D, 0xC7, 0x1B, 0x11, 0x34,
0xA6, 0x14, 0xA6, 0x24, 0xA6, 0x74, 0x66, 0x7C, 0xA6, 0x94, 0x72, 0xB0,
0xCA, 0x8E, 0x46, 0x1A, 0xF1, 0xCE, 0x93, 0x8A, 0xF3, 0xAA, 0x13, 0xAD,
0xC6, 0xE2, 0x4E, 0x36, 0x0A, 0x2C, 0x38, 0xD8, 0x2B, 0x71, 0x27, 0x5B,
0x8E, 0xA8, 0x4E, 0x2B, 0xCD, 0x78, 0x8C, 0xAC, 0x03, 0x4A, 0xE3, 0x47,
0x38, 0xCE, 0xC3, 0x62, 0x4B, 0xB2, 0xE0, 0x49, 0x81, 0x97, 0x2B, 0x09,
0xB0, 0xDA, 0xC1, 0xB8, 0x83, 0x70, 0x88, 0x90, 0x60, 0x54, 0x5D, 0x51,
0x9B, 0x51, 0x8B, 0x51, 0xA9, 0x51, 0xB3, 0x51, 0xBB, 0x51, 0xB3, 0x69,
0xA9, 0x84, 0x68, 0xE2, 0x19, 0xD9, 0x66, 0x26, 0x59, 0x85, 0x96, 0x5B,
0x96, 0x37, 0x2C, 0x6E, 0x08, 0xDA, 0xC8, 0xA9, 0x30, 0x1A, 0x61, 0xB6,
0x66, 0x1A, 0x68, 0xA9, 0x86, 0xA2, 0x20, 0x49, 0x95, 0x16, 0x32, 0x4D,
0x04, 0x1C, 0xD2, 0x9C, 0xB0, 0x1B, 0x89, 0x38, 0xD8, 0x28, 0xB0, 0x10,
0xC1, 0x0C, 0xCA, 0x60, 0x84, 0xEC, 0xB0, 0x42, 0x72, 0x12, 0x21, 0xDA,
0x49, 0x10, 0xFC, 0x58, 0x04, 0x43, 0x9A, 0xF1, 0x09, 0x9E, 0x0C, 0x19,
0x44, 0x31, 0xCE, 0xAE, 0xF1, 0x0C, 0x91, 0xC8, 0x69, 0x96, 0xE8, 0xE6,
0x33, 0xA0, 0x83, 0x1C, 0xD3, 0x81, 0x91, 0x4E, 0x93, 0x47, 0x09, 0x29,
0x36, 0x26, 0x91, 0x86, 0x8C, 0x50, 0xB0, 0xCC, 0x98, 0x43, 0x21, 0xB4,
0x43, 0x24, 0xC9, 0x10, 0x94, 0xCC, 0xB7, 0x08, 0x4C, 0xF1, 0x50, 0xE9,
0x18, 0x23, 0x1E, 0xA8, 0x16, 0xC1, 0x13, 0x45, 0x04, 0xE9, 0x10, 0xDC,
0x08, 0x44, 0x5F, 0x73, 0xC4, 0x4B, 0x98, 0xE1, 0x0F, 0xD8, 0x48, 0x88,
0x35, 0x12, 0x21, 0x3B, 0x2C, 0x14, 0x86, 0x0A, 0x2C, 0x38, 0xD8, 0x2B,
0x71, 0x22, 0xB9, 0x60, 0x39, 0xE8, 0x3A, 0x63, 0x36, 0xE9, 0x10, 0xCC,
0x38, 0x84, 0x33, 0x06, 0xB1, 0x0C, 0xC2, 0xC0, 0x10, 0x9B, 0x6D, 0x9D,
0x22, 0x12, 0x8B, 0x56, 0x91, 0x1A, 0xAF, 0x60, 0x8D, 0x19, 0x58, 0x23,
0x30, 0x46, 0x58, 0x8B, 0x84, 0x61, 0x08, 0xB8, 0x42, 0x50, 0xF1, 0x09,
0xB5, 0xE2, 0x19, 0x85, 0x44, 0x2C, 0x10, 0xCB, 0xA8, 0x91, 0x82, 0x19,
0x9A, 0xF4, 0xA4, 0xE4, 0x7E, 0x32, 0x4E, 0xA8, 0x4E, 0x89, 0x0E, 0x15,
0x9B, 0x89, 0x38, 0xD8, 0x28, 0xB0, 0x04, 0x38, 0x44, 0x99, 0x71, 0x88,
0x86, 0xE8, 0xC4, 0x47, 0x97, 0x20, 0x8A, 0x72, 0xD6, 0x21, 0x18, 0x69,
0x11, 0x6E, 0x0A, 0x44, 0x27, 0x19, 0x18, 0x49, 0x10, 0x96, 0x45, 0x5A,
0x44, 0x25, 0x71, 0x4C, 0x91, 0x09, 0x92, 0x26, 0xA4, 0x42, 0x68, 0x8A,
0xF4, 0x88, 0x4C, 0x68, 0x8D, 0x22, 0x13, 0x7C, 0x54, 0x24, 0x42, 0x50,
0x89, 0x12, 0x21, 0x33, 0x44, 0xB4, 0x88, 0x4E, 0x3A, 0x18, 0x91, 0x09,
0xC2, 0xC7, 0x10, 0x9B, 0xA6, 0x10, 0x9C, 0x34, 0x08, 0x5E, 0x6D, 0xE2,
0x17, 0x99, 0x18, 0x85, 0xE8, 0xD0, 0x21, 0x7B, 0x12, 0x08, 0x97, 0x4D,
0x62, 0x2F, 0x2D, 0x94, 0x0B, 0x00, 0x02, 0x0D, 0xC1, 0x4A, 0x52, 0x95,
0x02, 0x79, 0x92, 0x40, 0xCE, 0x76, 0x0A, 0x50, 0x16, 0x00, 0xEE, 0x61,
0xCB, 0x21, 0xD3, 0x51, 0xA1, 0x49, 0xC1, 0x49, 0xA9, 0x49, 0x8B, 0x49,
0x86, 0xD3, 0x0A, 0x92, 0x6A, 0x46, 0xC6, 0x36, 0x41, 0xAC, 0x2C, 0x08,
0x19, 0xCE, 0xC1, 0x4A, 0x81, 0x3C, 0xC9, 0x20, 0xDC, 0x14, 0xA5, 0x29,
0x40, 0x16, 0x00, 0x03, 0x3A, 0x73, 0x39, 0xC6, 0x75, 0x06, 0x64, 0x66,
0x7C, 0x66, 0x94, 0x66, 0x54, 0xA6, 0xB4, 0xA6, 0xDC, 0xA7, 0x54, 0x27,
0x2C, 0x07, 0x54, 0x27, 0x14, 0x26, 0xB4, 0xA6, 0x54, 0xA6, 0x94, 0xA6,
0x7C, 0x66, 0x64, 0x66, 0x75, 0x06, 0x73, 0x8C, 0xE9, 0xC0, 0x2C, 0x81,
0xC2, 0x94, 0xA5, 0x29, 0x4A, 0x52, 0x94, 0xA5, 0x29, 0x4A, 0x52, 0x94,
0xA5, 0x29, 0x4A, 0xB0, 0x0F, 0x09, 0xCE, 0xF6, 0x1D, 0xCB, 0x38, 0xDC,
0x6E, 0x40, 0x75, 0xBC, 0xE5, 0xA0, 0xE8, 0x90, 0xED, 0x71, 0xDA, 0xC0,
0x02, 0xC0, 0x0C, 0x7A, 0x09, 0xA9, 0x22, 0x40, 0x89, 0xA0, 0x78, 0xDA,
0xDC, 0xF1, 0xB5, 0xC2, 0x91, 0xB5, 0xCA, 0xC1, 0xB0, 0x50, 0xE8, 0x52,
0x35, 0x75, 0x26, 0x56, 0x08, 0x4D, 0x49, 0x95, 0x82, 0x13, 0x7B, 0x25,
0x61, 0x13, 0x2F, 0x64, 0x29, 0x26, 0x65, 0x4C, 0x7B, 0x89, 0xB4, 0xC4,
0x68, 0x88, 0xC5, 0x14, 0x8D, 0x31, 0x19, 0x82, 0x32, 0xC4, 0x30, 0x44,
0xE5, 0x80, 0x3C, 0x27, 0x3B, 0xD8, 0x45, 0xB6, 0x29, 0x48, 0xE2, 0x14,
0xA5, 0x35, 0x38, 0x8C, 0x1A, 0x9C, 0x36, 0x0A, 0x6A, 0x70, 0xD2, 0x35,
0x78, 0x89, 0x1A, 0xEC, 0x97, 0x08, 0x7C, 0x4F, 0x11, 0xA2, 0x45, 0xA6,
0x4D, 0x98, 0x5B, 0x9A, 0x63, 0xE2, 0x18, 0x58, 0x06, 0x1D, 0xE0, 0x58,
0x0C, 0x4A, 0x8C, 0x2A, 0xCA, 0xF0, 0x4B, 0x70, 0xC9, 0xB3, 0x48, 0xB3,
0x04, 0x62, 0x88, 0xA2, 0x9A, 0x06, 0xC9, 0x5C, 0x83, 0x5D, 0x92, 0xE1,
0xAE, 0xB9, 0x23, 0x57, 0x88, 0x91, 0x4A, 0x42, 0x6E, 0x58, 0x84, 0xE0,
0xAC, 0x89, 0x96, 0xC2, 0x44, 0x99, 0xA1, 0x0B, 0x00, 0x0B, 0xAF, 0x30,
0x30, 0x0B, 0x71, 0x09, 0xB3, 0x48, 0xB3, 0x04, 0x62, 0x8A, 0x6C, 0x34,
0xC2, 0x36, 0x0C, 0x08, 0x06, 0xAE, 0xE5, 0x8D, 0x4E, 0x1A, 0x45, 0x21,
0x98, 0x69, 0x10, 0x9C, 0x44, 0xD3, 0x39, 0x13, 0x2E, 0x4D, 0x2C, 0x22,
0xDB, 0x11, 0xC4, 0x29, 0x4A, 0x52, 0x90, 0xC1, 0x13, 0x96, 0x00, 0x0B,
0xA9, 0x30, 0x30, 0x0A, 0xF1, 0x09, 0xB3, 0x48, 0xB3, 0x04, 0x62, 0x8A,
0x6D, 0x0F, 0x4C, 0x90, 0x0D, 0x82, 0x54, 0xD0, 0xB1, 0xAE, 0x8D, 0x30,
0xA4, 0x6A, 0xEA, 0x4C, 0x29, 0x1A, 0xBA, 0x92, 0xF7, 0x0D, 0x5D, 0x51,
0x0D, 0x5D, 0x48, 0x10, 0x9A, 0x9A, 0x21, 0x35, 0x52, 0x44, 0x98, 0xEA,
0x26, 0x64, 0x74, 0x05, 0x80, 0x35, 0x98, 0x22, 0x7C, 0x36, 0x08, 0x66,
0x22, 0x44, 0x70, 0x08, 0xD6, 0x11, 0xA0, 0x23, 0x6C, 0x47, 0x10, 0xA4,
0x72, 0x08, 0x66, 0x22, 0x63, 0x80, 0x43, 0x31, 0x13, 0x4A, 0x44, 0x4F,
0x86, 0x9A, 0x52, 0x2B, 0x85, 0xE7, 0x0C, 0x85, 0x80, 0x16, 0xE1, 0x94,
0x40, 0x98, 0xE8, 0x27, 0x95, 0x32, 0x49, 0x49, 0x3C, 0x73, 0xC2, 0x99,
0x8C, 0x6B, 0xA7, 0xAC, 0xC6, 0x5B, 0xB5, 0x0D, 0xE5, 0xBE, 0x16, 0x64,
0x9B, 0xCB, 0xA1, 0xEB, 0xC2, 0x37, 0x93, 0x0B, 0xD7, 0x04, 0xB0, 0x1B,
0xC9, 0x85, 0xEB, 0x5D, 0x2B, 0x37, 0x93, 0x0B, 0xD6, 0x94, 0x24, 0x56,
0xF2, 0x61, 0x7A, 0xD7, 0x4A, 0xCD, 0xE5, 0xD0, 0xF5, 0xC1, 0x2C, 0x06,
0x32, 0x68, 0x7B, 0xB0, 0x8C, 0x65, 0xBD, 0xEE, 0xC0, 0x27, 0x73, 0xA8,
0x83, 0x1C, 0x9E, 0xD9, 0x30, 0x06, 0x4C, 0xFC, 0x01, 0x28, 0x97, 0x1C,
0x75, 0xF4, 0xD0, 0xE5, 0x8F, 0x7E, 0x8B, 0x02, 0xC0, 0x11, 0x3E, 0xBC,
0xE2, 0x19, 0xBA, 0xC1, 0x1C, 0x42, 0x94, 0xA5, 0x29, 0x48, 0x65, 0xD3,
0x88, 0x9F, 0x0E, 0x73, 0x59, 0x86, 0xB2, 0x44, 0x4F, 0x88, 0xB1, 0x0C,
0xC9, 0x90, 0x46, 0x88, 0xA5, 0x23, 0x14, 0x52, 0x33, 0x04, 0x65, 0x88,
0x60, 0x89, 0xC2, 0xC0, 0x11, 0x3E, 0x6C, 0xE2, 0x19, 0x86, 0xC1, 0x18,
0xB4, 0x38, 0x46, 0x2C, 0x94, 0x08, 0xC5, 0x82, 0x51, 0x4A, 0x46, 0x2C,
0x94, 0x08, 0xC5, 0xA1, 0xC2, 0x18, 0x22, 0x70, 0xB0, 0x9E, 0x43, 0x19,
0xE6, 0x32, 0xF6, 0x58, 0x63, 0x27, 0x29, 0x86, 0x32, 0xF6, 0x58, 0x63,
0x49, 0xA8, 0x93, 0x1B, 0xB2, 0x87, 0x13, 0xE8, 0x49, 0x40, 0xCD, 0x78,
0x25, 0x14, 0xBD, 0xD8, 0x25, 0x20, 0xE0, 0x92, 0x82, 0x8C, 0x8A, 0x1C,
0x01, 0x60, 0x11, 0x3E, 0xBC, 0xE2, 0x19, 0xBA, 0xC1, 0x1C, 0x42, 0x94,
0xA5, 0x29, 0x48, 0x64, 0x29, 0x11, 0x3C, 0x6B, 0x33, 0x16, 0x66, 0xBC,
0xC3, 0x8C, 0xC1, 0x69, 0x85, 0x68, 0x86, 0x63, 0x45, 0x8C, 0xE4, 0xCE,
0x22, 0xD5, 0xAE, 0x76, 0x08, 0x43, 0xDE, 0x22, 0xFA, 0xA0, 0x11, 0x1A,
0x16, 0x22, 0x8A, 0xD2, 0x22, 0x0C, 0x96, 0x08, 0x4E, 0x1C, 0xE2, 0x18,
0x22, 0x72, 0xC0, 0x11, 0x3E, 0xBC, 0xE2, 0x19, 0xBA, 0xC1, 0x1C, 0x42,
0x94, 0xA5, 0x29, 0x48, 0x60, 0x89, 0xC2, 0xC0, 0x11, 0x3E, 0x6C, 0xE2,
0x19, 0x86, 0xC1, 0x18, 0xA2, 0x94, 0xA5, 0x29, 0x48, 0x65, 0xD3, 0x88,
0x9F, 0x11, 0x86, 0xB3, 0x0D, 0x64, 0x88, 0x9F, 0x11, 0x62, 0x19, 0x93,
0x20, 0x8D, 0x11, 0x4A, 0x46, 0x28, 0xA4, 0x66, 0x08, 0xCD, 0x10, 0xCB,
0xA7, 0x11, 0x3E, 0x1C, 0xE6, 0xB3, 0x0D, 0x64, 0x88, 0x9F, 0x11, 0x62,
0x19, 0x93, 0x20, 0x8D, 0x11, 0x4A, 0x46, 0x28, 0xA4, 0x66, 0x08, 0xCD,
0x10, 0xC1, 0x13, 0x85, 0x80, 0x11, 0x3E, 0x6C, 0xE2, 0x19, 0x86, 0xC1,
0x18, 0xA2, 0x94, 0xA5, 0x29, 0x48, 0x65, 0xD3, 0x88, 0x9F, 0x0E, 0x73,
0x59, 0x86, 0xB2, 0x44, 0x4F, 0x88, 0xB1, 0x0C, 0xC9, 0x90, 0x46, 0x88,
0xA5, 0x23, 0x14, 0x52, 0x33, 0x04, 0x65, 0x88, 0x60, 0x89, 0xC2, 0xC0,
0x0B, 0xA9, 0x30, 0x30, 0x0A, 0xEE, 0x26, 0xCD, 0x22, 0xCC, 0x11, 0x8A,
0x29, 0xB2, 0x57, 0x20, 0xD5, 0xDC, 0xB1, 0xA9, 0xC3, 0x48, 0xA6, 0xAE,
0xE5, 0x8D, 0x7D, 0xB2, 0x08, 0xC5, 0x15, 0x16, 0x61, 0x36, 0x69, 0x5D,
0xC6, 0x06, 0x01, 0x75, 0xE0, 0x58, 0x31, 0xA7, 0xDD, 0x9C, 0xC6, 0x67,
0x03, 0x0C, 0x6E, 0xC1, 0x4A, 0x52, 0x94, 0xAC, 0x66, 0x54, 0x9B, 0x98,
0x63, 0x32, 0x34, 0xE1, 0xB0, 0xC6, 0x9E, 0xA4, 0xE1, 0xB0, 0x6A, 0x70,
0xD2, 0x29, 0xAE, 0xC9, 0x70, 0xDA, 0x11, 0x40, 0x8D, 0x11, 0x18, 0xA4,
0x5A, 0x64, 0xD9, 0xC5, 0x78, 0x86, 0x06, 0x11, 0x89, 0x48, 0x16, 0x00,
0x0B, 0xAF, 0x30, 0x30, 0x0B, 0x71, 0x09, 0xB3, 0x48, 0xB3, 0x04, 0x62,
0x8A, 0x6D, 0x0D, 0x84, 0x6B, 0xB0, 0xA0, 0x1A, 0xBB, 0x96, 0x35, 0x38,
0x69, 0x15, 0x8D, 0x3D, 0xEC, 0xC3, 0x49, 0x8C, 0xCA, 0x99, 0x86, 0x93,
0x19, 0x97, 0xB2, 0xE5, 0x98, 0xDD, 0x82, 0x95, 0x8D, 0xB6, 0x63, 0x71,
0x0A, 0x56, 0x33, 0x0C, 0x69, 0xCB, 0x00, 0x11, 0x3E, 0x6C, 0xE2, 0x19,
0x86, 0xC1, 0x48, 0xC5, 0x14, 0xA5, 0x29, 0x4A, 0x43, 0x31, 0xD2, 0x21,
0x98, 0x09, 0x11, 0x3E, 0x4A, 0xCC, 0xA7, 0x1C, 0x0E, 0x38, 0x20, 0x38,
0x24, 0x37, 0xE5, 0x34, 0xA3, 0x0B, 0x00, 0x22, 0xA2, 0x8A, 0x04, 0x43,
0x05, 0xE2, 0x17, 0x2A, 0x04, 0x26, 0x59, 0x86, 0xA6, 0x5B, 0x46, 0xB2,
0x58, 0xD6, 0xB1, 0xAC, 0x96, 0x17, 0xB0, 0x6B, 0x21, 0x86, 0x86, 0x0A,
0x6A, 0x5F, 0x0C, 0x2C, 0x10, 0xB5, 0xC7, 0x42, 0x44, 0x57, 0x42, 0xC8,
0xA6, 0x73, 0xC9, 0x91, 0x03, 0xCB, 0x69, 0x30, 0x28, 0x0B, 0x00, 0x35,
0x98, 0x2B, 0x59, 0x25, 0x79, 0xA4, 0xDA, 0x22, 0x34, 0x84, 0x64, 0x0D,
0xD9, 0x14, 0xA6, 0xBB, 0x05, 0x23, 0x57, 0x72, 0x44, 0x26, 0xE4, 0x8A,
0x89, 0x97, 0x24, 0xB0, 0x34, 0x27, 0x35, 0xD8, 0x57, 0x9A, 0x4D, 0x98,
0x23, 0x14, 0x53, 0x74, 0x45, 0x29, 0xB0, 0x08, 0x58, 0x84, 0x91, 0x30,
0x9A, 0x7C, 0x39, 0xCB, 0x67, 0xB9, 0x82, 0x31, 0x45, 0x29, 0x4A, 0x52,
0x90, 0xC1, 0x13, 0x85, 0x80, 0xD7, 0x61, 0xBA, 0xB3, 0x2A, 0x43, 0x4A,
0x53, 0x3E, 0x93, 0x4E, 0x23, 0x2F, 0x1C, 0xC1, 0xC1, 0x30, 0x30, 0x18,
0xC2, 0x6C, 0x09, 0x27, 0x1B, 0x80, 0x36, 0x61, 0xB4, 0x93, 0x50, 0x60,
0x42, 0x5D, 0x09, 0x9B, 0x2C, 0x0C, 0x31, 0x65, 0x63, 0x0D, 0x48, 0xCD,
0x97, 0x9B, 0xAB, 0x35, 0xD8, 0x68, 0x4E, 0x58, 0xD0, 0x9C, 0xD7, 0x61,
0xBA, 0xB3, 0x22, 0x83, 0x62, 0xF3, 0x32, 0x63, 0x0F, 0x00, 0xC2, 0xC4,
0x26, 0xC4, 0x9D, 0x83, 0x70, 0x60, 0x60, 0xDA, 0xE3, 0x9C, 0x6A, 0x0B,
0x5E, 0x61, 0x3C, 0xC4, 0x79, 0x9C, 0xF3, 0x45, 0xE6, 0x73, 0x4C, 0x4B,
0x4C, 0x2C, 0x22, 0xDC, 0x21, 0xB8, 0x43, 0x6D, 0x1A, 0xD2, 0xB9, 0x0C,
0x97, 0x99, 0x72, 0x47, 0x39, 0xA6, 0xF8, 0x18, 0x6A, 0xBE, 0x76, 0x19,
0x14, 0x1B, 0xAB, 0x35, 0xD8, 0x68, 0x4E, 0x58, 0x44, 0xE2, 0x19, 0x97,
0x38, 0x84, 0xE2, 0x30, 0x43, 0xB2, 0x52, 0x22, 0x0A, 0xE0, 0x10, 0xC9,
0xD2, 0x87, 0x98, 0x49, 0xAA, 0x13, 0x05, 0x2F, 0xA8, 0xC4, 0x4A, 0xE9,
0x30, 0xD3, 0x3A, 0x0C, 0xDA, 0x58, 0xC3, 0x2E, 0xF7, 0x4E, 0x5D, 0x48,
0x89, 0xDD, 0x48, 0x86, 0x32, 0x21, 0x08, 0x5A, 0x44, 0x52, 0xF4, 0x88,
0xAA, 0x34, 0xCE, 0xC1, 0x10, 0xA2, 0x01, 0x0F, 0xB5, 0xC2, 0x20, 0xC2,
0x48, 0x84, 0xE2, 0x30, 0x43, 0x32, 0xE7, 0x11, 0x39, 0x60, 0xD0, 0x9C,
0xC6, 0x7E, 0xA3, 0x0D, 0xE7, 0xEA, 0xAC, 0xDE, 0x5E, 0xAB, 0xCD, 0xE4,
0xE8, 0xC6, 0x6F, 0x27, 0x39, 0xA6, 0xF2, 0xEE, 0xB4, 0xC6, 0x5E, 0x3E,
0x11, 0x3C, 0x14, 0xE1, 0x63, 0x30, 0x4B, 0xE4, 0xC2, 0x5B, 0x08, 0x33,
0x21, 0x9C, 0xA3, 0x04, 0xBD, 0x04, 0x50, 0x98, 0xF2, 0x98, 0x32, 0x99,
0xB2, 0xC0, 0xC3, 0x16, 0x39, 0xD8, 0x6A, 0xD4, 0x6C, 0xBC, 0xDD, 0x59,
0xAE, 0xC3, 0x42, 0x72, 0xC0, 0x10, 0xC1, 0x0E, 0x8A, 0x11, 0x0F, 0xA6,
0x11, 0x10, 0xC4, 0xE1, 0x15, 0x21, 0x22, 0x1B, 0x4B, 0x04, 0x4D, 0x1B,
0x04, 0x32, 0x76, 0xC2, 0xC1, 0x0C, 0x5B, 0x64, 0x60, 0x86, 0x48, 0xD5,
0xB0, 0x43, 0x28, 0x44, 0xEC, 0x10, 0xC8, 0xE6, 0x10, 0xCA, 0x5A, 0x21,
0x28, 0xA8, 0x42, 0x6D, 0x84, 0x42, 0xEB, 0x78, 0x87, 0xDA, 0xE1, 0x15,
0x44, 0xC2, 0x69, 0x42, 0xC0, 0x36, 0x18, 0x2B, 0x3D, 0x66, 0x8C, 0x06,
0x9C, 0x24, 0x7B, 0x64, 0x38, 0x98, 0xD8, 0x83, 0xF2, 0xF1, 0xB0, 0xC9,
0x32, 0xD9, 0x86, 0x49, 0x89, 0x06, 0x21, 0x05, 0xD0, 0xE0, 0x90, 0x2F,
0x91, 0x64, 0x0C, 0xE7, 0x60, 0xA5, 0x01, 0x60, 0x03, 0x7B, 0xC4, 0x52,
0x80, 0xB0, 0x08, 0x19, 0xCE, 0xC1, 0x4A, 0x81, 0x7C, 0x8B, 0x20, 0xBA,
0x1C, 0x12, 0x4C, 0x47, 0x61, 0x92, 0x65, 0xB3, 0x0C, 0x7E, 0x5E, 0x36,
0x19, 0x0E, 0x26, 0x36, 0x21, 0x1E, 0xD9, 0xA7, 0x09, 0xA3, 0x01, 0x9E,
0xB3, 0x61, 0x82, 0x82, 0xC0, 0xC5, 0x71, 0x8B, 0x41, 0x8B, 0x19, 0xA8,
0xF3, 0x22, 0x03, 0x65, 0xC2, 0x95, 0x90, 0xE3, 0x4A, 0x43, 0x52, 0x43,
0x56, 0x43, 0x3E, 0x43, 0x46, 0x43, 0x46, 0x03, 0x16, 0x03, 0x15, 0xC2,
0xB4, 0x5C, 0x68, 0xD0, 0x6C, 0x4A, 0x6A, 0x50, 0x65, 0x2C, 0x2C, 0xDE};
unsigned char flut[] = {
254, 18, 4, 253, 5, 3, 17, 6, 9, 7, 11, 19, 13, 8,
12, 20, 2, 10, 16, 14, 22, 255, 21, 28, 15, 24, 27, 25,
30, 29, 36, 1, 23, 44, 26, 46, 31, 34, 32, 33, 38, 52,
37, 42, 35, 41, 40, 50, 51, 39, 45, 48, 54, 66, 49, 0,
43, 47, 65, 55, 67, 56, 63, 58, 60, 62, 57, 59, 64, 53,
61, 68, 70, 71, 73};
unsigned int foffs[] = {
0, 5, 27, 55, 131, 204, 318, 431, 444, 478,
512, 571, 592, 613, 624, 636, 661, 709, 742, 817,
883, 930, 993, 1060, 1118, 1182, 1250, 1271, 1305, 1373,
1392, 1460, 1511, 1675, 1763, 1829, 1900, 1960, 2008, 2051,
2136, 2188, 2211, 2248, 2341, 2378, 2462, 2529, 2607, 2661,
2758, 2830, 2910, 2952, 3017, 3090, 3191, 3297, 3378, 3474,
3490, 3515, 3531, 3575, 3592, 3614, 3674, 3720, 3765, 3815,
3869, 3909, 4005, 4048, 4077, 4118, 4179, 4196, 4265, 4308,
4350, 4404, 4459, 4495, 4547, 4576, 4613, 4664, 4736, 4810,
4877, 4937, 4976, 4982, 5021};
#define FONT_MAXWIDTH 74
#define FONT_DOUBLED 0
#define OPCODE_REPEAT 253
#define OPCODE_EOL 254
#define OPCODE_EOC 255

88
main.cpp Normal file
View file

@ -0,0 +1,88 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sndfile.h>
#include <math.h>
#include <vector>
#include "banner.h"
#include "fft.h"
using namespace std;
static constexpr int ORDER = 8;
static constexpr int TAPS = (1 << ORDER);
static constexpr int HALF = TAPS >> 1;
static constexpr int OFS = 20;
static CFFT fft (ORDER);
static vector<double> mono;
void cputs (const char * s) {
const complex one (0.0, 256.0), zero (0.0, 0.0);
complex data [TAPS];
memset (&data,0, TAPS * sizeof(complex));
int n = 0;
while (true) {
const char c = s [n];
if (c == '\0') break;
const complex fill = c == '#' ? one : zero;
const int k = n + OFS;
data[k] = fill;
data[TAPS - k] = fill;
putchar(c);
n += 1;
}
//printf("\tlen=%d\n", n);
fft.Inverse(data, false);
for (int i=0; i<TAPS; i++) {
mono.push_back (data[i].im());
}
}
static bool WriteSound (const char * filename = "output.vaw") {
printf("len=%zd\n", mono.size());
double min = 1.0e100, max = -1.0e100;
for (double e: mono) {
if (e < min) min = e;
if (e > max) max = e;
}
printf("min=%g, max=%g\n", min, max);
double z = abs(min) > abs(max) ? abs(min) : abs(max);
z = 32000.0 / z;
vector<short> data (mono.size());
int n = 0;
for (double e: mono) {
data[n] = ::lround (e * z);
n += 1;
}
SF_INFO info;
memset (&info, 0, sizeof(SF_INFO));
info.channels = 1;
info.format = SF_FORMAT_WAV | SF_FORMAT_PCM_16;
info.samplerate = 8000;
if (sf_format_check (&info) == SF_FALSE) {
fprintf(stderr, "bad output format\n");
return false;
}
SNDFILE * outfile = sf_open (filename, SFM_WRITE, &info);
if (!outfile) {
fprintf(stderr, "cannot open output file \"%s\"\n", filename);
return false;
}
sf_write_short (outfile, data.data(), data.size());
sf_close (outfile);
return true;
}
int main (int argc, char *argv[]) {
if (argc < 2) {
printf("Usage:\n\t%s \"Text to spectrogram\"\n", argv[0]);
return 0;
}
const char * buffer = argv[1];
for (const char * p = buffer; *p; p++) {
banchr (*p);
}
WriteSound ();
return 0;
}

381
mkfont.c Normal file
View file

@ -0,0 +1,381 @@
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_GLYPH_H
#include FT_TRUETYPE_DRIVER_H
#include FT_MODULE_H
#include <getopt.h>
#define OPCODE_REPEAT 253
#define OPCODE_EOL 254
#define OPCODE_EOC 255
#define MAX_RLE 80 /* Maximum number of repeats */
/****************************************************************************
* BYTEPOINTER FUNCTIONS
****************************************************************************/
struct histogram {
int position;
int count;
};
struct bytepointer {
unsigned char *p;
unsigned char *start;
unsigned char *end;
struct histogram histogram[256];
};
struct bitoutput {
FILE *fp;
int col;
int byte_count;
uint8_t byte;
uint8_t bit;
};
void init_bytepointer (struct bytepointer *bp, unsigned char *buffer, int n) {
int i;
bp->p = buffer;
bp->start = buffer;
bp->end = buffer + n;
for (i=0; i<256; i++) {
bp->histogram[i].position = i;
bp->histogram[i].count = 0;
}
}
void save_byte (struct bytepointer *bp, unsigned char byte) {
if (bp->p == bp->end) {
printf ("OUT OF BITPOINTER MEMORY.\n");
exit (2);
}
// If byte is more than MAX_RLE, break into MAX_RLE, 0, remainder
while (byte < OPCODE_REPEAT && byte > MAX_RLE) {
* (bp->p++) = MAX_RLE;
* (bp->p++) = 0;
byte -= MAX_RLE;
}
* (bp->p++) = byte;
bp->histogram[byte].count++;
}
int histcmp (const void *p, const void *q) {
struct histogram *p0 = (struct histogram *) p;
struct histogram *q0 = (struct histogram *) q;
return q0->count - p0->count;
}
void save_bits (struct bitoutput *bits, int bit) {
if (bit) bits->byte |= bits->bit;
bits->bit >>= 1;
if (!bits->bit) {
if (bits->col == 12) { fprintf (bits->fp, ",\n\t"); bits->col = 0; }
else if (bits->col != 0) fprintf (bits->fp, ", ");
fprintf (bits->fp, "0x%02X", bits->byte);
bits->col++;
bits->byte_count++;
bits->bit = 0x80;
bits->byte = 0;
}
}
void output_bitstream (struct bytepointer *bp, int max_width, int scaled) {
unsigned char *p;
struct bitoutput bits;
int col, i, v, lookup[256], offset, offsets[96];
qsort (bp->histogram, 256, sizeof (struct histogram), histcmp);
for (i=0; i<256; i++) {
lookup[bp->histogram[i].position] = i;
}
bits.fp = fopen ("font.h", "w");
bits.byte = 0;
bits.bit = 0x80;
bits.col = 0;
bits.byte_count = 0;
offset = 0;
offsets[0] = 0;
fprintf (bits.fp,
"/********************************************************************\n"
"* Font File format:\n"
"* 2 bits: =0, opcode lut index 0\n"
"* =1, opcode lut index is in next 3 bits + 1\n"
"* =2, opcode lut index is in next 4 bits + 9\n"
"* =3, opcode lut index is in next 6 bits + 25\n"
"********************************************************************/\n");
fprintf (bits.fp, "unsigned char mfont[] = {\n\t");
for (p = bp->start; p <= bp->p; p++) {
v = lookup[*p];
if (v == 0) {
save_bits (&bits, 0);
save_bits (&bits, 0);
} else if (v < 9) {
v = v-1;
save_bits (&bits, 0);
save_bits (&bits, 1);
save_bits (&bits, v & 4);
save_bits (&bits, v & 2);
save_bits (&bits, v & 1);
} else if (v < 25) {
v = v-9;
save_bits (&bits, 1);
save_bits (&bits, 0);
save_bits (&bits, v & 8);
save_bits (&bits, v & 4);
save_bits (&bits, v & 2);
save_bits (&bits, v & 1);
} else {
v = v-25;
save_bits (&bits, 1);
save_bits (&bits, 1);
save_bits (&bits, v & 32);
save_bits (&bits, v & 16);
save_bits (&bits, v & 8);
save_bits (&bits, v & 4);
save_bits (&bits, v & 2);
save_bits (&bits, v & 1);
}
if (*p == OPCODE_EOC) {
while (bits.bit != 0x80) save_bits (&bits, 0);
offsets[++offset] = bits.byte_count;
}
}
fprintf (bits.fp, "};\n");
fprintf (bits.fp, "unsigned char flut[] = {\n\t");
for (i=0, col=0; bp->histogram[i].count; i++) {
if (col == 14) { fprintf (bits.fp, ",\n\t"); col = 0; }
else if (col != 0) fprintf (bits.fp, ", ");
fprintf (bits.fp, "%3d", bp->histogram[i].position);
col++;
bits.byte_count++;
}
fprintf (bits.fp, "};\n");
fprintf (bits.fp, "unsigned int foffs[] = {\n\t");
for (i=0, col=0; i<offset; i++) {
if (col == 10) { fprintf (bits.fp, ",\n\t"); col = 0; }
else if (col != 0) fprintf (bits.fp, ", ");
fprintf (bits.fp, "%5d", offsets[i]);
bits.byte_count += 2;
col++;
}
fprintf (bits.fp, "};\n\n");
if (scaled) max_width += max_width;
fprintf (bits.fp, "#define FONT_MAXWIDTH %d\n", max_width);
fprintf (bits.fp, "#define FONT_DOUBLED %d\n\n", scaled);
fprintf (bits.fp, "#define OPCODE_REPEAT %d\n", OPCODE_REPEAT);
fprintf (bits.fp, "#define OPCODE_EOL %d\n", OPCODE_EOL);
fprintf (bits.fp, "#define OPCODE_EOC %d\n", OPCODE_EOC);
printf ("%d bytes.\n", bits.byte_count);
}
int main (int argc, char *argv[]) {
int error;
FT_Library library;
FT_Face face;
FT_GlyphSlot slot;
FT_Glyph glyph;
FT_Bitmap *bitmap;
int advance, byte, c, x, y, y0, v, offset;
uint8_t bit;
int max_decender = 0;
int max_width = 0;
struct bytepointer bp;
unsigned char buffer[48*1024];
int color, scaled, verbose;
char *font = NULL;
int ch, width, height;
struct option longopts[] = {
{ "font", required_argument, NULL, 'f' },
{ "width", required_argument, NULL, 'w' },
{ "double", no_argument, &scaled, 1 },
{ "verbose", no_argument, &verbose, 1 },
{ NULL, 0, NULL, 0}
};
width = 80;
while ( (ch = getopt_long (argc, argv, "f:h:", longopts, NULL)) != -1) {
switch (ch) {
case 'f':
font = optarg;
break;
case 'w':
width = atoi (optarg);
break;
case 0:
break;
default:
fprintf (stderr, "mkfont: --font FONTNAME [--width HEIGHT]\n");
exit (2);
}
}
if (!font) {
fprintf (stderr, "No font specified. Use --font option\n");
exit (2);
}
/* Adjust width to account for 0 base */
if (scaled) width /= 2;
width--;
height = width * 6 / 10;
init_bytepointer (&bp, buffer, sizeof (buffer));
if ( (error = FT_Init_FreeType (&library))) {
fprintf (stderr, "Error initializing FreeType");
exit (2);
}
FT_UInt version = TT_INTERPRETER_VERSION_35;
FT_Property_Set (library, "truetype", "interpreter-version",
&version);
if ( (error = FT_New_Face (library, font, 0, &face))) {
fprintf (stderr, "Error loading Face");
exit (2);
}
// Height, width reversed below because characters are rotated
if ( (error = FT_Set_Pixel_Sizes (face, height, width))) {
fprintf (stderr, "Error setting pixel size");
exit (2);
}
/* Find maximum decender and width */
for (c=32; c < 127; c++) {
if ( (error = FT_Load_Char (face, c, FT_LOAD_TARGET_MONO))) {
fprintf (stderr, "Error loading char");
exit (2);
}
slot = face->glyph;
if ( (error = FT_Render_Glyph (slot, FT_RENDER_MODE_MONO))) {
fprintf (stderr, "Error loading char");
exit (2);
}
if ( (error = FT_Get_Glyph (slot, &glyph))) {
fprintf (stderr, "Error loading char");
exit (2);
}
bitmap = &slot->bitmap;
if ( (int) (slot->bitmap_top - bitmap->rows) < max_decender) {
max_decender = slot->bitmap_top - bitmap->rows;
}
if (bitmap->rows > max_width)
max_width = bitmap->rows;
}
max_width++;
/* Generate glyphs and encode */
for (c=32; c < 127; c++) {
if ( (error = FT_Load_Char (face, c, FT_LOAD_TARGET_MONO))) {
fprintf (stderr, "Error loading char");
exit (2);
}
slot = face->glyph;
if ( (error = FT_Render_Glyph (slot, FT_RENDER_MODE_MONO))) {
fprintf (stderr, "Error loading char");
exit (2);
}
if ( (error = FT_Get_Glyph (slot, &glyph))) {
fprintf (stderr, "Error loading char");
exit (2);
}
bitmap = &slot->bitmap;
advance = slot->bitmap_left;
if (advance < 0) advance = 0;
color = 0;
for (; advance > 0; advance--) {
save_byte (&bp, OPCODE_EOL);
if (verbose) printf ("\n");
}
for (x=0; x < bitmap->width; x++) {
int repeat = 0;
// Check for repeating line
if (x > 0) {
int v0;
for (y = bitmap->rows-1; y >= 0; y--) {
byte = (x-1) /8;
bit = 0x80 >> ( (x-1) &7);
v0 = (bitmap->buffer[y*bitmap->pitch + byte]&bit) ? 1: 0;
byte = x/8;
bit = 0x80 >> (x&7);
v = (bitmap->buffer[y*bitmap->pitch + byte]&bit) ? 1: 0;
if (v0 != v)
break;
}
if (y < 0) repeat = 1;
}
// Find end of spaces
for (y0=0; y0<bitmap->rows; y0++) {
byte = x/8;
bit = 0x80 >> (x&7);
v = (bitmap->buffer[y0*bitmap->pitch + byte]&bit) ? 1: 0;
if (v) break;
}
offset = -max_decender+ (slot->bitmap_top - bitmap->rows);
if (y0 == bitmap->rows) offset = 0;
if (verbose) {
for (y=0; y<offset; y++) {
printf (" ");
}
}
for (y=bitmap->rows-1; y>=y0; y--) {
byte = x/8;
bit = 0x80 >> (x&7);
v = (bitmap->buffer[y*bitmap->pitch + byte]&bit) ? 1: 0;
if (verbose) {
if (v)
printf (repeat ? "*" : "#");
else
printf (" ");
}
if (v==color) offset++;
else {
if (!repeat) save_byte (&bp, offset);
color ^= 1;
offset = 1;
}
}
if (repeat) {
save_byte (&bp, OPCODE_REPEAT);
} else {
save_byte (&bp, offset);
save_byte (&bp, OPCODE_EOL);
}
color = 0;
if (verbose) printf ("\n");
}
advance = (slot->advance.x >> 6) - bitmap->width -
( (slot->bitmap_left > 0) ? slot->bitmap_left : 0);
if (advance < 0) advance = 0;
for (; advance > 0; advance--) {
save_byte (&bp, OPCODE_EOL);
if (verbose) printf ("\n");
}
save_byte (&bp, OPCODE_EOC);
FT_Done_Glyph (glyph);
}
output_bitstream (&bp, max_width, scaled);
}

BIN
output.vaw Normal file
View file

Binary file not shown.

BIN
screen.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 205 KiB