From c0850943942d56130a68f118e50c50c951f44de3 Mon Sep 17 00:00:00 2001 From: Michal Moskal Date: Mon, 30 Oct 2017 12:45:37 +0000 Subject: [PATCH 01/13] Add screen::unpackPNG() --- libs/core/Makefile | 2 +- libs/core/_locales/core-jsdoc-strings.json | 1 + libs/core/png.cpp | 130 +++++++++++++++++++++ libs/core/pxt.json | 1 + libs/core/shims.d.ts | 6 + pxtarget.json | 2 +- 6 files changed, 140 insertions(+), 2 deletions(-) create mode 100644 libs/core/png.cpp diff --git a/libs/core/Makefile b/libs/core/Makefile index 34b2e643..c871a84a 100644 --- a/libs/core/Makefile +++ b/libs/core/Makefile @@ -20,7 +20,7 @@ DEPS = $(PXT_HEADERS) package.json Makefile Makefile.inc all: $(EXE) $(EXE): $(PXT_OBJS) - $(LD) -o $(EXE) $(LDFLAGS) -Wl,-Map,$(EXE:.elf=.map) $(PXT_OBJS) $(LIBSTDCPP) -lm -lpthread $(NPM_LIBS) + $(LD) -o $(EXE) $(LDFLAGS) -Wl,-Map,$(EXE:.elf=.map) $(PXT_OBJS) $(LIBSTDCPP) -lm -lpthread -lz $(NPM_LIBS) cp $(EXE) $(EXE:.elf=.full) $(PREF)strip $(EXE) node -p 'require("fs").readFileSync("$(EXE)").toString("hex")' > $(HEX) diff --git a/libs/core/_locales/core-jsdoc-strings.json b/libs/core/_locales/core-jsdoc-strings.json index c7c1731e..e3412e25 100644 --- a/libs/core/_locales/core-jsdoc-strings.json +++ b/libs/core/_locales/core-jsdoc-strings.json @@ -85,6 +85,7 @@ "screen.setPixel|param|on": "a value indicating if the pixel should be on or off", "screen.setPixel|param|x": "the starting position's x coordinate, eg: 0", "screen.setPixel|param|y": "the starting position's x coordinate, eg: 0", + "screen.unpackPNG": "Decompresses a 1-bit gray scale PNG image to icon format.", "serial": "Reading and writing data over a serial connection.", "serial.writeDmesg": "Send DMESG debug buffer over serial." } \ No newline at end of file diff --git a/libs/core/png.cpp b/libs/core/png.cpp new file mode 100644 index 00000000..6d78b771 --- /dev/null +++ b/libs/core/png.cpp @@ -0,0 +1,130 @@ +#include "pxt.h" +#include "ev3const.h" +#include +#include + +struct PNGHeader { + uint8_t pngHeader[8]; + uint32_t lenIHDR; + uint8_t IHDR[4]; + uint32_t width; + uint32_t height; + uint8_t bitDepth; + uint8_t colorType; + uint8_t compressionMethod; + uint8_t filterMethod; + uint8_t interlaceMethod; + uint32_t hdCRC; + uint32_t lenIDAT; + uint8_t IDAT[4]; +} __attribute__((packed)); + +namespace screen { + +static uint32_t swap(uint32_t num) { + return ((num >> 24) & 0xff) | ((num << 8) & 0xff0000) | ((num >> 8) & 0xff00) | + ((num << 24) & 0xff000000); +} + +static uint8_t revbits(uint8_t v) { + v = (v & 0xf0) >> 4 | (v & 0x0f) << 4; + v = (v & 0xcc) >> 2 | (v & 0x33) << 2; + v = (v & 0xaa) >> 1 | (v & 0x55) << 1; + return v; +} + +/** Decompresses a 1-bit gray scale PNG image to icon format. */ +//% +Buffer unpackPNG(Buffer png) { + if (!png) { + DMESG("PNG: Missing image"); + return NULL; + } + if (png->length < sizeof(PNGHeader) + 4) { + DMESG("PNG: File too small"); + return NULL; + } + + if (memcmp(png->data, "\x89PNG\r\n\x1A\n", 8) != 0) { + DMESG("PNG: Invalid header"); + return NULL; + } + + struct PNGHeader hd; + memcpy(&hd, png->data, sizeof(hd)); + + if (memcmp(hd.IHDR, "IHDR", 4) != 0) { + DMESG("PNG: missing IHDR"); + return NULL; + } + + hd.lenIHDR = swap(hd.lenIHDR); + hd.width = swap(hd.width); + hd.height = swap(hd.height); + hd.lenIDAT = swap(hd.lenIDAT); + + if (hd.lenIHDR != 13) { + DMESG("PNG: bad IHDR len"); + return NULL; + } + if (hd.bitDepth != 1 || hd.colorType != 0 || hd.compressionMethod != 0 || + hd.filterMethod != 0 || hd.interlaceMethod != 0) { + DMESG("PNG: not 1-bit grayscale"); + return NULL; + } + if (memcmp(hd.IDAT, "IDAT", 4) != 0) { + DMESG("PNG: missing IDAT"); + return NULL; + } + if (hd.lenIDAT + sizeof(hd) >= png->length) { + DMESG("PNG: buffer too short"); + return NULL; + } + if (hd.width > 300 || hd.height > 300) { + DMESG("PNG: too big"); + return NULL; + } + + uint32_t byteW = (hd.width + 7) >> 3; + uint32_t expSize = (byteW + 1) * hd.height; + unsigned long sz = expSize; + uint8_t *tmp = (uint8_t *)malloc(sz); + int code = uncompress(tmp, &sz, png->data + sizeof(hd), hd.lenIDAT); + if (code != 0) { + DMESG("PNG: zlib failed: %d", code); + free(tmp); + return NULL; + } + if (sz != expSize) { + DMESG("PNG: invalid compressed size"); + free(tmp); + return NULL; + } + + Buffer res = mkBuffer(NULL, 2 + byteW * hd.height); + res->data[0] = 0xf0; + res->data[1] = hd.width; + uint8_t *dst = res->data + 2; + uint8_t *src = tmp; + uint8_t lastMask = (1 << (hd.width & 7)) - 1; + if (lastMask == 0) + lastMask = 0xff; + for (uint32_t i = 0; i < hd.height; ++i) { + if (*src++ != 0) { + DMESG("PNG: unsupported filter"); + free(tmp); + decrRC(res); + return NULL; + } + for (uint32_t j = 0; j < byteW; ++j) { + *dst = ~revbits(*src++); + if (j == byteW - 1) { + *dst &= lastMask; + } + dst++; + } + } + free(tmp); + return res; +} +} diff --git a/libs/core/pxt.json b/libs/core/pxt.json index 50e20cee..22af1604 100644 --- a/libs/core/pxt.json +++ b/libs/core/pxt.json @@ -11,6 +11,7 @@ "mmap.cpp", "control.cpp", "buttons.ts", + "png.cpp", "screen.cpp", "screen.ts", "output.cpp", diff --git a/libs/core/shims.d.ts b/libs/core/shims.d.ts index 5d20f4f5..a15e3362 100644 --- a/libs/core/shims.d.ts +++ b/libs/core/shims.d.ts @@ -70,6 +70,12 @@ declare namespace serial { //% shim=serial::writeDmesg function writeDmesg(): void; } +declare namespace screen { + + /** Decompresses a 1-bit gray scale PNG image to icon format. */ + //% shim=screen::unpackPNG + function unpackPNG(png: Buffer): Buffer; +} declare namespace screen { /** Double size of an icon. */ diff --git a/pxtarget.json b/pxtarget.json index 85a0e8de..3c894543 100644 --- a/pxtarget.json +++ b/pxtarget.json @@ -62,7 +62,7 @@ }, "compileService": { "buildEngine": "dockermake", - "dockerImage": "pext/ev3", + "dockerImage": "pext/ev3:zlib", "serviceId": "ev3" }, "appTheme": { From f6e350cf9fcd88dac9ddfb2e101978bc3bad79e9 Mon Sep 17 00:00:00 2001 From: Michal Moskal Date: Mon, 30 Oct 2017 13:04:12 +0000 Subject: [PATCH 02/13] Add separate type for Icons (same repr as buffer) --- libs/core/pxt.h | 3 + libs/core/screen.cpp | 192 ++++++++++++++++++++++++++----------------- libs/core/screen.ts | 5 +- libs/core/shims.d.ts | 35 ++++++-- libs/core/test.ts | 2 +- 5 files changed, 149 insertions(+), 88 deletions(-) diff --git a/libs/core/pxt.h b/libs/core/pxt.h index cc218ce0..53b37065 100644 --- a/libs/core/pxt.h +++ b/libs/core/pxt.h @@ -27,6 +27,9 @@ class MMap : public RefObject { extern volatile bool paniced; +// Buffer and Icon share representation. +typedef Buffer Icon; + } #define DEVICE_EVT_ANY 0 diff --git a/libs/core/screen.cpp b/libs/core/screen.cpp index 7400a0b1..002aa75e 100644 --- a/libs/core/screen.cpp +++ b/libs/core/screen.cpp @@ -130,82 +130,6 @@ void _blitLine(int xw, int y, Buffer buf, Draw mode) { blitLineCore(XX(xw), y, YY(xw), buf->data, mode); } -static uint8_t ones[] = { - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, -}; - -bool isValidIcon(Buffer buf) { - return buf->length >= 3 && buf->data[0] == 0xf0; -} - -static const uint8_t bitdouble[] = { - 0x00, 0x03, 0x0c, 0x0f, 0x30, 0x33, 0x3c, 0x3f, 0xc0, 0xc3, 0xcc, 0xcf, 0xf0, 0xf3, 0xfc, 0xff, -}; - -/** Double size of an icon. */ -//% -Buffer doubleIcon(Buffer buf) { - if (!isValidIcon(buf)) - return NULL; - int w = buf->data[1]; - if (w > 126) - return NULL; - int bw = PIX2BYTES(w); - int h = (buf->length - 2) / bw; - int bw2 = PIX2BYTES(w * 2); - Buffer out = mkBuffer(NULL, 2 + bw2 * h * 2); - out->data[0] = 0xf0; - out->data[1] = w * 2; - uint8_t *src = buf->data + 2; - uint8_t *dst = out->data + 2; - for (int i = 0; i < h; ++i) { - for (int jj = 0; jj < 2; ++jj) { - auto p = src; - for (int j = 0; j < bw; ++j) { - *dst++ = bitdouble[*p & 0xf]; - *dst++ = bitdouble[*p >> 4]; - p++; - } - } - src += bw; - } - return out; -} - -/** Draw an icon on the screen. */ -//% -void drawIcon(int x, int y, Buffer buf, Draw mode) { - if (!isValidIcon(buf)) - return; - if (mode & (Draw::Double | Draw::Quad)) { - buf = doubleIcon(buf); - if (mode & Draw::Quad) { - auto pbuf = buf; - buf = doubleIcon(buf); - decrRC(pbuf); - } - } - - int pixwidth = buf->data[1]; - int ptr = 2; - int bytewidth = PIX2BYTES(pixwidth); - pixwidth = min(pixwidth, LCD_WIDTH); - while (ptr + bytewidth <= buf->length) { - if (mode & (Draw::Clear | Draw::Xor | Draw::Transparent)) { - // no erase of background - } else { - blitLineCore(x, y, pixwidth, ones, Draw::Clear); - } - blitLineCore(x, y, pixwidth, &buf->data[ptr], mode); - y++; - ptr += bytewidth; - } - - if (mode & Draw::Double) - decrRC(buf); -} - /** Clear screen and reset font to normal. */ //% void clear() { @@ -309,11 +233,23 @@ extern "C" void drawPanic(int code) { updateLCD(); int fd = open("/dev/lms_ui", O_RDWR); - uint8_t cmd[] = { 48 + 5, 0 }; + uint8_t cmd[] = {48 + 5, 0}; write(fd, cmd, 2); close(fd); } +bool isValidIcon(Buffer buf) { + return buf->length >= 3 && buf->data[0] == 0xf0; +} + +/** Makes an icon bound to a buffer. */ +//% +Icon iconOf(Buffer buf) { + if (!isValidIcon(buf)) + return NULL; + incrRC(buf); + return buf; +} } namespace pxt { @@ -321,3 +257,105 @@ void screen_init() { screen::init(); } } + +//% fixedInstances +namespace IconMethods { + +using namespace screen; + +static const uint8_t bitdouble[] = { + 0x00, 0x03, 0x0c, 0x0f, 0x30, 0x33, 0x3c, 0x3f, 0xc0, 0xc3, 0xcc, 0xcf, 0xf0, 0xf3, 0xfc, 0xff, +}; + +static uint8_t ones[] = { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +}; + +/** Returns the underlaying Buffer object. */ +//% property +Buffer buffer(Icon ic) { + incrRC(ic); + return ic; +} + +/** Returns the width of an icon. */ +//% property +int width(Icon ic) { + if (!isValidIcon(ic)) + return 0; + return ic->data[1]; +} + +/** Returns the height of an icon. */ +//% property +int height(Icon ic) { + if (!isValidIcon(ic)) + return 0; + int bw = PIX2BYTES(ic->data[1]); + return (ic->length - 2) / bw; +} + +/** Double size of an icon. */ +//% +Icon doubled(Icon buf) { + if (!isValidIcon(buf)) + return NULL; + int w = buf->data[1]; + if (w > 126) + return NULL; + int bw = PIX2BYTES(w); + int h = (buf->length - 2) / bw; + int bw2 = PIX2BYTES(w * 2); + Buffer out = mkBuffer(NULL, 2 + bw2 * h * 2); + out->data[0] = 0xf0; + out->data[1] = w * 2; + uint8_t *src = buf->data + 2; + uint8_t *dst = out->data + 2; + for (int i = 0; i < h; ++i) { + for (int jj = 0; jj < 2; ++jj) { + auto p = src; + for (int j = 0; j < bw; ++j) { + *dst++ = bitdouble[*p & 0xf]; + *dst++ = bitdouble[*p >> 4]; + p++; + } + } + src += bw; + } + return out; +} + +/** Draw an icon on the screen. */ +//% +void draw(Icon buf, int x, int y, Draw mode) { + if (!isValidIcon(buf)) + return; + if (mode & (Draw::Double | Draw::Quad)) { + buf = doubled(buf); + if (mode & Draw::Quad) { + auto pbuf = buf; + buf = doubled(buf); + decrRC(pbuf); + } + } + + int pixwidth = buf->data[1]; + int ptr = 2; + int bytewidth = PIX2BYTES(pixwidth); + pixwidth = min(pixwidth, LCD_WIDTH); + while (ptr + bytewidth <= buf->length) { + if (mode & (Draw::Clear | Draw::Xor | Draw::Transparent)) { + // no erase of background + } else { + blitLineCore(x, y, pixwidth, ones, Draw::Clear); + } + blitLineCore(x, y, pixwidth, &buf->data[ptr], mode); + y++; + ptr += bytewidth; + } + + if (mode & (Draw::Double | Draw::Quad)) + decrRC(buf); +} +} \ No newline at end of file diff --git a/libs/core/screen.ts b/libs/core/screen.ts index bf85567f..2ff475c1 100644 --- a/libs/core/screen.ts +++ b/libs/core/screen.ts @@ -27,7 +27,7 @@ namespace screen { currFont = f } - export const heart = hex`f007 367f7f3e1c08` + export const heart = iconOf(hex`f007 367f7f3e1c08`) export function defaultFont(): Font { return { @@ -112,6 +112,7 @@ namespace screen { let byteWidth = (currFont.charWidth + 7) >> 3 let charSize = byteWidth * currFont.charHeight let iconBuf = output.createBuffer(2 + charSize) + let icon = iconOf(iconBuf) let double = (mode & Draw.Quad) ? 4 : (mode & Draw.Double) ? 2 : 1 iconBuf[0] = 0xf0 iconBuf[1] = currFont.charWidth @@ -127,7 +128,7 @@ namespace screen { iconBuf.fill(0, 2) else iconBuf.write(2, currFont.data.slice(idx, charSize)) - drawIcon(x, y, iconBuf, mode) + icon.draw(x, y, mode) x += double * currFont.charWidth } } diff --git a/libs/core/shims.d.ts b/libs/core/shims.d.ts index a15e3362..4a323c59 100644 --- a/libs/core/shims.d.ts +++ b/libs/core/shims.d.ts @@ -78,17 +78,36 @@ declare namespace screen { } declare namespace screen { - /** Double size of an icon. */ - //% shim=screen::doubleIcon - function doubleIcon(buf: Buffer): Buffer; - - /** Draw an icon on the screen. */ - //% shim=screen::drawIcon - function drawIcon(x: int32, y: int32, buf: Buffer, mode: Draw): void; - /** Clear screen and reset font to normal. */ //% shim=screen::clear function clear(): void; + + /** Makes an icon bound to a buffer. */ + //% shim=screen::iconOf + function iconOf(buf: Buffer): Icon; +} + + +declare interface Icon { + /** Returns the underlaying Buffer object. */ + //% property shim=IconMethods::buffer + buffer: Buffer; + + /** Returns the width of an icon. */ + //% property shim=IconMethods::width + width: int32; + + /** Returns the height of an icon. */ + //% property shim=IconMethods::height + height: int32; + + /** Double size of an icon. */ + //% shim=IconMethods::doubled + doubled(): Icon; + + /** Draw an icon on the screen. */ + //% shim=IconMethods::draw + draw(x: int32, y: int32, mode: Draw): void; } declare namespace output { diff --git a/libs/core/test.ts b/libs/core/test.ts index 6be67450..81f4f2bd 100644 --- a/libs/core/test.ts +++ b/libs/core/test.ts @@ -4,7 +4,7 @@ screen.print("PXT!", 10, 30, Draw.Quad) screen.drawRect(40, 40, 20, 10, Draw.Fill) output.setStatusLight(LightsPattern.Orange) -screen.drawIcon(100, 50, screen.doubleIcon(screen.heart), Draw.Double | Draw.Transparent) +screen.heart.doubled().draw(100, 50, Draw.Double | Draw.Transparent) input.buttonEnter.onEvent(ButtonEvent.Click, () => { screen.clear() From dcb398d3d52fb7049510dd1fa60f96d9a590d4b7 Mon Sep 17 00:00:00 2001 From: Michal Moskal Date: Mon, 30 Oct 2017 13:28:01 +0000 Subject: [PATCH 03/13] Rename Icon to Image --- libs/core/_locales/core-jsdoc-strings.json | 10 ++++-- libs/core/_locales/core-strings.json | 1 + libs/core/png.cpp | 4 +-- libs/core/pxt.h | 4 +-- libs/core/screen.cpp | 36 +++++++++++----------- libs/core/screen.ts | 18 +++++------ libs/core/shims.d.ts | 34 ++++++++++---------- 7 files changed, 57 insertions(+), 50 deletions(-) diff --git a/libs/core/_locales/core-jsdoc-strings.json b/libs/core/_locales/core-jsdoc-strings.json index e3412e25..842f6635 100644 --- a/libs/core/_locales/core-jsdoc-strings.json +++ b/libs/core/_locales/core-jsdoc-strings.json @@ -1,6 +1,11 @@ { "ButtonEvent": "User interaction on buttons", "Draw": "Drawing modes", + "Image.buffer": "Returns the underlaying Buffer object.", + "Image.doubled": "Double size of an image.", + "Image.draw": "Draw an image on the screen.", + "Image.height": "Returns the height of an image.", + "Image.width": "Returns the width of an image.", "LightsPattern": "Patterns for lights under the buttons.", "MMap.getNumber": "Read a number in specified format from the buffer.", "MMap.ioctl": "Perform ioctl(2) on the underlaying file", @@ -75,8 +80,7 @@ "output.setStatusLight|param|pattern": "the lights pattern to use.", "output.stopAllMotors": "Stops all motors", "screen.clear": "Clear screen and reset font to normal.", - "screen.doubleIcon": "Double size of an icon.", - "screen.drawIcon": "Draw an icon on the screen.", + "screen.imageOf": "Makes an image bound to a buffer.", "screen.print": "Show text on the screen.", "screen.print|param|text": "the text to print on the screen, eg: \"Hello world\"", "screen.print|param|x": "the starting position's x coordinate, eg: 0", @@ -85,7 +89,7 @@ "screen.setPixel|param|on": "a value indicating if the pixel should be on or off", "screen.setPixel|param|x": "the starting position's x coordinate, eg: 0", "screen.setPixel|param|y": "the starting position's x coordinate, eg: 0", - "screen.unpackPNG": "Decompresses a 1-bit gray scale PNG image to icon format.", + "screen.unpackPNG": "Decompresses a 1-bit gray scale PNG image to image format.", "serial": "Reading and writing data over a serial connection.", "serial.writeDmesg": "Send DMESG debug buffer over serial." } \ No newline at end of file diff --git a/libs/core/_locales/core-strings.json b/libs/core/_locales/core-strings.json index b706cfb0..84d91f12 100644 --- a/libs/core/_locales/core-strings.json +++ b/libs/core/_locales/core-strings.json @@ -106,6 +106,7 @@ "screen|block": "screen", "serial|block": "serial", "{id:category}Control": "Control", + "{id:category}Image": "Image", "{id:category}Input": "Input", "{id:category}MMap": "MMap", "{id:category}Output": "Output", diff --git a/libs/core/png.cpp b/libs/core/png.cpp index 6d78b771..90674728 100644 --- a/libs/core/png.cpp +++ b/libs/core/png.cpp @@ -33,9 +33,9 @@ static uint8_t revbits(uint8_t v) { return v; } -/** Decompresses a 1-bit gray scale PNG image to icon format. */ +/** Decompresses a 1-bit gray scale PNG image to image format. */ //% -Buffer unpackPNG(Buffer png) { +Image unpackPNG(Buffer png) { if (!png) { DMESG("PNG: Missing image"); return NULL; diff --git a/libs/core/pxt.h b/libs/core/pxt.h index 53b37065..e3eadfab 100644 --- a/libs/core/pxt.h +++ b/libs/core/pxt.h @@ -27,8 +27,8 @@ class MMap : public RefObject { extern volatile bool paniced; -// Buffer and Icon share representation. -typedef Buffer Icon; +// Buffer and Image share representation. +typedef Buffer Image; } diff --git a/libs/core/screen.cpp b/libs/core/screen.cpp index 002aa75e..dff65e69 100644 --- a/libs/core/screen.cpp +++ b/libs/core/screen.cpp @@ -238,14 +238,14 @@ extern "C" void drawPanic(int code) { close(fd); } -bool isValidIcon(Buffer buf) { +bool isValidImage(Buffer buf) { return buf->length >= 3 && buf->data[0] == 0xf0; } -/** Makes an icon bound to a buffer. */ +/** Makes an image bound to a buffer. */ //% -Icon iconOf(Buffer buf) { - if (!isValidIcon(buf)) +Image imageOf(Buffer buf) { + if (!isValidImage(buf)) return NULL; incrRC(buf); return buf; @@ -259,7 +259,7 @@ void screen_init() { } //% fixedInstances -namespace IconMethods { +namespace ImageMethods { using namespace screen; @@ -274,32 +274,32 @@ static uint8_t ones[] = { /** Returns the underlaying Buffer object. */ //% property -Buffer buffer(Icon ic) { +Buffer buffer(Image ic) { incrRC(ic); return ic; } -/** Returns the width of an icon. */ +/** Returns the width of an image. */ //% property -int width(Icon ic) { - if (!isValidIcon(ic)) +int width(Image ic) { + if (!isValidImage(ic)) return 0; return ic->data[1]; } -/** Returns the height of an icon. */ +/** Returns the height of an image. */ //% property -int height(Icon ic) { - if (!isValidIcon(ic)) +int height(Image ic) { + if (!isValidImage(ic)) return 0; int bw = PIX2BYTES(ic->data[1]); return (ic->length - 2) / bw; } -/** Double size of an icon. */ +/** Double size of an image. */ //% -Icon doubled(Icon buf) { - if (!isValidIcon(buf)) +Image doubled(Image buf) { + if (!isValidImage(buf)) return NULL; int w = buf->data[1]; if (w > 126) @@ -326,10 +326,10 @@ Icon doubled(Icon buf) { return out; } -/** Draw an icon on the screen. */ +/** Draw an image on the screen. */ //% -void draw(Icon buf, int x, int y, Draw mode) { - if (!isValidIcon(buf)) +void draw(Image buf, int x, int y, Draw mode) { + if (!isValidImage(buf)) return; if (mode & (Draw::Double | Draw::Quad)) { buf = doubled(buf); diff --git a/libs/core/screen.ts b/libs/core/screen.ts index 2ff475c1..8a020cb3 100644 --- a/libs/core/screen.ts +++ b/libs/core/screen.ts @@ -27,7 +27,7 @@ namespace screen { currFont = f } - export const heart = iconOf(hex`f007 367f7f3e1c08`) + export const heart = imageOf(hex`f007 367f7f3e1c08`) export function defaultFont(): Font { return { @@ -111,11 +111,11 @@ namespace screen { let cp = 0 let byteWidth = (currFont.charWidth + 7) >> 3 let charSize = byteWidth * currFont.charHeight - let iconBuf = output.createBuffer(2 + charSize) - let icon = iconOf(iconBuf) + let imgBuf = output.createBuffer(2 + charSize) + let img = imageOf(imgBuf) let double = (mode & Draw.Quad) ? 4 : (mode & Draw.Double) ? 2 : 1 - iconBuf[0] = 0xf0 - iconBuf[1] = currFont.charWidth + imgBuf[0] = 0xf0 + imgBuf[1] = currFont.charWidth while (cp < text.length) { let ch = text.charCodeAt(cp++) if (ch == 10) { @@ -124,11 +124,11 @@ namespace screen { } if (ch < 32) continue let idx = (ch - currFont.firstChar) * charSize - if (idx < 0 || idx + iconBuf.length - 1 > currFont.data.length) - iconBuf.fill(0, 2) + if (idx < 0 || idx + imgBuf.length - 1 > currFont.data.length) + imgBuf.fill(0, 2) else - iconBuf.write(2, currFont.data.slice(idx, charSize)) - icon.draw(x, y, mode) + imgBuf.write(2, currFont.data.slice(idx, charSize)) + img.draw(x, y, mode) x += double * currFont.charWidth } } diff --git a/libs/core/shims.d.ts b/libs/core/shims.d.ts index 4a323c59..8924385e 100644 --- a/libs/core/shims.d.ts +++ b/libs/core/shims.d.ts @@ -72,9 +72,9 @@ declare namespace serial { } declare namespace screen { - /** Decompresses a 1-bit gray scale PNG image to icon format. */ + /** Decompresses a 1-bit gray scale PNG image to image format. */ //% shim=screen::unpackPNG - function unpackPNG(png: Buffer): Buffer; + function unpackPNG(png: Buffer): Image; } declare namespace screen { @@ -82,31 +82,33 @@ declare namespace screen { //% shim=screen::clear function clear(): void; - /** Makes an icon bound to a buffer. */ - //% shim=screen::iconOf - function iconOf(buf: Buffer): Icon; + /** Makes an image bound to a buffer. */ + //% shim=screen::imageOf + function imageOf(buf: Buffer): Image; } -declare interface Icon { + + //% fixedInstances +declare interface Image { /** Returns the underlaying Buffer object. */ - //% property shim=IconMethods::buffer + //% property shim=ImageMethods::buffer buffer: Buffer; - /** Returns the width of an icon. */ - //% property shim=IconMethods::width + /** Returns the width of an image. */ + //% property shim=ImageMethods::width width: int32; - /** Returns the height of an icon. */ - //% property shim=IconMethods::height + /** Returns the height of an image. */ + //% property shim=ImageMethods::height height: int32; - /** Double size of an icon. */ - //% shim=IconMethods::doubled - doubled(): Icon; + /** Double size of an image. */ + //% shim=ImageMethods::doubled + doubled(): Image; - /** Draw an icon on the screen. */ - //% shim=IconMethods::draw + /** Draw an image on the screen. */ + //% shim=ImageMethods::draw draw(x: int32, y: int32, mode: Draw): void; } declare namespace output { From 9cdb4081fd038e319ad1b2cae4ae16e2069c5a2e Mon Sep 17 00:00:00 2001 From: Michal Moskal Date: Mon, 30 Oct 2017 14:42:08 +0000 Subject: [PATCH 04/13] Add PNG decompressor in SIM --- sim/inflate.ts | 375 ++++++++++++++++++++++++++++++++++++++++++++ sim/state/screen.ts | 175 ++++++++++++++++++--- 2 files changed, 527 insertions(+), 23 deletions(-) create mode 100644 sim/inflate.ts diff --git a/sim/inflate.ts b/sim/inflate.ts new file mode 100644 index 00000000..0d964ae9 --- /dev/null +++ b/sim/inflate.ts @@ -0,0 +1,375 @@ +// adapted from https://github.com/devongovett/tiny-inflate +// License: MIT + +namespace tinf { + + var TINF_OK = 0; + var TINF_DATA_ERROR = -3; + + class Tree { + table = new Uint16Array(16); /* table of code length counts */ + trans = new Uint16Array(288); /* code -> symbol translation table */ + } + + class Data { + sourceIndex = 0; + tag = 0; + bitcount = 0; + + destLen = 0; + + ltree = new Tree(); /* dynamic length/symbol tree */ + dtree = new Tree(); /* dynamic distance tree */ + + constructor(public source: Uint8Array, public dest: Uint8Array) { + } + } + + /* --------------------------------------------------- * + * -- uninitialized global data (static structures) -- * + * --------------------------------------------------- */ + + var sltree = new Tree(); + var sdtree = new Tree(); + + /* extra bits and base tables for length codes */ + var length_bits = new Uint8Array(30); + var length_base = new Uint16Array(30); + + /* extra bits and base tables for distance codes */ + var dist_bits = new Uint8Array(30); + var dist_base = new Uint16Array(30); + + /* special ordering of code length codes */ + var clcidx = new Uint8Array([ + 16, 17, 18, 0, 8, 7, 9, 6, + 10, 5, 11, 4, 12, 3, 13, 2, + 14, 1, 15 + ]); + + /* used by tinf_decode_trees, avoids allocations every call */ + var code_tree = new Tree(); + var lengths = new Uint8Array(288 + 32); + + /* ----------------------- * + * -- utility functions -- * + * ----------------------- */ + + /* build extra bits and base tables */ + function tinf_build_bits_base(bits: Uint8Array, base: Uint16Array, delta: number, first: number) { + /* build bits table */ + for (let i = 0; i < delta; ++i) bits[i] = 0; + for (let i = 0; i < 30 - delta; ++i) bits[i + delta] = i / delta | 0; + + /* build base table */ + for (let sum = first, i = 0; i < 30; ++i) { + base[i] = sum; + sum += 1 << bits[i]; + } + } + + /* build the fixed huffman trees */ + function tinf_build_fixed_trees(lt: Tree, dt: Tree) { + let i = 0; + + /* build fixed length tree */ + for (i = 0; i < 7; ++i) lt.table[i] = 0; + + lt.table[7] = 24; + lt.table[8] = 152; + lt.table[9] = 112; + + for (i = 0; i < 24; ++i) lt.trans[i] = 256 + i; + for (i = 0; i < 144; ++i) lt.trans[24 + i] = i; + for (i = 0; i < 8; ++i) lt.trans[24 + 144 + i] = 280 + i; + for (i = 0; i < 112; ++i) lt.trans[24 + 144 + 8 + i] = 144 + i; + + /* build fixed distance tree */ + for (i = 0; i < 5; ++i) dt.table[i] = 0; + + dt.table[5] = 32; + + for (i = 0; i < 32; ++i) dt.trans[i] = i; + } + + /* given an array of code lengths, build a tree */ + var offs = new Uint16Array(16); + + function tinf_build_tree(t: Tree, lengths: Uint8Array, off: number, num: number) { + var i = 0, sum = 0; + + /* clear code length count table */ + for (i = 0; i < 16; ++i) t.table[i] = 0; + + /* scan symbol lengths, and sum code length counts */ + for (i = 0; i < num; ++i) t.table[lengths[off + i]]++; + + t.table[0] = 0; + + /* compute offset table for distribution sort */ + for (sum = 0, i = 0; i < 16; ++i) { + offs[i] = sum; + sum += t.table[i]; + } + + /* create code->symbol translation table (symbols sorted by code) */ + for (i = 0; i < num; ++i) { + if (lengths[off + i]) t.trans[offs[lengths[off + i]]++] = i; + } + } + + /* ---------------------- * + * -- decode functions -- * + * ---------------------- */ + + /* get one bit from source stream */ + function tinf_getbit(d: Data) { + /* check if tag is empty */ + if (!d.bitcount--) { + /* load next tag */ + d.tag = d.source[d.sourceIndex++]; + d.bitcount = 7; + } + + /* shift bit out of tag */ + var bit = d.tag & 1; + d.tag >>>= 1; + + return bit; + } + + /* read a num bit value from a stream and add base */ + function tinf_read_bits(d: Data, num: number, base: number) { + if (!num) + return base; + + while (d.bitcount < 24) { + d.tag |= d.source[d.sourceIndex++] << d.bitcount; + d.bitcount += 8; + } + + var val = d.tag & (0xffff >>> (16 - num)); + d.tag >>>= num; + d.bitcount -= num; + return val + base; + } + + /* given a data stream and a tree, decode a symbol */ + function tinf_decode_symbol(d: Data, t: Tree) { + while (d.bitcount < 24) { + d.tag |= d.source[d.sourceIndex++] << d.bitcount; + d.bitcount += 8; + } + + var sum = 0, cur = 0, len = 0; + var tag = d.tag; + + /* get more bits while code value is above sum */ + do { + cur = 2 * cur + (tag & 1); + tag >>>= 1; + ++len; + + sum += t.table[len]; + cur -= t.table[len]; + } while (cur >= 0); + + d.tag = tag; + d.bitcount -= len; + + return t.trans[sum + cur]; + } + + /* given a data stream, decode dynamic trees from it */ + function tinf_decode_trees(d: Data, lt: Tree, dt: Tree) { + var i = 0, num = 0, length = 0; + + /* get 5 bits HLIT (257-286) */ + let hlit = tinf_read_bits(d, 5, 257); + + /* get 5 bits HDIST (1-32) */ + let hdist = tinf_read_bits(d, 5, 1); + + /* get 4 bits HCLEN (4-19) */ + let hclen = tinf_read_bits(d, 4, 4); + + for (i = 0; i < 19; ++i) lengths[i] = 0; + + /* read code lengths for code length alphabet */ + for (i = 0; i < hclen; ++i) { + /* get 3 bits code length (0-7) */ + var clen = tinf_read_bits(d, 3, 0); + lengths[clcidx[i]] = clen; + } + + /* build code length tree */ + tinf_build_tree(code_tree, lengths, 0, 19); + + /* decode code lengths for the dynamic trees */ + for (num = 0; num < hlit + hdist;) { + var sym = tinf_decode_symbol(d, code_tree); + + switch (sym) { + case 16: + /* copy previous code length 3-6 times (read 2 bits) */ + var prev = lengths[num - 1]; + for (length = tinf_read_bits(d, 2, 3); length; --length) { + lengths[num++] = prev; + } + break; + case 17: + /* repeat code length 0 for 3-10 times (read 3 bits) */ + for (length = tinf_read_bits(d, 3, 3); length; --length) { + lengths[num++] = 0; + } + break; + case 18: + /* repeat code length 0 for 11-138 times (read 7 bits) */ + for (length = tinf_read_bits(d, 7, 11); length; --length) { + lengths[num++] = 0; + } + break; + default: + /* values 0-15 represent the actual code lengths */ + lengths[num++] = sym; + break; + } + } + + /* build dynamic trees */ + tinf_build_tree(lt, lengths, 0, hlit); + tinf_build_tree(dt, lengths, hlit, hdist); + } + + /* ----------------------------- * + * -- block inflate functions -- * + * ----------------------------- */ + + /* given a stream and two trees, inflate a block of data */ + function tinf_inflate_block_data(d: Data, lt: Tree, dt: Tree) { + while (true) { + var sym = tinf_decode_symbol(d, lt); + + /* check for end of block */ + if (sym === 256) { + return TINF_OK; + } + + if (sym < 256) { + d.dest[d.destLen++] = sym; + } else { + sym -= 257; + + /* possibly get more bits from length code */ + let length = tinf_read_bits(d, length_bits[sym], length_base[sym]); + + let dist = tinf_decode_symbol(d, dt); + + /* possibly get more bits from distance code */ + let offs = d.destLen - tinf_read_bits(d, dist_bits[dist], dist_base[dist]); + + /* copy match */ + for (let i = offs; i < offs + length; ++i) { + d.dest[d.destLen++] = d.dest[i]; + } + } + } + } + + /* inflate an uncompressed block of data */ + function tinf_inflate_uncompressed_block(d: Data) { + /* unread from bitbuffer */ + while (d.bitcount > 8) { + d.sourceIndex--; + d.bitcount -= 8; + } + + /* get length */ + let length = d.source[d.sourceIndex + 1]; + length = 256 * length + d.source[d.sourceIndex]; + + /* get one's complement of length */ + let invlength = d.source[d.sourceIndex + 3]; + invlength = 256 * invlength + d.source[d.sourceIndex + 2]; + + /* check length */ + if (length !== (~invlength & 0x0000ffff)) + return TINF_DATA_ERROR; + + d.sourceIndex += 4; + + /* copy block */ + for (let i = length; i; --i) + d.dest[d.destLen++] = d.source[d.sourceIndex++]; + + /* make sure we start next block on a byte boundary */ + d.bitcount = 0; + + return TINF_OK; + } + + /* inflate stream from source to dest */ + export function uncompress(source: Uint8Array, dest: Uint8Array) { + var d = new Data(source, dest); + var bfinal = 0, res = 0; + + do { + /* read final block flag */ + bfinal = tinf_getbit(d); + + /* read block type (2 bits) */ + let btype = tinf_read_bits(d, 2, 0); + + /* decompress block */ + switch (btype) { + case 0: + /* decompress uncompressed block */ + res = tinf_inflate_uncompressed_block(d); + break; + case 1: + /* decompress block with fixed huffman trees */ + res = tinf_inflate_block_data(d, sltree, sdtree); + break; + case 2: + /* decompress block with dynamic huffman trees */ + tinf_decode_trees(d, d.ltree, d.dtree); + res = tinf_inflate_block_data(d, d.ltree, d.dtree); + break; + default: + res = TINF_DATA_ERROR; + } + + if (res !== TINF_OK) + throw new Error('Data error'); + + } while (!bfinal); + + if (d.destLen >= d.dest.length) + return null + + if (d.destLen < d.dest.length) { + if (typeof d.dest.slice === 'function') + return d.dest.slice(0, d.destLen); + else + return d.dest.subarray(0, d.destLen); + } + + return d.dest; + } + + /* -------------------- * + * -- initialization -- * + * -------------------- */ + + /* build fixed huffman trees */ + tinf_build_fixed_trees(sltree, sdtree); + + /* build extra bits and base tables */ + tinf_build_bits_base(length_bits, length_base, 4, 3); + tinf_build_bits_base(dist_bits, dist_base, 2, 1); + + /* fix a special case */ + length_bits[28] = 0; + length_base[28] = 258; + +} \ No newline at end of file diff --git a/sim/state/screen.ts b/sim/state/screen.ts index 086d8b67..572046bc 100644 --- a/sim/state/screen.ts +++ b/sim/state/screen.ts @@ -90,36 +90,172 @@ namespace pxsim.screen { screenState.blitLineCore(XX(xw), y, YY(xw), buf, mode) } + export function isValidImage(buf: RefBuffer) { + return buf.data.length >= 3 && buf.data[0] == 0xf0; + } + + export function PIX2BYTES(x: number) { + return ((x + 7) >> 3) + } + export function clear(): void { + const screenState = (board() as DalBoard).screenState; + screenState.clear() + } + + export function dump() { + // No need for this one. + } + + export function imageOf(buf: RefBuffer) { + return incr(buf) + } +} + +namespace pxsim.screen { + function DMESG(msg: string) { + control.dmesg(msg) + } + const NULL: RefBuffer = null; + function revbits(v: number) { + v = (v & 0xf0) >> 4 | (v & 0x0f) << 4; + v = (v & 0xcc) >> 2 | (v & 0x33) << 2; + v = (v & 0xaa) >> 1 | (v & 0x55) << 1; + return v; + } + + export function unpackPNG(png: RefBuffer) { + function memcmp(off: number, mark: string) { + for (let i = 0; i < mark.length; ++i) { + if (mark.charCodeAt(i) != png.data[off + i]) + return 1 + } + return 0 + } + function readInt(off: number) { + return ((png.data[off] << 24) | (png.data[off + 1] << 16) | + (png.data[off + 2] << 8) | (png.data[off + 3])) >>> 0 + } + if (!png) { + DMESG("PNG: Missing image"); + return NULL; + } + if (png.data.length < 45) { + DMESG("PNG: File too small"); + return NULL; + } + + if (memcmp(0, "\x89PNG\r\n\x1A\n") != 0) { + DMESG("PNG: Invalid header"); + return NULL; + } + + if (memcmp(12, "IHDR") != 0) { + DMESG("PNG: missing IHDR"); + return NULL; + } + + const lenIHDR = readInt(8); + const width = readInt(16); + const height = readInt(20); + const lenIDAT = readInt(33); + const sizeOfHD = 41; + + if (lenIHDR != 13) { + DMESG("PNG: bad IHDR len"); + return NULL; + } + if (memcmp(24, "\x01\x00\x00\x00\x00") != 0) { + DMESG("PNG: not 1-bit grayscale"); + return NULL; + } + if (memcmp(37, "IDAT") != 0) { + DMESG("PNG: missing IDAT"); + return NULL; + } + if (lenIDAT + sizeOfHD >= png.data.length) { + DMESG("PNG: buffer too short"); + return NULL; + } + if (width > 300 || height > 300) { + DMESG("PNG: too big"); + return NULL; + } + + const byteW = (width + 7) >> 3; + const sz = (byteW + 1) * height; + const tmp = new Uint8Array(sz + 1); + // uncompress doesn't take the zlib header, hence + 2 + const two = tinf.uncompress(png.data.slice(sizeOfHD + 2, sizeOfHD + lenIDAT), tmp); + if (two.length != sz) { + DMESG("PNG: invalid compressed size"); + return NULL; + } + + const res = output.createBuffer(2 + byteW * height); + res.data[0] = 0xf0; + res.data[1] = width; + let dst = 2 + let src = 0 + let lastMask = (1 << (width & 7)) - 1; + if (lastMask == 0) + lastMask = 0xff; + for (let i = 0; i < height; ++i) { + if (two[src++] != 0) { + DMESG("PNG: unsupported filter"); + decr(res); + return NULL; + } + for (let j = 0; j < byteW; ++j) { + res.data[dst] = ~revbits(two[src++]); + if (j == byteW - 1) { + res.data[dst] &= lastMask; + } + dst++; + } + } + return res; + } +} + +namespace pxsim.ImageMethods { const bitdouble = [ 0x00, 0x03, 0x0c, 0x0f, 0x30, 0x33, 0x3c, 0x3f, 0xc0, 0xc3, 0xcc, 0xcf, 0xf0, 0xf3, 0xfc, 0xff, ] - export function isValidIcon(buf: RefBuffer) { - return buf.data.length >= 3 && buf.data[0] == 0xf0; + export function buffer(buf: RefBuffer) { + return incr(buf) } - function PIX2BYTES(x: number) { - return ((x + 7) >> 3) + export function width(buf: RefBuffer) { + if (!screen.isValidImage(buf)) return 0 + return buf.data[1] } - export function drawIcon(x: number, y: number, buf: RefBuffer, mode: Draw): void { + export function height(buf: RefBuffer) { + if (!screen.isValidImage(buf)) return 0 + const bw = screen.PIX2BYTES(buf.data[1]); + const h = ((buf.data.length - 2) / bw) | 0; + return h + } + + export function draw(buf: RefBuffer, x: number, y: number, mode: Draw): void { const screenState = (board() as DalBoard).screenState; - if (!isValidIcon(buf)) + if (!screen.isValidImage(buf)) return; if (mode & (Draw.Double | Draw.Quad)) { - buf = doubleIcon(buf); + buf = doubled(buf); if (mode & Draw.Quad) { let pbuf = buf; - buf = doubleIcon(buf); + buf = doubled(buf); decr(pbuf); } } let pixwidth = buf.data[1]; let ptr = 2; - const bytewidth = PIX2BYTES(pixwidth); + const bytewidth = screen.PIX2BYTES(pixwidth); pixwidth = Math.min(pixwidth, visuals.SCREEN_WIDTH); while (ptr + bytewidth <= buf.data.length) { if (mode & (Draw.Clear | Draw.Xor | Draw.Transparent)) { @@ -132,24 +268,19 @@ namespace pxsim.screen { ptr += bytewidth; } - if (mode & Draw.Double) + if (mode & (Draw.Double | Draw.Quad)) decr(buf); } - export function clear(): void { - const screenState = (board() as DalBoard).screenState; - screenState.clear() - } - - export function doubleIcon(buf: RefBuffer): RefBuffer { - if (!isValidIcon(buf)) + export function doubled(buf: RefBuffer): RefBuffer { + if (!screen.isValidImage(buf)) return null; const w = buf.data[1]; if (w > 126) return null; - const bw = PIX2BYTES(w); + const bw = screen.PIX2BYTES(w); const h = ((buf.data.length - 2) / bw) | 0; - const bw2 = PIX2BYTES(w * 2); + const bw2 = screen.PIX2BYTES(w * 2); const out = pins.createBuffer(2 + bw2 * h * 2) out.data[0] = 0xf0; out.data[1] = w * 2; @@ -169,7 +300,5 @@ namespace pxsim.screen { return out; } - export function dump() { - // do we need it? - } -} \ No newline at end of file + +} From a8a726785102a3543a7168c34be4676fda728aee Mon Sep 17 00:00:00 2001 From: Michal Moskal Date: Mon, 30 Oct 2017 15:34:47 +0000 Subject: [PATCH 05/13] Add LEGO EDU images --- libs/core/_locales/core-strings.json | 1 + libs/core/images.jres | 136 ++++++++++++++ libs/core/images.ts | 260 +++++++++++++++++++++++++++ libs/core/pxt.json | 2 + scripts/rgf2png.js | 20 ++- 5 files changed, 417 insertions(+), 2 deletions(-) create mode 100644 libs/core/images.jres create mode 100644 libs/core/images.ts diff --git a/libs/core/_locales/core-strings.json b/libs/core/_locales/core-strings.json index 84d91f12..1f02f582 100644 --- a/libs/core/_locales/core-strings.json +++ b/libs/core/_locales/core-strings.json @@ -107,6 +107,7 @@ "serial|block": "serial", "{id:category}Control": "Control", "{id:category}Image": "Image", + "{id:category}Images": "Images", "{id:category}Input": "Input", "{id:category}MMap": "MMap", "{id:category}Output": "Output", diff --git a/libs/core/images.jres b/libs/core/images.jres new file mode 100644 index 00000000..e6f01011 --- /dev/null +++ b/libs/core/images.jres @@ -0,0 +1,136 @@ +{ + "*": { + "namespace": "images", + "dataEncoding": "base64", + "mimeType": "image/png" + }, + "expressionsBigSmile": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAAt0lEQVR42u3UsQ0DIQwFUEcUlIzAKIwG2YxRGIGSApmcuVy4AwqkSxEppvjFEwIJG0OZLg/s7Ox/50G0PLuDlidHAHPk2TOAPnLJZSAXsXPUSOebbLhe7L/oUJfpHXfXvefd1X1X7+julZRJ3/VSJ0A0y/6sc8Muu/9E57TVjR7oysfoNDFQjJ7ofeToZEmNjtvZQU/qDrY4M3EnE9iJ+61cs/6JAGLmuVX32m+tq64eBf879i/5C1nd6IT3Lpx4AAAAAElFTkSuQmCC", + "expressionsHeartLarge": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAB/UlEQVR42u3WPW7cMBAF4BEEmI1hXSCwrpAyRWDlSCndicEWuZZ8Ex6BpQqBDsUfzXtcOQsHcapso+UHLeftaJekvJ6+Fvm77sd8DT27LWMvM/oqZWzFoC8iaaIgIuhxOOzXLb6Z1OPwvs/Tlxuyx+lHW+b7bNRdvMtPeb75h3q8TbYxl52duo3jJ5Pmk9HPh8s+vuSyZp2q7x8X85LqSLdPmH1PLb3LdeRpqL5PKxLn3evIo6nukz9PqY4MPfvXMdURc6nu0vhT8f6leionD0OqL51jNybXl8Nt/nz17zP7JdeX5+p52FX/MpHHgvl6XzwU/5bry8PILsXvim/CLzOce/9O74qvrf88d3mvm//+Ed4+Rxn+jYfWxz/z19anG24bn2/40jivD/o7v+W++R/d8vXqcf3et6s2w/pJbYP1ltoD6zO1AdZzaoOu//x1db/gmLq/cMzioY0J+xTFrG6bmLDfUczqrolZ3XP3cT+l+NVDE/PYl5uYul9zzMMXjnm445h6HuCYh68c8/CNuqweOL6eQzi++kIx1R3FVPcUU32lmOobxVQPFBPOSxQT3EKX0ReMD+4xJviKMcE3jAkeMCae6zAmuoWY6AvERHfaZXIP8dE3iIkeICadPyEmudWY5G+9d925+/7cV3Pu23DuYXzj/Dx93Dn8yn8BfHcW3cEFXEQAAAAASUVORK5CYII=", + "expressionsHeartSmall": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABXUlEQVR42u3WMW7DIBgF4Gd5YKvVC5QzRN1r5Sy9RiRbykF6FTJ17BU4AiMDsgtWZN6PbSVRutUMlvMR4QcxP8G42gx23/0B99ONaUrv0cYrUDoQvxow9ZIH1OdxdFMvu4e6jKMFlHQH5dInHKUbVL6LD4eTHuXUxofDL/xND9FPnfAoL02MiY+2dKV8vGrhaYT6HOOj0exphGry+qt0XGzq/WFPI+OYHN8Lh1m4w9w+H/R3dpv9sOGv97jJjv/gtA7VM06/S/2M++zqHg/Zmw3X5Xt+bYt9ccO7ct/xctL+Fcszu5XTpTogpkV1Q0yL6oyIOfsgY3K94pjZjYiZ3YqY2Z2IyfWTY2YPImb2QcSk+txzTHLDMcktxyR3HJPcc0zykF8SeV5wfPaeYrIbisluKSa7o5jsgWKyDxRTnGsUU3g/r7L0rXtbr7tX6x6adR/0xvnb7v83dv8j/wXoD/U2XjE34wAAAABJRU5ErkJggg==", + "expressionsMouth1open": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACQklEQVR42u3WvW7TUBQH8L+xFC+AH4DBPAIL6sBgNp6g0IlkR2LuUtmoQ0bew+nQsRuOPPAEqKurbGHgRlXEFXHv4Vxfxx/XNgIJhCrlSlHkn/7+kO1zfECDK8V98c0Qr1IIp8+5yw4EXVWAcSBqcYzG632U2Wq8u9i/yz57O3ZzxPaKyPhctTWQtRMVtRJ1POQfm/oDV6HlH7te/I5Hxum/++2Q35buWx7+Td8M+Uq78st7a9wvn0Pphe1++X5S4XVd+pRpl7Z72mUoXhGJyDxf0plz8tiDPOM3e//cXc4sFXsBZ8n1sXeuhjyHz/cT7ozoQWC8eBrRUiBMsYsnl4GY7P2Zp9wrvEuxpbsTwDfXR/KU3+YpXaf4kSQXwAvPuHgPPE6SBeePj9/E7vYDn++cz3+d44ylzCekkjRQiMPCST7Rep/XawY4KReQ2aryvK74fKI8tl5NfhrjbArc2fmEaL0gSux8d7XynXXIH/L/KL+j3h4L+qrr8ZGdfo2jFAoTO3+BJ7quXTt/outahks7fxnp/hDlX6z8jOa6z4hv7UtakLqp+s8p/Cb8Fm6mfUNyBrfJc2FmVX/j0iWqypK4WL3KHUpzZ12mBfJIVK48HXpONKVtzLuaflj2Vf52BuC+E3An0N+e2j35EMgxcYuOc+vlb+NL/XmcNx7o9hyHPAHEIX3W2y1Pdd/No57f6P4tqOcr/S8PPuL7mSZqe3eeqd0ei0oXQ/NSNj5f/XIeG57fhue9kflwbJ6873PyiP8E/XjE+2xX1DsAAAAASUVORK5CYII=", + "expressionsMouth1shut": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACG0lEQVR42u3WMW7bMBQG4F8lYC5tdAT1CN2DQt1yAiEZgqK9gbcGHUoVGTz2CpkzxBmzWYaGnsBzWXj0IiNIQ8QKXx5FW7ZsuWiBBl1EQDb1gRJp8vHRoNaSofPOn8PnbTzNUAS7rAU7EDXVAt4BtcEp1l4/Y/3d2puF/d7sslyw+zduFkXeB3ZTI1M7UVkrUcNjvtjsX7iNt/xb08s/ceWd/rvftvlt5eGWx//S520+dW7Dam69h9U6VF5ue1jFJ5Wy6Sak3LnZduncxMURUaH8+pJrc06SPdI5R/Zq3QW3GVv2EsGY98fKeTdojZD3EYQmehF5L18rGl/jMMNdKvtR0Vv5G2nFCT5leCB7A4R+fGTOgN6QZtyeHk+Bt9J78R54dUz3GRY4GKZi9pX7O+f+Zxqfr9z7f0EmREkWWaRxGUwUTU4RuXGKSy4aCDL4+o0bp4nHkyRJuD/Z5/65mvSV+71KuzbDFF9GwIOrX9DAzVvxgx4T7mNSXcdEH5fzeYaDy7pcQeTO52Q+QCR1OQHy5XrxUEbkW4/omgew9IAyHdxVrQtoVSzdSuJkcEh2SIsUwXJ9qzjhXBBBGP6AcHupdmleAho9UTacQ4n3+ju33Qdrj1y4pTFntDSm7+5+wzMXR1rt+E8XjwXt+NR9m873+CpHq01v5ufat9N85UVb/s/3nxe/PV/az6P282vPebfvfOz+P3T+DP4EGY4rBjL+iVYAAAAASUVORK5CYII=", + "expressionsMouth2open": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAEj0lEQVR42uXWz2sjZRgH8CnBBkrT8VKQsOkchXpRJAhVnEgPuQhboW+SQmFXCgrxklIiKOjMbm0ClTZ/gJQs7sHum6HbImJlYUkI20Fx24MMKHhIGtxCBJlsWZyu4/v4vPMjZKaJeFPwufU7n74zTOZ9n0eAoVUX/q18bFjcEoRhF3iMJQVTJvRLGYhVYbCksLWEIRWtC7khF6IbKWFXCa3I71ZShRzec2YwfRZv9YzjQez1/0eRWphPqcKyAixqgqWAKcMFgNTEPJYSNBlYxISnCjyWwAQmrUvAJlRhUQZ7zFTOZTjDXGFSFPOE4+2Uqfwug16Fx4o9I0pgx1Uhg/n1gvJLFbYq8EixryQwn04JVAKr8KL8WxU2T+BYtp57VQR7Dj3mPwrywwokrkJFttRiBaxkSqhJcKEJ0ncnENfhM9lUuxUw86pAROhlJqWdNEuuQFLqdQzMCXrMazNivMNmb7MXqp37FPOu68nXYnLNLq6xYlUnpAJtA30FevTX8dkDO39gd6slir5B0ZehQ0ipuGQZb1lGdYv7Jq5PdTiltJ7XLPrNBa1McH+T+zT3143MqpE7J8cJ7st9f4vSl6h2So8/5H6c+xU4I2TVyEbIok7eNLiPcX8bjii9R2slqk3Rbyl6Fud+DTYIuUbIA5JJkHmCnk1zfwD4zFiM0jl6zL09x/0S905ln5CPuLeT3O96vl8VK899ru+9qpiEew22Q97scr+obIV823C8MhHyDcp9Ro6F/LqzPpXjIX/T8VlpOuSjjq9JQV8TpxxPxJCfirm+EvKTcdefhPxk0n0ePeSFvOvfSQZ4FiPHfz4bfH6h6/pC0GfGDNfvh3yEun4h5CPe+ochP+755ZCPeV4L+TnPZ0K+6Pla0Ne6nidPyKXiflg5nvwv/NMRfmeE3x7h10f4G32fNQa9avh+Lx949LzvlwPrq/7vSw8DvuR/D6QQ8KWE71sBX972fT3gyxv+9/NJwOtHvp8sDvp00/dXAh+c3va/z9cCH2i65+0X7fWgN739lfs44Octb/19FtjATdvbvwUW2PDzzNvvbd/fp3e5Z3Oun3d91lghiwb/M+H6JvddquXbVMPjvAkTri/j+U2+IrliylhEOg9b7vlThk1ai+O2/z6vbXNf8s4rBLhpV5LHSewA6JuuF9HvjdOzeGVOw3ejQ9M9PyX0uOdPdqo7OXw3aWg4fk/ChnH4fq36aXXzjtVF33Y8NuwH1xbWiPRQeriE7yYNLfd8luHo3v4fNVmXH92x3+vq4J7nyzI0V1sXGflM7iyxV5JpsJz1d2U4bTX+1JRT5fwAZrALe/1CgU59zP4Zm/7FDyDE0Bcdj7kaYbs4JFhfgjqugz3r+fNIhP2EI4fdgRvraWBOPzrESSMaZR+ABexdaDR0cPvdAoApRmENc3geGq0TcPvjPuZSFF7meRTa5lXAHwB9AXNZhC94LkLbEj1/C3NFhDLPq9CzMS9x/zbmIPlz0SrDfIP7NuaDc5Tv37g8d/H+frd+eU6LMHXkXDdqDvybuXH4nDn2j8dV58J/bN7+C/XpdkrjO2oQAAAAAElFTkSuQmCC", + "expressionsMouth2shut": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAD20lEQVR42u2V72sjRRjHpwS7UJqsbwoSTAZ8I8Q3lSMo9cXkKDRvhDshk6ZQuJOAQnzTEiJ4qLt37aVQaecPkLIH98LeZPFaRDw5OBLqJSg2fSELCr5IGmwhgmxaxM257uPMbu9IeznxrdLvy898dn7PswiGporO+Tn/L/KRYbiF0LAGiUXwaeqhJ9EGsI4Gg8+6DhoSpYpyQxqUmym0qZ3pUY5W1lFOjBkfpM+LoZ7zfVB7T77RcEvwiI7mNfAUGxwNbAJ9ALwjeDiFTAJeyIZHGhxhsMHDSxi8MR1lCLgjtnZM4FBwzcOK4DHfd1O29geBhgFHmhtXMbhRHWUFv7qg/WLAGoMDzX0xJvhECnEMzsIk+c2A1T1oEueFN1Rwp4Qv+I+I7DKIXQJGHL3EwEmmUAVD30T4uz2INuBTYuuPGNgFHVEVetlxvJH2knlI4l5nQ3AqfMErcTXa8RK3vVeMzoN1wbuBT79Sk0W3VPRKRoMuMWhbwmfQ47+OJrbdwrbbNcr8OoMaF/4KdCxaLs051luOZaxRncGO6J83oFPg1YLp8K/7nI1xwW9IPw37lF61sotW7pg2Y9JfCfz9Ar/F+avc3OfNa7zMYFT6eTigdNGaDdFMg74phmIQlv5t+KbA7/NKmZsR/i3nK8yLSr8Iy5ReofQhzcboNKWCT0h/G5YLXMTjfIo3OW8wd0r6c7Bcon5mf6cfUZpmblL6m7Cc4ANpMKcg/RwsJ+lA0sym0jdh/Yxvd6Wf0dZP+dOsbfm+FokO+jusxqWfJZGJ0/6S3z8n8RP/Ab/r+zd8fxbHfX/WytOMJX3F9ytY+l1uFtrcvCZ8NeL7VMVhSr+kuVLKysSEHwkHPsOrvBLlW4nvC+a68Mfjgb+H12g2TPPJZlKcAJ0evxD4aeF/PsoPo2zKbIv1onwwn3fIGp1P0r0NYyPXs2gaXQzm/xKp83vvV4xPjNU7TpfXUTtY7yR5eOVykeJdvDvnUDoz0gr2Z5LU72/9WSENcnDHfa9bD53s5yTZWWz1s+SQdOa815IzISfY/9fJfqv2l6nta8fbEI/WleC85j8kneqI+7N4dP0fAIVnVKfkn6/gesjbFI/U+QL00TpxE/75fkyOQyHvJ/Hk3Q5cX5rRPP8+3NPIkaJ4H4AD3rtQqzUguG+XAWxVgaLg8DLUWnsQ3M8twbECFyRXoG1fAhiT/oLgRIXPJFeh7agn/i3BNRVWJDeg5wpelv7bggN+XJcWPcFvSr8t+GAde+xffLruyfd1t/p0nQx5+jPr6rPq8D/U7eF1fuRf/y78hvP/7Dn/H/G/AcCdgHhcio2gAAAAAElFTkSuQmCC", + "expressionsSad": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAAkElEQVR42u3TzQ2AIAwG0I9w8MgIjuJosoErMQojeORg1BSD4c8oJzUphwYeCTSlYKsOA3Z29tfc9RQXlbvtKM4ydy2S5a3DTzTGZ77CCzB8w1vzb67PVZ2v3oX7lj1zI6q+ns2cugFEzQGEbo7dkavSLZSDLF1L2iudznDnBZGPIaR+/JfSJ58Uvzs7+498B3cE819ZIE/TAAAAAElFTkSuQmCC", + "expressionsSick": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAApklEQVR42u3TsRHDIAwF0O+joPQIbBKNZkZjFI9AScFBkJucET7bcZEUouDgFSCEhDocAerq6j/z5HjOc++r5Tma3v202546toXHcs0LNgHoP/xu/Lfzc5Tno3/RulV/5p6GXjAPPaHVZiHhkTsgO+GBeyhJ99QuiNJRg6mrOL+YdkP1S+/Z1owXRJzcKcAk3fHGCucXxc+Td3nLoHE+ofWjrv6NvwHAjOwKGeyV+gAAAABJRU5ErkJggg==", + "expressionsSmile": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAAkklEQVR42u3TvQ2AIBAF4EcsLBnBURwNNnAlRmEESwqD8pOYAGeUSk2O4gJfQeB4YCeHATs7+2vuplg3WbsdY12H2rUolreONNFQz9wjCTB/w3vP392fqz5fvQvnlr3wJaWl9Zw31XjOOeEhao5wHaJp0e5vIR2G1h3CkMT5oyvCDSCo+/rzM1Z9MILfnZ39V34A6BLzXyhnhjoAAAAASUVORK5CYII=", + "expressionsSwearing": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAEtklEQVR42r3WQW/cRBQA4HGN5B4Q7rEHlLlx5hikKMM/oagSV1S4pNKS2apIERKq/0BgfwiHTBQUH4Buf0DReuWqPq6ND3G0s/N4783MepvsFVZq4/3stWfee34zAvZ+jPjP3dHf5Y7deP+Tjl/r0fs1e0XHf+/40LO3RG933DbsRuHx/GbLZ7dz9ssL/NJsvc36gr2jb10TXajG3+eWvrl8eznMvW8+mFClwaz2zDfD8cyjj4Ok+20WwYdkHDteso5eTca5UhxiPKdCRe9gqpvoQsyi162Qq+BOiDyEFxpzjMeO3QqR0W0l/lemcIbCPnhv6SGvJJQokrwVIiWnWZwrqGFl1Y4L8sdPdA9N9IQmZsgPK4W+4ftXIr+k2eH93RdO9ninXW9xPO45zOrR5TL6CcxKKproTnFY3ImWJVUI+wN56XyE3ORAFlAl3vPiytHMQLpToaTDabLLs5eOZmBzp6YO55p7Vya1HIkcFFhVBW/V23Q4o5nlIDEzg5DBf03bOUUihxwH6YIPcpZznaOXcIX5C57L/Cr4JQ3soQx5+TQ7a8klxhBnfZDHPGZ55d1itJ3Koh9LrD9ynjQ+xddJcq6msHXM/rbeqOTcWEbeN3+B2OewwhTvc6y4R/u8FXkXvLBp9DUIPutw7DYx/CuOW8Wlw461x6P19ZNB9Er4Iua4hdclehadg+DdCF+U7PoyXA/sYusvtz7NKz7h3T/XYm8Rn9MPlJ9XaALoRnwpeKTsJngSPQ/xl3c8C+7jhZHxfpgG16PT55Nkv6fBB2oW3GO8J3e85PCMTp9b362EePChd767IU7vuuWWIJ7gudErbnnYQsQjCpwRjpPI75SiwhAP8Z82wnLeHMVE8gPIsT+0igsDY1hJHtFHFFAjOr8mYIzYrfiYAmpEDS0XkvKNCXhmmRFNNYCP0cA+jW4mmts49lRKEIcoNaL88TQ4XpvyiESCfn1wrGHtjumh0vgpixdGvP6OHABbq1P46Db49VPvC2raVkJNPkVPj9h900Y33uv8CLPSBJ9BWXlfuiNweuVzU8yguMZhCoyPPQRQC5+DfAayMGKCPkye488v6Ba9UxKUpBFhnB9zahf4yN5p6Y4VJZPyQjyR6J07VXaiekMOLwD+oOaOjjgMun5H8aGr33AQ4NZa3bWQXVM8fdoxdAUM9gT6pcvmoy/I7eQZ1Ffu2/k0D75YsZ+mUBZOF34dwc9vN+TUwMoSBxv7hltj4OZAUC+dVt57rMBN9G5wJyq+p+A3ERoX8KH95yS+17jWOY3NTtPStWy/D471ejPI4F3dPo19SbFjFjA7fdk1O/sW77SgFru+qvwihe+Y7Oqd66fYOtzXeFCorh3dUTNy9MCDrW/Yqa/iufdHuk28W8dt0Ht1yOse+wl5or0/2/bbzWdcxBfYHy7gfTf6K37P0b9R0NSjO/avwL7DIDXR3Q/R6d0er3eJ3fXx/sq79E7rIWxW6HOrg/+O8+LWaKkeGlyTvf/MueCGit5jJXg/j/tBl7Gvgv+y3R2lHLeb4OMO7CfyKqM4qF2fkTf8Mt/z2xW7vrsvXRe8Nbq3X13TfkUk93zgdpLt3/caud83//9+e7//C0qd0Owbh6PaAAAAAElFTkSuQmCC", + "expressionsTalking": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACDklEQVR42r3Wzc3kIAwGYEesxJESKIXSyGgby3ZCCRw5IGb5S7DBiRTp05fjowkwxPgFvuxzwK855EetfhQHO3uoDNvs0B9F3Z++Ud8BTJtEY499gAQgsLvz/dCX1L2N0kAPj/3t+oIc7vtsbQXD8S75vrA6vBye6sqqx2vWOpA43ZPNdnC6E9hj+QfVd0W+SRm1Ohk+m2oep2/pZfMgqMetuZPUEzQ/9FQMeUHFdzMXiam+lJDTxdM2u1fFo5w9S/agZk+iuNdLdW7FnVl8r27Xai5+rFXubPadcZP9s7ovLlYP+t6TXD2qe49q9STvPWjm+IoHN4z/fe+e88+DW8b//aC/XM9P7cPb/X/7fd/Wz219bkw964c6vzsvB3O+7MN5vDu/d+c9rP2helz+WJBPfeauL619bG/97ZgX1PuhnyZOvX+GaYLSZ1sfphM4efZtOsHe+/b3ELQNGzYvwpULdAK3jTzCE9Rw6vkl8DAa5Z1FcWRRPo6BWrJeecrm5pmuI3G7+/OGcAZ09zO/c55LkvsHQL8VGOKxDBTWe0KOaYN+PjxB+dhXQI8Ez+W4A6z3mai/41aAPGhcYNhxQaLxDS5s7PggDHcWHxzsu+X8IHWNPG6sf0j8I/eSdUHiHzkpurHPf4C9NybYWEdXr+neqFj39DBd7oC/r9KzhOpE8T7fpeBqRaxH+8v38P/FUimZWI/+PwAAAABJRU5ErkJggg==", + "expressionsWink": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAAqElEQVR42u3TsQ3DIBAF0B9RUGYERvFokMplVmIDr8AILlNYJEARKbl/kd0kUnRXwSsQ+nxwp5Nhbm7+Y9/O3FfH/bnd6QnxzYvjnsYCmF69AoH5dtR9oV5DnZir9//sR/PRctbexXr7HV8UnxW/KJ4VL1HpwyT8OjwIH80p0kczIfvTaSWe2kHp5IUXtPGz8Fv3sAiv3VmeGXDM21eNNP/krIfm5n/hD5hN/hkkU+lAAAAAAElFTkSuQmCC", + "expressionsZzz": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACK0lEQVR42sXWPXLVMBAH8NV7zLhhxsNQpHRBQZuOUiXnYCg4Q5pIVJQ5Ategi6m4hjtad7gQUvQt7Xo1QxryquT3/Oz/rtaWwbGfFV7Q54HDPHCYOLfgPyOHkYvnufg6OP7nwD8P/N0/u/kvfj33eR14/IJzt9Glyb4DWct2/MK5v4DkXAMoztn1jR0VnBsaP/txmqzkp/jZT/FbfyTneuBAy0pu+XkO8fuydpn9QGUZKL6jsmLm6FtflhZ2aetey9rgXhTv44dbYan3Y4vfOYofRmmp8yaQz8lR/M5RfN3Og1al87U/f3BZvQWiXirQ6c/msrRnRX5bXGlwnb/O/uh/0ftF2pTQAXGTKrWx+Ooi+HXqXVeHX6GLE3IV/P3JL8WP2CzOl96h+D50iZ4PKuffmscvOA8TpyzcppVS3b5gwn/xkhrQfmFcvqT3v2Qf2cKPQFhBPA2l0HfEdR7KV8TDigS/YI+dN2loeo8dZn2OQ0z9GPqSXSGPHXuGx06ynp4JIW7vcTDzI7D3uF4GwJ39Y3qaIA8d++LMTPf30JkPdN9/SH5DXUvefQoD3X3ffBq4GPingb8ZueVcw1v2fcYO3K1X3vn90Z+H3R99E9j90S8ruz/6W4XdH90m+PexFvMR11tiHhL3p8Rc0fG2xgR0vKkxsR81JvWS84fCXi58KPxeIR5y4cSh+B/i37N/I54L2CYyD8Wv/LpsZP734orcF6lf7vcLv28/AaqW51qc+IlYAAAAAElFTkSuQmCC", + "eyesAngry": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACX0lEQVR42u3Wv27UMBwH8K8bRAakhhEJUF6BCRhQI96kb8BtIDHETLxORwakXsXAyAtUOksMbJCJC7qrw++fnYNgBpYy9Ja6n7P9dezWv2D642eNG79u34M+Tn8P3G7UpY1OHNaH3cM62VCgZ4/artgHbbfs1sfl6Xks+UjDuKcsQ0b5mn2QdpRvfSuzVexBEifPC5Ivp71jX+sKA3WN9hRg99JnGmjYvlL3Pbu2R/badoHdxrKNje1GR25jI3ur7YE8JqefQ/KW3ObkcUNnWX/xvWVNbyivtzU0/+C2humC3Jrxxq/f64K7gqMveFvweuGjuFt4YL9rAQfu2R9YwOwR8lwWMPuovna/eVAfNGB2fyRuT5A94lj3TQOyjzhR14DsAbbPGpDdV+YakJxWn85FApKP6JJLQPKAfI4SkNxX2SXAnKafz50DzGn6uT8HmNP02XeBAsxp+uxbTwHqEXdm/woKUB/xcPZLvlbVA45nf8d3srrH2z77GZ6iFY9wH2Zf4Rlq8RHu83n2U7yCEw+oLg799BGes3tULntcw9/jP7tAteAWNgeO++Ij3/6/Om9RCEsf2P3Rwvn/JuD2wifxx0vn9eP7odP68US82tEO2vobc75XG/V0366Al+Ldjh549jPghd7DV+S9ON/ztP/f9J6/WqPu8/1/CbdRj3Je4hWfb3VudWTF58t1hPttfdNb3XmP11p3+Dl34STVqY3bWp2iuraffqS69mX6ZHWN62D7MdXBMXZWB7luhi7XTZfqZqnOlupyqY6X6n7pPaH0XlF8Dym9t9y81/2H/hNF0RpVT4pRTAAAAABJRU5ErkJggg==", + "eyesAwake": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACCUlEQVR42u3WvU7cQBAH8L9lCVNA7gGOxC+Qgo7iohyPkkdIB50dIdHyCHmFK6nAVClpr4jESbQITMNZwngzMzvjPT4WRIREFLiG4efd9dq741m4B38V3v21vQX9Ev//jOOBd4kxFoe2YS+hjbQrULB3Pk7Zax/n7Nom6YfnvuQNdeOWMg3pVWbstcSdXC1zGS1ln8kdXckTkouuTdgrP8MZNe30KcBeShtXU7c29V4W7D5u2DN9C+zal60Z6NsYk2vfjj33cU3emdPf2jwn1zG5Xz3Wez3ird7L/aD7FTqHwV+4zsEdkWvYvUXHfa/Es7veQFy3eHCoJ7d9Zu73vrkAz0cSITilyVfxhi4Ep9TIdP4VZ4g6Z489l8Tq0saed0J9vdOYadH7d85TcQqyw34cTreEXYIT85tKE9Kn44X5dZmsmH/G8lbvSHcb79kUaxvmc6S/ikrc7ePTyPwK2U7BuUg5OcGXYfAlmrR/rgnWez/DcnKo/g2bq8Gx4Hh1v5KXbvPH8Cmf02KY7wOj8D6xZOs7BTbC+8cH89/A1sJ6fTQ/X1gvWt+R+Xxhfd025ubXVdgP7iC9ML+p87B/jt3Pfh8Wbcivy7bo9+3eaXD59tl+zv+T78YLfYef+/2P1ZFY3YnWqVhdi9XBWN2M1dlYXY7V8Vjdj50TYueK6Dkkdm55P9f9g/4H3XgcZrwl+lgAAAAASUVORK5CYII=", + "eyesBlackEye": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAB50lEQVR42u3WMU/CQBQH8Hc2UkKinZhQuzO5MWACfgMH2P0WjK0xcfUrMJpOjmzUya/gQGITV6OdgITSeu/u2rsebWyCRmK4geGXR++4Pu5/kBQOH/a+Sx4AHdamIwPZ8Ig5OLqH3G3dA+6W7r6Bn67JPBJzodjsaQZz/uUeW47DZifMXfHMJImJWC16zOfCJ0cGd9ehLtaMpZEppkdfQtvzvDEubGmJ5faoh2RIxwCnXNri56EHDQ+HSxcUpm5T95tYP+zbWMd9ie62Wf3Y0p2VD6+oB47YVos6sHLvwdSc8PqB5vEBr/fobw3Etsboh7x+qHtJfZTWE80bov5my/qmqL/83/XYE8wBsoZDv38r9NiJCn0d2k6Rr3xzWuQLIK/c7WTtw2mSPDH/APhMfeWS49RnUB9lDsZd6i9w0kl9AcazI3wCZ93U52Depv4IFy3pNUP6eebvUCdT4dfQP5IOisOf+5yeGnL90PrOF4pPALpyP6Em9xM6Re9rBjAqcvm+yt5vtX6Q/ZPvT9lvWj9n/VnWz7/9//qh82er87DCeVt6PivneaXzX80LNUeUfMnljppHak4p+ZXLNTXv1BxU8jGXm0qe5nNWyd9cLit5ncvxCrlfdk8ou1eU3UNK7y37e92O+BcKz5DpA7xJVAAAAABJRU5ErkJggg==", + "eyesBottomLeft": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABtUlEQVR42u3WsU7DMBAG4N8KUjfCjiCPAQMir9I3oBtIDDETr8PIgNRUDIy8AFIjMbBBJhrUEOOzz04Gjkos7ZAuvX7xJa5z8hnm10+J0bftLexH+d8Vxal3FyN3Dh5DrsGDOBUoyDsfJ+S1jzNyHqPi7SnXemPTaKSbhsvSE/LaxZ27qjN3t4S8ck80mibkLppWkZd+hpUd2vG/ALl2Y0xt09rEuy7IfdyQT3gVyDmXrEl5NXLrnNuRZz6urXfB7XcdPLPO96S8Oudn/eEtP8vc2OcVPIf0H85zMAvrHHajj777XuW9q4FnT9GbLo/emq/ob+Y5+ro6j75Uq+grnRbBH3Ad/R3JPPgMR9FfoJbsXYX96Pc4+GD/LnFbBL/D6UVwrR6jz3B2yb7W6nUefIqrk+BIFgOfDlwFPy6hD9k/sYdl7+gdW3c7f/Tzh5pv8hnQr497F2E90a8nkqJffwzWf1Jsel/S+xXqIeX6cfuqrx+/33K9Off1xvuwr0/nvj7J7T7v69nv82rT/i/1EanviH1K6mtSH5T6ptRnpb4s9XGp70vnBOlcIZ5DpHPLeK7bQf8By0loyHh24uwAAAAASUVORK5CYII=", + "eyesBottomRight": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABt0lEQVR42u3WsU7DMBAG4N8KUjfCjlAeAwZEXqVvQDeQkFoz8TqMDKi0YmDkBRCNxMAGmWhRg8OdfbYz1FRiKUjt0usXX+I6J5/RrvxMsPVNewP6KPe74jh3bmOU1iFj2DVkkKQCI3bj4oy9dnHBLmNUuD3nki8ojUfaadgs3WOvbWzsVV3Yu2XslX1iq3lC9mLbKPaJm2FFQ438C7BrO6atKa3JnOsRu4sX7D1ZBXbJZVvksholueQa9sLFNbnxTt+194Jc7sl5dSnP+sEbeVZ7Sc8byRzyX7jMoZ2SS2i2vvV/4VUZXXW8eAi+MGXwpv0M/to+Bl9WJ8Fnah58rvOR91tcBH9Ddud9gIPgT1AzcVNhN/gN9t7Fvya4Gnq/xtGpd63ugw9wfCa+1Opl7L2P80PvyKYd73dceTcT6H3xD+zgOTqiY+NO80ecP9R4nQ+AuD7IxnE9EdcT2TCuPzrr3xuue1+p97uqHnKpH7+vUv2E/ZbrzTvVW9yHqT69U32yu32e6jns8+rH/T/VR1J9J9mnUn0t1QdTfTPVZ1N9OdXHU30/dU5InSuS55DUuWV7rvuD/g1mT2jIOjnq9AAAAABJRU5ErkJggg==", + "eyesCrazy1": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABwUlEQVR42u3WsU7DMBAG4D+K1HShfYACeQW2DkUqj8JblM1BSKw8Aq/QsRMNEyMrAxKRWBENS1OpqYPPvqIEnZGCkOjQLHW/+GLXvuaMSrxS7P2/vYS5Avc9o3bfuW1jbB3chzwBd+JQQJFr1w7Jc9eOyblP8PV4ijW+MmHU007DRiUReW7b2t5NYvu0kDyzI1YJTcjerMqAPHUzzExXzb8C5IntU+UmrAydJ4rctVfkEa8COceSrfq8GmPjHKvJY9fOjeutm89867FxfibF5WMe6wcveazq0oyneA79X3hcuSndG+cu2vlHqUR/rG5FvwsXol+gkFxnGEm+SXEk+ToJeqIjvJa8QPigBF8iupK9E0r+hm4wFx075UvzJ1ItvAAiJa4nOvL6o9dmv77tr0l2MR9uXsX80aoU822Tx0rKz3UazbWQzwWCF3Z3sb8DC8mf0Z1I/oTDoeQzHI8kn+J0IPuJ6Oc4O5AdO+VTYNDGZ8BIXk8M5fXHpM1++fa3lg8Nr+VPw2v51vBafjZ9m89/9B5u+/731RFf3fHWKV9d89VBX9301VlfXfbVcV/d950TfOcK7znEd27Zn+t20D8BnntiOLdBg8cAAAAASUVORK5CYII=", + "eyesCrazy2": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABxElEQVR42u3WMU7DMBQG4D+K1HSBHqBArsDWoUjhKNyibA5CYuUIXKFjJxomRlYGJCKxIhqWplJTGz/bLUl5BhUh0aFd6n7xs137Kc9Q7CfDzv/bK+hPYH/n1O5YN20kxuH6kKdwnVwoIMilbYfkhW3H5K5PsBqeYrXPdBj1NMswUWlEXpi2NE/T2IwWkudmRpXSgsxDVQXkmV1hrrtK9y9Anpo+qtBhVWg9FeS2PSOP3C6Qu1iyWcftRqLdxUry2LYL7XLp+rtYeqzdjUlxReLm+sYrN5e60PMJt4bOL9ytQd1pt4tRkvPrF9alqFhfFLHgfJ5FY85LBM+cvwETzp/QHnD+iIMe5yMc9Tkf4qTL+zHrZzjd4x1b5UOgu4mPgD6/n+jx+4/BD+dlU/3r+b5Xgs2HB3XD5s9tOGHz7Rwll58yR5/L50WGw5rTWMbnabDPOsIrzkuE94LxKaJL3lsh569oB2PWsVU+1S9nsYGXQCTY/USL33+w++87r7XzXflaPnx6I39q3si3mjfys+aNfF75H72HN33/++qIr+5465SvrvnqoK9u+uqsry776riv7vvuCb57hfce4ru37O51W+gf2n5iOAicusQAAAAASUVORK5CYII=", + "eyesDisappointed": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACl0lEQVR42u3WvW7UQBAH8DGLblOccpSRCPErUEERhHkUHoEKqGIjJCokHoFXoKQipqKkpUDCEj1Zqlg6x2b+83H2GQ6JKhR3xZ39u/2Ytcc7puGPn5r2ft3eEX8yPW9wvFKXYyrEydrAK7JG1pWohPd6HOBJj3O4tck2w6Mve8vd0EnDyPm7ivAUdOASItOwsDc4bEOFgOhJRKMMXgNSbHiEPmtleoJXGKBZJe7WhU6mr0q4TJi38Njr9HBtUXQ8Mv8n0zcFu45Y9vB8kOkTew/n7vhNvFAsIOXsFhn6pcKidkd46imad7JCPnvB85XSYuhW5uitLgvYOGZTlwWIyxXk6D6yS8QcnjtOzNHEXTqbY0h3mcwcIbhLcOYI2T1NPYzeLMd5X2ej1/lb9/6MRq/ChftV4pjdiS7d1zVnpDknz6n7JbLNnJPnjvsPZJt5S9mh+1ei6J4ovHL/QkfBvaHwqTR/T8eZe03xpfs7ekDuFS3C6Hc5Z9SJDrJz88f0iAp1PDAT5wWod3Nfqbdzj+rp5rYfBPVmue3LTL2eO6lX9/jpHeOn23QmTk9nXj2EnxBf8zheHzqtT+DH2ZpoMV5Put8cwo/CuqLp9X+WFvBb8areul8X7Q04L7uZ3t/sGxM8H55P8yGe9+rF8GGaP3k5qJfD52HMt7LjPBMfhp/dmJ9vvnNewpGn03xGHsODbZnmss3B4+/e+nM6881zOvN+79fvfr90Xx3v1z967/mg+7zmQ/4Xt7yyOqJ5lXvdYde6o154nULtkjqlVbvwuqbmOSl1rSotV1EH1aUO1hqE1k112tRZrRNaBa3OyibPe67UZQlI67LUcd5DZUJpo3V8V93f9Z6w671i53vIrveW/Xvdf+i/ANCjCZtu1XwRAAAAAElFTkSuQmCC", + "eyesDizzy": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACP0lEQVR42u3WvY7cIBAAYCwXdMsLnOw8xhar+FXyCFuelNOZjaVsmTeKbF2R18BvQOnCgswwM+AiJEoUKT+6bY77FuxZGBhU/OZnVq/+p31X8Gnof4dtQ57aakiuuA+6VdyJhyo1ogdqt+ie2j0692ny43Es+AbDsGcKI42yGt2ndkjf2j49rUV36Y3RYkDpy7g36DNF6KBr4F+h0G3qEz0M21tyO6JTe0PXPAvoPBZtMzwbAziPDeg9tT14EIe/XrwH52fiOD/wu77jO78r3uB9I8dgfsE5hriAczP8Y74d/NPBXfFgDm6LbwcPqrg7OC03+TwWp2Ulvx3i8QNkMHvrm+zuCbM8edAz7BBxj1lObjD72RfXQ8Im37vGa/Fphgwj3y4GEon9PmFI5I8DhMSutYPVT+6vz2YWN8Z24n5rnPjJKKPZITY/kodTp/Sd3K1OPYo/PPTtC/m6LP4yiJ+HRfxl2h+Kv1+z3z8f/N26in88dX3xa3F9+rG/Kf7h4BdVfC7edcqJr+4kDvPQSJwwD53ECfP2RX6X9/tTdt3GSfw6bDIP8X6L7STr0vvzkNfxrLWsY2uvY173PP97p/L8R7ept0byxLZ5vdxzGkV55cxS8jBug+RhjFPOW4MnALnFA0ryv8GdwfnfQy/ZLyrnJ57QOT/htNTiO57m4r7kf1Ql/2mDseMGC//D+fObzuGfPf9rdaRWd6p1qlbXanWwVjdrdbZWl2t1vFb3a/eE2r2ieg+p3Vte73V/oX8Fk+c0j6ggguQAAAAASUVORK5CYII=", + "eyesDown": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAB1ElEQVR42u3WsU7CQBgH8H/ThLJIHwC1r+DGgAk+im+BW8+YuPoIvoIjk+Dk6MpAYhNXI3UBEkrrfd99X+vgkeiCQ1k4fty1R+/j/ofqx9cMrR/aC9hX4D5n1I6dcxsjdkgfcgPpJEOBlLx07ZA8d+2EXPoE9eVprPWNHUY9eRo8ykTkObdL/tYkfLWQPOM7VoYmxF9WRUA+czPMbNdSfgXIDfepcjusCJ2blNy1N+SRPAVyGUu2ieVpjKzL2JI8ce3ceqlu33P1xLpck8blI7nXHi/kXtW1vV8qc4j/4DKH6sm6NMvWW2/9187/bXH6b6t/Fmntd2+Nv1T36mVaNP4YLtV3eZLWfoW1+nYWTdXLDEP1NYJX9d0MJ+ofwFJ9a4Ke+gLdce0Ib9XnOB6orxE+p+ITnA7VV4hu1B9w3m+8EzZ+Vvs7usFU/BIXR43jm+PgvrJp1Mwf/f0e2+eDKJV9dQK7FrLfboGO7rdzYFC7QU99AYzZ7T7v1svt87xesv+79XXO68seunqQHOF6oByhflQ/kjtcP5Q7lFNUb5JTXG+cU8bVp+Ya1Sfnms1BvrbkINUz56AvN30568tlX477ct93TvCdK7znEN+5pT3X/UP/Ag/3YjiGSiORAAAAAElFTkSuQmCC", + "eyesEvil": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACf0lEQVR42u3WP27VMBwH8J+xVHcpOUAL4QjdOjyklJv0CGztFnMCjtArMDIVcwFYGZCwxIqoWfoi1Y35/bHjNJAODMDwnlTV7/Ns5xvHyS+QfvtxsPN/7RHwo+S7p3Yjzm3o2CH3IbeQO+WhAD35KG1NHqTdkuc+apqexqIPOIx6cgweZQ154PbIv9qWZ9Pknj1ZCsQ/pqDInUT32HXMTSC3csoBg0adT7Yntzx4IDcy5Sm5cnyqZEMjJ+07dB04xEguLR3QRy29RpxbekQTWnSTj0beSYKBPaeb3LfksUkS9BUKJ3NdbNgl6OS2zy5BJ8clJm9zjPfoOdgoPpi547fsErQ4LlR2CVocFza7BC2OKYpz0OL4pbjvZo6TFueg2Wn9inPQ7NSe+uvqYdb/g6ruj6pfQXXX1jwXtG+yW/NuOl9Puzw7qC/F7xztcnHcxdfFby2Y4gPsn0/Ou188wNFJ8S08UsU9PN0UvwEDxR08P6y+h0HFLRxP/g32Mag4wOlBdbql2Olmu+dGfFi6Fg9LV+J+4QrE3bOF257dns38Bqc/a8lH9QbgcO4vG/Ko577FmBeGfDBvATaz9dyLmjw0nwBOZuv/eFTkvv0McD67Xk+SJXf999n1wuu7Se4FusVj1euL+2GbPF4a/Lt1dT+kK31NDxd65NyF2f75mC7TQI63UB/rfvsR+xTJcbu8/lqd97aSZxPt+eL37/eFl/tl53/Xm1+vS/wDH0326TlPdeMB1znDVEfoP9Wd7FPdoXFUp/Kxap1KXKdsnrPWteS43vXLOohEdbNb1s3EddM3yzob1UN1ea2Or9X9tfeEtfeK1feQtfeW3Xvdf+g/AbKCHZJ1IQy5AAAAAElFTkSuQmCC", + "eyesHurt": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACWklEQVR42u3Wv27UQBAG8G8xwl2cFvHHjwEFuhNvcm+QdEFCwps3oqSIFFNR0lIgzhV0ZCtiFMdmvp1Zm/jiFDQgcdfc+ne7O3u7dzOL4dZXjb3/be8gL6fPDduFemxjHR3Wh+5hnWwoUNF7bWf0oO2Sbn3cOD3HircyjD3jMuIon9NDbPfxU1/G2TJ6EyMOnguKHw6do9e6wka69vYtQPexzxBkWJep+4qu7Zae2y7QbSytLWw31uI2tqeX2g7ifXJ5D8lLcZuT48LaYt3hncUaTiVeZWso/sBtDcN7cWv2e/9/3PH3uusdvdj1QM92vaZj1xF9PfdOvZh7wEtxn829dly/BfjNkdNbDTB5h5Lea4DJA6q4Dxpgcll9dA0wOXJ1DTC6TK+uAUaX6W2fY4DRuTnqMcDoMr15DJC8w8PkXxkgecAq+ZYJM3mNIsU9AyaXrHpufsyMbC6Z1W1t/Q2zqrlk38ML9euaGdlc2s+PzL1jylaXjPziRP3KOzlkdSbuV8/Mkcni1AM22EzufKZeo4Z/pP4D9+VJHQ8k8OjAJ6zoj/H0pn/BAf0Qb2761t+jw/Uzl58dPZ97q17OvVevhg0wrh/ufPB0OdroMa+qN/Q8bvqJuedRtJaH3wJH6tfiVczDzPPvgAvN87L/eTXm/888r+hyXgdWF+T5u0xqdeQYT7SOsN+lLyqrO2d4rXWH//OrZpXq1NZdWp2SutYNP1Nd+zZ8tLrGOlh+SHWw7ddWB1k3JWGkuulS3Vyqs0t1eamOL9X9pXvC0r1i8R6ydG/Z3+v+Qf8FVocQ2WNhih8AAAAASUVORK5CYII=", + "eyesKnockedOut": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABBUlEQVR42u2WMQ6DMAxFjRgYOUKOkqOR3ozehCNkZEBJ/W3TLnWlVlVLq7BgXvwTk8HfVO8+MzX+bb4RP51+L4hH5RJTFE6WA57IkkxKNIEXjXvwrHEAt5zuuj20zFeWIVPKEFUawLPERVZTkN168EVOrAkFyWLdOvBZK1w4tdhfEHiSnJpZtvXK0wSu8Qo+2C2AmxZsHe02InPTFvCgcWZeds7vvPPA3PaELkc76wHf7Kx64vMmq2F8gVsN9czcwvLvfLjxNTZ+DF60DQiXRhA+w9v9H5b/Qj95Ux9+tv97PuL5jutTnq95Puj5puezni97Pu75vjcneHOFO4d4c0ub6w7IL0FMhO6cZXtmAAAAAElFTkSuQmCC", + "eyesLove": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAB+klEQVR42u3WPU7DMBQH8BeMmgXUgaliKFsP0IExx2EEiQPEnIAj9CrhBByBHMGjB8vB//eeGw+4EhVSK9QudX/1V2L7PdP042egi5/aA6VPI79HlJfiXKaOnbQO3JJW0qZEPTxK2cCdlNdwrdPsu0fb5D41Q02eBreyLdxxOfK/ds29GfjII04WE+I/p9DAB5nhmKpGfQqCW64zudQsGHHbw6Xs4a2+Bbi2hfmlvo0uubaN8LWUXfKYPX277Ovk2ifauU7HOuBBx5re0ni9zmF5hOscpo/kWoz/29OSp8UXJyy++tBOaeuxR+o8ZbevMW099mB2jnp1WgXaiHv6HJtOPNKNp624o6eh2YkHWrzQSnykraXP7OaBbrOviJ7FPbb8tfiA8qbwReGP4nx4rnp2Pmt3hZvC7wunws1pnZ+Liudqj3ONS/o+ETYOe5Two+uF8JPXF33m9UVIy/uBQ5HsB36UvK847Om+wlDqjkOduMVQ6ug0788BQ6kHjnriI4ZSjxwlxR2iZN7naKvuMYXsFtFWPGAK2UdEZz0XGCq7Q3xUt2Z2T/M5Sodk76GZHWE2O8c4dcS4/XlsZ/dd4e+zh77wr9njucaTP4rDv43/tTxSyzvVPFXLa7U8WMubtTxby8u1PF7L+7V7Qu1eUb2H1O4tl3vdGfo3+S3L7VKZWUcAAAAASUVORK5CYII=", + "eyesMiddleLeft": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABpUlEQVR42u3WvU7DMBAH8L8VpG6EHUEeAwZEXqVvQDeQGGImXoeRAampGBh5AaRGYmCDTDSowcbnnJ0OHBUfUhmSpddffLbruDnDfnqVGHzT3sJdqvteUZx27mPk3sFtyDW4EacCBbnp4oS87uKMnNuo2D3lOm9cGrX00/BZekRe+9j4uzrzvSXklR/RapqQv2lbRV52M6xcU8O/AuTat7G1S2uTznVB3sUN+YhXgZxzyZqUVyN3zrmGPOvi2rkJ7j7r4Jlz7pPy6pzH+sJbHsteuPEKnkP6A+c52JlzDs3gv/Eq712teHYXvTF59Na+RX+y99GX1XH0uVpEX+i0CH6D8+jPSKbBJ9iL/gA1ZzcVtqNfY+eF/b3EZRH8CocnwbW6jT7B0Sn7UqvHafAxzg6CI5mt+HjFVfD9EnqX/RVbmPeO3rFxd/NHP3+o6TqfAP36+GcR1hP9eiIp+vXHyvqPinXPS3q+0n6Q9o+036T9Ke7n4f+e/t17+Lvvf6mOSHVHrFNSXZPqoFQ3pTor1WWpjkt1XzonSOcK8RwinVuGc90/9A8jSWjIB4EzpQAAAABJRU5ErkJggg==", + "eyesMiddleRight": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABpklEQVR42u3WvU7DMBAH8L8VpG6EHaE8BgyIvErfgG4gITVm4nUYGVBJxcDICyAaiYENMtGgBgefc3YycFR8SDAkS6+/+GzXcXNG8+GVY/C/9hr2Uu33guK4dRcjdQ5uQ67BjTgVyMhNG0fkZRsn5NxGhe4p13pl06ilm4bL0iPy0sXG3dWJ6y0iL9yIjaYJuZtNrcjzdoaFbWr4V4BcuzZNadPqqHWdkbdxRT7iVSDnXLIq5tVIrXOuIU/auLRuvNvP0ntinfukvDLlsT7xmsdqTu14Gc8h/obzHJq5dQ7N4D/0Iu1c9Ty5CV6ZNHjdvAZ/bG6Dr4qD4Au1DL7Uceb9EifBnxBdeZ9gJ/gd1ILdFNgMfoGtZ/a3HGdT7+fYO/Su1XXwCfaP2FdaPcy8j3G86x3RvOfjnivvJofeZn/BBu47R+f4c7fzRzd/qNk6nwDd+iCadeuJbj0RTbv1R2/9R9N1z0t6vtJ+kPaPtN+k/Snu5+H//lvv4a++/6U6ItUdsU5JdU2qg1LdlOqsVJelOi7VfemcIJ0rxHOIdG4ZznX/0N8BvkBoyHDCksQAAAAASUVORK5CYII=", + "eyesNeutral": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABrElEQVR42u3WvU7DMBAH8H8UqekCfYACeQW2DkUqj8JblC1BSKw8Aq/AyETDxMjKgEQkVkTD0lRq6uBz7uIOHBUfUhmapddffLFruzmj/vTKsPVNewV7Bc33nOJe4y7GyDm4DXkKbsSpQEJumjgkL5o4Juc2Qft4yrU+t2nU0g3DZaUReeFi4+6msXtaSJ67HuuUBuRu1lVAnjUjzG1Tw78C5KlrUxc2rQobTxPyJp6TRzwL5JxLNu/xbIysc64hj5u4sG7E7WchHlvnZ1JeMeK+vvCK+6rPbH8Jj6H3A+cx1HfWOTRb/5W7NWanNRZ/r5LWL1+8P9RX4iapvN+GU/FlESetn6IUX2TRRNzkGIqXCJ7Flxn2xd+AqfgiDXbFn9Adt47wQvwRewPxEuF9wn6Dg6H4DNG5+DWO+t47offD1l/RDSbsJzje8Y4Vx8Z9Zt9Kfvzor/MSiPz8YOjnEx0/nxj4+cfK/GO8br209dX2g7p/tP2m7U9tP2//73/3Hv7u+1+rI1rdUeuUVte0OqjVTa3OanVZq+Na3dfOCdq5Qj2HaOeW7bnuH/oHa6JiOJLpgNsAAAAASUVORK5CYII=", + "eyesNuclear": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACgklEQVR42u3WsW7bMBAA0BMMVEthrR6M6hu6OUv5Mf2BBlk6FCGLDF2K+geK5lfUJd7iX5ChwasMLzRA8HrHO9pLGaNB0GSIYSTUEynS5B0pwL9+Onj15/YA9KnkuudyI57KYJKD1mF3oJW0KYBlj1KesI9Sbtm1TnV8PLcl99SMa6ZhpFauZh9TOaa7rk1Pm7D3qUd0PKB0E0PF3skIe6oa9VcAu0t1cKRmYSLuLLuUPXuts8Cubdl8o7NhyLVtZG+lPJLH7PR/zN6S6zO53Wi0rwc8aF/4lfqzOobmEa5jwN/kWoz/ydP8qvN8Z+84etQBTl7xBIuHujfZ6XuTfbSxyT5aFnH6e5N9QzNo1b8hXaqvqCejTr357Evk6+R0H4NVn1scluLhEvGHEY8LeshK3NOj6lY8fDLYDeK7jhZ0qU4h6K7E987Gai3uKXLhUnxwJlQr8UNHfiG+BRNgK75zdYSZ+B20Hj6K79nn4vfsV+IDTAK8tcm/QzPCe/Et+1T8J/vF4/wO6l/wxiSfwbvPMBO/h3oKtfgC5vTNPq1PvphnX6c4ETccJ+Gcc85kp9w7OjYnDyY7LfstLWzyFqNFr78rhar8rlsuH8459Xt06ld94HEG8SWPc6frgr7CIOuyxr7Gva4juxdfsQ+67rzpHXTdeevTdffsO40Tdo2TQNum3WtcoatQ4ypY8hyH7BqHkXYnk+OW807jFlsHbY7za4Brk/OCPOfFB4AvOS9WPdXJeeSqYx5twuSUd2OzOZenpbwu7QPFfaO0zzzJPvZE+/C/7v+lc6R07hTPqdK5VjoHS+dm6Zwtnculc7x07pfeE0rvFcX3kNJ7y+t73Qv0PwhMG/HSVEiBAAAAAElFTkSuQmCC", + "eyesPinchLeft": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABe0lEQVR42u3WvU7DMBAH8H8UpG7kARDkMdjIq/QN6MbAEPNGjAxIhImRF0BqNjbIRIMabO7ss8PAgUAVBZEuvf7is6/5OsO9+2kw+bZ9AH2y8LvluAjuY1TeIWPYDWSQpAI1uw1xzt6FuGSXMVmannPJe0rjkb4Mn2Vm7J2PrT9qSj9bzt76FZ3hgvxBN2TsTaiwpaFW/gXYjR/jOkob8uCmZg9xzz6Ts8AuuWx9IWejIpdcy16GuCO30em7i16Sy5yc11Wy1gc+yFrujNarpYbiGy41uGtyCe3k/9eB9OC1Mf4JP2gw35N6npBjKfWQm9F33jpGx8a9nAOH4msq9+ozXwAn0Q3y5OfAsfgLeR39AniM3mCW/A7ZUty22E3X68HPGa7XAvvJV6aoo1/iNPm6PUrXd5mtkg/uOfm9ux3vh/ImeW+rbd8Pf+V52dB7+Kvvf62PaH1H7VNaX9P6oNY3tT6r9WWtj2t9X9snaPsKdR+i7Vumfd0v9FdjPP/LItpYaQAAAABJRU5ErkJggg==", + "eyesPinchMiddle": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABhklEQVR42u3WMU7DMBQG4D+K1LBAD4BQrsDGwFCOwi1gszkBR+AKjEw0nICVAYlIrBU1C63U1MbPfs9kwCBQRUE0S1+/+NmvaZJnuHePBhtft3fwRxG/txQPo4cYo+DgMeQaPIhTAUVuY1ySmxjX5DymSNNTrve5T6ORoYyQpStyE2Ibzuo6zFaSt2FFp6mgcNJ1BXkTK2z9UMu/AuQ6jHHGp3VldK3IYzwnr/gqkHMu2XzIV2PknXMteR1j492K+08jXnvnOSnPjHitD7zjtdyZX09xDcNvONfgbrxzaDf+fx1ID14r8U947SYYFGOu5xj721LnBFs9P+o5eo6V+4t/Kyn2S2D3M58BlfgVcCi+AAZyne+Ag+QaO+L3wIn4ssGe+BMwFbetn5N9huIh/Y+nmIkvmmqc/Lqcii9NrZLfugtxq7q3++G5U+l+OH9c+/3wN56XFb2Hv/r+z/WRXN/J9qlcX8v1wVzfzPXZXF/O9fFc38/tE3L7iuw+JLdv2ezrfqG/Ar/2+7GXAFZTAAAAAElFTkSuQmCC", + "eyesPinchRight": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABf0lEQVR42u3WO07EMBAG4D8K0nbkAAjlGHTkKnsDtqNAIuYEXIWSAkE4ARdAEImCDlKxQRtsZuyxQ8GAQCsWxKbZyRdPPJvXGO7drcHaV+0DaMvCfstxEdzHqLxDxrAbyCBJBWp2G+KcvQtxyS5jsnR6ziXvKY1H+jJ8lpmwdz62/qgp/dly9tbP6AwX5A+6IWNvQoUtDbXyL8Bu/BjXUdqQBzc1e4h79olcBXbJZesLuRoVueRa9jLEHbmNTr9d9JJczsl5XSVzfeCDzOWOaL5aaii+4VKDuySX0K79/zqQXrw2xj/h/B42mG5JPU/IcTO6GX3jrWN0LN3dFNgRX1DF55/5DNiPbpAnPwH2xF/ID6OfAo/RG0ySXyO7FbctNtP9ekB+Ee/XDNvJ56aoo5/hIPmi3U339zabJx/cc/J7dzU+D8d3yXtbrfp5+BPvy5K+w1/9/mt9ROs7ap/S+prWB7W+qfVZrS9rfVzr+9o6QVtXqOsQbd2yXtf9Qn8F3gkAZhfTUgYAAAAASUVORK5CYII=", + "eyesSleeping": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAA/UlEQVR42u2WPQ7DIAyFHWXImCNwlBwt9GbpTTgCYwYE9bOdTnWl/ijtAEtePmxwkMIztYdjo85/zQvxGPQ9Qc/KRdMinCwGPJIFWSrRCl5Vj+BZdQC3mOG+PHKZ75yGSClDsuIEnkVXmY1BVhvBk+zYIgqSyVYG8E0rTBxa7SsIPEpMy5xWRuVxBVe9g092CuCWC7bPdhoLc8ut4EF1Zl4Pzs988MDc1kReXmyvJ7zYXu3C+61Ww/wGtxralbnJ2nnnZ3Oi+w+fDn0G7+ff+Sf8S/fwq/e/5yOe77g+5fma54Oeb3o+6/my5+Oe73t9gtdXuH2I17f0vu4P+Q3tn6K1k3T0owAAAABJRU5ErkJggg==", + "eyesTear": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABsElEQVR42u3WzUrDQBAH8H9YML1oHsCPHHwBbx4qxJuvIfgQesuK4PN49Nb01FfwIBjxKhoQ2kDjrjv7kXjIFALFemgunf6yk51s2sxC9x4Ftr5pb2COyH0vKU6c2xiZdfgx5BJ+kE8FcnLlYkFeuTgl92Oi9vKUa7w2aTTSlmGzZExe2VjZszK1VxPkpZ1RSyrIntRNRF64CkszVPm7ALm0Y3Rl0hrhXObkLq7JY78K5D6XrE78amTGfa4iT11cGVfBzWcVPDXur0l5VebnWuGNn0vfmvlyX0NiHGgXrgzxX7i5lxsstJ4a13pZxBOtnKsS4+ALRC/BvwscBv8APoMvZbQX/Bmj69Yh7oM/4eA0+AJilnt/xNE4+BzxXfAHnO13viM6P2n9HaNo4v0S57ud45dj4z43/5aufvj6N/jc7eHqcb/tQb5Yk38x/rYmf2V8OtALxiXneb8j63WFtNcbxmuR9DtmvV7hgvErxo8ZF2vxGvEgb5AMWjfTOVY+R+49PNCHvv+5PsL1HbZPcX2N64Nc3+T6LNeXuT7O9X1un8DtK9h9CLdv2e7r/qH/AE7U1rlxChGvAAAAAElFTkSuQmCC", + "eyesTiredLeft": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABiElEQVR42u3WP07DMBQG8M8yUjZyAAQ5Bltzld6AbiBVKOZGjAxITSfGXgCp3tggEw1qZONnPzsMGCQGClK69PUX/3nN4M+wn35aTH5oH+A+IvzWVJfBfY3aO3gMuQIP4qlAQ25CLcm7UFfkPEak5Wmu895No5G+DT9LFeSdr41/qiq/miTXfkerqCH/0A6CvA0dajfU8L8AufJjbOemDTK4ashD3ZMX/BbIeS5ZX/LbqJ3zXENehbpzbqK77y565ZzXpHldzXt94QPvZW/cfg33UP7AuQe7ds6lmXzyyf+HA+mg1LH+Da/muDrnfvaQ61Xsc475BxfRz1qoE/ZXHGE7OkbHwd31j7F/iNU3Xi6ASz5XlwpyFc/bW+CC/dp5E/0OeIneomA3xSPEls/5mcZxOv+f/Zrh/F/gNLrcqbKJOXKPJeeIlXs9S7mzFTvOHSsG+5Zy6sluYk4pWz2kXOtNHXNNNboec1CkHMzlZi5nc7mcy/Fc7ufuCbl7RfYekru3TPe6P+jvVlI6sc0WsN0AAAAASUVORK5CYII=", + "eyesTiredMiddle": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABjElEQVR42u3WMU7DMBQG4D+K1LBADlChXIGNgaEchVvAZnMCjsAVGJloOEFXBiQisSIalrZSU5v37PdSBgwSAwUpWfryxc9xM/g3/KdXjcF37R3oyuJ9w3UZPdSYBIeMYbeQQdIKGHYX65y9jXXFLmOyfnruJV9RG48MywhdtmBvQ+3CU1uF2XL2JrzRW15QeOi7jL2OK2xoqJN/AXYbxviW2ro8ujXssV6xF/IV2KWXbVXK15iQS69jr2Ldkjt1+m3VK3KZk/vaibzrC+/kXf6S3mdkDeUPXNbg78mldIMPPvj/cKDfKButf8Mrv8AoN7KeGxyNdZ0v2Mum4mc43d86Pjh27gtKne36Mf7Ol0ChfgucRC/9GhjpvvoAHOt+u7Y4UH8EztU3NQ7VX4F5cNrnXUNzyj6/RPbU7/8XWKqv62Iane7v8rnmyKatTMgRHjfz15o7znQxdzin3jrT59TVs+SUjVmkucaZFHItlYOp3EzlbCqXUzmeyv3UOSF1rkieQ1LnluFc9wf9HedzO02a43rNAAAAAElFTkSuQmCC", + "eyesTiredRight": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABjUlEQVR42u3WsU7DMBAG4N8KUjfyAAjlMdjIq/QN6AYSiJg3YmSoSjp15AUQ9cYGmWhQg43vfE4YcAcGClK69PrFl1wz+Dfct58ao+/bO/iPCr8N1XlwrlGyQ9aQa8giaQUqchvqjLwJdUEua1R/e+r13vo2WsljcJeekDdcW76qC75bRm74iU7TQHzRdYq8DhMav9TKvwC55jWu8W1dFlxX5KFuySfyFsill6zN5W2U3qXXkhehbrzb6P67iV54l3tSX1PKs3Z4J89yN/55lcyQ/8BlBrf0LqUdffTR/4cD/UZpYv0bTvNMcXEi82yRLReDT7+4im5r6CPxNxzgaXAMjr27nx/D/FCLXU776gw4l311q5HNo98CZ+If3q+i3wGv0WtMyHmff4Rayz5vDQ77/f8F2X3c/2c4Zqcc2ej8OubIHJeUI5w7W3Pa585abSh3OKc6997n1LN74JziXCtWfa61tuRc4xw05ZCDKuRgKjdTOZvK5VSOp3I/dU5InSuS55DUuWU81/1B/wSObTqxus+kUQAAAABJRU5ErkJggg==", + "eyesToxic": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACF0lEQVR42u3WPW4cIRQA4EeINEUikS6dSYrIpXMASxzBR8g1No0HKwfYI+xRvJYLl77CRKnSIaUZSxjyHjx+ipCVo0ixFW+z7LcwPBjgAfGXnz08+792D/gR+fdCZZU9lcEkB65DboErcVOAmTzksiR3uazJuY6oj6e26Cs2o5opjNTKTuQulUP61+r0NEm+pB6jpYDSn9EL8n2OcMGqgUcB5DbViQ6beZndzuS5vJJPPAvk3JZsVTwbBp3bBnKdyw49FMdvV1yj8zOpnTPc12/cc1/xAvubOQb1B84xxCt0Lob/1NO7Yad3U9zRumG3svle7IoHeN3cwllxDy/mzk+ai+YAb4uvAJfFQ9oV2R3tiuavOv90qL5Puyj7QrvokKvpovrmtLneXlX3553fNg+HPejtdY3Tn7dxqeMv1T+fduP92MYlrG7ztpnqvEncz/W9bHR9L3Jf38tl8/vedwuYb9l9xCnR7Fs8KIrPeIwUl/cf4k32VX8/CSZ7AHOMLZI7cWcWxf4Gz6f37NYEUfwIgvjK7ianVI1Tb3+UOMHPu7oOu/Vp2/rc3UIZlw8bqP5SLrLE+U7DEceJQ/S4ULKDWqCMC1dA83mtblPP+fkT9cx+TT1lDxTd3Dx2vha/6dx0/rTPjb90Dj/0/B/lkVHeGeapUV4b5cFR3hzl2VFeHuXxUd4f3RNG94rhPWR0b3m+1z1C/wlHT0r16qhmxgAAAABJRU5ErkJggg==", + "eyesUp": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAB5ElEQVR42u3WPU7DMBQH8H8UibBAD1AgV2BjACkchVuUzUFIrByBKzAy0TIxsjIgUYkVQVjaSg15vC+3DA0IFhjipe4vfrYrv+YZtLKN0Plfew1uiX0fS79nrn0U6vAx4iV8kIcCQbyxfipeWT8X9zHJYnqJZZ9xmIzUbWhUmYlX2m/0aZnrbKn4WFekUjakD6lOxEe2wzEPbfxXQLwM1PBUFYfV8snPyyBO9FYHmolnROdPvLw4x97RhRo/a0LNcxbsHHudvlIjntN7lQeq2GXuY0xtjZzmo2zIn+wZNWPsk8RVBU2RPHKc+vsI29FfgFf1ukfzMtkkOuH1Aj1gfUB1zxzpWfR7bO1FnyK9De5X2Nk3z2mC7DTQDTvRJQ761ERfS5e+u/BnrCdD9yMcbiwdnxx/7hPOquX+0f/Op0AW/Qp8Fu5zYI3c74G9hZfYjP4ADKLbeZnrebnb+Zrr+bprPrhrPkSX/HHX/Iku+eau+RZd8tNd8zO65Fp0yefo2tz1z9N5553/zHv+xd6r2upfuNQJbfae1+bv/9We+h68RmnBy63uqFvdMS+sTulaVqes9hVW13ROr2taVoPVQY31Oqg1NHxRN9vqbFtdbqvjbXW/7Z7Qdq9ovYe03Vu6e90/9A9mtWI4APcpSAAAAABJRU5ErkJggg==", + "eyesWinking": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABYUlEQVR42u3WMU7EMBAF0G9Z2lBtToByEIpci85eIXENbgKhouQKOQASpiGRCDYee5YCzSAFEFAkzc6+eGyv480YSbwGbP7XviBfpn4fKW6rlxh9cXAbcg9uxKmAI481tuShxh05tzHv3VNu9jmnUcsyjZLlG/JQ4lju+q70ZsnHMmLyNKFyMy2GfKgzHHPTyL8C5L60SSGnLba6d+Q1nskbXgVyziWbW16NPjvnRvKuxiF7PHr+DEfvsnOflBd6HusTX3isdMjjOZ5D+wXnOaTb7BzGzb/l5RkL/rQ40e/TlejX9lH0c0ySxxFnkr8OOJX8xZu96LCXkk+wd07wZzQXsu+s5A84MTeigx18/bZ/nD+sW+ET0DhxPbGT1x/7Nc9Le77aflD3j7bftP2p7eft//5z7+G173+tjmh1R61TWl3T6qBWN7U6q9VlrY5rdV87J2jnCvUcop1btnPdP/Q36EeCwIlHlo8AAAAASUVORK5CYII=", + "informationAccept": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACY0lEQVR42r3WTWrbQBTA8adOibsIcZcuGJQjuHTTRYh6lEIvEMgBNLtkEUJP0FxlTIKzKe0VRF3IVm43ExBy51vz3hvTVeuFMT+E9H8zEhbsix8F/8rXB1we8GVT9vO66GNzVfThcl103fVF36mzpuS/1Uld8q0UVyV/hOq+5LcAFyVfAixa7uN7gKO64BcAYsZ9MA733HVnfMV9p4wvW+ZbafyE+xPYD/eNc37+G8sV94V1wdyOC8DnsuMCzJkPH63z9dF2LGiY76TPp74N+dQ3IZ/6t5BP/SbkU1+EfOLjKuQT92Px+3BQIZ+4liGfuBtXcN/GTOKbmEn8a8wkfh0zib+OmdjH05iJ3Y1bcXe7KLg/y5iPfZfysf9I+dgfUj7265SP/XPKx75K+cjduIL78CHlI3e7OOf+POUj/zXlI/855SN/mPKT34VxK+y6DrsosEubdzrlB9fiuxl3Wv3osnk042b53rXonsx3lu9dnoPxPst3roWCT8Hz/xd1BnC533dZvvO1uW3e2Z9TvnN74FtzlSwz+Zv9Ps90bi+48GM1udvwY+9t7oPzIc9M/rLVeaZze4ajts8z/ToYedF02SrH9TFHOp8zrxqV53s3VNUyz/duT3GH8r3blC8of/JjlB/20dgrlO/dLQHK9z4Gnx/wmr4/BG+oSwCcH1wB4HzkFfMOAOcH72l+vM9pfvCB5iNvmI80Pz5fND89dyQ/d1FwRfKjdyQ/ek8yc28Lrklm9IFkRh9JZuaz4nsjyUwu0SpPrnB+5m3ROyi/r/ZV2bU44LOyD/Oyj/X/et/+i/8B3hwL9ySzr9cAAAAASUVORK5CYII=", + "informationBackward": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABFElEQVR42u3WPwrCMBQG8Bcj/gGhg4tbBAdn8QB1c/QQHqS5gUfwKNYT9AqCg6tjh9LaphGbl/eGgg5CAl1+lML3pcMHFXlS+LprAIgJrxkU4co+2Jf1++ceDsGDBw8e/P/9CeZokK7fWt+BID2uruR3AO6u529/uF5YFhnt8uR6+XaFclkfxci19YT2Gfa09QXuzQbeYLeBt4wfsdsi9tht4Ax7G1icGFfe/RofxJ7rbg0dN4GHjE/8/8cUMfXdBJ77bgKvGF/7boo4+G4CRz12DjC7qCkiITxlvAlc0S4or4uQlOeM14HHjEeUl524zj7kXH9qQJ6QnjJ+A3qXPgXjkvac8WJMexkxe1j19MtPd7jrL3T4N1ugBC5lAAAAAElFTkSuQmCC", + "informationDecline": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAChUlEQVR42rWWQY6bQBBFizgS3oGl7InGByFZ+VigrNjNlYjkgyDnAng1LQUxaXdVdfNraM0sMr3x8PTH/g1d/0Ovu2uk/8v/KnhBflf+B/mk/Dfyayd8QP6rFf6tA140/Lk+tVu+0jPz5Wez5QtdmLv+ecsdncWvCITPdGJ+E4HwiY7iVwTCR/rK/gYRCO/pC/urRSCciDewfhcB85WIN7D8EAHzxfML2xcBc+f5me2LgPnsL09sXwTMJ395ZPsiYD76y+BvUAFz/2vsr1YBc38V/Hn7Igj8YT/48/Zlh4EvgV/YPm8gcBf4me3zBjb6E9snqvD7j2yfqAE/D39D+KMF/w9/deAd7Nf/f7BPhPfH/16wTwXeT6KS7R/w/nvA9kt8Xv4Lkv3N8/Ur2U/nIews2k/n57GS/XTe0sLzGVeB5zmuA57/uEqcl7gqnK+4YL5eE4d5lA1E+5GPaD/lA9qPfEb7kTu0H/mC9iNf0X7KN7SfeA/2Ex/BfuIT2E98BvuJO7Cf+AL2E1/B/iafwf77PPc9ud/N+cztK3cfcvdtyNznev+5yOi+eY48um+fu+v3z8k9c65umXN4zZzbIXPO6/25iPbNHEX7Zu5cvz+n98xc3zI5cM3kxrDh25ypyQy25BjbH22OSXBONvckOGebkxKcjkyuSnAuZHJYgnMlk9ua+2RyXoOzx16IuT9ij8Tcn7B3Yu6nDWx6qtThMD1VqcD0VKMC01OtCkxPdSowPaUC01OFCkxPHVRgeqpUgempSgWmpxoVmJ5qVWB6qlOB6SmdH9NThcaH6amDxo3pqVLjyfRUpXFmekrfG21PaUDantL30v5j77G5997ce/KnvZ//A/4SazfzAqDCAAAAAElFTkSuQmCC", + "informationForward": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABLUlEQVR42u3WMWrDMBgF4BcMngLtqE7uEWpygOQoBQ89hj1mKKRjtl7FQ6jHXCE0F4ibxYNRa8mWFEsvQ4YsxRo/hOA9fiHhl64Sd/Ccu1ze5m3Cvdlwryvu5yP344L7V8r9XXDfznPqIqYuX+Il9dcoYd6uZhvmTYE987pAxfwMZMy/gZT5DnhivgYE8y3girjwR8AFdi6fgYh4u+o8IV4CrgjnXQ1wgZ3XHeMt9B/lWegH5WnoO+Ui9LXyeegf2vPAFbsirEvtNrB1VUMX+DNwvd8WYb3Rbouwfuo9u+IL3w+9p76XvQvfi95NYN9j34FREcbl4KYI4+3gJrDv5goYb4xXYz8Zz8Y+xMVDzR2zK+dEwTyrzWzOJ5988skn//eOG1y/hPld/+GX/gcqVSYNBdilYwAAAABJRU5ErkJggg==", + "informationLeft": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABAUlEQVR42u3WMWoDMRAF0CEu7NKQJoUxvkOaFLlbBGlcGO+VhHWEXECq3ArSTCFG3saS1/xfbBHS7JQPIX0hhpFUWF4WX/xP/Uo8EP/Gbq/Yyzt2/cWeiIcf7AM+1/bYyyd2zdhTxB4c9kGg2w57+cCuGXvy2IPDfhboYxzZyr26j3Fk0/yruUaRdXvR7slJr5fuQbCfsNsb9nLArh57kkk1vxA/Yrct9iLY1WHPZL0n7mauZ/urzMtfmZN7PQdqnokrcSNemTvikXgmrsSN+DTQQ3+NgVao7yLxTLwQN+KVuSceiWfihbgRr464Jx6JK/FC3Fbz5hSda9flP7D4v/kNWMQjUDSyRnEAAAAASUVORK5CYII=", + "informationNoGo": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACvElEQVR42rXWMW7cMBAF0KHXiIoszE2XAAboLrWR1gjducwhfIHcQALcuNsj+CpCYMClryDnBEqnQlhlSM6QHJLukq12H1bSJ0VyBrbmZ4R/75Nq+gLQtXyAG+hrx7+buat9AlCbqh3wo2db+upcrbr02TnYh9In791b6YN3WHrpp8BwY6Sv5FpLX8i7F+kTuXqTPpLDT+kujnYPueyFu7/6qy5s7i6m9qk+mtzdHay/7NMx98VNso919ZL7TO9wgdv73DG+Cc8ZrnMfw+23TcHnwkPeX7DPfYBd8Gc47zOPS+cRPtjkJz8q9znAzggPjz1dgXpKjsMN07XegjoKp9eD8/qafGH/g/N0l3wGWoC/0e9zj/EBviWfUnyA64Yf0L8kH2lYGH8fJk46xr8ME8duOP53OE8+0DRg/D5MqHSMv8FZcp6eZxzfcGYrf8TxDSp3jt9tY+0YX+d+Isf4Bt0kVxzf4unxVLqLL30X4+OcR1/JXXz0Y+kuPvpr6S4++o/kXYyPa6B0H7/hPn7uS3AfH3/cJdcxPl78tXAfv+E+fsN9/NpD/NpD/NpD/NpD/NpDfBp85iG+9C7Gpx/ZvB34SNHCKX7lFF/6LsbH9yid4ldO8XP364rio8v1SfFxz0qn+NIhxqe9GffFSiclitgvCx9Z0vuZ994gfYJYCWy+r0c+msJ10ePJmjtm45OV9ib7BZ+sq/Q9xxfuq5elyqEK72ufQ5nKjszkigviTpzDHH8MeeO5zScoHY3JNU+PFnWB4m/0JbnlYRlRd2J8sKJOxfjQt+oafynrIEhPdZPGXdVZGndVl2ncVR2Pq66o+2DafQLYdl8BfbsPgXbfwq+t7HPS65F9Eeh2HwWm3XdB3+zT+LFlX8erpegD42OLvpFnoegz0+1lX5o1sqKPhVYf+27f+16f/H/687+bJlUxAa4nQgAAAABJRU5ErkJggg==", + "informationQuestionMark": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABoUlEQVR42s3WQW7DIBAF0KGuyiZKLhCJZa/QrjhOt80Fam7QI/Qq3mXZKyDlAl6ysNwaiAIzzFSx1EjJIlKeLPLBwwD8sJ8B/t8BLOcjAHDuFjetTwAq6NbjMHZo3S+ux77xODx8mMYjg9lRn5PrI/UpuTpRD8nhQH3M/kLdZ9/3xIfsW0vcZdeGeGboPrHPZ1dH7DG+illPrZv4Jwfs8dE+hnptXKXvF+zLdHUabd/4LqXdsO5g0yP3uRYcPDZu088n1j31IcaP/mA5HxnPsTrWA3UXlyG6WuVT6935NVzr+i8P1EuVrvJRcC/4eVkbd4ID77Pg06V1YA+Cj5CXm/oSv+N8ENwBaM4hVy/1uXQy5DG+ZTxcpou96pTI/WVa2Et87CU+9hIfeRUfeRUfeRUfed3oa6/iU+84H0p85K7Ep27486gcSMR7wYVzTXE+V/GJ65W+43yqpnWl23vym983bu1e8+6UcP957/n3uxfWbcv6cuYY3tWXcL/6XuPLtnsT/FlwfU8+CvtF8iDsl7ByH81SnVft5Ko6kerqJvX8C9BZnroLD70HAAAAAElFTkSuQmCC", + "informationRight": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABD0lEQVR42u3WMa4CIRSF4cvDxFdJa2HCFrCzm8INuQPsLHVJJhauY/I28KKNVhrBqwbOKSjshvIrmD8MAyM3OPYy+ODf9ivxf+aRuMd+dsSP2E898UB8FrFPPHbrsJsjdumJB+IaVLoGla5BpWtQ6RpUeSA+jW/fy3P8iAYlX6uPRIOSb3Wei4jZvH0nH6MnHsD8j5GDas9Bteeg2nNQ7TkIeCCegoCnIOApCHgKAi5/xAPxRcS+Is8l81vSMyb9k65tfVZkPQ9t78uS9z7q2vbPnOy3JfENduPB9/LKKc89kd+I3dywW+KOuCfeEcfns+ZUbok74p54JE7uC0N8TNy13Tv0nmq8B4f/hMG/7HcdRCwW5RggbgAAAABJRU5ErkJggg==", + "informationStop1": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACf0lEQVR42q3WvWocMRAH8BEqtotSurp9BncJOdDDuMgrXGGsLVIG+5UEgbjLMyy4DxvSbIhYZfT9cRpwQq45+BW7/5FWowE7/Gn4Vwf/k70fwefeTaCn3ncQ7u+59y085673Nfht7zokuel9Uf7vs+o8/n+VrR/Mv4C9zK0brv17fzy1vk+L98tz65sIOc93ra+n4Kfb1vU5uLhpfbkEn2IBySGuD48FRI/xSwHRU/xcQPQUPxcQPcXPBURP8XMB0VP8XED0FD8XED3FzwUEz/FzAcFL/FRA8BI/FRC8xE8FBC/xUwHBS/xUQPASPxUQvMRPBXiv4qcCvNfxYwHe6/ixAO91fCzgY/ZT7afi59rfFH/3t86ML2nvfbIc44oDz/tWu7Bf0GeLbmqf7Qu6tIu0R+3S/kRX/rTWruxvdNwg9MfaBfqvQ2wS5m+VH3xnhpkJXdRu2MYM3/kuYap9B42+MeffGwd8ygpGAq/dEH5411eunAsN993zlQ7+0OWRW/Ym/2zGLmx29djsyxK9XU9u16GD3ZI3+wJyT97sIwiTvNl34MmX9rtihAPl93Hden+I6z901vtb535/W7+49w589+6+k8Y/HC4/Jtpaf49nGP2Y1+45+NHikXG3T+vKu7ry2e0LuHPRurD4fYI7R0t37nBFYTK9gz+hsL7yXFP9geonRP+h+hXV36h+SPVPst9S/Znq51T/p+4L6n6h7iPq/qrvu09qfD8CcZ8y4v7lxH09je/3TYzngXUezw9ajueNRY3nEyDmGUbMP5yYl6bxfBXjX81j6zye37Qcz3uLGs+HQMyTjJg/+fW8Gtbner4N6/PaeZian//bfN75HwXO6JISlEzrAAAAAElFTkSuQmCC", + "informationStop2": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACbklEQVR42q3WsW7fIBAH4ENUZankNUNVP0P2KH6YDH2LmCiVulTKKzE1r2EpD1C6ebCgBxwYMCdVbbyQ/yfZ+Z0xcOCHl4F/dYjX0rtLPvd+JHrpfYcpDK+92/Sch9635Le9m5Tkpne9xuHH2jmNP5fWnUjj29z6IdP4+6X1XdH42rqd6L6H1jd6rrtt3eQXedM6xS8FZC/TQAWQ5/ilAPIcvxRAnuOXAshz/FIAeY5fCiAv8XMB5CV+LoC8+rpSAcnP+LmA5Gf8XEDyM34uIPkZPxeQ/IyfC0hexacCklfxqYDkzeKIBUSv41MB0ev4VED0Oj4VEL2Oj3d/LT7X7k5f3stdTHqo3nc4AJQV+Huq3cId+gb4W9a+wWd0A6sBUbuBT+ga8A+oXcMHdNw20B9rt+gfhZ2M3+4rF4dy0skd3dYu3eTkoQ5l/F678ljaMbngXxr3+JTZS+OP2iXjIvpycR0cX+tz93y9JH/q8pipeJN/k2O3UFw/NvOykrfvE3fboXucPvJmXrxR2Zt59FZmb+YdP2nytf2uHOOe82d6b70/0fsfuuv9V/A4v61/D/934Cp6+E4avxMhPyaaWr8HCC62uXsOfrS4ZPAY7FxH1xffwrz4sC5atxCWXlhHa7fu8I36Xfbu084x/+d65/YTZv/h9ituf+P2Q27/ZPdbbn/m9nNu/+fOC+584c4j7vyqC/i2js9HYM5TwZy/kjmv1fh8pzsv/cA2j/sHs4z7Db2O+xNg+hnB9D+S6ZfUuL/K9/X92DaP+zezjPs9vY77Q2D6ScH0n/Lar8ZLXfvbeE1/2w9z/fO79eed/wEyMn3kewrZowAAAABJRU5ErkJggg==", + "informationThumbsDown": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAA+UlEQVR42u3W0Q2CMBAG4CM8aEzMjcAoTOE87Ty6REdhhD7yQKhSUCm939AIwRjujS+XtPyUA3JiGdr9h90QlZJrokJyIuIUfyBb6ioP/Hy5sPFOgZ+uN9a9q0k/DVVM+kUf9TPo52/6j5R9dhXmMOrPgWeJTsjVRu6WcIa5LXa/5Ua+cs7yOSlgnplb8znOd66A18CdsP9uzjgdv1/+RBng/cKHaO7ZeJ74OWnjueSrfo+3wJs4f1/tc/Oxszi3R8M4cA3cAK+AW7BunejNEOZcb1+xTb5Tcj7proG/r0Kvkl2JboHX0MtVvVnIW+AO3Bd0o/b/sf/yO03ytM7x6NfjAAAAAElFTkSuQmCC", + "informationThumbsUp": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAA9klEQVR42u3WQQqDMBAF0C8uLIWSI3gUT+F5kvO0l8hRPIJLF6I1KnTa/AEDiosasvExxOQTRjHS4XH5Ce4td6T5gIp6v5N3hzs/V6t4o/qY5F5xl3HHPj4gp96jSPIOJslbxRuU1L3iTnFwH8DfOznNp8dnIend5DnxFmFY6R7TTVu8lO7CczN7IR1hi372PHIXuwlz5vUIqz/q2nSLQ/r9+TIN8ake4PXUD6j/2v8NGURqsWv1P+tLtzt5dZKn7pPmYNQ8sZfbkzzxnmieU7dqbuYkLze6cYj7UnAvYpPeihi++gz5YokbtcmdaM1Rn7z+x/7I37QxtM54FQn1AAAAAElFTkSuQmCC", + "informationWarning": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACT0lEQVR42rXWPYrjMBTAcSkJ4wkMmJB2wUWKnGErlylzne3sqbbMEXIVHUVH8HYqhLV6evrW8yyBHRcJ/GKD/c8DP2bIQ7Bv8IF23dGu9ht+pn05vuby8JqL3UT6vBtp57Qz9qRdkr4yeSedL6RrvlwpV3t12fAz5UunTxt+pFz26+EVF4NJQTOfrY+Uj+aTcmZ9oHwy4tn6Cn6n3N4q4Rr82rriNsVlw8+tL3aa1YnwLg+aXHZyr98J78WfFDS56OdfawyafB7mHylo4R+Gt85G9jbFoJlP1mPQ6DYn203i0bqxHoNG1+jX2m026zFo7efabU7rMWjhbFLH2mUHHoMm78Fj0OiiNzMz62Gq3E6n9Ri0dl67nU7wELT2+Vk6TCd4CNr4vXSYTnB5K10Fv1TO0UPQ4DCd4CFo48fSbU7nIWjjh9JtTuchaHCbzQh7TyFo47x0mw3dB23cT6h3yOb9QbufUO+Q0/std8WD+wn9h0M2I+HDB239mDtkQ/dBWz/kDjnRfVDvc3IMGnwIbgpnyfmQO5ykenfpM7nLZjSe+ajd/9P35Dp/q96Sq9wvmfPsrZ35kvsp82xDUJnjEym3V6j3zLt0FQZFdzmN/GliUHSX04gPE4N6dwXmNxODojPvUwzqfcQ9wfln9LXw+ZEcAb9cUOe69Ftwn9O7C1p6Curc5wwzeYqOOSVPQZ1jzvCzC4qOixt2xsl1Lrp8BdQQ1DnmjC9cCPels6HYJSHoV+5zpoXhga5Zdfze8NuGd//X19r70KHy8Zv28Nz/AgHnbGIis7BaAAAAAElFTkSuQmCC", + "legoColorSensor": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABAElEQVR42u3WQQqDMBAF0BEX2dULtOQaXRQ8V6E06Ql6JY/iEbLMQmKdVCw1f0DRUhADgryFmD/jRGrhqmhVb2hYxSI3w5Ofm3OXY7dkxl6bmBFn8xi7J1LIa6IMedWFjNx2boBzUcrUA7tOvemLOHbPrqa7Y89Tr9mz5V5R7jiI1IsGuw7ILV0MB5f6WfBrrHDq5k9etjTDpRzk3HDOa9VR6pO5/dZQVqO+DaQ86vOW91siP9ywH+/YTwG7nunS+whuu32h7912OZgZ80GaJ5JLc8nFMk53ae6FOJa+Pc7VOMbAvH3fp+7V9s6dlc5lXrq/dt9994/3/0WL/Tf/5y+oIIpSoJDd5QAAAABJRU5ErkJggg==", + "legoEv3icon": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABgElEQVR42t3WMXLEIAwFUHlcuPQRfBQfDbqkyCRX8lE4AiUF42SNEEh4f5FuE5fPuzMIjPTp++lz0Kt6oMcz3f24nO7ui7ubF6Z99JN9Gz2zr6Mn9mX0yD6PHtin0Xn5RKP76m7wylKA+Cm+Wc/iq/UkvliP4rP1ID5Zl+UTWffNnfHGtYDqZ/dNe+6+ak/dF+2x+6w9dJ+09+UTaffKnXLFXAD7qX3rntt+xVoAe2r7m2oB7LGdR66/YA/ap+6HdurujbvmZHwXP61v4tn6Kp6sL+LR+iweisdr6bmeQPGj+PWWD1rcF7/eulxPoDgf99vjD3uuJ6D8i577J/CPX/o7cH9zP7gz9Xa3fc+rtvQ/HNWL9gft56s5+j7R94y+f3Rf0P1C9xHdX3TfYX9A/QT1H9SvUH9D/RD1T9RvYX9G/Rz1fzQv0HxB8wjNLzTv4HxE8xTNXzSv0XxHeQDlB5Q3YD5BeQblH5SXUL5CeQzlN5T3YD5EeRLlz7+Snwf/AbPOUrbIcZsfAAAAAElFTkSuQmCC", + "legoEv3": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAAuUlEQVR42u3UsQ0DIQwFUFsUlIzAKDcajMYojEBJccIxJCflgEhOkVQ+CQk/mm+DDmj7JVBXV1f/hwMAVktUXOLtcXnjAoohyjbyzou8IldO7ifvol8cd47jMBAc8aC88xRmZ+xHJPbozzGUfM9z+Zyfm+qtNbFn20cn92KylTtSxeSmnKOvly/9nhD93mHrrb+QzZyH3+9l5OEkgdZ7/+xxLLkn/M6zmZyeOYvt9dv71/+Durr6L/0BgN5AjLS7ff8AAAAASUVORK5CYII=", + "legoGyroSensor": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABVUlEQVR42u3WsU7DMBAG4GyMnZiZ6Uv0ETIQizEPwUqxmBmYPHdgKPWSF0BKBVv27Axk6USJkKBqa3K50IrfjtSWVBUoliJHn36dEvuc1jPOMfYa9bm3Gp1fuVxVvt3YYyO38j9Q/3nt15bz2Nzr6rh9QPNSon+EpR+hP0ZUZ3mPfuyTL0QPvBuV763RU5/mRYB1kiHVmWn09Jz808rrIc0zLcHVGc3vAl3fUJ3XbgwuLshzBc95pXml9QA84NVPQ8zzOieO/ENHmgzyl0X+7c6YSfTT+8KYjC4f8iNjEu3Op4E7r4t3cOWVkAfJb/X8lB3ZeVrPabHFmWP958Unxlp/wfuoQuxP9/7K77zVz3F5Y/WP4vNi9xufL6s/a/u/Oi/oWVUffdIrb07RX7g/n9Cn7Dl6XuM7fH8O4Dt9h/+jN/S7TOOkulpvvfW102Fpwvfz//wLrcogjkDLtBMAAAAASUVORK5CYII=", + "legoIrBeacon": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABVElEQVR42u3WsWqDQBzHcY8M6XaP4Ft07ZjZZ+hU0Gdop2YoJY9RHIXgLLS0Q+kQuiS4XBUzx05XEP/1ck53P4tS3bwl4YP5Yu7PxTgEV+KM7Imj13/9Tb9I01/05RezD/Ou/RxrLp0uVIWZLpatM9OLOA3ig+k5HRtOb6g0PW84iGzXHduHdr5UZ2f7SXWubZeqs7a9umw+sLG9Vvvg2k7Kr4DrNZnXnKgC9yMXRKel7WVElD3b/n2o3RzsT+5X/APNaytXr2hee/n0jubl/6w6OmvcqTju1C7uEOEOEe4QTdkRzbuE9feu+Q7tTP29xusIhjuC4U7h4U4WDusIhjplVHjHT/C7sctCdC7kovDQ+ap5FqLzSFR4+FxnIfb5+r+vF8x2wbVXzHa1TKdN67c9/a59zvb1R/U4SoOt6fdnjvemP5w59efOtJ2hc+zyqf6f/wIbEfAds1E0cwAAAABJRU5ErkJggg==", + "legoIrSensor": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACSElEQVR42u2WS04bQRCGCzOGkTczSLHEzmOx8yU8PKRsEwnvc4QcAMmDBcK7XAGxQj5Fi+QgQC7g7Lyw3KlXPxBtHkrYuTZuf65+VHXXXwabNAMb/jqHJzZ0/P4p33KcvnRHYrVMIL6EsbWdmdgPa5tC+LxoAC7VvwQ42xZuvuPcI/WvALYb4efoDn1xP6X1v42Jr3Zo3xJ9cY9b8tnvEV/uE8/Rtz0afaXxTkF8UdE4GzRQweCGA9glPjc0bnUhb0H3hCP7SfxBguwQ70z5S5/4nUR/yf4lj0viF8KP2J/3gnyMPBfehyyDTzWPs6GBlUylADpyfDxED7lMpQC6cnw8BPKl8myAEd8oLwwsZEkMANNzoldzhbxRH7qBqfLPBubK+Qb0DHBs4I+7VlpP94IDAw+OV/obB2Pg0fEevgC35p6BO0hYaeBXiufr+UWS1zBN8ez/8TzJMYQUbxGnBF97RI9XOFr71BfLyPvT58yvMIv5lveXma2X9v1Yvi4PH53/dff+3vez7h0+pvhe9M5j60d1EdtBVEc2UsbjqO54v1B3vk75fKFOfV1T/Wahrr0OUL1Pgg543SA5PASvG05nKnqA143XGadLh+T/pQ66pAmakP9tFXRMda/NclsG3VOdFEHPg06qrkoDyIKuqg4P2H8SdFh1O8qS6LbovFOexuu89IU6qJPrC9xHruxvaxeWsuj6CPedQviqF/qOFbVibiH0Kb69ofIm6mvkNFZuoj4oJvx5P93wDX8Lv1ft+Fe++b+a4n8BxZLiTc0fV/wAAAAASUVORK5CYII=", + "legoLego": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACCElEQVR42u3WMaobMRAA0JFlLBfmy+UWH8tH2DJFiH6Xa+wRcoCAZFz4EoFcI6VMin+FlAq5gEp9EJqM/BMyWlz+dCuWXfbtIlajmWEB744Ab+gZuqEWX3zxucsLcxHARLD0sl9/ZK6LRDoyYOn83YMGfYCDDLrzIAcQCeQDiDObX3gR6SGIH3Rm3yMbtpEAJuYrAK88+QQwMt/ICJiAbm0amO90Ephle1S2zLcmKSwas8C6Yz6YpLGYtrTO95Y8Wyxka+ajiwaza1N1fnTRYsLnYl46nzBYDCiLiZ0/YXBBkNver+idF1VlGzo/oUcvi8quc3FGQJBFJudnLhBUFpGcrUvIVwegK3OpKgVG35zHYaWqRNTpIHrftHQgd6cq6nbmldZ6rbKyfVnrrMh/4vcqC/OdIS/Niyp77rRd2V7nvqVteUmvnlk+DDbqBDa456zzce4uWPLEfG9Dc28v5Czf9i6Y5u6STXz656PzVBXkOpkYuH8xv1qMdbLRc8eWJlcKqbsyPyJ+xeIo1IinO97S6gydm+aZfNX7LT0pSnXDfGwzk0eK6pq7qwqTwUAVvONuqVaCRi8wDcz3Ot7yCrwLI/Phb8sIrSLZfjUUAJup1THLB4BInQR2I1U+cwnyGzxG+PQIivclET9oSO9lVP5z16/+fCcIjHf62LT088UXf3P/n//nvwGyQo0HQOyH8QAAAABJRU5ErkJggg==", + "legoLargeMotor": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACiUlEQVR42u3WT2sTQRQA8EmC5qBtLh4Eafcj5FpBm/0o+QCFFrwUikx6qgchHsQKCv0I4ifIQsE9SY/qKRu2NpfiZik1u8nujjPzJrPzr+hFUOiDkuSX8mZn5r3XIuKMAN36v+oFwk7PUM/pOfnLjlh0HM/Dom07f/zYdv4udazLIrvBC2z5jK1b9QxHjTl7hz3dK9RI2LvR0PBezn0cGo7Bk1j3gfB5qjsSvsx03xReahsI0LbwSrvN2vUNcI8Q8owNKK5tQMmjbUBxuoGCHaCZZ5nDjWLDy5zfGZy3kqfKSdzJ8Kln+0V7/+DwxMhD/bzVf4R+7zLPH7rMc9O6087+wakjz7QaXRNX/kaw7sr/nX1tOfQBQi0jz8obVn4iK97lrGBczm7A5cRT6416BOt6Q7U+qcMrSUK1nmufx6L+z3RfpsI/6F5moo92da/oBljfISN/RWcI71PDM3pCvK8ND0iEVU+FHw2e9BQvY/H9Jj7rcJ+Dh+DF4734iPuSf74agmfT/k7MvYAB54GnY7/7rJ4/9NiFj/zuR8ULDB5jv/utnm/0BfyC+N3Leh7SJgL/RPq7l/X8RGJukc9kL/np8/kvYikcgxNyTH8WuHjO/QXCURPa+FUbbTVxtc39Hbsy8JMF+VJh4vEHOO7Mqg3w908nyTomwxH78KY9K9bA325MftzFJByzD69bwdYdkX9tsNPEBA7a9pQP5AeWw4HYvw8T0V4XRozynC97E3If8wKHzZfgoeieAVv3IT2HFngku43GPXpuC/CZ6E7zPLWQ528Evy+Hy/s14orWw1eHy/oxIl/VmxGyPo2Q9WyErH8zVv1i/W0X/WXGTPSjtQD07+3/af+T/wJN3ebtyLaNLQAAAABJRU5ErkJggg==", + "legoMindstorms": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAAkklEQVR42u3SsQnDMBAF0O9KpRYI0SIZ7ApDBBnAKwm8iLKB1aUQXCSTmMgRIeD2X/mK/+/goN0JoNPpdPpfno46IALrhwUnmOgCRgwRaD3Yvnuz+fkiotOUUu0wtzmPku4lv3E7f/kCl/RxXf0z5+2aj7mqW3ura9552bP1eldxb3Y5Lw+279Ftzv+k0+n0n/4ExFPChY04blkAAAAASUVORK5CYII=", + "legoMediumMotor": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABl0lEQVR42u3WvUoDQRAH8DmOJJVcY2Eh3msEFFP6AAbBxmewtBBzdnY+hG0a32BFMaWvcBAk2F1Ms8Fjx9kE9DbOPxg/SIocZBN+hGM/ZmeGWH0M/chz+niiqptPp+94zw+xTWW0s+5STjQvO5OvL25d0td8aOOh5qMiGmvez8lqPjB0rnpGe5r3xDuKPxHtLMUz2l/IDV2onpNTvYh0t7HuLtFdjn5lvCSSIHQyhi4XIC0bLOEf+uXkcvjhLHAfyZdFS6K3WfVHEU5OfPxvVf1BJuJ2367l51Vwj1zC5dHGAZepqfqdjdl26zdcNPLAi4jH7doh53Hg9zLHYbd+yyYqAjfUGbVrx5xR6Bm1Xm38Igs+DdYl3s+oKR6uV7ZnQLQtG9ec9WeiTc3/5P9gPmj+cL1gf9B+ov1H54XOF8UDih8Ybyg+UTyv2r2blx9QPkH5B+UrlN8WzZNLyueovqB6hOoXqneoPqJ6iuovqteovmv9wLz+wVuqvAd5Ov2sfe3/7mYag6z1w5r7vtqXgGymr/593/4ORMuwad9vYW4AAAAASUVORK5CYII=", + "legoSoundSensor": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABSUlEQVR42t2WsUrDUBSGk3bImAcQmqGbu6sZ+gBxCR0dfA0hg4Ojj2DBoXIdfAPplsGXqM0LFFwEq9dgEsTT/3PRoPZAQvj4uJx7DrnnBl7GIuibtzH8Lm8/KuDLIAIeEE/1+utE8ZW7i6WfTy+07861n5fgl+BPwK/APwH/6l/718FY+lMv67C61bzKevYpH8p/V/tF/pGpQxuDualbdw5kmg9U/es/+sX6zrmb/fpl/byOg/ohfw6+zb/z7X4739ZnN/xZ3YKx8DNzRHf+5RZv/OOefcqH8v+qPhX4E/BL8EvwP8+LvPCNb+aLm4WNb+fRMvTvE83Mr49IgXvNt+Zpouf7UHP/DD7w1z1Y5x54BfxR84jyoX0VwFPgyQ/x+I9xynNEPNX8EPgp8E2h+/ikuV/DvfQB+JnmmwjusTHwVPPwl+7bwN8AruTZQAWFR1QAAAAASUVORK5CYII=", + "legoTempSensor": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABrElEQVR42s3WsUoDMRwG8JwdDgS5BxDM7u5q8AGEDh446nsIERw6+grtJtci9Q2E23QSVBxb+wIFl4LVmNM77p/4fTioaIZQPn6kyeV/lygH26X67bxune/m9Y8ZyScqJbliucHjzzXKH4vzDPo872FflMQfEn9BfJf4M4v9vsV+ZLDfM8Rr4jPiT4nvEV8SXxI/IP6G+DHxDxb7kcX+1mBfaOzvff0mwA+rwgb+7tjnFozvH+iyeSGk3/VdlL/7K98xj8avvAXzId5h31Vr0PfVKvQHga/bSuyb70A8fus/z8fv00s8/6IohptF1cL15r5tVd0XvvnD2De59HK/pJf7K3xQD9LL+pHjy3oTPqhP4YN6Fj6of+GD90X4qcN+QHxJfEl8j/iM+Ix4Tbwh3mAffj9bP7bYh9/n1g8c9jvEh+dFbl3t09D3kw8fn0eTxL0vaKHReari865tDudJfG5qfL53cO6eiSf56zoZ55rkM5I/4Txl82HrsiQ3JNc/lGf/LGfz3GC5wfk2yY9IvrR4Hxc4d3NyL52S/ATny5TcYzOSG5wnf3TfJvkb6gg75melAHsAAAAASUVORK5CYII=", + "legoTouchSensor": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABB0lEQVR42mP4jxUcYKCq+B8GOOCnSLweSDQw2APJforFIYB4cVLNn/8fu/is1djFp4YSrf4BQn0jhjhEfeOoehLVi4bKYxP/p/2rH5v4nxh2d2ziPx4wPMYm/rH5hyE28cdy7yWwiR8rlz1Tjy5ewcDAs4ZtGQMDO4a4yBXWVAzxyv//X65h2/T//3M08dDQyBDW4NDQdDTxVatW/mH/tGrVcgz1wQ0MltjUb2pg0MSqnoFBEpv6zUBxUtTjNB+He3C5H7t/cYQPrvDEFf644gtP/OJKD7jSD670hit94krPo/md9PKWLupx1Re0rNeoVC+DgDwUj4qPio+KI8RBmYUa4rRpnwMAklG4kKcHXLEAAAAASUVORK5CYII=", + "legoUsSensor": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAADpUlEQVR42u2WPWgcRxTHR6g4YpwsBFRIGLZKs1ViCCRBubG7FCJyohtJnVGhRlVsCKg4bk841oKRc9WBioAxMpJvJHDSpTB47SU6UH/9bpZrVO0ZDGsx2cn/zdz6JOTDhZpAdMXevN+9fTPzPo/p935Cdsk/zNmZDy95fJZPlJyxcy8QV8yPJ0vD2YRuOpZn+H63fci1mrQ89LEFH3Iy3rR8A8vctbio0Dl84mZpHuXveIArVzddfW+4rV8wv3CI5zzHkV9aHuMyFV0hnuHBeGZ5RJfBEzzRjIdO7hseKAYxIR7hvGpS2YM6uEzmkAkd5G7T3SjMQQs3brBGJffBnXjdexz7DnHFN2IZbCgessJ92Re1dR6Y4/uVtvghLlxwfu+BlL+5XcOLTzwpf/LBFXeEEPNOZK6lvoUwy52Q5Y1rUsqdICGe5Hch/OoG4OprqIgoo4hMZn2sl5xuyDJFKjK1fHCE9X4rCtkgXyX9lZzsdJM2CUEasiQ7kk1P/m4cEUSeZFJGScjSQa/G/xJfKeKtrrilp2rpIGRRIjv6RG7XyUHOptzTx3IlC1k3FQtaibkGcfehmNcD8UUOHnnPtPYOqoZflS+0wmYhCw7Fba3bi1WX3DktfF2I5fwGax1CRR/tcuJ8RuItb1uB3xew0PvRJV6dqoGL7+rgWxInPN63/HoHXB4Qf0gqbxYs/3IBQm8O3Nkik6/3XQRMVa/vQzg6qDPmfmT0hdMCr39m9GtV8BkyedJpGb62B+F4l/i0wPKtsHx1CUJ/8b+of8Xct2Pv5Zn7PgF3Sv8YP5T+YeRP6x/rz6F/yJ8Ike6X/qTN2uTP1i8mXtLyT028nhI/NPFatHGcNvFaRhyDQ/kIIdq1cZ9B8Aq5jbh3I6SMFnM2Tz7Gy/+Izyl/Um8HKXPQoHx2t2RLv5Z/5JSHbYHrLteJO5tiSfcF5WGKlOev5J/DvPWe6iuS8jbJeuLGFEzaPBeCiRrl+SBfo3op64LWHaqLTP2MCqmlpnFEgx6EBaqjXH1DKtGAeJodQ9ijukOdkkpZp3cgfE91irpGiT8r63oW+s+prtEHUIPX3vUB7GX6APrG31KO+sYD2TF9g/qMuDnqM4momD4zti+N62Pj+t64Pjmur47rw+P6tu3z5QwZ9Xk7F04PneapOXJq6JRzhOYOxFRrxICN5o5R9oe8OZpTxrge8vDUXNOMnGk5rPKzc3PIz83TS37JL8Jjm4EX5v/v/7H/Ajl+8VgNmvuRAAAAAElFTkSuQmCC", + "objectsBomb": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAB8UlEQVR42uXWPU7DMBQHcFcZOnpkQcpFkHwUrsGAcBADY4/QozSoQ8ceAVcZOpIIhgCJH7bTunn2M6kQEgMdKvWnNHp+/vuDAfkp2Z/6S8IXCecA15Q/gs4TLiivvnMde2O9FZG3AMZl5J3UEprYtTTveQLKpSk27pswzmlHIzj6UkNH+baztcb+os3YCN9r2FP+2sM24QvKP3vc6MGfoe87GfvWeEt4AUGZBy/Ns3vC1QWdH50lcvUmErndVrTvFcvInLeMCTr/bZZYF0XCa0G7nsfusvNA5MR+7WoZ5vNQa+jrhC9AOhfY32xsTaGh76S2i0ixHHl/b+ZR2h/YW24Kcs6RKwH94IyNvVkNrozPx27yBitbj//DsQ+N9xx5BUs3Z+xmTju/R74x2XWeKZwT6+79wy5x9IVdLs7v8siVq4ePPbdboh0v44/j/cF5YT1b4/ndAFhms93YV8b14A32CjrnrMW5qtywrEvab0OvB78SyJthWIxdJtzNwNjLCefI34c2RP7hfR6ur4SzCc/Oc/1Tn/0zP7M/8Nt+bh6mnAdeTngeuJpwEe7/Ey4DbxN+WO8MaJ9F58upnfj+lvLCtw176duDXfk2YK99+dg7Xz527csJ7pmFPxiwq2j/P3VOUvfV4+tD9yfbH9+fz/cvYG0fIZhr9gsAAAAASUVORK5CYII=", + "objectsBoom": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAEWUlEQVR42rWWzW7bRhCAV5ECx74wEEKgNwroAin4BDmVUp3AYi6xUfGcQ1+jACXbgZNcrLLorUDspEDdfYnIboMAufQRSjcFcgwNX2h4wenM7orcleRbK9i09Wk0fzs/y2Dla8b+a/7nDfw9PT4v89+dLzX8lB4Hy/w5PdaW+c8pQHV/me8jl1sreARQbi7zrwOA4nKZryPPf1ziVezhux+WeYq+H1w4vKJfvgewO3A5uah47OpBkxLOoQpKl6NJGffSsjN1+Z7iQc6nqBGKmj8P4BIqxkBGjvxsDU55xlg2dPnpDfxjTpmfofnoEq4bng/ZrZhP13kWnMMnh3djnuGPdwmHDb8AFtSnHzS85FMtHjMoI5tnhveiGYV2iFwir+tMsg5YPK6/wO6q+jJ6Gt67a8VV6/mLfFtll2ebi9xEtrWgpyK/MdZPNke5YQelMUsHFi+I9zV/ZXN6fJWC/NKkZ55PsnhvnU93MNOLPGzx3SOXj+nh9+HZaK1yOLkeHrEN0eI2Z8T9EfOTAY8aLlv074bA16/S4WT3pwRfD6cWLxV/SfL7Ns9V2yr5J7YeKp4sVvpfWHZzzX2SjxvOGKMSANT/WryStf8zLc5R/lHysMlDaXgoxEux33Cp1VT3kuR28tTKzzlJMyY2xGP0p+Hq1FkraW0/SuxzrDydnQftD+IQrPPdRbu3kySCd+iPVT907N8IEcEH9GdgcYzxSstvQp42+cRSm5L8mTjWrW3mBgWm5Xf41OqXNn4WihT+FifaO8MnWG7JCGs8GXXjtls/oUAHhOjGzKpDtOUn6ECSBFB4TT1jp4e/YQGEGMCwXXOJ3P8W//oYcMyimnvozwSd2hBvdL40rzrZ0O+ngAXXxxBb9fxEHoqgwALFUh3XejCwyh957/DAIr0EDMdpFYo3eMInGGHa8HPKzw7WDzZM35rPObl+gvLHZgHNOeYnGaH8dmbnh7hQ8r9kscmnVCM2lVp+q55jJY5rKPC8dqmej01Dzti14duM6nnAs/q8cGKgnvH3IfWXnh9zu0U37mTUACMdVsNxnFDDHBF/2/AUR8czihdkWjZ5K6h0ySGG9UMtY/MJhnuHZykEVn5AVcORWk6RlQesuMG2j+7jaljgw/GtF9ysDMNVbq+C8ik4c54KUe0LKmCX0x6Jl/hB0aZViM1VetYegc6YoUV0iY/Zms0Z68z5/YZXX6wxj/Rc4xT5ruGyZ2bZdNiqrHMvUafi2dDDPWz4W8Unes17emEQD1QD53pfBGrbK65Fcr0vInuf0o4o1blKhx/Wu0ef+nx/kZBcwcHsHZZK/eazxdEuW+cL95MrgG7cY62eGTtzfk3GZ9Fp6dwfFN/PWFoM8aomFzl25R19v5tzutG8l5ilB84eVBGc9QOzmeZcr74zHATwh8316P1Ik/Afi+uMQT6Zb0r3XlrsWRvd4hdUIHKFvLeal4G5si3yaPV9+CYu09W8+n/v4Qv8X0gYw3qRwhztAAAAAElFTkSuQmCC", + "objectsFire": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAEaElEQVR42q3WPWvkRhgH8Ecr7+miInJhQarTlUZVCAQuYLJb3OFy11jCZfIR3ARSBDRxOjcHAdcWXLF742K/QCBqTMg2qbZXjrhxE53DgXzImjzPvEizaztVFrMSP/9XmpdnRgLx4KeA/9+bx3z0sLfBI+7d8zvpzj2/ld/G285r+W2u2WTGK+WZ8rp3KaAbWq17a7wcdT6SHm16Gdle9E5dbSDY9MJ9xKlL9QMOax4ZZ3SojJedAx3KzgPt7X96Ybzy1px17mpvpMM9r8mb3h3b697B9uohd6g5vWeP+Mi4S83s+gWR5QDdfPXurXvQe9t7YbzpnAW2t+gNOQUsF8bV1LDO8efYZ2p2oAawrxPpjG7d2t5gn2Ekm9T0Xgd1DQP4GqhEq96boKphCHvSWe+tVx5jXrrsiFl3PxXHmH8BuDQa2/9kx+DDZ+S6wcrv4HPYgm09b7236D4Co9EEM1/kL2AHsAty3npv8NoxwMCRzXRE708pv+Xo+SzgVjtQ3ldO61QtdWpcYvIe3aTOjGP+qaN3A3Raun/r/DbWRaSdjq91fhc90+7RTqXzU7fbf2o8bTydn1uOt6qlp+t5vH8pnQPktmeidFXemXqW46p3VX6Q2x5pV/nKtJ9GyZF5RnnmKm+w9pn0dDwce62sUOkODlVj8npT6X2s8lXvgIX6AzwHnvu5V0C07tuQTsOxy4xjeWWAlRlDPPdzF9QmavwZhDI/6BwvguX9Kfh5PI/zAU2u07sHwyRMwilWUFZZ7sCAx5znMGBy00THFlABDlP8UF7Q4u8c85zyvtOoOsE/6Y7Kh44cCeWM/kH5OfhuRT1DL7Wnocy7BfUAvdIeDygf40gor7WHX6VpAgl6Jr0x+V9izHNP773khcxHYZo4yRPjrXb//JTzAX8CP+oHAsPVPcb85DJNh8mW42ovgxJnC+LFO85PsIiMt6MSptj+yYeUWrTjmQfLXQm72N/FDXUZ/M6bCmt/mE5uN/J1BTj2fFHL/G7Q+feAY5PuNzSkMLWd8rNW5ueR8WpP5o9ayjvT3p9RPp4J+hXkI8txaMIjEcp87wH4fM5ngq5/YuU9hsmzfXGG+eE469xlPn97uhCnWEMnrHcohunBaiJWSZq+svLwrc8vlguxnMf81M7j6BxeYl522PYBf3P9WiwvsAdreSc9uvpGrA7v52fvzsVyhnnYyH+IxGp/Mw98dvOrWC7W8nKxH70fiasJTZjlzyGefczE9flGfgfz+JZ0NdrI+yye4WvddUYl2nlDi/EIT/4Sa/kGm+/P8OT3di3f0uKi/G9t+iqxHRfXGzz5o+U/W3lB+UP52Ei/tPK4hDm/kI8B/sUchOVpciAfS8l3U8sLrJ9PZH5+Y+dLCJOX8v3x4Grq9F5h/RzT7T7OrnPLscPpHvn7YC3fYofP1fvgde5a76XMSSd0/Edcjm0vcb7URr7MPctrUP0VYjW2vYX4rfJTFtjvySxM1MnZOLK9iLl6ueVM7av/ArwbP0k4AOccAAAAAElFTkSuQmCC", + "objectsFlowers": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAFKUlEQVR42rXWT2hcRRgA8O9l0p3ELjuvtwTXfSuKeChlwUuEZV9KQTyoZ4/NxV5EGjyYwpI3azDpqSsI2pMVEb0KHj1klpQkB+32qCDlrSn0UtwJoXTSvr7xm5n33u4mm4MH9xCyv2Vn5vsz31vQU18C/jc/OMPFGQ7hVE/P8ASCM5xNdXWGS2CH0zwGJsLpjjuf8h0BFdzhlIOA8hRPrdNTroBPdYk+9x88tn56XzHp25Oex/Wimzv3OPiwlnnCJj0OTjoYJ5xZ/0qNe71BgVrfmHCoVzLvTPjy1QUgpxxuLscN62koEpaGue/3hPMkQE8K//1AXHXO4oTlKwEMP+PC7pvQuM1UkMXlJ8EGWE+JbDOZ+4JkmwAmrtSTzSDO1uflZS8FsHkA1QriKMsn5ZAARAKONW+3ApHnmQCsgYf5VJFo1oKeC6ATU4D6dVNHGcS1WtBR1uE6M4tHxolE37AbJ7C0jr5n6iY9xSoBFYHtnloNfdu4gia9FTDObJdQPLy7L3hvaLfF7K2SQPDwC57xFNhGv1UD1z3QArhoz6k52Rk2l0jmJYBrNi6tvMNhG4/snHEY8CwPN4ZrLm/oa8KTy66+Inx6w+UHHSRVYOoiA8z9UU/nrlPnMUSsN2SK5P64DeAZp8NqOxKZk6ePm5lDuvJWCtTGBfTHj2vW8f/q8rYElzcIPnrsHHcp85BTdxuhtXv3vHWTRv4tuLpzeLE55vBldp3w8LPmCrj+TC4Ho4tXNm77B7C+o4s3z8H1myDPIBzNh0UOZtSAOblYApLPgQuYIpNPrNfRE+xXmh3IMw0UmvNHPf1IuC9gANhY62D7QX/xz6pyLq1HQ9s/+txuQ8csSzQ2XGT7h6Xzu0uhDk64itILu9UgHyc43ZxjuN5mmRVeK1y9ulmh+VgyDZS5vFxipPCo8JiUqJeHC7pwjs5z9wpPPUKJiLIhTwtPZmbQ8/seoLs5r2ZKlMSjTPPMZblEPOzP4QmPq+jYiz/lFfO2nS9VzpsJtFVc4TtufVWe7yQRo3nlaZDloTzPU124ZCzLQ3Uew9raep7FpruFd5C3jvKT5t5cRN/bGuTed562F/d0Z2erl/te9vxKXu7r3kF356TrX/F0B10bQOqezM6f6yO52u927WnG/EjLtbf7FVN88/5wzKuL/So1BcC3x2Neqd5bCkyBI7uW8wOtyK0H10PzPhzzR1p79/4S+OmYH1qPP/lzB9tK1NGTyNbL+CAJn3fRP603ck/6GKBgt1vrRPmi/V2kU+sDgokS8Ox9SZM5DlfR7XNcblh/nfEoOdcE3MB5+ppJuI4veTopzbzr48bOfesP32QYbe0HH6Nzz8f9EBuAr2I11NxLospyf4iuiKpGWvmeb35udK3/jZ/H7ME6UOnv3zeBOR+E+L3wm18EUfXv+XLhyZ1Qx9HsH5omt680jPedfxDqXnrxt2iYzr7jG99zXjG5eu9uiC3/ho/x5n7J5HZuN8CqNOo3C09L+K+c22M6foV2qK2TrcvX6L25HZxDHsyQkd9F/9zf2TBeJrbert/Qwb/SwyvU/3nccY+yf3mgzW8EYhsod11trDzRDBp2nmWutGKqsYJ55zZtI8eHw+qKKY5vB/Kx82Mdh2rFuPTtKC0c79fgmvGG6UNcwHk6g6saSD5cm3BzCjtRNmftWHF+aDx1T6qK9cj6kflt6TwJxl157mLh3wmXhesJf+i5ZOSeZr5PpvrT+yO/M+aPsOf1i3EPnQt3ObNZgq9Q/AsPqgGNrWWh1wAAAABJRU5ErkJggg==", + "objectsForest": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAEt0lEQVR42r2W0WscRRzHZ1nJRozZQh9MMWYsgtYXvZAHo8ZMpWAf/RcSheZFJDUPTej1ZsshVyH2kDwYoe09+OCrvhez8SQnNOYUXyqU3l63cCKlN0cKmfMmO/5mZncvJHugYLynu8/ezO/7+87v95tFMvPjo/+D7/1L3vqPeHjMfHMAvzqAo2weIZrJBSIDOM7k+76bHdd3srk3iNcG6L80QP8gndl6OMqOGyArk/sIZXKEjgRWXADH2ToP8vYAXjvAR+L96SGe6FfLqrKX5mX3uXiPdNK8Ev0umcmfKTRj7qHk4EfIGPDTh/NqXCNjhTPRS4ZHSV6izi6uy3b0ej9fZTRfrj35pS0fP3ebas6AK0E8t3VpvS6fOvEH1hzkaKNFTizd+FW8kfvpiuZgsxYanXqyUlm7scTvc829mMvWSe/KRrkrGoYrrBNwnhlZnLr5iH5xgEMCYqoYTb74+w7JGe6PIItBAvxyb4XkOjvjy93EN0tWpLzXe2tydmWtMdyQJc2ZCVu7Mz0/Q+vSKks78VMfyGcnw2keSrt8ykn8VL61vmrJ0+yuU6w/X0781IUogsLQJPaK7bXUT3WQb4uPIhdjz+7+pjk3/kT4liumyMRrNr9AEj/VshdKlrgo83VbXMCJnxB49J2SN/Yt3/+8KOpu6qcrh14u+U+v85VrRUgy9dORxQecWBXx9Xo1muz7Zsnrn8jwakM63Spb7HPIePzncFP+sCerFlNcyUfYJ53t7ZovS0vQzUJxgSYgbOQ2H65uz8mteenN6zrhSOh8w+C2mKNiSVq8ozizma6T2uQ+Zxi4LQLFAzcwPrwJqTv7Ujh/nlN+BsQzPrwKVsG6wKkR5UNVGh/EQ1WSqvlLFcUrApnC/VFZRQOEy1uLZ2OfIXD0sSpX2JSIRc2ZyTfKU7AKwzdeOHE28RNZD+YIRBoHabzNUz+R3ayXIdIIROpukcQfyLjzZRV2HFadoDk3HPde8ZHDht1olu4onYHhUn7IQAoiEzE3YbEcWuCWGnXX80QqbqJKaUcSXEX0U0Hlhq9M9rVvpVsUK37n+wWlHYrc19t3V/Oa/0U2FWfIMbxzfRmq16M9oblErq+PvVMPNO/utrrp3ACfm3tWRXHRgoGS1DnwludU1P7R+zPvpnUO+sXlnYbibTx+Lp0bUJ9sYYcqHuKbrXRuQKGw8/epuppCLB/TtJ5tGZTWKKylVcKG8YG6DUvfqbU0JP4Y1nUY+1le1pI/INY95b85XhA6cVdvOVZ4ti77/kOnlsxSPl5T3LNhMfYsuV+Kl+bPAwdl6t8c0W5NbQPPhCok7pq+9ijfg4UO/Coo3tGC1NzjZiD4o0TKA30tu8LMLVopp3NSDZqe0M/Djbrbn5NYzy3dT5WYe7F8tSEsC91vcL9/7fR+C0enSNy/OSMo0E93V6ebpn8tZgL75p55NIt0n0K1msBePM6W5oxvmM1pJV58PTR3tW+IsrxWnlxvTaJ9syRT1pEouWaaWNcnlALlanQkPFTcB4WMwh62SPie4mpP4GCSSK+xjfg9genfHPXfa/4JZ9ncCTJ5BHcByh/lAsE5TNMjPKm6QzyuUpyh5+j7z3HzY3wP/xtx7CF4mzMsBwAAAABJRU5ErkJggg==", + "objectsLightOff": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABkUlEQVR42u2Wu0oDQRSGRyQE0qTaevv1IVaxsI2Yg6VPYSnxQhDS5BmCTTgWvoGYgI+QPklptQqBRcKsM7Fw2PMfyIAgQqb8+Jjbf87OmgqOF7PjO/43vGxifm16iFtjUsTLRreJ+DzjG8QnRIeI3zKPe5LbBlE3lXydMXNb8pLcaALOT8x3kr9TRXQk+fzRMo8kn5yviDqST930PJa8fzFzB+gJPnjm4MA/PLly++/mgrc+nc+SJ5f+wGmd2+zN+5InK+wfYH9NM++3Bf/2h1v7WazPik9Rvk1IuR9W7gf7VYuV+yclL8Xvb3xQD4zr4dX7qN4Y19vC+6eSL70/QvXvxrHkhfcflP46Qf3lxj3o0zCuev8OQb8n2N8Elio+4JsAcsCTIK6QDxS/H8RV89H3ygcG/WkQV83vVBH+Iog35Msg3m38jyDekLuCOEO80P3jGL9Q/NIY+I6sFa69R+p7Z0weM49btw391ELf5hXeT179zrqKb9NCWbfIY/zodWPvf76HebEf939i2//wv+sL31hb+2Un18IAAAAASUVORK5CYII=", + "objectsLightOn": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABpUlEQVR42u3WMW7DIBQAUKoMHjkCR+FoTidGjpCjNJEHj71CIl8AqwuDxW/AQMB8JKOk7dIoSpQXzP8fyHcIoI8z+UVn//4qZ+Flyp0GH3IXYQKR+xCc5n7zbFjuyvvCc9d9/h48jFOb/O28unvEifXe8ziSPuYVXYAhhMU6og+g6dKB3PoE1x7esfW8AFwxF4/sUzf3jBZWuquMlu7mEIjbWofSZzjGXUz9Zg72y8IHm4wqfbSBdenSFrv0pU+4M5uj4aWPuHOZHtHopuqnijPUl96RLJ3/sH84X8jh4WfC/Irtdr9iSL1tvgq2L40uoXIeKj6uh3e3T+uh3u0zAHr+a65j8H3uSpL73VR+184ZbPqh4d5p0feYu0YUfXL1oeirJ+e3og9Ll6sq+vbqvmUlff7TuW+8yX1hdGvkG7p3+2l1X4B3e7V3kXnv9mSOd47gEH3a9tUp2fbUv9xzv8/JcXjGVdKGU9eEdJgvhFDM3f2o5f8PIbxlnmpcZtDxhgOeD4fXxK2MN0xV4ireMr45buv6X99wVwfcdYe7oX/0//kZ/wYyt6dnLKXVqAAAAABJRU5ErkJggg==", + "objectsLightning": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABm0lEQVR42s3WMU7DMBQGYKeuGpAqooqFAckDJ2Ark4/AITp0ZmRybtAj9CqpGDJyhUhcIGOGKCGuO9h5/4/oBJmiT0ml917+V6sRXpX6cx+Uv4zw/uwWeDG95ODzYy+98z+zHbG/SG+9vxHfEa+lNxNnn8QP2LWRXk2eW+wr4OXka0d8xP4A3Jf1TPyJ+F76ELdn7gfpfozZkbjBvrDS/XhXDvuS+A34Pv14N8TvgTdxe2aeE38F7sdbEDfELfDyB3fA/VhG7BlxlNPh4g65ljm9PC9yGraAeicuctoF/8Ke1di1yGMb3GCXuQt+J3LXnP2R+Fb0s1I4d8F3xGW+ShWvmbkfsWuZr7Tcma9FjsIYZY6Cb4ijvPiO7onXyJtonaSeGewLlIvpdumww1xMnbslviGuocfrIfUC+RCvgdTtNd7HayB1+H/dxWsgcU08h97GZf3Cm7jcxC1xBz09kUSeYS/1dZ6UG3tB3EAfkrJid9B7NV7nGfZOE8+xtwVxQ9xib5g77BU5T56IfxCviR+IH4lb4u6fnLe/AYeBsM+fqRuCAAAAAElFTkSuQmCC", + "objectsNight": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACL0lEQVR42tWWO27kMAyGqVEQuxistjSwA9hHmDLABus9io+QMlWsImUOkyPoKAb2Ai5dGKNYsqiX6UGmWCBR4bG+oUXqJ0UI4PuOWvrXdjTPcp10HWKhtVp+TnbCZIW813paftY5h6PDXGs9+DUPcBeW0cHt3fKP86r1jFRFfDEfAy+BheWVw2wIvIiWF5fAF7cX68/YzIE7t/eWT4H3q9vWyMLHwN2ukGOczIVTQ8pNmBL5IeiAYf5CtZxuLkw/UGcRqRPnpc65y2O7JmUz+kjNjA8U1/tcEZhd4ZLgPOJlxvG9inic3VPKvWyPgHlO+R/zOEIus7CC/IBc5sJyt5uIcytIr3L5mTVtJXIvf8g/wdsd/nuHw3b9fxIaCIdo8pUj4Snicdq7lFebvFzn8GV47Xio9SrWh73BOa4K5Pwenin7w8HbQ8bhU1z49Td8XuMhOeRntciPNVHnn+F8n2vYOadww/mFDX/Y6Q+V7zPKdDs/yrj/cCrxw7XEY1vOEmDKnxQauKSF5ooWrlC0QGKghch574SoR3JjPNdPrBur8/7tAhX5QXCBFhud1kC5z8M5OFZ2H3LtJk+pY/sVU8uHwYFxbL0sorJLtDPzxPmc3hN83U3pvUJv7F24yF93eDbmF5qPNc1V8b9uTkzexrm6jQuXcCHjNLpMmZOlUjkxI+cuk9+ZNA38Bd//llKbaI5+m4YlJYf2545PFK8UbS9kyk8PXqn3mP8sv+sd+gPiXI5c60PqyAAAAABJRU5ErkJggg==", + "objectsPirate": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACYUlEQVR42s3WvW4cIRAA4CErhcYSbYpIvELKdJsoL+QyxSmsdYVfa08u8hp0aSmJhJbAwMHws5VjyZbOp/tuj99hGPDTvx3+v5tl6geAnPkGAGr08Dj5QXUbnY9uoi+j79FhdOQva+/YLVxk7w79l+gdhwOS967R+a33NByme9/Q4VHN/WvvieHz2vqR/UG27rJ/FHP/0LnNvvC5s+fWTXa4nvjLif9oXd/9+4mz1/l+d3j3fgnhs4/OwtZLM7oIL3WMLsNaxHAZ3bCZr94uMex6V95x+vmd+LDvZ76ibxPH+Q6e14f1cSu8/haO2dI797tWbvTFg5G2dwvMMrsYmJyvxdUMR88puhjPOz9qpqT5gcd/65h/hK8JkeYx6WtipXlPhmgQb+LP6HGcrbOSyJo8fEDjC/WcEMN0D1Zd5S/i467zLa9Odd+4PXFD2hHUy3gcRs0TbOh7cVxjf33Sj9GhtGPw4rrezM8VP9xd4834O3m6JYuHjbqZi8KAWbPvKY+8mDqq6tL/+Zvztyy+3xNkePxTcQ32vgbh3VZnPkdm+B1vXKeQioN0pd9wsHLIxgm6Mn6HCSb2HI9Zdc/TxRAtRUF7Ly8YMZP7Xfl5ncBn9QbM6w2cgpi4G+uHLajEJW7rhDDzsNuGFCI5HmRoRB0pQA2vLvbYxI5D1SROHrAJ3Cy1MxI/6UbD0mIDEj+pS12uEuKy3PKt1+qiceHpE7VfVcuLOn6oeY04yUeWeuyO7ELdX1MXXqcm767ILojqzJPycS2uiRvwU7evcHPillS8jvghqmNamtXPy1vV4Y3/A9znMVqMtuZiAAAAAElFTkSuQmCC", + "objectsSnow": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAE/0lEQVR42o2WwWskRRTGX1shNYE2FdlLDos94+59I+shsCHNopCjR48mrLi3NSEgOUSn1yzqYWHBs5D9Jzx5sIcFRwi4B6/L2u0Ec5KpYVamYzrVvvequnqSibhDMpn5pbrq1Vffe6+guvKVwmvx9w6v5o9ieh/O8EV1JTf/wc+PJ/Snf5mXxydXz7ND/Pfh2SWuIcD3o2d95uUlPv70+SVejmieVw9uMX/85OK65gO7bhr5B37t0n8PusQnWdzl4P2+Dnj8uKhYlVP8/Zo+lQ95/Pjxc+a61s18YsfPCc9/IJ31A0X8WvuawG8Tfe4WH9/n+MXqrsRvuS66lh8d/Ua8d/M7CjTbzhx3uiU3lyg6vZTUuxi+JB622z2vDb/6fxFfBcgpahB+fE5cJ4ATHxqQ1eE0H3x1HdeNqiSqnIDDtIvcyAC5qjAcVbuH+EAK4mNddmvO82RJSDzT2vM6nh3ksJKqC9zGr2Ap8fyl26+spAIAxceSO9+yPoEKQagWcr11YLlYQT1xDsAfDKDoSMtZf+RpdJHzeWUqzHYVCVKCcjzE8y1EuPIsJEUNPeT9UAByq3TN2T8ZhEsHQPOgOFXX+g0nTCyP8NG0ojfrTwN6HuZBS4MhkOjEXwwrIwrcb1ASzysT1T43MkMOX0pEnrOfEuLou+g0H5i4ySPYBFp2EmV5r7zjuQk0wLasRuqXrWS/43kps8WgEKhH0oH9oOGoWbJI/FGntSea+UvkQlRa/gzLRcPN28TxVIJ+speJqfmRKzwHOElPU+h6HhQqMKICuJGOEoiJd1l1jB/nhW2Ra9Fw3m9bVbJALnXNjWJ9YjxayLPI5vsXyIUmXhLvJJZPbtP0xTzMQSExbTqUIMhPPyTZIIQD2KTExRfzf27xOfM5osBrOIK5iTnryA8IegbijPk5zeP9068gLpj//RFlNfptTH5L90GlPk7yZxKTP5t1eb/ez7S/oOHe/wbjj2qu6nyRsQlIh5+szsrnlyxRN1XGU5zzEfZI58Ryg3Kpp1p/rOhceiOw+lclCqUGusTn6BxH9TnyeFsf6NyL+txHLV9PtOzDau0TDb7+oH86y3vOb5ryquB6xX6rfWgEP0QfsydJJ9m/y9x0QuIrVA/HKt1Ky9s2X0S44etndJ5PXF6UMhRUbzUZpsmjP9blokwrrGOV4zYf31lXSqaHXM8rzkfL32gvLwDmds1Tx5P4YSvGHnPKxm7yPYl7zM/qzIxt3fh2LWjJpif5OlOGIpTi0Pewui7puSCcb9qkr2ODdNTa3uvOcFSmlZqmd9Z10ujloDdpmm0+dOu+gmB+MHt/KO9jUpzMcnMvgbV+04M9f1dD8c0sp8rW9CjXpWe5VWSGuy5N87+lQfsW77o08RspLPt4XJem+O8BzG14brs08c9bAfj9ui6N/M9iFdLjmrsujTzXO63U6+y6NPEc9V+quevSyL/ncyRGJ++6NPnhehBy62TuunTtk6Tmtks3nIIe46/t0sShvYA+rMfbLs3+XH9zQRGfnGGHsF3a+pz8TBeaHHdtu7TNI/Q/n9SPG5Xr0i6PFu3V4U48HT/l1/veydyl3b0uDz9jnl3Qx9YHem2Sniu7fnwRNBnR6G/rA68bTZ+XrSccJ1ZY7tKOn9l7w4j21fjB1ivW/3zaP1Ocnaaa+7C7f4wu+LPhPP7F8Gpezt6rz9y18vXv5//P/wU3cEY41pvMeQAAAABJRU5ErkJggg==", + "objectsTarget": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAADzElEQVR42q2Wv0/bQBTHL7WCBwSeKiSq1p3pkC6oQ0XMn8BQR50i5i6wgTAlDqjtv8EcGBgz1JGl/gNZIjEgc90iVGEPEY6a4Pa98/nu7MTAgKfk4+/dO797v8i/uY9P5O/Eeh5Otbk8IkSfxwk8rVk+Rm7Mch95ZZYTsvBebiT4lGh/LUrMIo+I1asdiRMJ7lcm17HnV4rcNbzQCcakwBPyMYi98IhYeT4l9yCPPdfM80hDuRNQPc/pEpOH+1qe+2+YPP5ZyXN3h8mda5LnJJV7odtSeaKl8iCmlsqnOpc7fVPl40Uu94aGyqPXXB6MdJXTemb3QFO5v5PZ9SoqdzO5E7gqbwt5uKlyTcjj05bkiSbkTvphnFcR9mr4JlL4dJnJP7CrNCUfG6i8ZVe5byh8BZWRzm5A4RFTErKHr3WFb7AYIQbupnDaBPk2IRpupCkc3eO+eMtuTeE+/if1OsFjtRU+wUi4eefjNSi8DfJL3R7sLmeO4xy/f7XTOddhI1/yE4zAddtuoF+p5C9w+U2nc4YLaUtwjJ62Dc8mLpQco+e4A88pLNwVPNFheRX1W7DwwhIcr2UB9RfgqL7kcOzbJdR/hjgaSg7XMlpF/bkJfhV8Crl4+BL1n+CC9k3BIWq7a6jv4C/JwV2X66hvQJpdSQ7JNfyC8jM4wR/JwVpkswccN5IcrO2mevjyQ8lfwVcOmP4HXJDgY7DbBzF49BvYNQQHu3RgN+BIx2BXcghYCrvDJ5w4wZ3klhf+HtjNDdv+BbVGcB/8TNY6F+BS0owvKoKDn8m6vVW1G2TH6Uu+EHuZfs+LKnJ/J8j2nwSJtAuJss3PA5ktOXzvaXr+E54YD34v+jlK/fN9xs/cnzN+5v4v+rmb6hdVP5feL9zqMI0H/CU5xlUaPyYvBDzewFoabxhXMg7BWi+NT0j87uPxDH4O0/hv8gLE8wXSIc0XLCtKfkEepfmFdULhkEc+y8es8D2cv21MQ5bvuFDhsLyL9QG7jMJ9WH6F9QS7jFpnWHmD+oP1qf14vaJYCCnUN6xXWqFOYj2cVydjwsqbWifHrNtFrCmNjMfr85RtfMd26yr1nBWg8IA1pb7aFzTRRjy1X7DCx9/Q1hP6kSv7Ua5/+U2xUa7f0Vom7+X6Y7SSya/0p/TfaTWzG5n5/p7Z3bby88AkO2YrPz985RuRp80b1Ejll1pxnuHe1IvzTzqeFOefhFjsKovzUtl8BfNYEN+Hs/MYzG8H9WR2foN5L6nNmffK5sPSebJs/iybV0vn27J5+Nnm7bJ5Psf/A67d6k1IisxZAAAAAElFTkSuQmCC", + "progressBar0": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAAiUlEQVR42u3UoQ2AQAwF0KKQWNzNwATHSjgkNwFho0tOgGAIEgSaYCBpDhjg11+glU80TftTumF5UldXT9G5CBfyM3cH9LGEvq/lJvhssU8Guht66EHwu+rhnLGBnsfWwD0w29/mYSFQmSeP/NUOek0Fas9EBnlU/4pLd5dyIuVKyqH+bXX15P0BRBCejozMPEMAAAAASUVORK5CYII=", + "progressBar1": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAA7klEQVR42u3UMQrCMBTG8YhIwcVJ6JYr6NYtbp0LehC3bk0vYPECLi7iKQJZHDyE0sFV6FKhJCqVqu33dsG88cef9kEfZRaOYs6dO/9BV2Vf34DLuJ8WwFeB9ZFvHn4BboKRfxRdrwLPP/Cul4lO11nXrzbXyM82t1PgutBmCVxOPBOD98qAV5X423s4MTA9xRTyh0roMzbc15N9Pr5ibLyoh3+6YU0vWv7q5wnudxb3kcX9luhDos+InhO9wP33+u/+e/13H1ncb4k+JPqM6DnRC9y31m/61vpPH4D1n9+duhPqrqg7dP9t585/3u93SkjFUCzChQAAAABJRU5ErkJggg==", + "progressBar2": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAA5klEQVR42u3UsQqCUBTG8dMQQotT4OYzuDkIt81ZqAdxc0ufQHoGF+kpBAcbeojAoTlaCi7edDA1v7ML3TP++KOX60FScArSrl37Aj32zPKN3DWSJ/D0VVnQH7V1R89p/SqAh7V1secunTo5pXNvnLpkXDnAPbdqQuAUGU0E3ptIU0rxt/twIzCrggrkrcbQd7Q5j6a/fkm0PYymv/6Gpr0YfNzvj7jPFe4DhfuM6X2mT5neZnqB++/xf/pc4T5QuM+Y3mf6lOltphe4H44/7Yfjd74Gx+++O7cn3F5xe6j/29q1L94/+ZwRM/Tj2IYAAAAASUVORK5CYII=", + "progressBar3": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAA5klEQVR42u3UsQqCUBTG8RMRQktTcLf7DG1ut61ZqAdpcyunRukZXKKnEO5QQw8ROLQaLgbiSYUW/c4udE/bjz900IPEcFJy7tz5CJ38qf1gjwrglc8KesjqBbwMF+phgJeeuuuh52yjczz0N2cWedb8VsBtYes98Fvu1SH431Opq8r87T08CcwkpRR5o0foa5pf+9M804pouevN9sBc07C/cOeDPmDcJ0K/EfpY6LXQG9y366O+XR/1AeM+EfqN0MdCr4Xe4L5bH/Td+qAPGPfJz2dg/fa9S3ci3ZV0h+677dz56P0LdFTgaNorlhkAAAAASUVORK5CYII=", + "progressBar4": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAAo0lEQVR42mP4jxUcYBgVHxUfFR984vIH/vAf/okh/k++oYK98TOG+A/5norjEtjE5QwfSzzHYj5I/Iw9dvET8ljFGyf2YxU/jEP8vyEWcaA7/xViiP9gBvrrX4U8pjgwHP78sR+x6eEBAxbAeIDhADZxoGgDVnEHBq5VWMAKBgbRUCwghAG7+lWj6oeaelYc6nGlE1zpClc6HC23R8VHxQe9OACi8J4xH2oOzQAAAABJRU5ErkJggg==", + "progressDial0": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACXElEQVR42u3Wv27TQBzA8Z8bKR5Q604whMZPwMBSVULB4jlYIhhgyCXNgpBA2BAhXoNH6IAu3WorA2vHqFeplpiDzBJ5cByc+2Pf/XxIMIAYakWK81H89SVxfAdb6xbDrf9zD+xe+n/X9w4Dm8d7h2DxAir32h7vHFpeAjz2AXzsOXjf7xXgYo9hQ3sT7aXcAY+yAS0gML2Ad4ys2STyTM8cRmj1SDumpx5n9tYxPRpwJnMIdS9hLTos9nUvOpJJ5umeu5Lp0tU9PZLMxo7u8SvVmUe6R4qrE4eaOyvFJA0aL9yaae41nh80nZFb+4+sR5oDOrVn6aBh5nyrfbhumEQL5flDjWkyU17oefbcVV56VD/Aq8fZ1fnaV76Z6Z3XQX3ehd45e1H7M71z+bUef6h3pvU4U53JxXvlsf5xq19AeWIwSZUbwyQ0C5UbzE6Vd83OeSC8dM3O0pe+b3ZG0ou+2dl9odx7Jl9JzwdmZ+JKPzY7c+nZG7PDZtIRE+VrNJ6F8BQxeyJ9hTqJ8AQxTaXjzlD4Ao/nTPgMdy5D7h9w51T4J9w5F/4Rd5bCu7jzMuDutjrC93HnWvgB7oy4l3dw54vPvd0Rji8HNhbewx0q/AjzlfC79k7R7njc2x3hx7gzEf4Id+bCH+AO+0WH/GZnY++M+/ZOffM2OtXNOGl3bqp5DaatzjarGE5Weme7pdXTbrsv/yA3/PqMOtsIhD+V1yGElYMzFAx9mf8MAfcL+f6+nDVS7lVH9UM5+fGO3N25Zd7fjf/Evh6IpnaPE7vn7p+tN27Xe/+R/wQBUibT3x/mZwAAAABJRU5ErkJggg==", + "progressDial1": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACw0lEQVR42u3Wv27TQBwH8J9rqR5QcScY2sZPwNClQiqpxXOwVHSAIU7KEkWC4oMIsfAQPAJI6JKhCEcZOtIxyqFgqQNTkLtElnAd7Pvnn9NbGEAMjTr4Ps19ffe7OzuwNH4iuPF/7r7Zc+/v+tqmb/JobRMMnkHh7nWPSodrngMceADeqqfg/rybgbPqEVzRrQ5qygtwKWvSDPy6Z/CSBQvWIW7dE4sFtPiL7brHLmf2wqo7aXIOBhBiz2EhcljkYc9syUHiYk8dyXTiYI93JLO2hT3qqpwBwU4UFzcOkVtzxUHsV545mmnqVp7ernJajvbLZCuoOtjak7hZMbMutB8uKg7IWHm6i5iO+sozHM+OHOW5S3EHV49zHfM3T/lVH+f0fH3fMc758ET7Y5xzfqbHH+KcZ3qcMebgyyvl0eIX/k+kfMQ+4w6x8n4wwzdOQuX0B845Vr7OjnDO0BeeO8FHnDPxpG/QyRx1aEnPGqzVXSko96L8+4in0tMmne6gnI4jfY918AoMpCfPg0FtBfrSi8sRnoDyYpfEeDxj4aUlJ6jDQ+nFpHoN1GEkvMw+dVFOLL24nKGdzg6Fj8tjZeMdIbxfzgWdGHoecn9dtki3tjClvy1bEarcUPgbPgZUuYlwXrNjdMSe+tz5M2Bo1xa49A2+uy2004XzhDagBeae3+ItqHI+edx5DoMDfGJKF6UkVeXawsVpjFDlhIsZHVaVmwq/I4pYVU7kyFM9gQXacKWLnBbsow1X+p5oga5cR7j43hR05QbC74kvgX6GMpwzILaeAM5hERhzghhOTDk0gYYxp6dvXM85BcuYM4NdY04b7s9xznKpXi3bsnLf+f4kqvBk+5HchxAWDpZ60DbkxXvwucthkIbcuzF3Il9xy3cPQvny4zn68zUzv/fPUrNfXJo9Hpk9df7s98bN773/yH8D54AvVfwldP8AAAAASUVORK5CYII=", + "progressDial2": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACjUlEQVR42u3WsW7TQBjA8XMs4qGk7lSGqPUTMLB0QcHiOVgqGOiQS2CpkEDYECEWBkZGXgApQ3WpBBKOMnSkY9SLwFLnIHeJPLgO9n3fOXcXd2CgYmhUWddffH9fL64csqx9ReTGr939es+9f+uNLb/Oo8YWqfGMFO6ue1Q6WfOckAceIZ7pKXF/38mIY3pELlm7r/yKA+Iy3mEZ8XXPyGtOF7wfuronFqes+Ilt3WNXMH9l6R52WNmhIxKonpPC2NdiQuSpntll5EsxJ3FVTx3IUzZ1VI93GHZ6lurRoeyMQtVDLjs8ChS35uWpZYfG/sozR5wqLpK6K083RWS7PHadyi+SdskjcWR25UncWXW4dV75/mLVoeFEenqPK53xQHoGgJ0njvTcZUqHudU6m2pn5km/HKidF3513YmA/q6YNnxa+WMIb4jj6Um1/kDAWUtMe16tM4Z8D3bp+xvp0ULt8Ej6mKsdGksfaB2WBNKZ1nkmval3jn3w3NE7Uw+9pXe66Bn8/eynfN9Fx+3vyuugp/Dp0iO8Tt9B34PzZrfg/RF68lLv8AE61TtU+kLvsAl4zI3OQ/S50RmDj5nRidHNzj74BKd/k50huNz+qY2D00D4W5x+0ODVB1P6e5x+bMsB+DuzMwVvmp0DX7iz1gFvmZ0Z+KbZ6QrPN8zOkSd8vQO+a3Z64G2zw8B35LZYODgD35bbYmkdeVvRoUWrG6709Q74ntnpg983OyPwu2aHX9Gh19uJr+jsk/pOROZqZ7nE6RHBf5Bf4v4MbZwekke4MBIUTuQyPjZw8Jn4wrHzqXmICxMe4iNu+eF2gA8/0aleP7L65/5JWu/nF/Uej+s9df7u+8bN973/yP8AnFAiX5+Wj+sAAAAASUVORK5CYII=", + "progressDial3": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACtElEQVR42u3Wv2/TQBQH8OdGqgdo3akMUfBfwMDCUgWL/6SiAwxxEpaqEhU2RIiN/gcVf0IG5IQJR5HIBh2rXAQndQY5S+TBdcjdvfM9u14YQAyNqurykf31u58OrGs/Mdz6P3ev3nP37/rWnlfn8dYe1HgGG3dueiwcbngO8NgFcKuegvPrXgZ21WO4jpo98hUb4ESsHWXglT2DV8xfsV7olD2xmB9t/nij7NyRzE6tsodtyf4IAuo5rFQOi13qWQPZTxzqqY0cXdrUeQuZdS3q8bHOGYXUQ82bBwfErZ+afe4Zz+yCo9Qxnu6anI5d+DJp+uaGRuEJbxtm1lXhhyvDfjjVnj4kHE0G2jMaz45s7bkT0Rucos5tygtX+/WA5px4xXOnNGf4rPCnNOdiVtQf0JwXRZ2csv/5tfaYdnfEYu0TVrqBay+V2V0lgXZ69SfW117q7tIfe8pzuzRs0aWLvkNzvrAOenaflnkmB1R6afhb0Rw9pbPb3Wc9G/0RyRkf+CP05CXJSTb/B+g0XiwN7XTYxFhNlXNaphirJ+hmMUffxQqeKJ+Q+I5YwRydlin6eKh8SssUG22onA4/F328CKS/oYtZ9LGv/B0pE0RtY+VvSZmW3NvKyTSeyvPguSedTONQtsfKyTRy2V4oJ5s0llPakZ7fIWXKKf3oSt8hZbZxxwg3y2EB8lzpKjfL4QRUQ3nLlKnOlbnyfVNmIzI5ZFnF23oHCy9yeqBO17lys6xAXdJTfmDKVI8aKX9gysRLKjkJYKOSE+MpXc0J8SVQyelCozZnDHiMVnI47NbmHEGzNmeG3cWc9RpzvgLe+UOuz1C/Q94DbrQ+BBsHC3POdXc/gCcdc87hWBfmyRx8RZ7dDfDlJ3OKz7es/r0/S+v9alnvfFLvqf1nvzduf+/9R/4b6couiYOY0EIAAAAASUVORK5CYII=", + "progressDial4": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACWUlEQVR42u3Wv27TQBzA8Z8bKTeg1p1giFo/AQNLFxQs3qSiAwy5JCwICYQNEWLrIyAeoQNysuEoQzfUMepVwlLnIrNYHhwb5/7Ydz8fEgwghp4yJB8pX//iWLqDyrpiuPV/7r7dS+/v+s6+b/N4Zx8sXkDtbtfjrUPHS4BHHoCHPQf3+70CCPYYNtFgon2Ub8CN2DAqwDe9gDeMZmwSuqanDqNR/Up6picuZ/baMT0ccqZzCHQvIRMdFnu6Fz3JNHV1z4nkaE10Tw4ks7Gje/xCdeah7qHi+sKB5s6NYpr4rRek4Sh3W8/32s6INP4jHdD2C73G02TYMnOuGz/OWqbhSnn+QONoOVNe6Hl2QpSXbqR/wW3m7Ot85SnfzPTOS7+57krvnD1t/IneuThv5g/0zvNmzkRn+uWt8lj/ufU/oHxpME2UG2PSKA2UG8ymyvtmZ+ELL4nZWXvSd83OSHpxaHa2N5T7wORL6fnQ7EyI9COzM5eevjI7bCYdMVWeoXlWwhPE7LH0G9RZCl8ijhLpuHMsfIXnORM+w52LgPs73JkK/4A7C+HvcWctvI87z3zupNMRvos7V8L3cGfEvbyDO5897t2OcPw4sLHwAe5Ewg8wXwq/a+8U3Y7LvdsRfoQ7E+EPcWcu/D7usF906G92NvbO+NDeWRB7J6mfS1vnJASnsnTOoV5BqTpVJTtft17veNk3/nyGag85BbGCKQS1gyM7H6U7n8DnLjvKg4R7KLe46lT2q5R3msWvG3T3/XpOx3YeuA7t54TtfbB5Tv7svHF73vuP/Ce0kyhgevPCZQAAAABJRU5ErkJggg==", + "progressDots0": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAAoElEQVR42mP4jxUcYBgVHxUfFR8VH1DxP+woBFz88Q8UAi4+/789MgEXr2G/j0zAxP99/vkeiYCL/z3/rxyJgIv/3v9/NxIBF/9e//8uEgEX//b//1skAi7+DoQQBFz8LUgLgiAofhvopHoEQZQ4gzSMoEycFHtJ9Reu8MEVnrjCH1d84YpfXOkBV/rBmd5wpU9c6Xk0v4+Kj4qPitNfHACn+Bo8YhiGeAAAAABJRU5ErkJggg==", + "progressDots1": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAAwElEQVR42u3TQQqCUBDG8S+CXNUFopO06FhtAruJB2mRN2gbRLRoWxYEz8J8kzU2KDSUBLUZF3/hh6DvvRH08ophbm5u/le/BrWIb8+1iEc0qkZ8Emyqebo/tg7kT5cy4nmMMeULX0Y8m2JI2ZxmHPEUGFAa0poj7oAuOaI9RzwBepQUd474Dujcn3Oct74E2uGq+C7OR45+QY98503e23Rd2v5o+6ntv3Ze2vlq86DNjzpv2nxq82z/u7m5+e/9Btpp4iJQL2EkAAAAAElFTkSuQmCC", + "progressDots2": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAAxElEQVR42u3TQQqCUBAG4D+CXNU6iE7SomO5CewmHaRF3qBtENGibWoQaGG+SRsaFBpKgtqMyPDzweM9542gl08Ic3Nz87/6zWsU8cOlUcQXNK0X8Zm3r5enu/M1IXfqJJzEi7XzqQjhcxLPV7SkfI4JJ/EsoB1lwJiTeEoUUQr0OYnH1RsDA07iUbXkCPQ4vfVteaRgA3SDR/rIMSwdo6+9zb5tv0vrj9ZPrf/afWn3q82DNj/qvGnzqc2z/e/m5ua/9zvyr+IiXMvuKQAAAABJRU5ErkJggg==", + "progressDots3": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAAvElEQVR42mP4jxUcYBgVHxUfFR8VH1DxP+woBFz88Q8UAi4+/789MgEXr2G/j0zAxP99/vkeSnxgfI8Q/3v+XzmUOMBQjhD/vf//bijRwGCNEP9e//8ulGBgkEWIf/v//y2UYGDgRYi/AyEIwcDAhxB/C9ICJt4wMLARFr8NdFI9mLjBwMBcT5Q4gzSIkKBYnBR7SfUXrvDBFZ64wh9XfOGKX1zpAVf6wZnecKVPXOl5NL+Pio+Kj4rTXxwACwTiIq5kKFcAAAAASUVORK5CYII=", + "progressHourglass0": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAB8UlEQVR42t2WsU4CQRRFMRZWZHsavoKab7AgWpgQYkdFaeV08B3GxkAi2FmYDHGifAEfsKGzWgqTDVn2uW8X2WHenQSjRONUm7M3s/fNzrszFYJjWvldHlc242SXR5/8eH9+xA8LoFceXvfwL3zX559mm/fuOkw3+n25b57/yl9a+Th3+eswH3ff1c88+udCP3H5otCfCl7oH1weFvqOy5eFfuHyaJ7rjcvjLstHA5cnDZafBS5Pa6y/r4u+q7L+oil4n/WPSnDD+p7s35D1oeR5AUZyLmBr3+JcwNa+xbmArX07N6qWfZv3Lfs2N5Z9m4eWfZtnBRjE425p3+ZJo7Rv87RW2t/JvWppf4f3S/s73PRwfoY3mC8vPfzWM08HczPBfHCFfQZPsK60fg3XIWlquG6xUnCdI9Lwv4Sk4H80pCPEB6RitE8C0gnYV2mdVAr2YabVBPZtNrcisM8zL5pAX2TeFYE+MqyPJB+wPpZ9GrA+EX3N1hWlIgdYqYlEbvDMikjkDDvRRCKXlpTrRY6FhT4UOVnol4hrwPmDbdouhH1epCN8jqxbmL8NMZ+3FOLpcDhGfJ3lFeKrLN8Q5zxEnPNTA85525Z8xfqx5O95/ktenC/xvued93w87L3lJ+973ntd08ODA973/ti9WvAPeLUJTL11Ut0AAAAASUVORK5CYII=", + "progressHourglass1": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAB00lEQVR42u2WsWrDMBCGUzp0Ct6z+Cky+ylEOhRC6ZYpY6Zqi5+jdCkKNB0zFBQQbZ8gD2CydXKGgAmO1XPiIMv6BSkktJRqiMyX39JZuvu5loZj3vpZnrWqcWXz9MAvj+cX5cMS6LmHhx7+jX198euP6v/mOcwr/bHct84/Py1X1T03eZUfq2N5Yk2Gr6zXDE+t7Q3P+G6KmzyPdlPQ5EVofq26C/S2f3irzuNCTA671LnaMsZTt36TTyFk4vJ0wVhfuTwbCDGJXZ53GesFLi86QjyHwDfajN1EgI+FmHHAFWND5D+JEAni9AEK8Wxgwq/zvGvCr/OiY8K3fK9twrf42IRvcTXE/pk8YL668/BHzzq3mKsXzOMRjjN4hd9VhPfwHPJIwnPLOIfnnGoJ7yXRHN6j0jJFPNY8Q3kSaJmDvKIS4gXIQ9JKDfKW1uYa5DnFIjWoC4qda1BHqtSDuotLPajTQBcS1DWFTvXu+gApN1PgG7Tyugd8hiIRAvgS+Rj5g+tjiS7IH1zfW+o1+QPyT0H+4PLSfmoGZHx7Q3oxdf18UeqZy8VuuHwnZ6Mmf9/rZ03+ttdfe/RPf01/5r7llP2et6+LPDw4Y7/3y/pqh38B9mUeE1Ss9HoAAAAASUVORK5CYII=", + "progressHourglass2": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABqElEQVR42u2VsU7DMBCG3alb/QQoPAIj6kBeAledQH2IbkgpUxhQty4s7Gml9g1AyjN0b9ZOHTtYDT5foTn/RgKEYEmkRs6nz7XvbJ9VHX1eVctb/tf8XqDsg4tOk/TH/LLJp1/gSmmGVqme4B3mm5CrjAeV/LnepJ53ajsV3CbUOOiQ135gmwLPqbHPgJfU2NXAK2pUyHfUKJHvKYAcuaVPjfyQ8C/k3k0jPOcxgJc8J+AVxwB8xzEDd3+ex7ibjI7xQ0LTl3xGb+1DFvzphQLwKZL+LQXgUyr9JQVQAZ8ZCqBEv6AAuhHfDWB1xF9y9iW/mBnzvp0FfyqoA/PHEz93vsmQK+cXxZE/NDj55iYB7v0Fz3MS+sMucO+vyrg/quL+Mc/gu3UxEX+u7VUR8Qdu3V1awV+kda+Yoz90+8plCfyVW3nqFvojt/JrY65Dn/b5NuLTuRijP6dz1Ed/QOfuDP0FffbQH/pzjf7K1wH0R75urMHnOrMFn+vSOPSXvBn6oX93rHvSb9bJJm/WVSX4qQ5LfqrbKv31e+S7/LN7rb33W/7P/A2qqP8PNx6qQwAAAABJRU5ErkJggg==", + "progressTimer0": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACJUlEQVR42rXWO27cMBAA0BFUqJRvwCukdKdruTBA2jmIr6JUuQaNAHbLII0ECBzzI4kzIpmVkM02KzxwqeEsORzA4meE265AFh1gKLkFEEUXtuwD3sdr8ze66NjoYvz4osvr/f0LT/u0Pf/kbiQagBbxO3cXigJwiW64j2JxDL0F7q+99t4sD5J51/lpAJ4eB+q2f3WTuKkengX1RYw+GBeS7alPgw5/LjTYUTdyDAFqWBewukYVxk0gf1B/t3EvuK93Nn5xS/1wU6mejTdPzrzrjs0/fXNRfs5uQMviWaCPHh7Iev1rva/v3/PjV+UdYeCOq488b361Ph7UPG/t5obnzUf3Iben5P3mC89n8pblR2xuG+bD5sh8lFs8qKgr4pI62bHUm+TxcPzdbZvciNu+Lj6l5Jb3yRfiE/WOeDroaE+4od4SH0gpPOGaenPCJfGXf/DnPdFaEB+pK+p/9mneqC/Ex//hezyTOONYmedeLit5qOStlue7/Y8X98/V/Vnb51fPS+3c1c7p1fN+tZ5crVfVuqdSyWZ1ciSe1eEZszoc6vaMWd0OdX7GrM5PybvsHpkxu0fCrwPxeye8LbgW2b02f2b3GqphdZCHfiP6sd/QffTl0J+YNrppD/1PE+PRHXd/73tXPffUJxz6q72vOPjehxzcxL6lPfoU+5zu6Db2RSLr62IfJTOPfVfeB8Y+rdAfKjIN9dgHFvrJ2vPVvp35F2dRFhdh12CjAAAAAElFTkSuQmCC", + "progressTimer1": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAACuUlEQVR42rXWPW7bMBQHcAoaNCo34BU6dtMpBLdL3bkn8GCUTHqMDNnpwRcoanXqCbwzKGCvLLxIgCCWH5L4nkjDLtp6CfHDPzRJWXyP6OSnIbedE5Z0QqqUD4TQpNMh7ZX+N35t/kwmXWcyuX79KNP7/fVT3+3tNP6BXTGtCMm1/oLdLIUTYg46w97Q3jApB4L9qZTWs/6BIS8KOw0hm7cV9KF8MpOYqR62FHpPG7sYs6ShhN5W0j1ckukCumKNW6Ak4wZGl5q7XEvYd+ivg/st7M2fV5TvzVZP2VHzEuXVxkx/ysRBFmj+9o1Z5bk7rlSO1tOT0rrYuQHYr/3a8/tjPRC0X213ZfLiQCrs2s1frxt8bna3Zj1iL/G55c6P9Urhc7OrOzEhdi1aZ1s6P9Z1j8/T+SchhJsxnA+d8p8z5NU4vzggb9i4nnrNoXM2rl/s3XB2v2uTXzXQx1+fye/8y4G8th/oQz7FxU7RyF0e+rh5mxfuSLC7/AZ6GfJfgfv/9fltAZyG/LfYXf4DcAXzOfAq5Nexu/weuIT5LHKfh85CfvUYuY2bayiZZ8i3+ZSXFHjj3eY/Ug79Ms//DL2/zPO/NJG75/vcJPPrK/kDzs/reUdj948Iur7MN+rL/3AGnEfn5t9AHp2z9/i5jGXjL7wCnt12BT2/w0MBHN9N9F54L+7wMnhfRO+pDmP0Xocr8IYPefDEfRL5dF+Fs7rhHFRqtrwn/ZWN7skGeHQPd+Cr4L3dzZUD3/PdXDlwXejAkcA60s0jXHcc4brjvs25pFFd684WcL3j1eiELfoN78t+Q5be+0V/onLvKl/0P5lfjyyw27pvnZfYxzo9levQX819xcLnPmThyvct+dJb3+cUSx98X0Sjvs73USxy33fFfaDv0xL9IQfTQPd9YKKfvDb+074d+W/1dr0hXblJ3QAAAABJRU5ErkJggg==", + "progressTimer2": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAC3klEQVR42q2WsW7bMBCGKQioRmXPwFfo2E1PIahZ6s59Ag9GKaePkaE7PXjtUMTq1CfwzqCAvbLIIgOCWPIoW3cihTppvUT58Pt8dyLvfmain4b9nddMRDljRYz3jPEo532cF+b/8Ln4iYpyk6ho/mat4vX+/mWu5u35+SflWhjNWGrMF8ptKjVjttEJ5Q3vLGZ5zyi/z5XjSXcjCM8yF4ax5bsC8z6/t0FsqJsVx7zjjUvGptTnmLeFgpfLEpNhrkUDCSo2FDBwZWrQtUz8wPyph7OwtX+eiL6zpR6SvalzotdLG/6QyJ3KSPz2rc3yeNpXOiX5dCx3XG7gAdXrfvZ4ty97Ruo1riqrlztWUG4gfrloaN9ctTYfuVW0bynwfVlp2jeX3UFIuWlJnm0OfF+WHe0n8E9SSog49oef9Z8TwoshvtwR3oghn3JRY16LIX+5hccL91VbfdVgPpw+q9/4y0F46T6Y9+lZLjeaBxz0mA/FO72EllAO+iXm+aj/jrj/rtevMsT5qH8MOeg/IK6xPkW8GPWLkIN+i7jC+iTgXo+5GPXVOuBObsdQVC8IX6VnveKIN547/UdeY/58if+Aefd8if+1CTi834cmql/M6HdUf8nnPQ+503+7xdzMxDcz8Ud9OaM3RC9QvXXQN+jnbR302ffzX96XQOdhHT8/1RXn56XnU+Pzn77+vrT4PmbBPfX3MX/9fUfzRF4zT4a5JGfmlftCRbife71rD5l7MBzbzOnJnARR+wbmZzCHT+Zy3cncPrn4j0kw5+16se1Jg70AeroXYHtAfLpH4L64fDZ078CecvlXigd77XSw14XuNVPbf09HezyZmPgNr5/6DZV7fTfxJzoF/VanE/+TQD4LlVHu9r7N3+59yv2ers7revRXzlf0zldM+MWHTLj2viWd8tb7nGzKe++LeODrvI8SAfe+K/SB3qdF/GGNwmDufWDET849v9S3E/4HKuJgRipvQikAAAAASUVORK5CYII=", + "progressTimer3": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAADJUlEQVR42q2WvW7bMBCAKQioRmXPwFfo2KXVUwiqlzhz1y4e3FBJHyNDdnrQmgBBrE59Au8MCtiAJxWGATVQyPJHou4kGW2BckiED18ud/w9oiZHSf7Mc8ImOSHJFJeE0ElO5TRP1P/hp+IHYpKrQEzmr67FdL0/f6i/5nX3/R3ziqmKkFCpr5jrVHJC9EQHmJe00ZjEkmB+EwvDg+aMIR5FJgwhi3cJ5DK+0UF0qLMlhbyhpUlGpyRjyOtE2MUlgYogr1hpExSkLaDlQuXWqwn7BvmztHuh0L+ekd/oUrfBRuUx8quFDr8N+FpEKH79Vme5+7XJqhDl05DYcL6yH6Be8293s00qCapXmaq0z9ckwVzZ+Om8xPNmqtX58ELgeQst36RZhefNZLdlnK9qlGcdW75J0wbPp+WfOOc2Yj8/tPOvAsSTNj5fI16yNp90nkOeszZ/XthPz13V2s9KyNvdp/2VOxyIp2ZALsNO56uKjrj1IW+LNz63U4K59ReQx73/CLj7W+cvI8Bp7z+NufUvAK+gHwKe9P58zK1fAC6gH4y48yFnvZ9dj7jR9TU06TPEl2HnCwp46bjxL2kO+cHHv4W8Ofj4d+WI2/W9LSf9+Ql/jX2fz0eKOW/H/Tnk6pC2A8dXh87H8Y+fOz894SvkMx+f3cF5WPh8xHmO5rnzLyleFx9/sF4+PuJX3I8C8vc+/TSD++QD8AO4D3sf7U/oQ057/yKE56L38XkBPuRx7z9G8JxuvL9E53rvfXzeex+edxn2Pr5Pjt6HXAUvnT64r17NzJhFyBDPpdk65keB7r38i9makfHRPVmaBbt/Y+9PfA9rdab8ce/vba0+mPhPAb7ndcEzOz0hfhf2rY/fhTo6tvHxO9KELy6fFX53pCnY5J+JwXunN+jDVteM3zWVJ5t0ttPbk7BBv7G3/rDfEPHR+s2gP6lCafyiCgf9T6BMPnMRYa7f/b3OX7/7mOt3+nWusu657vsr01dI01cMuO9DBrxyfUs45LXrc6Ihl64voqO+zvVRbMRd3zXuA12fNtEf5iAM5K4PnOgnT33/a9+O+G9KZg5hxzWVdwAAAABJRU5ErkJggg==", + "progressTimer4": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAADGUlEQVR42q2WsW7bMBCGSQioRmXPwFfo2KXVUxCKl6pTA3Tt4sENlfQxMnSnB68JUMTq1CfwzqBAAnhSERhQAoXsUbKkO1lGk7QabOHDj8PP0/HumBt9cvZ3njE1yhmLx7hlTIxyYcd57P4P3xefm1HuuBn1707N+Hl//3JP5mX7/pPyQrmCscC5r5SDlYwxSDSnPBcVYBZZRvlZZDzn1YEiPAx9GMamb2LMbXQGQSDUwUxgXoncmwFLNsK8jE39cRl3IeaFymuDhm0PsOXGZbWuZOoH5teWCevcAv6uib5iavORr1wWEX0x5U7fcL00IYlfvg4e5fH9KikC4qdi0YO+vddzeCHnZWIjjycraRk5r2Ox9nq9ZDHlTvr4Ms1p3rjV3o9eGJo3sCPBv0wKmrfwAfRK63lJfJbRBvRqJWVF8xmtQf9Ja10FJD9itdWfcMLBfh1fLwnPlWz8yDTDPDvRjX+9yBTmYF8qB/okx5yDfe0c/Myby9FysL99MLeB19fPvBCY93rMq3Dd6nUZYb7q9FPMo06uvyNeRr1+FiIuev0V4Z1cvke8wPoA8bjXp5i/6/ULxA3Wc8SxHvMvvT45RVy5Vg5tiPBWrgifBa3eCMTzWdDqP4gM87su/jnm1V0X/1tOePd9z/NRfbpHv6T6zs+RoLzVXxxi7vbEd3vibz53+dyjd0Sv0HlxHqZ9Pg8zkuc+n//yvU5QPWD+FtXDE+rnufVZ4PoPXn5fSnwfQ3xP0X2MXn7fbdDrn9JPmn7V1CftV76/pf4jJIRn1peO/1mQvpf5C3kUej3pk7n/YBev6v5J+zBIJ6677n3fBumlj3/FaZ+HA0/q9AR0Lqy3ejoXynCzjU/nSOUbrvczp3PH+gN7/4kZzDso0MsbODOday6LV3JyC+XJ1GDfWNf64b5hYIB5fTXYT4rAev2iCAb7D3feT2pCymHur8E/zH3KYU4/pi5px3W/X/m9wvq9YsC7PWTAi2ZvCYa8bPaccMhtsxeJnb2u2aPUDm/2rt09sNnTRvbDDIXBvNkDR/bJfe/P3dsJ/wMGWMEfZruZ5wAAAABJRU5ErkJggg==", + "progressWaterLevel0": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAAz0lEQVR42u2NMQ7CMBAE11jCDSJtCgRfoKTLV3gJBCHR8iVX8AzMCzBdJILDLhIdBSXFnbSXu/HExvC1IowbN27cuHHjxo0b/4k/9b2pbZmHhot4p+nMlIbtru0onqXtmX7BlsSDeJLmmK7SxbSKFz9RKzVR1mUHWr0T99T6mlq8ko9pddhGFB+ozri2awpB27KJ6PyOr03CULBshvcWV1VE8nyqnTr+vaqG5Lih9hFw2WcELFrM0QM5JEyhahgeASTARkPEpyZqa2b0Gf6rXmaqYCuI4ImXAAAAAElFTkSuQmCC", + "progressWaterLevel1": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAAzklEQVR42u2NMQ7CMBRDHSKRBdG1A4IrMLL1KpwEipBYuVImOAbhBIStEiXFRmJjYWP4lvz7/eImGL4qwrhx48aNGzf+A3/qe9PY0g8tF/FO25kuDcdd6SieVdvT/YIjiQfxpJqju0oXs1W8+Im1UhNlXXZgq3finrW+Zi1eycdsddhGFB9YnTG2axaC0rKJ6PyOr03CULBshneKqyoieT7VTh3/XlVDckyofQRc9hkBixZz9EAOCVNIDc0jgATYaIn4aKKxpkefxWQy/YtegRuKvotww9gAAAAASUVORK5CYII=", + "progressWaterLevel2": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAAAzUlEQVR42u2NMQ7CMBRDHSKRBdG1A4IrMLL1KpwEipBYuVImOAbhBIStEiXFRmJjhO1b8u/3i5tg+KoI48aNG/87f+p709jSDy0X8U7bmS4Nx13pKJ5V29P9giOJB/GkmqO7ShezVbz4ibVSE2VddmCrd+Ketb5mLV7Jx2x12EYUH1idMbZrFoLSsono/I6vTcJQsGyGd4qrKiJ5PtVOHf9eVUNyTKh9BFz2GQGLFnP0QA4JU0gNzSOABNhoifhoorGmR5/FZDKZTKbf6wUwPOKl8QPByAAAAABJRU5ErkJggg==", + "progressWaterLevel3": "iVBORw0KGgoAAAANSUhEUgAAALIAAACAAQAAAACHQw5jAAABP0lEQVR42u2VMWrEMBBFRxGsGrNqXYT4CltuFV9lj5EqVlhImyPkKoKFbJcrrHKCKJ2XKFb+BGxsGBdbBRJ/mGHm+VtjJGNT/srQO6cG8cnFKXvKLVdHRFcjfXD3xDyybY9IFVJgbpgHtilEa5E8XJ1m/gJbVwJFXuwRrqSYa9hSCZt/A1/B1VLjqdMG1mu0bgeD4W5Te2r1A6YVJne0qfNP57fWU9AY5dYKd29tDgodldoTqagjGaoc3VAiiibQmlg1ApeIQIjuufDUq+C0Q1z1xaJFi/60iluZ28aJ3Jy9yPU5iFxlmesZvsry+kUz8/z/5qTuZKyizM2F3IYZfnDyuR7kc61fL+P4qYmq0mCZ+tuhfHZjPvhV8iKnMVejuZNXrjnK3O77aeo03hEzNGqyUcbNnJdfPjqLFv2+vgH+JtBJ4nz/SAAAAABJRU5ErkJggg==", + "systemAccept1": "iVBORw0KGgoAAAANSUhEUgAAABgAAAAQAQAAAAAkX4I4AAAAQElEQVR42mM4wMDMsP//X4b6//+AWI6h/p8dQ/2fOob6H/8YKj/+Y6h4/I+hxvkfQx07UJ4fiOf/A6sF6QHqBQDsYh9jNdETHwAAAABJRU5ErkJggg==", + "systemAccept2": "iVBORw0KGgoAAAANSUhEUgAAABgAAAAQAQAAAAAkX4I4AAAAQUlEQVR42mM4wMDMsP//X4YEBjYGB4ZHDA6MhxgcmJsYHNiZGNz4mBjcZZgYnPcwMTj+YGJw+ADECUxgtSA9QL0A+IIPxwiZFtwAAAAASUVORK5CYII=", + "systemAlert": "iVBORw0KGgoAAAANSUhEUgAAABgAAAAVAQAAAAB0khOLAAAARUlEQVR42iXD0QmAIAAE0IvWCtqmMbLG8MtVhAZwjBvALyE85XzwoE/QO8f5WPsd0K+An6c3Jq8sThIUUVg9qfmDDRn7AD/WMAQEJ+pCAAAAAElFTkSuQmCC", + "systemBox": "iVBORw0KGgoAAAANSUhEUgAAABgAAAAQAQAAAAAkX4I4AAAAGklEQVR42mM4wMDMsP//X4b6//9IwiA9QL0AlQYkzY8nCoAAAAAASUVORK5CYII=", + "systemBusy0": "iVBORw0KGgoAAAANSUhEUgAAABMAAAAPAQAAAAAuP8mBAAAAMElEQVR42mPY/38Bg/x/BgbnHw4Msd8dGKLeA+k4IL0XSGdB6TioOFAepA6kHqgPAJCPFdTsOCPGAAAAAElFTkSuQmCC", + "systemBusy1": "iVBORw0KGgoAAAANSUhEUgAAAA8AAAATAQAAAABnuWoHAAAAOUlEQVR42mNoYGKw/8EAJO9/A6GrYQyv1jF8jWP4tY/hbx3D730M3+4xvH/HcO8bw90yhlvbGGDqAdjhGYsKgwC5AAAAAElFTkSuQmCC", + "systemDecline1": "iVBORw0KGgoAAAANSUhEUgAAABgAAAAQAQAAAAAkX4I4AAAANUlEQVR42mM4wMDMsP//X4b6//8Y6urtGOrt6hjq5/xjqD8JxI+hGMQGiQHlwGqAakF6gHoBybUeX0RcSJEAAAAASUVORK5CYII=", + "systemDecline2": "iVBORw0KGgoAAAANSUhEUgAAABgAAAAQAQAAAAAkX4I4AAAANUlEQVR42mM4wMDMsP//X4YEBjYGx4ZDDA4HmxgckpkYHMyAWAaKQWyQGFAOpAakFqQHqBcAGz4QyzSHE/gAAAAASUVORK5CYII=", + "systemDotEmpty": "iVBORw0KGgoAAAANSUhEUgAAAB8AAAAfAQAAAAA31SuUAAAAYklEQVR42oWOMQ5AQBRE5yZ7FEfSKTmC25CQuILehkahkc12IvgjRqHUTPX/ew+MzsByNlhxGq7ochz90mFL9gmBFjCSGTxZoSUb1OTwTkquP/Md61cU8USWQzZ5VaCWp+oGeLZn9EklJaAAAAAASUVORK5CYII=", + "systemDotFull": "iVBORw0KGgoAAAANSUhEUgAAAB8AAAAfAQAAAAA31SuUAAAAX0lEQVR42mP4/0H+H8P//sf/GP7V//nH8PeDfB3D7wPs+xi+MzDeY3jHAER3GBjKGG4wMJgx7GBgsGLYwMAgBSESGBh4CBAIxWC9YFPA5oFNBtsBtg1sL9gFYLeAXAUAPIwyHWLMTS8AAAAASUVORK5CYII=", + "systemEv3small": "iVBORw0KGgoAAAANSUhEUgAAACsAAAANAQAAAAAY06pGAAAAPUlEQVR42mNg4LFvYwACFEr+n32fPYiS5/8P5PLLyz8AUXwQqs8eSMn/b7H/D6IO1NmDBA/UgbTzP/gHpwBcwBWO2QYBDwAAAABJRU5ErkJggg==", + "systemPlay": "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQAQAAAAA3iMLMAAAAMElEQVR42mP4Y8/wsZ/h+XOG858Z5v5k2POXwcaGoUYOhIAMIBcoCJQCKgAq+2MPAAFKFVmziLfGAAAAAElFTkSuQmCC", + "systemSlider0": "iVBORw0KGgoAAAANSUhEUgAAAAwAAAAbAQAAAABg3VNpAAAAEklEQVR42mM4YMBwfwPV0AEDAHmKKNims3dJAAAAAElFTkSuQmCC", + "systemSlider1": "iVBORw0KGgoAAAANSUhEUgAAAAwAAAAbAQAAAABg3VNpAAAAGklEQVR42mM4YMBwfwNFCAKuGjCc2sBwwAAAT7olG9TpXdAAAAAASUVORK5CYII=", + "systemSlider2": "iVBORw0KGgoAAAANSUhEUgAAAAwAAAAbAQAAAABg3VNpAAAAG0lEQVR42mM4YMBwfwM5CAJObWC4aoAgDxgAACpUJGftPg+WAAAAAElFTkSuQmCC", + "systemSlider3": "iVBORw0KGgoAAAANSUhEUgAAAAwAAAAbAQAAAABg3VNpAAAAG0lEQVR42mM4YMBwfwMJCAKuGjCc2oCFPGAAAPSIIz417p4OAAAAAElFTkSuQmCC", + "systemSlider4": "iVBORw0KGgoAAAANSUhEUgAAAAwAAAAbAQAAAABg3VNpAAAAG0lEQVR42mM4YMBwfwNhBAGnNjBcNcBHHjAAAMJ6IooqNLP/AAAAAElFTkSuQmCC", + "systemSlider5": "iVBORw0KGgoAAAANSUhEUgAAAAwAAAAbAQAAAABg3VNpAAAAG0lEQVR42mM4YMBwfwNOBAFXDRhObSCKPGAAAHfbIWHuFKlNAAAAAElFTkSuQmCC", + "systemSlider6": "iVBORw0KGgoAAAANSUhEUgAAAAwAAAAbAQAAAABg3VNpAAAAG0lEQVR42mM4YMBwfwM6goBTGxiuGpBGHjAAADklIK1PooVQAAAAAElFTkSuQmCC", + "systemSlider7": "iVBORw0KGgoAAAANSUhEUgAAAAwAAAAbAQAAAABg3VNpAAAAG0lEQVR42mM4YMBwfwMUQcBVA4ZTG8gkDxgAANmVH4SOiUHMAAAAAElFTkSuQmCC", + "systemSlider8": "iVBORw0KGgoAAAANSUhEUgAAAAwAAAAbAQAAAABg3VNpAAAAFElEQVR42mM4YMBwagPDVSqRBwwASoohT92wVBIAAAAASUVORK5CYII=" +} \ No newline at end of file diff --git a/libs/core/images.ts b/libs/core/images.ts new file mode 100644 index 00000000..c3b68f0c --- /dev/null +++ b/libs/core/images.ts @@ -0,0 +1,260 @@ +namespace images { + //% fixedInstance jres + export const expressionsBigSmile = screen.unpackPNG(hex``); + //% fixedInstance jres + export const expressionsHeartLarge = screen.unpackPNG(hex``); + //% fixedInstance jres + export const expressionsHeartSmall = screen.unpackPNG(hex``); + //% fixedInstance jres + export const expressionsMouth1open = screen.unpackPNG(hex``); + //% fixedInstance jres + export const expressionsMouth1shut = screen.unpackPNG(hex``); + //% fixedInstance jres + export const expressionsMouth2open = screen.unpackPNG(hex``); + //% fixedInstance jres + export const expressionsMouth2shut = screen.unpackPNG(hex``); + //% fixedInstance jres + export const expressionsSad = screen.unpackPNG(hex``); + //% fixedInstance jres + export const expressionsSick = screen.unpackPNG(hex``); + //% fixedInstance jres + export const expressionsSmile = screen.unpackPNG(hex``); + //% fixedInstance jres + export const expressionsSwearing = screen.unpackPNG(hex``); + //% fixedInstance jres + export const expressionsTalking = screen.unpackPNG(hex``); + //% fixedInstance jres + export const expressionsWink = screen.unpackPNG(hex``); + //% fixedInstance jres + export const expressionsZzz = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesAngry = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesAwake = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesBlackEye = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesBottomLeft = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesBottomRight = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesCrazy1 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesCrazy2 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesDisappointed = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesDizzy = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesDown = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesEvil = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesHurt = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesKnockedOut = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesLove = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesMiddleLeft = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesMiddleRight = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesNeutral = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesNuclear = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesPinchLeft = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesPinchMiddle = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesPinchRight = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesSleeping = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesTear = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesTiredLeft = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesTiredMiddle = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesTiredRight = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesToxic = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesUp = screen.unpackPNG(hex``); + //% fixedInstance jres + export const eyesWinking = screen.unpackPNG(hex``); + //% fixedInstance jres + export const informationAccept = screen.unpackPNG(hex``); + //% fixedInstance jres + export const informationBackward = screen.unpackPNG(hex``); + //% fixedInstance jres + export const informationDecline = screen.unpackPNG(hex``); + //% fixedInstance jres + export const informationForward = screen.unpackPNG(hex``); + //% fixedInstance jres + export const informationLeft = screen.unpackPNG(hex``); + //% fixedInstance jres + export const informationNoGo = screen.unpackPNG(hex``); + //% fixedInstance jres + export const informationQuestionMark = screen.unpackPNG(hex``); + //% fixedInstance jres + export const informationRight = screen.unpackPNG(hex``); + //% fixedInstance jres + export const informationStop1 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const informationStop2 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const informationThumbsDown = screen.unpackPNG(hex``); + //% fixedInstance jres + export const informationThumbsUp = screen.unpackPNG(hex``); + //% fixedInstance jres + export const informationWarning = screen.unpackPNG(hex``); + //% fixedInstance jres + export const legoColorSensor = screen.unpackPNG(hex``); + //% fixedInstance jres + export const legoEv3icon = screen.unpackPNG(hex``); + //% fixedInstance jres + export const legoEv3 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const legoGyroSensor = screen.unpackPNG(hex``); + //% fixedInstance jres + export const legoIrBeacon = screen.unpackPNG(hex``); + //% fixedInstance jres + export const legoIrSensor = screen.unpackPNG(hex``); + //% fixedInstance jres + export const legoLego = screen.unpackPNG(hex``); + //% fixedInstance jres + export const legoLargeMotor = screen.unpackPNG(hex``); + //% fixedInstance jres + export const legoMindstorms = screen.unpackPNG(hex``); + //% fixedInstance jres + export const legoMediumMotor = screen.unpackPNG(hex``); + //% fixedInstance jres + export const legoSoundSensor = screen.unpackPNG(hex``); + //% fixedInstance jres + export const legoTempSensor = screen.unpackPNG(hex``); + //% fixedInstance jres + export const legoTouchSensor = screen.unpackPNG(hex``); + //% fixedInstance jres + export const legoUsSensor = screen.unpackPNG(hex``); + //% fixedInstance jres + export const objectsBomb = screen.unpackPNG(hex``); + //% fixedInstance jres + export const objectsBoom = screen.unpackPNG(hex``); + //% fixedInstance jres + export const objectsFire = screen.unpackPNG(hex``); + //% fixedInstance jres + export const objectsFlowers = screen.unpackPNG(hex``); + //% fixedInstance jres + export const objectsForest = screen.unpackPNG(hex``); + //% fixedInstance jres + export const objectsLightOff = screen.unpackPNG(hex``); + //% fixedInstance jres + export const objectsLightOn = screen.unpackPNG(hex``); + //% fixedInstance jres + export const objectsLightning = screen.unpackPNG(hex``); + //% fixedInstance jres + export const objectsNight = screen.unpackPNG(hex``); + //% fixedInstance jres + export const objectsPirate = screen.unpackPNG(hex``); + //% fixedInstance jres + export const objectsSnow = screen.unpackPNG(hex``); + //% fixedInstance jres + export const objectsTarget = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressBar0 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressBar1 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressBar2 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressBar3 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressBar4 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressDial0 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressDial1 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressDial2 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressDial3 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressDial4 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressDots0 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressDots1 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressDots2 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressDots3 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressHourglass0 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressHourglass1 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressHourglass2 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressTimer0 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressTimer1 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressTimer2 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressTimer3 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressTimer4 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressWaterLevel0 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressWaterLevel1 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressWaterLevel2 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const progressWaterLevel3 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const systemAccept1 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const systemAccept2 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const systemAlert = screen.unpackPNG(hex``); + //% fixedInstance jres + export const systemBox = screen.unpackPNG(hex``); + //% fixedInstance jres + export const systemBusy0 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const systemBusy1 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const systemDecline1 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const systemDecline2 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const systemDotEmpty = screen.unpackPNG(hex``); + //% fixedInstance jres + export const systemDotFull = screen.unpackPNG(hex``); + //% fixedInstance jres + export const systemEv3small = screen.unpackPNG(hex``); + //% fixedInstance jres + export const systemPlay = screen.unpackPNG(hex``); + //% fixedInstance jres + export const systemSlider0 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const systemSlider1 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const systemSlider2 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const systemSlider3 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const systemSlider4 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const systemSlider5 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const systemSlider6 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const systemSlider7 = screen.unpackPNG(hex``); + //% fixedInstance jres + export const systemSlider8 = screen.unpackPNG(hex``); +} diff --git a/libs/core/pxt.json b/libs/core/pxt.json index 22af1604..24832ada 100644 --- a/libs/core/pxt.json +++ b/libs/core/pxt.json @@ -26,6 +26,8 @@ "shims.d.ts", "enums.d.ts", "dal.d.ts", + "images.ts", + "images.jres", "ns.ts" ], "testFiles": [ diff --git a/scripts/rgf2png.js b/scripts/rgf2png.js index dbdec15a..88d03c20 100755 --- a/scripts/rgf2png.js +++ b/scripts/rgf2png.js @@ -137,18 +137,34 @@ function compressImg(fn) { let sz = 0 let bf -let out = {} +let out = { + "*": { + namespace: "images", + dataEncoding: "base64", + mimeType: "image/png" + } +} +let ts = "namespace images {\n" + for (let i = 2; i < process.argv.length; ++i) { let fn = process.argv[i] let m = /([^\/]+\/[^/]+)\.rgf$/.exec(fn) let bn = m[1] bf = compressImg(fn) - out[bn] = "data:image/png;base64," + bf.toString("base64") + bn = bn.replace(/\//g, " ") + .toLowerCase() + .replace(/(\d)\s+/g, (f, n) => n) + .replace(/\s+(.)/g, (f, l) => l.toUpperCase()) + out[bn] = bf.toString("base64") sz += bf.length + ts += ` //% fixedInstance jres\n` + ts += ` export const ${bn} = screen.unpackPNG(hex\`\`);\n` } +ts += `}\n` console.log("total " + sz) fs.writeFileSync("out.json", JSON.stringify(out, null, 4)) +fs.writeFileSync("out.ts", ts) fs.writeFileSync("out.png", bf) //if (require("os").platform() == "darwin") From ebbbe6e86c9792f69a0d99f2d17db1d9511ea059 Mon Sep 17 00:00:00 2001 From: Michal Moskal Date: Mon, 30 Oct 2017 17:25:58 +0000 Subject: [PATCH 06/13] Add sounds (only simulator for now) --- libs/core/pxt.h | 3 +- libs/music/_locales/music-jsdoc-strings.json | 3 + libs/music/_locales/music-strings.json | 4 +- libs/music/music.cpp | 31 ++- libs/music/pxt.json | 2 + libs/music/shims.d.ts | 17 ++ libs/music/sounds.jres | 134 ++++++++++ libs/music/sounds.ts | 256 +++++++++++++++++++ scripts/rsf2wav.js | 97 ++++--- sim/state/sounds.ts | 33 +++ 10 files changed, 541 insertions(+), 39 deletions(-) create mode 100644 libs/music/sounds.jres create mode 100644 libs/music/sounds.ts create mode 100644 sim/state/sounds.ts diff --git a/libs/core/pxt.h b/libs/core/pxt.h index e3eadfab..e2a31439 100644 --- a/libs/core/pxt.h +++ b/libs/core/pxt.h @@ -27,8 +27,9 @@ class MMap : public RefObject { extern volatile bool paniced; -// Buffer and Image share representation. +// Buffer, Sound, and Image share representation. typedef Buffer Image; +typedef Buffer Sound; } diff --git a/libs/music/_locales/music-jsdoc-strings.json b/libs/music/_locales/music-jsdoc-strings.json index 3dd0fd2f..bdfe21f6 100644 --- a/libs/music/_locales/music-jsdoc-strings.json +++ b/libs/music/_locales/music-jsdoc-strings.json @@ -1,9 +1,12 @@ { + "Sound.buffer": "Returns the underlaying Buffer object.", + "Sound.play": "Play sound with given volume.", "music": "Generation of music tones.", "music.beat": "Return the duration of a beat in milliseconds (the beat fraction).", "music.beat|param|fraction": "the fraction of the current whole note, eg: BeatFraction.Half", "music.changeTempoBy": "Change the tempo up or down by some amount of beats per minute (bpm).", "music.changeTempoBy|param|bpm": "The change in beats per minute to the tempo, eg: 20", + "music.fromWAV": "Makes a sound bound to a buffer in WAV format.", "music.noteFrequency": "Get the frequency of a note.", "music.noteFrequency|param|name": "the note name, eg: Note.C", "music.playSound": "Start playing a sound and don't wait for it to finish.\nNotes are expressed as a string of characters with this format: NOTE[octave][:duration]", diff --git a/libs/music/_locales/music-strings.json b/libs/music/_locales/music-strings.json index 497070a1..5b2bce36 100644 --- a/libs/music/_locales/music-strings.json +++ b/libs/music/_locales/music-strings.json @@ -42,5 +42,7 @@ "music.stopAllSounds|block": "stop all sounds", "music.tempo|block": "tempo (bpm)", "music|block": "music", - "{id:category}Music": "Music" + "{id:category}Music": "Music", + "{id:category}Sound": "Sound", + "{id:category}Sounds": "Sounds" } \ No newline at end of file diff --git a/libs/music/music.cpp b/libs/music/music.cpp index c14a9d01..cae81c50 100644 --- a/libs/music/music.cpp +++ b/libs/music/music.cpp @@ -6,7 +6,6 @@ #include #include - #define NOTE_PAUSE 20 namespace music { @@ -51,8 +50,7 @@ static void _stopSound() { writeDev(&cmd, sizeof(cmd)); } -static void _playTone(uint16_t frequency, uint16_t duration, uint8_t volume) -{ +static void _playTone(uint16_t frequency, uint16_t duration, uint8_t volume) { ToneCmd cmd; cmd.cmd = SOUND_CMD_TONE; cmd.vol = volume; @@ -90,4 +88,31 @@ void playTone(int frequency, int ms) { } sleep_ms(1); } + + +/** Makes a sound bound to a buffer in WAV format. */ +//% +Sound fromWAV(Buffer buf) { + incrRC(buf); + return buf; +} + +} + +//% fixedInstances +namespace SoundMethods { + +/** Returns the underlaying Buffer object. */ +//% property +Buffer buffer(Sound snd) { + incrRC(snd); + return snd; +} + +/** Play sound with given volume. */ +//% promise +void play(Sound snd, int volume) { + // TODO +} + } \ No newline at end of file diff --git a/libs/music/pxt.json b/libs/music/pxt.json index 7e580311..d2c29bae 100644 --- a/libs/music/pxt.json +++ b/libs/music/pxt.json @@ -8,6 +8,8 @@ "shims.d.ts", "melodies.ts", "music.ts", + "sounds.jres", + "sounds.ts", "ns.ts" ], "testFiles": [ diff --git a/libs/music/shims.d.ts b/libs/music/shims.d.ts index 1edf379b..4cfdc542 100644 --- a/libs/music/shims.d.ts +++ b/libs/music/shims.d.ts @@ -24,6 +24,23 @@ declare namespace music { //% blockNamespace=music //% weight=76 blockGap=8 shim=music::playTone function playTone(frequency: int32, ms: int32): void; + + /** Makes a sound bound to a buffer in WAV format. */ + //% shim=music::fromWAV + function fromWAV(buf: Buffer): Sound; +} + + + + //% fixedInstances +declare interface Sound { + /** Returns the underlaying Buffer object. */ + //% property shim=SoundMethods::buffer + buffer: Buffer; + + /** Play sound with given volume. */ + //% promise shim=SoundMethods::play + play(volume: int32): void; } // Auto-generated. Do not edit. Really. diff --git a/libs/music/sounds.jres b/libs/music/sounds.jres new file mode 100644 index 00000000..dcf038ba --- /dev/null +++ b/libs/music/sounds.jres @@ -0,0 +1,134 @@ +{ + "*": { + "namespace": "sounds", + "dataEncoding": "base64", + "mimeType": "audio/wav" + }, + "animalsCatPurr": "UklGRpMhAABXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YW8hAACAgICAf39/f39/gIGBgoKCgoGBhIJ6cXyLgIOVd2tlTWCS0NfUhj8xUJGGlIZEaox6aXxzgM3fzZpyQyxsk4VvZ0k6dqm4qZh/fpenopR7V01cdH6IeWZfc4+gqqmNenh/foKJe2Z1e2+DiXR7hoF/mZGEgn5zen15goJ7eoKFf4aKjIp+dHN3foB8eX2Gg3+Cf4aJiYZ7hH14eICBfHx+g3mAgYeCgoqGgH14eX+AgXqEhnp4gYeCgYiMb4OKenuEgm97gYB/i4B/i359en+Bh4qAfXmIe26DgnaCh4R7fIGAi4qMgHd3eniFinuCgHZ+i35vi4eBjI99aH50cpKOhXyEd2aKlnmDjXp2lnVtf3uAgIuBgIhvfZKHg4R3cnOHiImUeWl2hXuBjHx6iI+Ac4V5fH+UiHKDfm5/mX98gnZ5e4COgXx+eIKMfJCJf396dXR+gnyGkIiIcmVWX4qz9eFuNx06Z4e3lpqkdFNSVHzE3sWbgUElTHaHlZh9Ylpwi6/AqZB0aGx7i4x9bGNebX+LkJCFfoWIjZGKfHt4d32Cfnt7dneDgoGEhYODgn+DhISBfX5+hIOCfHd2fIaGg35/en+IhYSAfnd5hYWJf3V5hH96h4WFfoCEe3+BgICCfnp9goWDg3t6f4h+hIh6dH2HhIN7eYKBfIaIgHp7e4eCg4N8gYB/e36Ag4F/gYKCe36Bf4aGhoJ8fHR6e3yDhomCf4GCgXyGf3uMgHV9gn1yiIl9foB8e4iKg4iKeHF3gXuJh394eoCAiYp/doCIfH2MeG2Wg2yTjmB/lmqDoXJrn29imZBrjZBbhJZiiax2aZx+W4mPYnKcg26HkXV8kIp6eph/coSIbXqCeXJ6gnZ/lY+EhIJ/jId+iG98dnNwhoiKnI1+TD5Tk+LntXlVR1l5b1FlmqCqpX1cZH2NpKqQbWx2fHx2altrgpujn5F6b3N9kJeHdWxocYqThnlwb3SInJ2Rg3R2d3iEiHx4eHp9hImEgHx7g4CEioh6eYB9gYeGe3Z8gIOHgnt/dXqMkIJ1cnd8i5aIhIBxcHyBgomMg36BfHt7fYCDgoB+eoB/hYmJgXh+f4CIiIJzdHeBhYOBf3l/hoqHjH51fIB/g4N6ent7fIiKh4aDfnZ+f32Eg3p6gYR/goeDfn18eHmEh4mIhnuEcX1/c2+RooFxeICAgYF+eIOHh4GBfnx6gIKDg3t9e3+CgoJ7g46CfoODfXR9fXyCf32If3p+iYuKfXeCgYB6fX59foKAgH97hIOGhISGf4B3fX99gICCfn56eYKLjop/cXOBjYyHf3FsgYh6e4uIfY2DbmlpfJuwnZWAV2Z1eYSAcHaOeXOFiYCXoomIinRrdH1+d4F3a3OGi4qPl4R6goJ9eXVxd4WIiYyCfHyAh4WAenp7eH19f3yDhIqEgYiFgYKGem95f32Ch4J4gn57hYp/gISDg4d+dnh7fXuEhoCFgn+CgIKDgH56gYV/gIB+gHt8h358gYWFgoaDeH2Cfnx+goCChoF9fXuAgX+Fh314g4V9hYWCf3t4e4B8hIR/f4OCfYGEf32GhIWCfXt6eXiBhYN/gIF+h4KCg4GFf35/eHaCg32Dhn9+f4GCgYF6g4WAfn98fH+DgYKDgIGAgHuAg4J+fYB9goGIhH99e36BgYOCfH6GfHmCgoODgH+Ad3qFh4eCfn1/fH6BhoGBgXp/d3B8jYiNkoN2f4Rzdo59aImKcXqPdm+TkHmNlnJ4jYF1hYRodYN3eo2JeIOCgIiHgoB+fn1+hoZ9eXt/eYKLeniDgoODgn19e3qDh4iFfH1+gH99hoJ8gXx+f4CAgoKBgH6Egnt8goJ9f4GDgoCAgX2Afnx/fX+Fg4ODf39/goZ+foJ6fH98gX2ChoODfYCAhIKBf357fX+AfoCAfoCAg4eGgn97fYCEgH5/e31+gnt9gn+IiH+DgHp/gX9/gX9/goB9f4J+gIODfIJ+fYCEf32BgIKBgoN8hIF+fXt7eIOJhYF+f31/g4OFg3x5fomCgX95fH6DfHuGg3yGhn+Bf36BhH+AfXl7foWEhISCfYF7en19hoiFgoJ6eH5+gYGBgoGDf399goN/gIKBgX97gH9+e32EgYCHgYCEfnt9gYKDfYGBeX97f4WDh4KIgHZ/fnqGfnh/e4GDg4iAfoKChYCCgn58e4B8ent/hIWJg3x/gH6FhH55e4J/hId+enx+gYeBgYB/gIGEg3t7foCBe4CDg4CAf4KEfX+AgoKBfH+CfXl+hHyChIJ+gIaCgICDgX98e3x4gYJ7hIWDf4GDf4GEhIJ7e4B6fn2EhYJ9gYF8foaBf36DgH2Df35+g3yCg3t/hoN/gn97eoSAgX5+gYKAg4KCgnuBfn+AgYF7gn6AgoJ8eYCGfoOFhIF9eoF+eYaGf4WCfXt5foOEhIKGe3uAgH+BfoV8eI98fXObfXSPaoh4nHKAhnB5eJtxhox9e4SLfoSDdV54iImAh42HgICAfX19gH19f36EgnyCf36Bf4SRkId8b1BOdZSlqquVfYV8aGxmZnd2e3lxhZOWpKOKeX11dIKHeG1tanN+ipaUjI6EfYN4eol3aHJzfYSSkXt0eIaXnZmLcWhxc3J3f3Fsh4mElZKEiImAgIF6hnZphIdweIh8dYeHjZV/cXd+goV7go2CeHt/f3l+d4iNfn6QinSCenCHf3uOgXqDgXuEfXaBjYKFg3Z5gXuAjYlzd4eHfH1+g3JxiYuEk4p4fXJ1jIp4hnttgoV7g4Z/gYx+eIR9gIOIh3l6gXR7jnt5hHF4inx/loaKint2gYF+enl6h4V1eIN7fIOCiIt7fo6HfHuEhnqBfXN4fX2BjoFyfIaDiYGBhYF+ioZ4c2uDjouKgmRli5yLb3+Yf2R/knh3i4+EeH98cnJ4g4mDgISJh4uJg3psdX6Ag4+ZiX1PLUOIxu3MnHRIVXh8anJ5doB7aWmBpb+ym39hUmR+kZqCYV1ugZKgoZJ/cW91fYSGe3JsbHeMl5aLhIKJjIeKgnNnaXR8g4R5cnp8iZyQh42GeoSKeXNtbn6CgoeCf31+foWSin2Af3t6e3yBfoB3e4d/d4SKjYN5ioZ9f313fn5/fniDgn55iox8gImCgIR6dnuCf3+GenqEgIGGhoJ8foGDeH1zhY2Dfn9+f4aHg4GEdXR8enl/gn2ElZB4foN8f42QenBxeH56dn1+g5aRgoeGgYCChYBmbnZ3iIaJhX59iZaOfW9vfoOAfXx5eoaDiJN8eoqNenV8c3J+hn2DgoJ+iJSEeoWGfHp+dnl8eICFg4SGiYR8gH5vb4eNgoF5f4yIgoCDgm5vg5aUk4tqUkRCZbLc2cOTamFgUDlFcZexpopwboGVnZ2SfWxxeXp4cG1ve4qbopuJenFucnx9fXludYWFh46QhX2Lk5CLgm5oe2tpjHNEiNiJNpLLY0bAuUFovoFTipttW3SEgoKWjWtsfpGkk3Bnc4aFgYR5eoOKhHh4eoCCiYaDeYCEhYOBem13h4WRjntxeoqHhHh1d4OEeoaIeXZzhp2SgYN8ZnB7gIKFiYmAe4eFfHGBiHqCkHtygIF6god2go2Jh4Z7aG9/ioWLg3tzgYCCiYVzdoaIkZKDdGd3gHuCeX6IfYGRjn1+gHuBg355dXqEioJ6eXeJiomKenp/gXx/g3lyeYSIhIOKioCAhYV+eHZ0e3p9gYmJioR1e4F+f4OChIR7iIZ6f4R8d3xicpqzr5lpJhZRlc/gzKd9ZmVSPDpfm8C6lW5aXnqbpp6Mf3d8fnhpbHd7goePi4mIgHt2dXx9f4WEgoKAfH19gIaMjJCKg3htbXN7fICAfn2AhIeEiY6Kg4iFe3ZydXp/f4SFeXqGhICLhnyBgnt8f3x7foGFgn6IhH5/d4N+foWBfH6Eh3x6f3+DioZ+goFzfIN7foCAhX98gYmGe3yEfX1/iXh0foSMj4VyfHt3d4SXlIN4c3FxdXiOmo2JhHN0enyFioaCe3N+enV/kpF1eomCgImDeHh4hIJ+gXmAjoF5gIJ/gIp9eX+BgICMg3dzg4x/d3qHhICDgX17c4GOfHiUh3Z8d3aBjIKNkoN1cnN2hoR/fIWEgYB9gn5uboignot7Z3J+hYZ0eHiSpY5sRDtcnd/tw3RGRl1qZF5upMS2il1EUH2qwLSQcWVhaXJ6enZ3jZudm4x2aGt3fYGJhoB3eHt7fXd+i5Kam41+dGlmd36Ah4SDf3dwcoCNkomEjIiGgHd1enZ/jIqHenBqdIWGk5CGg3d0fX98doKJiYiGgXmDem58g4F+gop9foOAfIGFg5GPgnh5cHN1dnuDjouLgXaAiI98f354f4J4foN7dHmFhouJj4l2cXx+eX2IhX2BenR8jIqMiH6CfHV4gnpyfId7gpyKen6FeneKf292hoCFj3t7gIGBhoKEeXxza3+SjIGCi4WAhYFvboGHh42Ab3B9i4d6dYCEh5F+e42De3d4fX+DjoN7am+JjZGSfW9zc3yIdoCIjI+Sd3uAdn9+gnd6gHuImpyMXTE6d7Pr465kPEdeVFBxqdbMpGQ3MVSSwsWmg2peXWp2eYGNlZmVjn5zc3V2fXx2coGMi4d8cHF9kJyhlYV/c2lnbnh8gYOFg4CHg3yChH6Fjo6IenZye3+BgYOIgnhzbniNkoWEhIKBhoR7dXWBgH2Ff397d4GEh4mEfnt/foOJg3SBhYF/enh8i4RwfYmIi4N7dXuDfH9/hYGFhIWBfHZ3hoGAg4JxfYOAhYuPiIJ0a4CAiol2d3x7foN8gJWQfICFemh+komKempgf5uQhn9zbn+VgX+Pf3WHhHl5eYF+gIGDfnyMgXd7jol6fX2Dj4NxbXh9iYeCk4N1f3l3fIWGh4KCiYBxeH1/hIqHd3Z1eoyWiod8bnd6gIODf3uCjHx6f3+HhI2MhnxebYKCd4iahHyNeFdwlKCXi4CBf3hJKE2U0+nLpGZDYWZCOmqm1dmcWjpBbp2xqZSAeXhvZG57h5GRjYR7ent9fHlzc3uGjY2Jf3t5fISKkYqFh310cHJvdnp9goaKiIeGfXqCjJGNh3tubXh7foiEfYeGfHl6hYJ9goSBgIGCgoOFhX98fHp5fYF5e4B9eoeRkImLhXx0dXqBfHp7foOAeXiJh4eNiIF9gnx2fICAfnVzfY2UjoV1b3mBhX95goGFi4uAd3Z5hYiCcnN/jY99eXt3g4eRi4OAe397bWlqgJmYhX+BgIaKe3t/hoqBeGdkcoaMj5GLhouCdHh6e31/enmAioV5eYeHk459d3F6gXp2fYB8hIuMjIZ4eYSLiIBwbHOBg4CHgXiAiIWDgnx9iJSDfH58f3t6c3R3g5iOkJ5oMjdtlrPW3K6Adlw5M0NhkLCtlntqZXCEm6iiknxzfoqEenJraXN8hId9d3h5foWJiYqSj4uKiH91cHR9hIN/enRtcXqDiI2KhoKAhoaNjH91d3Z+h4N4dXuDhHx+gX9/iI2QiX57cW11eoOGhoWKin58e4CEfoOBgH18e3p0dIaJj5GDgYF9e4OFhXp4eHV3fYGAhIWIiIeBfn6Egn94eHuDjYWEfHNyeoaDhYCAgoWGgHx+g4SIhn97dmxzgo6LhYF2fICChoqJiYR0amx5go+XmH9eY4CYn5NwY3CJj4NxboCVl4ZzbnWBjpCOgGhof5aNf3BseYuUkYp8cHN8h4l9c3aDjoSCh4J/fXx6eIeLg3h2eX2Dh4yDeHV5g42Lh4uGeXJydYKKfnh+jJOMclpdcpOtsZyAdG1wdnl3dYGLenBpdYSQko+Kgn6BiZaXh3dvbGpzgoJ4cnR0foeLkpSSjIeBfHqChHBveIOBgXp2fH14go2Kh4aGe3d4gIaOi4aBcnJ3fH18g4qGfnt/hISHhYKGgHl3dHd+ioyHgHh7gICCgIOCgoOIgXd2dnyHi4F8fIGHiIJ6dX+Fg4aCg398ent9fIKIh4F5fHqAgYeGhYd8goaBfHd0dHyAg4OGiomIhX16e3t5f4J2fIeOi39/f318en9/goR9goOEhXx3fYCDiIaBfn16d31+goaIiH95e36Gj4Z8d3h6d3yBiISAhH18gYmIjYd3dXV7e39+gISHhIeHfHV9fX+HiIB0eYOCf4KBhYuGhHZ0fIKNjYBrWVx0kqqtpIl0bnR2foSAfHlxbW9zeImUk5GOhH6GjIqFe3dzdHh8e358b3B9hoiLi42JhIWHh4J+fX55d3h4dXV5f4mFgYuNhICEiol4cHF6f4OKhn9+fH17hIeEhYOCfn56fHuBgnd7g4aKjIJ6eXx+foB9eX2DgYmLg36Ag4mGenFwe4SEfHp9g4mMi4F6foKAe4B+eoCCgH92eX+Ih4aGgIN+fIOAenmAhIGAgH9/fnx+foGBhoSAfYCEg4iCfnx5dniBgoSDgX16f4GGh4iOiIF0b3N6gISFgX98f4SEg4aGhIB9f3t8eXqCf3t8goKBhomFhoaEfnlzcXl/g4F7fIKJjI+KgX6Ae3VzdXuEipOTgWJQXHmbtbaggHZ2cnFuam58hoSAeXR5jJqajn50eYqWkn1saG57houGfnR1eICGhIGFg4CGh4iKhn99eXZ1f4mIf3Z2d3mEioaDgoB/g4OAen2BhYeCf3x9gYSDgHt3dX2Fh4aAenqCh4eAgIKChoZ+dHd+fn56e3+HiIqFeXh7hYyPgnRzeYGAiYd7eHd/iIR/foKKhnh2fIGKi4NwbXmMlI17b3aDj4t9cWt9kZOCcnB+jI+LgXNqdIiVlYZxZXWGjY5/bXKDlJaEdHF2g5CRf3FvdH6IjIZ+gX+Dh4N1dICOjYB1c3mBhoeAeHqCj46AeXp3eoKHioN5eIKIhnlvdYSOi4N5cHaKk4mCfn2Afnt6eXd+hIiEfXl6gI+SioJycX2Ej4+GhXtRMUiLyNTBoXZja2hLRW2q0L2BQCpJgq67spV7cmtpcX2LlpOBeHZ0dIGNioFzZ259g46VjYJ6d3uEj5WLfXdxdX+Dg3p5dnWEiIZ2dnmBjpWVi353foR9c3R5e4KIh3x0eoSPlYFtcYCKh4B7d3yJj4Z9enp9hol+dHR8hYyLgXZ0foiLh396f4OEgHt2d32Bh46FeXuCgImIfXZygIeAeG95jJmWinxzdnuBiX10dH6IioZ6cXqJkJKFeXF8iYV+cW16hZORgXd7fnyCh390eICJk5KDbW57hIeEfnh4goSFhHx7gYiHgHl6fomRiXhub3aHk4p+eXx4g4qAe3eAhoV9fH6Ci5WJeXFzfIiOf3Fsc32IjoWChICHkJCBa255hYmHg4iPaz83aK7U07aLZVhRQkx/vNKxdDkoSoe4xLaVd25oZnGBjpKIdWltfI6VlYl0ampzgY+PhoB7e4CCg4qLg399eXd9gIF9e32Bg4qIgHRwd4WSjoV+d3N8i4yIfX6CgYN8dG54h4uMfnR5hYiFhoqCeH5+enp7g4B/g4GAf3l/iY6IfXx6enx/hIKIg3p+f3x7f4B8gYeCf4CGiYJ5foOAgoF6d356e4SEhIOBh4qAd3Z9iIyIgXZ0d3l+hoiBgIJ9hIOIhHx8fn16g4V8e4N9eoOIhYeEfH5+d3yDgoZ/eYCBen+EgYSAfICDhYSBgIGFgXp3fX+Dh3d3gH56f4WIgoSHiIaBgoB8dnd3fn5/g4V9e395gYqJiIyJe3h7enN6g35+ipuQf2FNX4GhsK+Sd29vampvf5WlmHtfUll4l6ifjoFyeIWJiYV9fHd0foF4fYyCd3d0dIKEiY+OjIV+fYWCeHt9fHh5g4R+gYOFfnhzfouDf4WIhoCAg4F7fXt8hoF6gnx3fIGFiIh+f4ODfHd9enKHmJB+eXd5gX+GgXtxdIyPhHl8g4eDhYiEfnJ3gn16foCDhIN9f4V8gI2IhH52dXN/hIGJg3d7goOGh4WGgnd2f3t9hIeDeHmFg4mJeXp/fYB+en6BhIeEhXp+f3yCg4Z+dHeBiIqEfnyDgX2Df3uAfn2AgYF9f4GHhoJ4gH97g4aGgHt5fYCCh358eHyBhYeKiH55eoN+eHl8hoWHhYuBfHt+eHd/c3uChYmJiYuFfYODdXeEh4d8Z1JbfI+lqqGTioB4bHJ5f357c21udHqFjZCSiYuNhoOKjYNyaG92e4Z9eHZ3gYSNgnqFi4mRin94dHqKioB4dHd9f3t8gYCEg4J/fHuDkJSLfHN3coGEhYV8fX2Cg4B3e4CHi4p+dHZ3gYaKi4Z3eoKGgoFzdn5+goGAg4SKjIqDdG90eH2Dh4SCf3uKjIaAfn18e398eXx8hH9/g4SIh4KCf3V8f4SIhIB8gnt4fHt+iIuDg353eISEgoOAjIN3fIJ7h4F6hHx0dIGMhoKAhH1+gIiFhYB/hH14c3t7d32Jh4aJf4SHhX10fXp3iYt+d317goaBhn15gIuDd4V8boSKe4SUeoR4cYaHc4COhnp7dn2FhYmNgXF1c3eTjX2Ng3qCf3KBhn6Dgnt7fnaCiH2BhXh2jo1+iIJxgISEj4NseXlygn92iYmHiYSDiXZ4f4B8fXx9hoR8hn1/goN/fX99iYR8eIWCeYGHfYKDfHqJi2d4j3h8koiAeoZ4hH5ujYJzk4pvfXxzf45/jot1eoR3hY99dHeBdH+EeISSjI2RgnVrcXiDfYF+eIKBjYaEgn2AioJ9gXd2fYGEiIFpdoWFkIiEdnyDhIOFfnl3g4GCg3F5g4iDhIl0f4eBioh2c316g3uAinp9g4WGg3uFhYN+d3hzfouNgXeBf3yGg3x7eIeIhoN2bnyEipOGe3h5eoSPhHZxe4GCiHl4f3eOmYF9doCAgYiBg4p9bHx9c3yEf4eAgZKCcIKSeYCQe3eJe3SLdGmFi3eNg3KDhH+LgnOEjX+Bj3Fqin6BjnuBfXl+f4F7gn55ipKHhn1teoB/g3x3gYeFi4SAfoF+fX+Ad3iBh4N/fX14fX+FiIuLioR9eHR/fnt4iHt4gnt/jYqDhYGBgHl+fn59gYB+fIKEiHx1fnqFh4KIiYJ5fHp3goN5hIZ7gIWDgXl+e4F/hYp8en6FjIaAeHl4e4aFgXx8gYaCgX59eX2HiYuHgX16e3x1en1+g4WHhoR/fXp/h4mBe3x5foR/gH59f4CKf3yAhIV+gH+EgH19f4CAfnx9gY2Pmng8Uoi2mIqTeYmKg15RT3Czr5WRc3J+g3locmqQlpykj2JXaXWPppeHenZfX2lzh5ampY1ubH6RiYaCdnV4emxmYW6SqLOihnVzcXV3d3mCiod9fH58eXl8iZGHfnmAjZiSfWhcXXSHkpGHh4mChXVzfomGh5mWcmpnUluInI6ZnYmUkX5zcG11jX9wb3Bjb4aWn5+ShX97d4SQhnZva2d7hYmNjYl9fnh6fXyGh4B9gYODfXyBh4N/fHJ/ko+NfGtpdo6NgXt6cXqIi4qBe3l+k5OIgm9mcIKNjIR/fH54e3yHkoqDgHVsboGLjZOFeXp+fnR3gYWCf4R9doWKj4eHdnJ+jX58cHSAgo6MdnWKdIOXg3x/fXSlkGNzhmVkh4B8k5qbj5NzWWRqdpOloZuBZFFfeoiVl3xvbHF9mb2kg3Job3yBcnGAhH2AenN3i5OWmYJ7cXeEiIF2aWmAlpqPgGtlcoyYp5pzZlthb4eenpd6am13h5ScjIV2ZVxihpSaoo90b2hoe4WVnJaFc3FtbX+GhY2IgoGDf4CAfW90gIaKioV3eYOBf4p+eY+FdnZ9g36Fh3Z4fHSBioyKk4p/dmttdXuGmJB6enh7gISMf4R9fYCFeXeHfX6Ef32Agol+en17gJOVf3Fyc3CCjIqCg4qAgId8dXqChH97f4F6f4F8gZOPdn6HcHaGfn6JhneEjHtzg4J+d4B+j4F9dXqcl318bG+AjIZ8enBzfZWQiIV9dnyGjI5+k5ZrYGFfZIeOk5GEd313irq4l41wYUlncW55amdxd5a/tqKNh3t0e2t1eXFlbXR0gZmfnpeCd3Fzf4OCe3h2dXyJjYOBfoOHhoR/e3Z+eH6IiIdxdH57g5SCg4WEdX+JfnmFenN6gIB8jIeGh4F/eXt7f4GNin55cW16i4yUk3xxdIF3hYdzdYWIiIV9gXuHj3t3d358goyDeHVygoiPh41/c3Z8hYOKg3V9gX6Ae3yCjIF/g3uAf36JfYCDeHuBgn1/gnyHhoKFfX6CgHdwhoeCfXt2goOFjIF9gYKFi4Z3fHJ6fIGHb3+Gg3uMgIl5fniAkIl6gox2boKEi41vcXmNfml3i4mMioNmfoCMl6CTeXdxdHhqa2pogIiMhJCPipCcl5OIiYJsYVtZYHF7eoOEiaGuppOHhXSCe3FtbHFnd3p6eI6UkpaSh32Bd3lzgHx5fICEhH6ChIN7e5CHe354cXt+gIqIi4yCgIRwdnd+hIKNiHlzeIOCgYd+eoOGiIWEeXh2e4iDh4KFgXZzd4qOj4d7bHF5eoqLh4l+enqBeo2QiYJpYHWOlY2CdnCCjYB4doaSgYNzcXyGiIqDeHuGhImUh2pkZnySmoF2dneBkomKhYCIgXp0dHN8g4OBf32Ch4OFh4F3f4GIfn96f412fnx7fIOAf4GGhHqAgIF8hod/gIaHcnyIgnp3e2p8i4yKjX1+hYRyd4Z+hIyKeX6IgG9zeHd3fH2FgomXj4aFh5CIjHl4bWJqbmhvfYOSoq6PhIeCiIp2ZW94dm1ueHyGmZeMkY6Bcnp9en58a3Z9dZCRiYCBhIWHfoGAd3l8d316foaOh3aBhIeEgnt9gXaBg3uAe3uCioSBe32DfYiJgXx7eH2DhICCfHp4goSGhIqIgIB1fHd6gXqBh4mGiHt7fIl+fIKAe3x8enuJkIl+gYN2eH+Af4GFhYB7dXmBj42MiHB7dHV9hoqDhYR9bXeAgIOQjIWMeHl2eoB+fn2BhH5/fYZ3hoaWhHd6dHJ7koGBkX1xeY1/f4tudX55jIeDiYZseoWNlZCKZnB0cXd9h3qCjXuAfYKMlp6OiHVwdH6DdGZdXWZ7jKOumpWFgoaOjZSRdlxOV15qcnt5jpScn6Ojn5V2dGxpb3Z1bWtoanWHm6KnpZaDbGdub39/eIB7hX+DjIqBgIR+f4aBdHN5eYGGhnuIhYONjX6BgYR1dnRveoSBfHyHin6HjZGDhYJwcoWCeXd8fnGAh4KLh4iFgoN5bXyGi4GAfXd6eIOFhIeGgHmAiH94gXt/f4GGgH2Lfnl8hYd6fnhyfX6NjZCDgYOGgHh/dHBwfnyEhouJf4SGiIqFfoFwcHd7d4CHhH2GjId/fomIeoR8bXh2gX+JiYqCgn9vhH11hI6EdI6DeIF2e4GDfZCVgnd2d3d6foGCg4ODg4KCgoGBgH9/f35+fn9/f4CAgIE=", + "animalsDogBark1": "UklGRkQXAABXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YSAXAACAgICAgICAgICBgH+AgICAgICBgICAf4B/gIKCgX9/gH98foKDg4J/gYF7e4B/foWGf4KEenl/fX6FhYGFhHx4fXx8hIiGiImCbGl2f4eQj4qMh3FlaneDjYyIjI+DcGp5fYGEf36EhIGNmZOAWU5oe4WTpq2nhVxSW2t5hImfraKKdFlbZHB3g522t6FxTUJNbIOXqr28kl5ERGJ9hI2vxqBuUD5rl5iTk4pzZnRncp2ipZZtVWJ1f4KJoamTUDtvmavAm1tbZFlVdKm2yrtpQ11ZZHmTmY+Yfm+XpqJ9Ri5Ke4mXxcjBk044QE6GjKesfX2RiaaUZjM7f4+Em6yyq4pkPkJvgoaGjZKsraCDXyhKbHqVp7CupI9rP09kYXuNqLG1sINZPE1VcI+qqqiwlnNRSE1ReJ+0wsKaaUhMRVd+may3wqaAWTkxTnaaxNe9i1tQUz5ahJeez9GeeEQZNWKGwey3hGxjZ0g3bpGtzdmhczEnV3CBwsiFc4uMeTo4fZOmzceENkJbdZe6qGNYlJOHW1FtjLrUrFwhP2+fv8B0RGyTj3dqZGmnzciKLRJdf7fnr0o/gYWfalVdgbThyHYVI26ItMORUmmUf4NwV2aatdeXPC9ee6fQjEhgm3uXeFVpfrHRs0weWomstotKV4SjhpdlbXmfxY1RJlaSzcaQTU9igpKOcmuOwcKPXBg/Z866pFpxdYlunGVihLPAjlk1WI/WfGNsgWiDq69WYYGrrWhXT3qtum9daHxydLOgcXGgpH1NO3Gbw6RuU3prbX6nlHuRsZBZOk2Ptb16VWJ6Z4mwlIBzq4xxWUBNnOW9d2BjSGGHqnOOpruSYW9FNJjVjF9rjV2HsptlcaGFeWVxWHbIx21UcWFZia2Lf5Wue2h7a1WHsHxTdYiAjK+iZGOKeW57inN4v6BjWHhbYZK8joaSkGhif3xmjauJW2uHd3Wkn3RxiJNraoCGcaGvd0NoeW+Otq9scYJ+YWp/g53EmFVGXFVoq9SpkomBQ0RqfXux3pA6XnNXfrq0bnaLhFxplYJ4tLJQO2dfZ7vfqHF7dExGgKR0k9mWOE6BRW7F1IVnjIlZQKqSanbPijNfnl1dr9aXXoORT0eQqGZuw6lKQJ1/W5LDn2ZzjGhMi7KFZIGyf0VqoV9Umsmae5aHV0KAnYBhibqTXW+OUE2UyKR3fJZuWXKcgEt9sJ9scI5uVYmylGt2m4RuhIxzWWuYfn2OpJVvYml8fImbn4dzfIVrXmuGjo6QnH5fcYeTh4V2bHKNnp58X1NqfYmoupVwbmhSWIqun4CIj3doh4psWoCYhneSn3Vje5J9d4OAa3WNoZ1/c35wW12BnaWWi4h4X2N3en+Rl5COi4N5aWRocXmOnZ6WjnhvdWtnd4WKjpyVenJyg4B1c3R1hJSgkn54dW1tf46Hg4uEdm92gIqUl416YV90gImTmY6AfXNsdH6Cio6OgXh3f4B9foF/fXuCh4mLhn51cHF4hI6TkYd6cWtsdoaWmZODdW5rcX+LkJCLgXpxa3B+ipSXjn90b253gYqMjIaDeG9xfoOIkY1+dnd7foGFh4J9f3x1eIKFiI6Mf3V0eXt9hYuKiIZ8bW11fIeUl4uBenNxcHiDjZKRh3twbHB7iI6Ri4WBfHNtc3+Jj5OMe25xe32AiYyGgoSBd3N4gYOFiYR7fYB9fICFhICAhYR7en17en+IioeDgHx0cnyFh4qKhn14eHd0eoiOjIyIem9yd3qCjpGLhH11bnB9iIqPjoR6dnd2e4OJiYaBfXd5f4aGhYF9eXuAhIWFhH94dnh8hYiMjId5cXJ3e4iPkIh/eHRyd4GIioyLgXd2eHuAhIiIgnx8e31/g4SEfn6CgX1/goGAgn55eICHioqHfnNze36CiouFgoJ8dHN6gImPjoR7eHZ1e4WHh4eGf3l3e32EhoaBgYB9e32BgYGBhIF9en6Ah4eCfXp5foSGhYF8e3+Cf36Ag4SDgn96en2CgoOEgH59gH5+gISDgH9/fn1/g4WBf319foCAgoOAgICAgICAf4CAgICBgH5/g4F+gIF/gISFgHl8g4R+eX+DgYOGg317gYJ+fX2AhIGBgoB/gH1/g4N+f4GDhHt3hIyFenR8f3+AhIR+fY2RfnR3goN7eHyDfn+Ai4mFcIKUh4l5bmd4eoiEf3eMlJaUf3RxfHxwbIB1iH6JkJN7gJiZi2lqXHl2cHeNgIScqaaIhGZfZ31VcnWFpIamqJqSczmDeE9pdIyIi7mulZlcV4NgbVNxnoWap5infVp5XnFkZI2klJeek4JSYGeFjIOMf2p5npCVem9vcJGYn4FWRXmQen6lopCUk4FhR1lncoeQpqioopJ2XkVLdZOOZZSVhJillIZZT2KAp4N4joNYfZ+jooBuTVJygpKofHGOqqeVelQ3UnKOlbWbhoyNd3dpTlx2mJm1p4lffHlviIFlP3iHpqqvgm11goCPhE1RXYulrcWcbUJLbHuLhIiUpa6eiVY/UHltd6KrkIWJoZ1gLVuWl4qbkXJmWp28sGknXXFwj7msgYqfg4BnUEhLjZeUrMKjgXhbLExviZu31KVvXmlkbGh6dnN7mKSttY1WZ2dobXR1jYiWs5yha1tAUFmPma+tw5t2YFRdZFlvkJ2mi6Ssk1VHUWx9kpinu5xzTFNaV3iopJ6akIt3cGB5fHN/g39ufJOcoIZmaX+bfV54nY59fo1+T013paabg6CWgFhQZIR9g7ySa2dlZqClj3J2mZpgbo1uWY6vmWhcdm9/lZqIkpeNZWd+dWiDnoNmVX+aoa+bZGJ5cnd5iYyCkZaQXUtZb5eppJ+DhnZie4GBZXmAjYt2b4OIloV0g4iUcnSAoneAa3JabWp8qtO7eWBzaEZrgbCSso9WVmtaYYzIwZqIdmQ6apCqmn1mZFNfg7/gqHpfXj9jeaDBp5RbRVRpeJSrxIyHcXFjXZOJo49sT2xocHi2y6mEbXhSTVyKsb2cZ1tpVF6FrMGciIRqSmSNmKyUaFpUWGqMuc21iW1hPF1piJ3LsWpXa1tLe5nFlqmRektKdoWmk5FvZUZlgcHBrYpmVktqd3uOv7iDW2lrU2CEoamYnpuCUU5ykJeHgHBgU2uWys6ngU0+THCIjJu7sHFKbHdRY46rqaWhjGlHWnx+iJSYc2RygZOinoFdXH2Xk4OGgnBdfqGNdmxtanCTsquZhnVbUHOHiYB5fnqQm4qJi4RkTl9/kbGxnXxnWVpgiJ6UhHV0eJGcpJd6WUFZlaubhX1zY2OFsLaXbmFHTm6Xr7OlkHBcYnN9dn+LjH2CiJSKgXp4dGhoepmkoImAclhTbJm1qHxfZXd1e5KnmHplaICWmYhyZ29kbXSiqq2bg3ReZU1cepuvrJmHhHVtX2dhboKOo7Cpgm9lXmR/kpGHd3N3iJeXk31uZlxke5Wqs599X1phaXmNnZmKfX5/iYyHc1tebYOQmaOZindwcnV0dnV4hY+Zkol+dnN0hYuAa2h6io+OjI+Rd2hlfJOHhXJ6d32Eio+MhXhzcX6EioaCgXd3fYODhIeFf3t9e3x/hoaBgoB8eXqBhYiFfXp7gIOEiIh+cW54hI2OjId/eHNwdoCGio6OinxvbnWAg4qNjIF2cXV+g4mOi4N6dXZ6gIOGhoOBfXp6f4WGhYKAfHp8gYaDgX58fH+DhYWDgH17eXt/hYiJh4F2b3SAh4mKjYV6dXV3fISKiYN/fH18fYGEh4V+d3mBhIWDgn15eXyBhYmGhH59foF+e3p8g4SEgoF9fn6ChIJ/fX5/gICChISBe3h3en+Hj42If3hzc3iCiYuIgnl2d36HjYyGfHRxcnuIkpGMgXRsbneCjZKOhX12dXl+gYKEg4KAgH58f4OGg4B+fXx7foSFg4GDg355eHyChIOEhIOAfnt7fICDgoJ/fn+Bg4WDgn56eXyAgoWHhoF9enl6f4KEhIOBgH+AgX9+fX5+f4CChIOBgIF9e3yAg4KDgYGAf359foCBgYKDgn9+f4CAgIGDgHx6f4ODg4WFgHl3eHt/hoyOiYB4c3R5gIiMiYF7eXt/f4OFhYF8eXp/g4aGhoN8d3Z6f4KEiYuIgXh0dXqAhYmHgn59fn9/f3+Af3+BgoWDgYCBfnl3e4GGh4eHhH53dXqAhIWFhIB8eXt/g4aFhIB+e3l8goaGhYF8eXp9gYSDhoSAfX5+fX6Ag4J/fn6CgX6BhISBfXt8fYCGiIaBfHl7e32AhYeGhICAf3x6fH+BgoCBgoF/f4ODf3t8f4GBgoSEgn56eXt/goaHhIF+fX5+f3+AgH9/gYSDgX9/f358fYGEhYSCgX98eXt+gYKEh4eDfXp5en6Eh4aDgH16enyAhYeGgX59fHt9goSDg4N/fXt8foOGhYJ/fHt8foKDg4CAgIB/f4CBf36AgoOCgoB/fn1+f4CAgYKCgYOCfn1+gICBgYGAf39/gX9/gYKBgoKAfX2AgYGBgYB/fX6AgoKCg4F9fH+CgoKCgoB+fX1+f4CBhIWDgH19fn5/goSDgH59foCBgYKCgH5+gIGBgYKBf319fX+ChISCf359fX+Bg4KAf39+f4GCgoB/gH9+f4GCgYGBgYB+fX1/gIKEhIKAfXx9gIGCgoGBf39+fn+BgoKBf36AgYGBgIB/f39/gIGCgoGAf39/f4CBgoKAf39/gIGBgX9/gH9/gIGDgoB+f39/f4CAgICBgoKBgH9/fn9/f4CBgoKCgX9/f39/fn+BgYKCgYCAfn9/gIGBgoF/fn5/gICAgX+AgYODgoB/fXx9fX6AhIWFg4F/fXx8fYCCg4KCgYF/fH1/g4aEgH99eXl9g4ODhYWCgoF+fH17e3yAgYOGiIWDgH13d3t/gIWFg4GBgoOEhYJ5cHR6gYSIiIWGjIuEe3JpaXSEi5CQjIeEf3pycHN4fYaMlJSSjHFaaW99h4iIiY6Zl4l2ZFhheIeQkJGOjYqEcGFqfYGOmZdzY4CHe4N/bnaPoJmEenBeaIaOhIOKhIGBhHxziZqWa1BtfX6VnIF1i5GFhId5UVuKj4WIjnp6g5WvnWZITGV+n5+OhoqEeomdg1pab3p8homCgKLIp2NGV1NdkaubiYd+fZmpi19CW2Jvi6CpyrV1U1pdVHKOl46Hi5GYn5FxUURVa4Cg1sx8Y3RfSnWWimx5lZmYsqJtM0NiX5rdunNmb2d3l6B3U2eJjKLBllo+TGqqxphuY1Jgi7a1im1oZXmlonFPVnCQwraPbkU9ZZeznY6Fdn6Vm3w+RHGOo6ylg0tag5iIh4x8c4mTkG9adpuQbmZ6Zmagx61/d3FRYIyYdmyYrY1iZ21eXaGzsISCcnpqe4B8a5mmgUtgcml9scaqgm9qYV53gX2Yv5VUUGlVc6PKr49pd2RfbJaMpKGGSEROaJC8yb+QZllUWGuPnq2yg0dFUlmIt9fEiW5aQUdvo624snc/PUFklMPauJN6PzdHgJq2wqlhPjxKdKHV1q+CVys3Xpew0r+GSzM5VYe61sKec0s4QXeiuMasaj09R3Kiv8qvgFdGP2KVucKzeERBT26VrLusd2ZgU2WUrrSfb01LWH+aqLSZamFkYnigtquDVFRib4SXpZ10ZXN4f46lnpFoS1RxjqGbmIleU3GBlaCsm4FRSF+EnqKVjnRGVH6bs6CgjnA/P2uit6aPgFg1Woastq2oi1ImS4Sws6SRdDwtZ5jKyqiNbDgoV5nRwpyBXCkzbqHPzLeOYyggWpzWyqGAUiEzcKjj0KWDXy0bVaTgzqF9WCIpaJ7Y2biPZy4UT5jSzKiFYigjZJ3c3LKHZDcfSInO2q+GZD4kToe918Kfe1QmLmu32raQdVEeOHq049OnflkvHlSR0dqwhmQ7I0yHuM/DpIVfLy5imMHHqoJfPDBYibTUyqR5SDRDZoWx1rh+VkhFVX+oxMGYe2ZVSViApsO0h2JSTUxqmcXJoot8XUBHcISey7d8WltXTHOkwrqXeWhUVmqJkaG2nmU+UXB0ianAr4VmXFZph5KCka+YXEFmhn+Dn7SfclhnfIWKkH5sh5h7XG+QiHV3ipWQgoCCf3d7eWxxl6mLZ2N0d3Z+kaaslHNWV3WTknxziJyIYmCDj4B6fpCciXVxdHqKlYlwXWOHnZaLh39wZGh7naiZgGthbYSNhICKgnZ9g3x6hIiGf3Z6hIh8c36IlZ2Oc2FXVmyhwrCOeGhST2qNqbWoh2JNWX+Xm5aPgWJIUIbCxp18bF9SVnKasqqQd2JcdZaZh3t4cmVjdprAu5FtV09OZouosqmOcVpTa5WtnnxkYWdug56toIZ7e29bWnONmJaQh3pwc3+LlJiOdVhNXoGisaeUfmZVWHWdtaeDXElafJumo5WBaVdcfKOwlG9hZ211iZ6moYxtUk9pipedo5l+YVVlhJ2bin95c2x2jZuWhnVmXWmAnqufhnZsYV9zkqOZhnVxbWx7laylg2NSWmuBmammkntrYml7jJWLfnZ1dHeFkpSNgXVqa3eKlJCHgX94b217jpKGf3+AeXN6iJGNgXdvbneMnpmIeXFmWmeHo6qch3ZsaGt5jpqTgXBmZ3WKmqCXh3dqYmd4jZmXioB6dG1zf4qMi4V9fH58en+GhYKBfnp4fIGCgoKEhoV/fHx9f4B8fIKHhoOAfHl3fISHhomHfXNzfIWIiYiFfndwcXyHjY2Jg3t0dX6EiImIg3lwcHqDiIyMh4B8e3t8foGCgH59gYSDgX19gIGBgYGBgYB+fX2AgoGAf359foGEhoaDfXd4fYKEg4KCgH17fIGFhoWEgn13d32Fh4SAfnx7fYKGhoWDfnt6enyBhYaEgHt4eX+GiIeEgXt4en6BhIWEgH18fX+ChISCf359foGDhIJ/fHt8foGEhoWCf359fn1+gYSDgYB/fHt/g4SDgYB+fn+AgYKBf4CBgH59f4GCgYCBgYB/gIGBf35/gIGDgn57fYGEg4KCgHx5fIOHhIB+fn18fYCFhoN/fn16e4GIiIWCfXd2eoGIioiDfXd1e4WJh4OBf3p1d4GJiYSCgH13dn2HioaBgH96dnmAhoeHhYB5d3uBhIODg4F/fHx+gIGChIOAfXx8f4OFhIB8fH+BgYGBgoF+fn+Af4CCg4KBf318fYKEhIKAfXx9f4GChIOBgH58fICCgYCCg4B9fYGCgH5/goJ+fYCDgn+AgoF+fH2Bg4KBgYF+fYCCgX5+gIB/gYODgH19foCBg4SCgH59f35+gISEgX1+gIB/gIKDgX59fn5/gYKDgoB+fX6AgoSDgX9+fn18f4SGhIB+fXx8gIWFg4B+fXx9gYSEgH5/f35+gYSDgX9+fn9/gIKDgoB+fX2AhISCf319foCBgoOBfn1/gIGCg4KAfn5/gIGAgIGBgH5/f4CBgoF/fX1/gYSFg398fHx9f4KFhoSBfXl5fIGFiIaCfXp6e3+DhoaCf318fH6ChYSCf3x8fYCDhISBfnx7fYGEhYSDgHx6e3+DhoWCfnx7fICEhYSBf317en6DhoWBf358fH6DhoWCfnx8fX6BhYaDf318e32BhIWDgX59fX1/gYOCgYB+fn+BgYGBgYB+foCBgYCAf39+f4GCg4KAf35+f4CCgoF/f35+f4GCgoGAf39/f4GCgYB/fn5/gIKCgICAgH9/gYKCgH5+gICAgIGBgH+AgICAgYKCf319f4CAgoOCgH5+f39/gYKCgH9/f3+AgYKBgH9/gH9/gYKCgX9+f39/f4GCgYCBgX9+foCBgoKBf35+foCCg4GAgICAf35/gYKBgH9/gIB/f4CCgoB/gICAf4CBgYB/f39/gYKBgH9/f3+AgYGBgYB/fn+AgYGBgYB/f3+AgICA", + "animalsDogBark2": "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", + "animalsDogGrowl": "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", + "animalsDogSniff": "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", + "animalsDogWhine": "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", + "animalsElephantCall": "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", + "animalsInsectBuzz1": "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", + "animalsInsectBuzz2": "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", + "animalsInsectChirp": "UklGRp9aAABXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YXtaAACAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGAgICAgICAgICAgICAgICAgICAgICAgICAgICBgICAgIF/gYCAgH+Bf4CAgICAgICBgICAgIB/gX+BgICBf4F/gYCAgH+Bf4F/gX+BgH6DfIR9gIN6iHiGfn2IdYx3g4R1j3CMfHuObZNzg4hvlmyMgHWUapF5e5Bsk3V/i26SdIKIcZB0g4Zzj3SEhHWOdYWCd4x1hoB6iXeHfn2GeYZ9gIN8hH2BgX6CfoGAgIF/gX+Bf4CAgIB/gYCAgH+Bf4CAgIGAgIB/gICAgX+AgH+Bf4CAf4F/gYB/gX+AgH+Bf4CBf4F/gIF/gn+BgH+Bf4F/gIF/gX+BgICBf4F/gIB/gX+AgH+Bf4CBf4F/gIF+gn6BgH6DfYN+gYF+hHuFfIKBe4h2inqBhXWPcYt9eo9slHGFiG6YaJB8dZZlmHJ/kGabbIeJapxojIRummePgHGZZ5B/cphnkX5zl2eRfXSXZ5J7dpVoknp4kmuReXuPbo56fIxxjHt9inSKfH2Id4h8f4V5hn2Ag3yDf4CBfoGAf4F/gIF+gYB/gX6BgH+Bf4GAgIF/gYB/gX+AgH+Bf4CAf4GAgICAgICAgICAgX+Bf4CBf4F/gYB/gX+AgICAgICBgICAf4F/gX+AgH+Bf4GAgIF/gX+AgH+Bf4GAf4J9g36BgX2EeoZ7g4F8iHaLd4aAeoxwkXGKfnmQaphqj3t5k2SgYpV5d5lcqVuZeXKhU7BXmH9qqkyzWZGIX7NHs2CGlVO7Ra1sdqZGwEqfgGG3P7tbhptMwEWmeGixQ7hch5hQukyffWavSa5nfJ9Qs1iPjVuyUZ19aKtQpnF0o1KpaX6aWKhlhZFgpGaIi2edaomHbZZvhoZykXSDhnSNeIGGdol7f4Z5hn59hnmFf32Fe4OAfYR8goB+g32BgH+BgH+Bf4CCfYN9gYF9hH2BgH6Cf4CBfoJ/gIF/gYB/gX+Agn6DfoCBfoN+gn+Bf4F/gYB+g3yEfIN+gX+Bf4CBfoR7hXyBgX6Cf4CAf4CBfoKAfoR7hX5/hHmHe4GDeYh6g4F7iHiGfn6Gd4t2h358inGRcIp+d5JomWyJhW6cYJxug4xmol2ccH+SX6lYn3N4nVSwV5aDZa1Nq2h/mlWwWJaCaKdVo259mFqpXpGEZ6hUo295nlSuXouQWbJRnX5mrkyqbnWlTbBhg5lTsliSiWCsV5p9baFcmnh1mWOXd3qRa5F5fI1xi316i3WHgHmKd4SDd4t3hYJ5iXeFf32Fe4R9gX+AgH+DfIR9gYJ8hX2AhHmHfICFeIl6goR4iXmDgXuGe4OAfYN+gIJ+gIN7hX1+h3WOdIh/eotxkHCRb5NslHCJg2+gVLNOq2WHkFq3QbxSl4ZduzjIRaJ9Y7g2zjqxbHOtO9MuwVx+qTjaJ8Zceq012C68ZXarPso8sWt2pUfBRatvdKZIvkqjeGyrSLlTmIJlrkmzW46MXbJMqmx5oU63VJaHXrVHrml7oE+1VZeCZ6lTpmqAlFypXJZ/bKVUqGiAmFawV5WGYbBPo3ZsrEqvaHmkSrdZipZSuFGYhmCvUp57bKVYnnV2mmCbcn2QapR1gIlzjHqAhXqEgHyFfICEeYd7gIV4iHqBg3qHeoR/foN8hHyEfYGCeol3h358inOMeX+Ic413gYZ1jHeChHiJeoKCfIR+gIJ+gYJ9g39+hXqFfn2Hd4h8f4Z4iXqCgnqIeYV/foV6g4N0lWSfZo2HYrQ9yT6wanmjSMM9uF2IlU/FMctImoxOzyPYQJuRR9Ug1kWVlUfRKM1Lk5FQxDXCU4+QVbxAt1yLkFq0Sa9ih5JZtEmtaH2eT7pNn31nr0mxY4KZVbFXl4Bro1qgboGQZaBjk3x1mWCfaYeLZKVdl3xuo1ejb3qcVqllg5ZXr1uPjFywU5qBZK5PpHVvp1Gpa3ucV6lmhZJfpGWKimeeZo2DcJhpkHt6jXCOd4OCe4Z6hX2BgnyGeoR/fYd3iHuAhXeKeISBeoh4hX99hXqFfYGBfoN8hHyEfn+EeYh6goR3jXSIf3mOcI17fI1ukXWBiXCScYeDdJJvi392k2mWc4CPYatNtFGlaYeJaKRTsU6tXJZ7cqFRt0msZ4CbTsI6vlaOklHGL81DoIRXySTfMa98V88a6CyugVDVGuE5n45L0CnMTo6VTsM8uGCEmFO2TKdueptWrliaeXOdWadhkINsoVugbYGSYaVfk4BtoVufb36UYKNkj4FwmmSXdH+Na5hsi4Jyl2aWdHyTY6BniYplpVyXfW2jV6Fydp9WqGeBllmrX4yMYahdk4NopFyYfHCeXpt1eZdjmnJ/j2mXcoKKbpJzg4Z0jnaEgnmIeoKCe4R9gIJ9gn9/gn+AgX+AgX2EfIKBe4Z5hX9+hXqFfYCDe4V8g4B9hHuGfIGCe4d5hYB7iXWKe3+IdI13g4V1jnSGgXiMdIh/eot0iX17i3KMeX6LbZllmWqRdIl6g4B7jWufWapYn3F6nFG6RbFihZRWuEW2WJV+cJ5ZrFWmZI6DbKVOuUqqa3qjRM0wxVSIoDvfGtlHi6gs8AzeTXy6HPYSzWVlyhrqK66AU8wo0EmVj1O/P7Zfh5JcrlOjbIGPZKJem3KAj2afY5V5d5ZhnmqIiGqeYpV5d5Zjm22GiG2ZaJJ4fY1sl2yMfnaTaZZzgI1pm2uJiGigYpOAbaFcm3Z0n1mjbXyZWqdmhZJdqV+OiWOoW5Z/bKNbm3Z1m16ecH+RZppvhIpulXCHg3WOdIaAeoh5hIF8hnmFfYGAf4J+gn6Cf4CBfYN9gYF9hHyDf36Ee4Z7g4B+hHqGfIKBfIZ6hX99h3aKeoCGdI12hIV0kHGJgXWTa5B5e49sk3WBim+Sc4OIbpZrjYBynFqsVKdik3p5k2OkV6pZo2WRe3aZWLNHuFOZgWS0PMhBq290pEu9RrBfjoRrpFC3SLJdjY1YvjTNP6l4ZLws3ijCYXS3Ju4T1lR3vhn7DNNhZNEN+xq7e0/ZFeU5nZJH0CzGV4acSsFCrmt6nlKyVJx4dJ1bpWONg26eYJxugoxonmWUeneUZplvhodvlmuPe3yNbpFyiIB5jW+Qc4WEc5Nsj3p5k2iXc36RZJ5rho5ipGCQhmanWZp7baRWonF2n1aoaIGXWapgjIxhqF2UgmqiXph6c5pimXR8kmeYcIWHcJNwin95jHKMeYGFd4x1h397inWKen+GdYx3g4R3jHWHgHuKdYh8fod3iXqCgnqIeYZ9gIJ6h3mGfX+Fdot3hYJ4jHOIgHiPcIx8eZBskXh9jmuUcoOKbpRvh4Vyk2+Lf3ePb456fI5pm2Oaa5B4gIhvml2rT7NPqmSKi1+0P8RDrGx4o0jDPLhbjYtgr0m4Tahnh4xhr0W+R6pudqdAzjDEVYmdQNgd3D2dkkHhDe4vpJQ47gPwNpSoJ/UK3FN2vCLoJrd2XsMvzEqVjVa7RLJjhJJeqlmecX6QZpxoj351k2iWcoOJbZhpkXp6j2uUcYWFc5JujXp+iHWMd4V/fYZ4iHqDgXqJdol8folzjXiAim+TcoOLapxojIVrn2CVfW+gW510dp1ZpGuAlVymZImNYqVgkIRqoWCWe3KaYph2epNnlnOAjWyVcYSHcZJwiYB4jXKLfH6IdYt4g4N5iXeFf3yId4d8f4V4iXmDgnmJd4Z/fYZ4hn1/hHqFfIGCfIV8g36BgICBfoN8g39/hHqGfH+Gd4p4goV1jnSGgnaOcol/eY1xi3x9inOLeoCGd4l6gIV3iniEgHyGe4CGc5Juj3p5lV2uTbNSo2uGimmjVbBQrF2Xd3mXXK1PsFicdXibVbZHtFmUg2etR75Hq2iAmFS6QLxQm39or0HGPrRigpxIzCrSQZ+KS9gU6y2ojj7pBu81lqUr8Q3aU3m4J+QpuHJjvjLMRpuHW7lBtl2JkVuwUaNwe5ddpmCTfnGbX59rh4lqnWOXdnyQaJlsi4F1kW6OeICGd4l5g4B9hHyDfoCBfoN9goB8h3eJeoCHc49zhoVxlWqPfXWWZZhzfZFmm22Ei2qabIiHbJhsiIhrnGaOg22eYJh4dZlfnm6DjWeba4mFcZRviINyk26Lf3aRbZB4fopxj3WEg3eMdIh9fYd2iXmDgXuHeId9f4V4iXiFgHyIdol6goJ7h3qEf36Ee4R+gIN8hH2BgnyFeoR/foZ4iHqCg3mKdod9fYd3iHyBg3yDgXyHeYOCd45xi315kGqWcYWIb5ZsjIB1k2uQfHaZXKlZoGyGiGufW6hZo2STeXqTYKlSr1eddHibVLhFtliThGSvRMBFrWd/mlDBOcNLnYBjtjvJQKxudqJMvkK2WZOEZLI+yjq0aXG2KuYfxWhi0A/4HrWHPuwE7D6JsSPvG8FxXMsk1UeSlkvEP69tdqFSr1qVf2+fW6RljIRsn1ygaoeJap5hmHOAjGyXa494gIZ1jXKNdod/fIpxkXCLfXqNbpJzhoF5ineFgHyEfn+FeYV/e4p0in16jm6SdIKIcZFyh4J3jHaEgnmIe3+Gd4l9fIpzi3x7j22SdX+NaplsioJylGuQeX2Kco12hYB9hXuFe4Z6hnyAg3mIeYWBeol1iH18i3GQc4eCdpFsknSDhnKTbY95fotvk3CKf3iObpF0hIR1jnKKfXyKco14gIlvlWqRd3+MbJlmlnKEh2+ZYpxqjINwnF6faoeLZaZYomyDj2OkXJxwg4psmWaXcIeDdJNqlXCJf3qJeYCJbplll3GEiG6ZYp9hnWeTdIGMZ6VTr1WgcH6VXK9MsVecdnebVrRJs1mVgWmsRsFCsmODmU7DN8RMm4JjskHCRaxog5NatUK/SaZ0bbMz2iu9a2bHGu8jtING5ArrO46sJ+8ZxW1ezB/bQ5CePtI0s3Nntjy/VY6QWLROpm58ll6lYJV3fI5slm2OeIKEeYl2i3WKd4d9fYpwlGyQeXuPaZlsiYVummaTeniUZ5dygYpvkXWBiHKPd4GHc414gYZ2iXx9inSLen+Hd4d+fYd4hYB7h3qChHeKeIGHcpFwiX94jXOJf3iOcYx8eo9rlW+KgHeQbJNxiH96i3KOc4p6goN5inSMdYh9f4Z3ineHfX+DfIKBfIZ5hn1/hHqFfn6HdY10iXx9inCUa5Rxh4NzlWWcZ5J4fotvk26PdoV/foN+gX+BfYV4inSMdoWCd5Brlm2LgXKbXKdflH9sqUq8Salrf5VdqVqadnmWYaFljoJtoVerXJd6dZpdpGKTenmQbZF2goV3iXt+iHSNdoWBfIZ8gYJ9gYZyl2SdaI2Cb6BXrVahbIWMZahQslOicHuaU7lEtlqQiGGxRrtOo3F7mViySrNWm3hzo0nEOL9VjJlD2RvdP5adNeoP3kqBtCXsHsBxXM0f3T2akkjNM7tkd6lDwE2ZhV61RrFlgJxQuE2idnCmTrJZlYBtoFuhZ41+eYxyjXSKeId7goJ6inWLeIKDeIt1iXyAg3qGe4R8g32DfoCDeol2iXqBhHiLdYl7gIR5iXiGfYCDe4Z7hH6AgnyEfYKAfoR7hXyBgnuHeId8gIV4ineGf3yJdYt4goN4inaIfX6FeYd7goF8hHyCgH6DfYJ/f4J9g3+AgX6CfoGAf4J9gn+Agn2DfoGAfoN9g36AgX6DfYJ/gIF+g32Cf4CCfYN9gYB/gn6CfoGAf4J+gX+AgH+BgICAgICAgICAgICAgICAgICAgICAgIGAgIB/gX+BgICAf4F/gYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIB/gX+AgICAf4CAgICAgICAgICAgICAgICBf4GAgIB/gX+AgICAf4GAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIB/gICAgICAgICAgICAgICAgICAgICAgICAgICAgH+AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgH+BgICAf4F/gYCAgX+BgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgX+Bf4CAf4F/gYCAgX+Bf4CAf4F/gICAgX+BgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGAgICAgICAgICAf4GAgICAgICAgICAgICAgICAgICAgX+BgICAf4F/gICAgX+AgICBf4CAgICAgICAgICAgICAgICAgICAgIGAgIB/gX+AgH+Cf4GAfoN9goB+hXqGfYCFeIp2hoB6i3KMeYCIcpBzh4F3j3GMe3yLco14gYZ1jHeDg3iKd4WAe4h4hn1+hXqFfYGBfYN+gYB/gX+AgICAgX+Bf4CBf4J+gYB/gX6Cf4CBf4F/gYCAgX+AgICAgICAf4CAgIF/gX+AgH+Bf4F/gICAgH+Bf4F/gIB/gn6Cf4CBf4F/gICAgIB/gX+AgX+Bf4CBf4GAgIF+gn+AgX6CfoF/gIF/gn+Bf4GAgIF+g32EfYN/f4R6iHeIe4GFdY9wjniAiW+VapJ3fo1pnGWUd3qUYqJik35wn1mlZ4eOYahZmnpwoVelaYKTXahekoRopVmedHadWaVog5Jep2COiGWmXJWAa6Nbm3lxn1yddHiaXp1xfJVjm3B/kGeYcYGMbJRzgopwkXWCh3SNd4KFeIl6gYN6hX2Agn2Df3+Cf4GAf4GAf4F/gIF+gn9/g3yDfoCCfIR9gYF9g36BgX6Cf4CBf4GAf4J+gn+Agn2DfoGAf4F+gX+Bf4GAgIF+gn2Cf4CBfYR8g36AgnyFe4R+gIJ8hnqGe4KCeol0i3mBhnOSbo56e49qmGyKgnGYZJlxg4tpnWSVeHqUZJ9njoFwm2CcboONZqFhlXp1ml6haYeLZaNemHl0nVqkZ4aPYKlamH1tpVSnan6ZVa9akYlfsE+jdm2qS7BkgJ1PtlWSjVm1TaB8Zq5MqW90pFCsZoGYWKpiiY1jomSNhG6Zao1/do9xin18iHiGfn+DfYGAf4CBfoN9goF8hnqFfn6GeIl5goN5ineGgHuJdoh9fYh2iXqBhHqHe4N/f4J+gn2DfYKAfYZ5hn19iHWLeoCHdI14gYhxkHSCimubZpJ8dZpdp1yadHyVXaxSqGeDlVW5RbBne6NHw0KrcHOnSbxKpnB5nVK3SqppfpxQuUqmc3KnS7ZWlIRlqlKnZ4aNZKRbnm+BkGOjXpl2eJlcpmGQg2uiWqFtgZJho2GSf3CdXp5ugo9loGOTfHSYYZ1shotnoGGVfHGeW6Ftfpdaql+NjF2vU5x9aKxOqG90pU6wYoOZU7JYkIxcsFOcfmipU6RxeJtbomqEjWiba4mDdJFxin19h3mGfIGBfoJ+gn6BgH6DfIR8g39+hHuGe4OAfIZ4h3yAhHmIeoKDeoh5hIF7h3mFfn+DfIR8g36BgXyHeIh7f4d0jXaEhHSQcYmBdZNqlXCJfnuLcJZkolqmYJV7cqBRtkquYYqMXrU/w0ekemS8LdowtXJjwyThLLVzY8Ap3C+3bG21MtgvumlvtjHXM7F1ZLwzzEabh1q7P7lajI9bskyrZoWRXaxUonB7mFqrW5Z+b6Bao2mFjWWiYJZ4d5ZjnmmLg3CaY5lxgI9loGOSf3CeXZ5wfZZepGaHj1+pXZKGZKpWnHtrp1KlcHWhU6pngJhYqmGKjWGmYJCEaqFglXt0lmeVdn6Mb5F0hYN4inaHfICDe4Z6hX2BgnyGeoR+f4R6hnuCgXyGeoV9f4V4iXmEgXqKdYl8foh1i3mAhnSOdIeCdpBuj3d/im+Ub4mCc5Rrj3x2lWeWdXySZZpvgo1omm2FjGehYZV6dplcrFGwVKVniYllqky1UKRrhYtnplG0TalqfKNA0yrIV3+tLucZ0lN9sijtFNZRf7Eq6RrNWniyMdkwtmxxrEPASqRzdp1WsFKka4CVWrFOqGt7nlC3UZx+Z61MrWaBl1itWZd9cJ1doGqJhm2bY5hyf5BkoWOQg2mmVqFzdaFTqmWCllmsXo2KYqddlIFsoF6YeHaYYppxgI5pmW2HhXKTb4p+eYx0int/hXqGe4N/gIF9hHqHeoSAe4l1inmBhXaMdYd/e4tyjXeBh3GTbox+dpNolnGDiG+Ub4iDc5Jui392kmqTdX+NaphsioNxl2mQfHaVZ5Z0fpBomW2Hh26XaZB6e45tk3GIgXSWYadVq1uadXmaVrVGuFCib36VXLBLtFWbfGqxOdMuwl17sCrtEtlQe7sZ/gXdVHLFFPsRzGZmxiDjL695Yrk7wk6bfmyjVqpdmXR+kGSkWaJrgpNZsk6lcnGoSLlWkI9Xt0ukdm+mU6dqgJRfpWKRf3KZYp1pjIFxml+gaoaNYqdcln9qpVieeG+lUqhre5xVq2OHkF6oXpGDaqBgl3l3lmWYcYKLbJZti4B2kW6OeX+Jco51hYJ4i3WIfX+FeYh5hH9+hHqHeoV+foV5iHqDgXqJdoh8f4d1jHeEg3eMdIh+eoxxjHl+inCQc4WFc5Fwin54j2+PeX6Lb5JzhYRzkW+LfnmOb494gIlyj3WFg3eLd4SDd4t4f45lp1OtWph6c6BRuUS3VJt5cqFRtkquYY2GaaRTsFKnZI2FaKpHwUGzZHynOd4c1kqIqyj2BOdEg7gZ/wPeVHHEGfIdv29jwS3RQaGAZLBJs1mVfnGcXaVemXN+kmCpVaNue5xStVGdfmawR7JigZxQtlSWhWKtUaRveplcpmGRf3KZY5xsiIZtnWCbcn2VXqVjjIpjqFqYfmulVqFyd51ao2yAlF+iZ4mJaZxojYB0k22NfHuLc4t7gIR6hnyCgICAgH+AgX2EfIKBfIV7goJ6iXeGf3uLcY92g4V0j3KJf3qLc4p8fYl0i3mAhnaMd4SCeYt0iXuAhXiJeIV+f4J9g36BgH+Bf4GAf4J9g32CgXyGd4l4hX98iXWLd4SBeYp1iXt/hnaKeYCIb5dmmG2KgHeQbJdnnF+mVqpbmXpvqUTHOrpciJRVuz+9TqJwf5FiqFGxUadmiIxgskPARqtseaNEzizMSZaRSNgX5zCpiUXiCPUlrohE4wvuMKKTP98Z2EqKoT7RNLdneKJOtVSddHyQaZplmmqPe3iWXqhamXttqUu0XImWT79DqXZotEC7XIScTbpQmYRjrVGkcHqZW6ZhkYBwnV6gaoaMZKVbmXpvo1Wma32aWKlkhpNcql+Ni2KoW5WAbKBemnZ5lGeXcoKJcJB0hYJ4i3WIfX+Eeod6hX2BgXyGeYd6goF7iHeHfX6Hdot3hIN3jnKLe32KcY91g4VzkHKIgXaQcIx8e41vj3eBiHOOdYWCeYp3hX98h3mGfn+De4R9gYF+gn6Cf4CBf4J+g32CgH6De4V7g4F8hnmGfX+Gd4p5goV1jnOHgXaRbZB5fI5slHKEhnKSb413iXOXXK5OrWOEmUvMKdc3smx1p0THOL1WkodjrUu3TapglXh6lVuzQ8BHpnVqtjDdJ8VeeLQo7RHcSYetJ/UH5USFsx/6CNxUc8Ec8B+8c17FK9BGmYlcs0utY4uEb5ljnmSWc3+QYalWoXF3oU62VJWIXLZGrWx1p0m4WI6QWLRPoXhvpFSoZ4aOZKJhlXl3lmOdaomHa55hl3l1m12gbn6XW6Zlh5BeqlyShWekXZZ+bqBemHh1mWKac36QaJhvh4VyknCLfXyJdYp5g4F8hnmGe4KBfIZ5h3uCgnuId4d8gIR6h3qCgnuHe4KEd4x0h4F3kG2RdoCLbZVuioF1km2PeH+IdIx4gYZ1jHaEg3aOcYx7fYpyjnWEhHaOc4h+e4p1iXt/hXiJeYV+foV4inWKeYKFdY5yin18iXaFgnWRb4uBcJ5XrVWkZpB5gYV0lGOnULNQpG94oUnFN8FRlIpZvTfJQqlwdqFQuEixWpl1fZJhrEy4TKhteaRC0CvLTZCZQdwW5DahkT/lCu4zm54v8wXmR4C6HPYVx2thySLbPKCHWbpCtF6Nh2qeX6Blk3d9kGSjXZt1d5xXrFyRh2KsUqNydp9Wp2eEkV+mYJGCbZ1il3V+jG+Rc4aAfIV7g4B9hHqGfIKBe4d4hn5+hnqDg3WQcIt/dZZmlnV7lGKfaoaMZaNglXxym2CcboWHcZJwinx+hXuEfoGAgH+CfYN/gIJ9hH2CgXyHdop3hYF6inSLen+IcpFwjHx7jG6TcIp/eI9sk3KGhXGXZ5ZzgYxqnGWVdn2PaJppj3t7jHKMeYCHdYx2hYB7iHaJeId6hnqGfICEd41xjneDg3eNc4l9fIpzjHmAiXCScIiEcZhkmHGCjGqbZ5J5fI1wj3eBh3KRcIt9eZJkpVWuUqpflH1vpUnEN8RMm4RcwC7XM7ZpdKw9zzHCUpWFZqpOs1KlZ42AcptZski4UZ1+Yr4q4Ce+bWHNE/Ycu35H6AH3LJujJ/gF4FF2vx/pKLR5XME0xFOQjV+rVqBvgopul2mUcoaFcJlinG2Dj2KnXJd+a6dSqGl/mVeuW5ODaaRbnXJ+j2qWcIiAe4d5hX2BgH+CfId4iHqDgXyGeoZ7hHuFfIKCeI1xjXp8jmyVcoKLaZtpjIRtnWKWeHmUZZlvhYdykHOGgniLdod9f4N9gn+AgIB+g3yEfYGBfYZ4iXiGfn2IdI5ziX57jHCRcYp+eo5tlW6MfXqObJVviYJ0lGmWcIaEdJFuj3aEgXuGe4OAfYR7hH6BgX2DfIR8g36AgnyGeYh4hn1/hHmJeIV/fIh3iXuAhnWNdYaBeI1wj3aDg3iJeIOCeod9e5Blo1mkZY2Da6JUsFKoY5F+dJpbrU+vWZl6caVKwjy8VZKLWL40zj2ub3OpRMY8uVqQhWikVK9TqGGTfm+lSMQ6vFyDpDrdH9BUfbUj8BTOYmbNEvYduX5M3RDpNZ2VQNoizlOFoUPIPa9tc6dJu0+dfGupTrBcj4dkqlKmaoGUXapamHxvoVanZYmMZKZbnXN7lGKfaIuDcJdoknl8j2uVcYWGcZRsjXx6j2yVcImAeI1xjnWHfYGCfYV5inWMdoWBd49slW+Kf3iPbZNxiH97iXaJeoOAfoR8hXuFe4R9gIR5inWLeIOCeYp0i3iEgHyHeYZ8gIN6hnuCgnqId4d8f4Z3iniEgneNcY15f4tsmmaVdX2RYqVan3B+llqvUKdpg5JcrVGoZ4eMZaRcn2yHhXKSb4x7f4Z5hYB8iHaJeoCFd4t1iH1+h3aLd4Z/fIh1i3aHfn2IdI5yjHiDgnqId4Z9f4R7hIF4j2qbZZZzgI9jqFOrXpR/bqNSs0+oZomIaKVTsk+sXpOBaqpFxTu5XYeYTMcyx0yYiFu8OsVHpnJ3nVWyTa5amnV6l1i2Qr5PmoVXyCLiLq+BTOAI9yaolTL2APA9hbkY/BDJcFbVGN9DjaI70jeudmmuSbFfj4Jzkm2TbZNtj3p4ll+mX5OAbaFcnXF+kGmVdICJc4p+eI9wi4B0lGmSeHuQaZhuh4VylGyPeH+IdI11hn98h3iHfIGDeoZ7g4B+g32Cf4CAgX6BgH6Gd4p2hoF4jm+RdISGcpJujHx6j2yUcYaEc5NrknWCh3KRb415gYR5iHiGfIN9g3yEfYGCfId4iHqDgXyHeIh6g4F9hnmIeId6hXyDf3+De4h3ineHfX6HdI9wj3aEg3WRaphqkXaBiW+YZZtpj3t5kmWgX5xthYpnpVSsXJV+baZMukqpbH2aU7dJrmOHjmKnWKBugY9mn2KXdIGIcZJvj3WIeoV8goJ5jW6VbI96epNipF2bc3yWXKtWn3N2oU29Q7JjgptLyDDMRKJ+YL0v2S3AXn6lP9EsyE+Ti1u1R7NckoBzlGuRdoODeoZ8gYN6iXaKd4aAeY9pnGOYc3yXV7VIr2SBnkjIN7lkdq811jOxeF3GKNVElJlB0zG2c2DELMxUf68v2zSnikjXIsxZebE00zqrdmypTrFYnHCEh26dW6pZm3dzoVKwWZWAbZ5fmnGEhHqEgH2ChHSUaJV0fpFkoWKUe3aWY5xrioF1kW2QdoODeIp3h31/hHuEfoCBfoKAf4GAf4J9g4B9h3eJeoGGdJBwjHx7jW6TcImBdpFsknSEhXORb455f4hzjnOIfnyIdol6goJ7hXuCgH6DfYGBfYN+gYJ8hXuDgH6FeoZ7goF8hnmGfYCDeod5hX5+hXqHe4OAfYR7hH6BgX6DfYJ/gYCAgICAf4F+gn+BgH+CfoJ/gIJ+gn6BgH6CfoJ/gIF+gn6BgH+BfoF/gIF/gX+BgH+Bf4GAgIB/gX+AgH+Bf4CAf4F/gX+AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBf4F/gICAgICAgICAgICAf4GAgICAgICAgICAf4CAgICAgICAgICAgICAgICBgICAgICAgICBgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIA=", + "animalsSnakeHiss": "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", + "animalsSnakeRattle": "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", + "animalsTRexRoar": "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", + "colorsBlack": "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", + "colorsBlue": "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", + "colorsBrown": "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", + "colorsGreen": "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", + "colorsRed": "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", + "colorsWhite": "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", + "colorsYellow": "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", + "communicationBravo": "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", + "communicationEv3": "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", + "communicationFantastic": "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", + "communicationGameOver": "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", + "communicationGo": "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", + "communicationGoodJob": "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", + "communicationGood": "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", + "communicationGoodbye": "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", + "communicationHello": "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", + "communicationHi": "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", + "communicationLego": "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", + "communicationMindstorms": "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", + "communicationMorning": "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", + "communicationNo": "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", + "communicationOkay": "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", + "communicationOkeyDokey": "UklGRpwXAABXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YXgXAAB/f39/f39/f39/f39/f39/f39/f4GBgYGBf318enh3hJGJj3tvZ2d2nLG1kmROSGSCl6OVg29dSk+Hr9jnwYtSRDxVZF5eXnabw93OpXVKRU9pdomOiJSRko+Kf3JuV09ERG+65P/rrmM6MDRQWFZbdJfI6+W8jVU4OElSXm18lLzR1MSRYT4wN1Fvg5ywvbybYisYO6DJ/tiUYUFobZRtRS00a7Hp8b2YUlphcXhdW1J+oMHFooFcXWqEkH1rQjJHeMX0/deSXjpHUl5aSUtglcfl4raEWEtVXGliYm2Fq73DqINkVWJygX9vV0JNb63j9eGobkQ+S1heVlFegbDR3sOYbldRXGdnaWp7kaq2rZh9bmpqbmVWSEpvpNfy5LV1TT1IWF1aUFdxoc7j16+BXFBVXGFgYGuHpLvEtZh2W0c8O0Vlj73c6M+nfVpHPz5BSVZtkLTO19C2kXRRPjY7TWmLqsTPvZVnOyc1YY+3w7allJGLinFQMiQyWomuwMW7tK6cg149KDJUgrDHv5xySDdEa6PBzreafXJ6fHpiRDI1VX6owMS/sqqYhGNCLzBRgbHOxJhkNSJBfLvd37aKbWl3h39fOiInUIm31NTEsJ+Od19BMThYirrNr39FHi1jseP40pdpUmF4iXZRLhs0aafa6eK+noFpXU1EQ1Z2nrqtj1wyNFyi1vbcpXBOUGeDgWlFJClOj8v1+tSnclRKTldfbXeHkIh9ZVddga7O4ceeb1JKWm5vaFJAQV2Qw/Dy2KduRztEWnSEiIR2aF5ba4ewxdHFpIRoXltjYlpPQ0Vbga7W6eHCkWdJQUpfdYOEfGpcVWWDr8rVyKWFaWNibWthUUA8S2+eyOPiyZ96XFJXZHF3cWldVlVph67J186wkG9hW2NkYldKRU9tlbrS1MGhgWVfY3B8gXhrW05IVnGauNDQvqWKeGtqYltLQTxIZYmwytDErY93bmlvcnJrZV5cXmp7lKSxsambjoV+fXZtXVBJTlx1j6OtrqSakIuIiX9yYlZNUVx1jaGrqp+SiIKCgn93bWFcXmh3h5GWlZCNi4uNh3xtYlpkdoqdpJ+Ofm9rcHuDh4R6cnB0e4WLi4mDgX+DhYiFgXhycnJ4foSFiIWEhIeJiIV+dWtoaXF9iI+Rj4mEgoKBf3x4dnZ4fYKEhIOCgYGBf317ent+g4WFhIF+fXt6eHp7gISIiomFgXx6e3x9fn59fX6BhIiIhIF8eHd6fH6Cg4ODf317ent+g4iKiYWCfnx7fHx6enh6fYKFiYqHgn57eHt8fn+Bf35+fX6BgoSHh4WDf3x6enp8fn9/f35+f4GCg4OCgoF/fn5+f39+fXt6e32BhYmKioeCfXh1dXd7foGBgX+ChIiJiIN8d3V2e3+Dg4F+fH1/g4WHh4SCf317eHd4e36DhYWDgX5+f4GBf318fX6Bg4OCf316ent+gYOFhYWEgn98eHd3en6ChIWEgoGBgYGBgX58e3t8foKDg4F/f3+BgoKBf318e3x9f4GDg4OCgX9+fn5/f4GBf359fHx9f4GDg4ODgoF/fn18e3p7fICDhYeHhYN/fXt6enx+gYKDgn9+fX1+gYOEhIOBfn19fXx8e3t7fYGFiouKh4F7dnR0d3uAgoSFhISDgoKBf359fHt8fX+BgoF/fXx9f4OFh4WCfnt7e31+fn19fX6BgoOEhIWFg4F8eHZ2eH2Bg4OCgoKDhIWEgn57enp6e3x+gIKEhYWEgn9+fn5+fn18e3x9f4GDg4OCgYGBgYKCgX58e3p6e35/goOEhISDgoKBf356eHt7enuBg4WHhIWFgX1+f3x7fHx7fH6BgoODg4KBgYF/f39+fXx8fHx8fYCBg4WFhYSCf318e3t7fH1+f4KDg4SEg4J/fn19fX5+fX18fX1/gYOEhYWEgn99fHt7e3t8fX+Cg4WFhYOCf318fHx8fX5+fn5/f4GCg4OCgX9+fn59fXx8fH1+gYKEhIWEgoF+fHt8fH1+fn19foGEh4iHg356eHqOsjByv1Qr+FZXsnqEomvPXkKrXVSccnWNjXiCkX+Fi4N8inR3fXF4iHaCgnx/foSDioeHf4V3fnh7eHp8fnqScohulIpL3X9VrWlXnWJvlXV6jnSAi4KPj3yFgWqHgV6RgW+Pdn6CZXu8bY+cZYWCZIdtdXeLdYeAfnquinqRbpZybn9ocnp6iHd9gI+WkJR+e4FufXp3eHd3foGAh4CUfop/int9fHZ+dIF2hHuDhH6ChYODg4GHdH19e359god1h3uCfX6Jf4GKe4KCcn97eHeKfn2IfISBfIuEgY19d4R4fH54hXp2iWeFgX2LiHSDdYWDh4ONhXqbdIF3i2OBhWuFiHGEfXSEdIp7gZR1joppfYmHVbR1eoGkaIiQgXh/i1pyfWtrlHCKi41+lYh8jYJxe3s9oIo6z3qFiq90g4uHanWQWml+gEWnfWWanmuVonKLkX9tflFnojqYoW6SpY2DnIGJaJBoZGiEUmmhYHuriHS3i36VmmF1V1uyErCYXJ2tiIGwfo9kpFRoaXpUYpppbqedYsKUgY+oVXVPb5wD5G5oorRwjrV3inGnP3hkdkt6lV6Aqn12woKJnZVOgTS6QUT8IamOslq6i5Zrlos9iFhnUIJli2q1gY60mJGRn1FoSZY8XbtYiJ6nd6WYm22bgVRvalxdbYFrhKKElamhjZKQYU5fkjJru1eKpLB2qqKSZJ11SW9oVFx2dXx8qYOarqKWl5BpV0WRSTTNUH2iq4efqaR0jphHamdUTnFngGqthZW1qJ+ljnhfOHdoIZ6HXpyum5Gpsn97ol9WamJFaWd3b5CifLKrpKehen88UXxDPL1XfLGYpY28nHyIm0hlZ1FQaG5piIqdiLWlqqqXgnJLP3dRJ8NPiKebsJC1qIR3pUhkW19DaW5rgJWYh7ehsaOheH1HQXJgKad0epqjr42lsYhvnmVYW2lRXGt1hXKvhaGisaGaeIlSO2WKLna1V6SIr5CQi7FqfJFiYmFoZGlpkIKIm5WVj5SHhHeBem50fXpufX2FgIKDgoKBiIOIg399fXZ4fHx/fYKCfYGDgoGCf4J/fn17fH97eoKBgn+Eg4eFhYOEgXt8fHt3enx9eoCBgIODgYSFf4KDgn97e318d359g4WCg4SFf4KBhH1/fX19eHt8fH1+fYSBf4KEgYSDg4SBf3x6fHx3fn5/g4GBg4eEhIOEfn57fHx4e3x8fYF+goOCgYKCgoKBg4F/gn57fX53fH1+gn+CgoSDg4OCf4F9fH19e3x9fX5+f4GBf4N/goSCgoODgn99fXh8fHh9foJ/gYOHhIWHgoGBfHp8fHt7fn1/e312gHHDikPXVGuaTbxbZIpprV57joedapV/oWV3jnB/a3V+emmKjnSce46QcY96inWYfG9tX0l6dHa0drahq4mugYF3UmlWSk9oaXuJqaK7naqreINxcG5pXGNjQ1J7nYWbx7i+m6GdelVVW0FARWBydIu9tsO7uqSIblJhS1ttcWlbWFilq3vKy7itj5R6Yy9QVDdIW3yLlajWysKykIdaPT9RXG+NiXZUUqm3dafNw5+BgoFvLTxiV0lahJypp7LOxZp8b1xHP01ti5ealWU1d8B9e7W7t499dZBcKlFhXVVug6W6p6rKunxqW09VUFSCrqKVg0k0ia5tlre8tph6cItOL0hWW2N7g7HNsrWrsYFWRzxhWmeCsribezAonapykq/Ju6VkZ4dVMTVOYH2FfbHXyrGikHJhNjBXb36VsK6pfzANh6uFnZy2yshwUW9aSD4yR4Cji6TA0dGrg1FcSjtNXIeqwaSYfD8bY5qNsqmrvcSSXF9HQU0+QGOYorXBvciwomFEQjtbYn2UuLuffDwRWJ2dqqiovM+eY1REQVRFOFSLp7vCtsS9pXJFNjpbZ3aKqLqxkFIVLY6gt6uXrcPEgl07MlZWRUFjkbXSwri4q5RkPytDYneNl6SppHw7FVSPtsqnl6K+sIVVJzRRXldRZIjA186/pZiDZ0c2QViAm6WgmIhqQDVokLrIrZycqpyBWC8ySFtjZW+FtdHWyaeIcGNSR0RRdpqtp5V8XENIdpiywKWho6GWe1o0O0dWZWp1iKrDz9Kxi3ReUktNUm+NnqmcgV9IRHGdt8Opl5Wdm4JiOzVDWGpxdHuVvNTSt49xZV5aV1Rdd5apoYRoVEhekai7uKGampiDclQ7Qk5gbnV1fZ3C0Muuh29kYV5cWmR9lJuRfWBWTW6ir8W3opCOjXt0UUJFUWdyenJ7nrjLyK+NdGVcZGFja3iEiIV2amBRe6e20bCYf4KDfXxWTUpVaHR7cICQpMHFuJd7ZGFqam9qa3B3gYB8dGdtmqe9tZeBdn19h3ZiWlRhb3t1bn6Iori2q5V+bXJwcHBnZ254gYWEe3JogpCgq5uRf4SFioVvZVxhZ2pqanSCmKuyrZuJe3h6eHJqZ2l0foSHgndpaYSOpKeWjoGFhYl/bmRbYWlyd3d+iZihn5iKgXp8fX57dXJyeHt9fXt9foGAg4qLkIqEfXt8en17enp4e36DgoF+fHyAhYiIhYF/f4KCfnp1dHp+gYOFiIiFgn54dXV3foSIiYiEgn9+fXh2d3p+hIiIhYSCgXx3dHV4fYKHiouKh4J9e3h3eHt8gIOFg4F+fXx8fHyAg4mKioiEgnx2cHBxdnyAhImNj46Jgnx4eHp4enx/g4SCfn17e3x9gYWHiIiHhH97d3Z3eHp6fICFio6Lh4F7ent7enp8gISFhIJ+fHh7f4OEhYSDhIOBfHh3enx9fX19gYWKi4iBfXt7e3t8fYGCg4OCf3x7e36ChISDgoKCgX58fHx9fn5+fX6Bg4SCf35+fn5/gYKCgoKCf318eHh8f4KCgoKCgoKCgX5+fn9/f359fX59fn59fn+Cg4WFhIKBf35+e3h4enx+goSFhIODg4J/fn19fX1/f359fX1+f3+BgYKEhIOCf359fHx8fXx8fYGDhIWEgn9+f359fHx9f3+BgYF/f3+BgYF/fn5/gYGBfn5/gYF/fn19foGCgn9/gYGCgX5+fXx9fn+BgYGCg4KBfnx7e31/gYKBgYKCgoF+fHt9fn5/f4GDhISEgn17enp8f4KDg4ODg4J+fHp6fH+BgoODg4OCgX59e3p7fX6BgoOEhIOBfnx7fH6BgoKBgYF/fn18fH5/gYKCgoKDgoJ/fXt6enx9f4KDg4ODgn9+fX1+f4F/f35+fn5+fn9/gYGCgoKBgYGBf398e3p8e4F9h32vaGGfeGqJhHxxj3e0d1iSb1+XkXtdmpBxVuNuSbdxXJp1aYuBcYqFeoiBgYOHe3p4iX1/gYJ/lXVlhGtksY9enI59dI5ufYNyfY1ug4R6h4WCeot+e4OEd4p2e4V3gYdygoJ1i3p+jX56lXCNg2WKgXeIdXV9bZ6hY6F4ZZFydJRtgYV6goN9hIN8h4N6goN2goF7gYJ3h3p8iHyJeoR+gXqHeH2Ed4h+gX6BfH+Ee3+HdY17gYtwiHZ4h3uDiX1/gXF9inqHhX2Ff3qEfnuHenV9b3ytZ5qKaJBycYtvgYh2iYF6iYJ6jnWEgnuFfn59foJ4goN2iHuEfoN8gYGBf3yDe4p6gnyEg3Z9im2JgnWLgXyCf4ODdY17do14foN3iHd9iXp/iX58g4J+g3qEfnuDfXqCfoJ2i36BgYF8hXiJdYh7f4F7f3p9foR4i4GEhHyJfIKBfYKBdYJ6d394fn6Bf4WEgYp9i399h399f3xvdm2dS6OFb6F2mHSXeJBol2twiG11dYNvhXyKf4SaepGIiHyIfXx6e3duhWiEdYJ/h4WDfXWHlE6xfXGcfY9wlXqBcpBocoFxcXaEcYSFiH6XfZKEi4h/h358eH1ufXF4eHd+gn+Fj3yDem+iZXK7UqN+j3yHg4N0fYtViHBucoF3foeHin6Vin+Ri36NfoF2fHVvdnpxeH16goKJhI6JhHd7b5FrcLZUpX2OgYSHf3h8iVuJb3ByfHh7iISKf5SIhJWIf5J6hH9xfm9ye3F2fXd+g36HiIiNh4R7dHKSaHC0VZ6Bi4KBjX17fYhbhHJtdHx8eIqFi3+Xg4ePgpB6ioJ3e4NpenxpfXR+d4WBhYOOiYKQfYF0dXCLa3ilYqJ7kX+EiHt9eoRignFxdXx8eoqCi4OSh4iLj3uHjmmJdndyfnB3eHh+dot7h4WKgo2IgYh8fW92dIJuhY54lIWQf42CgXp+dmt8b3J1fniCh4eJh5CDi4Sab46PZ4l1dHKDYpBohH91iX+Ego93lXiKgn6Cd3V2eGuNeneeeoqQh4mDhX96dX5ldHZudn2BgImJi4iQioePgYeHcoJ8bnt4cXd6eHaAgoCEi4WEi4WBhYV6gX1xdHhwdY51g511mIOPgoSDfXZ2e2R6cHJ3gIKCi4uLiZCIhY9+g4hwfnd2cnd8cXt9e3aKgIOLi4WHi4J+hX92f3dvdHdvd5B9eK9xmImPgYKHeHVxf116dXB3goSBkIuOhZGKgo6Hd4d3dnhydXh0f3h9g39/iISEioWHgYV+fIF8doF2dXp4d3p+lnWJp26ah4p3iHx2dHZ6X4J0dHyIgIOQiIqIkYSEjYN4iXd1enZyb3x4dIGJd4eQfoePg4KIgnx+fXt3fXx1fHp6e3t7jodyrnaNkYWDfoVyem9+ZHR8bnqBhH6Qio6IkYuDiYh/co1rd3t1cXR/b32FgICPh4OLiISCiH57fn1xe310fXt7e31+fH6bco+fcpeFiXaFeHZwdXhhfnV1e4qChZGKjYmRhYSIgYF2fntvfHdydnx0gXaQe4mRf4qIh3qLeoF6fXt0fHp7eod3gYF8fXeSiWS3dYKSiHh8iW97b4RkcoNwdoOKdpCNiYWQjX+KiH1+fXp4cnxydHt2e316knqIkoGEj4F9i3x/fH56d3p7eHuCe35/gnd+e5ttiKlplYuIcot8cnd1fF9/eHB7ioCAlYiJipGEg4qCe3yBcXh6d3B7d3x4fpJykoqChI5+fYl6gXeCdnp8e3p9gnuDfIR8f359m2iWlnCQh391iXR6dXp6aYJ6dn6KfYSQhIiJjYOEh4F8fX50enp2cn18dYKHf4KRgYOJhH6ChXp+fn12fXx2f35+foV+f4N9fnuIinCWiXeLh3t7hHZ4d3x1coF6eoKIfoiLhYWIh4GDg398fn12e3t3eH97eoGJe4GSeIOKgXuHgnqCf353gn52gYJ6f4V6f4R8f35/inqFj3yEiX97g3x4e3p4dXx8en6Ef4OKhIWHh4ODhIF+f356e313e316fX5/f4KCg4KDg3+Cgn9/gX59f319fX9+fX9/fH5/fn2Bf4OCgol/hYR+f399e317fHp8fXt+gYGChIODhISCg4KCgX+Bfn1+fXt9fHt9fX19f39/gYKCg4ODg4KDgX6BfHx+e3x9fHx+fn99g3+DhYGIgoOEgX6BfXt9ent7e3x9fn+CgoSEhISDgoKBgX99gX18f318fn58fn9+foF/foGBgYGCgYGCgX9/f31+fX5+fX9+gX6Bfn9/foF/gYKCgoOCgYJ+f359fnx9fX19fn6BgYGCgoKCgoKBgYN8g4F7gX58fX97fn5+fn6Cf4GCgn+Dgn6BgX5+f31+fn5+fn+Bf3+Cf36Bfn5/fn+BfoN/f4N/f4GBfX9+fX1+fX1+fn9/gYGBhIGDhIGCgn9+f3x9fXx+fX5+f3+Cf4GCgYGBgX+Bf35/fX99fYJ8gX9/f4KBf4GBfn6CfH+Bfn+BgX+BgX9/f39+fn9+fn9/f4GCgYGDgYGCgX5+fn1+fn5+f39/f3+Bf4GBf3+Bf35+fn5+fn9/gX+Bf4F/gX9/fn+BfYF/fn+Bfn+Bf3+Cf35/fn5/f39/f39/gYGBgYF+fnx9gYSHgYF6d3h+f4OFgX9+foGChIJ/fXx6fH9+gYF/fYGBf4OEgYJ/fX59fn1+fX9+fw==", + "communicationSorry": "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", + "communicationThankYou": "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", + "communicationYes": "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", + "expressionsBoing": "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", + "expressionsBoo": "UklGRiEgAABXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0Yf0fAACAgICAgYGBgYGBgYCAgIB/f4CAgICAgICAgICAgICAgICAgICAgICAgICAgIGBgYGAgH9/f4KBgX99e3p6gYyQgoB3cXiJjYZ/c3eBgYiFf3J5hI2alIRbTll7m7CrhXBiboydkXlman+wtphSEhZJqdnYoHFaa5e0spFmR0Nri42Ymp+efkgyNmKbwcGggmlng56mnHpNRlh3pszMs3IiEDNqnsa7mHlibpWzsJRsQkFZfa/NyKZcHhE0cKfGtpJ1aH2iu7OTZT02T4GvzMiNOw8TUJ3S1Kt5WWmaw8+paTAaM3K00tKSOQUnXpzm3KpwUWOi0NOiWRsLNXm72c6ELw0wc8Tw1JZeSmys0cOIQBEWT5fO3btkHhNGmN/tt3NHTIfG165mIAoreL3i15Q1DCNuwvDWj1Y/Z67Zy4w+DRhOntPfvWcbDUOS1+q0dlFZjMbQoGEiFzl+tdHMkz4WLGu25cyRY1R5s9G0eDQTKFyhydS4aiIcSYzN3q59YmWUwLuNVSUkSYa1y8ePOxo0cbjevYRjYYvFzqNgIRI1crLQzapWGyNanNnVmmxccKvRuYJAFSNSkr/Sw4g0Gzx6uti0gGZnksPFllgiGz96s8/Po0gVKGSu4suLYFR3vtm2dCoJJ2On1di3ZBoZUZfU2qBtW2ujz72DQxQhVJbH2ceAJhM6gcjjsXZYWZTO0J5YFxA7fcDg1Z44Cyhtt+bHg15TfMDUrW0nDDBsstzcrFAOHFun4tOSX1Ftste/gTcNH1mg1uHAZxYVSJbX3aBrU2Kj0MWOSBEbTJLP48p7IQw7h9Dlr3BRV5HN0KNcGhE5f8Pm1pItCCx1xenBfFZQgcLRrWomETJ0uuLbnTkJJGy+6siDU0l4vde4dSwOJ2ix4OGtSwobWq3o1ZRdSGWr0MCKQBQiVqDZ5b1fEg9KnN/ipGhJXJzMyJVNGBpJlc7myXMeDDuL1+WyckpTj8bOpFseFTuEx+jViScJLHnJ6sCBU0yAu82tbCgWM3W+5NuZNwchar3szolVRnG01Lx8MhAkZbHi5qtJChhZsOnXmF1FZajOwYk9FSFZpt3mt1kPEE6i4+CgYkNandDMmEsUF0mZ2OzHaxgIPZLc6bBvRFCNxtCjXB4WP4rN6dB+IwgxgtPrvnhIR4DA1LRrJRAweMTq3JIuCCJyxe/KhlA/crPTvXsvEShquufioz8IGWC37deTVzxiqNLJjT8RHVio4ui2Vg4QTKXk4qNkP1WXzNCfURkWQ5XV68l0Gws3idbot3ZJR4O90LFsJxQzeMbq2ZIxBiJvwu/PiVE8aK3VxYs7Ex9ZquDms1YQFU6k4d+jZ0JTlcXNoVYdGEGP1OrOeiIKMIHP675+SUF4ttW+fTAUJWa45eOoRQwWWK7o3J1jPFmZys6fURoXQZLW6812HQoxhNLtwIFKQHaw0b17MRYmaLrl4adECxdWruvfoGI4U5XK06dVGxM7j9Xrz3ogCy+B0O7Cgko8dLDVw4AxER1htufmsk8NFEqk4+Oqbj1Mir/Ur2MiFDCCy+nYjzEJI2fA7NiVWDdanc3Sm00WFEWY2evIbyAJNojW7sJ/QjxusdfGgzYOHGCw5uexUxUPS6Li565rOUmBwti1aiUOK3nB696aPw0ZXrXp3qJcN1KPy9WpWR8ONofL7tWKMAkibcTt2ZZSN1iaztKcTxkSQpPT7cx4KggvftDuzYhGPGKo08uORBYUUJ3b7MNqIgs4i9bsw39BQGuv1MWFPhQXWaTg6rtiHQ0/lNrpvXhBRHO00799NxEbX6zk6rNYGg9Im97muHRASXa1z7l3NREgZrDn6LFTGQ5Jn9/ntXQ+Sne10bl2MxAfaLTr6a1SFA1LoOLntnJBSna2zbd0NBEjbLfr5alJEhBSqObosm47Snm2zbNwMRIocrrs4qRIERNVqufmr2s6SXq5zrNuLhIqdr/t4qBCDhNXrunlrmk4Sny6z7FsLxQsd77q355AEBVZr+rnrms3Snq3zbJuMBUqdbvq4KBGEBJWrerps2w4RnS1zLZ0NBYmcbbp4ahIEhJPqubts3I3QnCvzrp9ORshaa3j4a9aFxRFntzuvHpAPGmmz8CLQh0cWaLa5rtoHhE5kdbxx4VFNWCaz8iYTCAUSZbS68h8LRAsfsfu0pNNNVSMy82pXikRN4PE7daVNxAbaLzt4qBcLUl/xdi4byoNInO47OKlTBUSVavl6a9pMkJwu9rCgTQPFmOp5+m5YBsPPJrX8Lx7Ojhnp93Kl0IYDUuZ0+7HgCsUJn3E69OQUzFajdLSq14hDy6Dve3WnUUWGluw3+WnaTRJeL3au34vExlnquPmsWEdEUCb2O+/ejs6ZqndyZZAFQ1Ml9XuxIAtEymBxe3RjE0wWY/W061fIA8ugLrq0p5LHR1crdnko2o1S3e83LuGNBgYXp7Y4rVxKho6kcfqwoJGOmOa3MmmUh4NOYW/7cyWQxshbLTh3ptdMlB8y9m6eSsPGWql5eCwZCQZQ57N6rd3Oz9oqeHJnEcZCkaNyuzEiTkcJnu65NSSUzRZhtTWtGkoDCN2rOjXqVYnHE6mz+WsdDdIb6/gw5Q8HQxRk83nv4U0JCl+uuDNj1c0X4jT1LRoKBEhdqnk1KxaKiBJoMrkrns8Rm6q3saaQSAKSIzF5MSQPiglcbHb0pdhNlqBy9e6dC0TGWqh3de0azAkPJO/47iCSUFsn9zKpE8gDTeDuOPInk4uJl6mzNmgcT9XfLnYuYY2GhVYlcvbuYQ/LzJ7r9PFkGJEaYvJyqtqLRsmb57RzK5zQDRBia/PtYtcUXKVyb6fWzAcN3il0MOmZ0IyTZGz0K6JWFp1nMe2lFEvHUN9q86+oGNFM1iTtsuqhlZfdKDDs45QMB5JfazLv55kRzJdkrnIqoJUY3OlwbOITi4cTn2wy8KcY0cvYJO7x6p+UmR0qsO0hUwrGU99sc3GnWZIL16RuMSsflZkdabCtYRQKhlJe67PzaNuSSxTirLGs4RaYHGfw7mMVikVP3es1NWobkQjS4i1zbqKVVtrm8jAlVcqDTZ0qtrasXFFIkCEss++kFdXaJTHxJxdLwstbaTY3Lt2TCM1fKnNwppdU2eKxMmnaDcNImSb0t7Df1IpK3GhyMSmZlNngb3LsXE+EhZZkMvfzYtZMiRhmcDGrnVTZnuwy7d8RxwQTIa829KdZEEkTYuxxbiJW2R1nMW8jFYrEDl4qdPZsXVRKTR3ocHDompfboO4wqFrPhcgY5PH38eKWjMgXZa7zrh+WWZypMe1gk0gD0eBtd/Yo2lAHUCFsM/Ill5ZZ4zCxJtjMA0oa5/U4r6BUCkmaZ/Dz651VmR4rcivfEcbE02IvuPVnWI5HEWKttLFkVpYZ5DFxZtfLQsqb6Xa4bp4Sikqb6XEzKtyVWV6rMiveUUbF1CNv97PmGFAKEaJsMjClWFYa4i9w55nNRcnbJ7M2LmDUjouYJu2x7KDXGR3m8GzhlItG0F/q87MqHFRODp0or3FqXVYZ3imw6x9SicbT4ey1Migak4yQoGnwMKealtpgbHCo3FDHCJakLzWxZFkQy9OjrLHvYxcV2yPwsWdZTEUJWmby9i6iFZCNV+Zsr+qgVplfZ/FuIpTLBc2dqTIz7GAW0c9YZiqu6mDYWuCnMKwhlAtGDV6oc/RuoNaRTNgkK24sIZib36bvLKBVC0ZN3iozNu4hFdAMlSVp8CxhmVqgJbDsIZWLRs2e6PO1beCVT4wWY+uvraKam1+m7qyglUrGTZ1qcrYt4ZZQTlRkKW6ro1sbYSUuquIWDQlNneexsu5il5KOk1+n6+1mXtzhI6qr4toPzAvZI+xy7yea1Q7PHCUsr2shG55fqGyn3lOMiJOfajJya56Vzw2XpKww7SLbG17lrisiVkzHjVvnMnSv41dQTBJg6nAu5hvZ3eQuLucaDgcIVqQv9XJn2pGNDlun7jCpn1nc4iswKh5QyIZRH+w0tCwfVM7N1WOq7+1jnJugpm7sIpZLR0tbJ7G1LuSZEU5RHObs72ghnB6jam4mXVAKCRLhKvPxa6AWUA+UYCltraXg3KGmK2uiGEwKC9il7jOu6BrTD87YpayvbGUdHaLnLGjekYsIzx6p8XJuIthRkBDcqGwv6aObX2PnrWWcDsuJUyMq8vBr3hWQDhMhLC7xZ+AaYCSqriLYCwjJl+duNK7nWVMP0Nlmba6tY13boyZsal4UCcsNnijucaqkWNVS1FqlquzrpJ+do6TqJp2UTQ3P3uatLupkGhZTU9pmKu5sJV7dImMp5h6VDo3P3mQtLuslnBaS09il6q+spZ6aoOFqJ6CYD00OW6OtcK2l29QQkhmpLTGsYprZYGQtKaEVjgmOXORvsC0jWhRRVJwp7HBp4draoWSt6CDVDUoOnaRv7+wjmtTS1dupa28pIhtaoeTtaKEUzYpOnSRvL2zknFYTlRnnKe4qY1yboWPsqSHWjwnNmqJuMC6mXdWSE5hm6u/rpBxZICOsqyMXTUhLmWRvcm+mHFRR0pjn6u/rotvZ4ORtq2HWjIhM2uSusW1l3ZWTFFflqq7rpF0ZoCPra2MYTwoMWKMscO5nHtaTlBckae3spR5Z3uKpq+QbEYtMVeEpsC5oYRgU1NXhaKwtJuBaXiGmrGYd1M0Lkd2lLq/rpVwV05McZqtu6aJa2x/krSnhmI1JTJljLrLu6J0UkhGZZmsu6uNbmqDkLWximM0ISdgibXRwKd5WEZHWountbaWfWx/jKezjW8/JCZNgKjRyLOLXEZBSXqltb+mh2t1hZm3nXlOKR88eZ7O0LaQYkZAS2ygsL6rjXZuiJOzpn5bKyUwa5W80beea1BFTF+RrbS4mIRxgYycq4NqQCwyU4eiyL2ph2JPT1Rvn6m5qZN9couJqJl4XzI1NG6OrsmwpHNdS1Fcg6qvvKGOc3eHiqiHc1EzOEOAk77BqpdoWE5WZJass7aXg2uEhJmqe3A6Ni5WjJfPtKyGZFhPZGyhq7CukH1wiIOenHRhODgzbI6lzK+kfmZYW2ZvnaGpqpWCeYh9l491YkRBOnGDpcSuqH5rU1lgb6Smt62Ue2+BeZuOeGBAPTxzhK3Csad+bVNdXnClo7anlXprgHWZjn5lR0Q2bn6qwriufW5MXGBvq6O1pox0Z4R7oZp7ZT86N26Lqsewo31rWGZtbaCao6SPf2+Jd5KYdW5MRzlngpbCsKqNdV9ebmKUnp6qkoRsgn2IoXxxUEc8WYaMu7SolXxvYHVheJWNpZuUe3yCdpeFeWVRRkZ2fai5r6eJel1sYmGPjaGkm4ZziHOOlXtwUks6ZX6UvrOulYJnYWtWd5CUp6SVe4B8dpKCdWRURU54g629tKWJclhkXl+Nk5+onIl3hXWEkndxW1JFY4CMuLSrmoJqXGxXapKPpaibgnqAbIyKeHNbUURwfJq/sKySe2Bga1F4kI2np5l+hHxtlYJ4blpJSXl8q8CvpYtyV2ZkVYCQkaqtlIGEdHCSf3VuWUhSfYKuwKqehGhSaGpdiZeOqaeNf4V3bZR5bm9bUF+Igqm1mJeFb2B3b1p9iYKmsZOKhnBli391hWVTWnV3nbmcno1qX3FxXHyOfaWwkpCJeGSKfW2HZFpfdnSRsZKdknVpdXVicYR/lrOZlYx0Z3aHcY14YGVocnyllJSbfHV3e2tneHuJraeclXdqaIR7iY1nZ1pjao6clqmQfnZ3b2ZueYWar56ag3BrdIh+knZlXVNodJuapaKGfnN1bWhxg4ulqpmOc3JphYuJjGZeSlpriKagqpGCc3Z7cm92goKknpWPe3hwjoCFfl1ZTGVvlaahp42EdX16bmx1e4almpyPgHd2iHSEbF1XUmx2oqOqpo6EdX9wZ2JyeJKun6WGfmt2hHSJY2BQVXF+rqWzo4uAbXlpYWR4fJutop6Ef2Z/fHOCXWJOZ3aLtKGxmIl2cHpkYGF3fKWxp6SAeV15c3aHYWxTanePs56yk4Rya3VgY2J9hae3paB7dF10eXWIZmxca4COrJujjn50bnhtY2Z9f6ayqZ57clV2eHyTcHVaa3WDqJOhioBzcX9zbmR8eZuzqKh9eFZse3eadXtgYG9zn46ilIaAcoFydF52f464pa19dV5ah3Khf3ppUHNimZOanX+MbIeAem1jgXeqq6iVb3BNf3uRm3R6SmVgep+Lp4aPf36VeX9ab3SEs5+pfXNeXYx7poR5ZUhpWZOUm6eKmXePhXhxU3dql6ehonR7V3qFiKFye01XY2ugja2WkpB8lXd6VVpwcaymsZJ7bVaEdpiNeWxKZliJmp2xkZp6hIFyc0tqaoatqrOEfmBfgnughn9mTmRdj5ejp4+TdYR9dW9QcW2OsKytgHxYZYF+oYKAXVRiYZiUqJ+NjHKKeoFuVHBokKqwqoR8VmR8g6CKg19TXGGRlqedjIVyhYGJdlxrZoeks6yNelVedYSflIdlUlNbhJenpZSHeH+FiYBiZmt0nKanknpnWn2EnJ2DbktUVHqZnaySjXp/jIiMZWJlZY6erp2JdVt1e5CahnpUVFNskJqunJSEf4mJjGtZXFt7nq+smH9haHeGnpSCYlFMWYKTqaeZjIGGho5/XFdbZY6tsqWMclpygJKgiHVQS05mkZyvo5eLgYuKiW5NU1RwoLW5oIhnXnqAnZeCZkdLTHuWqbOeln+Gh4uHXkxMWn+vwridelldd4eiln9bQkdShqG1tZ+Od4CDjYplTUxZea7Aup5+Xlp6g6CVfF9BS1KGobC3mYx4gomSkmpJRE9up8LBqYVgU3N+naCDaENESHifr76kkHuAhZCVeE05S1WYwse9jXJIaX2Qsoh3QztDYKWsx6+PenCFh5+IXDw9TnvCysyid1JPeYGum3tdNUNPkq+/wpSBbHeBlphzTjRFW6DLz8SMa0VgeZCwiHZIOUprqLXHrYVyZHaHn5JwRjhMbLPO1LV+XD9neJ6uhnM+QU15sLjInHpkXXqOrJl2RjZJarPM1q9+WDxod6Wri3ZASU19qrO/kHhhZISYs5x5RSpEY6rP1rd/XT1hfKCzkHpFRE5yp626j3VkY4ucuKZ9SiA4WZzU3cSIXDxOfZ27pYBUN0Rdlq+4pHxpX3yXr7SOZS4lS3a/2tKpbU48aI2vupJvPThIc6i1upV1XWKBm7itjFwrLFKEwdnLmmVKQXGXtriNZjQ6TX2wt7SHaVNijKjHtY1VIiZLhcPdypllR0Rzm7m3i2M2OE19q7WziWlXZYqryLiQWCIcRH2+4tOlZ0c6Zpm2xJdtOjFGbKmztJFqWV6JqcnDmmMsFTdvqt3UsXFLQFiXssmmdEYoQV2bs7WfcmBZfqLCyKh3OhkiXJLM3r+QVUlKf6u8vIJaLTBQe7G2sotqX2qTr8a0jFYqFzh3qNzSsHhOTFeXrr+obUkkP16VvrmsfGNYb5izw6l+SywiSoiv1cWibk9VYp6vtpxkSCxNbp3AsKFxXFdtmrDBqIJYOzNGgaLAwqB9WFxgjKypqHVbP0lrgq+lmn1fYGaSqLu3knNOQDxijaO8q49pXWBypKqxlWpPPVpolqebk2xlYX2fsMSojGpLQkFqhJmumopybnSIqqOlh2JOSF5uk5mTinFtb4yftL2ljmxQPjpSdI+qqZ2Kdnl9mqGglW1dR1Fje5OPkHtydoKfsb+wk3BPQD5JbIqWp5uRhYKLjqOVjnheWFFnb4KKhYZ9hYmYpKajkH1oXVNSU21/kKiioo2GfX6TiJaBb15PXF2AjJecjIh6hIqYpZuRd2NPSUplhZewppyEeXx+nJaYhGVXSF1phpmVlH12dICXpLGljXRbUVJYZoGIlZiTj4iSipiWiIVoY1VhbHOKg4iDgIWHl5uhn4+BcWReWlZfdIKWpaigk4x+hoSDgXFrW2JkcISHlIyJgoCLjp2dlol0ZltbW2N7h5SgnJaLiICGi4WEdW1gZmtygYOKg4WAgo2Qnp6cjHttX11dXW1/iJmbmpGMioKOh4V9cGpibWt3fn+Eg4eFjZKVmpeOgnlsaWdmYGp6fZWanJePi36MhIWFd3FlamZwenyFhISCio6Vn5+ZjH9rZmJgX2R2d46Ym6CXloaMg36Bc3JnaWNqc3eGiY+OkJCQl5aUi4BvZmFfY2R2f4uZmZ2TkoiFiH6Bd3Nram5teHqAg4WIiI6QlZeUjoV6cG1qbGljbXOBlJ+mn5iHfHx2fn1/eXFwZWtueYWKkYyNiYmRlJeSiXhrYl9hYnB8hJKVmJKTjYmQhoh9dmxlamNwc3l/gYmKlZicoJqShHlsZmVnbGtocHiClqKrpp6MfXdvdXV4c29sZW1ygoyWmZOSiYmJi42GgHBoYmZvdHqChIaOkJWUk4qDf3Z5dnl4d3ZvcXF4goqQkY+Kh4iKjY6JfnNpZWZqa3eChpKVmJSRjISFfHx4eHVydG9xcnd9hY2PkY+Mi4uLiYd+dm5qbHB0cnp8fomPl5eYkIaFe315enZyc2ptbnV9h4+QlZGOjIuMiol+dm1mZmpvb3p/gY2VnZ6dlIV/dHFyc3V0d3FzdXiAh4+Pko6Jh4aIiImCenFoaGx1ent/foCJkpqalop+eXR4fIGBfXhva2pveIONkZSRjYmJiouMhXtwZ2NodHx9e3x5gY6ZoaKaioB2cXN2eXd2cGtqb3iEkZeal4+IhIOFh4eAd2xkY2p2gYWCgYCEj5mfnZOEd29scHZ7fn16dHFyd3+JkZSTjoiDgIGEh4aBeG1naHJ/iIiAeHV3hZWgo5yOfXJrbXN7gH97c2xqb3qIlpyclYuDfoCDh4iDeGphYGp6iZKPg3dzdoSVoqSci3dqZWl0gIaEfnNqaXB8i5idm5KGfHl8goiLhntuZWNreYiRkIZ2cHN9j56kn5F+bmlrdH+Hhn90amZqdoSSmpqUioJ+gIWKjIh/cmdgYmt8i5OSiHtydn6Pn6SfjntpY2ZxgIqMhHltZ2p1hJKbm5SJfnl6gIaLiYJ4b2lpcXyGjIuGfHVyeIKOmJuYjYJ3cXJ1fH5/e3VxbnB3gouUmJaRiYR/gICCgn12bmppcXyIj5CLgnp1d4CJkZWSin52cHJ5gIWFgnp1c3R4foSGiIeGhoeJiYqHhH96dnNzdHZ6f4OEhIF+e3p/hYuSk5CIgXp1d3l8fn17dnNzdn2Dio2Oi4iEg4OEhoWDfnp1cnJ0eX2EhoSCf39+f4OGh4uLi4iEf3p5d3h6enp4eXl7foKFiImJiYiIh4aFg4F9eXRycHB1eYGHioqHhYKBgIKEhIeHhYJ+enZ2eHt+gIGAfn1+f4KEhoaEhIGBgYKDgoKAfnt5eXp7foCDhIKAf36AgICBgoKEhoeGhIF9enh5en1/gIB+fHt8foOGiYqJhoKAfn+AgoF/fHd0c3Z8hYuLh4F9eXt9gYaGh4aFgoCAfn5+fX19fHt7e3x9gYOEhYWEg4SEhYaFhIB9eXd2dnh6fYCDhYaFg4KCg4OCf357fH+ChIWEgH58e3x/gYKCgX58e3t+gYOGhoWDgoKBgoKBf317eXp7fH+Cg4WDgX9+f3+CgYCAf4GDhoiHhH98enp7foCBgH16eHl8gIWIioiGg4GBgYOEg4F9eXZ1dnl9goWGhYJ/f4GDhoaDgHx6e36ChYeFgn57enp9f4CBgH17e3x/goWHiIiGhYOBgH9+fHx8e3t6ent9f4KEhoWEg4KCgoKAf359gIKDhIOAfXt7e31/gIGBgYB/f4CBg4WFhIOAf35+gIKDgoF/e3l4eXx/g4aGhYF/fX+BhYaEf3t4eHyChomIhYB8eXl7f4KDg4B9e3p7foKGiIiHhYOBgIB/f359e3p6eXt8foCChIWFhISDg4SEg4B8enh4en6BhISDgX9+fX+Bg4SEgoB9fHt8f4GDhIOBf35/gYOEhYOAfXp4eXx/goSFhIF+fHx9gYSGhoN+e3l6foKGh4eEgHx6enx/gYOCgX17e3t+goaIiYaDgH18fYCBgoKAfXt5eXt+gYSFhYSCf35/gYOEhIJ9eXh4fIGFiIiFgX57e3x/goSEgn98enp7f4KFh4eEgn99fX+Bg4SDgX57eXl7foGEhYSCgH5+f4CDhIOBf3t6enyAhIiIh4R/fHp7fYCCg4KAfHl4en2ChomJiISBfn1+f4KDg4F9end3eHyAhIaGhIJ/fn+BhIaHhYJ+eXd3eX6ChoaFgn58fH6BhIaGhIB8enl6fYCDhYSDgYB/f4GCgoKBgH58e3x9foCBgoKCgoGAgICBgoSEgn98eXl6fYGEhoaFgn9+fX5/gYKBgH58fH1+gYOEhIOCgYCAgYGBgYB/fn18fH1+f4GBgoKCgoKCgICAgICAgH9+fXx9fn+ChIWGhYOBf359fX5/f39+fX18fX+Bg4WGhYSCgYB/gICAgH9+fXx8fH5/gIGCgoKCgoGBgYKCgoKBf317e3t8foGDhISCgYCAgICBgoKBgH59fX1+f4CCgoOCgoGAgICAgYKBgH9+fXx9foCBgoOCgYB/gICBgoOCgH99fH1+f4GCg4OCgX9/f4CAgYGBgH9+fn5+f4CBgoKCgoGBgYGAgYGAgH9+fX19fX+AgoKDg4KBgICAgICAgIB/fn5+fn+AgYKDhIOCgX9+fn5+f4CAgH9/f3+AgYODhIOCgH9+fn5+f4GBf359fX2AgoOEg4KBgH9/gICAgIB/f35+fn9/gIGCgoOCgoF/f39/f39/f39/f3+AgICBgYGBgYGBgYGAf39/f35+fn5/f4CBgYGCgoKBgYGAgICAf39/fn9/fn5/gIGCg4ODgoGAf39/f4B/f39/f3+AgIGBgYKCgYGAgH9/f39/f4CAgICAgICBgYGBgYCAf39/f39/gICAgQ==", + "expressionsCheering": "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", + "expressionsCrunching": "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", + "expressionsCrying": "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", + "expressionsFanfare": "UklGRiZDAABXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YQJDAACAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAfn6AgIGBgIB+foCBgYCAgICAfoCCg4OBe3h7g4eEfX1+foCBgYF+fYCBgoSFgHVyfIaGgoOCfnx8foCAgIKEhYWDeW5xg46JgHyBgoB8fHx9gYSGiIV9cW56hYiFg35+gHt7goeDe3qBjpGCbGN1io6EgYOCfHp5fIKLiYF3gIuLdmFviY6CfIKFgn17eXuBlYF2h42LdFxljZ6KdHmCg4GBd3l4l5JsiZCNbFRij5+OfYGBfXZ8eH50paFYjYaLY1dvk56IeICFenF2fYCOxVd7fIqEYF92npiEfHh2b4CFi3eskViDfJd7YVeBoZSAdnV1cYiNkHKwiE+GfZt6YFaGoJSBeXRvaoeRlnWuj0uNg41kV2qcpY95cXFsbo2HlX7BeF2FfYNcXXiioIh+dGtgd4eKlKG6VXp3gm9bY4aqn4d2a2Jlhn6Wl7uSVoRtgmNgaJSunoJsX1x3jYSpj7Z8X4Fwe1xjdqSpk3liVWiHiKClgbJicHh1bF9wiKqghm1WW36KkbSEj59UgHd3X2d+lqWRemNWcYmIp6RtqYBdg3J0XHGIoJ+IclpagoqPro90r2RwfHBoYn2So5d7alZyiYCNt4OGn1p8d25cbomfoodyXl6Hhnycr3GfgWCEcWlddI+hpH5kWoCOe3ismnGpZ256cmVnhJqghIFWao2NdJO6ZIiVZ31nb2R6kKWEh3JTh5J9db6AZ56NaG1fcG6LqqJ7U2mCepOHw2t0eZ1wdXdlZ3eRp5xnTZZ7inLEfVyCj59pfGNhaIeXspBTTqGHb5HEX2uCpHJvdW9jdZGinHRAg6GAdbmKUICJn296amVphJelkldNm59vhL5pYYCgjWJ0aXF1kJuXd0d6qIF2rZZNeoKhfmlwbHWElpGKXV2YoGySrWVie5OfZ25re3mOkopvW4GofH6wgFdwgqWGXnRxhYKNh31kbZuWbKqTY2F6jqhla3d6h4uKeWpjiqV3lalqXm2Am5pceW6DiJKBcWB2n4uAsYJjXXmHq3VkeXSLjop5ZWiQk36hn2leb4CRnWJ4dICQjX5sZYGWg4+pd2hofnyhfWV6d42Si2phepGId6udZ2dvgIieYnd6hJCLe1xxkY53j7FvbG18eZWEaIGBi4qEbV+HkYN3r4tkcXV3e6lwdXiEj4p4V3uXiXKVrGFuboZqnJVjeXyTiYVjZZeIfX2xdGVxgn59oG91cYuUiXRbh5J8ep+VXnRyi3eXfXZweJySfF5wnn5vjapodnJ9eIuXbYBrk5aGZ1yUjXx1rYFgenaEep10fnd4m4t2VomNgHiQq110dIF7i4Z3jnSLjnVfeqB3g3SsemR9eXqGkW6Jg36Ne2lsn4V7dY6fZXh1fXShe3WBhYmHbWKVmHB9cKt8a26CcpGfa3p1kIGBYoCtb3lxm5RgenyHapZ2e32RlXRrYKKTcICJrWNbYYKFoJtydHKUenJoi7GNbFSTjXF5fXyDm3t9ZImRi3JoinWGhZaTZ3FteneYkY+GeHFRb4mxnm5wbZZ4e26JiqJ+SmiCp5JyZYWegXZemJSHi11QcrSHkXlycIF9dpyKlIhvdDuCo5p+kWlliIWIe4SNoYMwa46ylmN4cWyOnHyEkJVvSU2N0pNtgWWAX3GgqHqrbVxJcpankXaFi1N6dLaKYKeBVGR1jaCKg3FwcGe/omGYjW0iZbWpm3xUgHlyhLtvhZqBQFaNtHtggZqKikSrn2SRhHBFfKKVhHVwem19i8+KXYRyUVyQrZF4eHF3gXmWrGCTjnRDYK+geW11eWqEncd8e3xIRmyyzpJRXXdpeo/NlmuRYFVUjqiSfG17hmV5or10hnVVRXu1rXxlaF9wop3CkVZ9aEtenrKUbWhwcomehKNukIleRGinrHp0aWyAtXe3d2uEVFNwtbmBY051erSSjZZkkmlWTZWojX56gGuAnHC1eYt9RkWEtaJ7amloa8OfnolicWRSZa2pe3qAcWKLp3mia5uBW0ZtoKmKd3hecs1vmnVydW5fdqedlF1kfnXId3qHbYN2alySlnaXg3iIn1F6pH2Ke1tcdKx9ipFafblngqJ9YHBydmukmmGWfVi7fVqVi3iPhmhNZamJnJdNoJBSipR8fHhtbnSuk2OFYYbLZGWSgHCDdnBvgZJ3oY5wslJIk6uIeHFteGmUfoWgW6yGYoWWeFd+koVvdoR+oV+li1xslZdtkYVsX16dkatsiJRaZYKraHuEhXhqlXWSbYO7Ym9qon5teXuLZ3qGlo6Lq1NcW6mpbn1uhHRseJeTcrV2XHeFoWppdpqIZ3WFl26kjVpscbKAeYZ0ilhdlKx+l5tPa2OXnm+BfpNxZHidgYGsaG9vfaF0dnaPilNsr4qGsmBdZXC1jXh2e49jUp6XeLCAYHJ2lI1ub4WUiVKAlXSnhGN5ZJqdcXeDiYlNb6V3q4tndmOBnHZsiJ2HbGeSbZyKd4F0epB3cnaainBdmHmTqWV6el6Si3p7kI1sW4aEfKyAe3tsh4KBdn6fcGKAhHqliWeBaY2GfIWBkIFkaot+k5tphnl1gXd8g5WPcWiAgZKKb4WCgIBxfH6Oj3RlhIONkXeAh3x0d3iEkYuFbWyAfY+AioV5im9yi4CEkXRqgoCLhHKNdYSEbYCUh4KFbWuGhYh8iYN8gW5xiJKNboKCdIOPd3yOfX1vfYSOgnyCcnt5eZeKfYmHW3qIfoqHhXxrfoOAgIB8j4pufJFxfoaAcYGQhXlkhZR6fG9+jZCAiHxsiYFqbpOgfXlycIOKiot9b3GJfHeHnHx3gHmBi3R1goNyfoWKg4eVeHh4YHibjnh6fJxldISFlnB0hIOJeH14nnSBhm55b4iKkHlqhWvEhWiIfnxQa4enkntqfLBaeZeGcm95dYp7j4CfhEmRoHh2ZWiOl26EdauiWoV4fW5fgqeBco5wl41RoIJuVYq6hWRngHy0k1yJaVd7pJh1cGh+ksmEbX5PTXeoq4Nfanaou2pse3JjiqGFXWh4iayxaIFwUFisqYJbX3uisKlfe1pbd6CTgXdnjYuRi2iQZ26FnItpYmS1kKh4VXVRfqurbVh8fK97un5fTUGItqN2cHRdqZCwamtjaZ2aeGBxeY6qj6BdZVZnrKp4ZXhkkbKnk0RNV5K5j3ljh2KWhZaeY11dnZKOg2V7cr1hrmc9aJixiGB4e4m4dIGgRkZppK2PW5FohJVou5NNR4GXnnpUq1ypn1ejY2Rki5SRZXmaZc5pdJ1QQXDHoodLe45nt16onDtYj6GBjmCYZJukVJRsW3KSk4d9ZKp4rHVji1ZJkMWQaWGEi3qtdYR7T2CknnGIdoBtoptqgHZHg7GCb3aCn4WQaoR8VEixxXtua3lxjZ6LhGtFabeifoJngW6UhoGXcit8uZR5foaJdot5jXU9YMWvd2lth32FlYiOajp0tJ+TZ2t+b4qYl4lLPKKxhGh8qX1jfICOhVZhsJ2EbnB8cqCQdoZkRZTDinZkhoF0foOli0NLm6SLiX6KZ4CAhIRwYYGgintugY57inSNhm1TfriQcWmHdHyXh5BxV2GYn3uJjoFngXZ+lH5ubZGUfXJ5hY2IcIR5bnuInoZqd4p4fY+RgF9rcIuejYCJdm+Ifnh7i3triIt3gI55joVsfIGCb4iUeXaDfnmShH17aXx7jYaLhoR1bIN+iYKCgGSGkYR2hIGBhHl3eZh2cpB3gI+AcYSPfXFugXeRlX2BfHKBjnp1g4Z7aYWRhoV0fIR9hnx+jXVwioF8iXyIinJwa5CYcHWYgnd8cIaRdHeIkWxukY94fnp8h31xhpKIcHV6foqSd32QbmN9nIl1eYmEe3d2j49ue5GKYHKOh4iAenV6h4KOkIVbcnqGm4R0do6AY4iahV6GjoeEZ2+QlXR4mntnaZiKhX5xfn6Bg42Wa2V2h4mIgHmFiXVxiZdva4GTi3ZydZKBdpGRgFFvkZ2Bd3WBgXqBmpJnZXeHkIp2eoaHeXGLiHRxfJ6LdmJ6mI14gYtuXnyLo3p2coWPgHeOjWhteISadnt4hpp3cZB8bHeOj4lnboKQk3WHk2Jje5KLkW94fYaAeJ2HYW+Gi4OCa4OXgnB6j3Z0gpF9goBoh5pwgpWFWGSGnIWEd3GWiV6Nl4Jrdod8dIV7hZV6bZSDemuIlXl+bnCKmHWCioZ0X46IiIRxgIt8aYWWj2d1knx6d3iXkW1xfomAeImDfoF4dpSAco2AhWp5hoSEdXqSlW1jiouVcYRyeIN0fJaLcXqIeH6ElHp+cmeLmnJui5B6eXt8hY11gJJ2aHuPh3mHhIF9dmuSmnZye4F8foJ7j4Z6co18eoKIiHJxfX2IgXaKnnFwd4mNeoF9fYJybo6RfoJ7hnV+hX6LfXB6kHx5fIWLent6gop7eYaQdXR3hYCFioN9eHt+gYiAfXyBb4aLgo5uanuWiJF8dH51fnGCgn2Knnx1dH2KeHmCeI2QY412ioN9b3plwZdpa2yEgnyEcqSeXYJ0b2+EjYSPql6HaXJsi5WXbH1knq51VlN9moScqVZ7a5eDZXSGi7JfbZKGa1FynorQkUJidZaGd3BpnrFjgoSHaGB5eZvGbWdliZdvbm+OpX5sooZePnKWoredT2pvhnx8doGVl3dsnYZ3S0p9y8t+MoOGkWVlbpetnFh4iIVhVXWjvLB4RWFjjpKYbHydiXKUgWhRfYWro4RgZIJ4iqKBfGNxeo2ie2JvWqHFlXUwa5eLhIV8nV2nXHt7pWJbXMicqlFpaH1xpZqTS3iScIV3iHdwi62Kmzl3ZYGAoo6cSZqDmmxiYYeGunGUd2SAaYmTkZxBX6SAnGCCdWehl4GuNnV5i4mAlodDq3yKh2BdYJHed3d+aYlrfXaLrVpllXiie2NgbqPBlHZRTYqamGeOfF6okIJ8Y3B0e7GUaZZiiIuRelaLVn63hGuIdm1xkbV2doVdknx3bKlvaI2ahH5TYXLOjY19aXGCm4heYY12k5pidY13bWu5fNGGI2Sanm5PrIKAjYNnhHCGa5yCaMR/VoN8lnaQUl+nrm1qcop1aoZqp8RseGR4e3KbboCOgW+WfldxjoV9vpBiemeEao97dpqDeoVvem13gn6l0FtybWp2h5tfi5uAkGlPb3qYfJyrw09eSJWAxT5WyoaBfFRwZIp+mKCoo09RYXyOi2+pkn6VMIFDeMmNpX66hTtVYJWfWIaliZ1oPm5+pH6Vim7UfE5kYollib6dgn1GW2OPjXHecoukPXZ1gntQ4Yt9emJaen2gRYSjmvB0H1BcxGyEnHClYFZeqMZdX7KAjZ5AXmqnqlyWXYaImnZgcpFKqZdysstJOFqrbrKPbnt8cWNtnWyL4XhyW0dhjqmQabfGd049dmKJo27iUZaBcElekadiqHGEj2Bee2zTjp5ya4VrbF95nmCbwWSsZUlriIpnl8ZleneLllBsfnTLknplSmKPlpBk1YhhbF91eIOoUKyrkq8vSlaFt2eGuGiedWdqUal8aa+Ih3I9Z363mo7RgVZOQpGWcpFTzq1uTVCNkYSYXKKsUXdqhbB2dlqSuYl/QE+IlqVjbc2fZTs3uK+fWjCo4a1WS1h6hY5L0ah2WjiNw2eRSpKkh3lKameByHiV1GpEPGTImnxbR8CeslFDoGifgGrOgEpYh62TdHEr27uIOTyejoWNPLi+iEskk6mjeEKEz4hfbKSOWoVJcsuJgEV1m5WUQ1vBsFVGYqiRpG9Qx7F7HUafoK1jPqS5eDmepWmCmE+ivVhkVZCPmIVQiLGSW02InICUTnfrlzcVdMaipENK1KlrLpfDeXVjUbvNQy5hr3y5jk5xjZ5aZ51A0Z1jgtppHi+Nra2qNneUr0NLqM+DbF+XwZISOMWigoREesmTXUuNpYWbXGWbz00nU5qgxndGaMqqT1GEksOEX1CriUdbi457vHxxb3Jgk5J6Za2uYYaqJEOOo3mogWGOoXBfcIuUtXdfoMcxJ4i1pWx7Vmuwq2FwbqiSgHlWtoswS3G9nqRROqnFnW07aIi6xE1unEVeaJ6Ji6pdkHR1hHpddq3EfVuJY1RomrJasVJtnJ6JcFZ6fLe7QrSJMV96tmGcmkSbeqlhaqCHgZBSlK5TYEaPm56tG2qup6uCbmFTeLago4QxSVKphuFrXH5tgYh4fGy+n3CKeDtcXLXDn3EvYoWpr4Z0YXZ8fdqvSi9nvoqDmyh+jpalbFeaqZJLfp9wOG+OsJC6IT2cupp4hodglUuK7HpJQGyVcLGYRph8iYdRd4KavGWPl2E+QpuivJ4UgquQbG+Fm4iEO5L8ijcqgLF600c5iLSGiXR4gaVWWK6icFotrKS+YC15rbZhhZCFal9ft+psNTNqq6OwRYKBlHd7bGuEsqt3k2wpRWvT060VNZXDj5V4YmiRYoa7wWApR7aYymcxeZiGd5iEbqJ8R5ehbEVqh7vNbxhheN+WlGReaJFtiLWoYUZAe6XVbVqFnWFjlYBsW6y9nI9OKUF83NybEWK8WGTan1QvgnjKyG5qJy7quaBJUpWhWH6PnF2HbIC4kF5DPZPo1EgEdr2dhql9TlOhYbSqb1hyRKiboFdxl4Jvr21kPna3xp1wT1hBnZWvkXGTgzpsq7dsVW922pBWbESSu5aONmWqj4J1r3RUgj2trYCOQ0ScrspYXlGUoXKdlkmka2yoiXBaY45+yW1tfl+UtW57QV+Kr7h1kHUqX3ulzYeSR2SNbJVyhKRxonpgciia342lY2RJYM2SgYtCpGF9n2SpbltwdM2CgWs0xaRJe26roXyBSZ11UIGJo7Rah1eBp59GU1iapcdccrdQTVNl3MGUXUuRbIlqeZ2SoJpJd1RSlM6/d2FGRsGug3ZYfpd5nGmCkFdXW7TxYWI5lbqFa1V6kJexfF5yT2yBt9JxVE5hx7B9NTF60reLV4+GTUhquth1blSNlHdkbIqUrZ14VEtbiYfQ2mlCNmTAtIBUX4C7m3Bkmn06M5f8uTlOfrd+aVSIh6OkfIJ1T1JciOTUblFOZJ+5Ui5fp/+FV22WYUhQlum5VlpUlaN7O4Ciu5p4b1tDUYmr6c9PIiq0yJ9ASnOrxZJncYhiNFDB9XhEW3zBjW82d4/dlm1kcWlSVZ3ewV1dWI2ekCpCidbFiG13YDlIktrRa3dNaI2IeFOgsb9oXG9yZF5ur+KkSCxN08l4G1uY1JJweY97OjmP2MdPXFuVn5xdO3uyy4d8YWlkRmO40qx0UFiUoWgYYLzhj4OPckEVX9X2mF5aO6GhdURsttKqTmluX3Racd/JejopkuO7KBCFzct4aYGHdTpTreCAOliOtJ5wLGipwY9wiHKGYi5u0LWNZ2KJp3ggJafywm10eHhSOmTW34dSQGSyk3Q4mNStXF6bZVOBV6DXnFopW77YgAdBxb6YfYR1X2RYhNy5Vw1bqdqjXhGTwJNqmot+a0k6us6iYU5wp6JeG0Po4ZSBX1ZXanaW3J1gQ1aNpY99Or3Kdmpuclxnm3bKoGBORIXbmFwViumYcXt2dWFpc6zIhDw7nLuBcFtYyqNkdZOPiFRHYbzGiWhPi6drUS2O9KuFfFdjZXF0oMqDa1trnWdukYPHenmDb2JRfK6KxnJUUEatyXlPUL66fHZubnBrfJatrE4re9qUUkV+ltNwXXyfkXY8coi3hoNlcaGaPkBazeKIdF1gjW12hLGaXl9wn5RTSKCt0XFuZGhuV4qxo69TdShqsLFkV4nJjnpscG91bIuqsWM8UKXShk5EhaeqXoCRpI1PKJDApWxkTqHPeg87lvKse3xqdGxPhrSwcENug8KVLFuHsNR5d05ubG+Oo6qRak8vk9qSNVXIwmJrbIOVcGSNq21HbJPCsG0iWqyigWiUn5h0SlSUkZOQXVe8r0UbdNjNaGiQmIhASZq0l2BQgKisWjuDuah+g4BkeltjpKmod2ozTrrAhEByx4JrfHKiljhwpKlSSnakzqRQKGK1m3CAsKCGLk+hmICAi0WbxHEtL6HllmiIkIZyO5KOmm5icZXIgyo3nuGcd3qGTYhTlZijjVhaSLC9bGRTsbtjXHiUx2c1n3STSneLtrJuSE17tIJ0jq2fih1vb6CSkHdQsppNR1XJvmp1o5KPN1yUlKddbXWfnVZRe7eob4CTe2Bicq6Jq3JIRXDEl35obaWaYmt+uKA6cYqIfT11tsWYXUNKkauDd6WJm2RnbWiKlIqCdppuTU+BzsBwh3R5alaUhoiaZ42RhFpFa6yyoXqDgVJqdaKlfJNgRnqLjnKUfXygiVqSi551SXiFj4FJm6+WfF5SYZSvgoiqcXtcaYR2moOEfIuRWEpLkdWxjalrRUl2pH6UhXuPfm9jX2+bqrWPhmIvdaColXlxSG2bpGp3e22cnm90vYJuTnqgbmxogb2dZXBpWHmnsHSagG6CXXtrhZKJfY2naEs9aNS+dJ6pbk46iIKRlJ2NdXBBeZRtlKujo4EtPo+4kYKHcG1RlZJ0iG57nYF3qK12RjqTr49Nepa0fk5wd2CTq5e0k0ZUW4SSjYd6h26ak3BOLpbqj4aYem5EaoaWlnena4V3SWl4c9KnpZ5IHlq+um+HV5SAaotucoh4iaF9noKPaFhxdoh4dKuXoUBsaG11wou0n3pVOGGXiJJ9lHqGhmhpWFjDvXi2iXRLU4aGfI+ugkWQd2plYpPSqsNhNCl8xI97qFWBX5qTW1Sbd6eUsH5wXk2Pnmhxbpien4FAfV1TosrTo0RcO2+QiYCUg450lG1bW2ig05SJh4ZRVXyqZWyXsmp8eUdndHvIt7iKVyo9qq9eoph1b2yrYkttgK+4lIdwe1hihnltko2fdJxpWnlGeLnX0XdKMUWNlXuYkI50foFUcmlvusmAjYlaUn2ng1OEjo55n2NKaF6k3K6edTg8bq6QfatyZXSfkEBUep3TrmdqY4Z8gWxaepyhlGyDaHhVT7zjoZpcQE54kXJ4p5yNcmdRZI2ImMt5dJ5qVXKojV5skJWCanhra3R9yaSPolw2W3SWlLqVVWmLhWVRX53HvXF0fHBocH10aZiLlolsdoZnN3Dt1ah9OC5nhpRwmJiKhXZlZVpto9GecoWDR2iYt2tTeY6ne1hubGuBuLSXmHI3Q3ullnKudnWOi1NeUX3Jy35ndI13d2GBXXuekZaBXnqBUW7Aw5+UazxWaIOBfbqWgmNfa4Veg6nFfXmcXE2OnppSgZKOdVtejnx2h7uhn41PLFSOxICSkmKFhH1VaWCYuLF1koZfWHyEfliBkayUcEeIZVqw1aKSclFEcHGGcKevhG97Y2BcbbXDqWCElUZ1k5RrSquviWpDUZGDiqG6lo9oOkuWkYBrvY97e3BXa3uNn5Z2h66VTViBg2tlfpyvoTlNnHKAtJ+ti3FNR3KBeH24o1d7j2BhXIDCu4Jdm4RRioOBaHankXt7OG6NepG0sKdsSR2EvYlbh7aQcHZcVYWSj5iHk3qabVWPkmtVYJanwncJbaiRrIunkHJ4N2GChXGHvZBtjVFLdn2qvo5tb7xdY4B+ZHuirWx9WkCIjn2pqLp1aE1Cm5BlbbvFdVF2UWGnlYV4nqCHkztepJJUVX2lq6k2KbmWh4af0WN5Ujl9j3d1mLJ5k4I0WnaEyZqPWKmuPVqQkFttq551jTlQm4Cona2YSXJOgqBxSIvcsEhnbUaFpI6chY9qpXxJfZ1oXWyWq6BwDoXVeYCFw5hjeDVbnHdkh8GwZH1KTZJ0lqyQeXjbaxZ2rHh2eq17g3IkhZaOqpSvbHdfNpGsU3G8yG9OgERjmIGopZd0cqdTU557WIF1qpOfTirAkG+Wq79ib14+jZJYY5Pnml9oLISRfaONiG2xwyNWo3JkgI63cYQ7U6mDoo2On26QQVanblivvZRicmgxmJSXl3iSfKKeMW6JaHh3gqmEjzaKwU6BlsOfUHo+aJtxbYekt2tyUVaib5afhH6D01MlpZxlbHanmnlrKJejhpp7uItcWDmnpVh4uZ+Ca3w3WJWsqHp4hYC6aVN7dnB0Y6Coo081yIZkmqK7Z2dqQYZ9YZCquYRcX0iaimqklYF+rqE6YI9vcH6ctGd0PmO8jnt2mtZyXCNfuotoqJaabHVYSJycjYF0kpGYk0t1hXRwYlqovpwvhKBggqSyoU91Sl+DiYOQmp9ucVJoo2t4spGFgY98XIOEY3KIrZRUYFefqnKGkrCQUlBCq6hqeqeah11iQIrKhm1wba6elmBWjYlpdFqOsI9hV6qOY4+guYBgYThugZiqnY57VmtXmo1boaWFl4uQRlOTfnmSj5JqX1WJtHBuqaynZUQ3fcaOWoq6imJgX2q7kmB5hoaqk3hTg5VtX2N1uZ99SnCtcnGkp6F0Xj1coHt9qaCHcWBIbLlserGOdIeyezF2imyTnItqaGdfr5tulpqGjmVIV6+yYly6pGdLamGwt2NdiYqVmoZhbZZ0a3l1fpWVXV+5hVqLt5+JaTo6mK53iaOFeXhSRJ6eZZ+0eHqghUdXk31+mJR6Ym9YhZ+BnKuDe3BVT5bFcUqdsn1ceGJgt45ihpWFj5J2Y4h6V3qWiYecWDyrr2B3o7eNbVBEfJZ6hqScgHZdQXqwcnuvhIapkVNLdImClJCAb3VPbraWdqCHiH5nR2vOmFN3p4lbeYtciqFXb6CfkYR6bXd+Z4WNcnCtfTx+xWtqmqinbFNJe6F9dZKWlnpuOGCtlV+qmJCDi3JgaId8gpuKa4BVQp/FgZSScoJ2XVGoqIBnfp2FdnRUcKuEXJGXoYt6bXlwW36rkWeBikZttJ9HmKGwe2RdVYGKgIuSo4JySUebqGR0oaeqcIRVbHeGe4KchmdrPpG9hW6shZB4aUp0tJh4WH2fkY5TXoiGcYOSnpuGeF57dXGKioV2hHFNmqpwcq6Yk02Cbml+fnmNrJ9dX0aKomp9n5WceYOEW4JwgH2Nn25TTmjXmmSPm4uPY2dHnrqCWGS1l2JqY5SKYHt6or2Ag1xYgYWYh3V7Z4llZaSEfZ+WpHRcelSHhHp9nat8S2FrrmlSqK2ikVGQbX55a4eJlIdQXGyTrl6TpZigXl1sX8aQVEuk0HlJaYCgX2GTcM2oandahXh0kouGZ3B7Z4WOcaWOkaVffGlrhG15layRUVB6mJ9RbbCKsGpkoHB9aXiOl4FYQIOioXBYrJ6yijZ0ap2sXVuBuJJQXZabgzx6jpPVcmRvcJd4eo6LYmt+eHiEeISwhr90OoB+g3VsiaKjaz1olZGFW5eqkpI9kKV0ZGuKnohpU16UlYBfjr6krENGgoquX1aRrp1eOYO6lFVEg6K+n0WPim5ucZGtb1dueZB8ZHaTqLW9L0uSgHlogpeci1BFl62OSUqtyqdhObiVZF2AlJBpZ1yNqHlNc6/NqW8pcZCkhV96iZGHSGDCrlhPUpHTrk1UxYheYoKik1hnXJapX0+UqcKuXyKXm29heJWjjWoxabS0bUVnvc6DOWu9fVd5lIqEckFXuqdVW5iwy5U6R4mOinmTi3d3YUG01W89aFy21XVLm51hXYWdo2NcXn63gitjvMXHihxiq3licYGen307Tbu5aT1inNTERDqerWVckX2Fkmc4lrRpS5OtqK14LICBm4ODgYVvdE982qQ1YWt5uLZQibV0QmmjrIhEWna2njY5q9SknWA1uIhdV4eQpI9NIqTrkSNCicPOnhtrpJhVcpyNi2Qzd8WQPHOxtpyTTkl9g7aDh31yXF1vw8JYMXt6qr6HNqWbX1CXspVYSmurqlIWhuTLgXpDerVqU2CilpdvM3nWoUUffMTUp1o6kYqASZiokH42SbitVkGlvq6QYk50gqKDdqF5b0lbrNKKK0uJkruuXGqrbURsya1hSFudt3sxO6jgsX5dZ56EYkmHqoR+RF/Tu2wXLr7kuWs6g5J5VnXSiGVbNZrHeDxjyMqYcThseqmiX5CVY244hNC4WClgrbiyVFWvk15Ek9GLS0pyu5FSQW/I1o1pT56PaFVlqJZ3fTiS0YpNIG3xx5Q1ZKtrUV7C2FhdOV3JpVZJgt21gkZSmnaVfHmugGRRNs3SgjEuhN7Jhh2Lrm5aZ6y4YVhXl7t9PD6H37+NUF+veVxdfadriHJfw6RUNz3F5Z1lNaeVRHKCw5FVY0Gnt3FRX6rdkGMwirFvhGyRsGhoG4H7rUcjXs7IlkpEy5BPZH7DfmJSY7iyZzZKqta3gDaBsFtoWpehe3c6ntOAPDB28cWDOl69VE6gpbVTY0J7x4tPV4XWt45SMJebdIlvu4trOi3T320iQbrbpGMwgdJsUWigtWVaT7G8ckBChcfCsUhNo5ZRX16qnZdGX76hXEFQsdSuYT6HrlVfjq2OYlxVq6VoU2+0uJSIRl6TjnR8lrdxSSqO4phKRnq6sJJNVa2qV2CGpYBURZzdkUc8XLC8xHkxg6x7RWSUp3tXWra3eUNDgNOxiElXmqJodZKBcW1njpx2aWuNuK6SVDuEk5Z3i5aSXTtpwKVcVX6csYdwVZCpdlqBnHphU5TGj1tSV46+rZpWYKeITkiPq5teT5K4m140VLHgiWlOj5Nvap6Da3RuiJ53aG56kr2sgj1TiYebkY59e1RYj7CSYFpwrax4cWujg2l8knhRVI3gq1ROU2+uupB4Y5uQUV+EiIF3Z4a1nYBHPXPVsmlffKxtaJOHY2t4hp+EaHJsiL2xbmJTg36Br417dGJnfJGUlXBRfK2HfoKGiFyPm3JVT4e0xnBUYWCQt5aEbYWcUEmelnlqYX6sroJpLmGsx4Jveot1VJarbWJoiJqSZWpqbMLPiVhRW5J+m6lvfHJocIqpg3ZOcJ6ihHqHj2VuqHhUSobCrY1OaGWAqoiYgHWXdlJ7j2x3bX6irot2QjGxrpRwh5p8S2yykWFhb6CXfFx0cLKyhn5eWm2TkaCPbHdoanKxq3VLVpuWpXZqkIFxlZBuT0KW2J1tXXBrr3GPpWd7e2iJjX1VbHaesJd2aCV3yJebbW6Fameat3BQa4qigmBddq7OdYVyUWJyo6CHlGNrbICVpXViUpOQnJ1fco9xj4OKbk1atM1wY3ptj4BlyoVdindwcYeBUnuNrKiGbkA3mrCqqGtuZ1qEtKxDU4+jimdffpCvgYClZ09iccWTin1Ga4SjsoNVUHCkia12WJF8d5WXlic5j9W6Wm19e4hTochKcY+Fd2mLVVujmqSTgWMsYqm8rm1oeV9ym8B4KIWsh2RVh6+WhV2kmlhaVpDJlI5AVaWIkppoWmWeh5GqUneBa4aivGkAdKK+pGSBaXhyZ96IYYNpeHeGgjmLr5Ogg3E7M52t149QbV9xlK+bN1DFkHFrbI2DnHd5wW5bUXGptpNbJ6iyeaBvVWOJo2eohmOCaYWsnokaObaftJJueVaKTp/EbZJ7YHZwiGJSvIuTrXFbLXeqh8t2aXFheaqnbCict1yBg4N2eZhkr6tVTlybtpCORV+8Z46vVmpioIV6qWxpbmu2vohOCIq3mqx9cWF0dFrcqGJ0bXWLb3hLkMJrqZNTQkvBl4GvcGl3bYuchFRhxIVxk1B0dZ+HgryCSFd4sY1ph2mrk0OtiV9vcJV5npVabHySsoliO1bAlZ6Pb3ldd0qP+45bbGKFg25farydcrBaW1WCoHuJqnZ0boCSi2Fbkqh5q2pEcnyghqehUU98mKhrdIJ7oGxut2dkdo+HfpZqS5Cgto9dPVShwIWIX5x6V2lxw7tPdX6BiWlVZ6ivdYqDUXppl4tyhpiLcmeShIBKh8KUanZQdnyIkZ2xejlnjaF+a4Sbkm9cmqFiYW6amIl7VH2Ui6t1VUeIvaN4Z2mqX0OGsch3RYV9l3dSSZPPgnSVcGVVabCQeISDoGh5im1jV8nOcV5UYYV7i6GimF1FfaSrYlRuwaBNhJqAY2h3pJR2XXGojpCJT1p3vp9wdWmIk2Fkm5ahXW+QkolaSXG4q1CLkodfS3yyhYJ5e5N1knRScq3bZ1JrXYaFdpStn3xHSYnEp05ShsCDV553a2+Fg5+Ge1t2hp+cd0l6krVtgmlyfXGLmI6PaFqKpZdkQmulrmxxpGptXHGfpYVubH2PonFNXbXikS9qXHuUfHuYsZpPRWnNtVpBiZuWdH2Pd2x1g4iImmxtd4ikgmN2kYJ8gY9jjYFlkISNjlV5k7J9TlCamHFqsZ1dW1OKsZ2AUnR2qalJXqK/i1xceWmGgXmXoLBrME2t6oM2Y6B8epx9dXeBbIaUo4M+coKhoWxrn3xhi4Zwb557a5uAhmtpjZqaYleEoHJ6jo9saWhosJ2Scld4cKmGQajYgVRpYoF6g1ySra2QPkqEvKxQYKSJUoilfGuGZVugrbtVO3eDr49kl5JIgpVvhaCAPICbnIBgfIqcg1J2knV8rIRpXX1anLd6g2R0dXGpfnHAkk54cXWCg2RntqCgVkOJo7luRZipXV6Hk4CEikqSopaFRXCBlqFsk6RRU5hsebi4O0mIja1rcIB9om9nkINxjYR1bHtua8CQfHdpeFp9np61lk9bgHqBfHJRpbaSjkdbe62tVYGvalZ8fY2GhFp2wZuIUlN8h699d61tSYKQeJqoZDaKhpuaYYN3i49cfYqEkoppZXZ3a6iocX5veWttm36rt2BedXt6hnZadL6NjnpgbYase2O3hVBkgIGLk3J1l46LelZ8eI+eeKiGPmKKkKCrcjhekpKeeGmCiJBudKJ2cYCHbnl0YY69hXtpZG1znJ97w3hNdIl3eH1qaJiono5NUnyso2yWnV1hbIBqh5qInYd1e196j3qIh56iREuPrYKPgltVhpWXdX56g4V0XLGhcWh4cneJbmSiqYlyXHiAdYaNoa9fYYOJbH5tZHWVpLt+R0+CqpWPpFdbfYlrZZeifId9g3h8gHp2ipytVCp726dxdFJafJqXe3aRfW58fJeaXHWUhmh8Z2SQtY18ZWKGjXSIlpp4eHmRb3B2ZWuTq6eLW0p1nZ6SsXBFdYR5U3eusIR1b3eBkHZoeaG+eiFnsrmAd11Re42dj251lnRUgbK1Xlp8ioZ7cUtzvqR8eHB1dGh9q6x0bYh4j3JuXlx+rsCfa0RLlaeXrohHbnx8fWF8jrGPd3d4gIhtbobGlSlBu8KVb15Jb5aJln55fYVsbKKyblOCgYiGdW1Nnbl6aoCWel1dksqNXXmHdpxxXFGLnpSgi2lFZa+Qsq1VTnZfhI98goSsgnl6fHhyenauxl4sY7mtmGNYUoqIjpd5e2RthpvHhztdkoWcbmRgdb2abIGKclxods2uYV2Gh42PTkpuw5aJknhWTZiojr2ERmJ3eKFXaouhr4hucH5wcnyHwotSS5etoW5YZW2IdKCYdHRjhIidtGdEfZCQklVoYpyoenufi1VQYKzge09eiqGjVlBtj5x7mpdxTWGrnqKkYkFpe7WHPnKOnrSUYGl7b3R6tMlqKVi3t5VJZWyEdH6nhGF1dpibnoZOYZCRk19jbnWyon1uhXtYVobasFVVdYq2bTqCl4l6e5+NaFJ7o5+2hUhgfYWSVGyHnpavhGF0fFRfm+O3QiOHuqtpV2xxgHiTnHV8elWOsKltW2+DnXxgdFWEvKuAcnZkRW7HyXVKd4GUpVRfe35+i5ilbFNhnKCknk5VkZKQVVR7l6OWm3xte2U+ktq/YShjubx5UGtyenp9iYh+oWRXl7KNZXhsg5ZpclxuwK1veoB0Xk2iyZ9WaIN4k4Nye3JteZGxlU1RgbWYl31eg3WFcVt1jZeVk5eGa2RCW9fhiDVAkMadVlxqe4R+eJuIfntPh6iqdW18b45+aVtPq+CIanlna1Z7wKp5YYVxk45wZW54g4ejpGlIbKKueIV2k4ZuclBsip+Kio+oflZTUaDhqVw3b7e3aVxpanx8b4mxhn5XYJikqmxuZ32TfmNVdcGjeIl0ZFtetbWFZ3R1eKuHclthfI+csXlDXZe3hnmUfHtpem5ufYGRj5KcnVJAW5fUvHQ7SqXIfVFscm55gpKXeGyCapeIlJV0cHCDeG1dcKy7eoJ+a2NOg8WdfmN3iZ12Xntpd42QpJ9SRn2xlGeeo35iYnJtiXx4jpifmnlQU2etyaFlOHG+rldcd21lbqC5hVpjdo+ge5SBeXh+bneDUm2yrYuJb15TZLG4hGhTi7meRV90bY6am5N3S1+asod5lIF6aHdseoVxhJuflHJnY26IvqGCUFObuXtVfmxkdJGlh2tldpCgfnmYfnh0cVqciFODqpeOh2tHUZbOj3JfgJugX1GAeXiQop91Z0hwqLKQkIJpXWyQfIdbdKGlk4R6a0NyvcOCcUFxr6pacHJPbKC2imJhYZOxjl+CnIVfeoGDhEdrrKeahnpRR4O8nGlqfaufdT5sfIp+k6SJaVxLsMSEZZOEbFuLfIl4U5ChkoaGhl5LmMOeeGBKjbWHXIFianiYnnVxZ3KvoWxnjphvVJOOj1tKiaukmntgPW+xrXR7cn6Xl19YeHqRhKKYZ11NgOGqXnCSdWB1k26JaHeWk5yUbldch7y2d2JVcqOiXml7cH6Cm4JoeHCaoHVojYuKZXmVcnFQeqSnmIhwTk2ar4pxjXqIh4JSenF9j46wg1FRcMG3bmeUiWpciol3e2SIipisjVVHg6e2nl9GZKGtfVCEeGpvlqJxanWIqnxoeo5whnyhfmhLX6Cuo4JtaVp6nJ+NbHCFlYhuXn5kkZaclltGa8G+dWGAk3xhaJiCg2Vuj5qlimtRbrCaoIhLSJanj1tvlW5jeaOObHR+n4drfIR3gJGBhHZpRI2wopRxZGNwiZCuiFVwmI9+aHJoZaOwk2xYW4/FiWt9h4F1Z4WHfnRdhZ+nlnBeYJi0hZBkQoGylGpkhXFje5eddXR4l5FhcYh3hJeQeWh2XWelpY+EcWpofYqbomJalJ2FZ3B2YXevq3BlcXeknGp9kH15aHaViHddaZ6gkoZxaYCdmIKJRGChpH1rg3VWbJSkiXR2eZ9+YX2FepOAkHdtb19+qJ+Ie2thcpCXm4NQe56fcl5tb3eRsJNjcW2InoV0lYFxcm6PjXdlY4eslYN7dISPhH2Ge1CPl5ZycHRhX4qrlnR+fIGHbGmPho1+dZR6bGVtg6CkjnZbbH6RiJV0Z5CXkGVna3CBmKSQb215kIJ+i5tkanGTmnllamSIsZ6CeIGLeXR8h2t0l5GQcG1iWHWprHptgo17eGmDj32DeISOgGNqeIebooRqaHx9jX6GeomOk21fdXx1iJeVh2l3kn13hp2EYmR6oIlycmxfk7aagISKbmN1lYNpip2FbXh1Xl6Nr513dIR6ZYGDlnt6doB9kYdYYoKXopx0b3FlfZd+eY6QjYlaZ3h6fZyTiYRohYV1gJqPaG9ukZKCdmNddqu3k36Oe1ZigJFwkJ+XZ2GDaV96nZqJfoiFWG2Yi3d1g32NdpV4UWuPl6CVd35dX4mVboOrhIF3Z3ZueZObd4iOd4V0eYqgbmhvgZiQiGNRYY6+uoqAe1dle4N5fbCRgVF8gGJpipyPiICLaFqRnndogIWNhHKSYF+FlJGhi3ppUnyWiV6WsXt2bXRyb42dg22TkIJ1dXqLkHF4bI6Sj21PX4ClxqeDfFZReoKDe5+ofWRckHRpb42Om4+FdVpympFucYGGk3WCfVVtkpedoIFsTWiTmnJhpaJ8d3ZwbXqQjnaAopJpboKBjXp2cX6djoJQVHSYtcGNfWdSbHx8hImgl3ZYeYZvcnqCj5+LfGNrgpeCa318k4RrhHpndJOapYt4WleBmI5kcJ+efXB+bHx+hXt9lKuBVniBkYlsb3edkIJoS2mQp72yeGxNYn2FhYKHjaBrZYNwcXd+h5yUiGpjd4qYdGx+iJ5xbXB4ao6gpJB6ZVN5kJd0XXyoq2p1fW2DfXt4kKKpX2F5hJR6bHqPm3twU2CFo6y1k3hcSnaFjXqDgo2iYnd6b3d4dpCam4daaHuSlm5yeY2QdXJreHebnpiEfE1kjZyNYWCBoqtsiG9vg3VyiZ2thUhyiZODbm6AmpFyXFWEnayll4VuSGKJkYJyhHWVpWhyaXeGdXeQnZpqXHiFj4lwfHmOgHRsd4SImJWIiWdQgJaRdGR2gZupboZrh31gdJW1pV1TgJCKfXRxgpyBaFZxoJunlpaCUk56k495dXd3o51qb2WFfG+Cm6l7YGmFiIV6cnuKl3lqX4OTiZiOjXdUbJebeGNsfYWrnGtwdJpvaXylpXhqdYSDfnhwep2WY1pin6iXlIWIZVtwjpKAbnB2h6OKbXJ6hWl5gqiVcGxyhoF8eHZ+lodsanGWh4uOkYheX4Ocj29qcnqHnpJ5dYiEanmCqIJ1eoCGhHxtaoecgmhlgaCTlYaBcmB3gpSKdm12fImPinh5gHSDh4CRdnx+goZ5eXaEiodxcXSOkIiKhYdxZX6LkX1vd4CDgX2HiIuNdX53fIZ6iYGChn1ybXiSind0e46Ii459e213gYCKgXZ4fH6BgpGCem97koJ9enaHhYqBcnB8io56dnZ6ioiOi4V3ZXGJk41wa36ChYB3iYqNgISFbXV2hZOGiYBpbXeLlHtwdIWPkZJ7dXR0g4aEgHJ3hoF6dYaUg3R2ioV0fnuHiYZ9bm6IiIqBcHZ1g4+PiYZ9b2x9io99a32JeYB3fpCSg4CGdnV4dY2QhYhxaHZ+kYl5dHaFj5aJdXVweoWJgnhugYN9e4OLh3hxhI14eHqAkI6GbV95koiOfXRsdIiakIV9cGh8kY58bXSLgXuAeH6Pk4aFeG15dICaj4B5aXF8ho5+dHSFkI+LfXFxeYWIgXp1e4V3e4CKh4R6eYV+doF7iY6GeWxsiIiIh31xbXuRmI+Cd2RsjZOCdnaDgnV9g4J9jYuHhnhydHCNl4d7dW12gZCIeWx4ipKQi3dqboOPhXh4dYB9gYGEhoCAfIKEdniBhpGHd29ue4qNiH14a3iJlpKEd29ugpCHd3WBiHp2eomFhYmFg313d3iCjYd8e3l2eYWGgnhygo2Ph4F1bnqJind6enp6foOCiYV+eHyEgHp8g4mKe3Z2dX2KkH19dm6AlJaKemxvfYiKgHh5goGAeH2Jg4SGioB4eHeBiIh9enp7e4SGfXl1eYqTin55b3uHinlweYCBfoN+hYiBfHZ9goGAhoiCeHV6fICEjYN3fnl4h4+KhHlxgHx8gYJ8hH59fHmGj4N+gIN6foCBgIB+fYB7fXuBg4F+dnmKjYWAeXmDgoB3d3uCfIKDgo2EeHZ1g4aCgYeEgHh5eIGChoh8d4B4gI+NgXx3fIB5fIR9gIZ+hHp5h4+DgHt8eIKGg319eoGAgoB7e31+fniFj4Z9eYCDfHp4enuIhnt8eoOOgXh1eoiGhIN7fX19e4KKgH17eoCBeoaKiH57fHx6e36AfYmCgYF8foWEgX58foCFgnl8fIGBg4V+e357ent9i4qGenmDfYF8dHiDjYF8fYCDhH16eYOFgYWAfoB5en2NiYB7d3qBgYSFg4R8fYB7fnt6e4iJgX16foOHhIB9fX2DhH17e3qDg4mAd3uAeYCBhISFhHqCgHyBeHaCiIJ7fYGEg4F8doCJgYKCfIJ5eYGHiIF9fHl+foGFh4mAd359e358eoKKhIJ8e36Fg4OAhX18hH57fnh9hIaIfXd7enqAh4aEhHqBhHt+enV7ioaBgHt+hIGAenmHgYCKgXx5dH2Ii4WBeXh6gn2FhIiFeICBe3h7e36KiIN7eYGGgnx+g4d4g4Z4fHp7goaHg3t3e319fomEhnx7hnt6fn14gYl+gXx+hYN6fX2DhHmHh356dXuCioeDfXh5e32BjoiGd3yEe3t5fHqFi4d+dXuGhHt+hIh9eYqAeXl2fISQh4B0dnuAe4aLg354h4N3eX2AfIiHfHp7hIeBeH1+hX2DioF7dHiCiIuCfXt8fHx4hY6KfXeIfXZ5fYCAiIiBeXyEhXd6hIeFeYSHeXh3fH6HjYN6dnt+enyOi4N3fYZ6eX2BfICIhHh6g4aFeX2AgH1+ioZ9eXV8g4qJgHl8en18foqKg3eFhnd3en2ChYuFdniCh4F1gYSFfYGKfnd0eYGIi4Z5dnt+fnuFi4d9e4V8dXyDgX6Hhnpyg4WJgHV+gYKBhoZ9e3h6g4eHg3l+fnh9fIWIiX2Ahnl2enyAhIaJgHh+goN5eIOFhX6HhHp2dXqEjYiBd316e3yCiYiCeoGDeHp9gn2Dh4J1eoSEiHt4fn6BhoeAfnp2fYiIhX14gXt8goGCg4WAh4F1eXp9hIeFhHp8gIKBenqChIaEiHt3dHqBioaBeXuAe31+hIaEgH2Be3iAfoKBhYJ7dYKFhoJ5e4KAg4WCfIB4eoOIhYJ6fH16foWCfoKFhIR5eXx6fISIh4F6e32Bgn19gYKGhoN6dnJ+h4iCfnp+fH2AhIOCfYKDgHl7fn6BhISAd3mEh4R+eXuBgoaEgHx8eH6Hh4N6eoF+fYGEfXyCioV7eH19e36Fh4R9fHyAfoF9foOGhoB8e3h5hYV+fnx+gYB9goWAfX2FgX19fYB+gIGCfXl+hYR+gX18gYSCgIB9fHyChYSAeXx+gYCEg3t6hIt+e3x9fHuBiIiAenx8foGDfX2EhoN9fXl6gYd9e319gYKBgYWAeHqBhoGBfXx+fYCBgHx9hIaAfIF+foKCfoOCe3x+gYKCfX2AfoGBhIF7fYWDe4GBfXx7gIiHfXp8fICEg3t+goGAg4F5eoKAe32BgIGBgYaGenV4gYWHhHx8fXuBg4F7fISFgoGAe36BfoKHgHh6foGEgH19goKBg4N8eoCDgICCfn2Ae4KHg3p6foCDg3x8hIOAgYN+eX6BfHx8g4KDgYGFgXh6fIGGhoB6fX57goSCe32EgYKBfH6Bfn2DhX56fnyAgoGBfoOBgIR+enyBgIKCgH19fHyGh4F6e36BhYF6foKBgoSBenmCfn59gIGAhIKEg3p4e36EhoN8en5+fYSDfXmDhoKCe3uAgH2DhIF7fH59goCBgYGEfoGCenyAgoKBfX6AgHuAhoSAenyAg4R9fIGAgIKEgHl9gX19fYKBgoKAhYF7enqAhYWBfXx9e4GGg3t7g4SFgnp9fn6AhYN+ent8gISCgH6CgoCDfnp8gYSCfn1+fX58g4WCfHp+goaBeXyBhIODgHt6foB+fYCCg4SAgoN7fHt+goWCfn19fnyBhIF8gYODg3x7fYGBgoSAfnt7fH6Dg4CAgoCDgXt7fYOCgH6Cfnx8fYSFgHt8foSGfXl8goSEg3x6fH6BfYCCgIGAgYeBeXp7goOEgX18fH6AgoJ9fYKEhIB8e3yCgoSCe3t8gIB+g4B+goKChHt4fIGFgX1+gX58fYCGhHx9foGEgXp9gYSCg356fn6BfnuCg4GBgIKEfnp7gIOCgX1+gH19gIWCfoCBgoJ+fX1+goKEgXp8fH6AgYN+gIKBgoJ6e32ChYF+foB8e4CEh4F7fYCDg3x5fYOFg4J7e359gn5+goGAgoGCgnt6fYOEgn17gIB+foGCfoGBgoKBfHx+gYODgnx8fn2AfoGBgYODgYB9en1+g4OAfoCBe3yAhIV9fYCBg4F7e4CDhIF+e4CAfYB+goGBgIGBg4B7fICEg4B7fYB+gYKDgX1+gIKCgHt9foGEg4B7fX1+gYCBgIKDg4F+ent+goWBfnyAfnt+g4WBfICCgoF8eX6DhYJ+e3yAfn6AgIGBg4GAgIB8fYCDg4F8eoCAgICCgoF+foGCgX58gICBgIJ+fn18foGBgYGDgoF9fH1+gIKCgoB9gHx8foWEgH1+goOAe3uAg4SBfnx+fn2AgoKBgYGAgIB+fYCAgoKAfHyAgIKCgoB+foGDgoB8fYCCgYCBfX59fYCBgYCCg4J+e3yAgoGBgIB+foB9fYCDgYCAgYOAfXt+goOCfn1+gX19foKCgoKAfn1+gYGAfoGAgH2AgICAgYKAfoCBgoB+fYB+gYGBgIB9fH2Bg4KAgYKBfX1+gYCAgIF+foB+fYCCgoCAgYOCfXx8gIKDgH19gH5+gIGBgYGCgH58gIKBfoCAfn2AgYGAgIGAgIGBgYF9fYCBgICAfoGCfXx+gYKBgYKAfHyBgoJ+fn5+gIKAfX2AgYGBgYCCgH5+foCCgH5+gYB9foGCgYKCgH58foKDgH1+gICAgH6AgIGBgICBgYF+fX6AgICAfn6CgHx+gIGCgYGBfnt+goKAfn5+foGCfn1+gH6Ag4KBgX59fn6BgX59gIJ+fYCAgIGDgoB8fICCgn59fn6Ag4F+fn6AgICCgYGAfn6BgYB+fn6Cgn19gICBgoGBfnw=", + "expressionsKungFu": "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", + "expressionsLaughing1": "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", + "expressionsLaughing2": "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", + "expressionsMagicWand": "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", + "expressionsOuch": "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", + "expressionsShouting": "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", + "expressionsSmack": "UklGRsgDAABXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YaQDAAB8fHx8fHx0fHaCfJVwgLV4EvyCaPAZM//SIz34ly3ilznQxCdasQ6rj2CZuVRPwWxBp5tiXJuEZIt4cpGAfnp0eotqdKF0ao1ybo2NcHSEbo2NZHKhcHR0hnh0lY85tdw1I9atIXC3alaKj25wq5Ezeqt6XK9qVp1udJmPi2hcdIqndHJ4lX5Uj35ykYpqhItWj69aUaWdbmSGj5F4OYu9XIafP5m3GHqxioqbgBKdzDNL0JV+gHoleKenEHSrQVbFci25q1SET6+PP3Knp1R6k2JoqY9DqXJek4ZH0pU5T/RNO7WVhlGPnzubmV6Ghk3Bcj+vtU9Dt4p6coZDiqmMj3hPdIR6eKGTZGp+hLViBrPcXnCMXnK9eCWE1GBeqY9caJloXqmPXL+ZMVN0fuSGP2LSch+bn3CpZDG74iVcpUehtS+V2h9BzKlWXH6hhGpulYpkj4hNp4BPmb9WUY96eqd4aoxqmUFy3HJqUYyMfo+AYopwp3gzu4A1tZGGYptqP7WMVauAVZWhP4CrVXS1aHCVZGKvfnCZcEGheGjBqR9yxTdwkZmbgGpobHiMmXSGfn6AVoy5VWK9VjvmkzmVcIaPMamlZniAWrdsVqGhTWSPlZVwU4+pXD+/r1xaZnSpv094hk+AoXSEk3RBm6lcVZmbk1x6cJVqU7evP5WZL3DcYGSlbFyVkz+EyXh0lyNV6pc3k4+EcFqpm1pYdJu3ak2MioaEdF6GrVx0hnSnbE2jjFObkFiXk0uEnWh0m35cm5tPcIp4mZVodHCQhl6AmXiQfliEin5sgK2ETX6Kfmp+o3B6fmyQbGyrbE21cFGjl2SCimRqm5NwjnJkk4JVobNFbKFsbJ2KglhwnXZqq4pBip9gXLOIVZeIVZ+ObGZ8nWpmqZtgUY6RdoSdZmZsnYRRpYJmm3JYqY5LipNTjsNRWLNwYJF4hJ9qXHKKkop4aplqYIKZkHhwfHhyfJ1mcJ12cHyCdoSfdj2StWpyeIqSZlmXoXKCdlmXoU+IsWZRgp+CdnKCl3hmfJmOUWLFiFqOfG52jpJmbpKCboiSbniIdnKZiGJymXxyeJJ4WZKSYnaZfGCImWB4kmZ2pYpFiKluV6lwXJ+OYIKIdnCCkmp4fHaVjkd4uWZgm3xqkGh4p3hPiqdoXJKhgmp4cGiQm3x4gnhoiHx2koh8dmCKimZ8qYpcaIiKeIKCcHyIeIKIaHCKm3Bol3hccK98XIqCeIB8fw==", + "expressionsSneezing": "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", + "expressionsSnoring": "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", + "expressionsUhOh": "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", + "informationActivate": "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", + "informationAnalyze": "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", + "informationBackwards": "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", + "informationColor": "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", + "informationDetected": "UklGRusXAABXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YccXAACAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBgIF/gXyDeJV8WMRSlHV5i3WCj2SLkmiddnySZIaCbJJ/epBxinyBg4B8h3aIeoCDfoGDfYN/gICAf4CAf3+BfIZ8goCCfoN+gn+DeoNze32SX6GAepZ1lXt8jXp0h3J6e3R+eIODf4qKgYqGiICDhneDdIV0fIJ2dXlmkZo52XNqxFq3YpOPa26ZVnCFXopZm218mJB6o4+MioyLa4h2a3R4bnh4gXF4e3+Ao2iumW+9aqF0hXxwaXlkYIFdhHGMhYmTk46BrYl4rnd1iWxlaW1raYOFeJKBenWOhImKj69XxHKDjXd/ZIFgc1iJVoCAf4qOm4uVlo54rXR/k3Jte2dlbHJ3dZKEhYt9Z5t7hI+JqWO0fYKGhnNrgl1zX4BcfIJ9h5OXhp6Ni5aReZKAbYBtZG5va3iAhoOLhnN5mXSQhZ+IeLlgmH+EaYBxYXNnd16Oc4SLkYyKo4SUmH6PgH91dXFqbXJvd4R9i4eCdn+TfIGYlnOijnKWf3xxg2dscXBpdYNwioaOgqCJiatuoICAgHd4bHNtbm2Bb4uFhoV5e5p7dbF2hKJ6hYmDdnp8bmt4b2iBdHuEiIWMmoWXkYmKi394hm9zd2xqeXF7hYWIh4BynIlWxm13sWmSepJsgXx1aIBzYotsf3yKgoaYioGnd5CMfIGBeHB8aHJwe3GLgoWLgG6ak0fQanC6Xptzl22AgXdmhXRhkGaDdo93lYeLlImMioh/hXp8cntqdHN4d4eChYh6dp6BVdlFnZltl3GdYI92fGKUXnl/cX16jX2PjI6HmICMhIB9gXV0d3Bye3t4jX6Dg3iEqT7Fd2e4X51tmHCBe4VhiXNpiG1/fI16lIeKiJJ8jIN+fIF1eXl3dnp/e4WBhnqAi49btWl9omeQgICAgnWIan96cIN7f4SFh4WEioCGhX+Cgnt9gHiBeH98foJ7hIGCgIKEgX+EgYGBhH6CgX9+fX59fH99f4F/goCDgoKDgYKBgIJ/gH+Afn9/fIB9f3+Af4KCgoGCgn+CgH+AgH9/gX9+gX5/gX+BgYCBf4GAf4GAgIGCf4GAf4F/gH5/f36Af4CBgYKBgoKAgIJ/f4B+foCAfYGAf4CCgYGCgYCAgH+Af4CAgYGAgoCAgIB/f39+f39/gYCCgYGCgYCBf4B+f4B+gX6AgYCAgYGAgYF/f4B+gH+AgIGBgYKBgYGAgH9/f35/f39/gIGBgIKAgYCBgH+Af4F/gICAgICAgICAgH+Afn9/gICBgYGCgoGBgYCAgH9+f35/f3+AgICBgYGBgIGAgH+BgICAgYCAgH9/f4B/f39+f3+AgYGCgYOBgYGAgICAfn9/fn9/f4CAgYGBgYGBgYCBgIGAgICAgH+Af4B/gH5/fn+Af4GAgoCDgIKBgYCAgX9/gH9+gH6AgICAgYGBgIGBf4GAgIGAgIGAgICAf3+Af39/gH+AgIGBgoGBgYCBgIB/gH9/f3+Af4CBf4GAgIGAgYCAgICAgYCAgYCBgICAf4B/foB/f4GAgIKAgYGBgYCAgICAf3+Af4B/gYCAgICAgICAgICAgIGAgYGAgICAf4B/gH9/gICAgYCAgYCBgIGAgICAgIB/f4B/gICAgICAgIGAgICAgICAgICAgICAgICAgICAgICAf4CAgICBgIGAgICAgYCAgICAgH+AgICAgIGAgYCAgIB/gICAgIGAgICAfoB9gX6bfHVnfZ54kn12dnuBfoGFh3qEgIl9gYGBfH5/f32AfoR9gIN+gn+CgoCAgIF9gn6Cf4F9g3x/fYOAgoCCfn9+inuIdIp5hHuDgHyAgH5/fYOEgYKBgX1/foF/f4GEeYl3iHuDf4N5g35/g3mIgH+Bf4V6iHeMc4SCfn19inSMdY91hH6Efn6FeYtvkXKPco9slWyJf3yCg4B6i3KPcIl+hXqGhHSMeHiOb5Nri3uKeIeDe4VxkHSDhX5/hXmCiHmFf3iKenmDg4CAgYGBeYKAh32DhYRyineCgH15i3d6ioCAgoV3jW2Qd4V9hn98hnmKcol0inqDeIp8gYR+goF/hoB3gYJ2gX2Lfn+ChHyAgIKBeIR+g3+Jeoh0hH2AgIV9gHyEgXyBhH2HfYSAf3SFeoCCgIGKfH9/hoGAgoV6doB+gX19hIR9iYOEeniFgnF+hoaCfYl4Z0aRqIKRsKyTdmB/Xktvfnl2gZmbf4WZi3x9gnd3b4CFgYWMbVUylslwnta+jn5NfVAhUXxag6Gp2KCAoHxNbG53hXmDlHB7iomPfmJOJba+cMfXso5jOXk/KF18b5GQxd2gh5BvT1Nff4qDkZ17e4WLhnRVMkDaqoLc2p9/PDlvPDJ4kYCPk8jRln6HbEpOX4KPiJaihHiKh4BmPhaB9I+m3cuSWB1IbzVPiqCfoI+qwZZfcW9dX2iBnpGGlomBhXtwXik35c2FvsmcbzUfdWpIa6Kst55+nJNvZXFrfHZwi5eEho2HjoBuXUEmu+uIs7yfck8ZWYJbZZK6vaR5hIJwW2eFjoN2hY2DeIOPk4R1Y04lhf+XnLWheF4uO4p2Y4G5uqCDd31wWlqFm5aDgol+bXCKlomBf3JVMV30v4WhnopiQzB4jm93prqliWdxeGpcd5ugkoN9e3NqeJOZiYB8bVUxYfPEiJ2eiGFDL3GRdHqouaiFY210aGR6mKeYfXl5b2l0kaCTgHpzWzpBz+mMlaOUZEc0Wo1/eJq8soxna3VpXG+YqJqCfH1uZXKOnpF/gIJsSTF//LJ2oKuCSjxIgoxqfbbEmG1peHNdWIqyoYN9hHZkZn+al4GFkH5aRTaU/5ZysrxuN05dgXZkhMW+eW+Jfl1ddZ6ehnuJhGRifZSSioiRiG1TRzuk+IGCx75bN2JhcGFlh7uzcoKnlVZXhYp3c4qUhGt1kIp4e5ibemJcR0XNzWqp2KQ5V29dW1t6jKqOg56zgWKDd2RnhYGIjIKHgnZzjZiFeXFbMnnijHXF2HE9d3JUSXWFh4d9mrmgco2JW1J9h3GGmZJ5b3SCiYWKjXtcQ3nHhm2y1HxDhYxTQYKQbmuFq5+EhpuCYHGLfWmHl35peYV6fYyTh398enFmj5J1f5uYcnyMgGh1h3JpepCCfI2UiHyGiHpufYF2eoWGgoSHhX96gH59e3x+gYGCh4GChYR9fHl1eoGFhomLhH57eXd4fYGAgoiGg4GAgX59fICBe3yBgoGCh4aDg4F8c3J3fYOJiouLg3x4dnh9gYKBhIqBeX6DgH1/gYSDe3uCg3yBhoOGhH97dnd8fIKMiYiJgXh3d3uCgYKGhX96e4KEgH6ChoR9eH6FfniDjIN9goN4c3uBf4OKiIaEfXt7d36Ff4CHgnp6f4OCgoOEg4B6dn2Df3uFjYV+g4F2d35/fYGEhoWCg4N+eX6AfICEf3d6hIaAgomHgH54eH9+eYCKh4SEg315e358foGAg4aFg4F9fICAf4CBfHZ8hYJ9ho2EgIJ7dXt+fICHiIWBf359f4B9f399gYWCf4GBgoOAgIF9dnaAhYGAiIyFfn19e35+fH+DgH6AgYSGhYKAfnp4fH58goiFhIeEfnp4d3yBgYKFh4SBgoB+f4B8eHx/fYCFhoWIh4J9enh2eX1/hYmIh4WCfHh5en2CgX+EiIN/g4J+fX56e35+f4KFhIaHhYF8eHh7e3uBiIeEhISBe3h7f4CAgYODgoCAgX98f4KAgH9/foB/gIWFgX5/f35+fYCDg4GAgYB/fXx/hIR/gYSBfXx+fn9/g4WDgH5+fX1/gYKDgoCBgn9+fn9/gX9+goJ/foCCg4F9gYJ/fH6BgoGAg4SAe31/fn2AhIODg4KAf318fn5/goKAgoJ+fYGDgX5/g4J+foCBgICAgH9/fn5/goODgoKDgX16e35/gYKEhYKAgH16e3+CgoKEhYJ+fYB/fX1/gH9/gYKBg4SCf39/fHx9f4GDhIODgX9+fXx9foCCg4ODg399fX+Afn6BgoGAgIGCgoB/fn5+fX6Ag4ODgYCBgH5+gIB/f4CCgoCBgoB8foGAfoCCgoKBgICBgX59foCAf4CCg4GAf4CBgH+Bg399fn9/gIGDg4F/f4B+fYCCgoGBgYGAfn19f4CAgIGCgoF/foCAf4CBgX9+foCBgYKDgYB/f319f4GCgoKCgH9/fn1/goF/gIKCgYB/f4CAf4CBgH5+f4GCgYGDgoB/f359foCBgIGDgYCAgH5/gX9/gICBgYGBgYGAf39/fn5/f4CDg4GCg4B/f359fX6AgYGCg4KBf3+Af35+f3+BfoB9h5F4iXZ9eHd+e4iWeYd+f3p6h35+foJ+f4CAiIB/g4F8fnuBgH2BhX+Ahn2Ee4N9gnqDf4CCf4ODe4R8hnqFfIR7gX9+hH+AhIR8hXiCeoV8hXuFg3uDeop7gX+Bd4N8g4J9goN/f4d5hnx+gX96i3eFgoCAgHmCf3qDg4OBhnuEeoJ3jHOKeoJ5iXWLfIKChH5+g3aLbo1zlG+Sdo90gYB8f3mKe4d6jXWJeYZ6gHyEeoODfoJ9gYOAfoZ4h3iBfIF+hoJ/iHiIdoB9gneFgICEf4mBg3+FfoJ4gXp8eX59goKAioKFeIp7g3qIg4N7eHdbpXJtooORiYx+oGCBg2twdnN1g2WTfoOPlI2ZhomMd3V8b3R2c4B3eoqGg4l+e2h2rmmDo4qTe4eGj1WHemhpb3R6fnCeiYiNl4uQfpCOcXt+cWtyb35zeoyJhpCQh4FrYGuvX3yzhp96koSXT4OBXWtneHF/aqCOiZefkoaGh4pjhXZwcXV2eXd1koCJkJSMin9yaUd0oGV+vpeNnImTiVh3gFJZcWV5eHmenomcqpCMgoaCYW59amV5fHx6fpKPg5CYj4Z+d2pLQpaKYqOuppyXj6JzVH9lT1Zka31zhq2alamolpB5e3lpT26BW3Z/iYeHi6KPfZaLgHl2Z145a5prkbGxraCPo4pXZW1OTFRheHd9o7KeqbGklIBxbF1bY11og3iKkZOal5GQjXeBeHVya2RiVGuYc7ycrr+Wn32PTm5KTltLanCOhqupr7Oln5F+ZmJVSX5WWpeIg5Wlj6mDipVtbXVwZ3lvd3tZeZF2l9F5trh4m21zUHQuYWtJgnyZmLmdt7GHmIthaGZJXFdlj3mMo6GbmpONjWl1dWZocXqAg3aAem6FgInXZqm7dpdciUp5Ml2BRoV8qJWxn6+yfYiFaGliS3JiV4egd6eek6WEgIZ8W3xva35yho6FeIV5b39wedxogNpwnV+HYHZFRKFAe32dmqGdorx5f45ubF1adWNfbKaRgKidnn+ChX5nY4Nzc3WEjYV+gIxtbnt6eaisYM6LfotifFlvOIVpX5CJn5yjmaqUeIh6YmVhXoZsU6yfdZ+bipR0b5FtW4l+c4N5iJJ2eJN0YYB2eZO/YbK2YqJgfFtuRGmCUI6IlaCgm6iff4SFYWFfVoZhWrWKi56QnIlzdpBlaYd1gHl5jIpyfI9tb3x/cKbBT8ydcZVbeVdwNXh+VZSPnKaimqSbcYB/VmxfYG9wcaOViquQlYF1e3Rra4N2eoOAjYV9g4VyaoR5dIS5nW7BgYh0WXNiW0eFeHOTk6unkpyeiGt2dWBlZG98dHmWroWUp4OFbGt4a2F7jHaFiouUg32MgGhse3pweqeyaauYg31bdWhnSXeGb4mRoKaTlZ2ScnR6ZWhhZ4CNXJCiiZ+GlZV1Z3p7X3h4got1h5aKf4mEenVmcXpxdpXBdZyyfo9jb2pkSlqFZ36RnK6fmqKdfW16Z2JcY3V5eYWZlZKjm4mFeXFrYWZ2eXmJj46Pj4+Jf3h0b2Frd3aDlcKInK9+iWBlYF5QWYJzhJier6SbnZd+a3BiYmJedn5/i5eZlZCUl31zdXFpYnF7goKKl4+Jh4uHeHNzdWhjfIGDiKi+eaeSfXlVZV9iUGyLfJSapbGblZOKb2FrXGNkaYKFiZC7lH6rfoJ8WHF0XGOJfYWZiaCYeomLdXN5ZnFxX32IgYqoyHOonHaBT2RjXk9njneRm6CympKajHRmcWFlZWWEg4CSnJeNjYaEgnFzeHBudXuBhoePk4iEhYB7d3p4d3FweXuBgoPShHu+d4RlY2pnWFCOeXadk6ujjpiXg2Z1cF1tYXaEfoWXmI6Km4lte4B6aGqBfHh3kJSFh4qOf3J7gX1uc3x6cnuDjX+ypm+1gXp4YGVnYlR5hnKYlqColpGWh25udF5rZ22AhICUnJGRkoKEeXZ4bG11d3h/iYySjI6NgXt5enh1cXd7cniGhYqEvZtzrXp+a1lnaV5ZgIh9nZWpqZGQln5raWxea2NyhoWImpuWkIl+j3FlhG9ndnR+g4CKnY6Ik4N+em51eW5vg3p3gYeMjXy9lW+ieXtpXmV0Zl2Fjn6ajaOejIeRgG9udGh1Z3WGg4OPlJCLh4KCcnOBdnZ4f4B+fYWMhoOMg4B8eX5+eXh+fXZ6eoWDgYi3goOefn1wYXFwXmeCgn6VjKSajI6VfXdwcmpwZnaCfoaPk5SOiYiBdG+CeWt4fX1/eoeSh4SPjYF7eH57cHZ9enp6eoWFhICjrm2ajH5zZl98YWNujnqMkJWnj4qSjHd0b3Jtb2eCgH6HkY6PhY+NdH17e35udIZ3eH+Fh4mCjJB+fIF8fHN6gHl5e39+e4F/uoF+pYeAdWZzelZpd4dslH+imoqOnYd8e3Z1cGdsg3B9hYuOjoeNjIB+h3t2eXJ6d3R9hYKGi4uLiX+CgHh3e3l3enZ6eX1zrJh4ppGOf3hljFhlZX9pgXuJoYyPm5uIi3p9eG5idXNue32Ii4mFkYiWfoWNe3V2cXJ2a4CBgoSOi5CJgoiBeXp9eXpzdHR5cZaXeKCNlYOKbZBsbmx4bHZ2dY+Eh4+VjZOHhoeBc3d2cndzdn9/fYGJjX+NhI+JfX+DeXV3cn58eoCHg4WCgoWFgIKEgYB+enx6eICDfoaDg4KBgIKCgIB/fn1+fX9/gYGCgYOBgX9+f39/f4CBgoKAgoKAf39+f39/gYGAgYF/gH9/f4B/gICAgYGBgoCAgIB/f39/gIB/gYOAgICBgH9+f4B/gIGBgYKAgYB/f4B9fn9/gICBgoKAgYOBgH9/gH9+gIGAgYGBgYB/f39/f3+AgICAgYGAgICBf3+AgICBgIGBgYCBgH9/fn5/f36AgYGCgoKCgoCAf39/f35/f39/f4CBgYGCgoKBgYGBf39/f35+fn6Af4GBg4KBgoF/f39/fn5+f4CAgYKDgoKCgYB/fn5+fn5/gICBgoGBgYCAgH9/gH9/f4CAgICBgYGAgYB/gICAgICAgICAf39/f39/gIGBgYKBgYGAgIB+f39/fn+AgIGBgoKBgYGAgIB/f39/f35+f4CAgYGCgoKBgYF/f39/fn5/f4CAgIKCgoGBgIB+fn5+fn5/gIGBgoKCgYGAf39+fn5/f4CAgYGBgYGBgYB/f39/f4B/gIB/gIGAgICAgICAgIGAgICAf39/f4CAgICBgYGBgYCAgH9/f39/f4CBgYGCgYGBgICAf39/f3+AgIGBgYKCgYGBgH9/f35+fn+AgIGCgoKCgYGAf39/fn5/f3+AgYGCgYGCgoGAgH9/f35/f3+AgIGBgYGBgYGBgIB/f39/f36AfoF8jIF6i3mKdoR8gXp/foGCgYKEgIJ9goJ9gYN1jHGKdod8gYR9hH6BgIF/gIR7hniHc4t5iH2Efn1+fYJ/hXyJe4V7hHyDfoKFfIN3gnqDe4d/hoB/gn6BfoKAgn1/gH6AgICEgX+CfoF/f4CBfn6BfYF+gYOBgIGCf4B+gH+Af39/f39/g4GDgYGBgH9+gH+Af4CAgH+AgIGAgIGBgX+AgIB/f3+Af3+AgYGAgIGBgICAgIB/f39/f4CAgYGBgYGAgH+AgH9/fn+Af4CBgoGCgYGAgH+Af39/fn9/gIGBgYGCgYGAgICAf39/f39/f4CBgIGBgoGBgIB/f39/f4CAgIGAgYGBgYGBgIB/f39+f3+AgIGBgYGBgYCAgIB/gH+AgICAgICAgIGBgIGAgH9/f4CAgIA=", + "informationDown": "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", + "informationErrorAlarm": "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", + "informationError": "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", + "informationFlashing": "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", + "informationForward": "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", + "informationLeft": "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", + "informationObject": "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", + "informationRight": "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", + "informationSearching": "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", + "informationStart": "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", + "informationStop": "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", + "informationTouch": "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", + "informationTurn": "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", + "informationUp": "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", + "mechanicalAirRelease": "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", + "mechanicalAirbrake": "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", + "mechanicalBackingAlert": "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", + "mechanicalBlip1": "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", + "mechanicalBlip2": "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", + "mechanicalBlip3": "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", + "mechanicalBlip4": "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", + "mechanicalHorn1": "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", + "mechanicalHorn2": "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", + "mechanicalLaser": "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", + "mechanicalMotorIdle": "UklGRgIcAABXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0Yd4bAAB7cXB7q56VZnB3en+DdoGlknhdbXqIfYZ3WGyVlJqbmIiDlXJslZxmUDoxWW6ZqrXTtKWOh5WDbFlSW11WWWiWoIaMs8S1h46Uc0p6bXBzVF5HY4O0tLTLq35pV2JUfaJ8WV1TfneOma7OsXiHelNfYmFve2mAh7Kpdn1tjJm+q35vcVA0VIeplY2agD1qlaTFoYN9XlySYHewoGJcLGWAhsqiY5NjX6GlsLGSWHZdTkZwbmtcaYDFu9S6n11Qd4idpJpqGw4Zf7ajsriAn7Kmlp15WUE7PXzBx6ZzUlR4nKCfh2FCaXKKjp6oqYpbWmV+jKeVaWdYfKOgkYNkX1hziYOJhnOXrbi8nmZPWVdXXpi1rZJbT01WmMDOpHt+inpeal5cWV94kqzQt4JcU1yAtr+8c1AqPENumKqij5OPj42MmZ5+gIBzaE5iXGGEjY+ij6WTpJuJY3aDZmZifId5Xmh8anqsyse3n11QUGFhcIF6gXSCZoCSma2YipWdf2pdcYB2W1dmery2pGdwgnJzl62RT1Nkdo+anYFwhWJ7maClhnBtd2pcebOakoFnUmGQpa+JbGFscIC6sntrXVtekJaOdJKVZ5qNh4aHYWhnhGqJoYllVGl7jJ6rnqB/b4J0bIaJi4R8ZntQbHB0eoW6yJmAj3x/e4qCdV9yh3hnb25nmJeDpaiSfGFmaZihepBpZlBSdKe3zaRuXkdvhKKRhYheY3KQeZOSfIZ/h3dle2SBiY2AhYxdkJ2Zf4BpW3aTnIx1g3pgb1SCjJiNnY9vfnBvjaGqr5twZkBaeZ+zgW5aeXWJnoqWbHmNdHaJf4h0Z15Li5LEusWScFZIXmOJfXRtYHN/jKKsiqabh4mTi4NzYUReeoeRjZebgXFpc4eZlY9+aEk8cK+8w5t3S1t/gpywkVBQUFp/p6V4VlaTqZ2HjZOLhpyEbYSmaU03Y1p5p8fFqXNZZmWNra52Vk48WZZ8fZ6upJumkXx8hGZTcouIUDlWf3V9iK2/2LWVqG5uamFNXmRcVXKErKWlsauSgYKIblpXf4twaGhhYnqjpsejsYhoc25kZ3hqWltvb32dupyxrIuNg3JdUl0+QICXrMaqkHZgZnqhuKeVb0FIVEtupaW0o4V/g3iAlo6Db3F6ZH6EeW9hZm6irLaXent0enltcIuHhYqRaVBLdoGJm5Kfn6+mfXZROk1UhZyoo6CDeYOQgX17d299ho6FbkJVfazX171qSztle4R9c2ZdWoB/oKS3taGYemZral9lY0hWeJS9vqmWfmxedYWLkHRkZ4GBgo6Sk3t9kY6JiIh7b4N4X2Nlf5WRpJ+SbW5NX3OIhIWJkKmolYNucXx6emBqdnRcSXOFlru9nYmVg21/eYCJh3NlVldsfIiiqYp+kZami5B/a15oZG99en6Eh4qIip12lrCfeWFLTEdysZWTgnV6dKivemKVlWVpZHSFgox8bG+Ti3BvnZuPkqh8XGqBcFN5YH1/l5N+qcCnkZNcUV9cY4apo4xvTUR4y8+rhWhJRZGSsXd5amZYeIx8eoHGjYqwi397ZYZTXVwwcq6hcHOIlJm9qItpfHh+doJ7eIWTXF1/d3x4WICdj7CLkHSYqZ+FfHJJbHZ8VlhlkpypnqmPdmtZeYOYmXl0boBzYISMepeWho54dHuOd3mBbIqDim17gnVxl5uJenJDZY+MnaSUgoNyamR2g4yQm4R6Z4tjeHpzfnRxfr6nmY1uYXCzn456ZV1NfIR+hJ+agHOAgnyFnY57gnNxUF2RfY96aXdyprnJsohfL0VacHh8eYeph3uUm4u0ropNUFx8mn92g39rdoGizKmYe1tSWGJ0gXNiYoGsqb2ymGZZXG+Ms6V7Y0xCTVx7i5WxnY+Gho6Wj4WIaXyTl3FfPUxff6Cmtrydfk1ObpOzuYZVMkh1doSMjaSglo2OkaCTZ11YYGZle4VcTVuPy/TTv4hrYFpKX4CJd3tTT2uFqNatlZV7e4t6joFtQy5WZJqlmKqeh46LjIyGW2hxcHVlaGF+jpGUs7CKjJRtXWlnW2qTlnqDioV8fXZ3pq+PoIKAamJWV12DqYuIiJalfpp3UmN3pdS4m00dFx1Tqs2zz49zbGxtp52deIJmempJWIFRTHqpxuPLm2BMSFuHo52RZS5RgYmdq6WSnJGPgoODUFhFVm2Wu9i/hV1PanCHnqSNVFM/T2qHuMDDmIN7hndmc3p6T0Jtl8Gif2pqXW2Gn8O5h4lyYlFdjY6JgIp7d2+FgYaMlHdqkY6Dio2BaHZoWGB1lJWQhI6VpqB/dnNzdXd+a1RZfYd0hp6rnZN9fZCOeXSOkI5wZlYyWHStv7Gfkm9mYHWbkoR/f3JfaW6Dm4aNn3huhpaKk4leYlFqfXKepap5bF6Ih4O4jWyLdHNzc4VhcJOVlIV8eWxse6OHgm+MhGuQgFJwoIG2jKRtSmx6nH6Gi4l4bmV6jJGYmoKVXmFah4aSkolzabBqVoWQZ36UrpqKent8gUVTeXqMmqdzVDlTis/Uz61yZl9dgJF1X2hjUHqNopGbWIqis56fZm6SZXFaiI+Rl4NfNGuBk4ulnKSNf05XYpydl3trXnRxgaCdypVqaXVkan59dX93dX2Oj4uGm4uVfHNlVGt6l3KEmX1ukZOEd3V1gYaSlqODdm5aWUVFWa3OsMmDcIRgY4vC0IFYUztPjI2QoHyHiG+NrYePcWl4dH2VYnRxWGxldpDjzb+ChGxNW2NbZG2Qa2+Jg46OpZqooY2OZmN7bHGUhptpWF6Fe7eYe5l3bVmHdGiBoaWSfGVebqe2nIFiWW1mXomBgnNkeXuMrcWYZWaIjI6aoZtzOhxCYo3E4q53dGh0lKOchWpQPy9YlK2zlomAhpats46QeEw0SWCXlGtmWFGQkaTQ2LKejWlbaGJ1dlsyQW2pzLiLipSRsJqNc0pFWHJklZKHbX6Cj56UjpWWf2p1ZWF8hnp3TV1/or3LrItlYlxRXoB1jYmEfpqvn3p2dGR1h4p8mJSBZzhbdZayupKHin14c4F6an2waFeWl3VoUU9zkqefrrOVZ2lManagp2hlbVNdXoXDpquyfn+Oam1maXZ/aWh8dJ2UnIiNgpGOl6eRg1VJNk93mMbRuo9lSmGEdZmIcVVEdIaOiY6rq49seYZpfaOQdEQ/b5KVlISQc298oJGMmIBXfZN/fXiCdnWOj4iSdYCFh3hqfXiIg42Shm17fFpXaXaEd5O8sJuVf41yX2+OhH9oTk9ZbGJ4wNC7npeAfHOElYd4X2lZRll/k6Wih4OkqIWFgIh/bnpuTFtob3GYsqCdloeMjoZrZ0w6aZCRqI6mdXuBfISSgXuhfFtrcmyUkoeHRJGKc7uiUWh4aKWQeLZGfGtdc4l9k7iyjXaQV2NidomGqJxqP36Agpq9lm5CaomTf6CGipCBkTNxdEx6k4agx7yWf2VPKkN8rL+nXE5SUIO7o7KzwG5FVpiDl3ByUVSMnHB0YnKbkpeguZ2ul0BRZZp2fYeLQCZjk6vA07SFaFxbSXOKfJGEnnuBX3aMeLGJiYeWZV56emd9g5mDjolfY3h/vauCZmR3XH90jpSKgoqIcnxdZJOevJl3anFfcHRaO4ewp6jFmEpJb4Srv8eySC4cS3qvn6Och22KbX+QfJeAgGJ7mJJsclQ4T3a08umxalFDToSPcXd0WlCEkqCZs5WKkYiOdYOPaEZgd4aKgJdzi8Scg3d4cVVaXmiNn72JdFpYebDBx6pxMyFSYYS1pG9Hc3iZm4unmHFgdXScy7SUYiMjRn/J0K6SbUFTapawzbheQClAlb2ogXNmZZS5tI6chU45UnSqpo5xWig3X6v+8b2KZVhkjIeBZWlONWS2xKqGd2dyjqehvKZdPk1LWXugpoh0ioOPkISTj4aPamZld3pfRGOSmLrKn6RoWGNddX5qiZeUZnSPqYuCb1WMjpOYcYWFa1xmdYd/q9msflNaYG53eo6ZmIyDeZNfRE6DrLmcb2FmgXyHfYqIiYiye2lLWHSEdIahp5mWb2xhXXikoqWUXENmbHGVxdCZc2t7nJBeQDROf6vQyKh+cG1nbHaBin5qaFtQYZW60r6RU2p+i4l7bldTbW54m7Cji11jeYqds5B8fHJ0bHd7bnqLkaOYh4SCbGJrdIZ4jZeLeYWFb2dzfm10d4aymI2OiopvZHeciYVhZ2BRY4iYpX6Po51xdn+SoKSXfWNGSVt5hIuFg5y2hnmQoH2Bf3hmXWVpb42Hb5qqlKGclnJaa3E7VpGYuo6LeGSIhHpgb6WukXx2cnd1b32BiYNnhJNybIGNgYFynJdxbIBumJp2fZGob2JgXXqDgaeliIZ0i4N2hJB9h19XXX+PqJB+cnqpqoSCbExgbXmWq6OHdHBrXmd4lpSkhmBNWpWVlayYrINac3t9hWh5c1l/lIaEi2Jph56bsJ2UjFx6Y3l6gph4XUFxk52XopF7eHNsdYegboV/gXigg190ZoWCi4eKnZ+PZVJYeXZ+lq+Tf3txiYiGZ3duX3t7f5WOmYuYY2BrbZiLtaudaWJsPk5XYoTA0qCdilZog46ctrJ0L09YaHuRwIqHgnqJepOgiW9pQFiIop+OfXFUXXKe4syGW1dOX2h3jpWPeIR6f2eCoJSOooOVdnmFa2p3c2l2kq6ViYJ6hJSZfUQ0Yn2SqZ91ZmuHoa+8lIRZYlhiXmdcbZGLpXx1hqWnoYyLbYZuiYOJdjNKXoKwybWAf3NxjIOAg4xwXVtIa3h9mKyxp6ildoOfgFQ+R1tOcIF6goOhnqPPvo6Nf3BxYmk/Rmx0co/NqYtsko2npo55ZWhEantzX2aRsJaTmX2Sh4RvdHd5got2WUtOY6C5zL6PenpMYYN2bFV2nKaYj2+Mh3+KYmuVeniGko5+cWlbjYiIl6ufmHBJaE5zoqa6pm9hRU9nZImeuJR2b5SPhY11YXFubZWhiW5pZ3CXmZGQlH59Y3BiZpqno2pbXGaRp8GjnIZkYXSfnX41LlV/mLrIqYybiHFjTmN0bnxsfXJ2f6DYu4hhXG6Nn4dtTDRGaK3Pu6BuVWp/h5qgknFwbWFof5SjlIWTiXdggpCCf3Vpc4BxjZeSd4V8b3JqdGN/jaq0pndrdm13jZadeWdTWlt1h4qQjpGJhYejsJlxdIV2ZV+BZVeKfXWNoaOZiHqGmIZ/aH14TmNxZImZpZuKlbRhZHyDc1JhiYmVmI+jgVxgWnSIoqmyhl1abJKIZZGCbHx+g3GIi1ianpCFdI9wUYWDipKSqJJmU052c5Olmo54YIaepI6NZWZPW3BxoLB0jZeAj4iOfnppVmqKlqOxi2tMS05uiKuxlHBpR2Chsa2nw5d5UU9MXpeTbklxhpqXb3afhomJmaqoq3NbXWxgdYR/d0Zxe5+prqGIZWSLgIyFiYdtUGt9ip+DaHd7dIWqpZemjl9LRV5uf6OgmIJmkIyLiIdsaVhfbJGdtIt/fG57ao6Kn5dvan5HR3yyfKKog3BWfKF5hraiiJOLQkN6Z4h/qYZ+iG98mIKblW16fmJkbGiemX+JcoN7iZ2Zh3J4bmJrcnGBkIqDc3+Rg6GiqHF0dnJ/kHlya2xfj5uVq5h9jFRLeFx/nLetcmFEVneTzbe7fU1DaHB4eXB/bnh0lK2UhGR4f4mdyK9/eE4+Mj2O2MuoemplbpWSr4p/ZkYiOoiyoL+mk4F0oI6JjnxZI0WKtriDXDwwWp3Q1NqkcGFybml+h49bTEV1oLuzknttbXOOrLqrVkYyU2WRtcCue15WW3CdvbCegko/PHWOkpmIiJCRh6Wmfk85UWZojsGZpIVukIODjomFZjl5iXaehYFzbIGSha69tqdHKy1UlMLKumZCRTtbo8O2omRfXGW1vpFnT153fZCadn+ATWOKsL2ulWBGSmqZn5SWZU5UWJyqsbasgG52p6mYfz8qME58m6KfoKGmpaN1b3N1ZVlWVWGIj6SglouFkpOniGdRPkpvjpiSkIWDgpeEi4mXhXh4e3BvZmt1kZaQpZV4bWmAjamKbWBrbW9+l6aObFdufnmCpJeFd4J5a3Kns5SYa09TbZGDaXR8cXV7i7SqopqQmntoaGZ4ZTxigpKlp5F/eXCCrLK3g001O1pzg6Cvl4uIioZ8l4J4ZVBNcaGUo66OY2ZzaZWajIRpX42bqICMV0xap7SKgHIaMommysy7cDRHb4GvwNSAUT8wQ3WiybqXdTVqoJ+quJtqMBIsfLbJvKeOZpNceYCLY2KLiYSOvYtpT0dAbaKxpphcWUqLq7u9l4h2fEp4j39zWlhZdo2cq3pzcG+BobWoqciMYzlOYXucd2RJfWSPq7KjkX9kgoaUhZh9QVd0gnikl3hyfV18tKuXiodqcmOLblxTU4eUmLOni4SEcXN7fHt8g46DUFREe6Cqs7irhmhdU0x0eY6ypYFKUXWPf3670rOMlUJBXHuFnm2Lbm1reIe9t4p9YVNwg6SRanJXT32f1NCSeVxGR1aejHKDbXFtnpKpqp2YgF1df56be3xPREV4krjGsZ+Ue2U/RGt2h5+mp4JsVVxzmqubrpteQkxveYCBinp+got4fZSVhHl1eYqLqbGQWjocZ7XEvcF+XFBaZpKFnqRsPEFcg6PWy5CBkm9wiZ5/X1JLN2KYmquBYUd0rsPJw6OGW1JMW3aciFZkVXWUtKSqi4iBdpGpiXBuXi02fK2cqrB5ZmyBnpacmXRNQ2CBhICBk5GIgIiypo13ST06VYvCt5aJe2uIj52fj4NZTHN6cGBecIGexdC9o3xbSmNufImMenRZSFKRm5myrJxobZWOlHd7UzxaeoafgHyTeXiYs66OcGpjZW+OiWliYmxylLbIxZJyWmmEorKbZEAMM1KbyMyyoYl6fn2GiIV+ZEY/TX2Xn5+hoIJ+ipORjW5eUVpeb6GDa4CVoJKHl66QgXp2eG1iS0x2iKuvqaBsZFNknLabnZdjSVpeZoKco4Z4cXl3lYyPm35ueY5/jJCadmtgQGuXmKaSYlJrgpSdq5+ai4B8eG1jcFJxj3uJgH5zc5qkjZOUlpFoamlOU3Gko6OQcWxzcmmGmZyUioR0emp/eYKJbn2ZdHSIiHt9jHyJgo13a5iWSGt3f2mDn4hlnpSHpXuUeI6CV0lhWJiLoJyIjKaChqxqanNaRmxRb5yVpa7IjpRvdVyHd4yGgmBsVmVVZI6Nvq+Ta3qDsX6JenhniqCQgFtwX2o+f6CVnoRwhHxujKebq7SYe1xYY2KCi21FeW2Oj5mfpKCAaWp5f4OWdWZ3f3OGjYCPjIZwhoF/gnxxeYWLdG51co2Ta4ucfXGLgXuLd3J4dZWbhHdmX2GGh7C8h2d1VE+Vs5+MfFVXaGGBj5OdtKh/oXZ8V3qmlIVGaGxVdZmRlIt8k4B8haN/cXiGfmd+WXGjr5B3cmhymHh4bpJkWX2ZdZ6fkbCKl3lmdHZzaoBecX6ao5qLe1diZHqymqmZbFpZbaGczKlYQjZNf5V0hJd/fJeynV9hZFl3iri3s4BlY1JTdYqfrahpaW18sqWVeEguWnqNm4F5eYWJoNn10F8sKCJJicqygzcrSXCevMzesmZLSpHGt5ZgJxQ7dKnIxa9bbHGTjJOknlBNR2mLn6GUaHF6iaOdkXpicm58d4Z9eHR5WmCVv8SzjW9RTlp4koh3cF6Bmpmfs5J1fXBoh5l0XVthYH2Nm7+Zo59zamhykaeMbWtkaGx5eHNyfnqNoamhh46Dc2VpaZKHfmBPT1ufvruzim10bo5wfKiFWF1aXEWGpqiksqKqta+Af2M8NEJjaG6Vj4Cs0LGMh46EWW6GZ18/fYRRgqWfppaenX1+ZE5fYW2GkWSHmZehknJ/eZGtmHBZTmF7h4d8npCFqnNodY6dimx8cFBwdqGcjXZufoGAjXtvZGyGl5SRnJiViXFxaW1yd3NrXGd/h5+7obOYiYVsbmBlcl58kIuJfHV/mZp2gpiXjoJhRUt7oZV7cHyPrKGNpXBMS1t5kY+CmpSKYViEipOjoJN4YX9ygndzZWCGoaWNdodNSXacoI2hfWx0kWqIlZ6Ojl9JWWGKkqa3qURneLSbh5tLP0psX663nn6leqGHYMRzRHpvTJuAkpVvgnYUfKWrs5CUR01vlp+fpqh0aF9RfqCEj2Q/Tq+yhq5edHc6isS1rbGQZT1SY4enml5cZGqIo5aftnJOT4Sbo5qVW1twd3iXmn6idEBinIuckIuEdmuLeVZtj49pfIeajZaMcGxhYIGdtLJ4TjpSeZKkr7WaZG97XVFskZiTjWxmcW6Qn6KVsaBylmhCS5B9p5+AXzthnpCBuYdhgX2gmG58f05/gH+nuHiVRlt/TWm0jn59Xmxqk7O9k6N9al6JcKeReH1FR0aJsoqZvKC7llFESVNXnLKdkJFsbVlpn43DvXpPLmthbKyZj296WVuKr5erglBXq62boLBjG0FVkZuuxZBjRVKMocq6d0dRS3GTeYp2iIt6uK2neIeRaVpuh21STUs6ZYXR6cjCplhlmI2DZ3VsNEZJgamxmJB/bXehvM+ZVUpQX1CRmot0nYxjToefl7Odi2JIVISAbnh2lqGNjaOYbWdre1ZXeoeUs6Kfa3KMmmpjaYB6dZenclZXanukscPIonFFMk53o7GLjHZoSkhhhLCrqpCAcoqIgm5ra3eHjYtlam5/fnqTo5uAZHF4iqqkkWdOMVmYmrGRjXF9eKytsbV0Xk1FNVCAopWOq5t/iK2cinx5aV9QVltuiYaUm5Wlpp6GdmZpdFdlbmxfc62toHF+fJCtvp51UEc/Y3yEpambaW91goOUpqODfWtiWmSTkYN9eG5wi4uLfYxzf52ShoiEeX6GeG9xb39yh5WFYkZim56xxKOahYNgYmdRYW6KhouHkXtzlZmFkqOFYXxzZW9vX4eEmbeVfoJ6cHFja3uElYOJmY1lZXmcgn6LdH9xnZuBX31zhXacq5NUYEAreLO1pqp+aHSOiICVqoh6ZDhKY3aYs7Cdb0h0l8bKsXRaKyBCdIWgn7CslIZ9goGKeH6CkoRhWINyRGCAhoejtH2TdW6MhKGfZoqOgWp7fmRrVlmAl5uKgmyRhoSgnKibpHVUUHRdgaWHbWVmYX6fn6Wsi15mcWmHnJWCbm5vdoSQiaWLaF+UkHWEent5jXl8Z3RklXiFjZuJkoZfYo2QfY+Hh3hiYF14iY6pp6mKbVxxQXKdj6igak5EZIWilcazl3uSaGiEgn9rj19rb2dzl4p7k5Scjl9+jnp+mH2HVoJtdZeRnaCFV1JFaoWWlpRoent9pK+io4tuhmRoaXFwbW55jZKap62MZkFEbHOqwMq0bExCRF2lq5+Qd3xzY1h/kIGLk5CEbldZfX57jqXBqoqHaU1neo+jhmlkZGyRmaqHlIJcfmd5UXRwk5mnuaiRf5FyX2xkcnWLb0Y4WI6xnb/JrImOdGlhY2VrcHh+iYo=", + "mechanicalMotorStart": "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", + "mechanicalMotorStop": "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", + "mechanicalRatchet": "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", + "mechanicalSonar": "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", + "mechanicalTickTack": "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", + "mechanicalWalk": "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", + "movementsArm1": "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", + "movementsArm2": "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", + "movementsArm3": "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", + "movementsArm4": "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", + "movementsDropLoad": "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", + "movementsLiftLoad": "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", + "movementsServo1": "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", + "movementsServo2": "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", + "movementsServo3": "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", + "movementsServo4": "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", + "movementsSlideLoad": "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", + "movementsSnap": "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", + "movementsSpeedDown": "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", + "movementsSpeedIdle": "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", + "movementsSpeedUp": "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", + "movementsSpeeding": "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", + "numbersEight": "UklGRhUOAABXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YfENAACAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGBgIB+fnuHhm2JnmCAmW92hoBufI+UdoOOfHGKgGt8d3iGhI+QjYyKfnZ5a2psc3WggYO4hIGMfmV3bHt5dY15dHWIsF6mumuTgo1Nfl11Vm6Sb42YqYWmfo+Ganx6bnmAeIOAhYaDhIeAendbb9MmoNJNpnqwRpFkhFleqFSKiKxvopiEgXiCYnBwg2aMlIOImoZ5hHx4dIB8c29vcoqfbLSqdaKBhll4YGRdbohql52gk6eWf4NsbVpodWiEjpGPno6Kf315cXd3b3BxYXmioGHkm3KtfH1FfVFfUHuFZaumopqzk3x3fVpVdWJuepGLkZqbiIiMeXB1bmBdZ2iyfoLyeqOfkmVgcERcQYNieKamoam+mIl9h0ddaFljeomEl56fjJeKeHh2YVZZWoKpXdXDfsGUk059TU1CXHRPl52io8TAgqCYU1xsSVFucn2Fo6KVoKJ6gYBmVVlTVZaPfN+rnbqVg1tvRks9ZmBfmZugrNmjlbB9XGJjQFtmdHWOoZmcqJd+jHxhW1pPWIedeMjIkragiFxrU0FAWmRYkZ2fqcW5lKmYYGtnSVJiZXCClpebp56LioxoZl9KXWSUh5nNqayip2ptYklCR11TdouhoLe/uoaylUh/ZD9WclR4g5eQnqibjI+LaGBiSldnmIqK4ZymsZxxa2tGRUViTG+RlZi3wLSapKxNfHE+TXNUaIePjpismo2Uk2toXFtJao+Qb+qXlsORgGp/QlZEZE1kjoeRrcOcsqeVfXZvUFlfXmCCf42XoZaYlI5+cmFbVGCBjXi8uIXDlo1vgVZRTlpUVoaAiaC/q6ajs3R4g1ZQbl1ae4CAi5+TkpaWfn9yXlFraYSOhs6EtKKVfH9tTGNJYE16doWSq6Kow3+uhXFybVFpZWN3eoWJlJOUjZeCgG1mVmJ3jnab0GrCoIl2jGFRZFBgUIRxhI+zkbqoj6V6g2pxX29aemh7gYmGlI+Nj4aLZ29iYICRaai7a7udf3+MYFxoWV9agnB+kJmRqa2Jnpt2foFjZnJlaHh3eYaNiY6SkYKAc2BxeJdSt6VmuJeCc6RTcmNtVGh9bX2JlIGlpI2aqXOVfW9qdlxrbW5yfoeJkZWWj4l4bG1ok2d3xV+jnZFyonNqdWdmWHtneHqSfJOkm5SdpXShd250aFltY2h5eIqQl5iclIl4aWhxh1CflmiumImHqWKCbW1WamxmdIGKfZqamaSbmZCFfm5naGFibW52gIyRmZqWlop8Z2tbhG1dw2aWqpl5qIVogWhoVnhgc3OOfIuclpinko+QfH5ndWJna3Fpg4CHlJeTlJGCgWVoXoCBSs1xha6edZuZWolmcU1+XXJyj3+IoZOOppWAmn5xeHNgdG1xdIJ8i4qQjZCLg39/ZmR2gHdly1+cppBzpoBgiGdoXINgen2OfI+Xh5CVj4GUe356f2t6eHB4fXV8hn6Ii4uEiYd3a3tqnlGhm2GqjoN2sFSPcHpcgm1xfH6Fd5aBiYqUh4WfdYaIfGuGb2l7dG18g3mPjpCLj4mAcHhjjHRcvV2TmJRvqn10iXVxaH9ieXCGcIqLiIuYjo6WfJVvi3Fwd3NlgXR0ioCCjo2Fk4CHf3dtdHCWT6mHc6GTf4agYY9ufV6CZ3dzgnx9kYOLjpOFko58h4RweoZjgHtseoNwhYWAio2JiIiGfG+AZ5Rjg5pqlo+Jeqdpi3d9Z3tucXZ6gHqNhYuKlISPh496hIJwfHR3cX10fniGe4aFiIWPiImEgH9rdHqEVqhyfZWQd5ePc416e2uEaXlzgnGDhIKFjoqHkIeIh4Z3hXJ6cHtwe3x8f4eChouEiIeFg4Z9eHNwcZJWmotvmo9/h5ttjniCaIRweHSDdn2Hf4KJioCNiIWEh4OBfYZxgXZ3dXt0f32AhoWJiYqHiYOFfIJycWeWYWy2VZaVi26xbol+iGp6fXBzf4BujICBg5F+iomHfoiCeIaBcoZ6eH1+d319fH6ChIKIiYeGiYGEfYJ0e3F1cYptgp1qn4aPe59vjXOEaX1zdnWCen2JgYWHioGKhYV/hnx+g4Fxi3h2g3x0g3t9goGDgoWGg4WFgYSBfXx5d4B0gH6Ffo2CiIWJgIN/fHl6eHl7fH9/hIKFhIaDhYODgYJ+gX18g3t8gnt/fX59f39/gYOCg4eDhoSBf3h1eohYom2Bio14lYaEhYGCc394dXWCcoCAgn6Lg4iFjIGFhIF8gnx8fXx7fX58f32DfoGDf4KCg36HgIGCgnyCfn9+gH99gIB+gYF/fn9+gn6CgoKBhYGDgoKAgH9/fX59fX1/fX5/gICCgoODg4KFf4KHd4V/e3+CeIN8fn5/fIJ9g4OBgYF8gY1skIB9gI11h4F/gX5+gHx7hXh/gX56hXyDgISBhYCHgYKBg3yBfn59gH1/f35/f35/f3+BgYGBgoGDgoKBgYCAfn9+fn5/foCAgICBgICDgIGCgYCAgICAfoB/f3+BgYGBgYCAf39/f36Af4CBgYCCgoGBgYCAgH9+f39/f4CAf4GBgYGCgIGAgH9/f39/f3+BgYGCgoGCgX9/fn5+fn5/f4CCgYKCgoGCgYB/gH5/fn9+f3+AgIGBgoGBgYCAf4B/f3+Af4CAgYGBgYCAgH+Af4B/f4CAgIGBgIGBgICBgICAgH9/gH9/gICAgICAgIGAgICBgICBgICAgH9/f39/f3+AgIGBgYKBgYGAgIB/f4B/gICAgIGAgICAgICAf4CAgICAgICBgYCBgYCBgH9/gH5/f4B/gICAgIGAgIGAgICAgICAgICAgICAgICAf4CAgH+AgICAgIGBgYGBgICAf3+Af4CAgICAgICAgICAgICAgICAgICAgICAgICAf4CAgICAgICBgYGBgICAgH9/f39/f4CAgIGBgYGBgYCAf39+fn9/f4CAgYGCgoGBgIB/f39/f39/gICAgYGBgYGAgIB/gH9/f3+AgICBgYGBgICAgIB/f39/f4CAgIGBgYGBgICAf39/f39/f4CAgIGBgYGBgICAf39/f4CAgIGBgYGBgICAgH9/f39/gICAgYCBgYGAgIB/gIB/gICAgIGAgICAgICAf3+AgICAgICAgYCAgICAgIB/gH9/gICAgICAgIGAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGAgICAgICAgICAf4CAgICAgICAgICAgYCAgICAgICAgICAgICAgICAgICAgIB/gICAgICAgYCAgYCAgICAgIB/gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBgICAgICAgICAf4F/gX6Ce416goF8gnyDf4F+gn+BgYCCgIB9gn2CfoGAgH+Bf4GAgYCAgH+CfYJ+gX+BfoB/f4F/gIGBfoN9g3uEd5N4gYZ3hnGJfX99h3qEfIF+iISDg31+eXyDe4F/g36BgIGDgIOBf4F+f32BeoZ7hH+AgX9/g3+BfoR8hnmEgHyBgX6AgnuHfIGCgnqIeIZ8gnyJc4p6g3yGeIp2h39/f4R6hn1+hXx/goF7h3uDgH2CgXuGe4R+gn2Gd4p4hnyEe4V9gIGAfoR7hIB8hX2Af4R1jXKOdYh5jHWIfoJ/fYKCfX2FfYJ6iHqHd4l7gYCBf4R6hIF6hnuEe4Z4i3iEgIN7hHuDf3mHfn+DfIZ/fISCeop2h319gYN9gIN/gnuEgX6EeoWAfIOCeoh5hXyFeod8gIV6goJ9gYB9gYN6hn2AhnmDgIB/hHiIeoJ+g3qHfIGBfoCAgH6Ee4N/f4R/fYSAf3+AgIF8goJ8hXqFfIZ6goGBfIV8g32BgIR8gIV7hH2Ee4V6hnuCfn+DgX2Ef4CBfYOAe4Z8gn+Bf4F8iXeDgIF+gXuIfH6DfoJ/gX6FeoN/g32Bgn2Af4J/gICEf36BgYB9gYN8g3yEfYB/hH2BgH6DfICBgH6Bf4F/f4CDfIKDf4CBf4J8f4R+f4GAgX+AgoB/gYF+gYCBf4F9g39/f4GAgX6CgX2BgIF9gYGAf4CAgX+Agn+BfYN+gICCf4F/gn6Af4R8hHuDf4J8hH2DfIGBgX+AgIN+gICBgH+AgYB9gX2Df3+CgICCfYCBgIKAgIF8gH9/gIF/g4KCgoB/fH97f32Ff4WBhn6DeoJ7gXyCgYJ+gn+Af4CCgH+CgX9/fYJ/foCCf4N9goCBfoJ/gn5/f4F+gX+CgIF/gn9/gYCBfoB/gX6AgYGBf4F/g32BgICAf3+AgYCBf4J+gYB/gICAgIF+gn2DfoF+g3+AgICAf4B/gn5/gYB/gYCCgICBgH6BfoCAfoKAgICBgIJ/gIB/gX+AgICAf4CBgYCBf4CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgA==", + "numbersFive": "UklGRqIVAABXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YX4VAACBf4GAgYCAgICBf3+BgH+BgICAgIGAgIB/gICAgYCAgIF/f4CBgIB/gYB/gIB/gYCBgX9/gYCAgIF/gX+AgICBgICAgH+AgICAgICAgX9/gIGBf3+AgIGAf4CBgYB/gIB/gICBgICAgIF/gX+Cf4CAgIF/gYCBf4B/gICAgoCAf4GAgICBgX5/gYGAgICAgH+AgYB+gn+AgICAgn9/gYGAgX5/gICAgYCAf3+Agn+Agn+AgX9/gYCAgIF+gYB/goCBfoGAf4GAgIJ+gH+Af4GAgoCBgIB+gYCDf3+AgYCAgH6BgH+BgX9/gYCBgIF/gICAgH9/gYCAgX6Bf4GAf4GBf39/gICCf4B/gX2DgICBgH+BfoJ/gYB/f4CCf4F/gH6Cf4GAgYF9goGAgICAfoF/goB/gYGAf4CAgYJ8gIR9gX6CgH9/gX+CfoJ/foCAgYCBf4CAgX6Cf4B/gIJ9gX+AgX6DfYKBf4GAgH6CfoCBgICBfoB/gICBgYGAgH9/gIGAgH+AgH6CgIGAg32BgH5/fYOCgX+Cf4GAgIF+gH2Cfn+Cf4GAfYKBgX+Bf4CBf4N/gH9+gYGAgH5/gX+DgX6FfX6Cgn9/gX6CgH+Af3+DfoN+f4CCgIB/gYB+gIB+goJ+hIF+f4J/gX6Df359goJ8g3+CgH6Df3yCgH+Df4CBgH2AgX+Af4N/gn5/foOBgIN9gIKBfH6Ag4KAfYSAfoF/fIaFe4B8gIB/foN9g4GCgYF+fn2IiHx6fHx+gIGDgYN/gH+AgYCBgYOEgH1yaF9wmbCzp4RmYGpueYJ9f4ODgoiHhoOAeXl+f4OJioeFf2xTQ1KSze3lpl0uMkdrh4qDfImUp6yafmpfWmx6hZGdmY2IfHdxZ00/Wo7P9fG1aTEaLlV9jpedoKWklXxqX2JxgIqLioSBgoaKjId2X0hBWp7j+d+bSRUZP3CcrKehnZGDc2Jea3+OmJSFdm9xe42anJF4WDs7XaHo99SOQxslUHuepp+ZmZB9bF1hdo+bmYx1aWl1hZiinItuTjY/bLHt9Md9ORoqV4Ohq6ehl4RtW1VlhqOrnoNmWF90kKasnoVlRzZFcLPv9MR3MBIqX5CwtaiZi3djV1hrkbGynXtZTVx4mLKznX5eRDtKb6fl9cqHPRMfVIqwv7Cah3JcVFxskba7on1UQVJ3nbm7nnlYREFPb6Lg8M2MPQ8cU426x7CUfGdZWWN0lLi9n3dMOlB+p8G+mW5QREdYc6DT6NCURxMWSIu/z7eScVxXXWl8m7G4q3BBO0x/usy2jmNIRVReeKzZ5MaELwkgXKPS0KeBY1JXZHOHqMC4jlkzN2eiyMilc1BHUl5rhrff3q9dGQs5hMPXuo1qWVhhbXuSr8GseEQuR4K6zbiKXkpQXmdzls/hyow1CB5iqNfPnnZeVl1rc4enurKNWTU/bKHDwJtvVVFgbGtyoNXdv3IfCTN9vtu8iWlaW2dxdoynvLKDSi5DerXNuIpgTVRobm2Dud3UoEcMFVSg1NSkd19YYGtxfpqyvaJoODJZlsbHo3VUTmBxcW6Ry9rHgykHKXO438WNallaZnFzh6e3s49WM0Jwpsa5j2lXWWx3bWePztzGfCEHMX7A3rqDZ1xga3Fwhqa6t4xQMEJ0rcm2imRUW3F6bmeMzN3EeyEINILD3Lh/ZFxjbHFvhaq9s4dML0d7sMexhGJXYXiCclxzvOHSlzQGJXC02MGFaGFnb3FqeKC7vZlZLjxtpce4jWhYX3WDe2FcnN3duF0OEFKcy8+Yb2dpb3BqapK3vqhwODRekb3Bm3NeXGyDiHZWX6zf2qpKCx1lps3BiWxqb3JxZm6XvcGeYS84aqLCuI9pXGJ2iYdqTWm75dydNwcmbq3PtYNwb3Nzal5zpcK6j1EvSHurwK2CZFtjfZGQelRIjNjnxGoXEE2Rv8KVdnR6eG5cX423w61vNzhilbu5km9fYHWMkH9eQ23L7taPLAc0fKzDqH55gHttXlN3ssu3gkMvVouyu55zXmBviZqSeFI7bcfr15U4EzdwnreliYiHd2NUV4O1xa14Rz9jjqqrkXVqbHWGkI1/ZEFMo+nqv2APFFCLucGchH90Zl5cc6K+sYpdRVh+m6abgm9qb36Ql4xzUThbvvPkqUQKJGacv7WMfHt0aWRkfaa5pH5aS2KGnaGWf25tdIORj31lTkl+1u3KhTASPnyjuKOEgIJzYlxmjru7kmdHS3abp6KNc2xvcn6NkYx8X0hFlevqxG4bGVSGpbKTgYqHcGFbZ5a9solmT1x/lpyYh3Nra3WLm5mIZ0AubdP55506Di9kkbKolZmQcFdKVIS7y658ST5eiKatmnxpYWh+lKCZgWJIPGjB9OWiSBAkX5a4s5aDfXFlYGeEprajfVlOYoSeo5aAb2lteYuYm4x1WD0/iOT204QoDz54oLaghoiIdmVZXIC0x6h3Sj9fiqSqnoRwZmRzjJyci21KOVWv7ue2YiMlVn+fqJWNkIhwYldmjrO2mXFPUW6OoaKRemxnboCSmZKBbVZHTpjv8L5tHAxJhKi9qoyGfWRYWGWLtsOugUw5UH2kuK2La1dVa4ukq5h3WUtBX8D54KJMDyVplrCwk4OIfWRcXnCYubOVb01Na42jqpl9aF5heJShoo9xXlJLVJ/t6r5wHxFNh6q6n4B+gG9oZ2mApLGdhmJPYYCUo6GHc2hhaoWWn5+IbFtUUFme5e/HdSINQHyou6OIgoJzZ19ie6S4podmU1t2jJqil4JtX11zkKSmlndbT05UhuL6y34tCjZ+o7Ooi4KLfWNcYHecs6OHcF9id4iQmJOCdGpmc4eVmZSEdGlhWlZyxfbblD0JJG+it6+Oe4aHcGFbZoisrpt8XlxyiJSZjX1xaWd1ipefmohvXVJJVqLo7MZ2Ig5AeKW8qYuGg21gXGSBqbSfhGZcaXyIkpWLf3VsbXuHkJWPg3pyaWdiV3XI8dqZQgsjZ5WwrJGEkItwX1lmiayqk3tjZHaFipKPgnlwanGEkpqXh3NqZ2NdXJDd8cd4KAk2eqS2q5OIiXheVF57pLulgGRbZ3+NjZSThHZrZnKKlpaMe3F3gYJ9cl1Ka8j22pc/CyhvmaupkYiRiGRSV3Cdv7GDY1ljgJOOiYiBe3t1c36JjIuEeHR6gYaFdFhHc83y1484DzFzmameioqWjW1aWG6WsqWBZVtripiTjod7cW1rdYuXlIl6b3OAi4+Ic1dBUKz177hiHBVQgJqpo5eWkmxPT2SKtL6bd1pSaoiQmZ2OfW9iYXiPmZqNd2x0foaNh3NhUU2N5vPGfCwMOXeVqqqcl5d5UEhYe6e9pIFuZGd3hYOTnIp2aWRti5mXjn9saHOAj5uUemJJO3HU+NibRRIrZIWer6Oal35SSV16oLqrhG5fW22IlZWbknppY2Z6lp2ThHRpb36KlZaHblpIRYTk+c+INhAybYuirKKZlXtUTmB8nbSlhXRmYGl+jpWamIRwZGFviZqXjX9wbHSBjpeTf2lVQlKd7vK+dSwbQ3OHnKmmp5p0R0RdgaazoIV9cWhocoaTmJGIe2hhaoOapJV9bGZreoyXmI54YU5EYLX66a5fIh9OeYukrq2dhVxAVXaZqquPe3hvaGh+jpedk3tnZGd5kJuVin1uaW98jJ2ejW5VSEhvwP3fm1UqMFh3fZWqtKmMXT9Td5elo46AfXFlY3aRop6IdnVvaG9/kJyZhHJsbHOCk56diGRPTlBnrPnvsWkqIEJwf5uytKaJZUZZdo6Ymo+Fin5tY2x6j6ifhnVoX2h+iZeflYBwZmBwi56lnoNdTVNXaqf07K5pLyNDc36WrbKljW1MWXKGj5aTjJCDbWJqeIabm4d7endvcXmImJiGcGlseIiVm5eKb1dZWl5ztv3hoFcuLk9ucZSywq+NYUVZb4OMm52ZkXVhXnCAk52LgHp6eHN0eo2Uj4J3cnF5f4qUl414ZmNiX2d/zfrGgEg1Ol5rdZ++v519WFJndnyGmpyaj3dqbndyeoSRl4uBd3hycXmHlI+EdHR6f4SJkI+CbGVpZWFxld7vrm1FQUVZXXerx72WeFxcZmhwh6SooYx1amdoaXuepY+DeG90fHN7k5OCdnV4houCf4eIeHN4c2hmanzF9MCAXUtBSk5enMjCoYxzY2JcYH2doZyXi4B1ZFlofJellYuAdWlsc3iNlZCFgXlyd3mBi5GFe4F6aFteZovf7quAZEs5QERwtcevmI97bmFSYIKXlpqZkYd2Z2RvbX2hlpONemhueHGJlJGHgHVveXqCjJePgHtqXGFnbIDG7ruTcVtHQDhOkK6xrKuahWlOUGd7g5amqp6Ca2BlZYCNf4+bjnp3dYCBcnODjoeDgIKDf3+Dh3pranFra3aY5Nubg2xWNyw1da60s7Orj2pOUGdyeIeeq6SRgHpsWVyBd4SXkpaMe3aCbWp7g4yLhYKFfXqDh4N1cG91bWJ4ks/dn4t4ZDwzOmibm6Outp1/ZmFqY2N1kaChmo6HdWFkgnJ0hYaXkn6Hl3JpcG99g4GMnIyDgnp1a2Z7hXByf4ObybGRkG5ZSEJKdYyVrratlnplZGJfbX+PmJyYlYdyY4F7YH95h4yCgJmKcH54en54f5CIeYaFg3tweHl2cXZ6hJS9speQcGZNTE5ufomirq2cinhwY1pldYWPl5mSjHmQg1tzb3NygYKQpIqHh3tta3B8h4KLkoyFe3V4d2x0d3OBf7HElJqCdltLR2F7cZCjrqeZjYV6WlhhbXmGlqCkj5GTX3BrY2x2eoecjqGOfYBybnF4dImIiJOIfnh/dHRsZ3Z+h7u2k6KEcllRS2lvb5GeoZ+al5R+Y2RgYWt6i5qhqZeLfmplYGNvgYaVnJWOhXl0c293fX6GiouLh35+c29pbHR2ib21lKWFdVtPT2lqao6ZoKGcm5J/aG1kYWd1hpSYmJ6he3N1Z2NjcH2JlZiVlIh8eHNtcHd+h4qLiYCAfnV2dm9wdYi7m5uhjXxeVlFpW22MmJ+foZ2Wem9vYl9oeIOQkZaeoXt7gGxnYG92homSmpCNgX51cG14gYGKiYx9fH14eHNwd3aTtIyjlo50ZFpca1p1iI+WmaCdln15c2dmaHV7h4mfoISQhXtsaWl2dXWVkYuOjYN9dnKAeHiDiYWCgX2BdHV8d3RzmLGInJWSdGVeZm1YcoeOj5KdnpeAgH1uZmlxdnyBjaWUgZSGdmtrcnZ2foyLh4aIhoB8f4J7eX2BfnqAgH57fnp0dYqxiJeWjn5oZWJwW2mCho+Qn56biICCcGpmcHJ5f4yhh42RhH5yc3F2eH6BhoeCh4aEgoOCgH57fXl4e3t9gH18fnSbqH6dkop1bmFmcVlygoWMk52ZnIaGgXJqanBveXuHnISPlouAenZufW1whYGAho6HioOAiH96eX14dXt6fn9+d3yFopeInI2FcGxja2ljeIKHi5WbmJSIhX50bWxwdYN2hI+Li4iIhIV7eXd1dnZ6f4aGiYuJiYOAfXx3cnl5en2CgHt8gqSQiJaOhXJvZXBvZHeCiIaPlJKWiIaCfHBtcXh/doKIiYeDi4qHeXl9eHZye4GDg4SKiYeDgoF9enZ4enx+f4B8eIKYjIaRjoh9d2xzdmxyfIOCh4qKkI2Gg4J8dnt4eH2AgoOFgYKCfn5/gH9/f31/f4CBg4ODg4CAf359f35+gYB+e3l6eomOh4mJiYF/eHR8e3h4fX9/hISEhoaDg4SAf39/f39+fX5/f39/gYKCgYCAf35+f36Cg4GBgoKAgH9/fn19f3+Cgn9+fIGKhYKBg4KBf3p9fnx8fH9/goODg4KCgYOFgX5+fXx+f4CCg4KBgH9+gIB+f35/f4KDg4WCgn98fH17foGDgoGEgYCAfn9/f4GCg4KAgH9/fX59f4GBgoKDg4GAfn5+fX9/gICBg4KDgoCCfX18fH5+gYGDg4GDgYB+fnt/fn+AgoKCg4CBf4B/f4B/f4CAgICAgYCAgX+AgICAgYGAgIB+f35+f4CDgoKEgX+Bfn99fH2AgYKCg4OBgYB9f35+f3+AgYGDgYKAgIGAfn6Af39/gYGBgIGAgIB/gYB+gYCCgIB/gH9/gIB/goKDgX+AgX5+f4B/gICBgYCBgIGAfoCAf39/gICBgoKCgX+Afn9+f4CAgIGCgYF9gX+AgICCf4B/gH+Af4CAgIKAf4F/gIGAgICAf4F/foF+gYKBgIJ/f4F/gIB/f4CBgIGBgoF/gX9/f4B/f4CBgYCBgYGBf4B+foB/f4GAgYF/f4GBgICAgYGAf39/gH+AgoCAgYCBf39/gX+BgoB/f3+AgH+BgYCBf4B/gX9/gH+AgX+AgoB/f4J/gYB/gX9/f4GAgIGBgYB/f4GAgIB/f39/gIKAgYGAf3+Af4GAgYGAf32AgYGAf4GAf4B/gIB/gYF/gICAgoCAf4CAgX+Af4GAf39/gYKAgIGAgX9+gICCgIF/gX+AgX9/gIGAgICAgX9/gICAg4CAgH+Bf4GAgYB/gn5/foCBgIF/gYGBgYB+f4B9gH+CgIKBgICAf4F+f4CAgoB/f4F/g39/gH6BgX9/gYGBgIF/gIB+f4CCgYB/goGBfn9/f4GAf4CCgoCAgYCBf36AgYCAf4CAgIB/gn6CgICCfoGAf4B/gICBfoCBgX+AgH+BgH+BgYCAf4GBgYF/gIB/f35+gIGAgYF/gYCAgICAgICAgIB/f4CAgYB/gIGCfoCAgX9/gICAgIF/f4CBgYCAgICAgIGAf3+AgIJ/gH+ChYB+fX9/gH9/goCBgX+AgYB/gYCCgXx/foF/f3+CgoCBf4CAgYB/gX9/foB/gIGAgYKAgYB/f4B/f4CAgH+AgIGBgICAgIGAfn+AgICAgIGBgH+AgIB/gICAgICAgICBgICAgYCAgH+AgIB/f4CBgYCAf4CAgICAgICAgICAgH9/gIGBgYCAgICAf3+AgYCAf4CBgYCAgICAgH9/gICAgYCBgH9/gICAgICAgICAgICAgIB/gICBgYGBgIB/f39/gICAgYGAgICAgICAgICAgICAgIGBgYCAgH9/f4CAgICBgICAgICAgH9/gICAgICBgICAgICAgICAgICBgYGAgIB/f39/gIGBgYGAgIB/f3+AgICAgIGBgICAgICAf4CAgICAgIGAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYGAgH9/gICAgICBgYCAgICAgH9/gICAgICBgYCAgICAgICAgICAgICAgICAgICAgICAgIGBgIB/f39/gIA=", + "numbersFour": "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", + "numbersNine": "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", + "numbersOne": "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", + "numbersSeven": "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", + "numbersSix": "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", + "numbersTen": "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", + "numbersThree": "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", + "numbersTwo": "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", + "numbersZero": "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", + "systemClick": "UklGRskAAABXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YaUAAACBjIN2f4N5g3uHaIG+b1xjlrRJXpTuQ4GHLFS506wHtBb/c2xLgIPMY1Oja8lXaXCWeWmGro9xSVmso6xuRGSYlJtvZol8j4dneIuOi29mi4Gec39ucZOMhG9wkJZxcXCRjoR/Z3mDkI5zbIaGg3t4hIOHfnZ5gIaJg3R7foiDfICBfoF7fIODhoN5c4OIhHx+foR8fn6Dg4R5e3uIhoN3eYOGf3k=", + "systemConfirm": "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", + "systemConnect": "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", + "systemDownload": "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", + "systemGeneralAlert": "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", + "systemOverpower": "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", + "systemPowerDown": "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", + "systemReady": "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", + "systemStartUp": "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" +} \ No newline at end of file diff --git a/libs/music/sounds.ts b/libs/music/sounds.ts new file mode 100644 index 00000000..5a7d8adf --- /dev/null +++ b/libs/music/sounds.ts @@ -0,0 +1,256 @@ +namespace sounds { + //% fixedInstance jres + export const animalsCatPurr = music.fromWAV(hex``); + //% fixedInstance jres + export const animalsDogBark1 = music.fromWAV(hex``); + //% fixedInstance jres + export const animalsDogBark2 = music.fromWAV(hex``); + //% fixedInstance jres + export const animalsDogGrowl = music.fromWAV(hex``); + //% fixedInstance jres + export const animalsDogSniff = music.fromWAV(hex``); + //% fixedInstance jres + export const animalsDogWhine = music.fromWAV(hex``); + //% fixedInstance jres + export const animalsElephantCall = music.fromWAV(hex``); + //% fixedInstance jres + export const animalsInsectBuzz1 = music.fromWAV(hex``); + //% fixedInstance jres + export const animalsInsectBuzz2 = music.fromWAV(hex``); + //% fixedInstance jres + export const animalsInsectChirp = music.fromWAV(hex``); + //% fixedInstance jres + export const animalsSnakeHiss = music.fromWAV(hex``); + //% fixedInstance jres + export const animalsSnakeRattle = music.fromWAV(hex``); + //% fixedInstance jres + export const animalsTRexRoar = music.fromWAV(hex``); + //% fixedInstance jres + export const colorsBlack = music.fromWAV(hex``); + //% fixedInstance jres + export const colorsBlue = music.fromWAV(hex``); + //% fixedInstance jres + export const colorsBrown = music.fromWAV(hex``); + //% fixedInstance jres + export const colorsGreen = music.fromWAV(hex``); + //% fixedInstance jres + export const colorsRed = music.fromWAV(hex``); + //% fixedInstance jres + export const colorsWhite = music.fromWAV(hex``); + //% fixedInstance jres + export const colorsYellow = music.fromWAV(hex``); + //% fixedInstance jres + export const communicationBravo = music.fromWAV(hex``); + //% fixedInstance jres + export const communicationEv3 = music.fromWAV(hex``); + //% fixedInstance jres + export const communicationFantastic = music.fromWAV(hex``); + //% fixedInstance jres + export const communicationGameOver = music.fromWAV(hex``); + //% fixedInstance jres + export const communicationGo = music.fromWAV(hex``); + //% fixedInstance jres + export const communicationGoodJob = music.fromWAV(hex``); + //% fixedInstance jres + export const communicationGood = music.fromWAV(hex``); + //% fixedInstance jres + export const communicationGoodbye = music.fromWAV(hex``); + //% fixedInstance jres + export const communicationHello = music.fromWAV(hex``); + //% fixedInstance jres + export const communicationHi = music.fromWAV(hex``); + //% fixedInstance jres + export const communicationLego = music.fromWAV(hex``); + //% fixedInstance jres + export const communicationMindstorms = music.fromWAV(hex``); + //% fixedInstance jres + export const communicationMorning = music.fromWAV(hex``); + //% fixedInstance jres + export const communicationNo = music.fromWAV(hex``); + //% fixedInstance jres + export const communicationOkay = music.fromWAV(hex``); + //% fixedInstance jres + export const communicationOkeyDokey = music.fromWAV(hex``); + //% fixedInstance jres + export const communicationSorry = music.fromWAV(hex``); + //% fixedInstance jres + export const communicationThankYou = music.fromWAV(hex``); + //% fixedInstance jres + export const communicationYes = music.fromWAV(hex``); + //% fixedInstance jres + export const expressionsBoing = music.fromWAV(hex``); + //% fixedInstance jres + export const expressionsBoo = music.fromWAV(hex``); + //% fixedInstance jres + export const expressionsCheering = music.fromWAV(hex``); + //% fixedInstance jres + export const expressionsCrunching = music.fromWAV(hex``); + //% fixedInstance jres + export const expressionsCrying = music.fromWAV(hex``); + //% fixedInstance jres + export const expressionsFanfare = music.fromWAV(hex``); + //% fixedInstance jres + export const expressionsKungFu = music.fromWAV(hex``); + //% fixedInstance jres + export const expressionsLaughing1 = music.fromWAV(hex``); + //% fixedInstance jres + export const expressionsLaughing2 = music.fromWAV(hex``); + //% fixedInstance jres + export const expressionsMagicWand = music.fromWAV(hex``); + //% fixedInstance jres + export const expressionsOuch = music.fromWAV(hex``); + //% fixedInstance jres + export const expressionsShouting = music.fromWAV(hex``); + //% fixedInstance jres + export const expressionsSmack = music.fromWAV(hex``); + //% fixedInstance jres + export const expressionsSneezing = music.fromWAV(hex``); + //% fixedInstance jres + export const expressionsSnoring = music.fromWAV(hex``); + //% fixedInstance jres + export const expressionsUhOh = music.fromWAV(hex``); + //% fixedInstance jres + export const informationActivate = music.fromWAV(hex``); + //% fixedInstance jres + export const informationAnalyze = music.fromWAV(hex``); + //% fixedInstance jres + export const informationBackwards = music.fromWAV(hex``); + //% fixedInstance jres + export const informationColor = music.fromWAV(hex``); + //% fixedInstance jres + export const informationDetected = music.fromWAV(hex``); + //% fixedInstance jres + export const informationDown = music.fromWAV(hex``); + //% fixedInstance jres + export const informationErrorAlarm = music.fromWAV(hex``); + //% fixedInstance jres + export const informationError = music.fromWAV(hex``); + //% fixedInstance jres + export const informationFlashing = music.fromWAV(hex``); + //% fixedInstance jres + export const informationForward = music.fromWAV(hex``); + //% fixedInstance jres + export const informationLeft = music.fromWAV(hex``); + //% fixedInstance jres + export const informationObject = music.fromWAV(hex``); + //% fixedInstance jres + export const informationRight = music.fromWAV(hex``); + //% fixedInstance jres + export const informationSearching = music.fromWAV(hex``); + //% fixedInstance jres + export const informationStart = music.fromWAV(hex``); + //% fixedInstance jres + export const informationStop = music.fromWAV(hex``); + //% fixedInstance jres + export const informationTouch = music.fromWAV(hex``); + //% fixedInstance jres + export const informationTurn = music.fromWAV(hex``); + //% fixedInstance jres + export const informationUp = music.fromWAV(hex``); + //% fixedInstance jres + export const mechanicalAirRelease = music.fromWAV(hex``); + //% fixedInstance jres + export const mechanicalAirbrake = music.fromWAV(hex``); + //% fixedInstance jres + export const mechanicalBackingAlert = music.fromWAV(hex``); + //% fixedInstance jres + export const mechanicalBlip1 = music.fromWAV(hex``); + //% fixedInstance jres + export const mechanicalBlip2 = music.fromWAV(hex``); + //% fixedInstance jres + export const mechanicalBlip3 = music.fromWAV(hex``); + //% fixedInstance jres + export const mechanicalBlip4 = music.fromWAV(hex``); + //% fixedInstance jres + export const mechanicalHorn1 = music.fromWAV(hex``); + //% fixedInstance jres + export const mechanicalHorn2 = music.fromWAV(hex``); + //% fixedInstance jres + export const mechanicalLaser = music.fromWAV(hex``); + //% fixedInstance jres + export const mechanicalMotorIdle = music.fromWAV(hex``); + //% fixedInstance jres + export const mechanicalMotorStart = music.fromWAV(hex``); + //% fixedInstance jres + export const mechanicalMotorStop = music.fromWAV(hex``); + //% fixedInstance jres + export const mechanicalRatchet = music.fromWAV(hex``); + //% fixedInstance jres + export const mechanicalSonar = music.fromWAV(hex``); + //% fixedInstance jres + export const mechanicalTickTack = music.fromWAV(hex``); + //% fixedInstance jres + export const mechanicalWalk = music.fromWAV(hex``); + //% fixedInstance jres + export const movementsArm1 = music.fromWAV(hex``); + //% fixedInstance jres + export const movementsArm2 = music.fromWAV(hex``); + //% fixedInstance jres + export const movementsArm3 = music.fromWAV(hex``); + //% fixedInstance jres + export const movementsArm4 = music.fromWAV(hex``); + //% fixedInstance jres + export const movementsDropLoad = music.fromWAV(hex``); + //% fixedInstance jres + export const movementsLiftLoad = music.fromWAV(hex``); + //% fixedInstance jres + export const movementsServo1 = music.fromWAV(hex``); + //% fixedInstance jres + export const movementsServo2 = music.fromWAV(hex``); + //% fixedInstance jres + export const movementsServo3 = music.fromWAV(hex``); + //% fixedInstance jres + export const movementsServo4 = music.fromWAV(hex``); + //% fixedInstance jres + export const movementsSlideLoad = music.fromWAV(hex``); + //% fixedInstance jres + export const movementsSnap = music.fromWAV(hex``); + //% fixedInstance jres + export const movementsSpeedDown = music.fromWAV(hex``); + //% fixedInstance jres + export const movementsSpeedIdle = music.fromWAV(hex``); + //% fixedInstance jres + export const movementsSpeedUp = music.fromWAV(hex``); + //% fixedInstance jres + export const movementsSpeeding = music.fromWAV(hex``); + //% fixedInstance jres + export const numbersEight = music.fromWAV(hex``); + //% fixedInstance jres + export const numbersFive = music.fromWAV(hex``); + //% fixedInstance jres + export const numbersFour = music.fromWAV(hex``); + //% fixedInstance jres + export const numbersNine = music.fromWAV(hex``); + //% fixedInstance jres + export const numbersOne = music.fromWAV(hex``); + //% fixedInstance jres + export const numbersSeven = music.fromWAV(hex``); + //% fixedInstance jres + export const numbersSix = music.fromWAV(hex``); + //% fixedInstance jres + export const numbersTen = music.fromWAV(hex``); + //% fixedInstance jres + export const numbersThree = music.fromWAV(hex``); + //% fixedInstance jres + export const numbersTwo = music.fromWAV(hex``); + //% fixedInstance jres + export const numbersZero = music.fromWAV(hex``); + //% fixedInstance jres + export const systemClick = music.fromWAV(hex``); + //% fixedInstance jres + export const systemConfirm = music.fromWAV(hex``); + //% fixedInstance jres + export const systemConnect = music.fromWAV(hex``); + //% fixedInstance jres + export const systemDownload = music.fromWAV(hex``); + //% fixedInstance jres + export const systemGeneralAlert = music.fromWAV(hex``); + //% fixedInstance jres + export const systemOverpower = music.fromWAV(hex``); + //% fixedInstance jres + export const systemPowerDown = music.fromWAV(hex``); + //% fixedInstance jres + export const systemReady = music.fromWAV(hex``); + //% fixedInstance jres + export const systemStartUp = music.fromWAV(hex``); +} diff --git a/scripts/rsf2wav.js b/scripts/rsf2wav.js index a745fc13..058f165b 100755 --- a/scripts/rsf2wav.js +++ b/scripts/rsf2wav.js @@ -1,46 +1,75 @@ #!/usr/bin/env node const fs = require("fs") -const rsf = fs.readFileSync(process.argv[2]) -const fmt = rsf.readInt16BE(0) // 0x0100 -if (fmt != 0x0100) { - throw new Error("Invalid input format: " + fmt) +function convertFile(fn) { + const rsf = fs.readFileSync(fn) + + const fmt = rsf.readInt16BE(0) // 0x0100 + if (fmt != 0x0100) { + throw new Error("Invalid input format: " + fmt) + } + const size = rsf.readInt16BE(2) + const samplerate = rsf.readInt16BE(4) + const repeat = rsf.readInt16BE(6) + + const datasize = rsf.length - 8 + + const wavHd = new Buffer(44) + + function writeMark(off, mark) { + for (let i = 0; i < mark.length; ++i) { + wavHd[off + i] = mark.charCodeAt(i) + } + } + + writeMark(0, 'RIFF') + wavHd.writeInt32LE(datasize + 36, 4) + writeMark(8, 'WAVE') + writeMark(12, 'fmt ') + wavHd.writeInt32LE(16, 16) // fmt size + wavHd.writeInt16LE(1, 20) // PCM + wavHd.writeInt16LE(1, 22) // mono, 1ch + wavHd.writeInt32LE(samplerate, 24) + wavHd.writeInt32LE(samplerate, 28) // byterate + wavHd.writeInt16LE(1, 32) // block align + wavHd.writeInt16LE(8, 34) // bits per sample + writeMark(36, 'data') + wavHd.writeInt32LE(datasize, 40) + + let wav = Buffer.concat([wavHd, rsf.slice(8)]) + return wav } -const size = rsf.readInt16BE(2) -const samplerate = rsf.readInt16BE(4) -const repeat = rsf.readInt16BE(6) -const datasize = rsf.length - 8 - -const wavHd = new Buffer(44) - -function writeMark(off, mark) { - for (let i = 0; i < mark.length; ++i) { - wavHd[off + i] = mark.charCodeAt(i) +let out = { + "*": { + namespace: "sounds", + dataEncoding: "base64", + mimeType: "audio/wav" } } +let ts = "namespace sounds {\n" +let bf +for (let i = 2; i < process.argv.length; ++i) { + let fn = process.argv[i] + let m = /([^\/]+\/[^/]+)\.rsf$/.exec(fn) + let bn = m[1] + bf = convertFile(fn) + bn = bn.replace(/[\/\-]/g, " ") + .toLowerCase() + .replace(/(\d)\s+/g, (f, n) => n) + .replace(/\s+(.)/g, (f, l) => l.toUpperCase()) + out[bn] = bf.toString("base64") + ts += ` //% fixedInstance jres\n` + ts += ` export const ${bn} = music.fromWAV(hex\`\`);\n` +} +ts += `}\n` -writeMark(0, 'RIFF') -wavHd.writeInt32LE(datasize + 36, 4) -writeMark(8, 'WAVE') -writeMark(12, 'fmt ') -wavHd.writeInt32LE(16, 16) // fmt size -wavHd.writeInt16LE(1, 20) // PCM -wavHd.writeInt16LE(1, 22) // mono, 1ch -wavHd.writeInt32LE(samplerate, 24) -wavHd.writeInt32LE(samplerate, 28) // byterate -wavHd.writeInt16LE(1, 32) // block align -wavHd.writeInt16LE(8, 34) // bits per sample -writeMark(36, 'data') -wavHd.writeInt32LE(datasize, 40) +fs.writeFileSync("out.json", JSON.stringify(out, null, 4)) +fs.writeFileSync("out.ts", ts) +fs.writeFileSync("out.wav", bf) -const wav = Buffer.concat([wavHd, rsf.slice(8)]) - -console.log("writing out.wav; " + samplerate + "Hz") -fs.writeFileSync("out.wav", wav) - -if (require("os").platform() == "darwin") - require('child_process').execSync("afplay out.wav") +//if (require("os").platform() == "darwin") +// require('child_process').execSync("afplay out.wav") // TODO also play on Windows diff --git a/sim/state/sounds.ts b/sim/state/sounds.ts new file mode 100644 index 00000000..4aa21738 --- /dev/null +++ b/sim/state/sounds.ts @@ -0,0 +1,33 @@ + +namespace pxsim.music { + export function fromWAV(buf: RefBuffer) { + return incr(buf) + } +} + +namespace pxsim.SoundMethods { + + export function buffer(buf: RefBuffer) { + return incr(buf) + } + + export function uint8ArrayToString(input: Uint8Array) { + let len = input.length; + let res = "" + for (let i = 0; i < len; ++i) + res += String.fromCharCode(input[i]); + return res; + } + + export function play(buf: RefBuffer, volume: number) { + return new Promise(resolve => { + let url = "data:audio/wav;base64," + btoa(uint8ArrayToString(buf.data)) + let audio = new Audio(url) + audio.onended = () => { + resolve() + } + audio.play() + }) + } +} + From a7795302fcf94fe31d116d81b56b172511773f7d Mon Sep 17 00:00:00 2001 From: Michal Moskal Date: Mon, 30 Oct 2017 18:54:53 +0000 Subject: [PATCH 07/13] Make it compile with master --- libs/core/screen.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libs/core/screen.ts b/libs/core/screen.ts index 08584b26..3f9dad5a 100644 --- a/libs/core/screen.ts +++ b/libs/core/screen.ts @@ -27,7 +27,7 @@ namespace brick { currFont = f } - export const heart = imageOf(hex`f007 367f7f3e1c08`) + export const heart = screen.imageOf(hex`f007 367f7f3e1c08`) export function defaultFont(): Font { return { @@ -112,7 +112,7 @@ namespace brick { let byteWidth = (currFont.charWidth + 7) >> 3 let charSize = byteWidth * currFont.charHeight let imgBuf = output.createBuffer(2 + charSize) - let img = imageOf(imgBuf) + let img = screen.imageOf(imgBuf) let double = (mode & Draw.Quad) ? 4 : (mode & Draw.Double) ? 2 : 1 imgBuf[0] = 0xf0 imgBuf[1] = currFont.charWidth From e25590539edf971fe104c4ee1ac742c8dbcd2473 Mon Sep 17 00:00:00 2001 From: Michal Moskal Date: Mon, 30 Oct 2017 18:55:23 +0000 Subject: [PATCH 08/13] Add sample-playing code --- libs/music/_locales/music-jsdoc-strings.json | 2 +- libs/music/music.cpp | 89 ++++++++++++++++++-- libs/music/shims.d.ts | 4 +- 3 files changed, 85 insertions(+), 10 deletions(-) diff --git a/libs/music/_locales/music-jsdoc-strings.json b/libs/music/_locales/music-jsdoc-strings.json index bdfe21f6..872a8255 100644 --- a/libs/music/_locales/music-jsdoc-strings.json +++ b/libs/music/_locales/music-jsdoc-strings.json @@ -1,6 +1,6 @@ { "Sound.buffer": "Returns the underlaying Buffer object.", - "Sound.play": "Play sound with given volume.", + "Sound.play": "Play sound.", "music": "Generation of music tones.", "music.beat": "Return the duration of a beat in milliseconds (the beat fraction).", "music.beat|param|fraction": "the fraction of the current whole note, eg: BeatFraction.Half", diff --git a/libs/music/music.cpp b/libs/music/music.cpp index cae81c50..613face8 100644 --- a/libs/music/music.cpp +++ b/libs/music/music.cpp @@ -5,17 +5,24 @@ #include #include #include +#include +#include +#include + #define NOTE_PAUSE 20 namespace music { uint8_t currVolume = 2; +uint8_t *lmsSoundMMap; -void writeDev(void *data, int size) { +int writeDev(void *data, int size) { + DMESG("write dev %d", size); int fd = open("/dev/lms_sound", O_WRONLY); - write(fd, data, size); + int res = write(fd, data, size); close(fd); + return res; } /** @@ -60,6 +67,76 @@ static void _playTone(uint16_t frequency, uint16_t duration, uint8_t volume) { writeDev(&cmd, sizeof(cmd)); } +static bool pumpMusicThreadRunning; +static pthread_mutex_t pumpMutex; +static Buffer currentSample; +static int samplePtr; +static pthread_cond_t sampleDone; + +static void pumpMusic() { + if (currentSample == NULL) { + if (samplePtr > 0 && *lmsSoundMMap == 0) { + samplePtr = 0; + DMESG("END"); + pthread_cond_broadcast(&sampleDone); + } + return; + } + + uint8_t buf[250]; // max size supported by hardware + buf[0] = SOUND_CMD_SERVICE; + int len = min((int)sizeof(buf) - 1, currentSample->length - samplePtr); + if (len == 0) { + DMESG("EOF"); + decrRC(currentSample); + currentSample = NULL; + return; + } + + memcpy(buf + 1, currentSample->data + samplePtr, len); + int rc = writeDev(buf, len + 1); + if (rc > 0) { + samplePtr += len; + } +} + +static void *pumpMusicThread(void *dummy) { + while (true) { + sleep_core_us(10000); + pthread_mutex_lock(&pumpMutex); + pumpMusic(); + pthread_mutex_unlock(&pumpMutex); + } +} + +void playSample(Buffer buf) { + if (lmsSoundMMap == NULL) { + int fd = open("/dev/lms_sound", O_RDWR); + lmsSoundMMap = (uint8_t*) mmap(NULL, 1, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + DMESG("sound map: %p", lmsSoundMMap); + close(fd); + } + + if (!pumpMusicThreadRunning) { + pumpMusicThreadRunning = true; + pthread_t pid; + pthread_create(&pid, NULL, pumpMusicThread, NULL); + pthread_detach(pid); + } + + pthread_mutex_lock(&pumpMutex); + *lmsSoundMMap = 1; // BUSY + uint8_t cmd[] = {SOUND_CMD_PLAY, (uint8_t)((currVolume / 33) + 1)}; + writeDev(cmd, 2); + decrRC(currentSample); + currentSample = buf; + incrRC(buf); + samplePtr = 44; // WAV header is 44 bytes + pumpMusic(); + pthread_cond_wait(&sampleDone, &pumpMutex); + pthread_mutex_unlock(&pumpMutex); +} + /** * Play a tone through the speaker for some amount of time. * @param frequency pitch of the tone to play in Hertz (Hz) @@ -89,14 +166,12 @@ void playTone(int frequency, int ms) { sleep_ms(1); } - /** Makes a sound bound to a buffer in WAV format. */ //% Sound fromWAV(Buffer buf) { incrRC(buf); return buf; } - } //% fixedInstances @@ -109,10 +184,10 @@ Buffer buffer(Sound snd) { return snd; } -/** Play sound with given volume. */ +/** Play sound. */ //% promise -void play(Sound snd, int volume) { - // TODO +void play(Sound snd) { + music::playSample(snd); } } \ No newline at end of file diff --git a/libs/music/shims.d.ts b/libs/music/shims.d.ts index 4cfdc542..cb3e2a62 100644 --- a/libs/music/shims.d.ts +++ b/libs/music/shims.d.ts @@ -38,9 +38,9 @@ declare interface Sound { //% property shim=SoundMethods::buffer buffer: Buffer; - /** Play sound with given volume. */ + /** Play sound. */ //% promise shim=SoundMethods::play - play(volume: int32): void; + play(): void; } // Auto-generated. Do not edit. Really. From 2df90152fee4464b7305113c8654e8167f2a1c62 Mon Sep 17 00:00:00 2001 From: Michal Moskal Date: Mon, 30 Oct 2017 18:56:03 +0000 Subject: [PATCH 09/13] Remove debug output --- libs/music/music.cpp | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/libs/music/music.cpp b/libs/music/music.cpp index 613face8..b9373c0e 100644 --- a/libs/music/music.cpp +++ b/libs/music/music.cpp @@ -9,7 +9,6 @@ #include #include - #define NOTE_PAUSE 20 namespace music { @@ -18,7 +17,6 @@ uint8_t currVolume = 2; uint8_t *lmsSoundMMap; int writeDev(void *data, int size) { - DMESG("write dev %d", size); int fd = open("/dev/lms_sound", O_WRONLY); int res = write(fd, data, size); close(fd); @@ -77,8 +75,7 @@ static void pumpMusic() { if (currentSample == NULL) { if (samplePtr > 0 && *lmsSoundMMap == 0) { samplePtr = 0; - DMESG("END"); - pthread_cond_broadcast(&sampleDone); + pthread_cond_broadcast(&sampleDone); } return; } @@ -87,7 +84,6 @@ static void pumpMusic() { buf[0] = SOUND_CMD_SERVICE; int len = min((int)sizeof(buf) - 1, currentSample->length - samplePtr); if (len == 0) { - DMESG("EOF"); decrRC(currentSample); currentSample = NULL; return; @@ -112,8 +108,7 @@ static void *pumpMusicThread(void *dummy) { void playSample(Buffer buf) { if (lmsSoundMMap == NULL) { int fd = open("/dev/lms_sound", O_RDWR); - lmsSoundMMap = (uint8_t*) mmap(NULL, 1, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); - DMESG("sound map: %p", lmsSoundMMap); + lmsSoundMMap = (uint8_t *)mmap(NULL, 1, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); close(fd); } @@ -189,5 +184,4 @@ Buffer buffer(Sound snd) { void play(Sound snd) { music::playSample(snd); } - } \ No newline at end of file From e8e31e6aa706fbdfb9282b6589c7bbf17e546f61 Mon Sep 17 00:00:00 2001 From: Michal Moskal Date: Mon, 30 Oct 2017 19:03:45 +0000 Subject: [PATCH 10/13] Fix brick.print() --- libs/core/screen.cpp | 2 +- libs/core/screen.ts | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/libs/core/screen.cpp b/libs/core/screen.cpp index dff65e69..c7ab8d21 100644 --- a/libs/core/screen.cpp +++ b/libs/core/screen.cpp @@ -239,7 +239,7 @@ extern "C" void drawPanic(int code) { } bool isValidImage(Buffer buf) { - return buf->length >= 3 && buf->data[0] == 0xf0; + return buf != NULL && buf->length >= 3 && buf->data[0] == 0xf0; } /** Makes an image bound to a buffer. */ diff --git a/libs/core/screen.ts b/libs/core/screen.ts index 3f9dad5a..70ca003f 100644 --- a/libs/core/screen.ts +++ b/libs/core/screen.ts @@ -112,10 +112,10 @@ namespace brick { let byteWidth = (currFont.charWidth + 7) >> 3 let charSize = byteWidth * currFont.charHeight let imgBuf = output.createBuffer(2 + charSize) - let img = screen.imageOf(imgBuf) let double = (mode & Draw.Quad) ? 4 : (mode & Draw.Double) ? 2 : 1 imgBuf[0] = 0xf0 imgBuf[1] = currFont.charWidth + let img = screen.imageOf(imgBuf) while (cp < text.length) { let ch = text.charCodeAt(cp++) if (ch == 10) { From a0828074550f9c11c2904a66e205265e812423ff Mon Sep 17 00:00:00 2001 From: Michal Moskal Date: Mon, 30 Oct 2017 19:18:01 +0000 Subject: [PATCH 11/13] Fix locking in waitForEvent() and sample playing --- libs/core/linux.cpp | 2 ++ libs/core/pxt.h | 2 ++ libs/music/music.cpp | 2 ++ 3 files changed, 6 insertions(+) diff --git a/libs/core/linux.cpp b/libs/core/linux.cpp index b7322584..ac40c270 100644 --- a/libs/core/linux.cpp +++ b/libs/core/linux.cpp @@ -269,11 +269,13 @@ void waitForEvent(int source, int value) { pthread_mutex_lock(&eventMutex); t->waitSource = source; t->waitValue = value; + stopUser(); // spourious wake ups may occur they say while (t->waitSource) { pthread_cond_wait(&t->waitCond, &eventMutex); } pthread_mutex_unlock(&eventMutex); + startUser(); return; } } diff --git a/libs/core/pxt.h b/libs/core/pxt.h index e2a31439..0c62ad43 100644 --- a/libs/core/pxt.h +++ b/libs/core/pxt.h @@ -7,6 +7,8 @@ namespace pxt { void raiseEvent(int id, int event); int allocateNotifyEvent(); void sleep_core_us(uint64_t us); +void startUser(); +void stopUser(); class Button; typedef Button *Button_; diff --git a/libs/music/music.cpp b/libs/music/music.cpp index b9373c0e..5912ae5c 100644 --- a/libs/music/music.cpp +++ b/libs/music/music.cpp @@ -119,6 +119,7 @@ void playSample(Buffer buf) { pthread_detach(pid); } + stopUser(); pthread_mutex_lock(&pumpMutex); *lmsSoundMMap = 1; // BUSY uint8_t cmd[] = {SOUND_CMD_PLAY, (uint8_t)((currVolume / 33) + 1)}; @@ -130,6 +131,7 @@ void playSample(Buffer buf) { pumpMusic(); pthread_cond_wait(&sampleDone, &pumpMutex); pthread_mutex_unlock(&pumpMutex); + startUser(); } /** From 26b975b5f229dc4132e02490a849c8e5d021fa07 Mon Sep 17 00:00:00 2001 From: Peli de Halleux Date: Mon, 30 Oct 2017 14:51:14 -0700 Subject: [PATCH 12/13] images --- legoresources/images/BIGbulb.png | Bin 0 -> 2690 bytes legoresources/images/Blank.png | Bin 0 -> 160 bytes .../images/BlockFamily_Sensor_Category.png | Bin 0 -> 381 bytes .../BlockFamily_Sensor_Category_MouseOver.png | Bin 0 -> 343 bytes .../images/BlockInterface_Change_Category.png | Bin 0 -> 422 bytes ...ockInterface_Change_Category_MouseOver.png | Bin 0 -> 365 bytes .../BlockInterface_Compare_Category.png | Bin 0 -> 433 bytes ...ckInterface_Compare_Category_MouseOver.png | Bin 0 -> 399 bytes .../BlockInterface_Measure_Category.png | Bin 0 -> 353 bytes ...ckInterface_Measure_Category_MouseOver.png | Bin 0 -> 328 bytes .../images/BlockInterface_Update_Category.png | Bin 0 -> 425 bytes ...ockInterface_Update_Category_MouseOver.png | Bin 0 -> 385 bytes legoresources/images/BlockParams/=.png | Bin 0 -> 186 bytes legoresources/images/BlockParams/A.png | Bin 0 -> 3379 bytes legoresources/images/BlockParams/B.png | Bin 0 -> 376 bytes legoresources/images/BlockParams/Backward.png | Bin 0 -> 357 bytes legoresources/images/BlockParams/Blank.png | Bin 0 -> 160 bytes .../images/BlockParams/CTempModeIcon.png | Bin 0 -> 566 bytes legoresources/images/BlockParams/Clock.png | Bin 0 -> 650 bytes .../images/BlockParams/ColorTerminalIcon.png | Bin 0 -> 1153 bytes .../images/BlockParams/Color_picker.png | Bin 0 -> 833 bytes .../BlockParams/DeltaDegreesTerminalIcon.png | Bin 0 -> 826 bytes legoresources/images/BlockParams/Do Stop.png | Bin 0 -> 731 bytes .../images/BlockParams/EqualsIcon.png | Bin 0 -> 183 bytes .../images/BlockParams/EqualsTerminalIcon.png | Bin 0 -> 208 bytes .../images/BlockParams/FTempModeIcon.png | Bin 0 -> 413 bytes legoresources/images/BlockParams/Finish.png | Bin 0 -> 1189 bytes legoresources/images/BlockParams/Forward.png | Bin 0 -> 444 bytes legoresources/images/BlockParams/Foward.png | Bin 0 -> 353 bytes .../images/BlockParams/Frequency.png | Bin 0 -> 470 bytes .../images/BlockParams/Generate Light.png | Bin 0 -> 3252 bytes .../images/BlockParams/GreaterIcon.png | Bin 0 -> 388 bytes .../BlockParams/GreaterThanTerminalIcon.png | Bin 0 -> 368 bytes .../images/BlockParams/Hourglass.png | Bin 0 -> 2540 bytes legoresources/images/BlockParams/Input 1.png | Bin 0 -> 370 bytes legoresources/images/BlockParams/Input 2.png | Bin 0 -> 324 bytes .../images/BlockParams/Intensity.png | Bin 0 -> 413 bytes .../images/BlockParams/Intensity_light.png | Bin 0 -> 616 bytes .../images/BlockParams/Left_full.png | Bin 0 -> 418 bytes .../images/BlockParams/Left_half.png | Bin 0 -> 346 bytes legoresources/images/BlockParams/LessIcon.png | Bin 0 -> 403 bytes .../BlockParams/LessThanTerminalIcon.png | Bin 0 -> 377 bytes .../images/BlockParams/Light_blue.png | Bin 0 -> 593 bytes .../images/BlockParams/Light_orange.png | Bin 0 -> 594 bytes .../images/BlockParams/Light_red.png | Bin 0 -> 591 bytes .../images/BlockParams/Loop Index.png | Bin 0 -> 195 bytes .../images/BlockParams/Mode_color.png | Bin 0 -> 508 bytes .../images/BlockParams/Param_Amount_50.png | Bin 0 -> 3320 bytes .../images/BlockParams/Param_Scales.png | Bin 0 -> 3575 bytes .../BlockParams/PlugSymbolX3Boolean.png | Bin 0 -> 522 bytes .../BlockParams/PlugSymbolX3Numeric.png | Bin 0 -> 463 bytes .../images/BlockParams/PlugSymbolX3String.png | Bin 0 -> 697 bytes legoresources/images/BlockParams/Power_0.png | Bin 0 -> 868 bytes legoresources/images/BlockParams/Power_1.png | Bin 0 -> 981 bytes legoresources/images/BlockParams/Power_2.png | Bin 0 -> 920 bytes legoresources/images/BlockParams/Power_3.png | Bin 0 -> 922 bytes legoresources/images/BlockParams/Power_4.png | Bin 0 -> 884 bytes legoresources/images/BlockParams/Range_L.png | Bin 0 -> 307 bytes .../images/BlockParams/Range_L_R.png | Bin 0 -> 429 bytes legoresources/images/BlockParams/Range_R.png | Bin 0 -> 326 bytes .../images/BlockParams/Right_Full.png | Bin 0 -> 412 bytes .../images/BlockParams/Right_half.png | Bin 0 -> 338 bytes .../images/BlockParams/Rotation_number.png | Bin 0 -> 742 bytes legoresources/images/BlockParams/Run.png | Bin 0 -> 379 bytes .../images/BlockParams/Speed Left.png | Bin 0 -> 368 bytes .../images/BlockParams/Speed Right.png | Bin 0 -> 604 bytes legoresources/images/BlockParams/Speed.png | Bin 0 -> 973 bytes legoresources/images/BlockParams/Steering.png | Bin 0 -> 412 bytes legoresources/images/BlockParams/Stop.png | Bin 0 -> 3209 bytes legoresources/images/BlockParams/Straigh.png | Bin 0 -> 275 bytes legoresources/images/BlockParams/Timer.png | Bin 0 -> 825 bytes legoresources/images/BlockParams/Value.png | Bin 0 -> 249 bytes legoresources/images/BlockParams/Volume.png | Bin 0 -> 494 bytes .../images/BlockParams/XVariable.png | Bin 0 -> 3035 bytes .../images/BlockParams/YVariable.png | Bin 0 -> 3042 bytes .../images/BlockParams/ZVariable.png | Bin 0 -> 432 bytes .../images/BlockParams/angleTerminalIcon.png | Bin 0 -> 752 bytes legoresources/images/BlockParams/bulb.png | Bin 0 -> 2667 bytes legoresources/images/CTempModeIcon.png | Bin 0 -> 566 bytes legoresources/images/CaseSelector.png | Bin 0 -> 1268 bytes legoresources/images/CaseSelector_Boolean.png | Bin 0 -> 2947 bytes legoresources/images/CaseSelector_Numeric.png | Bin 0 -> 1328 bytes legoresources/images/CaseSelector_String.png | Bin 0 -> 792 bytes legoresources/images/Clock.png | Bin 0 -> 605 bytes legoresources/images/ColorLampBlockIcon.png | Bin 0 -> 3427 bytes legoresources/images/ColorSensorBlockIcon.png | Bin 0 -> 5317 bytes legoresources/images/Compare.png | Bin 0 -> 1288 bytes legoresources/images/CompareBlockIcon.png | Bin 0 -> 1023 bytes legoresources/images/ComparePalette.png | Bin 0 -> 879 bytes .../images/DeltaDegreesTerminalIcon.png | Bin 0 -> 826 bytes legoresources/images/DivideIcon.png | Bin 0 -> 264 bytes legoresources/images/EqualsIcon.png | Bin 0 -> 183 bytes legoresources/images/FTempModeIcon.png | Bin 0 -> 413 bytes legoresources/images/ForRotation.png | Bin 0 -> 512 bytes legoresources/images/GreaterEqualsIcon.png | Bin 0 -> 430 bytes legoresources/images/GreaterIcon.png | Bin 0 -> 388 bytes legoresources/images/GyroHardwareIcon.png | Bin 0 -> 1518 bytes legoresources/images/GyroPolyGroupIcon.png | Bin 0 -> 2050 bytes legoresources/images/Hardware_EnergyMeter.png | Bin 0 -> 4486 bytes legoresources/images/Hardware_NXT_Color.png | Bin 0 -> 3427 bytes legoresources/images/Hardware_NXT_Light.png | Bin 0 -> 5091 bytes legoresources/images/Hardware_NXT_Motor.png | Bin 0 -> 3205 bytes legoresources/images/Hardware_NXT_Sound.png | Bin 0 -> 2429 bytes .../images/Hardware_NXT_Temperature.png | Bin 0 -> 1567 bytes legoresources/images/Hardware_NXT_Touch.png | Bin 0 -> 3884 bytes legoresources/images/Hardware_NXT_US.png | Bin 0 -> 4573 bytes legoresources/images/Hardware_PBR_Color.png | Bin 0 -> 5317 bytes legoresources/images/Hardware_PBR_Gyro.png | Bin 0 -> 4950 bytes legoresources/images/Hardware_PBR_IR.png | Bin 0 -> 5043 bytes .../images/Hardware_PBR_MotorLarge.png | Bin 0 -> 5381 bytes .../images/Hardware_PBR_MotorMedium.png | Bin 0 -> 5170 bytes legoresources/images/Hardware_PBR_Touch.png | Bin 0 -> 4904 bytes legoresources/images/Hardware_PBR_US.png | Bin 0 -> 5271 bytes .../images/Id_2Motors_Tank_34x34.png | Bin 0 -> 3248 bytes legoresources/images/Id_Bluetouth_34x34.png | Bin 0 -> 5185 bytes .../images/Id_Bluetouth_Conf_34x34.png | Bin 0 -> 5529 bytes legoresources/images/Id_Boolean_34x34.png | Bin 0 -> 4404 bytes legoresources/images/Id_Buttons_Hw_34x34.png | Bin 0 -> 4920 bytes legoresources/images/Id_Buttons_Input.png | Bin 0 -> 5373 bytes legoresources/images/Id_DataCompare_34x34.png | Bin 0 -> 3891 bytes legoresources/images/Id_Data_Round_34x34.png | Bin 0 -> 3821 bytes .../images/Id_Data_constant_34x34.png | Bin 0 -> 4306 bytes .../images/Id_Interupt_Loop_block.png | Bin 0 -> 4902 bytes legoresources/images/Id_Network_messenger.png | Bin 0 -> 4713 bytes .../images/Id_Rotation_Sensor_V2.png | Bin 0 -> 4817 bytes legoresources/images/Id_Start.png | Bin 0 -> 1404 bytes legoresources/images/Id_Stop.png | Bin 0 -> 1213 bytes legoresources/images/Id_W8_Changes_34x34.png | Bin 0 -> 2370 bytes legoresources/images/Id_W8_Treshold_34x34.png | Bin 0 -> 5345 bytes legoresources/images/Identification_A.png | Bin 0 -> 289 bytes .../images/Identification_ArrayInBoolean.png | Bin 0 -> 415 bytes .../images/Identification_ArrayInNumeric.png | Bin 0 -> 389 bytes .../images/Identification_ArrayOutBoolean.png | Bin 0 -> 430 bytes .../images/Identification_ArrayOutNumeric.png | Bin 0 -> 394 bytes legoresources/images/Identification_B.png | Bin 0 -> 293 bytes .../images/Identification_BlackWhite.png | Bin 0 -> 552 bytes .../images/Identification_BrakeAtEnd.xml | 5 ++ .../Identification_BrakeAtEnd_Brake.png | Bin 0 -> 259 bytes .../Identification_BrakeAtEnd_Coast.png | Bin 0 -> 314 bytes legoresources/images/Identification_C.png | Bin 0 -> 273 bytes .../images/Identification_Celcius.png | Bin 0 -> 347 bytes .../images/Identification_ClearScreen.png | Bin 0 -> 369 bytes legoresources/images/Identification_Color.xml | 11 +++++ .../images/Identification_Color_Black.png | Bin 0 -> 224 bytes .../Identification_Color_Black_Selected.png | Bin 0 -> 190 bytes .../images/Identification_Color_Blue.png | Bin 0 -> 243 bytes .../Identification_Color_Blue_Selected.png | Bin 0 -> 189 bytes .../images/Identification_Color_Brown.png | Bin 0 -> 242 bytes .../Identification_Color_Brown_Selected.png | Bin 0 -> 187 bytes .../images/Identification_Color_Green.png | Bin 0 -> 243 bytes .../Identification_Color_Green_Selected.png | Bin 0 -> 186 bytes .../images/Identification_Color_NoColor.png | Bin 0 -> 288 bytes .../Identification_Color_NoColor_Selected.png | Bin 0 -> 220 bytes .../images/Identification_Color_Red.png | Bin 0 -> 231 bytes .../Identification_Color_Red_Selected.png | Bin 0 -> 183 bytes .../images/Identification_Color_White.png | Bin 0 -> 216 bytes .../Identification_Color_White_Selected.png | Bin 0 -> 182 bytes .../images/Identification_Color_Yellow.png | Bin 0 -> 239 bytes .../Identification_Color_Yellow_Selected.png | Bin 0 -> 187 bytes .../images/Identification_CompareResult.png | Bin 0 -> 172 bytes .../images/Identification_ComparisonType.xml | 9 ++++ .../images/Identification_ComparisonType2.xml | 5 ++ .../Identification_ComparisonType2_Equal.png | Bin 0 -> 172 bytes ...dentification_ComparisonType2_NotEqual.png | Bin 0 -> 269 bytes .../Identification_ComparisonType_Equal.png | Bin 0 -> 172 bytes ...tification_ComparisonType_GreaterEqual.png | Bin 0 -> 290 bytes ...ntification_ComparisonType_GreaterThan.png | Bin 0 -> 279 bytes ...dentification_ComparisonType_LessEqual.png | Bin 0 -> 285 bytes ...Identification_ComparisonType_LessThan.png | Bin 0 -> 273 bytes ...Identification_ComparisonType_NotEqual.png | Bin 0 -> 269 bytes .../images/Identification_ConnectToText.png | Bin 0 -> 526 bytes .../images/Identification_ConstantValue.png | Bin 0 -> 375 bytes legoresources/images/Identification_Count.png | Bin 0 -> 297 bytes .../images/Identification_Current.png | Bin 0 -> 272 bytes .../images/Identification_CurrentPower.png | Bin 0 -> 568 bytes legoresources/images/Identification_D.png | Bin 0 -> 283 bytes .../images/Identification_DatalogRate.png | Bin 0 -> 298 bytes legoresources/images/Identification_Db.png | Bin 0 -> 285 bytes legoresources/images/Identification_Dba.png | Bin 0 -> 332 bytes .../images/Identification_DegreesAngle.xml | 22 +++++++++ .../images/Identification_DegreesAngle_0.png | Bin 0 -> 3086 bytes .../Identification_DegreesAngle_Minus135.png | Bin 0 -> 452 bytes .../Identification_DegreesAngle_Minus180.png | Bin 0 -> 437 bytes .../Identification_DegreesAngle_Minus225.png | Bin 0 -> 453 bytes .../Identification_DegreesAngle_Minus270.png | Bin 0 -> 454 bytes .../Identification_DegreesAngle_Minus315.png | Bin 0 -> 461 bytes .../Identification_DegreesAngle_Minus360.png | Bin 0 -> 392 bytes .../Identification_DegreesAngle_Minus45.png | Bin 0 -> 443 bytes .../Identification_DegreesAngle_Minus90.png | Bin 0 -> 434 bytes .../Identification_DegreesAngle_Plus135.png | Bin 0 -> 475 bytes .../Identification_DegreesAngle_Plus180.png | Bin 0 -> 459 bytes .../Identification_DegreesAngle_Plus225.png | Bin 0 -> 478 bytes .../Identification_DegreesAngle_Plus270.png | Bin 0 -> 475 bytes .../Identification_DegreesAngle_Plus315.png | Bin 0 -> 496 bytes .../Identification_DegreesAngle_Plus360.png | Bin 0 -> 412 bytes .../Identification_DegreesAngle_Plus45.png | Bin 0 -> 465 bytes .../Identification_DegreesAngle_Plus90.png | Bin 0 -> 455 bytes .../images/Identification_DistanceCM.png | Bin 0 -> 403 bytes .../images/Identification_DistanceInches.png | Bin 0 -> 404 bytes .../images/Identification_Exponent.png | Bin 0 -> 246 bytes .../images/Identification_Fahrenheit.png | Bin 0 -> 274 bytes .../images/Identification_FileName.png | Bin 0 -> 399 bytes legoresources/images/Identification_Fill.png | Bin 0 -> 474 bytes .../images/Identification_FontSize.png | Bin 0 -> 385 bytes .../images/Identification_FontSize.xml | 6 +++ .../images/Identification_FontSize_0.png | Bin 0 -> 256 bytes .../images/Identification_FontSize_1.png | Bin 0 -> 245 bytes .../images/Identification_FontSize_2.png | Bin 0 -> 318 bytes .../images/Identification_Height.png | Bin 0 -> 306 bytes legoresources/images/Identification_Hz.png | Bin 0 -> 404 bytes legoresources/images/Identification_Index.png | Bin 0 -> 384 bytes .../images/Identification_Invert.xml | 5 ++ .../images/Identification_InvertColor.xml | 5 ++ ...Identification_InvertColorCircle_False.png | Bin 0 -> 451 bytes .../Identification_InvertColorCircle_True.png | Bin 0 -> 391 bytes .../Identification_InvertColorLine_False.png | Bin 0 -> 333 bytes .../Identification_InvertColorLine_True.png | Bin 0 -> 307 bytes .../Identification_InvertColorPoint_False.png | Bin 0 -> 284 bytes .../Identification_InvertColorPoint_True.png | Bin 0 -> 236 bytes .../Identification_InvertColorRect_False.png | Bin 0 -> 294 bytes .../Identification_InvertColorRect_True.png | Bin 0 -> 248 bytes .../Identification_InvertColorText_False.png | Bin 0 -> 477 bytes .../Identification_InvertColorText_True.png | Bin 0 -> 552 bytes .../images/Identification_InvertColor_0.png | Bin 0 -> 224 bytes .../images/Identification_InvertColor_1.png | Bin 0 -> 216 bytes .../images/Identification_Invert_0.png | Bin 0 -> 468 bytes .../images/Identification_Invert_1.png | Bin 0 -> 476 bytes legoresources/images/Identification_Joule.png | Bin 0 -> 212 bytes .../images/Identification_LEDColor.xml | 6 +++ .../images/Identification_LEDColor_Green.png | Bin 0 -> 974 bytes .../images/Identification_LEDColor_Orange.png | Bin 0 -> 932 bytes .../images/Identification_LEDColor_Red.png | Bin 0 -> 837 bytes .../images/Identification_Length.png | Bin 0 -> 311 bytes .../images/Identification_LowerBound.png | Bin 0 -> 351 bytes .../images/Identification_MeasuredColor.png | Bin 0 -> 432 bytes .../images/Identification_MeasuredLight.png | Bin 0 -> 362 bytes .../images/Identification_MeasuringMode.xml | 5 ++ ...dentification_MeasuringMode_Continuous.png | Bin 0 -> 577 bytes .../Identification_MeasuringMode_Ping.png | Bin 0 -> 531 bytes .../images/Identification_Message.png | Bin 0 -> 374 bytes .../images/Identification_MessageTitle.png | Bin 0 -> 214 bytes .../images/Identification_MotorRotation.png | Bin 0 -> 529 bytes .../images/Identification_NXTBrickButtons.xml | 7 +++ legoresources/images/Identification_Note.png | Bin 0 -> 356 bytes .../Identification_NumberOfDecimals.png | Bin 0 -> 438 bytes .../images/Identification_NumberRotations.png | Bin 0 -> 561 bytes .../images/Identification_Numeric.png | Bin 0 -> 297 bytes .../images/Identification_OutVolts.png | Bin 0 -> 293 bytes .../images/Identification_OutWatts.png | Bin 0 -> 305 bytes .../Identification_OutpuNumberDegrees.png | Bin 0 -> 549 bytes .../images/Identification_OutputBoolean.png | Bin 0 -> 416 bytes .../Identification_OutputBrickButton.xml | 8 ++++ .../Identification_OutputBrickButtonID.png | Bin 0 -> 305 bytes .../Identification_OutputBrickButtonID.xml | 9 ++++ .../Identification_OutputBrickButtonID_0.png | Bin 0 -> 305 bytes ...ication_OutputBrickButtonID_0_Selected.png | Bin 0 -> 266 bytes ...ation_OutputBrickButtonID_0_Unselected.png | Bin 0 -> 266 bytes .../Identification_OutputBrickButtonID_1.png | Bin 0 -> 344 bytes ...ication_OutputBrickButtonID_1_Selected.png | Bin 0 -> 308 bytes ...ation_OutputBrickButtonID_1_Unselected.png | Bin 0 -> 296 bytes .../Identification_OutputBrickButtonID_2.png | Bin 0 -> 329 bytes ...ication_OutputBrickButtonID_2_Selected.png | Bin 0 -> 277 bytes ...ation_OutputBrickButtonID_2_Unselected.png | Bin 0 -> 270 bytes .../Identification_OutputBrickButtonID_3.png | Bin 0 -> 321 bytes ...ication_OutputBrickButtonID_3_Selected.png | Bin 0 -> 304 bytes ...ation_OutputBrickButtonID_3_Unselected.png | Bin 0 -> 301 bytes .../Identification_OutputBrickButtonID_4.png | Bin 0 -> 341 bytes ...ication_OutputBrickButtonID_4_Selected.png | Bin 0 -> 306 bytes ...ation_OutputBrickButtonID_4_Unselected.png | Bin 0 -> 297 bytes .../Identification_OutputBrickButtonID_5.png | Bin 0 -> 329 bytes ...ication_OutputBrickButtonID_5_Selected.png | Bin 0 -> 305 bytes ...ation_OutputBrickButtonID_5_Unselected.png | Bin 0 -> 292 bytes .../images/Identification_OutputButtonID.xml | 15 ++++++ .../Identification_OutputButtonID_0.png | Bin 0 -> 337 bytes .../Identification_OutputButtonID_1.png | Bin 0 -> 347 bytes .../Identification_OutputButtonID_10.png | Bin 0 -> 352 bytes .../Identification_OutputButtonID_11.png | Bin 0 -> 352 bytes .../Identification_OutputButtonID_2.png | Bin 0 -> 348 bytes .../Identification_OutputButtonID_3.png | Bin 0 -> 351 bytes .../Identification_OutputButtonID_4.png | Bin 0 -> 349 bytes .../Identification_OutputButtonID_5.png | Bin 0 -> 346 bytes .../Identification_OutputButtonID_6.png | Bin 0 -> 356 bytes .../Identification_OutputButtonID_7.png | Bin 0 -> 351 bytes .../Identification_OutputButtonID_8.png | Bin 0 -> 341 bytes .../Identification_OutputButtonID_9.png | Bin 0 -> 342 bytes .../images/Identification_OutputChannel.png | Bin 0 -> 2874 bytes .../images/Identification_OutputCompare.png | Bin 0 -> 462 bytes .../Identification_OutputCompareResult_1.png | Bin 0 -> 172 bytes .../images/Identification_OutputDistance.png | Bin 0 -> 260 bytes .../images/Identification_OutputHeading.png | Bin 0 -> 414 bytes .../images/Identification_OutputNumeric.png | Bin 0 -> 294 bytes .../images/Identification_PlayType.xml | 6 +++ .../Identification_PlayType_PlayOnce.png | Bin 0 -> 424 bytes .../images/Identification_PlayType_Repeat.png | Bin 0 -> 370 bytes ...ntification_PlayType_WaitForCompletion.png | Bin 0 -> 697 bytes legoresources/images/Identification_Port.png | Bin 0 -> 240 bytes .../Identification_ProbabilityOfTrue.png | Bin 0 -> 670 bytes legoresources/images/Identification_Pulse.png | Bin 0 -> 499 bytes .../images/Identification_Radius.png | Bin 0 -> 482 bytes .../images/Identification_RandomValue.png | Bin 0 -> 327 bytes legoresources/images/Identification_Rate.png | Bin 0 -> 355 bytes .../images/Identification_RateUnit.xml | 5 ++ .../images/Identification_RateUnit_0.png | Bin 0 -> 452 bytes .../images/Identification_RateUnit_1.png | Bin 0 -> 255 bytes .../Identification_ReceivingBrickName.png | Bin 0 -> 488 bytes .../images/Identification_Result.png | Bin 0 -> 172 bytes .../images/Identification_SensorPort.xml | 7 +++ .../images/Identification_SensorPort_0.png | Bin 0 -> 293 bytes .../images/Identification_SensorPort_1.png | Bin 0 -> 342 bytes .../images/Identification_SensorPort_2.png | Bin 0 -> 346 bytes .../images/Identification_SensorPort_3.png | Bin 0 -> 326 bytes .../images/Identification_SetOfChannels.xml | 7 +++ .../images/Identification_SetOfChannels_1.png | Bin 0 -> 430 bytes .../images/Identification_SetOfChannels_2.png | Bin 0 -> 473 bytes .../images/Identification_SetOfChannels_3.png | Bin 0 -> 490 bytes .../images/Identification_SetOfChannels_4.png | Bin 0 -> 447 bytes legoresources/images/Identification_Speed.xml | 12 +++++ .../images/Identification_Speed_0.png | Bin 0 -> 3294 bytes .../images/Identification_Speed_Minus100.png | Bin 0 -> 3335 bytes .../images/Identification_Speed_Minus25.png | Bin 0 -> 3338 bytes .../images/Identification_Speed_Minus50.png | Bin 0 -> 3399 bytes .../images/Identification_Speed_Minus75.png | Bin 0 -> 3428 bytes .../images/Identification_Speed_Plus100.png | Bin 0 -> 3328 bytes .../images/Identification_Speed_Plus25.png | Bin 0 -> 3301 bytes .../images/Identification_Speed_Plus50.png | Bin 0 -> 3370 bytes .../images/Identification_Speed_Plus75.png | Bin 0 -> 3408 bytes .../images/Identification_Steering.xml | 29 ++++++++++++ .../Identification_Steering_Backward_+1.png | Bin 0 -> 264 bytes .../Identification_Steering_Backward_+2.png | Bin 0 -> 263 bytes .../Identification_Steering_Backward_+3.png | Bin 0 -> 365 bytes .../Identification_Steering_Backward_+4.png | Bin 0 -> 431 bytes .../Identification_Steering_Backward_-1.png | Bin 0 -> 254 bytes .../Identification_Steering_Backward_-2.png | Bin 0 -> 274 bytes .../Identification_Steering_Backward_-3.png | Bin 0 -> 354 bytes .../Identification_Steering_Backward_-4.png | Bin 0 -> 426 bytes .../Identification_Steering_Backward_0.png | Bin 0 -> 242 bytes .../Identification_Steering_Forward_+1.png | Bin 0 -> 269 bytes .../Identification_Steering_Forward_+2.png | Bin 0 -> 264 bytes .../Identification_Steering_Forward_+3.png | Bin 0 -> 366 bytes .../Identification_Steering_Forward_+4.png | Bin 0 -> 438 bytes .../Identification_Steering_Forward_-1.png | Bin 0 -> 269 bytes .../Identification_Steering_Forward_-2.png | Bin 0 -> 272 bytes .../Identification_Steering_Forward_-3.png | Bin 0 -> 370 bytes .../Identification_Steering_Forward_-4.png | Bin 0 -> 446 bytes .../Identification_Steering_Forward_0.png | Bin 0 -> 239 bytes .../images/Identification_StringB.png | Bin 0 -> 452 bytes .../images/Identification_StringC.png | Bin 0 -> 465 bytes legoresources/images/Identification_Test.png | Bin 0 -> 423 bytes legoresources/images/Identification_Text.png | Bin 0 -> 234 bytes .../Identification_Threshold_Current.xml | 43 ++++++++++++++++++ .../Identification_Threshold_Current_Out.xml | 43 ++++++++++++++++++ .../Identification_Threshold_Degrees.xml | 43 ++++++++++++++++++ .../Identification_Threshold_Equal_+1.png | Bin 0 -> 221 bytes .../Identification_Threshold_Equal_+2.png | Bin 0 -> 218 bytes .../Identification_Threshold_Equal_-1.png | Bin 0 -> 220 bytes .../Identification_Threshold_Equal_-2.png | Bin 0 -> 231 bytes .../Identification_Threshold_Equal_0.png | Bin 0 -> 218 bytes .../Identification_Threshold_Greater_+1.png | Bin 0 -> 2932 bytes .../Identification_Threshold_Greater_+2.png | Bin 0 -> 218 bytes .../Identification_Threshold_Greater_-1.png | Bin 0 -> 249 bytes .../Identification_Threshold_Greater_-2.png | Bin 0 -> 216 bytes .../Identification_Threshold_Greater_0.png | Bin 0 -> 249 bytes .../images/Identification_Threshold_Gyro.xml | 43 ++++++++++++++++++ ...entification_Threshold_IRBeaconHeading.xml | 43 ++++++++++++++++++ .../Identification_Threshold_Less_+1.png | Bin 0 -> 260 bytes .../Identification_Threshold_Less_+2.png | Bin 0 -> 240 bytes .../Identification_Threshold_Less_-1.png | Bin 0 -> 258 bytes .../Identification_Threshold_Less_-2.png | Bin 0 -> 231 bytes .../Identification_Threshold_Less_0.png | Bin 0 -> 260 bytes .../Identification_Threshold_NotEqual_+1.png | Bin 0 -> 230 bytes .../Identification_Threshold_NotEqual_+2.png | Bin 0 -> 215 bytes .../Identification_Threshold_NotEqual_-1.png | Bin 0 -> 228 bytes .../Identification_Threshold_NotEqual_-2.png | Bin 0 -> 217 bytes .../Identification_Threshold_NotEqual_0.png | Bin 0 -> 234 bytes .../Identification_Threshold_Rotations.xml | 43 ++++++++++++++++++ .../images/Identification_Threshold_Speed.xml | 43 ++++++++++++++++++ ...ification_Threshold_TemperatureCelsius.xml | 43 ++++++++++++++++++ ...cation_Threshold_TemperatureFahrenheit.xml | 43 ++++++++++++++++++ .../images/Identification_Threshold_Timer.xml | 43 ++++++++++++++++++ .../Identification_Threshold_UltrasonicCm.xml | 43 ++++++++++++++++++ ...ntification_Threshold_UltrasonicInches.xml | 43 ++++++++++++++++++ .../Identification_Threshold_Voltage_Out.xml | 43 ++++++++++++++++++ .../Identification_Threshold_Wattage.xml | 43 ++++++++++++++++++ .../Identification_Threshold_Wattage_Out.xml | 43 ++++++++++++++++++ legoresources/images/Identification_Time.png | Bin 0 -> 482 bytes legoresources/images/Identification_Timer.xml | 11 +++++ .../images/Identification_TimerID_0.png | Bin 0 -> 591 bytes .../images/Identification_TimerID_1.png | Bin 0 -> 630 bytes .../images/Identification_TimerID_2.png | Bin 0 -> 665 bytes .../images/Identification_TimerID_3.png | Bin 0 -> 615 bytes .../images/Identification_TimerID_4.png | Bin 0 -> 647 bytes .../images/Identification_TimerID_5.png | Bin 0 -> 651 bytes .../images/Identification_TimerID_6.png | Bin 0 -> 630 bytes .../images/Identification_TimerID_7.png | Bin 0 -> 654 bytes legoresources/images/Identification_Touch.png | Bin 0 -> 233 bytes .../images/Identification_TouchState.xml | 6 +++ .../Identification_TouchState2_Pressed.png | Bin 0 -> 235 bytes .../Identification_TouchState2_Released.png | Bin 0 -> 235 bytes .../Identification_TouchState_Bumped.png | Bin 0 -> 275 bytes .../Identification_TouchState_Pressed.png | Bin 0 -> 235 bytes .../Identification_TouchState_Released.png | Bin 0 -> 235 bytes .../images/Identification_TrueFalse.png | Bin 0 -> 458 bytes .../Identification_UltrasoundDetected.png | Bin 0 -> 532 bytes legoresources/images/Identification_Until.png | Bin 0 -> 475 bytes .../images/Identification_UpperBound.png | Bin 0 -> 364 bytes legoresources/images/Identification_Valid.png | Bin 0 -> 557 bytes legoresources/images/Identification_Value.png | Bin 0 -> 206 bytes .../images/Identification_Volume.xml | 8 ++++ .../images/Identification_Volume_0.png | Bin 0 -> 189 bytes .../images/Identification_Volume_100.png | Bin 0 -> 204 bytes .../images/Identification_Volume_25.png | Bin 0 -> 205 bytes .../images/Identification_Volume_50.png | Bin 0 -> 242 bytes .../images/Identification_Volume_75.png | Bin 0 -> 219 bytes .../images/Identification_WaitForChange.xml | 6 +++ .../Identification_WaitForChange_Both.png | Bin 0 -> 404 bytes .../Identification_WaitForChange_Down.png | Bin 0 -> 398 bytes .../Identification_WaitForChange_Up.png | Bin 0 -> 384 bytes legoresources/images/Identification_Width.png | Bin 0 -> 289 bytes legoresources/images/Identification_angle.png | Bin 0 -> 274 bytes legoresources/images/Identification_x.png | Bin 0 -> 332 bytes legoresources/images/Identification_x1.png | Bin 0 -> 380 bytes legoresources/images/Identification_x2.png | Bin 0 -> 435 bytes .../images/Identification_xColumn.png | Bin 0 -> 336 bytes legoresources/images/Identification_y.png | Bin 0 -> 327 bytes legoresources/images/Identification_y1.png | Bin 0 -> 360 bytes legoresources/images/Identification_y2.png | Bin 0 -> 475 bytes legoresources/images/Identification_yRow.png | Bin 0 -> 329 bytes legoresources/images/Intensity.png | Bin 0 -> 228 bytes legoresources/images/KeepAlive.png | Bin 0 -> 2093 bytes legoresources/images/LEGO_Add_Block.png | Bin 0 -> 1515 bytes legoresources/images/LEGO_Add_Palette.png | Bin 0 -> 3821 bytes .../images/LEGO_Arithmetic_Block.png | Bin 0 -> 1515 bytes .../images/LEGO_Data_Logger_Block.png | Bin 0 -> 2688 bytes legoresources/images/LEGO_Display_Block.png | Bin 0 -> 4239 bytes legoresources/images/LEGO_Display_Palette.png | Bin 0 -> 3436 bytes .../LEGO_Light_Sensor_ActivityPortClaim.png | Bin 0 -> 1711 bytes .../images/LEGO_Light_Sensor_Block.png | Bin 0 -> 3004 bytes .../LEGO_Light_Sensor_Compare_Block.png | Bin 0 -> 1606 bytes .../images/LEGO_Light_Sensor_Palette.png | Bin 0 -> 5091 bytes legoresources/images/LEGO_Motor_Block.png | Bin 0 -> 3205 bytes legoresources/images/LEGO_Move_Block.png | Bin 0 -> 6016 bytes .../LEGO_Play_Note_ActivityPortClaim.png | Bin 0 -> 1349 bytes legoresources/images/LEGO_Play_Note_Block.png | Bin 0 -> 2794 bytes .../images/LEGO_Play_Note_Palette.png | Bin 0 -> 4761 bytes .../images/LEGO_Play_Sound_File_Block.png | Bin 0 -> 2794 bytes legoresources/images/LEGO_Random_Block.png | Bin 0 -> 3004 bytes legoresources/images/LEGO_Random_Palette.png | Bin 0 -> 5003 bytes .../LEGO_Range_Sensor_ActivityPortClaim.png | Bin 0 -> 1319 bytes .../images/LEGO_Range_Sensor_Block.png | Bin 0 -> 2308 bytes .../images/LEGO_Range_Sensor_Palette.png | Bin 0 -> 4573 bytes legoresources/images/LEGO_Start_Block.png | Bin 0 -> 3537 bytes legoresources/images/LEGO_Start_Palette.png | Bin 0 -> 3537 bytes legoresources/images/LEGO_Stop_If_True.png | Bin 0 -> 3372 bytes .../LEGO_Touch_Sensor_ActivityPortClaim.png | Bin 0 -> 859 bytes .../images/LEGO_Touch_Sensor_Palette.png | Bin 0 -> 3884 bytes legoresources/images/LEGO_Variable_Block.png | Bin 0 -> 1231 bytes .../images/LEGO_Variable_Palette.png | Bin 0 -> 3686 bytes .../images/LEGO_Wait_For_Signal_Palette.png | Bin 0 -> 3860 bytes legoresources/images/LEGO_Wait_Icon.png | Bin 0 -> 1942 bytes legoresources/images/LEGO_Wait_Time_Block.png | Bin 0 -> 825 bytes .../images/LEGO_Wait_Touch_Block.png | Bin 0 -> 3884 bytes legoresources/images/LessEqualsIcon.png | Bin 0 -> 420 bytes legoresources/images/LessIcon.png | Bin 0 -> 403 bytes legoresources/images/LoopIcon.png | Bin 0 -> 5243 bytes legoresources/images/MinusIcon.png | Bin 0 -> 196 bytes legoresources/images/Mode_Light.png | Bin 0 -> 3254 bytes legoresources/images/Mode_Run_Forever.png | Bin 0 -> 3330 bytes legoresources/images/Mode_color.png | Bin 0 -> 508 bytes legoresources/images/Mode_display.png | Bin 0 -> 3193 bytes legoresources/images/MultiplyIcon.png | Bin 0 -> 349 bytes legoresources/images/NotEqualsIcon.png | Bin 0 -> 383 bytes legoresources/images/Palette_Loop.png | Bin 0 -> 4649 bytes legoresources/images/Palette_Loop_Hilight.png | Bin 0 -> 1759 bytes .../images/Palette_Loop_MouseOver.png | Bin 0 -> 4626 bytes legoresources/images/Palette_Start.png | Bin 0 -> 2885 bytes .../images/Palette_Start_Hilight.png | Bin 0 -> 934 bytes .../images/Palette_Start_MouseOver.png | Bin 0 -> 2873 bytes legoresources/images/Palette_Stop.png | Bin 0 -> 2792 bytes legoresources/images/Palette_Stop_Hilight.png | Bin 0 -> 829 bytes .../images/Palette_Stop_MouseOver.png | Bin 0 -> 2713 bytes legoresources/images/Palette_Switch.png | Bin 0 -> 4281 bytes .../images/Palette_Switch_Hilight.png | Bin 0 -> 1607 bytes .../images/Palette_Switch_MouseOver.png | Bin 0 -> 4233 bytes .../images/Palette_Tabbed_Switch.png | Bin 0 -> 3954 bytes .../images/Palette_Tabbed_Switch_Hilight.png | Bin 0 -> 1386 bytes .../Palette_Tabbed_Switch_MouseOver.png | Bin 0 -> 3932 bytes legoresources/images/PlayIcon.png | Bin 0 -> 331 bytes legoresources/images/PlusIcon.png | Bin 0 -> 259 bytes .../images/PolyGroup_Arithmetic_Diagram.png | Bin 0 -> 4219 bytes .../PolyGroup_ArrayOperations_Diagram.png | Bin 0 -> 3859 bytes ...Operations_Mode_Append_Boolean_Diagram.png | Bin 0 -> 433 bytes ..._Mode_Append_Boolean_Diagram_MouseOver.png | Bin 0 -> 393 bytes ...Operations_Mode_Append_Numeric_Diagram.png | Bin 0 -> 362 bytes ..._Mode_Append_Numeric_Diagram_MouseOver.png | Bin 0 -> 341 bytes ...Operations_Mode_Length_Boolean_Diagram.png | Bin 0 -> 484 bytes ..._Mode_Length_Boolean_Diagram_MouseOver.png | Bin 0 -> 402 bytes ...Operations_Mode_Length_Numeric_Diagram.png | Bin 0 -> 442 bytes ..._Mode_Length_Numeric_Diagram_MouseOver.png | Bin 0 -> 408 bytes ...tions_Mode_ReadAtIndex_Boolean_Diagram.png | Bin 0 -> 564 bytes ..._ReadAtIndex_Boolean_Diagram_MouseOver.png | Bin 0 -> 513 bytes ...tions_Mode_ReadAtIndex_Numeric_Diagram.png | Bin 0 -> 512 bytes ..._ReadAtIndex_Numeric_Diagram_MouseOver.png | Bin 0 -> 474 bytes ...ions_Mode_SplitAtIndex_Boolean_Diagram.png | Bin 0 -> 691 bytes ...SplitAtIndex_Boolean_Diagram_MouseOver.png | Bin 0 -> 540 bytes ...ions_Mode_SplitAtIndex_Numeric_Diagram.png | Bin 0 -> 642 bytes ...SplitAtIndex_Numeric_Diagram_MouseOver.png | Bin 0 -> 517 bytes ...ions_Mode_WriteAtIndex_Boolean_Diagram.png | Bin 0 -> 669 bytes ...WriteAtIndex_Boolean_Diagram_MouseOver.png | Bin 0 -> 559 bytes ...ions_Mode_WriteAtIndex_Numeric_Diagram.png | Bin 0 -> 610 bytes ...WriteAtIndex_Numeric_Diagram_MouseOver.png | Bin 0 -> 546 bytes .../PolyGroup_ArrayOperations_Palette.png | Bin 0 -> 979 bytes ...roup_ArrayOperations_Palette_MouseOver.png | Bin 0 -> 944 bytes ...up_ArrayOperations_PolyCategory_Append.png | Bin 0 -> 218 bytes ...Operations_PolyCategory_Append_Diagram.png | Bin 0 -> 218 bytes ...erations_PolyCategory_Append_MouseOver.png | Bin 0 -> 200 bytes ...up_ArrayOperations_PolyCategory_Length.png | Bin 0 -> 3010 bytes ...erations_PolyCategory_Length_MouseOver.png | Bin 0 -> 2962 bytes ...rayOperations_PolyCategory_ReadAtIndex.png | Bin 0 -> 415 bytes ...ons_PolyCategory_ReadAtIndex_MouseOver.png | Bin 0 -> 364 bytes ...ayOperations_PolyCategory_SplitAtIndex.png | Bin 0 -> 510 bytes ...ns_PolyCategory_SplitAtIndex_MouseOver.png | Bin 0 -> 3120 bytes ...ayOperations_PolyCategory_WriteAtIndex.png | Bin 0 -> 491 bytes ...ns_PolyCategory_WriteAtIndex_MouseOver.png | Bin 0 -> 461 bytes .../images/PolyGroup_Bluetooth_Diagram.png | Bin 0 -> 5350 bytes ...PolyGroup_Bluetooth_Mode_Clear_Diagram.png | Bin 0 -> 229 bytes ...Bluetooth_Mode_Clear_Diagram_MouseOver.png | Bin 0 -> 206 bytes ...yGroup_Bluetooth_Mode_Initiate_Diagram.png | Bin 0 -> 679 bytes ...etooth_Mode_Initiate_Diagram_MouseOver.png | Bin 0 -> 477 bytes .../PolyGroup_Bluetooth_Mode_Off_Diagram.png | Bin 0 -> 565 bytes ...p_Bluetooth_Mode_Off_Diagram_MouseOver.png | Bin 0 -> 472 bytes .../PolyGroup_Bluetooth_Mode_On_Diagram.png | Bin 0 -> 549 bytes ...up_Bluetooth_Mode_On_Diagram_MouseOver.png | Bin 0 -> 408 bytes .../images/PolyGroup_Bluetooth_Palette.png | Bin 0 -> 4546 bytes .../PolyGroup_Bluetooth_Palette_MouseOver.png | Bin 0 -> 1816 bytes .../PolyGroup_BooleanOperations_Diagram.png | Bin 0 -> 4034 bytes ...oup_BooleanOperations_Mode_And_Diagram.png | Bin 0 -> 589 bytes ...nOperations_Mode_And_Diagram_MouseOver.png | Bin 0 -> 530 bytes ...oup_BooleanOperations_Mode_Not_Diagram.png | Bin 0 -> 460 bytes ...nOperations_Mode_Not_Diagram_MouseOver.png | Bin 0 -> 395 bytes ...roup_BooleanOperations_Mode_Or_Diagram.png | Bin 0 -> 3309 bytes ...anOperations_Mode_Or_Diagram_MouseOver.png | Bin 0 -> 3289 bytes ...oup_BooleanOperations_Mode_XOR_Diagram.png | Bin 0 -> 878 bytes ...nOperations_Mode_XOR_Diagram_MouseOver.png | Bin 0 -> 924 bytes .../PolyGroup_BooleanOperations_Palette.png | Bin 0 -> 3940 bytes ...up_BooleanOperations_Palette_MouseOver.png | Bin 0 -> 1236 bytes .../images/PolyGroup_BrickButton_Category.png | Bin 0 -> 339 bytes ...lyGroup_BrickButton_Category_MouseOver.png | Bin 0 -> 303 bytes .../images/PolyGroup_BrickButton_Diagram.png | Bin 0 -> 5373 bytes ...kButton_Mode_ChangeBrickButton_Diagram.png | Bin 0 -> 493 bytes ...de_ChangeBrickButton_Diagram_MouseOver.png | Bin 0 -> 443 bytes ...Group_BrickButton_Mode_Compare_Diagram.png | Bin 0 -> 508 bytes ...kButton_Mode_Compare_Diagram_MouseOver.png | Bin 0 -> 465 bytes ...Group_BrickButton_Mode_Measure_Diagram.png | Bin 0 -> 340 bytes ...kButton_Mode_Measure_Diagram_MouseOver.png | Bin 0 -> 303 bytes .../images/PolyGroup_BrickButton_Palette.png | Bin 0 -> 1213 bytes ...olyGroup_BrickButton_Palette_MouseOver.png | Bin 0 -> 1221 bytes .../images/PolyGroup_ButtonSensor_Diagram.png | Bin 0 -> 5373 bytes .../images/PolyGroup_ButtonSensor_Palette.png | Bin 0 -> 1213 bytes .../images/PolyGroup_CaseSelector_Diagram.png | Bin 0 -> 1036 bytes ...roup_CaseSelector_Mode_Boolean_Diagram.png | Bin 0 -> 457 bytes ...elector_Mode_Boolean_Diagram_MouseOver.png | Bin 0 -> 368 bytes ...roup_CaseSelector_Mode_Numeric_Diagram.png | Bin 0 -> 304 bytes ...elector_Mode_Numeric_Diagram_MouseOver.png | Bin 0 -> 279 bytes ...Group_CaseSelector_Mode_String_Diagram.png | Bin 0 -> 246 bytes ...Selector_Mode_String_Diagram_MouseOver.png | Bin 0 -> 237 bytes .../images/PolyGroup_ColorLamp_Diagram.png | Bin 0 -> 3717 bytes .../images/PolyGroup_ColorSensor_Category.png | Bin 0 -> 396 bytes ...lyGroup_ColorSensor_Category_MouseOver.png | Bin 0 -> 376 bytes .../images/PolyGroup_ColorSensor_Diagram.png | Bin 0 -> 2006 bytes ...rSensor_Mode_CalibrateMaxColor_Diagram.png | Bin 0 -> 243 bytes ...de_CalibrateMaxColor_Diagram_MouseOver.png | Bin 0 -> 229 bytes ...rSensor_Mode_CalibrateMinColor_Diagram.png | Bin 0 -> 237 bytes ...de_CalibrateMinColor_Diagram_MouseOver.png | Bin 0 -> 221 bytes ...ensor_Mode_CalibrateResetColor_Diagram.png | Bin 0 -> 270 bytes ..._CalibrateResetColor_Diagram_MouseOver.png | Bin 0 -> 265 bytes ...Sensor_Mode_ChangeAmbientLight_Diagram.png | Bin 0 -> 552 bytes ...e_ChangeAmbientLight_Diagram_MouseOver.png | Bin 0 -> 427 bytes ...p_ColorSensor_Mode_ChangeColor_Diagram.png | Bin 0 -> 672 bytes ...sor_Mode_ChangeColor_Diagram_MouseOver.png | Bin 0 -> 595 bytes ...nsor_Mode_ChangeReflectedLight_Diagram.png | Bin 0 -> 624 bytes ...ChangeReflectedLight_Diagram_MouseOver.png | Bin 0 -> 486 bytes ...ensor_Mode_CompareAmbientLight_Diagram.png | Bin 0 -> 564 bytes ..._CompareAmbientLight_Diagram_MouseOver.png | Bin 0 -> 467 bytes ..._ColorSensor_Mode_CompareColor_Diagram.png | Bin 0 -> 698 bytes ...or_Mode_CompareColor_Diagram_MouseOver.png | Bin 0 -> 618 bytes ...sor_Mode_CompareReflectedLight_Diagram.png | Bin 0 -> 706 bytes ...ompareReflectedLight_Diagram_MouseOver.png | Bin 0 -> 541 bytes ...ensor_Mode_MeasureAmbientLight_Diagram.png | Bin 0 -> 516 bytes ..._MeasureAmbientLight_Diagram_MouseOver.png | Bin 0 -> 446 bytes ...nsor_Mode_MeasureAmbientLight_Hardware.png | Bin 0 -> 338 bytes ...MeasureAmbientLight_Hardware_MouseOver.png | Bin 0 -> 286 bytes ..._ColorSensor_Mode_MeasureColor_Diagram.png | Bin 0 -> 627 bytes ...or_Mode_MeasureColor_Diagram_MouseOver.png | Bin 0 -> 582 bytes ...ColorSensor_Mode_MeasureColor_Hardware.png | Bin 0 -> 432 bytes ...r_Mode_MeasureColor_Hardware_MouseOver.png | Bin 0 -> 443 bytes ...sor_Mode_MeasureReflectedLight_Diagram.png | Bin 0 -> 645 bytes ...easureReflectedLight_Diagram_MouseOver.png | Bin 0 -> 478 bytes ...or_Mode_MeasureReflectedLight_Hardware.png | Bin 0 -> 435 bytes ...asureReflectedLight_Hardware_MouseOver.png | Bin 0 -> 364 bytes .../images/PolyGroup_ColorSensor_Palette.png | Bin 0 -> 1708 bytes ...olyGroup_ColorSensor_Palette_MouseOver.png | Bin 0 -> 1719 bytes ...oup_ColorSensor_PolyCategory_Calibrate.png | Bin 0 -> 562 bytes ...ensor_PolyCategory_Calibrate_MouseOver.png | Bin 0 -> 491 bytes ..._PolyCategory_ReflectedLight@Calibrate.png | Bin 0 -> 826 bytes ...ory_ReflectedLight@Calibrate_MouseOver.png | Bin 0 -> 632 bytes .../images/PolyGroup_CommentBlock_Diagram.png | Bin 0 -> 626 bytes .../images/PolyGroup_CommentBlock_Palette.png | Bin 0 -> 3274 bytes ...lyGroup_CommentBlock_Palette_MouseOver.png | Bin 0 -> 581 bytes .../images/PolyGroup_Compare_Diagram.png | Bin 0 -> 4356 bytes .../PolyGroup_Compare_Mode_Equal_Diagram.png | Bin 0 -> 183 bytes ...p_Compare_Mode_Equal_Diagram_MouseOver.png | Bin 0 -> 176 bytes ...up_Compare_Mode_GreaterOrEqual_Diagram.png | Bin 0 -> 300 bytes ..._Mode_GreaterOrEqual_Diagram_MouseOver.png | Bin 0 -> 294 bytes ...Group_Compare_Mode_GreaterThan_Diagram.png | Bin 0 -> 289 bytes ...are_Mode_GreaterThan_Diagram_MouseOver.png | Bin 0 -> 279 bytes ...Group_Compare_Mode_LessOrEqual_Diagram.png | Bin 0 -> 294 bytes ...are_Mode_LessOrEqual_Diagram_MouseOver.png | Bin 0 -> 291 bytes ...olyGroup_Compare_Mode_LessThan_Diagram.png | Bin 0 -> 283 bytes ...ompare_Mode_LessThan_Diagram_MouseOver.png | Bin 0 -> 282 bytes ...olyGroup_Compare_Mode_NotEqual_Diagram.png | Bin 0 -> 265 bytes ...ompare_Mode_NotEqual_Diagram_MouseOver.png | Bin 0 -> 250 bytes .../images/PolyGroup_Compare_Palette.png | Bin 0 -> 1483 bytes .../PolyGroup_Compare_Palette_MouseOver.png | Bin 0 -> 1442 bytes .../images/PolyGroup_Constant_Diagram.png | Bin 0 -> 4306 bytes ...oup_Constant_Mode_BooleanArray_Diagram.png | Bin 0 -> 529 bytes ...nt_Mode_BooleanArray_Diagram_MouseOver.png | Bin 0 -> 487 bytes ...olyGroup_Constant_Mode_Boolean_Diagram.png | Bin 0 -> 539 bytes ...onstant_Mode_Boolean_Diagram_MouseOver.png | Bin 0 -> 506 bytes ...oup_Constant_Mode_NumericArray_Diagram.png | Bin 0 -> 486 bytes ...nt_Mode_NumericArray_Diagram_MouseOver.png | Bin 0 -> 430 bytes ...olyGroup_Constant_Mode_Numeric_Diagram.png | Bin 0 -> 423 bytes ...onstant_Mode_Numeric_Diagram_MouseOver.png | Bin 0 -> 434 bytes .../PolyGroup_Constant_Mode_Text_Diagram.png | Bin 0 -> 370 bytes ...p_Constant_Mode_Text_Diagram_MouseOver.png | Bin 0 -> 365 bytes .../images/PolyGroup_Constant_Palette.png | Bin 0 -> 1366 bytes .../PolyGroup_Constant_Palette_MouseOver.png | Bin 0 -> 1386 bytes ...s_Mode_AppendNumeric_Diagram_MouseOver.png | Bin 0 -> 341 bytes .../images/PolyGroup_Datalogging_Diagram.png | Bin 0 -> 3795 bytes ...talogging_Mode_OnForTimeMinute_Diagram.png | Bin 0 -> 632 bytes ...Mode_OnForTimeMinute_Diagram_MouseOver.png | Bin 0 -> 536 bytes ...alogging_Mode_OnForTimeSeconds_Diagram.png | Bin 0 -> 590 bytes ...ode_OnForTimeSeconds_Diagram_MouseOver.png | Bin 0 -> 489 bytes .../PolyGroup_Datalogging_Mode_On_Diagram.png | Bin 0 -> 429 bytes ..._Datalogging_Mode_On_Diagram_MouseOver.png | Bin 0 -> 391 bytes ...logging_Mode_SingleMeasurement_Diagram.png | Bin 0 -> 479 bytes ...de_SingleMeasurement_Diagram_MouseOver.png | Bin 0 -> 411 bytes ...olyGroup_Datalogging_Mode_Stop_Diagram.png | Bin 0 -> 2909 bytes ...atalogging_Mode_Stop_Diagram_MouseOver.png | Bin 0 -> 189 bytes .../images/PolyGroup_Datalogging_Palette.png | Bin 0 -> 1152 bytes ...olyGroup_Datalogging_Palette_MouseOver.png | Bin 0 -> 1146 bytes ...oup_Datalogging_PolyCategory_OnForTime.png | Bin 0 -> 3512 bytes ...gging_PolyCategory_OnForTime_Mouseover.png | Bin 0 -> 3353 bytes .../images/PolyGroup_Display_Diagram.png | Bin 0 -> 4239 bytes .../images/PolyGroup_Display_Hardware.png | Bin 0 -> 3941 bytes .../PolyGroup_Display_Mode_Circle_Diagram.png | Bin 0 -> 455 bytes ..._Display_Mode_Circle_Diagram_MouseOver.png | Bin 0 -> 383 bytes .../PolyGroup_Display_Mode_Clear_Diagram.png | Bin 0 -> 270 bytes ...p_Display_Mode_Clear_Diagram_MouseOver.png | Bin 0 -> 265 bytes .../PolyGroup_Display_Mode_File_Diagram.png | Bin 0 -> 295 bytes ...up_Display_Mode_File_Diagram_MouseOver.png | Bin 0 -> 293 bytes .../PolyGroup_Display_Mode_Line_Diagram.png | Bin 0 -> 397 bytes ...up_Display_Mode_Line_Diagram_MouseOver.png | Bin 0 -> 336 bytes .../PolyGroup_Display_Mode_Point_Diagram.png | Bin 0 -> 183 bytes ...p_Display_Mode_Point_Diagram_MouseOver.png | Bin 0 -> 176 bytes ...lyGroup_Display_Mode_Rectangle_Diagram.png | Bin 0 -> 209 bytes ...splay_Mode_Rectangle_Diagram_MouseOver.png | Bin 0 -> 203 bytes ...yGroup_Display_Mode_StringGrid_Diagram.png | Bin 0 -> 315 bytes ...play_Mode_StringGrid_Diagram_MouseOver.png | Bin 0 -> 298 bytes .../PolyGroup_Display_Mode_String_Diagram.png | Bin 0 -> 333 bytes ..._Display_Mode_String_Diagram_MouseOver.png | Bin 0 -> 324 bytes .../images/PolyGroup_Display_Palette.png | Bin 0 -> 3941 bytes .../PolyGroup_Display_Palette_MouseOver.png | Bin 0 -> 1237 bytes .../PolyGroup_Display_PolyCategory_Shapes.png | Bin 0 -> 502 bytes ..._Display_PolyCategory_Shapes_MouseOver.png | Bin 0 -> 409 bytes .../PolyGroup_Display_PolyCategory_Text.png | Bin 0 -> 3027 bytes ...up_Display_PolyCategory_Text_MouseOver.png | Bin 0 -> 3020 bytes .../PolyGroup_DistanceSensor_Diagram.png | Bin 0 -> 5271 bytes .../images/PolyGroup_EMeterSensor_Diagram.png | Bin 0 -> 4375 bytes .../images/PolyGroup_EMeterSensor_Palette.png | Bin 0 -> 1364 bytes .../images/PolyGroup_EnergyMeter_Category.png | Bin 0 -> 235 bytes ...lyGroup_EnergyMeter_Category_MouseOver.png | Bin 0 -> 221 bytes .../images/PolyGroup_EnergyMeter_Diagram.png | Bin 0 -> 2035 bytes ...ergyMeter_Mode_ChangeInCurrent_Diagram.png | Bin 0 -> 629 bytes ...Mode_ChangeInCurrent_Diagram_MouseOver.png | Bin 0 -> 506 bytes ...ergyMeter_Mode_ChangeInVoltage_Diagram.png | Bin 0 -> 632 bytes ...Mode_ChangeInVoltage_Diagram_MouseOver.png | Bin 0 -> 499 bytes ..._EnergyMeter_Mode_ChangeInWatt_Diagram.png | Bin 0 -> 651 bytes ...er_Mode_ChangeInWatt_Diagram_MouseOver.png | Bin 0 -> 544 bytes ...p_EnergyMeter_Mode_ChangeJoule_Diagram.png | Bin 0 -> 610 bytes ...ter_Mode_ChangeJoule_Diagram_MouseOver.png | Bin 0 -> 470 bytes ...rgyMeter_Mode_ChangeOutCurrent_Diagram.png | Bin 0 -> 626 bytes ...ode_ChangeOutCurrent_Diagram_MouseOver.png | Bin 0 -> 503 bytes ...rgyMeter_Mode_ChangeOutVoltage_Diagram.png | Bin 0 -> 632 bytes ...ode_ChangeOutVoltage_Diagram_MouseOver.png | Bin 0 -> 513 bytes ...EnergyMeter_Mode_ChangeOutWatt_Diagram.png | Bin 0 -> 658 bytes ...r_Mode_ChangeOutWatt_Diagram_MouseOver.png | Bin 0 -> 541 bytes ...rgyMeter_Mode_CompareInCurrent_Diagram.png | Bin 0 -> 658 bytes ...ode_CompareInCurrent_Diagram_MouseOver.png | Bin 0 -> 543 bytes ...rgyMeter_Mode_CompareInVoltage_Diagram.png | Bin 0 -> 656 bytes ...ode_CompareInVoltage_Diagram_MouseOver.png | Bin 0 -> 526 bytes ...EnergyMeter_Mode_CompareInWatt_Diagram.png | Bin 0 -> 676 bytes ...r_Mode_CompareInWatt_Diagram_MouseOver.png | Bin 0 -> 555 bytes ...gyMeter_Mode_CompareOutCurrent_Diagram.png | Bin 0 -> 665 bytes ...de_CompareOutCurrent_Diagram_MouseOver.png | Bin 0 -> 508 bytes ...ergyMeter_Mode_CompareOutJoule_Diagram.png | Bin 0 -> 667 bytes ...Mode_CompareOutJoule_Diagram_MouseOver.png | Bin 0 -> 538 bytes ...gyMeter_Mode_CompareOutVoltage_Diagram.png | Bin 0 -> 662 bytes ...de_CompareOutVoltage_Diagram_MouseOver.png | Bin 0 -> 523 bytes ...nergyMeter_Mode_CompareOutWatt_Diagram.png | Bin 0 -> 695 bytes ..._Mode_CompareOutWatt_Diagram_MouseOver.png | Bin 0 -> 566 bytes ...rgyMeter_Mode_MeasureInCurrent_Diagram.png | Bin 0 -> 593 bytes ...ode_MeasureInCurrent_Diagram_MouseOver.png | Bin 0 -> 490 bytes ...gyMeter_Mode_MeasureInCurrent_Hardware.png | Bin 0 -> 441 bytes ...de_MeasureInCurrent_Hardware_MouseOver.png | Bin 0 -> 368 bytes ...rgyMeter_Mode_MeasureInVoltage_Diagram.png | Bin 0 -> 590 bytes ...ode_MeasureInVoltage_Diagram_MouseOver.png | Bin 0 -> 458 bytes ...gyMeter_Mode_MeasureInVoltage_Hardware.png | Bin 0 -> 451 bytes ...de_MeasureInVoltage_Hardware_MouseOver.png | Bin 0 -> 366 bytes ...nergyMeter_Mode_MeasureInWatts_Diagram.png | Bin 0 -> 610 bytes ..._Mode_MeasureInWatts_Diagram_MouseOver.png | Bin 0 -> 506 bytes ...ergyMeter_Mode_MeasureInWatts_Hardware.png | Bin 0 -> 452 bytes ...Mode_MeasureInWatts_Hardware_MouseOver.png | Bin 0 -> 412 bytes ..._EnergyMeter_Mode_MeasureJoule_Diagram.png | Bin 0 -> 577 bytes ...er_Mode_MeasureJoule_Diagram_MouseOver.png | Bin 0 -> 453 bytes ...EnergyMeter_Mode_MeasureJoule_Hardware.png | Bin 0 -> 396 bytes ...r_Mode_MeasureJoule_Hardware_MouseOver.png | Bin 0 -> 329 bytes ...gyMeter_Mode_MeasureOutCurrent_Diagram.png | Bin 0 -> 581 bytes ...de_MeasureOutCurrent_Diagram_MouseOver.png | Bin 0 -> 470 bytes ...yMeter_Mode_MeasureOutCurrent_Hardware.png | Bin 0 -> 464 bytes ...e_MeasureOutCurrent_Hardware_MouseOver.png | Bin 0 -> 376 bytes ...nergyMeter_Mode_MeasureOutVolt_Diagram.png | Bin 0 -> 479 bytes ...gyMeter_Mode_MeasureOutVoltage_Diagram.png | Bin 0 -> 594 bytes ...de_MeasureOutVoltage_Diagram_MouseOver.png | Bin 0 -> 459 bytes ...yMeter_Mode_MeasureOutVoltage_Hardware.png | Bin 0 -> 451 bytes ...e_MeasureOutVoltage_Hardware_MouseOver.png | Bin 0 -> 386 bytes ...ergyMeter_Mode_MeasureOutWatts_Diagram.png | Bin 0 -> 613 bytes ...Mode_MeasureOutWatts_Diagram_MouseOver.png | Bin 0 -> 486 bytes ...rgyMeter_Mode_MeasureOutWatts_Hardware.png | Bin 0 -> 480 bytes ...ode_MeasureOutWatts_Hardware_MouseOver.png | Bin 0 -> 403 bytes .../images/PolyGroup_EnergyMeter_Palette.png | Bin 0 -> 1324 bytes ...olyGroup_EnergyMeter_Palette_MouseOver.png | Bin 0 -> 1287 bytes .../images/PolyGroup_FileAccess_Diagram.png | Bin 0 -> 4918 bytes ...olyGroup_FileAccess_Mode_Close_Diagram.png | Bin 0 -> 311 bytes ...ileAccess_Mode_Close_Diagram_MouseOver.png | Bin 0 -> 286 bytes ...lyGroup_FileAccess_Mode_Delete_Diagram.png | Bin 0 -> 229 bytes ...leAccess_Mode_Delete_Diagram_MouseOver.png | Bin 0 -> 206 bytes ...yGroup_FileAccess_Mode_Numeric_Diagram.png | Bin 0 -> 423 bytes ...eAccess_Mode_Numeric_Diagram_MouseOver.png | Bin 0 -> 434 bytes ...PolyGroup_FileAccess_Mode_Text_Diagram.png | Bin 0 -> 370 bytes ...FileAccess_Mode_Text_Diagram_MouseOver.png | Bin 0 -> 365 bytes ...olyGroup_FileAccess_Mode_Write_Diagram.png | Bin 0 -> 433 bytes ...ileAccess_Mode_Write_Diagram_MouseOver.png | Bin 0 -> 392 bytes .../images/PolyGroup_FileAccess_Palette.png | Bin 0 -> 4176 bytes ...PolyGroup_FileAccess_Palette_MouseOver.png | Bin 0 -> 1468 bytes ...PolyGroup_FileAccess_PolyCategory_Read.png | Bin 0 -> 311 bytes ...FileAccess_PolyCategory_Read_MouseOver.png | Bin 0 -> 296 bytes .../images/PolyGroup_Gyro_Category.png | Bin 0 -> 386 bytes .../PolyGroup_Gyro_Category_MouseOver.png | Bin 0 -> 354 bytes .../images/PolyGroup_Gyro_Diagram.png | Bin 0 -> 2141 bytes ...olyGroup_Gyro_Mode_ChangeAngle_Diagram.png | Bin 0 -> 507 bytes ...yro_Mode_ChangeAngle_Diagram_MouseOver.png | Bin 0 -> 424 bytes ...PolyGroup_Gyro_Mode_ChangeRate_Diagram.png | Bin 0 -> 541 bytes ...Gyro_Mode_ChangeRate_Diagram_MouseOver.png | Bin 0 -> 454 bytes ...lyGroup_Gyro_Mode_CompareAngle_Diagram.png | Bin 0 -> 516 bytes ...ro_Mode_CompareAngle_Diagram_MouseOver.png | Bin 0 -> 422 bytes ...olyGroup_Gyro_Mode_CompareRate_Diagram.png | Bin 0 -> 547 bytes ...yro_Mode_CompareRate_Diagram_MouseOver.png | Bin 0 -> 470 bytes .../PolyGroup_Gyro_Mode_MeasureAngle.png | Bin 0 -> 462 bytes ..._Gyro_Mode_MeasureAngleAndRate_Diagram.png | Bin 0 -> 578 bytes ..._MeasureAngleAndRate_Diagram_MouseOver.png | Bin 0 -> 511 bytes ...lyGroup_Gyro_Mode_MeasureAngle_Diagram.png | Bin 0 -> 462 bytes ...ro_Mode_MeasureAngle_Diagram_MouseOver.png | Bin 0 -> 417 bytes ...yGroup_Gyro_Mode_MeasureAngle_Hardware.png | Bin 0 -> 272 bytes ...o_Mode_MeasureAngle_Hardware_MouseOver.png | Bin 0 -> 253 bytes ...Group_Gyro_Mode_MeasureAngle_MouseOver.png | Bin 0 -> 417 bytes ...olyGroup_Gyro_Mode_MeasureRate_Diagram.png | Bin 0 -> 474 bytes ...yro_Mode_MeasureRate_Diagram_MouseOver.png | Bin 0 -> 411 bytes ...lyGroup_Gyro_Mode_MeasureRate_Hardware.png | Bin 0 -> 336 bytes ...ro_Mode_MeasureRate_Hardware_MouseOver.png | Bin 0 -> 315 bytes .../PolyGroup_Gyro_Mode_Reset_Diagram.png | Bin 0 -> 270 bytes ...roup_Gyro_Mode_Reset_Diagram_MouseOver.png | Bin 0 -> 265 bytes .../images/PolyGroup_Gyro_Palette.png | Bin 0 -> 1470 bytes .../PolyGroup_Gyro_Palette_MouseOver.png | Bin 0 -> 1472 bytes ...p_HWPageManualInput_Mode_Blank_Diagram.png | Bin 0 -> 160 bytes ...nualInput_Mode_Blank_Diagram_MouseOver.png | Bin 0 -> 160 bytes ..._HWPageManualOutput_Mode_Blank_Diagram.png | Bin 0 -> 160 bytes ...ualOutput_Mode_Blank_Diagram_MouseOver.png | Bin 0 -> 160 bytes .../images/PolyGroup_IICSensor_Category.png | Bin 0 -> 305 bytes ...PolyGroup_IICSensor_Category_Mouseover.png | Bin 0 -> 266 bytes .../images/PolyGroup_IICSensor_Diagram.png | Bin 0 -> 3119 bytes ...yGroup_IICSensor_Mode_IICByte_Hardware.png | Bin 0 -> 427 bytes ...Sensor_Mode_IICByte_Hardware_Mouseover.png | Bin 0 -> 390 bytes ...yGroup_IICSensor_Mode_IICWord_Hardware.png | Bin 0 -> 496 bytes ...Sensor_Mode_IICWord_Hardware_Mouseover.png | Bin 0 -> 464 bytes .../PolyGroup_InfraredSensor_Category.png | Bin 0 -> 423 bytes ...roup_InfraredSensor_Category_MouseOver.png | Bin 0 -> 402 bytes .../PolyGroup_InfraredSensor_Diagram.png | Bin 0 -> 2363 bytes ...sor_Mode_ChangeBeaconProximity_Diagram.png | Bin 0 -> 482 bytes ...hangeBeaconProximity_Diagram_MouseOver.png | Bin 0 -> 402 bytes ...raredSensor_Mode_ChangeHeading_Diagram.png | Bin 0 -> 624 bytes ...r_Mode_ChangeHeading_Diagram_MouseOver.png | Bin 0 -> 513 bytes ...redSensor_Mode_ChangeProximity_Diagram.png | Bin 0 -> 560 bytes ...Mode_ChangeProximity_Diagram_MouseOver.png | Bin 0 -> 453 bytes ...fraredSensor_Mode_ChangeRemote_Diagram.png | Bin 0 -> 466 bytes ...or_Mode_ChangeRemote_Diagram_MouseOver.png | Bin 0 -> 415 bytes ...ode_CompareBeaconSeekerHeading_Diagram.png | Bin 0 -> 644 bytes ...eBeaconSeekerHeading_Diagram_MouseOver.png | Bin 0 -> 522 bytes ...e_CompareBeaconSeekerProximity_Diagram.png | Bin 0 -> 503 bytes ...eaconSeekerProximity_Diagram_MouseOver.png | Bin 0 -> 443 bytes ...edSensor_Mode_CompareProximity_Diagram.png | Bin 0 -> 578 bytes ...ode_CompareProximity_Diagram_MouseOver.png | Bin 0 -> 470 bytes ...raredSensor_Mode_CompareRemote_Diagram.png | Bin 0 -> 491 bytes ...r_Mode_CompareRemote_Diagram_MouseOver.png | Bin 0 -> 418 bytes ...ensor_Mode_MeasureBeaconRemote_Diagram.png | Bin 0 -> 428 bytes ..._MeasureBeaconRemote_Diagram_MouseOver.png | Bin 0 -> 387 bytes ...nsor_Mode_MeasureBeaconRemote_Hardware.png | Bin 0 -> 255 bytes ...MeasureBeaconRemote_Hardware_MouseOver.png | Bin 0 -> 204 bytes ...BeaconSeekerDataloggingHeading_Diagram.png | Bin 0 -> 630 bytes ...erDataloggingHeading_Diagram_MouseOver.png | Bin 0 -> 513 bytes ...eaconSeekerDataloggingHeading_Hardware.png | Bin 0 -> 449 bytes ...rDataloggingHeading_Hardware_MouseOver.png | Bin 0 -> 384 bytes ...aconSeekerDataloggingProximity_Diagram.png | Bin 0 -> 439 bytes ...DataloggingProximity_Diagram_MouseOver.png | Bin 0 -> 355 bytes ...conSeekerDataloggingProximity_Hardware.png | Bin 0 -> 251 bytes ...ataloggingProximity_Hardware_MouseOver.png | Bin 0 -> 232 bytes ...ensor_Mode_MeasureBeaconSeeker_Diagram.png | Bin 0 -> 479 bytes ..._MeasureBeaconSeeker_Diagram_MouseOver.png | Bin 0 -> 430 bytes ...edSensor_Mode_MeasureProximity_Diagram.png | Bin 0 -> 517 bytes ...ode_MeasureProximity_Diagram_MouseOver.png | Bin 0 -> 450 bytes ...dSensor_Mode_MeasureProximity_Hardware.png | Bin 0 -> 321 bytes ...de_MeasureProximity_Hardware_MouseOver.png | Bin 0 -> 317 bytes .../PolyGroup_InfraredSensor_Palette.png | Bin 0 -> 1542 bytes ...Group_InfraredSensor_Palette_MouseOver.png | Bin 0 -> 1565 bytes ...Group_Interrupt_Mode_Interrupt_Diagram.png | Bin 0 -> 641 bytes ...rrupt_Mode_Interrupt_Diagram_MouseOver.png | Bin 0 -> 478 bytes .../images/PolyGroup_InvertMotor_Diagram.png | Bin 0 -> 2560 bytes ...yGroup_InvertMotor_Mode_Invert_Diagram.png | Bin 0 -> 493 bytes ...ertMotor_Mode_Invert_Diagram_MouseOver.png | Bin 0 -> 384 bytes .../images/PolyGroup_InvertMotor_Palette.png | Bin 0 -> 1687 bytes ...olyGroup_InvertMotor_Palette_MouseOver.png | Bin 0 -> 1674 bytes .../images/PolyGroup_KeepAlive_Diagram.png | Bin 0 -> 4983 bytes ...Group_KeepAlive_Mode_KeepAlive_Diagram.png | Bin 0 -> 617 bytes ...Alive_Mode_KeepAlive_Diagram_MouseOver.png | Bin 0 -> 522 bytes .../images/PolyGroup_KeepAlive_Palette.png | Bin 0 -> 1997 bytes .../PolyGroup_KeepAlive_Palette_MouseOver.png | Bin 0 -> 2009 bytes .../images/PolyGroup_LED_Diagram.png | Bin 0 -> 4863 bytes .../images/PolyGroup_LED_Hardware.png | Bin 0 -> 4751 bytes legoresources/images/PolyGroup_LED_Help.png | Bin 0 -> 8946 bytes .../images/PolyGroup_LED_Mode_Off_Diagram.png | Bin 0 -> 338 bytes ...lyGroup_LED_Mode_Off_Diagram_MouseOver.png | Bin 0 -> 322 bytes .../images/PolyGroup_LED_Mode_On_Diagram.png | Bin 0 -> 474 bytes ...olyGroup_LED_Mode_On_Diagram_MouseOver.png | Bin 0 -> 412 bytes .../PolyGroup_LED_Mode_Reset_Diagram.png | Bin 0 -> 270 bytes ...Group_LED_Mode_Reset_Diagram_MouseOver.png | Bin 0 -> 265 bytes .../images/PolyGroup_LED_Palette.png | Bin 0 -> 4751 bytes .../PolyGroup_LED_Palette_MouseOver.png | Bin 0 -> 1527 bytes .../images/PolyGroup_LightSensor_Diagram.png | Bin 0 -> 3717 bytes .../images/PolyGroup_LightSensor_Palette.png | Bin 0 -> 1649 bytes ...olyGroup_LightSensor_Palette_MouseOver.png | Bin 0 -> 1649 bytes .../PolyGroup_LoopCondition_Diagram.png | Bin 0 -> 933 bytes ...oup_LoopCondition_Mode_Boolean_Diagram.png | Bin 0 -> 457 bytes ...ndition_Mode_Boolean_Diagram_MouseOver.png | Bin 0 -> 368 bytes ...Group_LoopCondition_Mode_Count_Diagram.png | Bin 0 -> 377 bytes ...Condition_Mode_Count_Diagram_MouseOver.png | Bin 0 -> 354 bytes ...yGroup_LoopCondition_Mode_Time_Diagram.png | Bin 0 -> 552 bytes ...pCondition_Mode_Time_Diagram_MouseOver.png | Bin 0 -> 574 bytes ...p_LoopCondition_Mode_Unlimited_Diagram.png | Bin 0 -> 463 bytes ...ition_Mode_Unlimited_Diagram_MouseOver.png | Bin 0 -> 391 bytes .../images/PolyGroup_Math_Diagram.png | Bin 0 -> 4219 bytes ...yGroup_Math_Mode_AbsoluteValue_Diagram.png | Bin 0 -> 425 bytes ...h_Mode_AbsoluteValue_Diagram_MouseOver.png | Bin 0 -> 385 bytes .../PolyGroup_Math_Mode_Add_Diagram.png | Bin 0 -> 195 bytes ...yGroup_Math_Mode_Add_Diagram_MouseOver.png | Bin 0 -> 187 bytes .../PolyGroup_Math_Mode_Advanced_Diagram.png | Bin 0 -> 433 bytes ...p_Math_Mode_Advanced_Diagram_MouseOver.png | Bin 0 -> 390 bytes .../PolyGroup_Math_Mode_Divide_Diagram.png | Bin 0 -> 246 bytes ...oup_Math_Mode_Divide_Diagram_MouseOver.png | Bin 0 -> 232 bytes .../PolyGroup_Math_Mode_Exponent_Diagram.png | Bin 0 -> 318 bytes ...p_Math_Mode_Exponent_Diagram_MouseOver.png | Bin 0 -> 293 bytes .../PolyGroup_Math_Mode_Multiply_Diagram.png | Bin 0 -> 344 bytes ...p_Math_Mode_Multiply_Diagram_MouseOver.png | Bin 0 -> 278 bytes ...PolyGroup_Math_Mode_SquareRoot_Diagram.png | Bin 0 -> 382 bytes ...Math_Mode_SquareRoot_Diagram_MouseOver.png | Bin 0 -> 335 bytes .../PolyGroup_Math_Mode_Subtract_Diagram.png | Bin 0 -> 183 bytes ...p_Math_Mode_Subtract_Diagram_MouseOver.png | Bin 0 -> 177 bytes .../images/PolyGroup_Math_Palette.png | Bin 0 -> 1210 bytes .../PolyGroup_Math_Palette_MouseOver.png | Bin 0 -> 1155 bytes .../images/PolyGroup_MediumMotor_Category.png | Bin 0 -> 286 bytes ...lyGroup_MediumMotor_Category_MouseOver.png | Bin 0 -> 254 bytes .../images/PolyGroup_MediumMotor_Diagram.png | Bin 0 -> 4765 bytes .../images/PolyGroup_MediumMotor_Hardware.png | Bin 0 -> 4327 bytes ...roup_MediumMotor_Mode_Advanced_Diagram.png | Bin 0 -> 433 bytes ...mMotor_Mode_Advanced_Diagram_MouseOver.png | Bin 0 -> 390 bytes ...Group_MediumMotor_Mode_Degrees_Diagram.png | Bin 0 -> 590 bytes ...umMotor_Mode_Degrees_Diagram_MouseOver.png | Bin 0 -> 524 bytes ...Motor_Mode_MeasureCurrentSpeed_Diagram.png | Bin 0 -> 723 bytes ..._MeasureCurrentSpeed_Diagram_MouseOver.png | Bin 0 -> 602 bytes ...otor_Mode_MeasureCurrentSpeed_Hardware.png | Bin 0 -> 539 bytes ...MeasureCurrentSpeed_Hardware_MouseOver.png | Bin 0 -> 473 bytes ...ediumMotor_Mode_MeasureDegrees_Diagram.png | Bin 0 -> 665 bytes ..._Mode_MeasureDegrees_Diagram_MouseOver.png | Bin 0 -> 541 bytes ...diumMotor_Mode_MeasureDegrees_Hardware.png | Bin 0 -> 512 bytes ...Mode_MeasureDegrees_Hardware_MouseOver.png | Bin 0 -> 442 bytes ...diumMotor_Mode_MeasureRotation_Diagram.png | Bin 0 -> 664 bytes ...Mode_MeasureRotation_Diagram_MouseOver.png | Bin 0 -> 533 bytes ...iumMotor_Mode_MeasureRotation_Hardware.png | Bin 0 -> 514 bytes ...ode_MeasureRotation_Hardware_MouseOver.png | Bin 0 -> 440 bytes ...oup_MediumMotor_Mode_Rotations_Diagram.png | Bin 0 -> 582 bytes ...Motor_Mode_Rotations_Diagram_MouseOver.png | Bin 0 -> 496 bytes ...olyGroup_MediumMotor_Mode_Stop_Diagram.png | Bin 0 -> 364 bytes ...ediumMotor_Mode_Stop_Diagram_MouseOver.png | Bin 0 -> 274 bytes ...olyGroup_MediumMotor_Mode_Time_Diagram.png | Bin 0 -> 498 bytes ...ediumMotor_Mode_Time_Diagram_MouseOver.png | Bin 0 -> 452 bytes ...oup_MediumMotor_Mode_Unlimited_Diagram.png | Bin 0 -> 459 bytes ...Motor_Mode_Unlimited_Diagram_MouseOver.png | Bin 0 -> 391 bytes .../images/PolyGroup_MediumMotor_Palette.png | Bin 0 -> 4327 bytes ...olyGroup_MediumMotor_Palette_MouseOver.png | Bin 0 -> 1561 bytes .../images/PolyGroup_Messaging_Category.png | Bin 0 -> 442 bytes ...PolyGroup_Messaging_Category_MouseOver.png | Bin 0 -> 370 bytes .../images/PolyGroup_Messaging_Diagram.png | Bin 0 -> 4284 bytes ...aging_Mode_ChangeBooleanUpdate_Diagram.png | Bin 0 -> 627 bytes ..._ChangeBooleanUpdate_Diagram_MouseOver.png | Bin 0 -> 578 bytes ...saging_Mode_ChangeBooleanValue_Diagram.png | Bin 0 -> 623 bytes ...e_ChangeBooleanValue_Diagram_MouseOver.png | Bin 0 -> 477 bytes ...aging_Mode_ChangeNumericUpdate_Diagram.png | Bin 0 -> 549 bytes ..._ChangeNumericUpdate_Diagram_MouseOver.png | Bin 0 -> 468 bytes ...saging_Mode_ChangeNumericValue_Diagram.png | Bin 0 -> 547 bytes ...e_ChangeNumericValue_Diagram_MouseOver.png | Bin 0 -> 475 bytes ...essaging_Mode_ChangeTextUpdate_Diagram.png | Bin 0 -> 493 bytes ...ode_ChangeTextUpdate_Diagram_MouseOver.png | Bin 0 -> 428 bytes ...Messaging_Mode_ChangeTextValue_Diagram.png | Bin 0 -> 439 bytes ...Mode_ChangeTextValue_Diagram_MouseOver.png | Bin 0 -> 380 bytes ..._Messaging_Mode_CompareBoolean_Diagram.png | Bin 0 -> 648 bytes ..._Mode_CompareBoolean_Diagram_MouseOver.png | Bin 0 -> 521 bytes ..._Messaging_Mode_CompareNumeric_Diagram.png | Bin 0 -> 573 bytes ..._Mode_CompareNumeric_Diagram_MouseOver.png | Bin 0 -> 520 bytes ...oup_Messaging_Mode_CompareText_Diagram.png | Bin 0 -> 509 bytes ...ing_Mode_CompareText_Diagram_MouseOver.png | Bin 0 -> 458 bytes ..._Messaging_Mode_ReceiveBoolean_Diagram.png | Bin 0 -> 651 bytes ..._Mode_ReceiveBoolean_Diagram_MouseOver.png | Bin 0 -> 500 bytes ..._Messaging_Mode_ReceiveNumeric_Diagram.png | Bin 0 -> 608 bytes ..._Mode_ReceiveNumeric_Diagram_MouseOver.png | Bin 0 -> 489 bytes ...oup_Messaging_Mode_ReceiveText_Diagram.png | Bin 0 -> 521 bytes ...ing_Mode_ReceiveText_Diagram_MouseOver.png | Bin 0 -> 418 bytes ...oup_Messaging_Mode_SendBoolean_Diagram.png | Bin 0 -> 632 bytes ...ing_Mode_SendBoolean_Diagram_MouseOver.png | Bin 0 -> 497 bytes ...oup_Messaging_Mode_SendNumeric_Diagram.png | Bin 0 -> 618 bytes ...ing_Mode_SendNumeric_Diagram_MouseOver.png | Bin 0 -> 480 bytes ...yGroup_Messaging_Mode_SendText_Diagram.png | Bin 0 -> 530 bytes ...saging_Mode_SendText_Diagram_MouseOver.png | Bin 0 -> 437 bytes .../PolyGroup_Messaging_Mode_Send_Diagram.png | Bin 0 -> 465 bytes ..._Messaging_Mode_Send_Diagram_MouseOver.png | Bin 0 -> 391 bytes .../images/PolyGroup_Messaging_Palette.png | Bin 0 -> 1223 bytes .../PolyGroup_Messaging_Palette_MouseOver.png | Bin 0 -> 1210 bytes ...lyGroup_Messaging_PolyCategory_Receive.png | Bin 0 -> 464 bytes ...ssaging_PolyCategory_Receive_MouseOver.png | Bin 0 -> 387 bytes .../PolyGroup_Messaging_PolyCategory_Send.png | Bin 0 -> 458 bytes ..._Messaging_PolyCategory_Send_MouseOver.png | Bin 0 -> 385 bytes .../images/PolyGroup_Motor_Category.png | Bin 0 -> 515 bytes .../PolyGroup_Motor_Category_MouseOver.png | Bin 0 -> 428 bytes .../images/PolyGroup_Motor_Diagram.png | Bin 0 -> 5381 bytes .../images/PolyGroup_Motor_Hardware.png | Bin 0 -> 4314 bytes legoresources/images/PolyGroup_Motor_Help.png | Bin 0 -> 18034 bytes .../PolyGroup_Motor_Mode_Advanced_Diagram.png | Bin 0 -> 433 bytes ..._Motor_Mode_Advanced_Diagram_MouseOver.png | Bin 0 -> 390 bytes .../PolyGroup_Motor_Mode_Degrees_Diagram.png | Bin 0 -> 590 bytes ...p_Motor_Mode_Degrees_Diagram_MouseOver.png | Bin 0 -> 524 bytes ...Motor_Mode_MeasureCurrentSpeed_Diagram.png | Bin 0 -> 723 bytes ..._MeasureCurrentSpeed_Diagram_MouseOver.png | Bin 0 -> 602 bytes ...otor_Mode_MeasureCurrentSpeed_Hardware.png | Bin 0 -> 539 bytes ...MeasureCurrentSpeed_Hardware_MouseOver.png | Bin 0 -> 473 bytes ...roup_Motor_Mode_MeasureDegrees_Diagram.png | Bin 0 -> 665 bytes ..._Mode_MeasureDegrees_Diagram_MouseOver.png | Bin 0 -> 541 bytes ...oup_Motor_Mode_MeasureDegrees_Hardware.png | Bin 0 -> 512 bytes ...Mode_MeasureDegrees_Hardware_MouseOver.png | Bin 0 -> 442 bytes ...oup_Motor_Mode_MeasureRotation_Diagram.png | Bin 0 -> 664 bytes ...Mode_MeasureRotation_Diagram_MouseOver.png | Bin 0 -> 533 bytes ...up_Motor_Mode_MeasureRotation_Hardware.png | Bin 0 -> 514 bytes ...ode_MeasureRotation_Hardware_MouseOver.png | Bin 0 -> 440 bytes ...PolyGroup_Motor_Mode_Rotations_Diagram.png | Bin 0 -> 582 bytes ...Motor_Mode_Rotations_Diagram_MouseOver.png | Bin 0 -> 496 bytes .../PolyGroup_Motor_Mode_Stop_Diagram.png | Bin 0 -> 364 bytes ...roup_Motor_Mode_Stop_Diagram_MouseOver.png | Bin 0 -> 274 bytes .../PolyGroup_Motor_Mode_Time_Diagram.png | Bin 0 -> 498 bytes ...roup_Motor_Mode_Time_Diagram_MouseOver.png | Bin 0 -> 452 bytes ...PolyGroup_Motor_Mode_Unlimited_Diagram.png | Bin 0 -> 459 bytes ...Motor_Mode_Unlimited_Diagram_MouseOver.png | Bin 0 -> 391 bytes .../images/PolyGroup_Motor_Palette.png | Bin 0 -> 4314 bytes .../PolyGroup_Motor_Palette_MouseOver.png | Bin 0 -> 1564 bytes .../images/PolyGroup_MoveTank_Diagram.png | Bin 0 -> 3248 bytes .../images/PolyGroup_MoveTank_Hardware.png | Bin 0 -> 1991 bytes .../images/PolyGroup_MoveTank_Help.png | Bin 0 -> 24065 bytes ...lyGroup_MoveTank_Mode_Advanced_Diagram.png | Bin 0 -> 433 bytes ...veTank_Mode_Advanced_Diagram_MouseOver.png | Bin 0 -> 390 bytes ...olyGroup_MoveTank_Mode_Degrees_Diagram.png | Bin 0 -> 590 bytes ...oveTank_Mode_Degrees_Diagram_MouseOver.png | Bin 0 -> 524 bytes ...yGroup_MoveTank_Mode_Rotations_Diagram.png | Bin 0 -> 582 bytes ...eTank_Mode_Rotations_Diagram_MouseOver.png | Bin 0 -> 496 bytes .../PolyGroup_MoveTank_Mode_Stop_Diagram.png | Bin 0 -> 364 bytes ...p_MoveTank_Mode_Stop_Diagram_MouseOver.png | Bin 0 -> 274 bytes .../PolyGroup_MoveTank_Mode_Time_Diagram.png | Bin 0 -> 498 bytes ...p_MoveTank_Mode_Time_Diagram_MouseOver.png | Bin 0 -> 452 bytes ...yGroup_MoveTank_Mode_Unlimited_Diagram.png | Bin 0 -> 459 bytes ...eTank_Mode_Unlimited_Diagram_MouseOver.png | Bin 0 -> 391 bytes .../images/PolyGroup_MoveTank_Palette.png | Bin 0 -> 1991 bytes .../PolyGroup_MoveTank_Palette_MouseOver.png | Bin 0 -> 1977 bytes .../images/PolyGroup_Move_Diagram.png | Bin 0 -> 5939 bytes .../images/PolyGroup_Move_Hardware.png | Bin 0 -> 2017 bytes legoresources/images/PolyGroup_Move_Help.png | Bin 0 -> 27650 bytes .../PolyGroup_Move_Mode_Advanced_Diagram.png | Bin 0 -> 433 bytes ...p_Move_Mode_Advanced_Diagram_MouseOver.png | Bin 0 -> 390 bytes .../PolyGroup_Move_Mode_Degrees_Diagram.png | Bin 0 -> 590 bytes ...up_Move_Mode_Degrees_Diagram_MouseOver.png | Bin 0 -> 524 bytes .../PolyGroup_Move_Mode_Rotations_Diagram.png | Bin 0 -> 582 bytes ..._Move_Mode_Rotations_Diagram_MouseOver.png | Bin 0 -> 496 bytes .../PolyGroup_Move_Mode_Stop_Diagram.png | Bin 0 -> 364 bytes ...Group_Move_Mode_Stop_Diagram_MouseOver.png | Bin 0 -> 274 bytes .../PolyGroup_Move_Mode_Time_Diagram.png | Bin 0 -> 498 bytes ...Group_Move_Mode_Time_Diagram_MouseOver.png | Bin 0 -> 452 bytes .../PolyGroup_Move_Mode_Unlimited_Diagram.png | Bin 0 -> 459 bytes ..._Move_Mode_Unlimited_Diagram_MouseOver.png | Bin 0 -> 391 bytes .../images/PolyGroup_Move_Palette.png | Bin 0 -> 2017 bytes .../PolyGroup_Move_Palette_MouseOver.png | Bin 0 -> 2026 bytes .../images/PolyGroup_Random_Diagram.png | Bin 0 -> 4280 bytes .../PolyGroup_Random_Mode_Boolean_Diagram.png | Bin 0 -> 429 bytes ..._Random_Mode_Boolean_Diagram_MouseOver.png | Bin 0 -> 342 bytes .../PolyGroup_Random_Mode_Numeric_Diagram.png | Bin 0 -> 304 bytes ..._Random_Mode_Numeric_Diagram_MouseOver.png | Bin 0 -> 279 bytes .../images/PolyGroup_Random_Palette.png | Bin 0 -> 1380 bytes .../PolyGroup_Random_Palette_MouseOver.png | Bin 0 -> 1381 bytes .../images/PolyGroup_Range_Diagram.png | Bin 0 -> 3891 bytes .../PolyGroup_Range_Mode_Inside_Diagram.png | Bin 0 -> 275 bytes ...up_Range_Mode_Inside_Diagram_MouseOver.png | Bin 0 -> 267 bytes .../PolyGroup_Range_Mode_Outside_Diagram.png | Bin 0 -> 286 bytes ...p_Range_Mode_Outside_Diagram_MouseOver.png | Bin 0 -> 273 bytes .../images/PolyGroup_Range_Palette.png | Bin 0 -> 1024 bytes .../PolyGroup_Range_Palette_MouseOver.png | Bin 0 -> 964 bytes .../PolyGroup_RawSensorValue_Diagram.png | Bin 0 -> 1202 bytes ...yGroup_RawSensorValue_Mode_Raw_Diagram.png | Bin 0 -> 697 bytes ...SensorValue_Mode_Raw_Diagram_MouseOver.png | Bin 0 -> 631 bytes .../PolyGroup_RawSensorValue_Palette.png | Bin 0 -> 1407 bytes ...Group_RawSensorValue_Palette_MouseOver.png | Bin 0 -> 1373 bytes .../PolyGroup_RotationSensor_Category.png | Bin 0 -> 413 bytes ...roup_RotationSensor_Category_MouseOver.png | Bin 0 -> 343 bytes .../PolyGroup_RotationSensor_Diagram.png | Bin 0 -> 4817 bytes ...ationSensor_Mode_ChangeDegrees_Diagram.png | Bin 0 -> 678 bytes ...r_Mode_ChangeDegrees_Diagram_MouseOver.png | Bin 0 -> 569 bytes ...tionSensor_Mode_ChangeRotation_Diagram.png | Bin 0 -> 698 bytes ..._Mode_ChangeRotation_Diagram_MouseOver.png | Bin 0 -> 558 bytes ...otationSensor_Mode_ChangeSpeed_Diagram.png | Bin 0 -> 746 bytes ...sor_Mode_ChangeSpeed_Diagram_MouseOver.png | Bin 0 -> 609 bytes ...ensor_Mode_CompareCurrentSpeed_Diagram.png | Bin 0 -> 787 bytes ..._CompareCurrentSpeed_Diagram_MouseOver.png | Bin 0 -> 617 bytes ...tionSensor_Mode_CompareDegrees_Diagram.png | Bin 0 -> 726 bytes ..._Mode_CompareDegrees_Diagram_MouseOver.png | Bin 0 -> 588 bytes ...ionSensor_Mode_CompareRotation_Diagram.png | Bin 0 -> 749 bytes ...Mode_CompareRotation_Diagram_MouseOver.png | Bin 0 -> 586 bytes ...ensor_Mode_MeasureCurrentSpeed_Diagram.png | Bin 0 -> 723 bytes ..._MeasureCurrentSpeed_Diagram_MouseOver.png | Bin 0 -> 602 bytes ...tionSensor_Mode_MeasureDegrees_Diagram.png | Bin 0 -> 665 bytes ..._Mode_MeasureDegrees_Diagram_MouseOver.png | Bin 0 -> 541 bytes ...ionSensor_Mode_MeasureRotation_Diagram.png | Bin 0 -> 664 bytes ...Mode_MeasureRotation_Diagram_MouseOver.png | Bin 0 -> 533 bytes ...roup_RotationSensor_Mode_Reset_Diagram.png | Bin 0 -> 270 bytes ...ionSensor_Mode_Reset_Diagram_MouseOver.png | Bin 0 -> 265 bytes .../PolyGroup_RotationSensor_Palette.png | Bin 0 -> 1819 bytes ...Group_RotationSensor_Palette_MouseOver.png | Bin 0 -> 1812 bytes .../images/PolyGroup_Round_Diagram.png | Bin 0 -> 3821 bytes .../PolyGroup_Round_Mode_Down_Diagram.png | Bin 0 -> 294 bytes ...roup_Round_Mode_Down_Diagram_MouseOver.png | Bin 0 -> 274 bytes .../PolyGroup_Round_Mode_Nearest_Diagram.png | Bin 0 -> 485 bytes ...p_Round_Mode_Nearest_Diagram_MouseOver.png | Bin 0 -> 419 bytes .../PolyGroup_Round_Mode_Truncate_Diagram.png | Bin 0 -> 393 bytes ..._Round_Mode_Truncate_Diagram_MouseOver.png | Bin 0 -> 381 bytes .../PolyGroup_Round_Mode_Up_Diagram.png | Bin 0 -> 309 bytes ...yGroup_Round_Mode_Up_Diagram_MouseOver.png | Bin 0 -> 287 bytes .../images/PolyGroup_Round_Palette.png | Bin 0 -> 1135 bytes .../PolyGroup_Round_Palette_MouseOver.png | Bin 0 -> 1094 bytes .../images/PolyGroup_SoundSensor_Category.png | Bin 0 -> 408 bytes ...lyGroup_SoundSensor_Category_MouseOver.png | Bin 0 -> 386 bytes .../images/PolyGroup_SoundSensor_Diagram.png | Bin 0 -> 2793 bytes ...dSensor_Mode_CalibrateMaxSound_Diagram.png | Bin 0 -> 243 bytes ...de_CalibrateMaxSound_Diagram_MouseOver.png | Bin 0 -> 229 bytes ...dSensor_Mode_CalibrateMinSound_Diagram.png | Bin 0 -> 237 bytes ...de_CalibrateMinSound_Diagram_MouseOver.png | Bin 0 -> 221 bytes ...ensor_Mode_CalibrateResetSound_Diagram.png | Bin 0 -> 270 bytes ..._CalibrateResetSound_Diagram_MouseOver.png | Bin 0 -> 265 bytes ...roup_SoundSensor_Mode_ChangeDb_Diagram.png | Bin 0 -> 526 bytes ...Sensor_Mode_ChangeDb_Diagram_MouseOver.png | Bin 0 -> 464 bytes ...oup_SoundSensor_Mode_ChangeDba_Diagram.png | Bin 0 -> 570 bytes ...ensor_Mode_ChangeDba_Diagram_MouseOver.png | Bin 0 -> 493 bytes ...oup_SoundSensor_Mode_ComparedB_Diagram.png | Bin 0 -> 554 bytes ...ensor_Mode_ComparedB_Diagram_MouseOver.png | Bin 0 -> 494 bytes ...up_SoundSensor_Mode_ComparedbA_Diagram.png | Bin 0 -> 585 bytes ...nsor_Mode_ComparedbA_Diagram_MouseOver.png | Bin 0 -> 532 bytes ...oup_SoundSensor_Mode_MeasuredB_Diagram.png | Bin 0 -> 473 bytes ...ensor_Mode_MeasuredB_Diagram_MouseOver.png | Bin 0 -> 416 bytes ...up_SoundSensor_Mode_MeasuredB_Hardware.png | Bin 0 -> 286 bytes ...nsor_Mode_MeasuredB_Hardware_MouseOver.png | Bin 0 -> 265 bytes ...up_SoundSensor_Mode_MeasuredBa_Diagram.png | Bin 0 -> 492 bytes ...nsor_Mode_MeasuredBa_Diagram_MouseOver.png | Bin 0 -> 446 bytes ...p_SoundSensor_Mode_MeasuredBa_Hardware.png | Bin 0 -> 327 bytes ...sor_Mode_MeasuredBa_Hardware_MouseOver.png | Bin 0 -> 290 bytes .../images/PolyGroup_SoundSensor_Palette.png | Bin 0 -> 1785 bytes ...olyGroup_SoundSensor_Palette_MouseOver.png | Bin 0 -> 1744 bytes ...oup_SoundSensor_PolyCategory_Calibrate.png | Bin 0 -> 562 bytes ...ensor_PolyCategory_Calibrate_MouseOver.png | Bin 0 -> 491 bytes ..._SoundSensor_PolyCategory_dB@Calibrate.png | Bin 0 -> 673 bytes ...or_PolyCategory_dB@Calibrate_MouseOver.png | Bin 0 -> 581 bytes .../images/PolyGroup_Sound_Diagram.png | Bin 0 -> 4713 bytes .../images/PolyGroup_Sound_Hardware.png | Bin 0 -> 4045 bytes legoresources/images/PolyGroup_Sound_Help.png | Bin 0 -> 13142 bytes .../PolyGroup_Sound_Mode_File_Diagram.png | Bin 0 -> 295 bytes ...roup_Sound_Mode_File_Diagram_MouseOver.png | Bin 0 -> 293 bytes .../PolyGroup_Sound_Mode_Note_Diagram.png | Bin 0 -> 228 bytes ...roup_Sound_Mode_Note_Diagram_MouseOver.png | Bin 0 -> 219 bytes .../PolyGroup_Sound_Mode_Stop_Diagram.png | Bin 0 -> 198 bytes ...roup_Sound_Mode_Stop_Diagram_MouseOver.png | Bin 0 -> 189 bytes .../PolyGroup_Sound_Mode_Tone_Diagram.png | Bin 0 -> 366 bytes ...roup_Sound_Mode_Tone_Diagram_MouseOver.png | Bin 0 -> 330 bytes .../images/PolyGroup_Sound_Palette.png | Bin 0 -> 4045 bytes .../PolyGroup_Sound_Palette_MouseOver.png | Bin 0 -> 1312 bytes .../images/PolyGroup_StartBlock_Diagram.png | Bin 0 -> 1404 bytes .../images/PolyGroup_StopBlock_Diagram.png | Bin 0 -> 1213 bytes .../PolyGroup_TemperatureSensor_Category.png | Bin 0 -> 263 bytes ...p_TemperatureSensor_Category_MouseOver.png | Bin 0 -> 247 bytes .../PolyGroup_TemperatureSensor_Diagram.png | Bin 0 -> 5187 bytes ...atureSensor_Mode_ChangeCelsius_Diagram.png | Bin 0 -> 589 bytes ...r_Mode_ChangeCelsius_Diagram_MouseOver.png | Bin 0 -> 477 bytes ...ode_ChangeFahrenheit_Diagram_MouseOver.png | Bin 0 -> 432 bytes ...reSensor_Mode_Changefahrenheit_Diagram.png | Bin 0 -> 517 bytes ...tureSensor_Mode_CompareCelsius_Diagram.png | Bin 0 -> 586 bytes ..._Mode_CompareCelsius_Diagram_MouseOver.png | Bin 0 -> 487 bytes ...eSensor_Mode_CompareFahrenheit_Diagram.png | Bin 0 -> 534 bytes ...de_CompareFahrenheit_Diagram_MouseOver.png | Bin 0 -> 474 bytes ...nsor_Mode_FahrenhetCompare_PolyDiagram.png | Bin 0 -> 368 bytes ...FahrenhetCompare_PolyDiagram_MouseOver.png | Bin 0 -> 330 bytes ...tureSensor_Mode_MeasureCelsius_Diagram.png | Bin 0 -> 493 bytes ..._Mode_MeasureCelsius_Diagram_MouseOver.png | Bin 0 -> 420 bytes ...ureSensor_Mode_MeasureCelsius_Hardware.png | Bin 0 -> 332 bytes ...Mode_MeasureCelsius_Hardware_MouseOver.png | Bin 0 -> 277 bytes ...eSensor_Mode_MeasureFahrenheit_Diagram.png | Bin 0 -> 456 bytes ...de_MeasureFahrenheit_Diagram_MouseOver.png | Bin 0 -> 371 bytes ...Sensor_Mode_MeasureFahrenheit_Hardware.png | Bin 0 -> 277 bytes ...e_MeasureFahrenheit_Hardware_MouseOver.png | Bin 0 -> 254 bytes .../PolyGroup_TemperatureSensor_Palette.png | Bin 0 -> 1669 bytes ...up_TemperatureSensor_Palette_MouseOver.png | Bin 0 -> 1656 bytes .../images/PolyGroup_Text_Diagram.png | Bin 0 -> 790 bytes .../PolyGroup_Text_Mode_Merge_Diagram.png | Bin 0 -> 392 bytes ...roup_Text_Mode_Merge_Diagram_MouseOver.png | Bin 0 -> 334 bytes .../images/PolyGroup_Text_Palette.png | Bin 0 -> 617 bytes .../PolyGroup_Text_Palette_MouseOver.png | Bin 0 -> 595 bytes .../images/PolyGroup_TimerSensor_Diagram.png | Bin 0 -> 5230 bytes .../images/PolyGroup_TimerSensor_Palette.png | Bin 0 -> 1599 bytes .../images/PolyGroup_Timer_Category.png | Bin 0 -> 433 bytes .../PolyGroup_Timer_Category_MouseOver.png | Bin 0 -> 387 bytes .../images/PolyGroup_Timer_Diagram.png | Bin 0 -> 4894 bytes ...olyGroup_Timer_Mode_ChangeTime_Diagram.png | Bin 0 -> 698 bytes ...imer_Mode_ChangeTime_Diagram_MouseOver.png | Bin 0 -> 552 bytes ...lyGroup_Timer_Mode_CompareTime_Diagram.png | Bin 0 -> 715 bytes ...mer_Mode_CompareTime_Diagram_MouseOver.png | Bin 0 -> 569 bytes ...lyGroup_Timer_Mode_MeasureTime_Diagram.png | Bin 0 -> 667 bytes ...mer_Mode_MeasureTime_Diagram_MouseOver.png | Bin 0 -> 527 bytes .../PolyGroup_Timer_Mode_Reset_Diagram.png | Bin 0 -> 270 bytes ...oup_Timer_Mode_Reset_Diagram_MouseOver.png | Bin 0 -> 265 bytes .../images/PolyGroup_Timer_Palette.png | Bin 0 -> 1599 bytes .../PolyGroup_Timer_Palette_MouseOver.png | Bin 0 -> 1588 bytes .../images/PolyGroup_TouchSensor_Category.png | Bin 0 -> 305 bytes ...lyGroup_TouchSensor_Category_MouseOver.png | Bin 0 -> 290 bytes .../images/PolyGroup_TouchSensor_Diagram.png | Bin 0 -> 1927 bytes ...p_TouchSensor_Mode_ChangeState_Diagram.png | Bin 0 -> 503 bytes ...sor_Mode_ChangeState_Diagram_MouseOver.png | Bin 0 -> 405 bytes ...Group_TouchSensor_Mode_Compare_Diagram.png | Bin 0 -> 517 bytes ...hSensor_Mode_Compare_Diagram_MouseOver.png | Bin 0 -> 440 bytes ...Group_TouchSensor_Mode_Measure_Diagram.png | Bin 0 -> 447 bytes ...hSensor_Mode_Measure_Diagram_MouseOver.png | Bin 0 -> 365 bytes ...roup_TouchSensor_Mode_Measure_Hardware.png | Bin 0 -> 229 bytes ...Sensor_Mode_Measure_Hardware_MouseOver.png | Bin 0 -> 210 bytes .../images/PolyGroup_TouchSensor_Palette.png | Bin 0 -> 1693 bytes ...olyGroup_TouchSensor_Palette_MouseOver.png | Bin 0 -> 1705 bytes .../PolyGroup_UltraSonicSensor_Category.png | Bin 0 -> 772 bytes ...up_UltraSonicSensor_Category_MouseOver.png | Bin 0 -> 735 bytes .../PolyGroup_UltrasonicSensor_Diagram.png | Bin 0 -> 2471 bytes ...rasonicSensor_Mode_Centimeters_Diagram.png | Bin 0 -> 457 bytes ...sor_Mode_Centimeters_Diagram_MouseOver.png | Bin 0 -> 404 bytes ...asonicSensor_Mode_Centimeters_Hardware.png | Bin 0 -> 457 bytes ...or_Mode_Centimeters_Hardware_MouseOver.png | Bin 0 -> 404 bytes ...icSensor_Mode_ChangeDistanceCm_Diagram.png | Bin 0 -> 520 bytes ...ode_ChangeDistanceCm_Diagram_MouseOver.png | Bin 0 -> 437 bytes ...Sensor_Mode_ChangeDistanceInch_Diagram.png | Bin 0 -> 533 bytes ...e_ChangeDistanceInch_Diagram_MouseOver.png | Bin 0 -> 438 bytes ...asonicSensor_Mode_ChangeListen_Diagram.png | Bin 0 -> 621 bytes ...or_Mode_ChangeListen_Diagram_MouseOver.png | Bin 0 -> 439 bytes ...Sensor_Mode_CompareCentimeters_Diagram.png | Bin 0 -> 529 bytes ...e_CompareCentimeters_Diagram_MouseOver.png | Bin 0 -> 468 bytes ...sonicSensor_Mode_CompareInches_Diagram.png | Bin 0 -> 548 bytes ...r_Mode_CompareInches_Diagram_MouseOver.png | Bin 0 -> 467 bytes ...nicSensor_Mode_ComparePresence_Diagram.png | Bin 0 -> 660 bytes ...Mode_ComparePresence_Diagram_MouseOver.png | Bin 0 -> 483 bytes ...p_UltrasonicSensor_Mode_Inches_Diagram.png | Bin 0 -> 479 bytes ...icSensor_Mode_Inches_Diagram_MouseOver.png | Bin 0 -> 434 bytes ..._UltrasonicSensor_Mode_Inches_Hardware.png | Bin 0 -> 479 bytes ...cSensor_Mode_Inches_Hardware_MouseOver.png | Bin 0 -> 434 bytes ...Sensor_Mode_MeasureCentimeters_Diagram.png | Bin 0 -> 447 bytes ...e_MeasureCentimeters_Diagram_MouseOver.png | Bin 0 -> 389 bytes ...ensor_Mode_MeasureCentimeters_Hardware.png | Bin 0 -> 288 bytes ..._MeasureCentimeters_Hardware_MouseOver.png | Bin 0 -> 264 bytes ...sonicSensor_Mode_MeasureInches_Diagram.png | Bin 0 -> 467 bytes ...r_Mode_MeasureInches_Diagram_MouseOver.png | Bin 0 -> 401 bytes ...onicSensor_Mode_MeasureInches_Hardware.png | Bin 0 -> 308 bytes ..._Mode_MeasureInches_Hardware_MouseOver.png | Bin 0 -> 298 bytes ...nicSensor_Mode_MeasurePresence_Diagram.png | Bin 0 -> 579 bytes ...Mode_MeasurePresence_Diagram_MouseOver.png | Bin 0 -> 460 bytes ...icSensor_Mode_MeasurePresence_Hardware.png | Bin 0 -> 425 bytes ...ode_MeasurePresence_Hardware_MouseOver.png | Bin 0 -> 299 bytes .../PolyGroup_UltrasonicSensor_Palette.png | Bin 0 -> 1673 bytes ...oup_UltrasonicSensor_Palette_MouseOver.png | Bin 0 -> 1692 bytes ...UltrasonicSensor_PolyCategory_Advanced.png | Bin 0 -> 433 bytes ...Sensor_PolyCategory_Advanced_MouseOver.png | Bin 0 -> 390 bytes ...tedMotor_Mode_UnregulatedMotor_Diagram.png | Bin 0 -> 459 bytes ...ode_UnregulatedMotor_Diagram_MouseOver.png | Bin 0 -> 391 bytes .../images/PolyGroup_Variable_Diagram.png | Bin 0 -> 3850 bytes ...Variable_Mode_ReadBooleanArray_Diagram.png | Bin 0 -> 529 bytes ...ode_ReadBooleanArray_Diagram_MouseOver.png | Bin 0 -> 487 bytes ...roup_Variable_Mode_ReadBoolean_Diagram.png | Bin 0 -> 539 bytes ...ble_Mode_ReadBoolean_Diagram_MouseOver.png | Bin 0 -> 506 bytes ...Variable_Mode_ReadNumericArray_Diagram.png | Bin 0 -> 486 bytes ...ode_ReadNumericArray_Diagram_MouseOver.png | Bin 0 -> 430 bytes ...roup_Variable_Mode_ReadNumeric_Diagram.png | Bin 0 -> 423 bytes ...ble_Mode_ReadNumeric_Diagram_MouseOver.png | Bin 0 -> 434 bytes ...lyGroup_Variable_Mode_ReadText_Diagram.png | Bin 0 -> 370 bytes ...riable_Mode_ReadText_Diagram_MouseOver.png | Bin 0 -> 365 bytes ...ariable_Mode_WriteBooleanArray_Diagram.png | Bin 0 -> 642 bytes ...de_WriteBooleanArray_Diagram_MouseOver.png | Bin 0 -> 546 bytes ...oup_Variable_Mode_WriteBoolean_Diagram.png | Bin 0 -> 641 bytes ...le_Mode_WriteBoolean_Diagram_MouseOver.png | Bin 0 -> 464 bytes ...ariable_Mode_WriteNumericArray_Diagram.png | Bin 0 -> 593 bytes ...de_WriteNumericArray_Diagram_MouseOver.png | Bin 0 -> 510 bytes ...oup_Variable_Mode_WriteNumeric_Diagram.png | Bin 0 -> 548 bytes ...le_Mode_WriteNumeric_Diagram_MouseOver.png | Bin 0 -> 483 bytes ...yGroup_Variable_Mode_WriteText_Diagram.png | Bin 0 -> 494 bytes ...iable_Mode_WriteText_Diagram_MouseOver.png | Bin 0 -> 437 bytes .../images/PolyGroup_Variable_Palette.png | Bin 0 -> 998 bytes .../PolyGroup_Variable_Palette_MouseOver.png | Bin 0 -> 1018 bytes .../PolyGroup_Variable_PolyCategory_Read.png | Bin 0 -> 311 bytes ...p_Variable_PolyCategory_Read_MouseOver.png | Bin 0 -> 296 bytes .../PolyGroup_Variable_PolyCategory_Write.png | Bin 0 -> 433 bytes ..._Variable_PolyCategory_Write_MouseOver.png | Bin 0 -> 392 bytes .../images/PolyGroup_Wait_Diagram.png | Bin 0 -> 1639 bytes .../images/PolyGroup_Wait_Palette.png | Bin 0 -> 1276 bytes .../PolyGroup_Wait_Palette_MouseOver.png | Bin 0 -> 1259 bytes .../images/Polygroup_Interrupt_Diagram.png | Bin 0 -> 1461 bytes .../images/Polygroup_Interrupt_Palette.png | Bin 0 -> 814 bytes .../Polygroup_Interrupt_Palette_MouseOver.png | Bin 0 -> 799 bytes .../Polygroup_UnregulatedMotor_Diagram.png | Bin 0 -> 2603 bytes .../Polygroup_UnregulatedMotor_Help.png | Bin 0 -> 14324 bytes .../Polygroup_UnregulatedMotor_Palette.png | Bin 0 -> 1676 bytes ...oup_UnregulatedMotor_Palette_Mouseover.png | Bin 0 -> 1663 bytes .../Polygroup_Wait_Mode_Timer_Diagram.png | Bin 0 -> 552 bytes ...roup_Wait_Mode_Timer_Diagram_MouseOver.png | Bin 0 -> 574 bytes .../images/PortConfigurator_Conflict.png | Bin 0 -> 2620 bytes legoresources/images/Range_L_R.png | Bin 0 -> 429 bytes legoresources/images/StopBlockIcon.png | Bin 0 -> 152 bytes legoresources/images/StopIcon.png | Bin 0 -> 197 bytes legoresources/images/TankIcon.png | Bin 0 -> 252 bytes legoresources/images/TempBlockIcon.png | Bin 0 -> 1567 bytes legoresources/images/Timer.png | Bin 0 -> 825 bytes legoresources/images/Unknown.png | Bin 0 -> 439 bytes legoresources/images/Unlimited.png | Bin 0 -> 480 bytes legoresources/images/ValueDisplay_Boolean.xml | 5 ++ .../images/ValueDisplay_Boolean_False.png | Bin 0 -> 306 bytes .../ValueDisplay_Boolean_False_MouseOver.png | Bin 0 -> 266 bytes .../images/ValueDisplay_Boolean_True.png | Bin 0 -> 315 bytes .../ValueDisplay_Boolean_True_MouseOver.png | Bin 0 -> 267 bytes legoresources/images/XVariable.png | Bin 0 -> 3178 bytes legoresources/images/YVariable.png | Bin 0 -> 3084 bytes legoresources/images/ZVariable.png | Bin 0 -> 3072 bytes legoresources/images/_Id_Temp_34x34.png | Bin 0 -> 4882 bytes .../aaa_PortConfigurator_EmptyMotor.png | Bin 0 -> 162 bytes .../aaa_PortConfigurator_EmptySensor.png | Bin 0 -> 162 bytes legoresources/images/angleTerminalIcon.png | Bin 0 -> 752 bytes legoresources/images/color_wheel.png | Bin 0 -> 3432 bytes legoresources/images/displayxyz.png | Bin 0 -> 6712 bytes legoresources/images/icons-03.png | Bin 0 -> 395 bytes legoresources/images/icons-05.png | Bin 0 -> 316 bytes .../images/identification_StringA.png | Bin 0 -> 452 bytes legoresources/images/thomas_range.png | Bin 0 -> 429 bytes libs/core/_locales/core-jsdoc-strings.json | 10 ---- libs/core/_locales/core-strings.json | 1 - 1289 files changed, 865 insertions(+), 11 deletions(-) create mode 100644 legoresources/images/BIGbulb.png create mode 100644 legoresources/images/Blank.png create mode 100644 legoresources/images/BlockFamily_Sensor_Category.png create mode 100644 legoresources/images/BlockFamily_Sensor_Category_MouseOver.png create mode 100644 legoresources/images/BlockInterface_Change_Category.png create mode 100644 legoresources/images/BlockInterface_Change_Category_MouseOver.png create mode 100644 legoresources/images/BlockInterface_Compare_Category.png create mode 100644 legoresources/images/BlockInterface_Compare_Category_MouseOver.png create mode 100644 legoresources/images/BlockInterface_Measure_Category.png create mode 100644 legoresources/images/BlockInterface_Measure_Category_MouseOver.png create mode 100644 legoresources/images/BlockInterface_Update_Category.png create mode 100644 legoresources/images/BlockInterface_Update_Category_MouseOver.png create mode 100644 legoresources/images/BlockParams/=.png create mode 100644 legoresources/images/BlockParams/A.png create mode 100644 legoresources/images/BlockParams/B.png create mode 100644 legoresources/images/BlockParams/Backward.png create mode 100644 legoresources/images/BlockParams/Blank.png create mode 100644 legoresources/images/BlockParams/CTempModeIcon.png create mode 100644 legoresources/images/BlockParams/Clock.png create mode 100644 legoresources/images/BlockParams/ColorTerminalIcon.png create mode 100644 legoresources/images/BlockParams/Color_picker.png create mode 100644 legoresources/images/BlockParams/DeltaDegreesTerminalIcon.png create mode 100644 legoresources/images/BlockParams/Do Stop.png create mode 100644 legoresources/images/BlockParams/EqualsIcon.png create mode 100644 legoresources/images/BlockParams/EqualsTerminalIcon.png create mode 100644 legoresources/images/BlockParams/FTempModeIcon.png create mode 100644 legoresources/images/BlockParams/Finish.png create mode 100644 legoresources/images/BlockParams/Forward.png create mode 100644 legoresources/images/BlockParams/Foward.png create mode 100644 legoresources/images/BlockParams/Frequency.png create mode 100644 legoresources/images/BlockParams/Generate Light.png create mode 100644 legoresources/images/BlockParams/GreaterIcon.png create mode 100644 legoresources/images/BlockParams/GreaterThanTerminalIcon.png create mode 100644 legoresources/images/BlockParams/Hourglass.png create mode 100644 legoresources/images/BlockParams/Input 1.png create mode 100644 legoresources/images/BlockParams/Input 2.png create mode 100644 legoresources/images/BlockParams/Intensity.png create mode 100644 legoresources/images/BlockParams/Intensity_light.png create mode 100644 legoresources/images/BlockParams/Left_full.png create mode 100644 legoresources/images/BlockParams/Left_half.png create mode 100644 legoresources/images/BlockParams/LessIcon.png create mode 100644 legoresources/images/BlockParams/LessThanTerminalIcon.png create mode 100644 legoresources/images/BlockParams/Light_blue.png create mode 100644 legoresources/images/BlockParams/Light_orange.png create mode 100644 legoresources/images/BlockParams/Light_red.png create mode 100644 legoresources/images/BlockParams/Loop Index.png create mode 100644 legoresources/images/BlockParams/Mode_color.png create mode 100644 legoresources/images/BlockParams/Param_Amount_50.png create mode 100644 legoresources/images/BlockParams/Param_Scales.png create mode 100644 legoresources/images/BlockParams/PlugSymbolX3Boolean.png create mode 100644 legoresources/images/BlockParams/PlugSymbolX3Numeric.png create mode 100644 legoresources/images/BlockParams/PlugSymbolX3String.png create mode 100644 legoresources/images/BlockParams/Power_0.png create mode 100644 legoresources/images/BlockParams/Power_1.png create mode 100644 legoresources/images/BlockParams/Power_2.png create mode 100644 legoresources/images/BlockParams/Power_3.png create mode 100644 legoresources/images/BlockParams/Power_4.png create mode 100644 legoresources/images/BlockParams/Range_L.png create mode 100644 legoresources/images/BlockParams/Range_L_R.png create mode 100644 legoresources/images/BlockParams/Range_R.png create mode 100644 legoresources/images/BlockParams/Right_Full.png create mode 100644 legoresources/images/BlockParams/Right_half.png create mode 100644 legoresources/images/BlockParams/Rotation_number.png create mode 100644 legoresources/images/BlockParams/Run.png create mode 100644 legoresources/images/BlockParams/Speed Left.png create mode 100644 legoresources/images/BlockParams/Speed Right.png create mode 100644 legoresources/images/BlockParams/Speed.png create mode 100644 legoresources/images/BlockParams/Steering.png create mode 100644 legoresources/images/BlockParams/Stop.png create mode 100644 legoresources/images/BlockParams/Straigh.png create mode 100644 legoresources/images/BlockParams/Timer.png create mode 100644 legoresources/images/BlockParams/Value.png create mode 100644 legoresources/images/BlockParams/Volume.png create mode 100644 legoresources/images/BlockParams/XVariable.png create mode 100644 legoresources/images/BlockParams/YVariable.png create mode 100644 legoresources/images/BlockParams/ZVariable.png create mode 100644 legoresources/images/BlockParams/angleTerminalIcon.png create mode 100644 legoresources/images/BlockParams/bulb.png create mode 100644 legoresources/images/CTempModeIcon.png create mode 100644 legoresources/images/CaseSelector.png create mode 100644 legoresources/images/CaseSelector_Boolean.png create mode 100644 legoresources/images/CaseSelector_Numeric.png create mode 100644 legoresources/images/CaseSelector_String.png create mode 100644 legoresources/images/Clock.png create mode 100644 legoresources/images/ColorLampBlockIcon.png create mode 100644 legoresources/images/ColorSensorBlockIcon.png create mode 100644 legoresources/images/Compare.png create mode 100644 legoresources/images/CompareBlockIcon.png create mode 100644 legoresources/images/ComparePalette.png create mode 100644 legoresources/images/DeltaDegreesTerminalIcon.png create mode 100644 legoresources/images/DivideIcon.png create mode 100644 legoresources/images/EqualsIcon.png create mode 100644 legoresources/images/FTempModeIcon.png create mode 100644 legoresources/images/ForRotation.png create mode 100644 legoresources/images/GreaterEqualsIcon.png create mode 100644 legoresources/images/GreaterIcon.png create mode 100644 legoresources/images/GyroHardwareIcon.png create mode 100644 legoresources/images/GyroPolyGroupIcon.png create mode 100644 legoresources/images/Hardware_EnergyMeter.png create mode 100644 legoresources/images/Hardware_NXT_Color.png create mode 100644 legoresources/images/Hardware_NXT_Light.png create mode 100644 legoresources/images/Hardware_NXT_Motor.png create mode 100644 legoresources/images/Hardware_NXT_Sound.png create mode 100644 legoresources/images/Hardware_NXT_Temperature.png create mode 100644 legoresources/images/Hardware_NXT_Touch.png create mode 100644 legoresources/images/Hardware_NXT_US.png create mode 100644 legoresources/images/Hardware_PBR_Color.png create mode 100644 legoresources/images/Hardware_PBR_Gyro.png create mode 100644 legoresources/images/Hardware_PBR_IR.png create mode 100644 legoresources/images/Hardware_PBR_MotorLarge.png create mode 100644 legoresources/images/Hardware_PBR_MotorMedium.png create mode 100644 legoresources/images/Hardware_PBR_Touch.png create mode 100644 legoresources/images/Hardware_PBR_US.png create mode 100644 legoresources/images/Id_2Motors_Tank_34x34.png create mode 100644 legoresources/images/Id_Bluetouth_34x34.png create mode 100644 legoresources/images/Id_Bluetouth_Conf_34x34.png create mode 100644 legoresources/images/Id_Boolean_34x34.png create mode 100644 legoresources/images/Id_Buttons_Hw_34x34.png create mode 100644 legoresources/images/Id_Buttons_Input.png create mode 100644 legoresources/images/Id_DataCompare_34x34.png create mode 100644 legoresources/images/Id_Data_Round_34x34.png create mode 100644 legoresources/images/Id_Data_constant_34x34.png create mode 100644 legoresources/images/Id_Interupt_Loop_block.png create mode 100644 legoresources/images/Id_Network_messenger.png create mode 100644 legoresources/images/Id_Rotation_Sensor_V2.png create mode 100644 legoresources/images/Id_Start.png create mode 100644 legoresources/images/Id_Stop.png create mode 100644 legoresources/images/Id_W8_Changes_34x34.png create mode 100644 legoresources/images/Id_W8_Treshold_34x34.png create mode 100644 legoresources/images/Identification_A.png create mode 100644 legoresources/images/Identification_ArrayInBoolean.png create mode 100644 legoresources/images/Identification_ArrayInNumeric.png create mode 100644 legoresources/images/Identification_ArrayOutBoolean.png create mode 100644 legoresources/images/Identification_ArrayOutNumeric.png create mode 100644 legoresources/images/Identification_B.png create mode 100644 legoresources/images/Identification_BlackWhite.png create mode 100644 legoresources/images/Identification_BrakeAtEnd.xml create mode 100644 legoresources/images/Identification_BrakeAtEnd_Brake.png create mode 100644 legoresources/images/Identification_BrakeAtEnd_Coast.png create mode 100644 legoresources/images/Identification_C.png create mode 100644 legoresources/images/Identification_Celcius.png create mode 100644 legoresources/images/Identification_ClearScreen.png create mode 100644 legoresources/images/Identification_Color.xml create mode 100644 legoresources/images/Identification_Color_Black.png create mode 100644 legoresources/images/Identification_Color_Black_Selected.png create mode 100644 legoresources/images/Identification_Color_Blue.png create mode 100644 legoresources/images/Identification_Color_Blue_Selected.png create mode 100644 legoresources/images/Identification_Color_Brown.png create mode 100644 legoresources/images/Identification_Color_Brown_Selected.png create mode 100644 legoresources/images/Identification_Color_Green.png create mode 100644 legoresources/images/Identification_Color_Green_Selected.png create mode 100644 legoresources/images/Identification_Color_NoColor.png create mode 100644 legoresources/images/Identification_Color_NoColor_Selected.png create mode 100644 legoresources/images/Identification_Color_Red.png create mode 100644 legoresources/images/Identification_Color_Red_Selected.png create mode 100644 legoresources/images/Identification_Color_White.png create mode 100644 legoresources/images/Identification_Color_White_Selected.png create mode 100644 legoresources/images/Identification_Color_Yellow.png create mode 100644 legoresources/images/Identification_Color_Yellow_Selected.png create mode 100644 legoresources/images/Identification_CompareResult.png create mode 100644 legoresources/images/Identification_ComparisonType.xml create mode 100644 legoresources/images/Identification_ComparisonType2.xml create mode 100644 legoresources/images/Identification_ComparisonType2_Equal.png create mode 100644 legoresources/images/Identification_ComparisonType2_NotEqual.png create mode 100644 legoresources/images/Identification_ComparisonType_Equal.png create mode 100644 legoresources/images/Identification_ComparisonType_GreaterEqual.png create mode 100644 legoresources/images/Identification_ComparisonType_GreaterThan.png create mode 100644 legoresources/images/Identification_ComparisonType_LessEqual.png create mode 100644 legoresources/images/Identification_ComparisonType_LessThan.png create mode 100644 legoresources/images/Identification_ComparisonType_NotEqual.png create mode 100644 legoresources/images/Identification_ConnectToText.png create mode 100644 legoresources/images/Identification_ConstantValue.png create mode 100644 legoresources/images/Identification_Count.png create mode 100644 legoresources/images/Identification_Current.png create mode 100644 legoresources/images/Identification_CurrentPower.png create mode 100644 legoresources/images/Identification_D.png create mode 100644 legoresources/images/Identification_DatalogRate.png create mode 100644 legoresources/images/Identification_Db.png create mode 100644 legoresources/images/Identification_Dba.png create mode 100644 legoresources/images/Identification_DegreesAngle.xml create mode 100644 legoresources/images/Identification_DegreesAngle_0.png create mode 100644 legoresources/images/Identification_DegreesAngle_Minus135.png create mode 100644 legoresources/images/Identification_DegreesAngle_Minus180.png create mode 100644 legoresources/images/Identification_DegreesAngle_Minus225.png create mode 100644 legoresources/images/Identification_DegreesAngle_Minus270.png create mode 100644 legoresources/images/Identification_DegreesAngle_Minus315.png create mode 100644 legoresources/images/Identification_DegreesAngle_Minus360.png create mode 100644 legoresources/images/Identification_DegreesAngle_Minus45.png create mode 100644 legoresources/images/Identification_DegreesAngle_Minus90.png create mode 100644 legoresources/images/Identification_DegreesAngle_Plus135.png create mode 100644 legoresources/images/Identification_DegreesAngle_Plus180.png create mode 100644 legoresources/images/Identification_DegreesAngle_Plus225.png create mode 100644 legoresources/images/Identification_DegreesAngle_Plus270.png create mode 100644 legoresources/images/Identification_DegreesAngle_Plus315.png create mode 100644 legoresources/images/Identification_DegreesAngle_Plus360.png create mode 100644 legoresources/images/Identification_DegreesAngle_Plus45.png create mode 100644 legoresources/images/Identification_DegreesAngle_Plus90.png create mode 100644 legoresources/images/Identification_DistanceCM.png create mode 100644 legoresources/images/Identification_DistanceInches.png create mode 100644 legoresources/images/Identification_Exponent.png create mode 100644 legoresources/images/Identification_Fahrenheit.png create mode 100644 legoresources/images/Identification_FileName.png create mode 100644 legoresources/images/Identification_Fill.png create mode 100644 legoresources/images/Identification_FontSize.png create mode 100644 legoresources/images/Identification_FontSize.xml create mode 100644 legoresources/images/Identification_FontSize_0.png create mode 100644 legoresources/images/Identification_FontSize_1.png create mode 100644 legoresources/images/Identification_FontSize_2.png create mode 100644 legoresources/images/Identification_Height.png create mode 100644 legoresources/images/Identification_Hz.png create mode 100644 legoresources/images/Identification_Index.png create mode 100644 legoresources/images/Identification_Invert.xml create mode 100644 legoresources/images/Identification_InvertColor.xml create mode 100644 legoresources/images/Identification_InvertColorCircle_False.png create mode 100644 legoresources/images/Identification_InvertColorCircle_True.png create mode 100644 legoresources/images/Identification_InvertColorLine_False.png create mode 100644 legoresources/images/Identification_InvertColorLine_True.png create mode 100644 legoresources/images/Identification_InvertColorPoint_False.png create mode 100644 legoresources/images/Identification_InvertColorPoint_True.png create mode 100644 legoresources/images/Identification_InvertColorRect_False.png create mode 100644 legoresources/images/Identification_InvertColorRect_True.png create mode 100644 legoresources/images/Identification_InvertColorText_False.png create mode 100644 legoresources/images/Identification_InvertColorText_True.png create mode 100644 legoresources/images/Identification_InvertColor_0.png create mode 100644 legoresources/images/Identification_InvertColor_1.png create mode 100644 legoresources/images/Identification_Invert_0.png create mode 100644 legoresources/images/Identification_Invert_1.png create mode 100644 legoresources/images/Identification_Joule.png create mode 100644 legoresources/images/Identification_LEDColor.xml create mode 100644 legoresources/images/Identification_LEDColor_Green.png create mode 100644 legoresources/images/Identification_LEDColor_Orange.png create mode 100644 legoresources/images/Identification_LEDColor_Red.png create mode 100644 legoresources/images/Identification_Length.png create mode 100644 legoresources/images/Identification_LowerBound.png create mode 100644 legoresources/images/Identification_MeasuredColor.png create mode 100644 legoresources/images/Identification_MeasuredLight.png create mode 100644 legoresources/images/Identification_MeasuringMode.xml create mode 100644 legoresources/images/Identification_MeasuringMode_Continuous.png create mode 100644 legoresources/images/Identification_MeasuringMode_Ping.png create mode 100644 legoresources/images/Identification_Message.png create mode 100644 legoresources/images/Identification_MessageTitle.png create mode 100644 legoresources/images/Identification_MotorRotation.png create mode 100644 legoresources/images/Identification_NXTBrickButtons.xml create mode 100644 legoresources/images/Identification_Note.png create mode 100644 legoresources/images/Identification_NumberOfDecimals.png create mode 100644 legoresources/images/Identification_NumberRotations.png create mode 100644 legoresources/images/Identification_Numeric.png create mode 100644 legoresources/images/Identification_OutVolts.png create mode 100644 legoresources/images/Identification_OutWatts.png create mode 100644 legoresources/images/Identification_OutpuNumberDegrees.png create mode 100644 legoresources/images/Identification_OutputBoolean.png create mode 100644 legoresources/images/Identification_OutputBrickButton.xml create mode 100644 legoresources/images/Identification_OutputBrickButtonID.png create mode 100644 legoresources/images/Identification_OutputBrickButtonID.xml create mode 100644 legoresources/images/Identification_OutputBrickButtonID_0.png create mode 100644 legoresources/images/Identification_OutputBrickButtonID_0_Selected.png create mode 100644 legoresources/images/Identification_OutputBrickButtonID_0_Unselected.png create mode 100644 legoresources/images/Identification_OutputBrickButtonID_1.png create mode 100644 legoresources/images/Identification_OutputBrickButtonID_1_Selected.png create mode 100644 legoresources/images/Identification_OutputBrickButtonID_1_Unselected.png create mode 100644 legoresources/images/Identification_OutputBrickButtonID_2.png create mode 100644 legoresources/images/Identification_OutputBrickButtonID_2_Selected.png create mode 100644 legoresources/images/Identification_OutputBrickButtonID_2_Unselected.png create mode 100644 legoresources/images/Identification_OutputBrickButtonID_3.png create mode 100644 legoresources/images/Identification_OutputBrickButtonID_3_Selected.png create mode 100644 legoresources/images/Identification_OutputBrickButtonID_3_Unselected.png create mode 100644 legoresources/images/Identification_OutputBrickButtonID_4.png create mode 100644 legoresources/images/Identification_OutputBrickButtonID_4_Selected.png create mode 100644 legoresources/images/Identification_OutputBrickButtonID_4_Unselected.png create mode 100644 legoresources/images/Identification_OutputBrickButtonID_5.png create mode 100644 legoresources/images/Identification_OutputBrickButtonID_5_Selected.png create mode 100644 legoresources/images/Identification_OutputBrickButtonID_5_Unselected.png create mode 100644 legoresources/images/Identification_OutputButtonID.xml create mode 100644 legoresources/images/Identification_OutputButtonID_0.png create mode 100644 legoresources/images/Identification_OutputButtonID_1.png create mode 100644 legoresources/images/Identification_OutputButtonID_10.png create mode 100644 legoresources/images/Identification_OutputButtonID_11.png create mode 100644 legoresources/images/Identification_OutputButtonID_2.png create mode 100644 legoresources/images/Identification_OutputButtonID_3.png create mode 100644 legoresources/images/Identification_OutputButtonID_4.png create mode 100644 legoresources/images/Identification_OutputButtonID_5.png create mode 100644 legoresources/images/Identification_OutputButtonID_6.png create mode 100644 legoresources/images/Identification_OutputButtonID_7.png create mode 100644 legoresources/images/Identification_OutputButtonID_8.png create mode 100644 legoresources/images/Identification_OutputButtonID_9.png create mode 100644 legoresources/images/Identification_OutputChannel.png create mode 100644 legoresources/images/Identification_OutputCompare.png create mode 100644 legoresources/images/Identification_OutputCompareResult_1.png create mode 100644 legoresources/images/Identification_OutputDistance.png create mode 100644 legoresources/images/Identification_OutputHeading.png create mode 100644 legoresources/images/Identification_OutputNumeric.png create mode 100644 legoresources/images/Identification_PlayType.xml create mode 100644 legoresources/images/Identification_PlayType_PlayOnce.png create mode 100644 legoresources/images/Identification_PlayType_Repeat.png create mode 100644 legoresources/images/Identification_PlayType_WaitForCompletion.png create mode 100644 legoresources/images/Identification_Port.png create mode 100644 legoresources/images/Identification_ProbabilityOfTrue.png create mode 100644 legoresources/images/Identification_Pulse.png create mode 100644 legoresources/images/Identification_Radius.png create mode 100644 legoresources/images/Identification_RandomValue.png create mode 100644 legoresources/images/Identification_Rate.png create mode 100644 legoresources/images/Identification_RateUnit.xml create mode 100644 legoresources/images/Identification_RateUnit_0.png create mode 100644 legoresources/images/Identification_RateUnit_1.png create mode 100644 legoresources/images/Identification_ReceivingBrickName.png create mode 100644 legoresources/images/Identification_Result.png create mode 100644 legoresources/images/Identification_SensorPort.xml create mode 100644 legoresources/images/Identification_SensorPort_0.png create mode 100644 legoresources/images/Identification_SensorPort_1.png create mode 100644 legoresources/images/Identification_SensorPort_2.png create mode 100644 legoresources/images/Identification_SensorPort_3.png create mode 100644 legoresources/images/Identification_SetOfChannels.xml create mode 100644 legoresources/images/Identification_SetOfChannels_1.png create mode 100644 legoresources/images/Identification_SetOfChannels_2.png create mode 100644 legoresources/images/Identification_SetOfChannels_3.png create mode 100644 legoresources/images/Identification_SetOfChannels_4.png create mode 100644 legoresources/images/Identification_Speed.xml create mode 100644 legoresources/images/Identification_Speed_0.png create mode 100644 legoresources/images/Identification_Speed_Minus100.png create mode 100644 legoresources/images/Identification_Speed_Minus25.png create mode 100644 legoresources/images/Identification_Speed_Minus50.png create mode 100644 legoresources/images/Identification_Speed_Minus75.png create mode 100644 legoresources/images/Identification_Speed_Plus100.png create mode 100644 legoresources/images/Identification_Speed_Plus25.png create mode 100644 legoresources/images/Identification_Speed_Plus50.png create mode 100644 legoresources/images/Identification_Speed_Plus75.png create mode 100644 legoresources/images/Identification_Steering.xml create mode 100644 legoresources/images/Identification_Steering_Backward_+1.png create mode 100644 legoresources/images/Identification_Steering_Backward_+2.png create mode 100644 legoresources/images/Identification_Steering_Backward_+3.png create mode 100644 legoresources/images/Identification_Steering_Backward_+4.png create mode 100644 legoresources/images/Identification_Steering_Backward_-1.png create mode 100644 legoresources/images/Identification_Steering_Backward_-2.png create mode 100644 legoresources/images/Identification_Steering_Backward_-3.png create mode 100644 legoresources/images/Identification_Steering_Backward_-4.png create mode 100644 legoresources/images/Identification_Steering_Backward_0.png create mode 100644 legoresources/images/Identification_Steering_Forward_+1.png create mode 100644 legoresources/images/Identification_Steering_Forward_+2.png create mode 100644 legoresources/images/Identification_Steering_Forward_+3.png create mode 100644 legoresources/images/Identification_Steering_Forward_+4.png create mode 100644 legoresources/images/Identification_Steering_Forward_-1.png create mode 100644 legoresources/images/Identification_Steering_Forward_-2.png create mode 100644 legoresources/images/Identification_Steering_Forward_-3.png create mode 100644 legoresources/images/Identification_Steering_Forward_-4.png create mode 100644 legoresources/images/Identification_Steering_Forward_0.png create mode 100644 legoresources/images/Identification_StringB.png create mode 100644 legoresources/images/Identification_StringC.png create mode 100644 legoresources/images/Identification_Test.png create mode 100644 legoresources/images/Identification_Text.png create mode 100644 legoresources/images/Identification_Threshold_Current.xml create mode 100644 legoresources/images/Identification_Threshold_Current_Out.xml create mode 100644 legoresources/images/Identification_Threshold_Degrees.xml create mode 100644 legoresources/images/Identification_Threshold_Equal_+1.png create mode 100644 legoresources/images/Identification_Threshold_Equal_+2.png create mode 100644 legoresources/images/Identification_Threshold_Equal_-1.png create mode 100644 legoresources/images/Identification_Threshold_Equal_-2.png create mode 100644 legoresources/images/Identification_Threshold_Equal_0.png create mode 100644 legoresources/images/Identification_Threshold_Greater_+1.png create mode 100644 legoresources/images/Identification_Threshold_Greater_+2.png create mode 100644 legoresources/images/Identification_Threshold_Greater_-1.png create mode 100644 legoresources/images/Identification_Threshold_Greater_-2.png create mode 100644 legoresources/images/Identification_Threshold_Greater_0.png create mode 100644 legoresources/images/Identification_Threshold_Gyro.xml create mode 100644 legoresources/images/Identification_Threshold_IRBeaconHeading.xml create mode 100644 legoresources/images/Identification_Threshold_Less_+1.png create mode 100644 legoresources/images/Identification_Threshold_Less_+2.png create mode 100644 legoresources/images/Identification_Threshold_Less_-1.png create mode 100644 legoresources/images/Identification_Threshold_Less_-2.png create mode 100644 legoresources/images/Identification_Threshold_Less_0.png create mode 100644 legoresources/images/Identification_Threshold_NotEqual_+1.png create mode 100644 legoresources/images/Identification_Threshold_NotEqual_+2.png create mode 100644 legoresources/images/Identification_Threshold_NotEqual_-1.png create mode 100644 legoresources/images/Identification_Threshold_NotEqual_-2.png create mode 100644 legoresources/images/Identification_Threshold_NotEqual_0.png create mode 100644 legoresources/images/Identification_Threshold_Rotations.xml create mode 100644 legoresources/images/Identification_Threshold_Speed.xml create mode 100644 legoresources/images/Identification_Threshold_TemperatureCelsius.xml create mode 100644 legoresources/images/Identification_Threshold_TemperatureFahrenheit.xml create mode 100644 legoresources/images/Identification_Threshold_Timer.xml create mode 100644 legoresources/images/Identification_Threshold_UltrasonicCm.xml create mode 100644 legoresources/images/Identification_Threshold_UltrasonicInches.xml create mode 100644 legoresources/images/Identification_Threshold_Voltage_Out.xml create mode 100644 legoresources/images/Identification_Threshold_Wattage.xml create mode 100644 legoresources/images/Identification_Threshold_Wattage_Out.xml create mode 100644 legoresources/images/Identification_Time.png create mode 100644 legoresources/images/Identification_Timer.xml create mode 100644 legoresources/images/Identification_TimerID_0.png create mode 100644 legoresources/images/Identification_TimerID_1.png create mode 100644 legoresources/images/Identification_TimerID_2.png create mode 100644 legoresources/images/Identification_TimerID_3.png create mode 100644 legoresources/images/Identification_TimerID_4.png create mode 100644 legoresources/images/Identification_TimerID_5.png create mode 100644 legoresources/images/Identification_TimerID_6.png create mode 100644 legoresources/images/Identification_TimerID_7.png create mode 100644 legoresources/images/Identification_Touch.png create mode 100644 legoresources/images/Identification_TouchState.xml create mode 100644 legoresources/images/Identification_TouchState2_Pressed.png create mode 100644 legoresources/images/Identification_TouchState2_Released.png create mode 100644 legoresources/images/Identification_TouchState_Bumped.png create mode 100644 legoresources/images/Identification_TouchState_Pressed.png create mode 100644 legoresources/images/Identification_TouchState_Released.png create mode 100644 legoresources/images/Identification_TrueFalse.png create mode 100644 legoresources/images/Identification_UltrasoundDetected.png create mode 100644 legoresources/images/Identification_Until.png create mode 100644 legoresources/images/Identification_UpperBound.png create mode 100644 legoresources/images/Identification_Valid.png create mode 100644 legoresources/images/Identification_Value.png create mode 100644 legoresources/images/Identification_Volume.xml create mode 100644 legoresources/images/Identification_Volume_0.png create mode 100644 legoresources/images/Identification_Volume_100.png create mode 100644 legoresources/images/Identification_Volume_25.png create mode 100644 legoresources/images/Identification_Volume_50.png create mode 100644 legoresources/images/Identification_Volume_75.png create mode 100644 legoresources/images/Identification_WaitForChange.xml create mode 100644 legoresources/images/Identification_WaitForChange_Both.png create mode 100644 legoresources/images/Identification_WaitForChange_Down.png create mode 100644 legoresources/images/Identification_WaitForChange_Up.png create mode 100644 legoresources/images/Identification_Width.png create mode 100644 legoresources/images/Identification_angle.png create mode 100644 legoresources/images/Identification_x.png create mode 100644 legoresources/images/Identification_x1.png create mode 100644 legoresources/images/Identification_x2.png create mode 100644 legoresources/images/Identification_xColumn.png create mode 100644 legoresources/images/Identification_y.png create mode 100644 legoresources/images/Identification_y1.png create mode 100644 legoresources/images/Identification_y2.png create mode 100644 legoresources/images/Identification_yRow.png create mode 100644 legoresources/images/Intensity.png create mode 100644 legoresources/images/KeepAlive.png create mode 100644 legoresources/images/LEGO_Add_Block.png create mode 100644 legoresources/images/LEGO_Add_Palette.png create mode 100644 legoresources/images/LEGO_Arithmetic_Block.png create mode 100644 legoresources/images/LEGO_Data_Logger_Block.png create mode 100644 legoresources/images/LEGO_Display_Block.png create mode 100644 legoresources/images/LEGO_Display_Palette.png create mode 100644 legoresources/images/LEGO_Light_Sensor_ActivityPortClaim.png create mode 100644 legoresources/images/LEGO_Light_Sensor_Block.png create mode 100644 legoresources/images/LEGO_Light_Sensor_Compare_Block.png create mode 100644 legoresources/images/LEGO_Light_Sensor_Palette.png create mode 100644 legoresources/images/LEGO_Motor_Block.png create mode 100644 legoresources/images/LEGO_Move_Block.png create mode 100644 legoresources/images/LEGO_Play_Note_ActivityPortClaim.png create mode 100644 legoresources/images/LEGO_Play_Note_Block.png create mode 100644 legoresources/images/LEGO_Play_Note_Palette.png create mode 100644 legoresources/images/LEGO_Play_Sound_File_Block.png create mode 100644 legoresources/images/LEGO_Random_Block.png create mode 100644 legoresources/images/LEGO_Random_Palette.png create mode 100644 legoresources/images/LEGO_Range_Sensor_ActivityPortClaim.png create mode 100644 legoresources/images/LEGO_Range_Sensor_Block.png create mode 100644 legoresources/images/LEGO_Range_Sensor_Palette.png create mode 100644 legoresources/images/LEGO_Start_Block.png create mode 100644 legoresources/images/LEGO_Start_Palette.png create mode 100644 legoresources/images/LEGO_Stop_If_True.png create mode 100644 legoresources/images/LEGO_Touch_Sensor_ActivityPortClaim.png create mode 100644 legoresources/images/LEGO_Touch_Sensor_Palette.png create mode 100644 legoresources/images/LEGO_Variable_Block.png create mode 100644 legoresources/images/LEGO_Variable_Palette.png create mode 100644 legoresources/images/LEGO_Wait_For_Signal_Palette.png create mode 100644 legoresources/images/LEGO_Wait_Icon.png create mode 100644 legoresources/images/LEGO_Wait_Time_Block.png create mode 100644 legoresources/images/LEGO_Wait_Touch_Block.png create mode 100644 legoresources/images/LessEqualsIcon.png create mode 100644 legoresources/images/LessIcon.png create mode 100644 legoresources/images/LoopIcon.png create mode 100644 legoresources/images/MinusIcon.png create mode 100644 legoresources/images/Mode_Light.png create mode 100644 legoresources/images/Mode_Run_Forever.png create mode 100644 legoresources/images/Mode_color.png create mode 100644 legoresources/images/Mode_display.png create mode 100644 legoresources/images/MultiplyIcon.png create mode 100644 legoresources/images/NotEqualsIcon.png create mode 100644 legoresources/images/Palette_Loop.png create mode 100644 legoresources/images/Palette_Loop_Hilight.png create mode 100644 legoresources/images/Palette_Loop_MouseOver.png create mode 100644 legoresources/images/Palette_Start.png create mode 100644 legoresources/images/Palette_Start_Hilight.png create mode 100644 legoresources/images/Palette_Start_MouseOver.png create mode 100644 legoresources/images/Palette_Stop.png create mode 100644 legoresources/images/Palette_Stop_Hilight.png create mode 100644 legoresources/images/Palette_Stop_MouseOver.png create mode 100644 legoresources/images/Palette_Switch.png create mode 100644 legoresources/images/Palette_Switch_Hilight.png create mode 100644 legoresources/images/Palette_Switch_MouseOver.png create mode 100644 legoresources/images/Palette_Tabbed_Switch.png create mode 100644 legoresources/images/Palette_Tabbed_Switch_Hilight.png create mode 100644 legoresources/images/Palette_Tabbed_Switch_MouseOver.png create mode 100644 legoresources/images/PlayIcon.png create mode 100644 legoresources/images/PlusIcon.png create mode 100644 legoresources/images/PolyGroup_Arithmetic_Diagram.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Diagram.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Mode_Append_Boolean_Diagram.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Mode_Append_Boolean_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Mode_Append_Numeric_Diagram.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Mode_Append_Numeric_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Mode_Length_Boolean_Diagram.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Mode_Length_Boolean_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Mode_Length_Numeric_Diagram.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Mode_Length_Numeric_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Mode_ReadAtIndex_Boolean_Diagram.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Mode_ReadAtIndex_Boolean_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Mode_ReadAtIndex_Numeric_Diagram.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Mode_ReadAtIndex_Numeric_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Mode_SplitAtIndex_Boolean_Diagram.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Mode_SplitAtIndex_Boolean_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Mode_SplitAtIndex_Numeric_Diagram.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Mode_SplitAtIndex_Numeric_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Mode_WriteAtIndex_Boolean_Diagram.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Mode_WriteAtIndex_Boolean_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Mode_WriteAtIndex_Numeric_Diagram.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Mode_WriteAtIndex_Numeric_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Palette.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_PolyCategory_Append.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_PolyCategory_Append_Diagram.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_PolyCategory_Append_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_PolyCategory_Length.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_PolyCategory_Length_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_PolyCategory_ReadAtIndex.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_PolyCategory_ReadAtIndex_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_PolyCategory_SplitAtIndex.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_PolyCategory_SplitAtIndex_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_PolyCategory_WriteAtIndex.png create mode 100644 legoresources/images/PolyGroup_ArrayOperations_PolyCategory_WriteAtIndex_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Bluetooth_Diagram.png create mode 100644 legoresources/images/PolyGroup_Bluetooth_Mode_Clear_Diagram.png create mode 100644 legoresources/images/PolyGroup_Bluetooth_Mode_Clear_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Bluetooth_Mode_Initiate_Diagram.png create mode 100644 legoresources/images/PolyGroup_Bluetooth_Mode_Initiate_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Bluetooth_Mode_Off_Diagram.png create mode 100644 legoresources/images/PolyGroup_Bluetooth_Mode_Off_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Bluetooth_Mode_On_Diagram.png create mode 100644 legoresources/images/PolyGroup_Bluetooth_Mode_On_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Bluetooth_Palette.png create mode 100644 legoresources/images/PolyGroup_Bluetooth_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_BooleanOperations_Diagram.png create mode 100644 legoresources/images/PolyGroup_BooleanOperations_Mode_And_Diagram.png create mode 100644 legoresources/images/PolyGroup_BooleanOperations_Mode_And_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_BooleanOperations_Mode_Not_Diagram.png create mode 100644 legoresources/images/PolyGroup_BooleanOperations_Mode_Not_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_BooleanOperations_Mode_Or_Diagram.png create mode 100644 legoresources/images/PolyGroup_BooleanOperations_Mode_Or_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_BooleanOperations_Mode_XOR_Diagram.png create mode 100644 legoresources/images/PolyGroup_BooleanOperations_Mode_XOR_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_BooleanOperations_Palette.png create mode 100644 legoresources/images/PolyGroup_BooleanOperations_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_BrickButton_Category.png create mode 100644 legoresources/images/PolyGroup_BrickButton_Category_MouseOver.png create mode 100644 legoresources/images/PolyGroup_BrickButton_Diagram.png create mode 100644 legoresources/images/PolyGroup_BrickButton_Mode_ChangeBrickButton_Diagram.png create mode 100644 legoresources/images/PolyGroup_BrickButton_Mode_ChangeBrickButton_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_BrickButton_Mode_Compare_Diagram.png create mode 100644 legoresources/images/PolyGroup_BrickButton_Mode_Compare_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_BrickButton_Mode_Measure_Diagram.png create mode 100644 legoresources/images/PolyGroup_BrickButton_Mode_Measure_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_BrickButton_Palette.png create mode 100644 legoresources/images/PolyGroup_BrickButton_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ButtonSensor_Diagram.png create mode 100644 legoresources/images/PolyGroup_ButtonSensor_Palette.png create mode 100644 legoresources/images/PolyGroup_CaseSelector_Diagram.png create mode 100644 legoresources/images/PolyGroup_CaseSelector_Mode_Boolean_Diagram.png create mode 100644 legoresources/images/PolyGroup_CaseSelector_Mode_Boolean_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_CaseSelector_Mode_Numeric_Diagram.png create mode 100644 legoresources/images/PolyGroup_CaseSelector_Mode_Numeric_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_CaseSelector_Mode_String_Diagram.png create mode 100644 legoresources/images/PolyGroup_CaseSelector_Mode_String_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ColorLamp_Diagram.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Category.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Category_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Diagram.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_CalibrateMaxColor_Diagram.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_CalibrateMaxColor_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_CalibrateMinColor_Diagram.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_CalibrateMinColor_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_CalibrateResetColor_Diagram.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_CalibrateResetColor_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_ChangeAmbientLight_Diagram.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_ChangeAmbientLight_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_ChangeColor_Diagram.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_ChangeColor_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_ChangeReflectedLight_Diagram.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_ChangeReflectedLight_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_CompareAmbientLight_Diagram.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_CompareAmbientLight_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_CompareColor_Diagram.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_CompareColor_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_CompareReflectedLight_Diagram.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_CompareReflectedLight_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_MeasureAmbientLight_Diagram.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_MeasureAmbientLight_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_MeasureAmbientLight_Hardware.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_MeasureAmbientLight_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_MeasureColor_Diagram.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_MeasureColor_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_MeasureColor_Hardware.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_MeasureColor_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_MeasureReflectedLight_Diagram.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_MeasureReflectedLight_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_MeasureReflectedLight_Hardware.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Mode_MeasureReflectedLight_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Palette.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_PolyCategory_Calibrate.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_PolyCategory_Calibrate_MouseOver.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_PolyCategory_ReflectedLight@Calibrate.png create mode 100644 legoresources/images/PolyGroup_ColorSensor_PolyCategory_ReflectedLight@Calibrate_MouseOver.png create mode 100644 legoresources/images/PolyGroup_CommentBlock_Diagram.png create mode 100644 legoresources/images/PolyGroup_CommentBlock_Palette.png create mode 100644 legoresources/images/PolyGroup_CommentBlock_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Compare_Diagram.png create mode 100644 legoresources/images/PolyGroup_Compare_Mode_Equal_Diagram.png create mode 100644 legoresources/images/PolyGroup_Compare_Mode_Equal_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Compare_Mode_GreaterOrEqual_Diagram.png create mode 100644 legoresources/images/PolyGroup_Compare_Mode_GreaterOrEqual_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Compare_Mode_GreaterThan_Diagram.png create mode 100644 legoresources/images/PolyGroup_Compare_Mode_GreaterThan_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Compare_Mode_LessOrEqual_Diagram.png create mode 100644 legoresources/images/PolyGroup_Compare_Mode_LessOrEqual_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Compare_Mode_LessThan_Diagram.png create mode 100644 legoresources/images/PolyGroup_Compare_Mode_LessThan_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Compare_Mode_NotEqual_Diagram.png create mode 100644 legoresources/images/PolyGroup_Compare_Mode_NotEqual_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Compare_Palette.png create mode 100644 legoresources/images/PolyGroup_Compare_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Constant_Diagram.png create mode 100644 legoresources/images/PolyGroup_Constant_Mode_BooleanArray_Diagram.png create mode 100644 legoresources/images/PolyGroup_Constant_Mode_BooleanArray_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Constant_Mode_Boolean_Diagram.png create mode 100644 legoresources/images/PolyGroup_Constant_Mode_Boolean_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Constant_Mode_NumericArray_Diagram.png create mode 100644 legoresources/images/PolyGroup_Constant_Mode_NumericArray_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Constant_Mode_Numeric_Diagram.png create mode 100644 legoresources/images/PolyGroup_Constant_Mode_Numeric_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Constant_Mode_Text_Diagram.png create mode 100644 legoresources/images/PolyGroup_Constant_Mode_Text_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Constant_Palette.png create mode 100644 legoresources/images/PolyGroup_Constant_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_DataArrayOperations_Mode_AppendNumeric_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Datalogging_Diagram.png create mode 100644 legoresources/images/PolyGroup_Datalogging_Mode_OnForTimeMinute_Diagram.png create mode 100644 legoresources/images/PolyGroup_Datalogging_Mode_OnForTimeMinute_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Datalogging_Mode_OnForTimeSeconds_Diagram.png create mode 100644 legoresources/images/PolyGroup_Datalogging_Mode_OnForTimeSeconds_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Datalogging_Mode_On_Diagram.png create mode 100644 legoresources/images/PolyGroup_Datalogging_Mode_On_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Datalogging_Mode_SingleMeasurement_Diagram.png create mode 100644 legoresources/images/PolyGroup_Datalogging_Mode_SingleMeasurement_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Datalogging_Mode_Stop_Diagram.png create mode 100644 legoresources/images/PolyGroup_Datalogging_Mode_Stop_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Datalogging_Palette.png create mode 100644 legoresources/images/PolyGroup_Datalogging_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Datalogging_PolyCategory_OnForTime.png create mode 100644 legoresources/images/PolyGroup_Datalogging_PolyCategory_OnForTime_Mouseover.png create mode 100644 legoresources/images/PolyGroup_Display_Diagram.png create mode 100644 legoresources/images/PolyGroup_Display_Hardware.png create mode 100644 legoresources/images/PolyGroup_Display_Mode_Circle_Diagram.png create mode 100644 legoresources/images/PolyGroup_Display_Mode_Circle_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Display_Mode_Clear_Diagram.png create mode 100644 legoresources/images/PolyGroup_Display_Mode_Clear_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Display_Mode_File_Diagram.png create mode 100644 legoresources/images/PolyGroup_Display_Mode_File_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Display_Mode_Line_Diagram.png create mode 100644 legoresources/images/PolyGroup_Display_Mode_Line_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Display_Mode_Point_Diagram.png create mode 100644 legoresources/images/PolyGroup_Display_Mode_Point_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Display_Mode_Rectangle_Diagram.png create mode 100644 legoresources/images/PolyGroup_Display_Mode_Rectangle_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Display_Mode_StringGrid_Diagram.png create mode 100644 legoresources/images/PolyGroup_Display_Mode_StringGrid_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Display_Mode_String_Diagram.png create mode 100644 legoresources/images/PolyGroup_Display_Mode_String_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Display_Palette.png create mode 100644 legoresources/images/PolyGroup_Display_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Display_PolyCategory_Shapes.png create mode 100644 legoresources/images/PolyGroup_Display_PolyCategory_Shapes_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Display_PolyCategory_Text.png create mode 100644 legoresources/images/PolyGroup_Display_PolyCategory_Text_MouseOver.png create mode 100644 legoresources/images/PolyGroup_DistanceSensor_Diagram.png create mode 100644 legoresources/images/PolyGroup_EMeterSensor_Diagram.png create mode 100644 legoresources/images/PolyGroup_EMeterSensor_Palette.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Category.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Category_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_ChangeInCurrent_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_ChangeInCurrent_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_ChangeInVoltage_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_ChangeInVoltage_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_ChangeInWatt_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_ChangeInWatt_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_ChangeJoule_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_ChangeJoule_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_ChangeOutCurrent_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_ChangeOutCurrent_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_ChangeOutVoltage_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_ChangeOutVoltage_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_ChangeOutWatt_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_ChangeOutWatt_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_CompareInCurrent_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_CompareInCurrent_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_CompareInVoltage_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_CompareInVoltage_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_CompareInWatt_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_CompareInWatt_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_CompareOutCurrent_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_CompareOutCurrent_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_CompareOutJoule_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_CompareOutJoule_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_CompareOutVoltage_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_CompareOutVoltage_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_CompareOutWatt_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_CompareOutWatt_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureInCurrent_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureInCurrent_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureInCurrent_Hardware.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureInCurrent_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureInVoltage_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureInVoltage_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureInVoltage_Hardware.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureInVoltage_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureInWatts_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureInWatts_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureInWatts_Hardware.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureInWatts_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureJoule_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureJoule_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureJoule_Hardware.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureJoule_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureOutCurrent_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureOutCurrent_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureOutCurrent_Hardware.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureOutCurrent_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureOutVolt_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureOutVoltage_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureOutVoltage_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureOutVoltage_Hardware.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureOutVoltage_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureOutWatts_Diagram.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureOutWatts_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureOutWatts_Hardware.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Mode_MeasureOutWatts_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Palette.png create mode 100644 legoresources/images/PolyGroup_EnergyMeter_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_FileAccess_Diagram.png create mode 100644 legoresources/images/PolyGroup_FileAccess_Mode_Close_Diagram.png create mode 100644 legoresources/images/PolyGroup_FileAccess_Mode_Close_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_FileAccess_Mode_Delete_Diagram.png create mode 100644 legoresources/images/PolyGroup_FileAccess_Mode_Delete_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_FileAccess_Mode_Numeric_Diagram.png create mode 100644 legoresources/images/PolyGroup_FileAccess_Mode_Numeric_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_FileAccess_Mode_Text_Diagram.png create mode 100644 legoresources/images/PolyGroup_FileAccess_Mode_Text_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_FileAccess_Mode_Write_Diagram.png create mode 100644 legoresources/images/PolyGroup_FileAccess_Mode_Write_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_FileAccess_Palette.png create mode 100644 legoresources/images/PolyGroup_FileAccess_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_FileAccess_PolyCategory_Read.png create mode 100644 legoresources/images/PolyGroup_FileAccess_PolyCategory_Read_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Gyro_Category.png create mode 100644 legoresources/images/PolyGroup_Gyro_Category_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Gyro_Diagram.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_ChangeAngle_Diagram.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_ChangeAngle_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_ChangeRate_Diagram.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_ChangeRate_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_CompareAngle_Diagram.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_CompareAngle_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_CompareRate_Diagram.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_CompareRate_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_MeasureAngle.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_MeasureAngleAndRate_Diagram.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_MeasureAngleAndRate_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_MeasureAngle_Diagram.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_MeasureAngle_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_MeasureAngle_Hardware.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_MeasureAngle_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_MeasureAngle_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_MeasureRate_Diagram.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_MeasureRate_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_MeasureRate_Hardware.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_MeasureRate_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_Reset_Diagram.png create mode 100644 legoresources/images/PolyGroup_Gyro_Mode_Reset_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Gyro_Palette.png create mode 100644 legoresources/images/PolyGroup_Gyro_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_HWPageManualInput_Mode_Blank_Diagram.png create mode 100644 legoresources/images/PolyGroup_HWPageManualInput_Mode_Blank_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_HWPageManualOutput_Mode_Blank_Diagram.png create mode 100644 legoresources/images/PolyGroup_HWPageManualOutput_Mode_Blank_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_IICSensor_Category.png create mode 100644 legoresources/images/PolyGroup_IICSensor_Category_Mouseover.png create mode 100644 legoresources/images/PolyGroup_IICSensor_Diagram.png create mode 100644 legoresources/images/PolyGroup_IICSensor_Mode_IICByte_Hardware.png create mode 100644 legoresources/images/PolyGroup_IICSensor_Mode_IICByte_Hardware_Mouseover.png create mode 100644 legoresources/images/PolyGroup_IICSensor_Mode_IICWord_Hardware.png create mode 100644 legoresources/images/PolyGroup_IICSensor_Mode_IICWord_Hardware_Mouseover.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Category.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Category_MouseOver.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Diagram.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_ChangeBeaconProximity_Diagram.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_ChangeBeaconProximity_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_ChangeHeading_Diagram.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_ChangeHeading_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_ChangeProximity_Diagram.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_ChangeProximity_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_ChangeRemote_Diagram.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_ChangeRemote_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_CompareBeaconSeekerHeading_Diagram.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_CompareBeaconSeekerHeading_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_CompareBeaconSeekerProximity_Diagram.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_CompareBeaconSeekerProximity_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_CompareProximity_Diagram.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_CompareProximity_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_CompareRemote_Diagram.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_CompareRemote_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_MeasureBeaconRemote_Diagram.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_MeasureBeaconRemote_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_MeasureBeaconRemote_Hardware.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_MeasureBeaconRemote_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_MeasureBeaconSeekerDataloggingHeading_Diagram.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_MeasureBeaconSeekerDataloggingHeading_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_MeasureBeaconSeekerDataloggingHeading_Hardware.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_MeasureBeaconSeekerDataloggingHeading_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_MeasureBeaconSeekerDataloggingProximity_Diagram.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_MeasureBeaconSeekerDataloggingProximity_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_MeasureBeaconSeekerDataloggingProximity_Hardware.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_MeasureBeaconSeekerDataloggingProximity_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_MeasureBeaconSeeker_Diagram.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_MeasureBeaconSeeker_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_MeasureProximity_Diagram.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_MeasureProximity_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_MeasureProximity_Hardware.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Mode_MeasureProximity_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Palette.png create mode 100644 legoresources/images/PolyGroup_InfraredSensor_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Interrupt_Mode_Interrupt_Diagram.png create mode 100644 legoresources/images/PolyGroup_Interrupt_Mode_Interrupt_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_InvertMotor_Diagram.png create mode 100644 legoresources/images/PolyGroup_InvertMotor_Mode_Invert_Diagram.png create mode 100644 legoresources/images/PolyGroup_InvertMotor_Mode_Invert_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_InvertMotor_Palette.png create mode 100644 legoresources/images/PolyGroup_InvertMotor_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_KeepAlive_Diagram.png create mode 100644 legoresources/images/PolyGroup_KeepAlive_Mode_KeepAlive_Diagram.png create mode 100644 legoresources/images/PolyGroup_KeepAlive_Mode_KeepAlive_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_KeepAlive_Palette.png create mode 100644 legoresources/images/PolyGroup_KeepAlive_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_LED_Diagram.png create mode 100644 legoresources/images/PolyGroup_LED_Hardware.png create mode 100644 legoresources/images/PolyGroup_LED_Help.png create mode 100644 legoresources/images/PolyGroup_LED_Mode_Off_Diagram.png create mode 100644 legoresources/images/PolyGroup_LED_Mode_Off_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_LED_Mode_On_Diagram.png create mode 100644 legoresources/images/PolyGroup_LED_Mode_On_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_LED_Mode_Reset_Diagram.png create mode 100644 legoresources/images/PolyGroup_LED_Mode_Reset_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_LED_Palette.png create mode 100644 legoresources/images/PolyGroup_LED_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_LightSensor_Diagram.png create mode 100644 legoresources/images/PolyGroup_LightSensor_Palette.png create mode 100644 legoresources/images/PolyGroup_LightSensor_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_LoopCondition_Diagram.png create mode 100644 legoresources/images/PolyGroup_LoopCondition_Mode_Boolean_Diagram.png create mode 100644 legoresources/images/PolyGroup_LoopCondition_Mode_Boolean_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_LoopCondition_Mode_Count_Diagram.png create mode 100644 legoresources/images/PolyGroup_LoopCondition_Mode_Count_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_LoopCondition_Mode_Time_Diagram.png create mode 100644 legoresources/images/PolyGroup_LoopCondition_Mode_Time_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_LoopCondition_Mode_Unlimited_Diagram.png create mode 100644 legoresources/images/PolyGroup_LoopCondition_Mode_Unlimited_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Math_Diagram.png create mode 100644 legoresources/images/PolyGroup_Math_Mode_AbsoluteValue_Diagram.png create mode 100644 legoresources/images/PolyGroup_Math_Mode_AbsoluteValue_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Math_Mode_Add_Diagram.png create mode 100644 legoresources/images/PolyGroup_Math_Mode_Add_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Math_Mode_Advanced_Diagram.png create mode 100644 legoresources/images/PolyGroup_Math_Mode_Advanced_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Math_Mode_Divide_Diagram.png create mode 100644 legoresources/images/PolyGroup_Math_Mode_Divide_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Math_Mode_Exponent_Diagram.png create mode 100644 legoresources/images/PolyGroup_Math_Mode_Exponent_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Math_Mode_Multiply_Diagram.png create mode 100644 legoresources/images/PolyGroup_Math_Mode_Multiply_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Math_Mode_SquareRoot_Diagram.png create mode 100644 legoresources/images/PolyGroup_Math_Mode_SquareRoot_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Math_Mode_Subtract_Diagram.png create mode 100644 legoresources/images/PolyGroup_Math_Mode_Subtract_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Math_Palette.png create mode 100644 legoresources/images/PolyGroup_Math_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Category.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Category_MouseOver.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Diagram.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Hardware.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_Advanced_Diagram.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_Advanced_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_Degrees_Diagram.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_Degrees_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_MeasureCurrentSpeed_Diagram.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_MeasureCurrentSpeed_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_MeasureCurrentSpeed_Hardware.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_MeasureCurrentSpeed_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_MeasureDegrees_Diagram.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_MeasureDegrees_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_MeasureDegrees_Hardware.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_MeasureDegrees_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_MeasureRotation_Diagram.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_MeasureRotation_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_MeasureRotation_Hardware.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_MeasureRotation_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_Rotations_Diagram.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_Rotations_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_Stop_Diagram.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_Stop_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_Time_Diagram.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_Time_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_Unlimited_Diagram.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Mode_Unlimited_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Palette.png create mode 100644 legoresources/images/PolyGroup_MediumMotor_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Messaging_Category.png create mode 100644 legoresources/images/PolyGroup_Messaging_Category_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Messaging_Diagram.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_ChangeBooleanUpdate_Diagram.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_ChangeBooleanUpdate_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_ChangeBooleanValue_Diagram.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_ChangeBooleanValue_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_ChangeNumericUpdate_Diagram.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_ChangeNumericUpdate_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_ChangeNumericValue_Diagram.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_ChangeNumericValue_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_ChangeTextUpdate_Diagram.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_ChangeTextUpdate_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_ChangeTextValue_Diagram.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_ChangeTextValue_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_CompareBoolean_Diagram.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_CompareBoolean_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_CompareNumeric_Diagram.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_CompareNumeric_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_CompareText_Diagram.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_CompareText_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_ReceiveBoolean_Diagram.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_ReceiveBoolean_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_ReceiveNumeric_Diagram.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_ReceiveNumeric_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_ReceiveText_Diagram.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_ReceiveText_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_SendBoolean_Diagram.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_SendBoolean_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_SendNumeric_Diagram.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_SendNumeric_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_SendText_Diagram.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_SendText_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_Send_Diagram.png create mode 100644 legoresources/images/PolyGroup_Messaging_Mode_Send_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Messaging_Palette.png create mode 100644 legoresources/images/PolyGroup_Messaging_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Messaging_PolyCategory_Receive.png create mode 100644 legoresources/images/PolyGroup_Messaging_PolyCategory_Receive_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Messaging_PolyCategory_Send.png create mode 100644 legoresources/images/PolyGroup_Messaging_PolyCategory_Send_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Motor_Category.png create mode 100644 legoresources/images/PolyGroup_Motor_Category_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Motor_Diagram.png create mode 100644 legoresources/images/PolyGroup_Motor_Hardware.png create mode 100644 legoresources/images/PolyGroup_Motor_Help.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_Advanced_Diagram.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_Advanced_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_Degrees_Diagram.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_Degrees_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_MeasureCurrentSpeed_Diagram.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_MeasureCurrentSpeed_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_MeasureCurrentSpeed_Hardware.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_MeasureCurrentSpeed_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_MeasureDegrees_Diagram.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_MeasureDegrees_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_MeasureDegrees_Hardware.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_MeasureDegrees_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_MeasureRotation_Diagram.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_MeasureRotation_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_MeasureRotation_Hardware.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_MeasureRotation_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_Rotations_Diagram.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_Rotations_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_Stop_Diagram.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_Stop_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_Time_Diagram.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_Time_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_Unlimited_Diagram.png create mode 100644 legoresources/images/PolyGroup_Motor_Mode_Unlimited_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Motor_Palette.png create mode 100644 legoresources/images/PolyGroup_Motor_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_MoveTank_Diagram.png create mode 100644 legoresources/images/PolyGroup_MoveTank_Hardware.png create mode 100644 legoresources/images/PolyGroup_MoveTank_Help.png create mode 100644 legoresources/images/PolyGroup_MoveTank_Mode_Advanced_Diagram.png create mode 100644 legoresources/images/PolyGroup_MoveTank_Mode_Advanced_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_MoveTank_Mode_Degrees_Diagram.png create mode 100644 legoresources/images/PolyGroup_MoveTank_Mode_Degrees_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_MoveTank_Mode_Rotations_Diagram.png create mode 100644 legoresources/images/PolyGroup_MoveTank_Mode_Rotations_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_MoveTank_Mode_Stop_Diagram.png create mode 100644 legoresources/images/PolyGroup_MoveTank_Mode_Stop_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_MoveTank_Mode_Time_Diagram.png create mode 100644 legoresources/images/PolyGroup_MoveTank_Mode_Time_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_MoveTank_Mode_Unlimited_Diagram.png create mode 100644 legoresources/images/PolyGroup_MoveTank_Mode_Unlimited_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_MoveTank_Palette.png create mode 100644 legoresources/images/PolyGroup_MoveTank_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Move_Diagram.png create mode 100644 legoresources/images/PolyGroup_Move_Hardware.png create mode 100644 legoresources/images/PolyGroup_Move_Help.png create mode 100644 legoresources/images/PolyGroup_Move_Mode_Advanced_Diagram.png create mode 100644 legoresources/images/PolyGroup_Move_Mode_Advanced_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Move_Mode_Degrees_Diagram.png create mode 100644 legoresources/images/PolyGroup_Move_Mode_Degrees_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Move_Mode_Rotations_Diagram.png create mode 100644 legoresources/images/PolyGroup_Move_Mode_Rotations_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Move_Mode_Stop_Diagram.png create mode 100644 legoresources/images/PolyGroup_Move_Mode_Stop_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Move_Mode_Time_Diagram.png create mode 100644 legoresources/images/PolyGroup_Move_Mode_Time_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Move_Mode_Unlimited_Diagram.png create mode 100644 legoresources/images/PolyGroup_Move_Mode_Unlimited_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Move_Palette.png create mode 100644 legoresources/images/PolyGroup_Move_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Random_Diagram.png create mode 100644 legoresources/images/PolyGroup_Random_Mode_Boolean_Diagram.png create mode 100644 legoresources/images/PolyGroup_Random_Mode_Boolean_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Random_Mode_Numeric_Diagram.png create mode 100644 legoresources/images/PolyGroup_Random_Mode_Numeric_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Random_Palette.png create mode 100644 legoresources/images/PolyGroup_Random_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Range_Diagram.png create mode 100644 legoresources/images/PolyGroup_Range_Mode_Inside_Diagram.png create mode 100644 legoresources/images/PolyGroup_Range_Mode_Inside_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Range_Mode_Outside_Diagram.png create mode 100644 legoresources/images/PolyGroup_Range_Mode_Outside_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Range_Palette.png create mode 100644 legoresources/images/PolyGroup_Range_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_RawSensorValue_Diagram.png create mode 100644 legoresources/images/PolyGroup_RawSensorValue_Mode_Raw_Diagram.png create mode 100644 legoresources/images/PolyGroup_RawSensorValue_Mode_Raw_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_RawSensorValue_Palette.png create mode 100644 legoresources/images/PolyGroup_RawSensorValue_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Category.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Category_MouseOver.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Diagram.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Mode_ChangeDegrees_Diagram.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Mode_ChangeDegrees_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Mode_ChangeRotation_Diagram.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Mode_ChangeRotation_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Mode_ChangeSpeed_Diagram.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Mode_ChangeSpeed_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Mode_CompareCurrentSpeed_Diagram.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Mode_CompareCurrentSpeed_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Mode_CompareDegrees_Diagram.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Mode_CompareDegrees_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Mode_CompareRotation_Diagram.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Mode_CompareRotation_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Mode_MeasureCurrentSpeed_Diagram.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Mode_MeasureCurrentSpeed_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Mode_MeasureDegrees_Diagram.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Mode_MeasureDegrees_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Mode_MeasureRotation_Diagram.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Mode_MeasureRotation_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Mode_Reset_Diagram.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Mode_Reset_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Palette.png create mode 100644 legoresources/images/PolyGroup_RotationSensor_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Round_Diagram.png create mode 100644 legoresources/images/PolyGroup_Round_Mode_Down_Diagram.png create mode 100644 legoresources/images/PolyGroup_Round_Mode_Down_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Round_Mode_Nearest_Diagram.png create mode 100644 legoresources/images/PolyGroup_Round_Mode_Nearest_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Round_Mode_Truncate_Diagram.png create mode 100644 legoresources/images/PolyGroup_Round_Mode_Truncate_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Round_Mode_Up_Diagram.png create mode 100644 legoresources/images/PolyGroup_Round_Mode_Up_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Round_Palette.png create mode 100644 legoresources/images/PolyGroup_Round_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Category.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Category_MouseOver.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Diagram.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_CalibrateMaxSound_Diagram.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_CalibrateMaxSound_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_CalibrateMinSound_Diagram.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_CalibrateMinSound_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_CalibrateResetSound_Diagram.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_CalibrateResetSound_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_ChangeDb_Diagram.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_ChangeDb_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_ChangeDba_Diagram.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_ChangeDba_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_ComparedB_Diagram.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_ComparedB_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_ComparedbA_Diagram.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_ComparedbA_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_MeasuredB_Diagram.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_MeasuredB_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_MeasuredB_Hardware.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_MeasuredB_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_MeasuredBa_Diagram.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_MeasuredBa_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_MeasuredBa_Hardware.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Mode_MeasuredBa_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Palette.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_PolyCategory_Calibrate.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_PolyCategory_Calibrate_MouseOver.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_PolyCategory_dB@Calibrate.png create mode 100644 legoresources/images/PolyGroup_SoundSensor_PolyCategory_dB@Calibrate_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Sound_Diagram.png create mode 100644 legoresources/images/PolyGroup_Sound_Hardware.png create mode 100644 legoresources/images/PolyGroup_Sound_Help.png create mode 100644 legoresources/images/PolyGroup_Sound_Mode_File_Diagram.png create mode 100644 legoresources/images/PolyGroup_Sound_Mode_File_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Sound_Mode_Note_Diagram.png create mode 100644 legoresources/images/PolyGroup_Sound_Mode_Note_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Sound_Mode_Stop_Diagram.png create mode 100644 legoresources/images/PolyGroup_Sound_Mode_Stop_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Sound_Mode_Tone_Diagram.png create mode 100644 legoresources/images/PolyGroup_Sound_Mode_Tone_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Sound_Palette.png create mode 100644 legoresources/images/PolyGroup_Sound_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_StartBlock_Diagram.png create mode 100644 legoresources/images/PolyGroup_StopBlock_Diagram.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Category.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Category_MouseOver.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Diagram.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Mode_ChangeCelsius_Diagram.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Mode_ChangeCelsius_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Mode_ChangeFahrenheit_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Mode_Changefahrenheit_Diagram.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Mode_CompareCelsius_Diagram.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Mode_CompareCelsius_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Mode_CompareFahrenheit_Diagram.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Mode_CompareFahrenheit_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Mode_FahrenhetCompare_PolyDiagram.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Mode_FahrenhetCompare_PolyDiagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Mode_MeasureCelsius_Diagram.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Mode_MeasureCelsius_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Mode_MeasureCelsius_Hardware.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Mode_MeasureCelsius_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Mode_MeasureFahrenheit_Diagram.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Mode_MeasureFahrenheit_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Mode_MeasureFahrenheit_Hardware.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Mode_MeasureFahrenheit_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Palette.png create mode 100644 legoresources/images/PolyGroup_TemperatureSensor_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Text_Diagram.png create mode 100644 legoresources/images/PolyGroup_Text_Mode_Merge_Diagram.png create mode 100644 legoresources/images/PolyGroup_Text_Mode_Merge_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Text_Palette.png create mode 100644 legoresources/images/PolyGroup_Text_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_TimerSensor_Diagram.png create mode 100644 legoresources/images/PolyGroup_TimerSensor_Palette.png create mode 100644 legoresources/images/PolyGroup_Timer_Category.png create mode 100644 legoresources/images/PolyGroup_Timer_Category_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Timer_Diagram.png create mode 100644 legoresources/images/PolyGroup_Timer_Mode_ChangeTime_Diagram.png create mode 100644 legoresources/images/PolyGroup_Timer_Mode_ChangeTime_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Timer_Mode_CompareTime_Diagram.png create mode 100644 legoresources/images/PolyGroup_Timer_Mode_CompareTime_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Timer_Mode_MeasureTime_Diagram.png create mode 100644 legoresources/images/PolyGroup_Timer_Mode_MeasureTime_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Timer_Mode_Reset_Diagram.png create mode 100644 legoresources/images/PolyGroup_Timer_Mode_Reset_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Timer_Palette.png create mode 100644 legoresources/images/PolyGroup_Timer_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_TouchSensor_Category.png create mode 100644 legoresources/images/PolyGroup_TouchSensor_Category_MouseOver.png create mode 100644 legoresources/images/PolyGroup_TouchSensor_Diagram.png create mode 100644 legoresources/images/PolyGroup_TouchSensor_Mode_ChangeState_Diagram.png create mode 100644 legoresources/images/PolyGroup_TouchSensor_Mode_ChangeState_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_TouchSensor_Mode_Compare_Diagram.png create mode 100644 legoresources/images/PolyGroup_TouchSensor_Mode_Compare_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_TouchSensor_Mode_Measure_Diagram.png create mode 100644 legoresources/images/PolyGroup_TouchSensor_Mode_Measure_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_TouchSensor_Mode_Measure_Hardware.png create mode 100644 legoresources/images/PolyGroup_TouchSensor_Mode_Measure_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_TouchSensor_Palette.png create mode 100644 legoresources/images/PolyGroup_TouchSensor_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_UltraSonicSensor_Category.png create mode 100644 legoresources/images/PolyGroup_UltraSonicSensor_Category_MouseOver.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Diagram.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_Centimeters_Diagram.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_Centimeters_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_Centimeters_Hardware.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_Centimeters_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_ChangeDistanceCm_Diagram.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_ChangeDistanceCm_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_ChangeDistanceInch_Diagram.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_ChangeDistanceInch_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_ChangeListen_Diagram.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_ChangeListen_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_CompareCentimeters_Diagram.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_CompareCentimeters_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_CompareInches_Diagram.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_CompareInches_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_ComparePresence_Diagram.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_ComparePresence_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_Inches_Diagram.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_Inches_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_Inches_Hardware.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_Inches_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_MeasureCentimeters_Diagram.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_MeasureCentimeters_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_MeasureCentimeters_Hardware.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_MeasureCentimeters_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_MeasureInches_Diagram.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_MeasureInches_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_MeasureInches_Hardware.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_MeasureInches_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_MeasurePresence_Diagram.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_MeasurePresence_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_MeasurePresence_Hardware.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Mode_MeasurePresence_Hardware_MouseOver.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Palette.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_PolyCategory_Advanced.png create mode 100644 legoresources/images/PolyGroup_UltrasonicSensor_PolyCategory_Advanced_MouseOver.png create mode 100644 legoresources/images/PolyGroup_UnregulatedMotor_Mode_UnregulatedMotor_Diagram.png create mode 100644 legoresources/images/PolyGroup_UnregulatedMotor_Mode_UnregulatedMotor_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Variable_Diagram.png create mode 100644 legoresources/images/PolyGroup_Variable_Mode_ReadBooleanArray_Diagram.png create mode 100644 legoresources/images/PolyGroup_Variable_Mode_ReadBooleanArray_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Variable_Mode_ReadBoolean_Diagram.png create mode 100644 legoresources/images/PolyGroup_Variable_Mode_ReadBoolean_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Variable_Mode_ReadNumericArray_Diagram.png create mode 100644 legoresources/images/PolyGroup_Variable_Mode_ReadNumericArray_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Variable_Mode_ReadNumeric_Diagram.png create mode 100644 legoresources/images/PolyGroup_Variable_Mode_ReadNumeric_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Variable_Mode_ReadText_Diagram.png create mode 100644 legoresources/images/PolyGroup_Variable_Mode_ReadText_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Variable_Mode_WriteBooleanArray_Diagram.png create mode 100644 legoresources/images/PolyGroup_Variable_Mode_WriteBooleanArray_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Variable_Mode_WriteBoolean_Diagram.png create mode 100644 legoresources/images/PolyGroup_Variable_Mode_WriteBoolean_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Variable_Mode_WriteNumericArray_Diagram.png create mode 100644 legoresources/images/PolyGroup_Variable_Mode_WriteNumericArray_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Variable_Mode_WriteNumeric_Diagram.png create mode 100644 legoresources/images/PolyGroup_Variable_Mode_WriteNumeric_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Variable_Mode_WriteText_Diagram.png create mode 100644 legoresources/images/PolyGroup_Variable_Mode_WriteText_Diagram_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Variable_Palette.png create mode 100644 legoresources/images/PolyGroup_Variable_Palette_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Variable_PolyCategory_Read.png create mode 100644 legoresources/images/PolyGroup_Variable_PolyCategory_Read_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Variable_PolyCategory_Write.png create mode 100644 legoresources/images/PolyGroup_Variable_PolyCategory_Write_MouseOver.png create mode 100644 legoresources/images/PolyGroup_Wait_Diagram.png create mode 100644 legoresources/images/PolyGroup_Wait_Palette.png create mode 100644 legoresources/images/PolyGroup_Wait_Palette_MouseOver.png create mode 100644 legoresources/images/Polygroup_Interrupt_Diagram.png create mode 100644 legoresources/images/Polygroup_Interrupt_Palette.png create mode 100644 legoresources/images/Polygroup_Interrupt_Palette_MouseOver.png create mode 100644 legoresources/images/Polygroup_UnregulatedMotor_Diagram.png create mode 100644 legoresources/images/Polygroup_UnregulatedMotor_Help.png create mode 100644 legoresources/images/Polygroup_UnregulatedMotor_Palette.png create mode 100644 legoresources/images/Polygroup_UnregulatedMotor_Palette_Mouseover.png create mode 100644 legoresources/images/Polygroup_Wait_Mode_Timer_Diagram.png create mode 100644 legoresources/images/Polygroup_Wait_Mode_Timer_Diagram_MouseOver.png create mode 100644 legoresources/images/PortConfigurator_Conflict.png create mode 100644 legoresources/images/Range_L_R.png create mode 100644 legoresources/images/StopBlockIcon.png create mode 100644 legoresources/images/StopIcon.png create mode 100644 legoresources/images/TankIcon.png create mode 100644 legoresources/images/TempBlockIcon.png create mode 100644 legoresources/images/Timer.png create mode 100644 legoresources/images/Unknown.png create mode 100644 legoresources/images/Unlimited.png create mode 100644 legoresources/images/ValueDisplay_Boolean.xml create mode 100644 legoresources/images/ValueDisplay_Boolean_False.png create mode 100644 legoresources/images/ValueDisplay_Boolean_False_MouseOver.png create mode 100644 legoresources/images/ValueDisplay_Boolean_True.png create mode 100644 legoresources/images/ValueDisplay_Boolean_True_MouseOver.png create mode 100644 legoresources/images/XVariable.png create mode 100644 legoresources/images/YVariable.png create mode 100644 legoresources/images/ZVariable.png create mode 100644 legoresources/images/_Id_Temp_34x34.png create mode 100644 legoresources/images/aaa_PortConfigurator_EmptyMotor.png create mode 100644 legoresources/images/aaa_PortConfigurator_EmptySensor.png create mode 100644 legoresources/images/angleTerminalIcon.png create mode 100644 legoresources/images/color_wheel.png create mode 100644 legoresources/images/displayxyz.png create mode 100644 legoresources/images/icons-03.png create mode 100644 legoresources/images/icons-05.png create mode 100644 legoresources/images/identification_StringA.png create mode 100644 legoresources/images/thomas_range.png diff --git a/legoresources/images/BIGbulb.png b/legoresources/images/BIGbulb.png new file mode 100644 index 0000000000000000000000000000000000000000..36828aec6282240ed81eacd1c3a00c8cbc9b235f GIT binary patch literal 2690 zcmV-|3Vrp7P)p}WiUq6^)VAAVanZgOcH8Z~U-y0P-+aHv%w<9d`hWYg=4xP!EoMAcW7R)VV+;D5i%@GBCT`T2sjd25zLmrL8splQ zpXoZm+OQBTa?fqCOK-d;bbTzsx_wTjBuOq-?;GBsFWsB%K_3TJgq2`rn5V%ncm>#8 zOK<^sFwJJ`>ZX@ZQFtH6INF>5Ue zJ_87JuwHGF!)p86Ci7lc-D*RWdO6mx~v9=AI(LIR5E@qKivNs7#@0c*@Ur%L1^kgk#q?%9m|>{06M>|V3+o%UsD zY?kqVK8YCh=sCG!)h2RNWY~Bqm!JVkR2eh_FIRwc*}={(KZIHuQIp{<1zO5XIrulORDk;aw zk4oQQb~|2#w2kDzJqZHl6=9CLstI^9mE*Hp(x2rd(8n#H5Bj_E898Y~MIdIcB(FG0 zM+ZGwe^lzJv*%-4K3o|coA|o~XhgboxUv+p!p*BJC$GGe0hy>Xe1L<-1uv@mzLP@ z8$`#9-raah*>1_%mcO|p_m_`s=zn$1rR~=k(MurZ*L2On19_Cj)kehg(_}R#l!O>S zOG&utDI}$WB9K{l#tf1Vi*|zPM$}QK>4B%Se?o_u8qoe?$XfTI-)47I@&jPh zMwNz)%XEqsMi9cv06jHC?$`;c3>|?T!y*ijpF&w$uITM-uGxlrOMy`Yv1nein5LlL*J_ua3+(N2r?vhT=Fvo;#mh^ z3#j6XL9mr|h6rjC^=x#FiX^GY4a6!4!CAGnI%~$UM`|Y-|q95H>hdbl0P!e|+Ik z1)iQKhEmUdEY`Fra zYB%f{qD7f{UK{VHfog-YI=_FuhQ~3k6*TF1_2if0y&B@09>L24Haj zi>RVW))8a@t?8?)EUb)h6pY6q)(Z8HxFcF-Gdfz-rQ@ZZR(6zkRTQkXtVCNK2lep$+mAf06jL(u#09*)3hvoJdf(Q&19hvz<;;_S9fCWKQXW$I@b?u~>Q3N~BmS zmW#Puj*7)1nP#x_=R8<(!siidm zaE<~S3fUBiL=Z75G(I{;nN*qz`NFxN>AwM5f%y6zckCM(8SQfl&KW&B4#2xEC0bi( zRo80jzNnk_@85r@<|hk(DZm%=n@jDvh&&c;S-)=mx?4VZ>z%IWZ;Zua6mN{F&?m!Q zspw>SdJgP)M%E`0aptocd@@CE){h3RH#889?BD)q&~8>byzIuxI9@?=vV5I$6E!u_V<{O wK8uUh93obeP*H;~)i@(9JLv!Azkdrb09i*sl9e(l%m4rY07*qoM6N<$g12EGumAu6 literal 0 HcmV?d00001 diff --git a/legoresources/images/Blank.png b/legoresources/images/Blank.png new file mode 100644 index 0000000000000000000000000000000000000000..9f0fc519406d14b6d0d3a084bc3ac84f8d5259d9 GIT binary patch literal 160 zcmeAS@N?(olHy`uVBq!ia0vp^N+8U^1|+TAxeoy;mUKs7M+S!VC(K#9UIO`&C9V-A z!TD(=<%vb942~)JNvR5+xryniL8*x;m4zo$ZGei5JY5_^DsH_w$H>dTz`?Arwf=eZ rVP6ji^_ASq`UC_~!B4qJMmC0SpkC^>bP0l+XkK`H3m} literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockFamily_Sensor_Category.png b/legoresources/images/BlockFamily_Sensor_Category.png new file mode 100644 index 0000000000000000000000000000000000000000..e659e8c5d7538cf5c8aa6f8f76002dc3a1744dd0 GIT binary patch literal 381 zcmV-@0fPRCP)Px#1ZP1_K>z@;j|==^1poj532;bRa{vGi!vFvd!vV){sAK>D0TM|>K~zXf?NmDw zf-n$WJPS}boFJS)Y^*#2De(|?Hd^XI$O+^Gjsbo-hSTOOoFcK zU|Cx&+m5>VmOs)Qg>5fsz$Vp?y1bWd&H^AW@!~FJe0^@mOKT@lvM1fMMn9F3l}I(t z=)&HBw?5<9{Wj!Q<{TF1h8-qt{`4`0j3D$ix{O339F?&63E7C{=8A`yTOCfStsh7_ zBSzT`;8F9S`ECOc#))>q?OtdI?!I|eAl4CuqcyImw?5<~xl;0tzb-qh_FjaJw6M7A z8F3$geX3_eAnKmPF8oIcmW!$IB{DisN^Jo;VaOjXMDJ+A0{_N3w?8}RpY_=ix(j$= b|3}yt-LgT`ZXjSt00000NkvXXu0mjfh*_Jv literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockFamily_Sensor_Category_MouseOver.png b/legoresources/images/BlockFamily_Sensor_Category_MouseOver.png new file mode 100644 index 0000000000000000000000000000000000000000..b776a382dbb4c3c1df683208ff285b6064b758dc GIT binary patch literal 343 zcmeAS@N?(olHy`uVBq!ia0vp^YCtT;!2~3gRVzb)6k~CayA#8@b22Z19L@rd$YKTt zzQZ8Qcszea3Q&-}#M9T6{SLE?2(#n@J&`p)p_iU6jv*e$-%c`|bjX0mb-!h|@5F~J z4_R(C&$wh#BE#fW$g(QeY|a5YM>W?Ev3puK`5j_lJ!264qjZvL?d#hP3qSDP`l(`2 z>-WJq>JSq{!gs&tB89VZedpM0ws<&q-VddV5%ZH*exJP1{Lj~l<*FxwIx{WOq{jg!f-n#T;{Z5;Za_D{4L}!AH(&(ZKsSH|2yB28s2ku0Isv{*&P1_%YOz1O z|G`XlmL58-F^1=PoUL1pnqq8t2~tX7)W}0JO%(hufvD3p@nC zU{GMpPzZM$LeCW5m%%<~ENKDCU?wx(h+1G+gi_~JbRXaoFl3T*+Z4VVf-%3Q&tW#p zw!(&H%Bm8R3ud6oZtwtcp=1MISLV9Ng=hfvSlpJxS}IdnPDfM$%8*EiPzfx1Da|w{ z9otJl$?T*O*qa^!9G#_k11Pn?SSSyY_TVY4(({LyMD<-s3>~>j+g=&HuBJ{phMiMN zHXVjU7&C~#5;)SS1y^I8d~CTu27g^xT#;T$rxJc$Tz~TH`9H07v%3HT02z8^5GCLg QAOHXW07*qoM6N<$f}qc!q5uE@ literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockInterface_Change_Category_MouseOver.png b/legoresources/images/BlockInterface_Change_Category_MouseOver.png new file mode 100644 index 0000000000000000000000000000000000000000..03647381542187f58299ee4a4a0f2d7f44453187 GIT binary patch literal 365 zcmeAS@N?(olHy`uVBq!ia0vp^YCtT;!3HGPxW8itQk(@Ik;M!Q+`=Ht$S`Y;1W-`2 z#5JNMI6tkVJh3R1!7(L2DOJHUH!(dmC^a#qvhZZ84N%c9PZ!6Kid%2O74e}H!Cg_nh?P0;ozjI0AwAIF<{-FUO8!L$&|X_Z8|YUoD2D5-rcJAV$i4)e5(0| z`w&aerLP`7$8~y6vRNLGQr_fS@xFUbJIkhagS3mH;S%az-Fx1y*&BQ&_?^brHs@(~ zVzR_%C@+#>{utSB@W4eXSciF$T8b|pXS(lkuH7z6^vtixd9=Qn5bnSB#LnYU$5|g+ znC9%b`MhUSnVs4F*JT|{e(~L!>ue6y`2AW?G~esBVA!6czg`BUD!`F z{A7(z#(AH{ACuTBPv!S7xVLnU-Bo4YY`b~&8~$s&(LBJ=UjCcg`;^r~U??zny85}S Ib4q9e0MZ7Fod5s; literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockInterface_Compare_Category.png b/legoresources/images/BlockInterface_Compare_Category.png new file mode 100644 index 0000000000000000000000000000000000000000..6c045541c759ff70527acc20b40a182aa0d0ab52 GIT binary patch literal 433 zcmV;i0Z#sjP){jg!f-n#TioIu?GClEJ)3Dga61DrtI04ES85GD{e&J_}@JZVP(Lc1yThX zVQG8vR}$YFV`GlAaveT|n5XGfW|FjdnEJ9cr*j$@RV;x*U8_-Ntkf0_AzEx>@`tD` zRjLzo=N-NS&9KDQS=mRf+m%Nm6ZS9a<>ypw|Ome7q$3v-mqxdPY|J8aZ b_7PwJttMx>o%ayE00000NkvXXu0mjfuo{fvdgCG!urUNhnouG{12#!EE=m;I5-M|qXK{v1y)NVj0uut+N#Jm_G5YzON zOB7zX{NMk}r)gq)v;*6z?UvXv@p}oV0Tn>tS_fzVW75f1V-XO5`xLeY{i5!OB{ksX zmYfNY8)C`DXw0VR?7b_%1<(_|)~_v*%4#7p9Y6!*LW*_ni0MEPNPHfM{W^EV##tm< zKn+kR_K@DPil0i+K&+coVtnIBT66BPIBYL_&GvZC&i^FVK7a?{grqb<>Ycmux3gB^ zgfABMm^TfwieC`=F(`b6h0qfEk|jF7Ug`82Njkfh8cA#9{HnZ_oRto0A#H9FR0(Hq tZWojZoR`e&{3i8K{{OZ96=Gij1^_i2ej_0UhoWSD4 z(=5_s)e~~SsYi*Oot;^sl%eD2$qkQ{PjoP|^TjN1?P!z{Wk|JlGK@33px6^o#uQ?o z$uLEmGqJk*_x}?nD|1o|lRkd%{^JqoI_1ZPlT%fe8WtH^{)+VY$g<(a4(=uQm=~XB z@ys!wV8r&wZ$X86h!3Yn;}OR#0=A1TiFUAFyd>hGBm2r?#tmDAQn6Q^-7PIi~ju0oWSD4 z(=5_s)f2{N%@YKa8v9n=p9&ae2V+@aBU&lT1g7vBOQqfWJIT65N!ERXqfi zh0Z!CNk`^9QLA$kI_jQQc+g}01?8)W<&8ghX5GkBsAE6!)Fa6&VCw=GeGmTjok<%x zRHpGAIp&e{z2S$B!2b3mwy3Ge{}*l%61eX=S-7Q3Gx1`%xYqyqSBiS(9O;*1dcPp> zdZWrTwq7r`sCJ1JPy7_FUJrY9jE|YafZ_X3 Wk^fI?T3-S^$l&Sf=d#Wzp$PyHI(Xy& literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockInterface_Update_Category.png b/legoresources/images/BlockInterface_Update_Category.png new file mode 100644 index 0000000000000000000000000000000000000000..f8ae9360ef1592d43657fd1c33b437530a2eb00f GIT binary patch literal 425 zcmV;a0apHrP)WYD)c^E1F}z4?Yk2UI zODUB0Yp?x#kugRs(N=1q7W?R=EO!}-gjL;jNBwP|k!vUcBOo=r;;WveKo0O0-T-p= z85p2S4tx9YTa1SC`f5|DrdBp?9^NI*g*;9zyIPC<8MkZE@K9QJ!PV8lHts^Rgi$t%>}d*dwET84WJnqeu1{%rW>FVdQ&MBb@0Nl|t#Q*>R literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/A.png b/legoresources/images/BlockParams/A.png new file mode 100644 index 0000000000000000000000000000000000000000..6256a11d213a123252cf04840d30d9dae4490250 GIT binary patch literal 3379 zcmV-34b1Y1P)KLZ*U+IBfRsybQWXdwQbLP>6pAqfylh#{fb6;Z(vMMVS~$e@S=j*ftg6;Uhf59&ghTmgWD0l;*T zI709Y^p6lP1rIRMx#05C~cW=H_Aw*bJ-5DT&Z2n+x)QHX^p z00esgV8|mQcmRZ%02D^@S3L16t`O%c004NIvOKvYIYoh62rY33S640`D9%Y2D-rV&neh&#Q1i z007~1e$oCcFS8neI|hJl{-P!B1ZZ9hpmq0)X0i`JwE&>$+E?>%_LC6RbVIkUx0b+_+BaR3cnT7Zv!AJxW zizFb)h!jyGOOZ85F;a?DAXP{m@;!0_IfqH8(HlgRxt7s3}k3K`kFu>>-2Q$QMFfPW!La{h336o>X zu_CMttHv6zR;&ZNiS=X8v3CR#fknUxHUxJ0uoBa_M6WNWeqIg~6QE69c9o#eyhGvpiOA@W-aonk<7r1(?fC{oI5N*U!4 zfg=2N-7=cNnjjOr{yriy6mMFgG#l znCF=fnQv8CDz++o6_Lscl}eQ+l^ZHARH>?_s@|##Rr6KLRFA1%Q+=*RRWnoLsR`7U zt5vFIcfW3@?wFpwUVxrVZ>QdQz32KIeJ}k~{cZZE^+ya? z2D1z#2HOnI7(B%_ac?{wFUQ;QQA1tBKtrWrm0_3Rgps+?Jfqb{jYbcQX~taRB;#$y zZN{S}1|}gUOHJxc?wV3fxuz+mJ4`!F$IZ;mqRrNsHJd##*D~ju=bP7?-?v~|cv>vB zsJ6IeNwVZxrdjT`yl#bBIa#GxRa#xMMy;K#CDyyGyQdMSxlWT#tDe?p!?5wT$+oGt z8L;Kp2HUQ-ZMJ=3XJQv;x5ci*?vuTfeY$;({XGW_huIFR9a(?@3)XSs8O^N5RyOM=TTmp(3=8^+zpz2r)C z^>JO{deZfso3oq3?Wo(Y?l$ge?uXo;%ru`Vo>?<<(8I_>;8Eq#KMS9gFl*neeosSB zfoHYnBQIkwkyowPu(zdms`p{<7e4kra-ZWq<2*OsGTvEV%s0Td$hXT+!*8Bnh2KMe zBmZRodjHV?r+_5^X9J0WL4jKW`}lf%A-|44I@@LTvf1rHjG(ze6+w@Jt%Bvjts!X0 z?2xS?_ve_-kiKB_KiJlZ$9G`c^=E@oNG)mWWaNo-3TIW8)$Hg0Ub-~8?KhvJ>$ z3*&nim@mj(aCxE5!t{lw7O5^0EIO7zOo&c6l<+|iDySBWCGrz@C5{St!X3hAA}`T4 z(TLbXTq+(;@<=L8dXnssyft|w#WSTW<++3>sgS%(4NTpeI-VAqb|7ssJvzNHgOZVu zaYCvgO_R1~>SyL=cFU|~g|hy|Zi}}s9+d~lYqOB71z9Z$wnC=pR9Yz4DhIM>Wmjgu z&56o6maCpC&F##y%G;1PobR9i?GnNg;gYtchD%p19a!eQtZF&3JaKv33gZ<8D~47E ztUS1iwkmDaPpj=$m#%)jCVEY4fnLGNg2A-`YwHVD3gv};>)hAvT~AmqS>Lr``i7kw zJ{5_It`yrBmlc25DBO7E8;5VoznR>Ww5hAaxn$2~(q`%A-YuS64wkBy=9dm`4cXeX z4c}I@?e+FW+b@^RDBHV(wnMq2zdX3SWv9u`%{xC-q*U}&`cyXV(%rRT*Z6MH?i+i& z_B8C(+grT%{XWUQ+f@NoP1R=AW&26{v-dx)iK^-Nmiuj8txj!m?Z*Ss1N{dh4z}01 z)YTo*JycSU)+_5r4#yw9{+;i4Ee$peRgIj+;v;ZGdF1K$3E%e~4LaI(jC-u%2h$&R z9cLXcYC@Xwnns&bn)_Q~Te?roKGD|d-g^8;+aC{{G(1^(O7m37Y1-+6)01cN&y1aw zoqc{T`P^XJqPBbIW6s}d4{z_f5Om?vMgNQEJG?v2T=KYd^0M3I6IZxbny)%vZR&LD zJpPl@Psh8QyPB@KTx+@RdcC!KX7}kEo;S|j^u2lU7XQ}Oo;f|;z4Ll+_r>@1-xl3| zawq-H%e&ckC+@AhPrP6BKT#_XdT7&;F71j}Joy zkC~6lh7E@6o;W@^IpRNZ{ptLtL(gQ-CY~4mqW;US7Zxvm_|@yz&e53Bp_lTPlfP|z zrTyx_>lv@x#=^!PzR7qqF<$gm`|ZJZ+;<)Cqu&ot2z=0000WV@Og>004R=004l4008;_004mL004C`008P>0026e000+nl3&F} z0007BNkls#U*Q=a0IK0;s^lCfkZ7a@d`cw<+VLb#rCK0oGSBQlHq6nQsE)a~BD zFecmMDCaWykFC)BB|JiqQdUY?nZ>oWQxoyr3in~W8jx}}rYwZpB(8W3_tyJs_`dNS z#~uGxck6I>EyD?4;!M*($MEoN5tl-~sn@f0!8X3dSNN;idYoXfXIbW5#JLnHWnm%M zyN&BdT)h)KAT0i?|T%E<NNJfuImPTyds(VrliKE;7@lUJXH@XOTU|2 z4yuv1?`0gsL%0_4c^!-I)wNg5@ky*YUaCzo+vCqP<2zjaX8@9_!iRO5U)lfw002ov JPDHLkV1mi9V@Ci0 literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/B.png b/legoresources/images/BlockParams/B.png new file mode 100644 index 0000000000000000000000000000000000000000..a82c9d4f5926b14211136394a87af584af127b92 GIT binary patch literal 376 zcmV-;0f+vHP)3qZU9h$mQCntvR~5HWyy;sDS?{DUEC zKn_ZvC~B~P15iu|1V9~t%%4bAhXCWdk&q%_R4f2e50Hcu1|({Lj(vzGq%c~J3|5C+ z7!Zd56RSU#+(y;xn*g-LfylB020jo|I+N-U1!8glk^?|Re8E5$@kD1`azf+*T0uo9 zOV&|`;3-`R);FYP zUk6~KBi0cD$O)HF=}NLgpqNy!VKAf-P)S@ckPf*3El~}Ksq`2}JK>`a87d9|2rvL| WFh|8*X~a7K0000i2U-nM9S_+SD9Z&M6dTz`?Arwf=eZ rVP6ji^_ASq`UC_~!B4qJMmC0SpkC^>bP0l+XkK`H3m} literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/CTempModeIcon.png b/legoresources/images/BlockParams/CTempModeIcon.png new file mode 100644 index 0000000000000000000000000000000000000000..6d4285cfa0de0122e82cb5a1de43570a7aec1ce6 GIT binary patch literal 566 zcmV-60?GY}P)U>d-XEP_y&ZuQT&~Xa4h@@0>GZghHV(Cq{UfL&Gs)mvy4rQzI|S zh6Kok3%G*w*_r8^FZ|On`EUs*_yj-g7^hTBJ1l|^#$XlJVTg6N#lKj624DhO-q(!x zk){6J}7|>sAE0gQc(lbs-gjCWO3KDGZF6s z5A<+frO`@+%lIBKcgl4qB%6;S6U6yM!ZM4>;Qms>-GO@%WKN=4gC<0~u~V9hEwgY1 z#7Tl+>8mUwBuT8-aIbZG9QrkR`{2dz?&FMkqa>^uR#@=Zm zc9LgUKlF&FX~D~vEl0a)4-ODLwp$g({~yG0;Wq&W0OM1l@Xv%fC;$Ke07*qoM6N<$ Ef@^8~I{*Lx literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Clock.png b/legoresources/images/BlockParams/Clock.png new file mode 100644 index 0000000000000000000000000000000000000000..0e4f2da758a2c58c753fd713d8b574862fdea47e GIT binary patch literal 650 zcmV;50(Jd~P)0qYUmu+;8kh3R5mIW%pEY+MF1ZD|ol$~kc!+=2Jg%%NiPa#o_ z&%F2?Y$%)ad<_gs_ZXF|NJ{TY$0+ca}_lkBe}-LrVk3p zSXulA0ZAp0J&UWHpGCC+8jvPnF{XXDy@`oe!AdKB8^r>V^oGci$!KZeDr9#>0g-#( zV5Ol+>S95-fYc&FmZ^0ld@fyU3=uHwBl9Z?6F=ayd9dM!%{g^ zi55|{jJYAX|A6S-vx1qG&^yFBu(v$e1q)J4pmP@hfZ3YZKpgBkK@8m@fm5*5A%A$( kA(b^qn&Xvo2=*hu0P&X)hZtgdL;wH)07*qoM6N<$f?!`AQvd(} literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/ColorTerminalIcon.png b/legoresources/images/BlockParams/ColorTerminalIcon.png new file mode 100644 index 0000000000000000000000000000000000000000..e873cc080b454c351381872b55839962d295b530 GIT binary patch literal 1153 zcmV-{1b+L8P)Mt)}w)DwDRJINr0rP{kB*v zR+3_ljU$88pb8A6ixClg_XH74_3N3*WU2{;Lalneo}v91{Spl|$qTM(3D#zA=McM`}}x3{vq05!S5R9P!epIjr67L_zQGqFlWtd2yyZ@ z`b-NN#Rd_NCz78Nd3hq6oSgJvn`U1KEs8W{q9`&+lFmss>zh_le9`T8oPB9Z$filxb*+v)1aS)S*Q80rI~>_DwJbL0ArT?s*#YZL@$JfSO&#U|F3moNWw z?|b|G#YG;+j$L)~z2We;ilP)ywKW)0*33icgw%mQK#|%LBm$f8Ww3u>=RhzRMQ5|Y zXxNO$FT+d4Jw5IH!Qh>6?eCxzH-(qVsZ-@dDzSM07uE+rW!|Lw0Jkhd6}KSM)GxX&N3esJ(WL1ks-6~Eu_ zrlQB~7qBwbS(7S8J_oOXYqS`}L|0eWzS}o%%721Ca%A^>A#v+jj%gM=M9#4_Q z<#yfm6np;3&(E)qiD9g?noi$&8uQC)u^~m?M4?ViUAI?Ao-A!9(>l)AnR)HUbI5_46^zXA*ZYbTA? Tdgo#E00000NkvXXu0mjf_-`s_ literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Color_picker.png b/legoresources/images/BlockParams/Color_picker.png new file mode 100644 index 0000000000000000000000000000000000000000..58d6911130028ea9548ac46c9d32246c7ff8a7dc GIT binary patch literal 833 zcmV-H1HSx;P)jRcDJ<97$p%EP>HnIn=u~b=1t*1qfvQy$6)kS&~WO(lNZm1 zgVA_0@j_xqAq|3w+M;&*fQ=ps!9Mo|g>E1I(^PE?g|_U8@F$aQW~cLY{+;=^2pz>? zk0zxjym{;P)$*nP^{bbBwQ*_%!Dg$~I(N3K%hB1{fr6nB2i<*uFDnjXtbA$K>2z=P zdYwa*M6|ZPj=H-WdTq9jRX04u@e=-Y1|qEQr(K|v6960un@OW#a%X490mG)sMT1wQWLBb(QYS{k z;YcdLFtkojJ{cLhGhOc^Q`d{8QmJex6vn8DBn^)nLHC6#Q8*$_C=xQD9H7kxgK=_X z`0jM0$5CA?nn)yMCK%)xCTKDmsfp2%q3MIv`KmBM5Z5l+Z5$K?XFMLy0m@^PqG;E> z(cuH3RW}!`wwb1>8Gz5lVzC@fFB1&W6irS1U{`BJ@u4od-R|09&%F2ZmCKhpS5{Vw z9~KvNf*@{cw3_D|>uYc7Kyl$t;j#^Qp(c3VyYQmp%&C5#&%YH3hZocujWPCXgRL{0 zaXb~YPtdmhU%6_xZ?v5_{!XLSYnFXqX7O8Rb5j!PMDdDo5y3xp16t1O_13hx3X2Qg zr|{VdjV@QXraIxRa;mp?d(KrSbGcjx{XeIj+W+;fZ+&Z>@d|}Pq7upw zmxJeWIT?RH?17iC4IX7OnZIVAbUe`wuou3-R5$_CgF3nvBA&R82PR`z!7Nx*Rv|1) z4Q2`))~YVJ4^6QP;bm!<8`3;fZLj>nD|t*mq+EDp2kZ-K;Kd&>pJ1nouE#8Zr?CoQ z;L(`P(86TbB7N|2m%l2%CvjMRpLHd2L0h1QqsMa7gzdH)n(dOB%vrUZ5 zgB5T9ZX5NojT_4%M7<$tTV{R<4ry+XGC{mjE|17A*$7#91vlYcG4Nq2VkbHkqU+xV zBP1vZ!an%T^97^Z99ZJoBQn$N>VnE6YWFLkenvAK z|En+Uzc5#ftt?r1O02DoaRKXNJBYApnBjMZGw;|su2ywZ(%U{p0SUY)H+mh0W(AOruj zIK$+M@J*jb!mh|dP(KE<1s?0oJ90sM*7(_w(v&|b>W}bdJ-B2$b~AvDmb{+U#Zs%c z{-aTZ%!jY~oKD!6AI9$SblgxOUZwnhB$=p?@<)IH06w71+8C-*&j0`b07*qoM6N<$ Ef-)6(s{jB1 literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Do Stop.png b/legoresources/images/BlockParams/Do Stop.png new file mode 100644 index 0000000000000000000000000000000000000000..711411feaa9ed7cd0ed2dcd7c29e09865dfea352 GIT binary patch literal 731 zcmV<10wn#3P)Px#A#_DpbW?9;ba!ELWdKKVVQ^?^V?%Flc4cyOWpW@WNp5syY$6rlnFAtF7em||aGx-$|A+3dz39zXQM zoSc)Ho!{(b{<{YNaPS%SDbRO;?cX*mo)_@p;Qqr9as?Ga$|)R%!dn(n6!P8o@84XA zKX5pJXe{;*5>+7aEe&e1K(ItQMgJUszmx~Mj5{bg`NfhkmQVQ1VI%v$6lDL;YFAzRGgCn-@&$bOh zuvXKl!fX9n3U&67&Hy{{vRLD`O>tN3pbEj*3P)_VeoN@?ZFMFj_oVZ`8@zWd#HUPpzqR%-Ec~ z?sKKggSC2%oV`ImFxa$A=@={w;|irB4{ow$KxeyiyZ0IQM-LQN-RPFJ6K9IfiY9L* z&lykUGj>F&bz|^gCt+Noue&Zab_%V`#_8V*aD-vsGe+e?joAFR70_C#3|jRR?u`VyX9*c23-i~LyZ>Ym!4h} z6HMZDV~r;x&vT%};uPcQD|AGGk009600|1{Vu7c>H!Epcp N002ovPDHLkV1m*7Ohy0z literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/EqualsIcon.png b/legoresources/images/BlockParams/EqualsIcon.png new file mode 100644 index 0000000000000000000000000000000000000000..0aa79b0ea173f7eaeb879dd65c985570e0de345d GIT binary patch literal 183 zcmeAS@N?(olHy`uVBq!ia0vp^{2ZB= a|1&d8{GHQ-=!jTxyQ3BXZDa6s^>bP0l+XkK DcxFi1 literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/FTempModeIcon.png b/legoresources/images/BlockParams/FTempModeIcon.png new file mode 100644 index 0000000000000000000000000000000000000000..0339f8202b6d7f54a88639b4e26729e1f4783eed GIT binary patch literal 413 zcmV;O0b>4%P)Kjn;Z+u}3l>Y)WY%h?R4W#*j zv>p(@0^&2c3?>E4h8pGy#Mgm%G0?(~7^wniGl+8ph%2E%fgZ-sff}D%KvTqMK|jb11_&?!AB}NGXiF=S00000NkvXX Hu0mjfvLKvF literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Finish.png b/legoresources/images/BlockParams/Finish.png new file mode 100644 index 0000000000000000000000000000000000000000..7503e288d01fac30921ccb85826086d6fa9c4d82 GIT binary patch literal 1189 zcmV;W1X}xvP)Px#A#_DpbW?9;ba!ELWdKKVVQ^?^V?%Flc4cyOWpW@WNp5syY${aPgQ+E{gFSa6PAqm+R$R0=n5lGl2Qc;wG46RlR6tqm8acsvfLpNp1LKX<7 zA8zlt$$RsH4`v)cIGypsnUnmMd+zUU?+OuJ`4sphqW^DUpUXzZ>sM8Hoi-|$id3yu zC>9Qo+ulR2UNbG^r|D8*^NnkCnNYD%Aiu{>@7|rsIk3ZOBD=*PaM?`MY&NO+Zws&o zhrn<~R~SYu#_MD;bdjn13)L`ym-QH~Q4bpcE9*c!X?!$Ixsf#4%r`jXU4rw%ShKW&{|GsF_xE4*gtN)DWzwG5a! z&j>O2ym92bh2Hn}5D_Kk+Vx*v|D-Sc>g5Yn6pTW%qSzS9Wo3Uj8I#awlJWP1M~4O} zlS&9$`ECfqzOL|(JKJhufJ1>+p@AW&bqdC3C&!ovWZ%Fo10XsTZX29?zP&*wCnt1t zctFKsfnL7Y(HGu%{=Kvjgsasmjj(YT21BfVQm1;oCi|7jaeGiy$z!*OgVKt|F4ai@ z?PqSc;SbxJ`ohn))}_&L5V^&xaT)C3!2qWq09FiRFBC@xmW163xptQcwSFi)OvpI3}4&M4wzTtrzOoe(f|Usd}U zP|j|wKcT(1Z>Y#^cX+T*tIPNGg|UIx;n3mH5zlAz@PIH3;WcmyFDw*}gt3lKp0l?{ zQiE30MosI`!{tSN;gtt><)V>skpaEE5Lda9(;(+wyXWEdQ*fd15|=!B74Y*bBiH_BYgz>y26Wh@^T2h3|2(J$TKEX zEEM3}`=qh~h~P|qW`dUQF9_zQax|G8;k49g@y;AA-D~yo(!F_oVFmNIrs(#qNh*~~ zDkifTn#zsPH1{xA@7{;tqb`3I{w#bM{sRC2|NjF3x2Ek@kG_QY00000NkvXXu0mjf DSYASW literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Forward.png b/legoresources/images/BlockParams/Forward.png new file mode 100644 index 0000000000000000000000000000000000000000..cc4a36961f8875352644d7b6d8d747bbd88978a3 GIT binary patch literal 444 zcmV;t0YmEaNeW%WQx z0gDt!tbi_w73yP90u{icUjdkKAJRIpP9We225M$!tRVsn4SOK-0Fh>3&CWnG^pPBT z0jQ=BUx={aDZGdUAj=G~hzp?QHqsI+G&C5XA#wmm$RNvoK+;3Kx&|7|j%beikEX_P zv>7n!kWq(>I)p&UN*2IVQ92-%MW9-HB27aC+OWn~Jv=~b?a?l3fR34n)V@Ur1-N0@v}qG{c&f>yvquZ+GdQnY*-X4CjB8&-%99oiM3plMAj{bMP$t&{P zB_bk2F{sF$o!>!~eQOhUcv>EV)g$FlpuHsm-V$glO^Zo$Wuvv)ZhYzmpA t&+tkAk_sm?FPo^V_=H+UCI&_}hBMQgecu}FH3Ryb!PC{xWt~$(697SRcE$hz literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Frequency.png b/legoresources/images/BlockParams/Frequency.png new file mode 100644 index 0000000000000000000000000000000000000000..fe96823b08470ef928e8ac3edcff66f28ffceb71 GIT binary patch literal 470 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 RhBeT044$rjF6*2UngD2~a{d4S literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Intensity.png b/legoresources/images/BlockParams/Intensity.png new file mode 100644 index 0000000000000000000000000000000000000000..b9ab0334b957be17a5a6f72bd513c5dcdac30f47 GIT binary patch literal 413 zcmV;O0b>4%P)P000>X1^@s6#OZ}&00009a7bBm000XU z000XU0RWnu7ytkO8FWQhbW?9;ba!ELWdK2BZ(?O2No`?gWm08fWO;GPWjp`?0V+vE zK~#9!>{jg!f-n%pk01WS4RC|HLD>K|U<5|c4P*mHkPUDHVFE@FC#XmANG`P%Pf`DP z$xD;wUSIEecMt@B6WHtpjv_1w*H2w4A{fF&LYfLiR#=x~iD*J7j8aR)GnN)@2^)Z0 z3ST1;;)fZC28gU7l+1U}{4R({R7H*F=B~?}!MU^f1Cg4rCgg;crKNxT6QLp$So1N; z`e3EdKy=V1judUIy#j0HIb(_FT)f(quFi2MjIc{-?BO{@3Xu9{Yq1v(2>Ey-3t1m< zG-J)GElO2cLJjsbe4Uk~Lx?5lF2rPFdQH=yKOcdAh9m?d&f0%`OFB zJLpa*8zC?Bo%TmJ>hH*J4vHvt9!(v4ie8}#a;00000NkvXX Hu0mjf%Y&gg literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Intensity_light.png b/legoresources/images/BlockParams/Intensity_light.png new file mode 100644 index 0000000000000000000000000000000000000000..91bd4e16c38a7a059f32a3493bf91f772443ee10 GIT binary patch literal 616 zcmV-u0+;=XP)?n=?#z}|3V1iW#D7|HP++B^lam^j;BPBM*ze% z424#F{uny1 zKxj$uT{w?`p<4q>avn)qZ0dIl1CLPA;eEB`NY=8+4H&<)uxO;`0O)rF5gX=64#X51 zW#JU%;Av&y4rNW&_2>7<6dL4=I($E*TDa)yIU#fJO`(~dpKgPz23vmK@Hz${%e__& zxdbgS&IJpdtU>tnB_C#`y<-KNU0DFXAy9?jHo+b-G%)FKK-tnL{hMAx7o`+G)~81u zH&B2R7?=A<)Y8CaczQ|s0_SirLH7}5>7tXiM#;da&R0dG>yq<`t6P000*V1^@s6{^R5m00009a7bBm000XU z000XU0RWnu7ytkO8FWQhbW?9;ba!ELWdK2BZ(?O2No`?gWm08fWO;GPWjp`?0WV2J zK~#9!yj9T+f-n#*gnw}YaRT`?`k@=h2I>Ynfovcn-~=*)erWvE4R8b9z-#hIE)`0_ z;!BzWJ?{0rD~Br#ak<_Gq9r_ok*Bx zMAe)WJ+vf@Y=&fCCySCeY(uFMQ%U4#zL6z7_f--Wv&Ug6AgvG88o5;@6nMa4h&3@= zWj%mGGbJT`E2gCDiuEIERY2NyZbV|(-*RScP9(!xyP5zs;I#?R_w13d8s_ZL$~p;< zu%X8O-xS>N=;0uEIgTN161_f)5S5Q;#N|^0u~wDG9~$r zzn&KlGcA>EuwYmrdBl$4sPvk(I(m;To#5Ck=;3=n=|AJy1??}SzBXQARf_q+&>`Kx zrjx?-ae-fzLyOx4ZnFjnACD$>jtr)qCm1tMx(Aso%22xMCcYlLai z#;;7X99a)sc&@(WBa=y>!fho6FO?rAhnSf<_!sR|VpL@m@Hqa_A&YU-Sq0~r9UKl{ zE|eX37Q(~8`<6XJ@yr32lr6CeH{EokSWjH_m=tWkpw+~FqtwOCa~K1qCKlVRo8nyc oZozCfF`+AY4M!C@7+542q(eMTKm2g93+QDAPgg&ebxsLQ07%w${r~^~ literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/LessIcon.png b/legoresources/images/BlockParams/LessIcon.png new file mode 100644 index 0000000000000000000000000000000000000000..dd09ae810fe7b7078f6c2fe78dffca43439b0f83 GIT binary patch literal 403 zcmV;E0c`$>P)Px#A#_DpbW?9;ba!ELWdKKVVQ^?^V?%Flc4cyOWpW@WNp5syY$o8Q{PpWsp7rb3XON`%(W6Id6DLlb;Nju%!N$hsKS9lZ|Ndn< zdi1DIQBlzjTU*;rRIYOF-vl0-eo^ z)z5eC+|ljm=$PZ|?EDR+!O6+#M^jVNl1rB^SrZJf{QUgAAWeRLelM0RSyKM~{d-ZO zL%Y1Zd=p4B$bUe8?mTqpkpG`Qf0&8V{QLKBmVNv7g=S}GAAqD70U-oAY+ zPINrqx^>H-y}f-d(BI!dhB!Jp{%mMySa$K^MH`|M$%hXggcmPfTmf$dENI-r+ xaNs~tPEO7Nq7n%%eEaroJs2AR009600|11pZDjPCj3WR5002ovPDHLkV1i2)z4!nC literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/LessThanTerminalIcon.png b/legoresources/images/BlockParams/LessThanTerminalIcon.png new file mode 100644 index 0000000000000000000000000000000000000000..0f1ba0dceaf29c40ca7a175e8e75ae7ddcbd8ccb GIT binary patch literal 377 zcmV-<0fzpGP)ABg9ZT2@f%5JezP zL`wq#&@^)%iW6`oV5*160;q!=fp`O&ya6{sn=!Y~ju75~WwWP^HxG6EYkVuEyn!UUxYL}7z;g2D#r24;df8}uAsz?cjE zNDHcjB}XWZeb4Xi-5reG$G;zic!D{N-TpAp_!~U8FhvXG>Hrwy#_!oJ01O^u2gT3u zT*Itk&eHynQANEOSUL(zX7mf0)t=cP z@)!WZx2h3U(gq>I%dw9194p-}NUFzDp0z6J0q^byboz}ObieRtU9tTAuGl?tqw6j2 fe-mTIj{pMzHej$HrTB8j00000NkvXXu0mjfRyO>; literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Light_orange.png b/legoresources/images/BlockParams/Light_orange.png new file mode 100644 index 0000000000000000000000000000000000000000..2bb90d1a8ca40e6a3d08a3d6e58829b8a808c63d GIT binary patch literal 594 zcmV-Y0{s1Q!!Qs|t2{$CfDH%};1Rk3;T?%~gD?R+@ZPXNn1HZBvVqyaut2$!&eF*} z$FbXnm!4#~j(xt*_uni#(?8Q9h3WS#yM(EP(O*1fKZgKVCh~POG=Z5NKuL4Ke$NWv zXtea$_yxue=R_Z|{GZVPfawONH7(b$-bM=FGJXZ?yI2iq7>2DY0fb?5?+CA)b2e{;MWI$OkGK1H>9fOD2*QVu$#UNY15wkb zSC)j7O+*Niw9wGEYxIFB!lN@GIcO)mwgQ14Cr!ola_tD`Aj*)vy(XZ`8{u-y^&9Jm z9^uyh7a&otHtka;CAU>rBZq^6{2IDf_RfJ-Q2kiyUxtA>T64gfGLLd@8i zJq-ZUJ0RE2EAep4?AndI45@Xrv2sk-OOCooNVAo&g_qx+q#9!AkzG+!50n=)GfQoS z<2ee|hhLsgAe$w4UP$^AghUpJNLyzLi){Xpvfg56XV&(Rf|LzweKK3lx{ gSQDMer9S}%0EOVlpna&ys{jB107*qoM6N<$f-tTM-v9sr literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Light_red.png b/legoresources/images/BlockParams/Light_red.png new file mode 100644 index 0000000000000000000000000000000000000000..3e79a629781ffbb5512a55b1999e7b1717f04f22 GIT binary patch literal 591 zcmV-V0{i`P!!Qtbqr4~2JkV}HHmI3^Y|yX)8#GKn*`S>OIssvVh7AG_yf#b_&e8>) z%sKwS5(4$4lPf#tes})vM~IXB2YC}`OVD|YyOKZv53n?#T?`;epj}CRFMbO|R7nis zUV{#xPoP=AbFDy+uJ)!#)VNCZ_C7!q09dx5IoemDAR6+!V1Ur`o&i9m4FyqZ#tO(r zJHJt$o{RSv1aQFssNnqB1|sD)!SDkvmFRJS+c`al zihGhJTx!-FQB%VHaw1c9765uF-!Kl1_2<%*qW#3>t;070NouPN-6SWFbb2%%Nk+^~ zm!NFn+iUW?rPka!6M21!xh5rDkCw#x5x{k-F8YX^(`KNZt%Rr@!Nw>(@Pw>p&%V~N){v|3ZL$qI06u~ff?q7mT7v;Pv(gYQb?vR>pYPf_Q#2+ahV4UV?c$q!D>GX%$k7$_5~Vi+U{bOf;7;s_6he% d{*-(QFaW<0wYw+k9ZUcK002ovPDHLkV1lQ;`XB%R literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Loop Index.png b/legoresources/images/BlockParams/Loop Index.png new file mode 100644 index 0000000000000000000000000000000000000000..0280b45096a46d0ba4264e5e3ece5e70ddabd15a GIT binary patch literal 195 zcmeAS@N?(olHy`uVBq!ia0vp^av;pX1|+Qw)-3{3jKx9jP7LeL$-D$|*pj^6T^Rm@ z;DWu&Cj&(|3p^r=85p>QL70(Y)*K0-AbW|YuPgg)79K$*mTe9qUO*vdPZ!4!kK@S+ z60C=14JNHFJb5bg|H3n~4Id^-EqRqLr6IpLV1c=?*M50li^ZMUR~`j+yX(qrt$;FE cm1P(hHtgnZ+@w>f2sDnt)78&qol`;+0Ijk(p8x;= literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Mode_color.png b/legoresources/images/BlockParams/Mode_color.png new file mode 100644 index 0000000000000000000000000000000000000000..17a0bd2a23d8c7c6775a1216c0bc729f729b3754 GIT binary patch literal 508 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 M07*qoM6N<$g6@FrIRF3v literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/PlugSymbolX3Numeric.png b/legoresources/images/BlockParams/PlugSymbolX3Numeric.png new file mode 100644 index 0000000000000000000000000000000000000000..7716503e4dbd8548a00ab6a457484f7da8ff2948 GIT binary patch literal 463 zcmV;=0WkiFP)Px#A#_DpbW?9;ba!ELWdKKVVQ^?^V?%Flc4cyOWpW@WNp5syY$_Asq1n zhBD9hf0!VaC-b%6!*DXeVx^_U#hv~DSxax1Bh%D$AmK$Biv_t3s&<0m{xEN`$Rw3n zhF(pYoX=*(%G|FWU}RZX#)}ecUbe8=zQU#J#S)Hx1J}ztSU)`%D?`#Bjj>eIjkwIR zZDfsRE7!bamRYSIfuydeSUiqSh(6QW1~Q}D!##z{+y+7FSs}S_oXkS0H!gz^cuB@N zp@ke-N8u8T|7BOMTbvAyd1l3>lywItGP$AVo|jxQ@Na%F28L009600|0QZrbBU{tVI9-002ovPDHLk FV1i3B!>|AV literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/PlugSymbolX3String.png b/legoresources/images/BlockParams/PlugSymbolX3String.png new file mode 100644 index 0000000000000000000000000000000000000000..fbf75679d4ebec3dfa7189a14ebacdc1a981d57d GIT binary patch literal 697 zcmV;q0!ICbP)Px#A#_DpbW?9;ba!ELWdKKVVQ^?^V?%Flc4cyOWpW@WNp5syY$Z$Rl~O4Nx*)9}HumD>$=D`dF@^$4nv$m4rkAhK z#7{dtbL?)nADIGF^y-A>O(m5Sy&|I`Aj)k<@WKbnA{ zXpDOBeNz}rh+<=3zI~+$f&)PgW_4{%=T$GFo?WD?7;9ZzYOxo^RT|4GdAJd#lYU=a z(c5{wUL8z3G-@asrG;3yXl$7C70WN-!&%cDrdn^n+`WwLjNsWm@p9k}@Z z^Tu6381}3xKK77Kc?#@}vlUw`6cWGoEEnyt?|uZ`>x zK2y)wQAv_@o`cHCb)7`Q80M7h3Yst(0@O*TvPw=H8(Tz$agarRy|D@J_V&T=_tRLh z{O=1(rI%<7_wW7wA$^9ILP*n{$vjg)W|kKJ54pl~hz*bE+D~^T7=%zbta(w&@^Z(K zupZ30{$|4*Miu_7+DBld%OAg>QmvVKvGdilb3>nLq5r9_0|*!aBVYuKfawKw9iV4n f{r~^~|NjF39W(W;Y!aeo00000NkvXXu0mjfz(qSF literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Power_0.png b/legoresources/images/BlockParams/Power_0.png new file mode 100644 index 0000000000000000000000000000000000000000..61563e22cdcbb59921929aa25ff4feac12b3ae80 GIT binary patch literal 868 zcmV-q1DpJbP)0Dq7$LYKTm;vjH zYcYUXmoRV{v!~8AMlm|400{i6a3zw_%J`-}ay%O$AIWQ&xq%L3FFN@L!M&h{04)Tm z!}kn?uq6BET#XG_wC5-I0x)}A0y;8su?8Uc6OKN*SVmgc>6jwwq{M*0zx*-=RL*it z%_v5{fp@@OV^9M-Xy(gPgqXdG^s87u#)QQ=k(tUlflBzz+OdQ_Xe+*&6LrZ8z)N%@ z!J?G}pR7z|i-%Y3;LqtIj}0V?+&WFnRKc=0ns*^ zP0x7`?%y*Hk3JCWf~wa%VO0R5(MbFL({Q5csyp*>kW}p|G&8r&Gqpv-AVyKg0eyP1n3^C-ENa! uug|Ej{5JsHWku$;Ty{m%{2tqX1Q-CfU1`jW^U{X^0000c>a literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Power_1.png b/legoresources/images/BlockParams/Power_1.png new file mode 100644 index 0000000000000000000000000000000000000000..459f1c8ae512617114a7b3e916eb92aa3038330e GIT binary patch literal 981 zcmV;`11kK9P)yRkbo;@}#n+FZ z)2J!XRAD*=jYBiBJ)FM3@W(*_;3;%*+9*MrqHx%7g#aBv$S8p(VE%b0{a$f!baXUR zsZ>hPKNA3^pe>W)r~rdv(PqpwPSLs;v@m?XihA0C_+8`F!NE7hvex6ZT1{JD-!KZ> z+Xg8`3B&2;T$TzuzhQ0-x;0_$3AqU^Xu?>BHM1Qp;_-ME1_na0{{Hi9X?aDHq`u_M z8((m569i4t~PdQ6A0L(tQ zN+Fmezyv#jpe(+66PDyY9tvGxd!>?Xo#O6p3S+3t3=2Y=p_tOh#pouzBM8yznM^hs zlw~H%5^FRX48}@2oiQMG<^gEL31o~L`c#GSh%3#bWDSE{lpv^>+bW(GX^QmB=kvv` zPDI$MwZ_WjvOOONoMU67qr7%_XlAoHT>x=1NhLR!lr<=EauMpECpZiKd(jSLnM`LA z3`3aor;KeGM}`ImnH-c@rSgOK^aN78w6CBW>-9QrI_Kzd7d63EF_?SYG=0fjVd0ea z=Gk2C1k6@G5Am}H77F0$HRxI7$~Z3;cjKT(a}Lr(OmdmlE=E*Zcx+L%TC?4QFz)}M z?$~W-r^r5hOe+vmYA_fKlODYZ2zT}oQ`ue6G{=8}Wo+wUj8v=D`1sgp9Mig$An+}9 zioJcegr~NssHvpKsk%vmRNAGlPC@2GyK`^E0KoM7{VB|(R)VhMoJVPB5Cj*>zb?d} z)%Mb()N`z%38%3lk#U~S7c_K7D;d6Yk$v6RjMD+abf~sBayPdx2C^}7c~~uRuC@a~ zSg1QDT?@0P(eLfDR44L7pHitCzQ76O00000NkvXXu0mjf DT)4sO literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Power_2.png b/legoresources/images/BlockParams/Power_2.png new file mode 100644 index 0000000000000000000000000000000000000000..885d682f53c7bb406bf02c7d984a6129d0c0e722 GIT binary patch literal 920 zcmV;J184k+P)l3(d(7u6vg!%;H8}t#%g~mIV zTR~W&h8l`lz|vN_t#isZX1Z)!{tP-hVJyF)KYh{Ao3tzo=fXJ7V7#dpx~oPoL~x zDF7&S#LUB5Pt0<=-R@f6Xf#diy9^FsR(K8rGjayy&tX|s%mS2@`G2$7?0%zZnh8+y zJP($9aX&XmzBWYp8wkonFtfnQD3#L5NTuk@*KcH5^E5L(twlha0M4KSz8}YiHbgm( z66iG5a|SRvI!e2{RhpZfp}D!)tYBg_B4Zi%92k;~f*9$e{1q;i0l=9#xGxV^yuj}) zGGn=)3tXTqsO1*I90+jZ=oUqZ08m=pWl|`A4G`N(P`mvANZR5`tF(X&BjttduqQA( z)UgwZgbY|0X}2AbQNo%%1poo##aV~JEcg=>6j6r}g!~ zT9^+qnY8GJH@asGXz|`%(o@NzV8>Al&9I@-IfrlsKf?>@^aPEM-||n&aEmxN#na42 u^?Uo*006{-Qkvz%!#m3p?4KLI1sDKBx?!@UzIp=y0000rPC{$e5lr||zJ+nE}3|pX(v{#;FGAuJY-*?XW&Y1=H-_1A7=GSlDKE`Po zhmK>(vuxwAXqXQl++V#E0tgzzDNn=1QO3a~C<3kFo=3_nI*}9vi(=rOrdT*VJzbRl z`FuW?;K&8wi{z0!Q~(!UH-w-~7c9 zyr}5rJOT3FpnR7|G|)!_T%AWpM6N7BlaPH|2r0SXIK zz3O6?-|si?EM#?`4;U(&{cbcs3u~-e-G^4I1u_*P?*a(D-}DeLRAH+c$aQNJiixln z7P1+JKnxWPd)2C&XE94~VFDZ@!PR_njk!z(uAfSJ&toN;e zU@*wnKW&sfnqo?~%+qrR0j?;YE3HXug8GlbPtIk;Wc!w$7rhmBMgUd0 zg3}7Jo>jaz)UX8te*36(bYUMr4RA%srWCNaxV(GMbwb=EL?gy4Pl-NvnocerkK@x$ zPjF2OL$m3)4Q-Gsd1QzNSFY~Y^jIv)Cngd-^M7*E=IwTS;LB@Z0_cs1h=l^Q=hJhx z02Ad#mk#LqEtr{^7VEB-EVX&jgmR>2j%COz>l+NccPr{j2z2>E w;#4KFc?r*-UD-Eb7c#P9tU*2Y+CKpX0PN&S+e-O-0RR9107*qoM6N<$g1jf4!T0VQ}~B zOCTI4b`XN%dsC`5BE9oB$5DHb8VV7Q*jWRW#0ni%RoT6}cgWe<4=s^M(BW{%q3a)a z_t^RQIg|F7aAQ*FE@5EoI{4XAB|{xc*oc4;ia4{gv#h$hqJ7xjp`Lek37SeJX>F}a zj*gG*g;LQx?)QnR{BrMkp5GN!A#>?DzaaKqcX-l2@xQy>t^m^2P#JQZluB~TRmN&- ztK{vw_w?f8; z$6dE;gh7H9^*(5Ye4Z2vd0(MyCSxX($)*TTwIDnK?#A_He%R|ZdcC8G zYFkkhe{vsSM&X0gQ^$2(8^#NtR`_%udumHphI+ZYWP7Jxy?byFX%D#r3KU2_PdTMI z8!OBL1;$=0Cce)A)CMH4v3#wp@9uqyw5!#sBkm`Ik7mX~?E};Ve0000< KMNUMnLSTY@iHtD- literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Range_L.png b/legoresources/images/BlockParams/Range_L.png new file mode 100644 index 0000000000000000000000000000000000000000..067952c94c7f6d3ff699ef33285803e454bc8b75 GIT binary patch literal 307 zcmeAS@N?(olHy`uVBq!ia0vp^fg<{bJ`}pl4Vu6$6%6SFL3&?*T!!SuNbE6X6TSt@Kkr;b!1y`0oM@CGBpkP|9P;;3NHi;mhW4dJDN2I1Ct6lB^#wpE$4`=obc0S3j3^P6{h`IfWc3=r~B0MxcwFB)yE6_PIBIDCjaVi?H}Xi45A zbBTxcKXjn;O~JL~RW_L-{1@!yBgXGmUZ@{H^BTlUTu#sI>sjIjh!mj0CNb1|G?0o) zQ=YFi;cmQ5nYAN%Qw2+z#FgLeaZjx@W5|9FX+Kv-Zo4js8KRF^zu-fA7l8%^Q zSHyyqWj25|YR{?^u1VsI%Y@1g-Xb?uYWXtB+u7cdKNDQWp;36Tp+AtfpR4?<>n^|m X(WiApsR)KF00000NkvXXu0mjfpJ=gl literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Range_R.png b/legoresources/images/BlockParams/Range_R.png new file mode 100644 index 0000000000000000000000000000000000000000..e0d749fb67a0a8bc1bf7d216db608503b2bf05a9 GIT binary patch literal 326 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 literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Steering.png b/legoresources/images/BlockParams/Steering.png new file mode 100644 index 0000000000000000000000000000000000000000..6ee1df864576f7737f103dc3d414871d138a3d33 GIT binary patch literal 412 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 literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Straigh.png b/legoresources/images/BlockParams/Straigh.png new file mode 100644 index 0000000000000000000000000000000000000000..03cfa7154333b7c045d33a0b3518dfab41683284 GIT binary patch literal 275 zcmeAS@N?(olHy`uVBq!ia0vp@KrF+-1|)YSnmPd~&H|6fVg?3oVGw3ym^DWNC@5Lt z8c`CQpH@jxlYqa%DYXT<-vXi&7*cM#I+>X+_^AG1D`$qc&4j3i zqYD@oDoxtG)-Eb% QfNo{*boFyt=akR{0PKHPBLDyZ literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Timer.png b/legoresources/images/BlockParams/Timer.png new file mode 100644 index 0000000000000000000000000000000000000000..2596a44d877b05a4c32a0774db151363df80f61f GIT binary patch literal 825 zcmV-91IGM`P)(*1 zK~#9!v{g@Q6HyRfvq{X7w63vY5+hj*_@^qapyDmtn>T|L1yAeITfTuyLGaj*5Cw~R zO25GiUi6kAt+rma{;3ga*hEMIA>hn*o=#rU+8!Jj-tK#Ee)F4oGw*5If085nE#ABT z;1~=Js7-2uHb8w)@%q(D^H9J9SRv(LJ~^;RalQf$>i+}=(5o=i2yht{3_Eg7vV`vv z3?4;PB?lde6P*Goh)J1mRE1bBfXy8O#z?MBFoq2U0uf6yqR zDmtdL*)&&!xrewxm%x`UU%`b0=xrR~-@Ja~rjt9Jt#mqFw^%G%i;H)ydi{-M7{;w! zF019w6aq{cfW3qLEldrJVr}jHR)n#_T)D^s*@Cfs{=zvgolck4G^A2VGkqfM&Cg#f zv(!AJXff|vgyvm5ae2CUFaTPi5H($oi~;NVZlLj_aW9iO#U0~eJD65!Ax}1xxs!7? z&4mK&6~?JQ-VX7q@X)uvZP&=z#No+`kkae*gxpJIi@-txBT$*TFLc!U-oknends5KU_9RNxFJvW5aO#7zXccozRDv3bfNxp00000NkvXXu0mjf DO&Wc( literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Value.png b/legoresources/images/BlockParams/Value.png new file mode 100644 index 0000000000000000000000000000000000000000..45d571c13a433dedc7ed6a4694b0560189dac0b8 GIT binary patch literal 249 zcmeAS@N?(olHy`uVBq!ia0vp^N+8U^1|+TAxeoy;mUKs7M+S!VC(K#9UIO`&C9V-A z!TD(=<%vb942~)JNvR5+xryniL8*x;m4zo$ZGeipJzX3_DsCnH`TyVkZ~}u5Pcuu8 z6^rbKfZGR>kNdx458_kUHg&1x1H`7SH_<*v=!`&cGtUpuA4%cR_=cKhRkWp00i_>zopr0D~@3`~Uy| literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/Volume.png b/legoresources/images/BlockParams/Volume.png new file mode 100644 index 0000000000000000000000000000000000000000..447c44ffa03a0cf7ea25b3417a5a5b00a51c8cd5 GIT binary patch literal 494 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 literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/YVariable.png b/legoresources/images/BlockParams/YVariable.png new file mode 100644 index 0000000000000000000000000000000000000000..32c94fbc80586fbd6f01e8c92254d7acbeefa440 GIT binary patch literal 3042 zcmV<83mx={P)KLZ*U+IBfRsybQWXdwQbLP>6pAqfylh#{fb6;Z(vMMVS~$e@S=j*ftg6;Uhf59&ghTmgWD0l;*T zI709Y^p6lP1rIRMx#05C~cW=H_Aw*bJ-5DT&Z2n+x)QHX^p z00esgV8|mQcmRZ%02D^@S3L16t`O%c004NIvOKvYIYoh62rY33S640`D9%Y2D-rV&neh&#Q1i z007~1e$oCcFS8neI|hJl{-P!B1ZZ9hpmq0)X0i`JwE&>$+E?>%_LC6RbVIkUx0b+_+BaR3cnT7Zv!AJxW zizFb)h!jyGOOZ85F;a?DAXP{m@;!0_IfqH8(HlgRxt7s3}k3K`kFu>>-2Q$QMFfPW!La{h336o>X zu_CMttHv6zR;&ZNiS=X8v3CR#fknUxHUxJ0uoBa_M6WNWeqIg~6QE69c9o#eyhGvpiOA@W-aonk<7r1(?fC{oI5N*U!4 zfg=2N-7=cNnjjOr{yriy6mMFgG#l znCF=fnQv8CDz++o6_Lscl}eQ+l^ZHARH>?_s@|##Rr6KLRFA1%Q+=*RRWnoLsR`7U zt5vFIcfW3@?wFpwUVxrVZ>QdQz32KIeJ}k~{cZZE^+ya? z2D1z#2HOnI7(B%_ac?{wFUQ;QQA1tBKtrWrm0_3Rgps+?Jfqb{jYbcQX~taRB;#$y zZN{S}1|}gUOHJxc?wV3fxuz+mJ4`!F$IZ;mqRrNsHJd##*D~ju=bP7?-?v~|cv>vB zsJ6IeNwVZxrdjT`yl#bBIa#GxRa#xMMy;K#CDyyGyQdMSxlWT#tDe?p!?5wT$+oGt z8L;Kp2HUQ-ZMJ=3XJQv;x5ci*?vuTfeY$;({XGW_huIFR9a(?@3)XSs8O^N5RyOM=TTmp(3=8^+zpz2r)C z^>JO{deZfso3oq3?Wo(Y?l$ge?uXo;%ru`Vo>?<<(8I_>;8Eq#KMS9gFl*neeosSB zfoHYnBQIkwkyowPu(zdms`p{<7e4kra-ZWq<2*OsGTvEV%s0Td$hXT+!*8Bnh2KMe zBmZRodjHV?r+_5^X9J0WL4jKW`}lf%A-|44I@@LTvf1rHjG(ze6+w@Jt%Bvjts!X0 z?2xS?_ve_-kiKB_KiJlZ$9G`c^=E@oNG)mWWaNo-3TIW8)$Hg0Ub-~8?KhvJ>$ z3*&nim@mj(aCxE5!t{lw7O5^0EIO7zOo&c6l<+|iDySBWCGrz@C5{St!X3hAA}`T4 z(TLbXTq+(;@<=L8dXnssyft|w#WSTW<++3>sgS%(4NTpeI-VAqb|7ssJvzNHgOZVu zaYCvgO_R1~>SyL=cFU|~g|hy|Zi}}s9+d~lYqOB71z9Z$wnC=pR9Yz4DhIM>Wmjgu z&56o6maCpC&F##y%G;1PobR9i?GnNg;gYtchD%p19a!eQtZF&3JaKv33gZ<8D~47E ztUS1iwkmDaPpj=$m#%)jCVEY4fnLGNg2A-`YwHVD3gv};>)hAvT~AmqS>Lr``i7kw zJ{5_It`yrBmlc25DBO7E8;5VoznR>Ww5hAaxn$2~(q`%A-YuS64wkBy=9dm`4cXeX z4c}I@?e+FW+b@^RDBHV(wnMq2zdX3SWv9u`%{xC-q*U}&`cyXV(%rRT*Z6MH?i+i& z_B8C(+grT%{XWUQ+f@NoP1R=AW&26{v-dx)iK^-Nmiuj8txj!m?Z*Ss1N{dh4z}01 z)YTo*JycSU)+_5r4#yw9{+;i4Ee$peRgIj+;v;ZGdF1K$3E%e~4LaI(jC-u%2h$&R z9cLXcYC@Xwnns&bn)_Q~Te?roKGD|d-g^8;+aC{{G(1^(O7m37Y1-+6)01cN&y1aw zoqc{T`P^XJqPBbIW6s}d4{z_f5Om?vMgNQEJG?v2T=KYd^0M3I6IZxbny)%vZR&LD zJpPl@Psh8QyPB@KTx+@RdcC!KX7}kEo;S|j^u2lU7XQ}Oo;f|;z4Ll+_r>@1-xl3| zawq-H%e&ckC+@AhPrP6BKT#_XdT7&;F71j}Joy zkC~6lh7E@6o;W@^IpRNZ{ptLtL(gQ-CY~4mqW;US7Zxvm_|@yz&e53Bp_lTPlfP|z zrTyx_>lv@x#=^!PzR7qqF<$gm`|ZJZ+;<)Cqu&ot2z=0000WV@Og>004R=004l4008;_004mL004C`008P>0026e000+nl3&F} z0003ENkl?~Y>B4Vkra0|Ksx8NSMi4bfo1qlWl{~EC{ zpx9_3Vxfqj7Iq@05Xa^!Lm-gJBwbE*zB|l2a5&$cLXsqUp`sqC5B}F+s|O3E#WKd@ zxQ^5CLnvbe4Q!koAJy9iV;D=}UsB*HEQf!>Yt|^XQ@(`J@GGhLCZ4l`FL4omEZ{}V z#q15c_|B9uKCpx70M4gA0{am~N3A$ay*!IG4B!iU9kn8Kk9xFYA~nCpdEOpZ@zXS` z;WIDz05_@gdt{&c<~5qST5DCYtl&w^gilcE)~;BMTL@>k&9y5+1w3Lad^Mu!3it{S k;qThrZiW7@=}*4{07=R?-_tQxNdN!<07*qoM6N<$f&fXTo&W#< literal 0 HcmV?d00001 diff --git a/legoresources/images/BlockParams/ZVariable.png b/legoresources/images/BlockParams/ZVariable.png new file mode 100644 index 0000000000000000000000000000000000000000..26b0b400c484d9fb9c22e355a29ee61cbe743890 GIT binary patch literal 432 zcmV;h0Z;ykP)8*zuD^K+2Is^P8+J%}-O+AwXaV#6BcCWXAA~ z8mRAf;*r+};u0kOcObq?tl^B*sB3`fM-oV#1Y%jJ5XjI_VER}~x2OR+f*VL}L2?8L zRFL8biX8%U1W5lfAT~l0o&|J77ro1oJ|Ol(;_m|DY;p`DJBIi8h;ZmR@Hqfp11v&zh7FGbU0g~`^pd^ExGHR@=5TOfW-guW#}96Q=Vqie}J+ISvy$f!d`9RdXa a0R{l6UR_?A@ZjwL0000!r6}4( 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 Z1^`$n4;CN-SbzWk002ovPDHLkV1g-V?D_xz literal 0 HcmV?d00001 diff --git a/legoresources/images/CTempModeIcon.png b/legoresources/images/CTempModeIcon.png new file mode 100644 index 0000000000000000000000000000000000000000..6d4285cfa0de0122e82cb5a1de43570a7aec1ce6 GIT binary patch literal 566 zcmV-60?GY}P)U>d-XEP_y&ZuQT&~Xa4h@@0>GZghHV(Cq{UfL&Gs)mvy4rQzI|S zh6Kok3%G*w*_r8^FZ|On`EUs*_yj-g7^hTBJ1l|^#$XlJVTg6N#lKj624DhO-q(!x zk){6J}7|>sAE0gQc(lbs-gjCWO3KDGZF6s z5A<+frO`@+%lIBKcgl4qB%6;S6U6yM!ZM4>;Qms>-GO@%WKN=4gC<0~u~V9hEwgY1 z#7Tl+>8mUwBuT8-aIbZG9QrkR`{2dz?&FMkqa>^uR#@=Zm zc9LgUKlF&FX~D~vEl0a)4-ODLwp$g({~yG0;Wq&W0OM1l@Xv%fC;$Ke07*qoM6N<$ Ef@^8~I{*Lx literal 0 HcmV?d00001 diff --git a/legoresources/images/CaseSelector.png b/legoresources/images/CaseSelector.png new file mode 100644 index 0000000000000000000000000000000000000000..56931adc4b168da81fd09be89a39c14afb7caba1 GIT binary patch literal 1268 zcmVPx#24YJ`L;(K){{a7>y{D4^000SaNLh0L01FcU01FcV0GgZ_00007bV*G`2ipc6 z6DvDF1vSb5000?uMObu0Z*6U5Zgc=ca%Ew3Wn>_CX>@2HM@dakSAh-}000C}NklK+Y+4)eWtBuVlu&?(8-X$aaWvue1;qmqsX zLGVIUDx8_hJ`IEJ>wQIIV`Dkn4+|Nk?;b9I4guSMIcW?Z!<0*L@w4gd)iCJM(b0P( zZ3l!V4%`{wNnp(Oc3@c2i?$EP<>;@LTb`u#wwG4Vl?7Y@o-f74Uu{d$J3$cKTZ)UH z%mlchO51)WwY4;cInvS5@f|>1j)s7(joPb`N_W-$Ol*Js#+$p7W>{(i-NOrO<{)WY z(&=U;t_FrjEnR?ZY+q>>bVI@;mkn3f^QZO2rM6bucDFQ<@MQdN97pHcR_T1MXN9Cq z7}u&$p^utbH3l;bi)BfYyk~ns)#xlqNZQ*>=xK$=uGe>GMn*=Svz-H0)P)8>e^e@* zYa8fnHv9_vuHoU~hky>-b82;Rs`3d*1I=zKrUWh6fUXr5Rp1G;J7arGDK1`YHuSV& zTGv;_weF)gE=Q+kqkWqibhSRd{;z9KuqPk(tZF-Gqr<>S;EL@^YHyZg+Ycm_WM3{D zE^I64xLn*&ii@jlFP79N>1~ z7+BQyO~B+S40wK9E1h0{)>%>@wDNX<9<0010PAlD=#T57L$=rFvf(;_Y!FG0|!fS@$zgRL;&{o@41-CWF7=QpBO2)&c1IHY_9En zw)eNfJtnR~vHy~!&A>+BSjwwO;7&(qNQx!B)w1yTA7^>Q_F!5~)ha;&zXU<>R8%Vb z-10PjlL^%2+P9aqYaaqiaXH#Qo%Ln~I&BUDU_{b@?f2tybiS<$rkf~Tk@POGD+q$~ e#c04YS?@m<8S=(C!J8QX0000C`LvA literal 0 HcmV?d00001 diff --git a/legoresources/images/CaseSelector_Boolean.png b/legoresources/images/CaseSelector_Boolean.png new file mode 100644 index 0000000000000000000000000000000000000000..6edf25d9dc5b77b6f8bd63abae2e50f2cc2b289f GIT binary patch literal 2947 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 literal 0 HcmV?d00001 diff --git a/legoresources/images/CaseSelector_Numeric.png b/legoresources/images/CaseSelector_Numeric.png new file mode 100644 index 0000000000000000000000000000000000000000..490334adf81f6bca95370d8dea4e43f5249f4fa3 GIT binary patch literal 1328 zcmV-01<(44P)Px#24YJ`L;(K){{a7>y{D4^000SaNLh0L01FcU01FcV0GgZ_00007bV*G`2ipc7 z5*i>MN_CX>@2HM@dakSAh-}000DwNklvgC+PQ_@-(&LmEBt zQya>onIsrvuI4)21vN%Vjysftl70)r`MT$Tz104h=Q~LxNph(#ph-UKqDDGC_brfg z%pyK_9Es!FC)UYK!WblZxV=3&fNx5Ai{wcM7?6BZ(jtIC%OO2P@}i9z>G(;~aeyP8 z&UJ8__W@XL3wwU1v-2?hpCp~PtAf&`0g<3XIUXhXeIA2M2Ok9>vF&~a2i**EPT%3a zcacqb@Gl(up#PJgCAC#az1SJ(PzOW8be^NO{E@V(hNK37k4XOMNIU{K0cgr|){28B z@dtpJRBN+xU;w-!>3F^}NF+CnF>}pkvtdv1B#H9?r>uJ+)=8WKa93B-l1Vy406r#p z)Uox8aa?=OWhV%#_W)V|Fl~Fagiqr*Jk}3RkCJ@aMMaVe1vov@qK8Z5aj7o{(HQf% zq)|H-0l?(~b{>{AW;+(Gpy+a6KqpD^e2b^FP>kDA6#iP=j*Y6k5k<9)zJSh@k+xue zP|(iHo+TIiqSI&3zCJAJ3C|^Vq2SplyEIzzQ>+l^t*x#0meO&}|H@}42&yl56iXz& zDWuauP#v;OMp4)xc`DO<$*CZ@2B2QxT`xK!3=*rUb9s1fMNyb!l8g2n(PWrC!sR%PexwXKr;GOxWRNhC{>UUStO zlJ-cxm)9dn?F^CpvC!!cg6b6jCp=A=Gf@=2@31i~>8kxwAdvhlio%(`&_mJ*Pw@ju zA9}X+6;GoQQn6yo3pxm@Q$F5G`X!EQH$0BbIFc4qt}ga;N6Y}4brnfPD!U-4J_KM4 zj#e(o>i{oN zCv?i#avaz8dZve@BLGHhUBvWr+frJ&*{CrDVBF(WgXCJzeUEfZx;_G>^jI^->^Rnx zNS0k6fh289TIo3>Rw{FY=|>Px#24YJ`L;(K){{a7>y{D4^000SaNLh0L01FcU01FcV0GgZ_00007bV*G`2ipc6 z6EGLs>yono000?uMObu0Z*6U5Zgc=ca%Ew3Wn>_CX>@2HM@dakSAh-}0007WNkl19{~Uc(42E4rG!{4wv^CHDG)*^ z000L6pjl`OJ;B5@os2Ocgy=br69NE^wj+WGg3uwNiPD3JUJ%PqHwe=7K>e}RJN-c-7z0Wvv1k|~VoE95>-EOo^7;$|kV4`1NvZVc-8uJZTv=Id z&LWYQ+4ZfhyX|E1+FK&R-zC@J+S>JYrBXhFNG6k|zq#dzcme>=?LoBA7TQ8vXbWwj zEwqKU&=%T4FAUmD-Ep)Y_9uz$G}df3(eu0l0E}jy2_eKZ)gj8|vMFOs4t}jBu`mq3 zxUSooDm9zQoyM@k!^2lQJFo9aDOLYH=iD3}9o^`5yH_WTmr@4lbh^P9Q)daQX8HWh z&&6W#2_k-)yQcvFTCG;1(P*p-Ax0BZIH!a=uqcXL-}l#tBSdQruIu2!!ebbaF?OkO z!_R(A<)V+Z>S3W57}KVIc(k6+-)LhDXss7|5HTK)ho0wsl~VTR0Zl|al}fc{k>8)3 WQ0b4243Am>0000Bc;(JzunxTVNVS&rg4e!jnUF5?WUO9isb|7IsjAvG-V7=xms!6Jv-roMjqHR zJWT?XbvzGCC1!c*foRZSyN62W6rO9Z) zkBFS%IsNTLRwdxp3Wji6WYI(lw$m`0{9s`|LjP}ESh$#vKE+8 zfjEJ+@W!|<&%mo}r#epM1VXAoTSGILYXxox+ZvC))>eopb;pUf#%GhOwOhRq~=f r>8TI+9SSK1yhna{)S;c`SAYQko!Q%rM>0fw00000NkvXXu0mjfR|pN& literal 0 HcmV?d00001 diff --git a/legoresources/images/ColorLampBlockIcon.png b/legoresources/images/ColorLampBlockIcon.png new file mode 100644 index 0000000000000000000000000000000000000000..c004a0ebbf61754257efc935da4c8bc2a47a860b GIT binary patch literal 3427 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 FV1fmupC|wT literal 0 HcmV?d00001 diff --git a/legoresources/images/ColorSensorBlockIcon.png b/legoresources/images/ColorSensorBlockIcon.png new file mode 100644 index 0000000000000000000000000000000000000000..82c7cf0323926c929633d64e23ab1c22b4901a5e GIT binary patch literal 5317 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 literal 0 HcmV?d00001 diff --git a/legoresources/images/ComparePalette.png b/legoresources/images/ComparePalette.png new file mode 100644 index 0000000000000000000000000000000000000000..ce816b6b0d4b8250c381c10694eee91fb44fd183 GIT binary patch literal 879 zcmV-#1CacQP)Px#A#_DpbW?9;ba!ELWdKKVVQ^?^V?%Flc4cyOWpW@WNp5syY$$+R4drE|+6jlfz+^q%31F=-ch~!^6XGMYzAee|&sQBoYe?A9(%; z1L7+gzZ9X-Xbc8}Xf!%M|1J^}I*$83N{4=@ z)9Lkk<6KzN?RI-Zz@IqaiEf7Do~y(3&dv_03`no9ukjt0RxX#3_@6Q|nM|Qjz~Jre zZ8W+!fexFq*{s!SHJMC)zdw~q)oL|5C5ocaXw>WV__8c(v)Oo_$1I_no0|!T$8rbd z$Q?AQ)oPVW6_3YB;25k{tC2_qQ{iwJ(V?29Qi-54D2x}+Rtq{97#5jEhd?k2$HV&j`}=|*5N8cP0T{s=BtfImghC-W=0)F;>~x|qMB0CA+#X~a&RvS~)4(Y*v>Cg>t18V#0ZjV;-0ZAAd%-Q69M^N((AZ6y}tlgU&< z5#otNRuJ$+&d$F5OZP>;rvCiNw!Usr1gnh2#l@wik9&I|rdpNEhL!g-Z}8YFYtRKQ zQA`U0&seIj+W+;fZ+&Z>@d|}Pq7upw zmxJeWIT?RH?17iC4IX7OnZIVAbUe`wuou3-R5$_CgF3nvBA&R82PR`z!7Nx*Rv|1) z4Q2`))~YVJ4^6QP;bm!<8`3;fZLj>nD|t*mq+EDp2kZ-K;Kd&>pJ1nouE#8Zr?CoQ z;L(`P(86TbB7N|2m%l2%CvjMRpLHd2L0h1QqsMa7gzdH)n(dOB%vrUZ5 zgB5T9ZX5NojT_4%M7<$tTV{R<4ry+XGC{mjE|17A*$7#91vlYcG4Nq2VkbHkqU+xV zBP1vZ!an%T^97^Z99ZJoBQn$N>VnE6YWFLkenvAK z|En+Uzc5#ftt?r1O02DoaRKXNJBYApnBjMZGw;|su2ywZ(%U{p0SUY)H+mh0W(AOruj zIK$+M@J*jb!mh|dP(KE<1s?0oJ90sM*7(_w(v&|b>W}bdJ-B2$b~AvDmb{+U#Zs%c z{-aTZ%!jY~oKD!6AI9$SblgxOUZwnhB$=p?@<)IH06w71+8C-*&j0`b07*qoM6N<$ Ef-)6(s{jB1 literal 0 HcmV?d00001 diff --git a/legoresources/images/DivideIcon.png b/legoresources/images/DivideIcon.png new file mode 100644 index 0000000000000000000000000000000000000000..f523e36f37d8185d141ebba0882c0d392821e7e3 GIT binary patch literal 264 zcmeAS@N?(olHy`uVBq!ia0vp^d_c_4!3HF+i2N%7QjEnx?oJHr&dIz4auiEkBT9nv z(@M${i&7cfixLYmGLxP2^U6|-N>YmyG(7W4QgbxR+kZ&{6;JhaaSW-Lll0^Ne|u)j z89Kfergqied>-D~n!W7%`}@~bJd?AtU)yMFul~Ps<;vqP7k~Wu`S~aF{Cg%fA09MX z`Ssr4U;jL6Q;MhNMv06SG7*n=m%n#$Jf|c!-?I3a;F^!Ox98v4oOU)#NzA_XSBT(p z`Nnku)qj3$Jau}yekxmKNkb5ifxw)GmB(A`GN(%L0A2L|KQlw=54Zod{|z{RTn0~9 KKbLh*2~7Zmlx%kZ literal 0 HcmV?d00001 diff --git a/legoresources/images/EqualsIcon.png b/legoresources/images/EqualsIcon.png new file mode 100644 index 0000000000000000000000000000000000000000..0aa79b0ea173f7eaeb879dd65c985570e0de345d GIT binary patch literal 183 zcmeAS@N?(olHy`uVBq!ia0vp^{2ZB= a|1&d8{GH4%P)Kjn;Z+u}3l>Y)WY%h?R4W#*j zv>p(@0^&2c3?>E4h8pGy#Mgm%G0?(~7^wniGl+8ph%2E%fgZ-sff}D%KvTqMK|jb11_&?!AB}NGXiF=S00000NkvXX Hu0mjfvLKvF literal 0 HcmV?d00001 diff --git a/legoresources/images/ForRotation.png b/legoresources/images/ForRotation.png new file mode 100644 index 0000000000000000000000000000000000000000..9842a41a608af18f662532878ad3c41db5f015e0 GIT binary patch literal 512 zcmV+b0{{JqP){Z=O!!Qs|5%0|gWCOYZ*`VPCq`r_&K$rk`gRp`7f&?#ggSH!(4Z;Sn0e9%L zbPZ=aO5v?1om{uBzx%%Xah9EIq)mn#y189k(vp*RuP@IZV}Q;hmrrRi{ovV zL?Cyxv;yF0J5xX&X|V!i2UatZZIzJtjr=0X2uuvNpX3!?z8{#!D?X3yb&wHq(h87r zCNHXbUksAAi>OqBofT3yfwMV+c!)M^!fFK92-!+_rbsyoh%3@i9-pw^ zLw+y4)B5cvN4?}%5fGNF5FmY7*}BwZ@I_E7<-EgWSdxD!l{Zfm(}8p?*yQ-U^uV!+ ztu*>3`Al&63JEMTNHpryv-Ld}koDJ4tq_%$Q0p5x7o7mHArST9!^KwVEr&$Uz*;tG zlKmtxR+<5&&T_4fddl&(R0@L*GjW}r?7!_>fB^uin~*IIDI%W$0000Px#A#_DpbW?9;ba!ELWdKKVVQ^?^V?%Flc4cyOWpW@WNp5syY$uz$efqQu-q3#b?3n`07Equ}nKGpZ825@qClZh| zLDBL3`*$vqQrPd`zga$g`XmU%0)#LyOn6WPx#A#_DpbW?9;ba!ELWdKKVVQ^?^V?%Flc4cyOWpW@WNp5syY$m{@+}zx}=+L1<{$y$P^z?jZV`KB*!^7kK)TvXue*XN)MzrR> zzP`zhj*dS-27s`go!y_p!or;o9z4(_+Rtm&tjP%u4t@wT1cbxF!tQR{wk@9M0K0eZ zo;Jv4dwcsoFhg8iT)uR5bz*16DPVd;UBNk{NJI(+D z+SCe+s-GYY4h{~#8X6jwUAc0_f~a`T&(GiM@9+P7?%cTzuV25GBq@bmzI@s8*RNj$ iQx!4>00030{{sMUC}tDUYL96E0000&ywCg2 zGT-;{BwZX&*rm4`_;_qAqZ`I?+qPdM7DcP~h+su=Leq_y^hBPXl-4~c<3_QNKj%2r zlV5!Gb-8Uoi9{m#)WER_JN5|BaTobx+0xfm*BzVsCJ zPCIc|i4i6_=v{|El|zYI2=O5?aA>PVD}4#ujvh;;lJA8AMEd!ttGj!zT%iZwvVxm} z)!yzDQa=)bPr7-?ypQeMw~zGq?|45HAYIpMb&V`9M2p5RoI(8JITC^vY_<^?g}dv_ zDa8KxWfds3uBK^DI1Q~3g>RTJ?`DxW`2$$F1fLcxz4{iI>$cVj3BCLDcZh#`3f|yO zR1Xe8cJ)4X{qV-9ao87s245gBwhh^xTD=I@6r(D8R#F5nm4P3Pg5Q~e{nsV<8s7q^ zW|YvSC79R$Aw_zq9UejDg_oP`XawT^y*b>vc@u>~0gW&-;h{Ww4DQeYde?(>TXr44II!ua8Uv?NWPe7yx;B|L_Pt76n=XKPEUxJ9I19y&)XpbB@f(o(J+mnPz z=`Dm8loadsb(lA95X~Ik?lfd125kdCybYg+G$W{v9->q>U|zd{mBfGw5CPhyZ(M8Rp+G8LwV zwJ_3{NcO?^$O`ghm2wnjqqBZ!6&^>xIdBk#u@7Km$5BzI_19&mP9&^jSdn-|`A7kG0S0O^X69-%h@MM8ya zYI5?&{8E0p;l64EM#2qlA=-IN5*Yp@gWJ8UykbsnF(ruD&+2J(gd0kTadmS=0;Xc}uHu@x&!Xin;8kHF3 zKb1-?7*nBUkI@+CE=f>6quO@5i){lcmP+}FiHTnq7Z=NN%~uC)$h#7W=VI|#(jyRp zM6N16wY|tqPeFZ%EG|BnbRFk5Qv<6*W-KhsUy4Q};d*Mvb#vuP<#;ZaTl?d^{v*s9)$>K5FwJbAS+Anu?suYN|&uIfU z5{byD>UB7OWL~Ytv13QSM-J{~$+wi!8sSskss3*DQJ{wvB(E>bX+hTNYePLF(Xvb? z9az=)cs6*(wybol2GjPXI)HRKjs5%gHOouKr9&;G!V(tDT2Sh$Gu2_W=bK<=J*Mi1 zl$)w$&8~1Ot_CQz?A?hwd1s({gWm$G)oSNiwvs)vgs7#yWY=U_Bc*BF zY&AcXO0~?mmVnH48Y;uk-0@qtzL}bwzD#-$Yl|CYlTj=dFKp(p>`D7c?|%UX03^hX UTQAAD82|tP07*qoM6N<$g7j6>TL1t6 literal 0 HcmV?d00001 diff --git a/legoresources/images/GyroPolyGroupIcon.png b/legoresources/images/GyroPolyGroupIcon.png new file mode 100644 index 0000000000000000000000000000000000000000..27ac483922072982149fb513fbf3a2b2e84ff455 GIT binary patch literal 2050 zcmV+d2>thoP)6v7-zrS6f^Oeo)LI!?1f zeMm$*4C-Q0K)*rvGbexhyPn|8eyvTz;NM0H#o{F0ni_qq>pBF4_C3#plqDeyTWib7 z<#PL}Z6wfSoZ+>-TD4j^K#y1H^kRXg!Ir^qm*Pp3&3cAi^9KpH?Iksz`qno5Q5 zfN0)9<4}9CLN4KwW+c_v(N*!n+1yB9X)63tHb(&^nbzUUB3$%y?dZm3huGanC zu`lQ#2%6ME19$mguw-K0v@F%{o4)hrx~(4vfqI?@mUk00xfO{|>V<4J^S#(im&@go z(lCY%3XWbnL7eOo-m1&!4IWAHkbL05kym}sKS8hFj|DoD&8ig{+Drw6??JOMg3dt2 zcL8e4eRTRW(5T2s+2+NP+NL82L+Tn4x4jx54dNGu+k$dl5SZ8Noe>x3WZ(!+1KS7X411bXJrVVr9ItqXI4XjTu zLk}g9eBxiIKlvPFD|*aF4l-@ouy0((&0#9%>Fc7fs6U|;%*6qEpp0PROc;fx)FXgS?-1&@GDU%ZG zRldU1)MZRfPh)PbiVGM1gLCIDpj$S1R=ivp{sU$5alyF{#@qs==TJ{_fS`Grod!g` z7D^tdFjDyRO~Fwqf)8BG_8(070{k zGFzs(uBn^)59mE*GGs_&)rxj=4U$f$kW41gzm%Y$CL@`M2-R;4(5#!8Jc3*)yywJV z&dySB+E^9ZfY_tdi$}+f&^1S&X&g9s07s8L9s*ti&AM)pR$rljb`@3N0sQQ=Ce%PpWxEQ7~YXbAV_5fuG7+O!ui&5_y-U1q6%1cVP3oe z%?e_ek>VnBr<#I!?gnW#x6|+@4#R!;33_(-C?kF`1*3Yivl?uBP!I2iKSI)_qRcIU zHipnXJPPb1@SY!LR`dFG*k50wV6-EHj;!dM&Ak1GPX^y=8Kj`vBjI z)`{m)QaOOuv)>K@`wtyLd*lebLOJwx2(dfRlAW?!f>=S)IXL6T!V}+LkwQ`l5wScK zej7dkTzKi{UFCGAkMOzznqxw45cY_mmu}wH_WWiyOg05WYu|%}oc9`Cyu+Br! zDm<%naF`xX#oiWMUS4j}<;>|*r;bWPn!2}d^TLbDjlvPr2una_il*4;?Bx;bH)p?D z3k#>=IE`lGbHN|zo)xe`HTe=%g&)#mGqz8YTX3VlR&G_^CziwAu3lA%^8FJ}J^7tK zmWGG(q%>QY?3T>W&z`+H^To_}SL>6_dnfdo?2#&)NjL8(xvUHxn5J3pR|`vKQ;0?~ zmD0Rdq15*JTP&5-tUC g+sYu^=zjtX0CjMcNW@5okN^Mx07*qoM6N<$f}yzfVgLXD literal 0 HcmV?d00001 diff --git a/legoresources/images/Hardware_EnergyMeter.png b/legoresources/images/Hardware_EnergyMeter.png new file mode 100644 index 0000000000000000000000000000000000000000..6a477168ad1bc7af4028f66a47cd1397cc51cb12 GIT binary patch literal 4486 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 Y0G2JCMghmH?f?J)07*qoM6N<$f?T_9D*ylh literal 0 HcmV?d00001 diff --git a/legoresources/images/Hardware_NXT_Color.png b/legoresources/images/Hardware_NXT_Color.png new file mode 100644 index 0000000000000000000000000000000000000000..c004a0ebbf61754257efc935da4c8bc2a47a860b GIT binary patch literal 3427 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 FV1fmupC|wT literal 0 HcmV?d00001 diff --git a/legoresources/images/Hardware_NXT_Light.png b/legoresources/images/Hardware_NXT_Light.png new file mode 100644 index 0000000000000000000000000000000000000000..e9ae7f11848d3d2cd6a32e4cf7c21baeb3b39637 GIT binary patch literal 5091 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 FV1ld1tbG6g literal 0 HcmV?d00001 diff --git a/legoresources/images/Hardware_NXT_Motor.png b/legoresources/images/Hardware_NXT_Motor.png new file mode 100644 index 0000000000000000000000000000000000000000..f9aa8e8e12839123233a04b69276bfa97ac66218 GIT binary patch literal 3205 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 literal 0 HcmV?d00001 diff --git a/legoresources/images/Hardware_NXT_Sound.png b/legoresources/images/Hardware_NXT_Sound.png new file mode 100644 index 0000000000000000000000000000000000000000..1d79330abc3bb62890c37c04188096ecbcfacbb5 GIT binary patch literal 2429 zcmV-@34->CP)H}lIrR1Q z-J;)LCObo*?*1=8xVPT=$^4g=mL|qVVPawu3EI8YV!=xP5{sh(Lte^@CHUa3@K&RBpl`ZJjfOeP~58XAz#=OtsVS#HSXa(c#u z_V#vkbad>asb3JF6DtN%VpNkgH8nO9-3Nogpaf*&#tl%b)e;+QFdz)jN(N(T=gys# z^!zCT^V1apA>T6pvd^#hd_JU7Dd==M3CQCtFi^~uEJmI-R4NsA?AU?o>gw+jm|n8( zWr1XA_wAcnE9eEs+-{Eqih(c~42!yhfndz61PqI-*49>R*|Md3)>S`PGFXi>8gV2X z4ogAGcCvYM`@BmQ8w>zg@v)TOA9W!Pa7{=T?@B9p7W8=_jwP_vye;SvrWJa}??+P7r- zF}Fmc5sZx7mjtf5x=I4dg8I^>%QWwRMlIs2k>6mOzaL!C3BO=QffJCVZX&NLhe@MA zT5iO6u^beSh^4a7dOpVWJHsd_j4=S=Q3w$yD!Bku zd;xz9kRHiIG;P?3=e_TuIdPp;NEE0Qy0Ym_1o$$@1s=k-ZCz3v&@TVf+}sqg+bj35 z3OrkXB---S60ovgn$47GGJ`B9$67@Y&nK@y!$n~YeF8oigvww>USosL(2SsN9V$o| ztL&8!DYdn!Nu&!U@buz5cREbvoLY^_I+T~0Bqf+Z(6+%%(y)@}Vfmo;)Ja{?% zTU2JbfS-RVhe-NjHkYH`)sIHsW$5@6N;(oc ztreL>3>vymG5D)RyZHY84+iKmKyec%Fh_@mZq2j-$=kux}pBXHYx z18P085g*h^57gNpM)NvU*5+Zc+F=gf!ZW^$(250czH9iX;y8TfbrfS-NjzzcFJR>H z@$liJzSh>`QhlJ0cs`3t0?>XO}&_+yQIJF)%QAsjF+--$-jtP`N)o>7uGj1y3i+kdn!f)mu?x zRm}(#eGikHeyu%>@=_Qza3iRH7AiWB5z}9$9i z584$w$<3eUdV6~>(4~RQ)6>&)lnP@PYZqA8$BJZGSs6$Q7R1JUVtmg3k906OB71@C vYh**SAVMqsf8?_oH)gNrW^KvwPXPu1{c$!g4%8}~00000NkvXXu0mjfK2U<5 literal 0 HcmV?d00001 diff --git a/legoresources/images/Hardware_NXT_Temperature.png b/legoresources/images/Hardware_NXT_Temperature.png new file mode 100644 index 0000000000000000000000000000000000000000..63d656a13831d9011f2ad86dcdf58c7b2948f17c GIT binary patch literal 1567 zcmV+)2H^RLP)TcBb3Go7FJbKkw5JJU*MC@Rx&Mv}hdWZrw3H}l3Dx+?o!KhAoSOFIZ`qt{y+(utRg7C!~%IP_<5pF_1hlFaaP=U4ybf^}fS)C;o z??%wD0J?U^e{Ty!&9IpQ!R+%LFYZtBV&-gIK+8#Q&f*+0wC;-%XH zfP4G|VBr!d8idXi050AD-=Rj>k>Itm!SmpB1px9NNZDnH7QmJ^;;{f7b^vk~uyI*3 zC^d3sA+0G%V*)qhDg$uLK{ME!SGWp-dA zKz}uvhhTbvn++5^+!Xe0wDepi&&afI6kCG~Q-e{2*j2jf8LEC^OMhaRF#bsY zvgFI|_Eo~`?I7Y3xV&2;@eD%(Luds)Q6_C6tn<|BeqkL-TCCU6b>{S14U4yj?fu~g zx>~&DZ2%5sR?6F=FuEd(V^FY5IKZkoowUTdl*ZQl*(;#p0#MPiin691 z*W{BFgupPO3oXH5I?TCI42yB-(7G!I(3L|raHlmn5B0z${;%nfb8ZxZ#Wpar{Nl_A zH)WfZEVLhhE)Xd^8iX|KMOAu|GHxq~(wJK5PMB^M>Lq!i_+fxtcR_(W&1al$jCfNU ziH+3gR6`R|6$VVQ49Y`>OUqm3=yfkx`7@;7(Qj=X_wlx^)JiF)F!7v4u&xQL&5pk z^@HCnhV=vO0v|mR1Yex7;Bo{@1pTMORNNHR=wYpXIWN_ZaShi>Qd1|;*@6qF3*NWy zWAMR+2v0{?DdV$QF>}s}9)$o4raunBg)bfFDD&h=!EmguhRG(7fgfa!WeT69qha-A zi1%;RtS9AZhQ?p(5?CV|E=l1T4*AbPo;#fPzxE6An%RD_6Cr!@GvKs#ro96fI7^CzdA;|T>O!viMqGrx7G?-8p8 zeeX2r8D*AaQ6~bmED^ES$1QQ+QUUE51u7#|dN}7@iX)6f8Jg@Ggk{Coke8pucR`3# z&4Ld~R}N=fKatiD<0Tg5?%^zFGE3n!b}w&k@QNfY%K@|YtbSPQZT3F}7yvksgWX%) RTkQY<002ovPDHLkV1mQK-wpr( literal 0 HcmV?d00001 diff --git a/legoresources/images/Hardware_NXT_Touch.png b/legoresources/images/Hardware_NXT_Touch.png new file mode 100644 index 0000000000000000000000000000000000000000..1a19e1f52f6d5bf5e63a5dbdf5b6b4e3ffb45701 GIT binary patch literal 3884 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 Hu0mjfl~BL| literal 0 HcmV?d00001 diff --git a/legoresources/images/Hardware_PBR_Color.png b/legoresources/images/Hardware_PBR_Color.png new file mode 100644 index 0000000000000000000000000000000000000000..82c7cf0323926c929633d64e23ab1c22b4901a5e GIT binary patch literal 5317 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 Uz6_CVxc~qF07*qoM6N<$g8ffHCIA2c literal 0 HcmV?d00001 diff --git a/legoresources/images/Hardware_PBR_IR.png b/legoresources/images/Hardware_PBR_IR.png new file mode 100644 index 0000000000000000000000000000000000000000..7f232861e47cfaae2e7b13197ac4e4dcfdcf2378 GIT binary patch literal 5043 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 literal 0 HcmV?d00001 diff --git a/legoresources/images/Hardware_PBR_Touch.png b/legoresources/images/Hardware_PBR_Touch.png new file mode 100644 index 0000000000000000000000000000000000000000..8a34d50540e60f308d511a1807c116e1f833c0e7 GIT binary patch literal 4904 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 literal 0 HcmV?d00001 diff --git a/legoresources/images/Id_2Motors_Tank_34x34.png b/legoresources/images/Id_2Motors_Tank_34x34.png new file mode 100644 index 0000000000000000000000000000000000000000..e81c0d12866bdf9fd27d7bdc599963f60c35bf3b GIT binary patch literal 3248 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 literal 0 HcmV?d00001 diff --git a/legoresources/images/Id_Bluetouth_Conf_34x34.png b/legoresources/images/Id_Bluetouth_Conf_34x34.png new file mode 100644 index 0000000000000000000000000000000000000000..08abee852e5c5057ca7b7da3618d28dc56dcd205 GIT binary patch literal 5529 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 bKL0lW>$Py46wuja00000NkvXXu0mjfly9*s literal 0 HcmV?d00001 diff --git a/legoresources/images/Id_Boolean_34x34.png b/legoresources/images/Id_Boolean_34x34.png new file mode 100644 index 0000000000000000000000000000000000000000..fab1ff1afac4b4b403116a8f15f5bddd3fed0491 GIT binary patch literal 4404 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 literal 0 HcmV?d00001 diff --git a/legoresources/images/Id_Buttons_Input.png b/legoresources/images/Id_Buttons_Input.png new file mode 100644 index 0000000000000000000000000000000000000000..cb389b30937c69ea3bb7bcf1eafb7e13083eaaa9 GIT binary patch literal 5373 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 bYy3R`BI!`h5n-sZ00000NkvXXu0mjf!0ZC( literal 0 HcmV?d00001 diff --git a/legoresources/images/Id_DataCompare_34x34.png b/legoresources/images/Id_DataCompare_34x34.png new file mode 100644 index 0000000000000000000000000000000000000000..859c0a2ec1aac62c7143997c5147064cffbe916b GIT binary patch literal 3891 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 literal 0 HcmV?d00001 diff --git a/legoresources/images/Id_Data_constant_34x34.png b/legoresources/images/Id_Data_constant_34x34.png new file mode 100644 index 0000000000000000000000000000000000000000..2a61197cdb5db4c810d916fa36edcc86dadf91d1 GIT binary patch literal 4306 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 Ae*gdg literal 0 HcmV?d00001 diff --git a/legoresources/images/Id_Interupt_Loop_block.png b/legoresources/images/Id_Interupt_Loop_block.png new file mode 100644 index 0000000000000000000000000000000000000000..dbe7bdf148fed7881d51d679a8457453906079d4 GIT binary patch literal 4902 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 KMNUMnLSTab4wpgz literal 0 HcmV?d00001 diff --git a/legoresources/images/Id_Stop.png b/legoresources/images/Id_Stop.png new file mode 100644 index 0000000000000000000000000000000000000000..d587a113f5f6a24683e837514663f69ca944f613 GIT binary patch literal 1213 zcmV;u1Va0XP)=2J z(~?IFQud7M+y|JH`50J~BpFyfurM>0#&=eU^}OuznR zVEFl)f$_^9hX0>f82ePj29T?*cliFSQ!|FfHWV_u|hlykLE(%0SYDNPk$NyBkBGJjv7XYf^UpW3_Rce zg6%_A^qGYTqTmUT)c6VX1p}(0+w4#io-_Yr(D(rq{>gx%=swFoh=PZ#P%VE^6@6p; zPdFq10@-NP!Ws)|uFt(noizJe$7$EXN4J8W4T%mJ_)F(uYWljFe|3}F^_ zNPoV~Mgh@*9mgf3_81NE__L7NgRI4sO6-*w7m!6ZPv-{=-J3|NjSK&*<05 zh@lG;$vqRb@;U_n&b0v`3S&Vx#J)V z!(iBHD?&CVF2Dsj3M*IY$iNH-;32`1sI9S+k~+{r1_mPaF*u(R`}c47o0VK=%5o;w zfrNHUbV7iTk2xz62G!E@rq(-^_~zmvs^nP98L2HO6-*J-YRKPo&>{WF`=VpLnyo4mSo&l2a zg{=KvLkdC+6<`pTpT8_fi{oOWwW*C-*Ji5Ua2RN={k;`D1Zci&aw3LdC>-ZU2oMqy z+=DB^Nrt1aWWhNQs{z3Z8k2cW;?jW<3JOvyRj$&X_o=m?UAq=fS`CPwTZG4L#K-?x z`x54Q^_@ehQ{R;S4o^Hmh4^Z&5(5l3l$dwSp@bpHI6FC(i2K4vG#<|i-o(2H!?*Y2 zIMI9~H(W=Vz zDZN`9P~HSnKcFQ!G7yd5EO0Rak|CobkZMeczJR>hQb-P0h5Yl8vMKchQVqimkY`(H z51@I72NXM{u0X2M1liV=V+fuNpM1I#kZPD=0SL!BfKttvjzC+#AXy*l6zpu;?_3>$ zRHF&F0ZlfPI600000NkvXXu0mjfIdmuh literal 0 HcmV?d00001 diff --git a/legoresources/images/Id_W8_Changes_34x34.png b/legoresources/images/Id_W8_Changes_34x34.png new file mode 100644 index 0000000000000000000000000000000000000000..a81b42ac600b78e213a3f972179804ce35484cf6 GIT binary patch literal 2370 zcmV-I3BC4-P)009KHe$&P+|9N=08JL)u7`}e{#^CMk$%t$Z3y2W;@jHP(uVlg9f2<6= z94t6}&G7iilmD;Zyam~JA7tmpk01Z<+PMqF_XivM^VhHcYqi}N-hKMY;B#s%gR`9z zT=U(BcNhTzh=CAb1R5p3WclI;K(B#JW4L+q=7GY(d`Gy7Lr0F*{{mVAih}p=KcIvX z9BdIc`u|wV{C}62@qe6l-B2_C4~?&QkZ<5Y3j?1&fBt{*(&hayNmx)bfh7O_`}ZG+ z7{tZJ9YFkZm(DV%D5!!pGVMEXF#g})zYLFc9T|QeH~|(k(ldq`yny-NpZ@{>e*AP; z{_i`({2kjFzI^@4aOc5oP-(f|Ja$N%5I|A4~`guj0M`u`0u9v=YH(CgQ4{^N}i z7^5E;mbO5r@awBG@VnVEu={y4{1W7407d` zVkZChsaT`90F;`5xE_f02^#k0%a`|8uU(%H)yNNvD;S>GKM|2dki7#=&ySz{7Z(>} z0EQ0(3kwUw%U7=$Tpe6cEC9tT2t-H3FkHWO9h`~50*8+r%?G9T-+v$hyGg?M|HbT@ z|8L*D``=jK1Wz$A+mSJfOWwYH_y1aWHp7j}w;1fW85te}v*E{|zZs17EMfS@`2T~S zr|$-!vIHbYIRG=$K@bBVfT)7NE}1uP!GB&34uL3kM9hh z!3pl`0idmpxC{Xo8<#I#ZU_zzY7m!}W>D7D08214GXu-Zj||-0+zja{=>-IxbN%{_ z|Nnr2_Vw#Gc!~v;bdP|s^$M6;4;(t2k54~1d-C$~GBEuA4@Cb^{K?43$ng93F9u;D zp#Xx0+^O$o`A8!u0>)Wvk={CWMGEffCZG9W5E>i^ZN zSHU#QRZPeRoIG_pUQb8o0s|`>!^209{_j6{h#x2{0F&3$(qve=Vkv``mKMXw6Q{ss zCyF7bPM?`?WN5J9$B&;3U;YAPg^Qcv*N>kc&|Nxd!X)egd-&+Fd>tL_1W=TMusE=S z=3r-M;OFNDE0UIx1{VP!mrR;4nZZ!c2ur;POqoEPxi1y$??(_wPUaFRviS@b2s-hP~cN42A+M3^zXhVK6+iiQ(dfiws@uoeWQ( zJjJjaRrd2+ydr+mktpOwzf75#-=6;KxN3`a{#$w zrbc}%87e4rHH|2doh(H(m(ih6D$X%`cqC`wC9S)KUin-Pu6 z6qMjM7co%jLPbp#^2!|$E1WrUDDc52Nj=SZcoH86s4U3RJbd)n{pYFg0&jln#X2e< zk@96S3N%w440Ms81cp9Rt;SOjKBUCefq^l^JG@5;C3!)CKFn)MN&xi978&Mxw7vRKTMU35Ib zHH2|S(0_~i!gjcBw{p%Pt>zu^zP(={G92OG-@Ruy&YnBN&)-pVrSbf;1$X0_jEFkX zTPPJuT4rT>@}cJyZhf``>e)+B`(DE*Z^UTZPdqcsBVYO9D)J~pEDn1Qp{J(@t=D{f zN#+1z*K|uDXgWXVVuz#ODLc8Pi7W5$bKNfVDev(qkz27@fQ8!qNAH0#BDC593mlhQ zAXdt-l39QHB_@j1kWY?T%?yWcG@lbh<@^-W@M2z~7jFiuNQLf^1b-i!tT zdQre=T)=R00tWg`3F)r6YB};YZ$xkJAKe{+`)mOJ^!wOmoH_!GL+IJSzY-d2s2esl ooSu&jV1Gt1uR`}`H9xb(UnJPUJS2qB-v9sr07*qoM6N<$f?)}Y5dZ)H literal 0 HcmV?d00001 diff --git a/legoresources/images/Id_W8_Treshold_34x34.png b/legoresources/images/Id_W8_Treshold_34x34.png new file mode 100644 index 0000000000000000000000000000000000000000..15fece14a8fe7f64d215e4d695c8bf38b125d71b GIT binary patch literal 5345 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 literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_A.png b/legoresources/images/Identification_A.png new file mode 100644 index 0000000000000000000000000000000000000000..ad11e5eba2c6874a14ea8748425a3c358e288840 GIT binary patch literal 289 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|-S17srr_TSt>We{fW zJ+R`S^Nj?tnn~Zv`kp#)wXjZXInVTQO>_IV^NWrgU6|3<)L^~74N@IbJ2|oN#4 z_a3-lJcD)qlD%^uGbxDrH&t@;%iWsqa3NvE!d8cxMvvz2%!W4-*aB8HBw9zaGn)LX zS15B3JKXO0Dlw--T%MuoKI4nI{1r{hWjvNLZqydI&wA0}Yc+@KJi99ej5ha586VjO z{IWH3ewfH(^1@#1u`y?L*8%mM}>gQu&X%Q~loCICJ}jOPFV literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_ArrayOutBoolean.png b/legoresources/images/Identification_ArrayOutBoolean.png new file mode 100644 index 0000000000000000000000000000000000000000..eedb47f18d132f6b5ea254493526dae9bd8094aa GIT binary patch literal 430 zcmV;f0a5;mP)qu*)_a0NGW0H0uq z4IYX)K~n^(u8Mg|71U)}oXv$uM017eKN|nQHe#a;mJ9{5l;dCk_HY!Oi|k`$uPjTH zgohR&mHypGQx-KtGtBb`)y){*=pGIP(5^e!ma-dzverF#PYM7sxCQ)%p#EQCA_A~oB7=hLf7v|4p z8Is~Gp{%K5ty?L2Eoa_96C8WGJ8k)X4ZCv3EMXrmhj-vMdv+Y;^|$_n-aq=+1K$J~ Y0D|<3*@d7*djJ3c07*qoM6N<$f-nKHegFUf literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_ArrayOutNumeric.png b/legoresources/images/Identification_ArrayOutNumeric.png new file mode 100644 index 0000000000000000000000000000000000000000..a9224ee4c107b00319184e8cf4394899a2d50a40 GIT binary patch literal 394 zcmV;50d@X~P)_=GS>JsMvCna_gHNxb0X zeo>J&ciE+5x1>v513mQy9>K)o5bqhC5(&F;HU#)cYWy48-?< zxB@87h-@f6zzECIP@5fr_%jfn!J+;v&|njodXPnEF24xG;BaQa;@Yzy3xNvnLcqE|F>t>H4tX* zWjM=|c2G4j|9J+_l5-4&&ks8P)@JMNZV!}L+*)oq!HYRbb;SjpgdNL+UnNagDC^PI zIdF}M}#BTPbtnEHU z#%{%yk!;e;%ANwcFB?Bp2mA=0)aNMpg)c*4mxadCJ4F<00>`T)cZKz!iD$zzNxPz4}C z2B5$}kYb?1dSo->fp|ZR4-i0D5hJqgAme~W2{Hi%@?k1K0zm$Ikn0=JbT=@8WYGjC zAiH2c5Zi;;00G2^B~<)@Q~}fv4M3AFqPPmpWiZDuB8A`r5FaM+9!LpbQw)^{`A7g3 z2MrAP0Z4uUvTj%ezyK&B767pV%oczEA_-v&jea0y0FB;8tcszr=>X*}fI0~jgb6@R z3*m_jnhqS040!-lPzZJF0&p?|0u~}dLjY6Kw8Uz(X!yiR4J~w}W z1|>?+oreiR)93>zT>y0VM2tv*S_x910K^wS!G|ml5MVSzjCcYeAL?%bJo*nny>yY7 zG>04}7+C<84xvF&fE4KPRWn@ag0w}G3ZtwvL4NidNTy%pI$TbmKEF?e+nT5zj04SUuLhBHGsREmUuv7uh qNrcjIJv65AMd$-)GCRmXF8~0voSnJ=?uDrU0000 + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_BrakeAtEnd_Brake.png b/legoresources/images/Identification_BrakeAtEnd_Brake.png new file mode 100644 index 0000000000000000000000000000000000000000..e05370c91203fe18401d123b580014d6ed71ecb2 GIT binary patch literal 259 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|*ZW7srr_TSt>We{fW zJz!vPt>Wq7>e zU;%@Xgyij;Rxu1oj3tFZhQeaIzcl`6*gJPIlPX`@Aw@o;KTH=2n6spLnEnJzXIJ31 zOPjKf;Rw?d2_EAb+Y299Ozzt-NaZgU-J%?wzOc`@iP32MLOYE_6H0VKDi^G|QFG!C8O8>qo5$%oliA zBbPLs52(>&+qr@vL&5C`1FwqKt>We{fW zJ+R`S^Nj?tB$1o9EvGTBG*Jj^;+o6)=qfw^+xJJ7woeSOVw2h>?XmO01T#jdx@k`q zH0%;dd10%-$1HV-TY98AqBQ*N;x zR$9S)vp_&vt>We{fW zJ+R`S^Nj?tlE&FRPE8J3<^s~rt(UI;-#?pma(O|42Xj!S$EO5Sc0QRIt|yK@4T$1c z!q{QGU|J&&>&de$Ndos-G9;8c*d7HeklEzQ)AK@-C4=L{*6N0JZ(2S%a>ZPJ`}G{t z%iRIaha1|~shRdTvb8kDa2`<*-`C#h$Xn}wA|QsX-05Zcg@lz1yZ+f;3HYSUpVh%B zw)K7H)H`9$yy7fwAsSbC*xFuKFG+aSu#`!F_sH&x!K|J@dn(jTIGc1VnN4`6B%O1p mE#}WJlGbf;<4t4WFknz;^uKE(P+bA^GlQqApUXO@geCxI$$6Fl literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_ClearScreen.png b/legoresources/images/Identification_ClearScreen.png new file mode 100644 index 0000000000000000000000000000000000000000..d91f838e13f113ed9565f51245005574f76cb3f4 GIT binary patch literal 369 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|-h67srr_TSt>We{fW zWjM=|rsx*fP(Oib!Y+m*e_F2O-PqALQA3=WSCnC;`munZ=0^+yuY*l{8rQ`-^ewF5 zWs|zau;kIoSy~NkY78r@jLz)tFb-wlHDw6;?AX;{nA4!{B)`D*g}Xx8fmcZ@7P2oe zvwq+mdf`bsk4yvK&xVIdE3_RZer1dmob^<=LF5GEf-QgLwB~Sx)H8;&Su%w7oWH=J zFqQvEpT{BY##iDCR;RXzIyv|rnda8(&@9#P%JJaB25q^B4XN%no&qU988Zqj9BMu4 zA{*I+7QDPI5I$jI^sb}H-8y^p)QskAbQ3#wLVB%ZMw)>`10%zB&hP-932(!JA;IA3 L>gTe~DWM4fNYI3C literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Color.xml b/legoresources/images/Identification_Color.xml new file mode 100644 index 00000000..0f5cadcb --- /dev/null +++ b/legoresources/images/Identification_Color.xml @@ -0,0 +1,11 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_Color_Black.png b/legoresources/images/Identification_Color_Black.png new file mode 100644 index 0000000000000000000000000000000000000000..7306f195e572d51a5db39398d50dbaae0e05dc80 GIT binary patch literal 224 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*JX@i(^Q|tv6Q#xeh3Busx`| zp}Hs6{bNZLPrJ#XxaTz;sw}Qw5?$Ghvqc-Vc3A#-aJT*BwdLXo$!XQn`^uhJ?x_@E z@Cgmxt*+$$@UOOC%0mfm9VK?Xw*R%2rzopr0IUv9WB>pF literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Color_Black_Selected.png b/legoresources/images/Identification_Color_Black_Selected.png new file mode 100644 index 0000000000000000000000000000000000000000..6ed955bd0ba095663584aaf6c275f62e2ff4d007 GIT binary patch literal 190 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP?5K%i(^Q|t)xHy|JyU`GH@%h zGX8Un$i26rP*&NMt@*$)-`9aZ{?#?Id^IqR@}s!Af}<=5K;Vf@&DKIH9!6J7+$i@WHjz)y=f&~$k%3W z|8LUMkO^^X92uF`pEME4muNn)`u!H8AIJAAK1-U_`Z4=f>&N?oGRI7`Tike;tv}cs lV!)rr_ISeT&kRgF3{1x=uk2!)8v=9-gQu&X%Q~loCIGXJRZ#!{ literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Color_Blue_Selected.png b/legoresources/images/Identification_Color_Blue_Selected.png new file mode 100644 index 0000000000000000000000000000000000000000..fcfc76a190b72a8cd01a388d901b6e3d064be9ca GIT binary patch literal 189 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP?49Xi(^Q|t)xHy|JyU`GH|QT zV*b;-VOQ4SW2HShQ+B-xd*dRq@7ALlgR@5*lnuV{EVJlIOzh&5$een|O*#L{gTQ8Y gUb%T}%q$WN`&jsrPd9|m1)9p>>FVdQ&MBb@0Qm+y5&!@I literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Color_Brown.png b/legoresources/images/Identification_Color_Brown.png new file mode 100644 index 0000000000000000000000000000000000000000..691ebc77bf197cd1ef6ece6b6761e9db47d54291 GIT binary patch literal 242 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*J_7i(^Q|t)xHy|JyU`GAN(r zEem^;$q@8aWY+Z^-|tOlGvH1!;IP&#`hS0C+R6GNMi2cHJToeFPF$OLW2eEM>c5k8 zmN$J-Visw>zqiV9tAU&0kF%?vZ!!Gw_OxQU!P-MJ%GfUJX|y>=7#m*T=#lb?Z!yF^lbflguYboFyt=akR{04&Ep`|ShXT;&7LpyCZASFR32&5v`SbK dn#v`Rz%XM4|I#FbR3V_544$rjF6*2UngAAII$8h# literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Color_Green.png b/legoresources/images/Identification_Color_Green.png new file mode 100644 index 0000000000000000000000000000000000000000..3eb11fa81d28aee1163519a161c4ecf6464c932a GIT binary patch literal 243 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*H=Yi(^Q|t)xHy|JyU`GAN(r zeP{db0>hG5nkMTv-uUFeJcHFpqNTd;=KuYlvVPYWF?#5q;F(dWbK;sN#|*=ozkmC5 zmN$J-VisxM|F6n>tAU&05AL@-b7c~VsRKM8`bPI#0tDnm{r-UW|1K?MX literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Color_Green_Selected.png b/legoresources/images/Identification_Color_Green_Selected.png new file mode 100644 index 0000000000000000000000000000000000000000..ebcfe18de5cf2304b073e956aca1cb492cd529ec GIT binary patch literal 186 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP?5W*i(^Q|t)xHy|JyU`G6*yG z9$0a3FM9@zFsw(H14zJ(W0EKYh7sO)o*@o~mWv#bvW d1`-Mf7?v;L>rf4GWd|C`;OXk;vd$@?2>{wAI)wlL literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Color_NoColor.png b/legoresources/images/Identification_Color_NoColor.png new file mode 100644 index 0000000000000000000000000000000000000000..6a7d43c472d39eddce4858c12ce81b01ce12352c GIT binary patch literal 288 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|;dX7srr_TUV~0ia*V5RbE) zXUs|~IQR7-vwNevChN5*g;bfs1sAsJy1Zv74%idEm|>5zVd?|nD7JkLKR@uEYL*YM z`qOmj0gH*epUdY5JSMW|TrMXt{o)h8m_DQN-l2t`Bs9X_$xSOXO}zMfli9vCmfgwP hRX=yn-OgdaV6y9c=S%7I3ZTOoJYD@<);T3K0RRzfZAbtB literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Color_NoColor_Selected.png b/legoresources/images/Identification_Color_NoColor_Selected.png new file mode 100644 index 0000000000000000000000000000000000000000..5bd9b55f2e3f3530a0f261607c3b1ce0a8b10e32 GIT binary patch literal 220 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*J9*i(^Q|t)xHy|JyU`GH`cr zeBeKn^{cJ-wZus?$tOwm`w#qAkm`|?5Nh~g-z6bAgY&4E+c6deOZg6AOavo6NVZFez ztL3&;*X5TI`)h6o73a=!KH%UWDDTp&#n8#o+tm8OXCjwhZKQmDYvZ*KmOILerhk`f z)k@)s|G9KR7$5)U2d&dL6ug)2Ycr0S_cr<4LiLD`caMwxd)|Aapv>aU!s{jV_cRYM YyyN>(Dm?iK6VQGJPgg&ebxsLQ0HADD3;+NC literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Color_Red_Selected.png b/legoresources/images/Identification_Color_Red_Selected.png new file mode 100644 index 0000000000000000000000000000000000000000..e72b6379d843dd1cfb812e5cd47889455a0ff2c1 GIT binary patch literal 183 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP?3wLi(^Q|t)xHy|JyU`GCW>! za4{RdU^DZd<_%f*HWbP#b1&7qy&=v;R-#cBpbpJ8;I?a7Iu=j=|YO z6;~bvHoNo6na)UQ-kx*QX`ADVD#^r9;jP?N#}vb#GqOl9Oi|n%{xpnhBG5txPgg&e IbxsLQ07Fhl^8f$< literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Color_White_Selected.png b/legoresources/images/Identification_Color_White_Selected.png new file mode 100644 index 0000000000000000000000000000000000000000..ee2765e7c7e80dcde64ce8d9244d284df04709b5 GIT binary patch literal 182 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP?58zi(^Q|t)xHy|JyU`G6*yG z9$0a3FPw9>wfy{F}!4*$!Ofqdeh2H%$lvO ze*MWJtqA>X3mSI(6a9Kvg6H4GGY_Vl82zyC<@xtN-=wEKsAzGdqDhuPEpOhErpf|i giT0Se>;ef4doqh3XEYu00lI_1)78&qol`;+0Kaim8UO$Q literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Color_Yellow_Selected.png b/legoresources/images/Identification_Color_Yellow_Selected.png new file mode 100644 index 0000000000000000000000000000000000000000..348d868a05576efa559ccdf3ce34bb5bafeeb688 GIT binary patch literal 187 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP?3kHi(^Q|t)xHy|JyU`G6*yG z9$0a3Fms{+kr@O1TaS?83{1ON~uG>`xQ literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_CompareResult.png b/legoresources/images/Identification_CompareResult.png new file mode 100644 index 0000000000000000000000000000000000000000..2b7849cf4fad0aaffc039cbd5689171aa15fe023 GIT binary patch literal 172 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP?4pli(^Q|t)xHy|JyU`G6*yG z9$0a3F + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_ComparisonType2.xml b/legoresources/images/Identification_ComparisonType2.xml new file mode 100644 index 00000000..6f82f1c8 --- /dev/null +++ b/legoresources/images/Identification_ComparisonType2.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_ComparisonType2_Equal.png b/legoresources/images/Identification_ComparisonType2_Equal.png new file mode 100644 index 0000000000000000000000000000000000000000..2b7849cf4fad0aaffc039cbd5689171aa15fe023 GIT binary patch literal 172 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP?4pli(^Q|t)xHy|JyU`G6*yG z9$0a3Ft>We{fW zJ+R{77V{acGQQu+`dA%S$#=*zZ9I6;`M3Ro)rl&mI~jRH8G^(cX2^HQHnzzfSjM;d zpu<^}n`|a?Cgvsjlmsx;Dl#mQb7)o&d~u5PikB$&f;Kso6pf2)%(2o8Oa3gp!?LM4 z>4lrzg{OQDS@u)9jn7UJId&n0p?gW^5(%%cbJDtI?EMEB7}*#M%WajHygN_;bR~nQ LtDnm{r-UW|81q?x literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_ComparisonType_Equal.png b/legoresources/images/Identification_ComparisonType_Equal.png new file mode 100644 index 0000000000000000000000000000000000000000..2b7849cf4fad0aaffc039cbd5689171aa15fe023 GIT binary patch literal 172 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP?4pli(^Q|t)xHy|JyU`G6*yG z9$0a3FqE|F>t>H4tX* zWvJ!dw!L@`!x6SA5@$HL_;uJ0v&b`jWK)PM_;BGL_Z1Tf$q6Z(dd=btD;X4?9beeL zKsAEbZ4-mYIZlT+3`c(b&|!=UaM*G%W15CTE#skYFFrXmOP=(~bLizyxW`_|xiVex z&{8%Jy`$nXExc?}Vht%0k%AqkkG?+X%j?3#VkkQ}1}N?ojGaxqZU#c(a;D hn{OPVCw(? literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_ComparisonType_GreaterThan.png b/legoresources/images/Identification_ComparisonType_GreaterThan.png new file mode 100644 index 0000000000000000000000000000000000000000..0ca6fe640bbb196bff9a1b6be9fdbb57391ec26c GIT binary patch literal 279 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|*@k7srr_TSt>We{fW zJ+R{758iFti{~&LVVfdxrb9QBfwz^@j^z=r!=48Z7XB4qk!fJ0a8f9SO`jo%(cw(L zv%I6X#K%;D3=4IJjm!eCA8%&KaAds5wm5PT!&g?0+lx;#^QNh2?_@N!Yp9ezqPk>W zE5~#xg`Fbt1p;Og84(PV5>s3i^u*Vzo0|&AiabdZ63dcu3oDY=?Ps5Vkb#knf%|Ld Ug5O{6gM7;1>FVdQ&MBb@02?t^d;kCd literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_ComparisonType_LessEqual.png b/legoresources/images/Identification_ComparisonType_LessEqual.png new file mode 100644 index 0000000000000000000000000000000000000000..876858d5a1a8d29d3ab5df2f1426b6d45e32d691 GIT binary patch literal 285 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|+$+7srr_TSt>We{fW zJ@CNf#=UbF89LMxCMPQ%H&B?$aD>r8hhJ1r;dFvb+e20z5vgy29p(b51}0}dNR|n9 z@H2dDYHt4)uWLV%5e0FS}+c!iS* zMoN4sC)pP9s9hCWaIi;3+NVcVM7rlRki!*XJmbj|wi3>hW{KQfvqWe2EH>ph%ge@L az|gcJaLR@10v({M89ZJ6T-G@yGywqa`CM24 literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_ComparisonType_LessThan.png b/legoresources/images/Identification_ComparisonType_LessThan.png new file mode 100644 index 0000000000000000000000000000000000000000..179792f1b8cf74508641e1ba1beeb14d09b6c45e GIT binary patch literal 273 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|-Y37srr_TSt>We{fW zJ+R{76~i0%&Rt~aP*0egta#i&VJgEBMh6{!Q9Xsz2{LUDS#?CDz6o}i3#1yDocSPG zCfLEx@Uf}6{ad`k(W5^jj_^6fZez^2!Q9ovboK(PLby=228Y3->7oY~R5&O|Bt>We{fW zJ+R{77V{acGQQu+`dA%S$#=*zZ9I6;`M3Ro)rl&mI~jRH8G^(cX2^HQHnzzfSjM;d zpu<^}n`|a?Cgvsjlmsx;Dl#mQb7)o&d~u5PikB$&f;Kso6pf2)%(2o8Oa3gp!?LM4 z>4lrzg{OQDS@u)9jn7UJId&n0p?gW^5(%%cbJDtI?EMEB7}*#M%WajHygN_;bR~nQ LtDnm{r-UW|81q?x literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_ConnectToText.png b/legoresources/images/Identification_ConnectToText.png new file mode 100644 index 0000000000000000000000000000000000000000..7f86783c6ef8dbdbc11dd446f0b070cab4c5e907 GIT binary patch literal 526 zcmV+p0`dKcP)ug zK~#9!%vG^Y!cY`_C9DK=WYNvhCVW8q0Ui1W;J_@Oz~C;domkq*0l&bqn+Tgu>cVIg zKHzyybBh;ZT0ls=$;rF7dGFkN&uw2FYppqkRm_oWCt~0C&ks%vQXk8!tcM{6S0jbN zy$8mO|4a;$5X+m$(2>XeLsZO4KY zci`glwvvp?kOP%&ek#7OA3SumF)$i1uW2! zcoYPIrNwb<7mLN3-|cp}x1V!Wby`$DRw1jMpuLgA?OLs7IL9c8G6@*dr_mSfvv=Gn zyWONcCV61oY&Ok&J~v5{WPYB2wp=cm*jWv)?Bi29XQZ1(!e8Ht!p|;E$7=dz_O;Ko zIox8;U>{-*Wk#pfYOQotoy^eP>T+^+`8CNPdxE-Zf1pWsCjJ-yyl(*p0EN%N+jwC& QR{#J207*qoM6N<$f+msc{Qv*} literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_ConstantValue.png b/legoresources/images/Identification_ConstantValue.png new file mode 100644 index 0000000000000000000000000000000000000000..be0420fcb914e230e79de69cb2edfdac06f909b0 GIT binary patch literal 375 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkD0|O(Ar;B4q#jT`2|Nq-F>oN#4 z_cCxRvVJS;V{$mf*ulHNNt{pa*8au`c5XF}j3y?G9=;4obtWs@9p*4>dBAXz&6#&@ zze!QZ0n#-upKc=`(Fqy1>A$z{c9HEKuKaN>{=3lhA}c@(d;)81LK^ z5NC7P`N_eZWkS*hhBGoL&KG(1b3Bz25IyD~{-@oo&qk=1cMnTa;S8w-sXa$_%;5Lx ze&`waXu|^qRSlMfCh7wF4=eEt|Mv4c*L-x3z?Fs^jkeB-b3gxB*w*|a^nk$}wq9mq z1<|%A%9}Qs=$w41(3$zbc)}H@6B3=dc00Vyw|uev@YL|}gw>91^A0jFvN1f?2+-{o SzS#^6GzL#sKbLh*2~7Zdn1nh2 literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Count.png b/legoresources/images/Identification_Count.png new file mode 100644 index 0000000000000000000000000000000000000000..fa081b45fcbbed866db512325313fa2789c82a3c GIT binary patch literal 297 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|-F|7srr_TSt>We{fW zJ#fKzM(YHoYU|_73S39*Dl+VqL*6h=xa2OTeEjIQfL}^i0vKm3G%%dR%O>@x;mBTw zrMwf4@IAP6x}kZxT1(ELS<@eLPGhKiL(I@)wC*2<6KVEEm*Bb10Hv<_&0& z;^L3r(y`ki&&o_epita{iz~}TrgpQ*71kyXC-H?zZ5~O|j!8RWy3Zfwi!fpglx&u1 nmh~{4QMhG+{4O?T76}H6JZDCW$KifJA24{j`njxgN@xNAea2ig literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Current.png b/legoresources/images/Identification_Current.png new file mode 100644 index 0000000000000000000000000000000000000000..a0d5d99e07c1c1f328ebe5ecafb14b69caa3a29e GIT binary patch literal 272 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|;jZ7srr_TSt>Wq7>e z;Nd$7)z-&D9kfJFt+lAgs8?6C^>LBV;#d+hp~b1Q&`?+~%Ym(tr=I_*G_!8-qG<;e zHb`~67kr(i#&mE&iwKWGbGqZr%qhDho^7f=z;T<|REA|r!?axihZ80^E_hNb?%8M4 z+{h-`ti*Myly%n(!4}7py)z2ZloTZr68I}M{P)ZllTeh^OEP9OXUvgpG%%xdwuWMyZ7FEoFqvK|Iv!34+r&zk1l|u-_3k}g<_~b zzKDCiD)PLB|MsSSOd5S3`FTZ9zv0?q;?>V?Z;?H3W2Dp^p#AWG( zmW5R1Z~$`9@AC&&mUvLR(? zxVHj&f$ouM>8)CX0-y7W+M49G4QSgE(;;gC7DFkaD(1g+G%`xUEHc@$+DqFcR>e9^ zSg}hJDYLk3IZl}8RTo4YufH%M48+_*dZpLBg@pOqm7Zg+ue?I6aH6?XA%|ZGvt>We{fW zJ@CNj#=UbNWjXrUSOXhcJ3i>J2Px=qh(`HtJm}yY&bTtbBvInOZKNZkiHS(o30nm| z>xv9}We(<>YArmfBFFRstYkA3?)-N67U`vYUgC+-0>|n$pCabg#R>*%rmn~}(BVj9 z;uUXkTOlNH-o>jbMRj|m!yL9=mw=lNvf|9jydom&JoMUsD)r2Ga?B#?0)K2XBNGop Y&}+l=?t>We{fW zWw^+8`?jUog;Pg4L(C;!++t8r_2(8>53ucNTo=j^^lwXt&4g_8OQ#;NhL}o7W%97| zzrF8}D?a&Ylt6-GvEsHru?})O;2-8;1_#j zEOPj$%Pz5$4a{4;%_l4rZ&-o+wf1!t53mx{QI5jiIt3uQhmvtp?Bw44$rjF6*2Ung9{BWOo1n literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Db.png b/legoresources/images/Identification_Db.png new file mode 100644 index 0000000000000000000000000000000000000000..884a4730aec6c89cff59a9018725ae336f61b4a2 GIT binary patch literal 285 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|+$+7srr_TSt>Wq7>e z;Ncqy)z-&D9kfI`eEH;V)lZ9Pj`S#Gy)cPSA+%5Bi(JR$MzM8n;ip}e`5$hGknCV> zwCK$cXO3n2^vh?(vF{c<;w_gVn%Sp!JGSj(ubL?6@&2F^Ki7BT0PpvLsRkFe9t*hs zpnHXZig!BGR}DcE38~Kt(=`MIuQe@M*5#-0j$zjmd%pGSm`)wMu^^-{-^9CL%0`Bl cjl+O}cW?NT1J!rxfUainboFyt=akR{0Q2Q!S^xk5 literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Dba.png b/legoresources/images/Identification_Dba.png new file mode 100644 index 0000000000000000000000000000000000000000..61294ce9ddc9dca525cc4aeb3ff0a39d1eb91d09 GIT binary patch literal 332 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|;0K7srr_TSt>We{fW zJ+R{77V{abvlr~0`&dgslM9|i&Ad@T zV7cJiqy?uP;^uQ+{UO(0<)~3Bw(2?01S7Xe>_1b)c6B?p?PK>cV0vjA!Nc16TXMzH z?+#23Th#)-It6^>o3eo6Rt`@o@4gN$=S?MQ0sTS()0sb7EBu$8lrO;MoGh2JSV%BY zx5K4b>8s9_L*I8Otrr%Fa}fXI&TU>1;P5nNL1LxYs^hF0b>gvxk27AHWqmL(kWe_l YknqV}`gFgZ8qkvrp00i_>zopr07ay8IRF3v literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_DegreesAngle.xml b/legoresources/images/Identification_DegreesAngle.xml new file mode 100644 index 00000000..73bec088 --- /dev/null +++ b/legoresources/images/Identification_DegreesAngle.xml @@ -0,0 +1,22 @@ + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_DegreesAngle_0.png b/legoresources/images/Identification_DegreesAngle_0.png new file mode 100644 index 0000000000000000000000000000000000000000..3a06c899813f0d3235a5fa57ef7a9dc5a5eca2f7 GIT binary patch literal 3086 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 literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_DegreesAngle_Minus135.png b/legoresources/images/Identification_DegreesAngle_Minus135.png new file mode 100644 index 0000000000000000000000000000000000000000..753c18f31168b6a70f97dd09d6d6fc8b7a4a5a00 GIT binary patch literal 452 zcmV;#0XzPQP)` z&Eq+}I&KM$UEq_omtF`~HYc!zH?hN9zpf!-j$@vPMuIDGwqf5`8s_x%X4Fr)+mWDImOX`GNaj;c*&?@JG4u`RnmIpK!!US&DsC%fA84&PmA1Kc u*``1B*JNFYc39~;qrYVY-ksuCfB^u66^LB_4q~+c0000*%PrI0I^C>6vdaO7xLV3$A#GVXpqIT_G|Sq(==s|h^N#K zP18JM*ds0Sh32}hGdF<&Z85yd`C%ABc_*Z&EX#7#7$%kizyd=bb||B+>kWp2t8hH+ z06)mJxp>x~U&tMD13*s@BuPY45%3$8xa5wN@~K=0U5|5GGW3)FJl^>)m=EeKpcc?^ z$w2{5dT*(Upm~sDFV?!HQ1QN#8rxXYzsi@vyYw13KCr{eJ8^aJxw7E05Y(*0XOcjqv_87=25f@DVMfw&|Db zoUe4nW;CYU?U*nj>g`K>ak%`Jp>KftIX||F!&RIF(`<96*{0DxO(~;?A7`tK{+^#E f^Qe#Mj{pMzR)UT5y{sTF00000NkvXXu0mjf2`#{S literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_DegreesAngle_Minus225.png b/legoresources/images/Identification_DegreesAngle_Minus225.png new file mode 100644 index 0000000000000000000000000000000000000000..0542a7b69205ad84aac5ff5df625a39e1a53d043 GIT binary patch literal 453 zcmV;$0XqJPP)`r3cMm9H6bMsaw&;%1*QZ7TOz!xz%GFf@SoGHv^U<}!<;?RXm!i(yO}@35H8CS z{DS!m6*6qPuu)(JEE81R-Em5Zg|Z&qwk-C(YMqI zd*cqZ&FG7qpN(~0zf+bxjAqw#J2-~Wz-<__=L|bpk|ZBZ(>!b*n;!cyTSD8X$u;O5 vwg<5C4*E-L00000NkvXXu0mjfzU#)P literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_DegreesAngle_Minus270.png b/legoresources/images/Identification_DegreesAngle_Minus270.png new file mode 100644 index 0000000000000000000000000000000000000000..51845f648c064b914d688567ab997ecc06086aeb GIT binary patch literal 454 zcmV;%0XhDOP)lfVog#0vZE4 zZYdPtq<2DD7|o3og}AG?LdEyB)Ht>^^`$S3qikGYyI}3kH*r!e*xy6c0Q27+DmqT6Va+OxU&vYPVE*MQc=ViT#EY*&kY|`ahusz z&R~d5op7=ascpKo$oWjpmJ_pnO}F#H5Nf#%6?-Dmzi12SVX56>M--_8B5e?__c~(V wpkFXbzgQjgzMm!$A!Sw?O*ez@wI2Zn0F2d+*;{`oH~;_u07*qoM6N<$f=n^M?f?J) literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_DegreesAngle_Minus315.png b/legoresources/images/Identification_DegreesAngle_Minus315.png new file mode 100644 index 0000000000000000000000000000000000000000..97f929d4068a241627a68928d8d7b47d28e0d2e0 GIT binary patch literal 461 zcmV;;0W$uHP)Z%`0zaMv+w&a`0dXW8`4+lN>I@( z^g#gh2GAD_WpG~g#d#u);?QsjstuKDJ0t4{jNPXuX}xTQXCw<>C^)1w-J+Dh8|;Ha zSsF|mR_=HY^gl-mrgq-}o|Vl67XJx+uz_0=JM93U*j1gt71@a3F8W)Ecs63McLJyE z{1xZM8dTsgqLxlzxQps0WbDdROUiMN&z1~Xv+33>452$VR$xsdcCH1eZ<}tRK}BSM zaBJD?{jGRy&|7SpXsck`r-><4nWeg>o57FTw*UhG>CczFet14)OFEshpJE#)0smSum+Q7M) zQ(O2J_=I%`Ojcwhf0N-rKMbUh8f=O@0N$mI1IPaaPHf=WSSt>I3vyL8cr-Rjy!>8* zwk7Fa4Hm?{$IBmhG)PaDg$Cp3YiaMhJjcC}X=%w#x5+VtBo>w%LThdTn%SmX&UjHW m5O!?-e$b!(Yx;(~1Q-BjSBy2M5KKz|0000+rq5%LuJ zP!z=rmJ(P2OFFCTI=YD%q!pGA_q^|W6W$I`gfvaHk0Y{E0YZVLH6FT>W!V~w;3y;? zOOQ9NZftK5s!o#R*U|X`-hed-S|R}`MU*Nc{6-{l(qkyRl48>|Kf^FQlQ+0*JC#c& z{iMr}JSSp8*L4EWfTDe#=fZqD2eM(?KN~w0CY;iw<%;Sm9gY*?;44oF+o%xnk}G1a z992`y48c3~wuk z^qH$05AcUCyPPs67SH4KMeG3h(>RB#A6!$?`-wN{;8G&ZBqugQ84 l>6y>h4f?w`$RlJgzyS8&#+ru_D^>si002ovPDHLkV1oWsxxfGb literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_DegreesAngle_Minus90.png b/legoresources/images/Identification_DegreesAngle_Minus90.png new file mode 100644 index 0000000000000000000000000000000000000000..b227b9c44c62d43322961745153d343b88144fa9 GIT binary patch literal 434 zcmV;j0ZsmiP)kDA4))3s zJ8&!T$$_hs!kLR~1#1Z&Icf#F9Y_c4A1914=83SHnamsUy^rM2O9;EJ3*KQf-yeCN zFR&Ew6#hZas;UbA1qQUlvenOl=!E5p)Nm`2$N+|%0u^jpcwPjhh#1eBBjvqU~ z_j+%nep}El_$Pb`z=0rel8B@t;5RaH-iVF#DP0F$kB_uu=#E}4Bfo&TP(KQq0@^-P zD8NbY6=l(D-b+!az3y44I`6c`snm2ReQg|NZGmOM_7i*Jrtp!m;ddgqy=xHM&pDPe zU#a6OS~?OM1$_CZTI_3(lPcm^OPO&8zEl-=a&**u#xcVLla&*qEfwPmW}WG+YpeGM zT6)dHs5PgX>U|nMg>Ni!`Xxg**jIbUrZ}_`Y1MrB<;@u!o1yR1Bnsk;Q95qWztW=M cP4*|i0HUsrk9v!1KL7v#07*qoM6N<$f@{scwEzGB literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_DegreesAngle_Plus135.png b/legoresources/images/Identification_DegreesAngle_Plus135.png new file mode 100644 index 0000000000000000000000000000000000000000..aaaf21d3dba86a77d54da93ddaad55e2fe841509 GIT binary patch literal 475 zcmV<10VMv3P)ee6Sk0RX2#pe*7? RNhtsT002ovPDHLkV1nOj#})tp literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_DegreesAngle_Plus180.png b/legoresources/images/Identification_DegreesAngle_Plus180.png new file mode 100644 index 0000000000000000000000000000000000000000..d901f8ad79a032c5e11969661f146f7d94ab06aa GIT binary patch literal 459 zcmV;+0W|)JP)W!axv)gF^vV0#-oY)Hl;XsDM}jc|@Kl0V*(7U^+zFYGbv zv5A+c?95J>ox6{J|GR8PP18jG5u-lfBuU)jJ+ek_s;WBl0>6KJ8ay)2Db-fbOKs^E z@Z2xnv_MllNXeR&%}8)dBMWr0LmF8eD^ODSf_z2h5BGOgx`8AB{qbDXrz{{=tze~Z z$R_}cAN(dr;cW74IfL0#YQF?D3p`B2N+tZ34pe&VV0q{*0lRxR z#iI{)2QVZ`k8=XEzZ7;L*aqF>zlbAP_-Y1nOqb%lGk!p%9_JgFE_){Y4joLf_ZHR~ zm}1idYQ(-s?mvUsXS&OCo);lXYvq+bsAIEh2r+D;456d9fX1!UjfM~4mRn5myI^Hh zt6CbkIQX%)3h)xZi5T>Y4p-DcfBjF>Z{tgV0RS*2nl&Or3&{Wg002ovPDHLkV1h>J BzS{r* literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_DegreesAngle_Plus225.png b/legoresources/images/Identification_DegreesAngle_Plus225.png new file mode 100644 index 0000000000000000000000000000000000000000..4a4850682d4e7b82d78067dbc4f215b39ddac92d GIT binary patch literal 478 zcmV<40U`d0P)$>j!N8FqGEomR~S=ipO68H1RB^A*CFChXv&xJ6P&_O8{Wmx*lII z!MX6%2fn3xxR^+=D?pc63C<6g{Kc>x!Pe^@Un34+=Bw$*F>Q)>&iD>76`Uh5UiO6f z?c10F@d`@~jFGX+@AE+93(bzepfCg%Jqodu51+fB=@u%==qlXR9rGsa`hKBu+kr>$-4 z4)8)R-Z-F3JSdVEj%-B%J1(-pO%Cu_E>0~_itrWw1}`4&7rj&iP5}CFF4pH9Kw_1G zBYlTI0$BZ_H$f^Rla}QKW=-k(HK1$HWX2q+gx^v^rN#zU_*Mx3y*L-i^BP}!mS;K%mPyOG z_kE002ovPDHLkV1l<*%jp0B literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_DegreesAngle_Plus315.png b/legoresources/images/Identification_DegreesAngle_Plus315.png new file mode 100644 index 0000000000000000000000000000000000000000..ec19ed0ff0a561af6805bec3c9deb48ab4ffe8ad GIT binary patch literal 496 zcmV$ls*zC2y{t0xPfy5e1lLXsd5B-19Jmz0G*xA+`v-$Xd4uF zWF{J-(J)I0Rz_L@yR&Z}^Le}Iy3Y9zyZDQ9k|aHg21X4dud3>(`7UgXcl$RV9%~vQ z&b>T8X|5Xp&*Y>l82LB=bOoQtx(TKVz4Znm mmCA@os4$#&HJxi;0t^6nLoTj`q9_s=YS0`sCCd}&04n>wSKRrKvlyTfhTBf#8i3bcFaTq;B>m8H z?LiI~JYAvSpm)#?bUmamFF}R1C&jbb#$v{OZAArEjE)>=NJ|VcVOhYKsE5xr2b>Gt zRVOsU4;uXH9aIbMsmS!gTEV#;QOGN<>x^#aA!l_2ymSVi*(hJw7a& zwl0x8^_}AY=@b{rl`1$#-c|fp3$MELK)Nh z*9Q=5=BN>GZ&mcWvk6^+5HVRcAluC2_$B5()2TDoi>}!k)(s=yKutDVM942cW73+o zH0m*n5s30iF{g?z%2j3lh|dtA_a+GTNkH^3{&{`uM}PqU>Q2ao7KGhq00000NkvXX Hu0mjf>;1@X literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_DegreesAngle_Plus90.png b/legoresources/images/Identification_DegreesAngle_Plus90.png new file mode 100644 index 0000000000000000000000000000000000000000..1ebd08a9733debbebc1320bcd4f4d96e59ece02d GIT binary patch literal 455 zcmV;&0XY7NP)!w#f z0Z;Veumw8DgOq%*vIPllDdZKE9FayYjvAn(@C&&?CNI1b|ZP8_4|{?3AY=@FVxb z$4rBL1Nua!IKN=_m!j+muI(G$;`+jl0^;Z>=CCq4D;B<*EBL1E=AFFpJ!8g<8ki2d z6@CYYm@BRgOp*3bn<~a1n0=GD&C)@DoNJmz8KM0tfc xtA-opt0JY@RfArgAot%0h#umf*Cl=g7yv7in&ty|D@6bR002ovPDHLkV1oC(zFYtR literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_DistanceCM.png b/legoresources/images/Identification_DistanceCM.png new file mode 100644 index 0000000000000000000000000000000000000000..7176baea93c66bb14fff0c6748c272c6ae180de9 GIT binary patch literal 403 zcmV;E0c`$>P)P7I?JU(!D|?TijRz1!dm(mOm@DK6>l+wh zh)LWPA{h9XCG&Q6X0j7yjPZ(iN?t)vIm^-Q^nI8Ch)?I^&NZ+~YXyQ%VTc%LumLNn z!C^5S4jWmu0%FZUci2>iZGj6|g2xN!wrrQSJ=V;HGmAtksDhF3)BC`x#}o)zPWg+f$ys7TteEO-(@TY zr3Usn{yk}&0%OAjCIrKrq{tVt*7_&37Kh~Zydt$Wffr!Llc+MPGD+>nRv_3MrU9-w x*^;lp+Ru}B^JtKa=R(?^!miu@jr3E10RUs0&2#9Hwl)9&002ovPDHLkV1hkHsC57U literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_DistanceInches.png b/legoresources/images/Identification_DistanceInches.png new file mode 100644 index 0000000000000000000000000000000000000000..4384ec6795c361c33a7a9f683d6179637365977a GIT binary patch literal 404 zcmV;F0c-w=P)ZY5z>Ex`Bpo_bL=q~7{gMEcQLi`RA z2r*5~P{D&Amp0#BF4rCxLa-u?|0Hp%*%`y7=gVo67YJ<~ZU83Gr{;cOJVzjufsyXD zgb^T(N*tORTg5N9Be;S!NaSHlK)2YcgXQx=*P!xAR>h_b!4C9QbqKD(cd2C-4f{56 zq9yRs1RfunuAa(v9kiC%je4wTHrgQ}*OB>7z0cDS{O<>c}i(s(6CzzFUJdXA!K?}xkX@|IaUe>kWB%XsQEil47<5t4d=C%UKW^ggM yJF2C! za50;3{)WAC7aLBnVm>n0p@zTXa>ES?t-Zeu}+$eBiYLCM$mX7<(8@ZRVl{4}BuqRDOpF literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Fahrenheit.png b/legoresources/images/Identification_Fahrenheit.png new file mode 100644 index 0000000000000000000000000000000000000000..b7de25f4ff4fdd63ba94e203819e9d565f1b3496 GIT binary patch literal 274 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|t>We{fW zJ+R`S^Nj?toF;S0)-j-= z%mZ>vFMP25!K0+6F{R;$&IJVnwvCN9W=J^}@}~$~m}+o1reVkAq~^wTF}x-sDK{in z1gJ+DG&pD&?3sAFi7VkkiBOMCM#|F1g#wX@HcrMIk25N5vJBW5I1CsPc3VvQa`isQ O*9@MnelF{r5}E*Z(p>NW literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_FileName.png b/legoresources/images/Identification_FileName.png new file mode 100644 index 0000000000000000000000000000000000000000..09b9236baf0d06798bb3d003e4d7195870a3d7a9 GIT binary patch literal 399 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkD0|TRsr;B4q#jT`2|Nq-F>oN#4 z_cCxBsUNUE!Qe4hJ?Q-*Ug_(q0;vW991R=`*xX{I8m3t@to-XB!(ZCL9PpPti@nuO zAig2W;j6(k_D9SPhlMpve=v&~)+x;Ee^VqDgL6JobA++~6*JO-tmu938JZct#cqybyYFBfsU7^vYNc zRfgCq2B~WsJnR^bvK?VN%DUu33Ckn)1$SCi`g{FvBrKS2@4(Bxk^jMko>SlX7x`EE rY@hR;QS-iWK#+qW-%cxjg#!%p)#5%??E9M!3`_=3S3j3^P6 zK~#9!V*LOAKLafQ6Df)V{Db~e-C&@h4x~7Ok(i(W8oB^T#Y4Flf!JZg#&sVkaxs#j z7okG>KzslwEdjAf&=H@-((c~ ze}YT)?QS9EG>lY%&rqP80gyTm#D+le3s5nTOAiQs`=MWO@B#zJ?>{i*icBQ9Q~^p0 zpt(HYJr~EvBT7;zYMF@jKFDQ2>H-tgn+r%W9ABJ#;$VA; z5)?>=G)m&X%Zz{4^S!5ReUa!}e9fRzu#0)PMm01>z0k6sqz Q1poj507*qoM6N<$f-e%gga7~l literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_FontSize.png b/legoresources/images/Identification_FontSize.png new file mode 100644 index 0000000000000000000000000000000000000000..177e435000d2cf5b4a90575b3d5f1330e6b2393f GIT binary patch literal 385 zcmV-{0e=38P){QVWf-n$;#(&%Zod8B)0~$a4l~EkQ5nut*ZlD|B2DkxEfbWv4DYa;#@L@ue z%W>_y*LTN3*!O)f#}dIzYaxEF)i+5p-<5C&4!26z?azuqx+Z6DP1On_ieMGT#gxRf zj<5?XK^5soVt`Jtp1kL51DC_D+}CnUwHQ%!8|j_dGncBdJ_| + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_FontSize_0.png b/legoresources/images/Identification_FontSize_0.png new file mode 100644 index 0000000000000000000000000000000000000000..4a84020313ce4b1a5125f4d65868f3abdb72bae0 GIT binary patch literal 256 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*Ja^i(^Q|t)xHy|JyU`G6*yG z9$0a3F&jU7b7V)T!~^*fHV;YWji1_jU%v}Hdep%=wqc5pz4T zUXf&QVQW)BbGY+Hg)8hLyCqUIPJ9S;_``RKZ|Ssya}RJNvm`3q78Q{Rm_H%iAi!AT yP|N~H1~!Moj)}GX0TIT1VqcuECp0iHGrVk9I`U=L83CZf7(8A5T-G@yGywqZe^zS% literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_FontSize_1.png b/legoresources/images/Identification_FontSize_1.png new file mode 100644 index 0000000000000000000000000000000000000000..ca4784204ec7a82b5d7979d460c1fa381fbc8b99 GIT binary patch literal 245 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*Iboi(^Q|t)xHy|JyU`G6*yG z9$0a3Fim0Fcbfiq)7Jai$3fym9PcN_E9yHKS1dT*{`W5v nYp0;|@t(z|9A|miI1Curn4;hGd}DhAbPa>2tDnm{r-UW|S$bEV literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_FontSize_2.png b/legoresources/images/Identification_FontSize_2.png new file mode 100644 index 0000000000000000000000000000000000000000..167ba2c6c4f3afa9738d1b479810cd02bac78434 GIT binary patch literal 318 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|;~m7srr_TSt>We{fW zJ#fKzMyrG?<3GoR4q2j8qBkZ!-sP9IQzGR)Dc$7tAm; zjhVxCq$$8TT={21QnO>*9p<*zSqf}Bf5{zXW8TZd#gwcvz3G6CLRgcV#!bDpOgFO` zD;^{qnZC4fT@^cTd=A4DrzwpGKhIlI!eb&LmMQU4Ov_wYYUA7`Y^*wO&pAzJh%)I8 zn3ZBoW1h71l3j12WV9VI^)7o7lli^0>? K&t;ucLK6TTpKr_n literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Height.png b/legoresources/images/Identification_Height.png new file mode 100644 index 0000000000000000000000000000000000000000..0e87b3ccc0b3aba68ab97e14292a1cf6b869f3b3 GIT binary patch literal 306 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|t>Wf0!T z#r&t4#bL%PHs*tD3ULmh&5e4w3_;%<-teaiv-GqalE?^Pm=M*k_GU-o<6X=t(mW<1 zj2^KJNp&VG`yFx^O#U#QbY$#Z!5hJo+R&AIKzwG;5jFD#iV3X_;YLB$p%>I-`=xBM z44yKivo$``3aDJr@BH3Xp^PDI27mM7H4SO;6OJ+H1abc0QPt{Mcr;mgQh;(m4)f8c vhCv$|c!U|GUODtsi3urLHBJd(6i8rrsp)+=W(Nb%^9&50u6{1-oD!M<62M~> literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Hz.png b/legoresources/images/Identification_Hz.png new file mode 100644 index 0000000000000000000000000000000000000000..23cb821f20958934061209e44503b80bc3a100e4 GIT binary patch literal 404 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H#=yY1d2`HKAcwQSBeIx*fm;}a85w5HkpK!x zmbgZg1m~xflqVLYGB~E>C#5QQ<|d}62BjvZR2H60wE-HS=;`7ZQgJIO;Q*V?nYFJ1 zSs0i&oNvi>{7?2^U=gTexx}{gzwi}40f!^XZZl>&tYYloXV}Qhy{SuBy1DB=WXBD@@_$N(M%g z8v<91e;JsWnVu+o#lUMPA#Himj-l<6)0YL-4Ranfa7i_WFbL!y5Ie_rp`guDSI)zi zp{w?Ylx7Bl$Ykzw+nqTTCWMG#4^O>}21vK>i7Xf*C_stje{c+!LCb7}wTZYG;%5=v6RuEMz>{ vz@2gPDZ{K=3{PG$ao8#Bt}>BrW@MPVH}PA|7S02}5M}Um^>bP0l+XkK(YS;S literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Index.png b/legoresources/images/Identification_Index.png new file mode 100644 index 0000000000000000000000000000000000000000..092b5ccf046904d0c895efcafc329f461ea6fcc2 GIT binary patch literal 384 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkD0|O(kr;B4q#jT`2|Nq-F>oN#4 z_cCxRvaEImOFhxP&J!6u%hVQ=aMz$uN>UNb9aj$ZQr%sLQ z%oI;2EI9UkfeNQdiur_n>_^fa+nA2FYLtG|QV{KOm6`J6aD&(yHSL~8slyE+R#R5< z98r)DVK^%JQPL~tiKKJ0Bd1hj`pQXn8uYx~^_bXF9rp`N`MxnVxTaO$=Fw*hR(@t+ b;$gU^5Wk%<`BgM9^cXx{{an^LB{Ts5R{n)7 literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Invert.xml b/legoresources/images/Identification_Invert.xml new file mode 100644 index 00000000..98b6114a --- /dev/null +++ b/legoresources/images/Identification_Invert.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_InvertColor.xml b/legoresources/images/Identification_InvertColor.xml new file mode 100644 index 00000000..ad7ed43e --- /dev/null +++ b/legoresources/images/Identification_InvertColor.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_InvertColorCircle_False.png b/legoresources/images/Identification_InvertColorCircle_False.png new file mode 100644 index 0000000000000000000000000000000000000000..cda701777c54582dabc602949c4eea1a4a697cfb GIT binary patch literal 451 zcmV;!0X+VRP)Uq zK~#9!)Kviu!Y~j7G66UsH~<9<1sfOu9DsvLzyV+YhJ&JjNdO0RFz%CUQc62E5=dzB zX+!^S_xInYTUAx(8>`p((n{1#I#m)e%85hL}b z5T+^yir|r0=#DYU%{B=*Jb^JFbAFTUKoU2{T{kKo0G8OUFah7drnC*yE$L%PnPBk( zOm}3q_JTC-_tbNXv-X(RGM4o30Z^Bn6wJ`KaUW;Y(8Q$T-4?cJ1dP;D9?J%uRyxxC z=H>NbEZ7b2)`+r{Z-J@ZB~}z~1gv4_HpP>G0oy7DDuo-w2qck;OY^U!msw2ZNu&t6 z3dvAgJOl{aG3>_2a;5F~kuiOOt7`{6m{qaK#?)=0bj^f2!G`h@U0}_zsoIQ9e$>ik t5S#iM=Y0PsPOy&#{fiWT^Pl$+U;vg0n8>aGLuCK}002ovPDHLkV1l|VyA}Wd literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_InvertColorCircle_True.png b/legoresources/images/Identification_InvertColorCircle_True.png new file mode 100644 index 0000000000000000000000000000000000000000..4228924b5e1622e4065f84486b2960ec94cb7a0c GIT binary patch literal 391 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkD0|TRor;B4q#jT`2|Nq-F>oN#4 z_cCzz2tJTkVOV0uu+esAnkm>o6A4r!l_`dgN_pxzHk(DSon~A jVlch+&&6++>E-;hXv>r3J%(b@TUOmzarJPk zZLE}p&6mZOUQPJ;J^Dujr|Tac^Sv%Di*$JUcn)u8(k>0!vi`;29_jtLrkfptGMWE6 zTt2SV?w;OsV`>-I%?})Jm#?nL<1yV6Bs!<7D}i$skM~8Dh~|GSTVE*6X|8K6zPPlj z{6e$X(J($o{!lmHO&eRX7rsAOaZSfxR!5*!Fn9LClGg%HD|0mcqmOKLw7=Q4|L60) bED{V0)AG3Zv@h%i`jWxZ)z4*}Q$iB}wn~Bw literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_InvertColorLine_True.png b/legoresources/images/Identification_InvertColorLine_True.png new file mode 100644 index 0000000000000000000000000000000000000000..de5945b63723e9fa552c2a9bcaf9e2bad3be8805 GIT binary patch literal 307 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|*QT7srr_TSt>We{fW zW#H}+d?2sFu*8gEqwUNzSr*C7iH~>jztCHDB!F$jJ>DBlhvso9CiqV^c=qgBT0lt1 zlDsF4Jh{2KX&#=Qi{>3PaCTggTe~DWM4favo`% literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_InvertColorPoint_False.png b/legoresources/images/Identification_InvertColorPoint_False.png new file mode 100644 index 0000000000000000000000000000000000000000..a16eede7d33cdd6373dff5c16c3fdd35c429f4e2 GIT binary patch literal 284 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|-?H7srr_TSt>We{fW zW#H}+d?2sFu*8gEqwUNzSr*C7iH~>jYp^-2Q%CM4cg(Tk#N5-N| z=9O(tu`CxaH@t~f)8RV7%AO%qxnaZ7%2f+$ip)6NMI$L^|3(ye^p00i_>zopr0AImM1ONa4 literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_InvertColorRect_False.png b/legoresources/images/Identification_InvertColorRect_False.png new file mode 100644 index 0000000000000000000000000000000000000000..73c744d1a02f732330f82d0b7c05264e6e8516de GIT binary patch literal 294 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|;>j7srr_TSt>We{fW zW#H}+d?2sFu*8gEqwUNzSr*C7iH~>jYp^-2Q%CM4cg(Tk#N5-N| z=9O(tu`CxaH@t~f)8RV7%AO%qxnaZ64x23ozx@|2?6C-DHSF>%WI223|AmVTJ$z literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_InvertColorRect_True.png b/legoresources/images/Identification_InvertColorRect_True.png new file mode 100644 index 0000000000000000000000000000000000000000..4067bdb213832e8eb2f1a260697fa24a4ac21932 GIT binary patch literal 248 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*JO=i(^Q|t)xHy|JyU`G6*yG zGH~|@K9E;oSYpPo(ROBN1uqBvvrDvZ;bEj|CVdb92eW4EKKNLjI*mCsDW`DuP p9+2_FafM{U0gETEY#JDt86x*9>1Rxxbsy*;22WQ%mvv4FO#r#yQt|)* literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_InvertColorText_False.png b/legoresources/images/Identification_InvertColorText_False.png new file mode 100644 index 0000000000000000000000000000000000000000..c37958ca88ac3d1000adb508efd5d0ccf73b8d3b GIT binary patch literal 477 zcmV<30V4j1P)BmbcTLI*tfBHRGt!jlg{q5zP1@^A;_kphf_@vE zj1Q1c0 zifG4D`vTn5ZRkQwf6sxr-XDM~S_9JQZwaC2M`N8%r1k@N0-k|OSDw$uV+rP}fXbFz zS_8F-E6K--jcU}cfTCWveTb>}Ue%BbDbyBCNj_GP=tu{A{lY++wI%r|W=~+_ne=U& zd>8{urzfjL&`>=_x%;#!to75lt!+9wUZmW0<-JX8XdpG+3`)m5^@hQLn&3%Y; T{D_!ax+pKMWHrF4R>7CpxQ96CzP3`J;=l0)|O3x*(3E#Krh;Qdc6d5Cm5- zE(orcl`^R*i-Tpwy9T+BXu9?csvG4l2`}OC=`lV_j#E#rTfzF zM_MhYezaeyrkQk>b%0DH5MM-XUZED1Y89bS5PSQ(km?fZr21;*d0>kTC52RP;2?I0 zN~Ox?B9TB8MeXjUYC2Ps%oonjE{3u?L)YkuZL);ep6bKo87)jJVKj_=e(Kb?Sk;p$ qv|nRi2d*31VSJb3-~98w1Q-C%1)~1BslvDb0000zopr0IUv9WB>pF literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_InvertColor_1.png b/legoresources/images/Identification_InvertColor_1.png new file mode 100644 index 0000000000000000000000000000000000000000..0f0313527beb6da1b92d074f5866a34c11f591dc GIT binary patch literal 216 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*JLv;R-#cBpbpJ8;I?a7Iu=j=|YO z6;~bvHoNo6na)UQ-kx*QX`ADVD#^r9;jP?N#}vb#GqOl9Oi|n%{xpnhBG5txPgg&e IbxsLQ07Fhl^8f$< literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Invert_0.png b/legoresources/images/Identification_Invert_0.png new file mode 100644 index 0000000000000000000000000000000000000000..823cc38e907c66a2420f9f929eba47a20cf4872a GIT binary patch literal 468 zcmV;_0W1EAP)pFv>K(5j>U0p>npgD$;QlNiU4CoF+ z0$?_&754Gzys-XwYa&ouV*s_6^qBf(I72~dv&pVtwQJ-OpNoK6>g674-6eL@upICq z)o1WzA1k#I_q=645~PcP=lbRW+<0J#4IL!A;Mtoypd}`#ctEX=67vbS>FCYnql(o_ z2=F3Gy@Mlrz4K$MJ&ZbnwW!I)ZeHSl0Z>iF{y_sOx6Z|`w4AsN%x{quUZQs+Ynxyz zSiv`Wd8i!}>xa#<{rWs8wX()wy^FO%4y9Jx{0R?QvNa2WMip}rZTXcSEAli7_X=oP z06{CvZKJO6;8rObiX$uCjoK}uK2twTj{925_J0NbH~)Dj0R{j9pOfz;3vk&00000< KMNUMnLSTZwcFL9j literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Invert_1.png b/legoresources/images/Identification_Invert_1.png new file mode 100644 index 0000000000000000000000000000000000000000..8712410ce0c29a3d35c71a844b2df215a3127294 GIT binary patch literal 476 zcmV<20VDp2P)|mveN3zJ!WTj=gvXj_p3|T)#^gFwm;go-D98^Ns=7S#u#8RhLVmT`Cowpt;PUm zfDXa(v(^}Z8HNY}%+%rgyGKKxtg&JQui^2;9%jaVn8m69>yFI?>)6A#z_5X*8tXZ^ z?KQ>#iZHnKFHQv}>rk10fnPh{zgYWJaga1!d!t(NG-FV)aLEO!EfGgH@BPSb9dBkoRr~+y^)tO7CT9u5-M#;JfK{wJWbZ+hC}T5R#ZT( zR+ha0=CV$E!dkibbpt@|u-A-1Gk{hnKbunXOdc28efFT9VmS-^umAJD1sDM7f|&W? S!|0j-0000&u+ literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Joule.png b/legoresources/images/Identification_Joule.png new file mode 100644 index 0000000000000000000000000000000000000000..01f15b510b7f1877af71a0a7bfe0b4ce31c08ceb GIT binary patch literal 212 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*I|%i(^Q|t)xHy|JyU`GCW>! za53BD^bLFGKDJg+?NA9R{BYr)Urp7Fj*YSz9RdQzOf%nimKq8(_a0bru=zwn!lYtH zucB%Vuj3Af9oY6d3t4d=nR{T#_NpywBur6KENOr>mdKI;Vst E07JV*WB>pF literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_LEDColor.xml b/legoresources/images/Identification_LEDColor.xml new file mode 100644 index 00000000..0b2433b2 --- /dev/null +++ b/legoresources/images/Identification_LEDColor.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_LEDColor_Green.png b/legoresources/images/Identification_LEDColor_Green.png new file mode 100644 index 0000000000000000000000000000000000000000..e62f7db03751b33ea975fcf9a27c5ac009bffd9f GIT binary patch literal 974 zcmV;<12O!GP)g`aK(2&-UWv(JIj9tR;K@8hk$(h^DiUAufI%S z4*~?Bom_Gg27(}3BZEjbC=%DnopLb5A##f>EU_|3IEf9xzxk%RAs#M}k$N?yp6*vQ z_}}xkeN}HBz54S@>iuJ<8PS>7Pa8DdL6enzLew)WxU`MVuTAxtL>{Sc5y&`Ey>sr9h9?T^T6mNL0?%sd5cq5(Uhd( zWg#PQydYwOX6PPf4i0sH!n1UxDa@%ZW@*UC?icH_I3$nn@dv9Sa)jHb5E71JaZoZc ziwUWzdv9ye|v$dO}OVdswrM#-Pp1W7YD0u1U1k!u-UhYJY z8T$g*8#ou?2X$!8jf_)t**gAWFab%?y!U}rS_Bp#Fp$PjhF6sSX}(P`T4j4!F|btt z#RXPN;uYcH^v}sO!2X=7TAHOmr|gcuJnPyDB(T)G);ob$z-L@f|9R2ju&&Jk;jqqWQ$_kQMk?LG6j0Lvi8^Oo8liU0rr07*qoM6N<$g6WvI00000 literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_LEDColor_Orange.png b/legoresources/images/Identification_LEDColor_Orange.png new file mode 100644 index 0000000000000000000000000000000000000000..b41052a13fc738509ca7a79565e798a8b0bbbf24 GIT binary patch literal 932 zcmV;V16%xwP)C&ZK%Ac!+8CJF85sZqhyg{}w|iUu|NHif;qRlo2A1Eq zS{VMk_{YE^#=rm&KwtyDe}4NPqVPZ1%wLD~8^DJBIbYB4=iP6H|6l(wFblIWF#KhJ z*z)ho1_mZppn6^q2Z)&&9smRo16J^Hn@l~({O_ON{D;tQ|3i#;ew5+=ufGh8Oh7By zS%BsOE&p?WJHua~g^cV>3@k#dKtZ4b|9?Hl@c-w3utopAF@arhfsx}W12d4t$PBRu zAOL0LZo@DP1JNTR8*t{y5E(0D8F1qP+-HJR>GMO(^GSl-TVO$mJmKBxP+24EFXOG4 zW>oX-xK>O_EZ3Su9>!xreAhyaU(~QVhxMldocU6F|Nor97ZGm>J_Jeqi^B&A&R%xX z&a>V@8L?!rffYqP@|}cKy9q!$8SEek13|RgV*F%()4K^54_*u*B@qFP;wi}0wb$>0fdsc zqn#h(GIc@w8}cS+FkaM!#yA0ISBc*p1g$fEku!oZ#>sZkTC5pY-66zZN40i>3Q$Mz zMH?wsJ(mFm(dU9*qI+Y+WkrI`P>FRykGT3IW=_-#_$>`@nJaOaZOfU0?e%cj;y#zY zz5>)%Ex8E;G1O)vby*Go7vdTmpgl@^08UmRA%WPYP^1Vm5^`ce=f7;8MCdX1G zP5Tci2`)NseSC{0&j(F-Y>F2Fl~Ng5U-z36cOG}G)W($nNtx*cw3Ag~UEM*Pf&{45 zD`_e{K7C#YZ88ZA2Laj&5E~$z!1_#~*ZQ}hx*vUrt3U}&uhyew>-Z zO8^8ASkKqjFaE=MK-O(3%L6PR{>!>_1~$fj49txG8Gip~1WSS?KFzrVG59}J7bC+3 zfB<5^1{i@h+N(Z0egN(ym=WKPZ3dbPG2t)JY_Q;$otwcH{s$`m^$#le?a*z8UkqR` zGW=#>0t01!YVA+R2h%M{KoIl#n-Bnb5qmE=3=IE(u7_ztDBgP<$oUTrIwq(zC|*E{|3K}6EBFSj zoWYA_DVX@9pube)n8c6a-Q9(T1+1unTd01*olB zQV@oL=%l!D=iZGM5Z!qgSDwN;mnrrRCF^X15~iP}sG^l~)PYZ4&T#IOt0m_g@fbH*b7(6Sy<>;|s>PJmBtE*5$e*ak+mU02>E{@;0DhO|rfPs_|; P00000NkvXXu0mjf+_`h5 literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Length.png b/legoresources/images/Identification_Length.png new file mode 100644 index 0000000000000000000000000000000000000000..94e92f40251fae4a61e8ec872633340aee293488 GIT binary patch literal 311 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkD$N*0l$B>F!Z?0VAZ88vGd+_bh zYEEkl20aBiWy{2ioCOT!3WW_-?(fbl6*@ZQ*Adlvjn+C{la>93yM&&a@36TeS2#)k z`UC&m<(uzl{%$?iyve)wrs(Oz#;Fku>}>a|B%fV4mEE^Rnf2?<t>We{fW zWq8ZGZF}(_dzF|oPJPQ}_c%%H3;zGVZ(>sOMPA9Yl}wtYIu4Je89p*9_&EsAXE-9= z5YZ4JZoNQ~X>$hC8G#9@4qQvvj?8yhbCB0ThQX9!Nud0xdWKCRX_f-{43C&*L?!Xq zHKZ_jTt3#^{;j^DOIo2*o}nwg!OEd=!9jT^%2g<#z7e1DA7mclm%#KO=hN zK@Hph#PU#~k3c*DXm|tEzy(08kECTH(C`Ah1_KRM0J#E)`LQ@6(b?H00Z7|pk;5 zz$3DxxFi5-ILJ2+1Pw+?9ST4fHsDAF3}$9#wsy95B0vK-5S5ORfvcMbz7nc&_pTic zBxh-$p$ar9D}b(f0L^u{zynGOAzWU)2()+s*#-kOPXJPdXfEFfN(F?1f^oD4p}D~T a0R{kNYIJ=b;$wCI0000Q literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_MeasuredLight.png b/legoresources/images/Identification_MeasuredLight.png new file mode 100644 index 0000000000000000000000000000000000000000..7e0b12a1db29dfd740cd5d1b5bb39e6976b92bae GIT binary patch literal 362 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|t>We{fW zJ#aueC;xc{!=WRq(iIO1G6wu&x~a#u%cnu&x?`=PgI9nC!^g@6%UEpMnx33x*AZotjk{Jad>XY~tT>=m#^S z-NgnwN5``#l9du()U06SPdLeYYG1=NkhbbUgNS%@OlrsZ z)d7~yE2188DQ0X^jJWaOROymwdBQ7Z-Es4~$|8`!kZxIew#0ceGcX7kJYD@<);T3K F0RWrQhCKiP literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_MeasuringMode.xml b/legoresources/images/Identification_MeasuringMode.xml new file mode 100644 index 00000000..a3c23d14 --- /dev/null +++ b/legoresources/images/Identification_MeasuringMode.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_MeasuringMode_Continuous.png b/legoresources/images/Identification_MeasuringMode_Continuous.png new file mode 100644 index 0000000000000000000000000000000000000000..37a86170e6c753c58797471f5ad9761d6401a3bd GIT binary patch literal 577 zcmV-H0>1r;P)4xBuX!I=v_)B&EfKnU|nG8xznoC$gC}GP{ z#IL!tGNDC~yc7})1Ym#P33U$iM3BcS2GK1cAaam}oUFQLNvslfJRho%0;@&zbKMDe z%E2rx@I7&1{aUjO-2e&Y+x#fLR3A9x{7RVM>&BZw*wab1=HiT=&_X;Qa*vdQWQjnW zs4Fetos`mW97j|t6)~Mo#cVbcw*6g!p640s^}3amBHoH!Fiq1Y_}X02K^2Cf8jVJ3 zyWK|fcx^tPE84S(_ZRjSukYjP9$!yZt5s1f7KQ7&(RU&g?RHx<8jWZ?nM`n#Qkow~ zl6g{@EY@l@u~;l3(w%Le6+5g+u00-)6&mKSAntW5(mb1ke!nkPt5u|SI2?**vnhfg zh|uYDq6DXY=-F$Op|NMn3*|+oevi5M;dhttseQt@tCME>*OVFYmjD9*w+<`JpcNe< P00000NkvXXu0mjfAg2Lf literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_MeasuringMode_Ping.png b/legoresources/images/Identification_MeasuringMode_Ping.png new file mode 100644 index 0000000000000000000000000000000000000000..a85c6a5eddf3cbf9c022a9f8af09caabacb452d5 GIT binary patch literal 531 zcmV+u0_^>XP)0Df5-zEJ3FtlurZyT@eOBJxn5Y`mS zA*Rwejz{P|1IzfX{+SpgO@v5F?=;*fL-8Z<4s1d72jT-zpQO6-i_$jG2N_9wREh7p z>>z27i}>E34}b^=HPi=Im;mHdO^=&WJ<3fiq7&d2sjKVjJ{bRvbW`PoO^s3^f=1s0tAFq~5B%!9pf!Nb$PnYQUkA+Z|df z$He}m*G=!k9&48>Q`4{7(T+RFUF5kSR7>*fQeQV@=QZvkUS+5?7;hsEQsem^A>KZn z_PH}0sn%_I4%P4G@;K%90>Y(EKdTLpEG+!cW6_h;b?la%?RP9`Va5OAKkrk30RX8& VoI!@?)f@wE+alV{(mYJq#WbM?LF--{= z0l5TVgS!Ffqe;0wfM0txCMe*rAV3E#8Yp5)tKtb99-%7%B|xeLRfLvUqf96A2DIC@ zGJl?edM-sSfOG5X#;bFHFAyk|j;Wz|%(=a2tdpwm9%t|)02QT?@d_TY-^^9qbXW== zS#*p#x|f>xm@;KH8H=`wsVJJwMB~J!cs>Hs7hYRTNe02Q4?Jzh{r~8{7yJ-l0I!c} UHP`O)lmGw#07*qoM6N<$f_hMr^#A|> literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_MessageTitle.png b/legoresources/images/Identification_MessageTitle.png new file mode 100644 index 0000000000000000000000000000000000000000..ce79ea1fbec4810fd821c4c0c3953060082f5d83 GIT binary patch literal 214 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*Jj{i(^Q|t)xHy|JyU`G6*yG z9$0a(;6T%vjoXWtXsGea-8$cKHKD{ah+)@a4X!TZo)g7Um}Yl(Zq2!JbO-M;ljy??k24(YOL*Bh3>da>YRsGQKkpaNItEWyKbLh* G2~7YPy-A<| literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_MotorRotation.png b/legoresources/images/Identification_MotorRotation.png new file mode 100644 index 0000000000000000000000000000000000000000..e4efe4a8d6ab045930bb68256410c8fdf4b57ac8 GIT binary patch literal 529 zcmV+s0`C2ZP)5^#56ZcCUUPYEg~o7_lUE+E=bd|A zd+Q`gQrQHYGQzD^%Pby)BXAJM@nzGcTz*7i@EAnoz8ZR%F zRG68{K|~M@);vs?PPO>19O#ysFk*`xznpE&CRpcn8?4D1W@?*Q+;0nqR;C8eU>j`m zIt9c(cpe76Eo=@zqYGYxHHw~tQ_gEdmd>v*^A*@`>)U2HjsFA6%y5fBLbSpRm zf501XXvHytIe8RgMCqiCRj#gDFJ&hzyUT0YSnB`DqT!ewrSa!^uW!Db-#aiH6 z=^KH52QuAlMH8~iA5b*YTS~P}b^5+~mBnfFuSRb@LE#@QpxmcvW8b_om + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_Note.png b/legoresources/images/Identification_Note.png new file mode 100644 index 0000000000000000000000000000000000000000..b055227eb62afabe541b3b68838a6532bf4d443f GIT binary patch literal 356 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|-(E7srr_TSt>Wq7>e zpopZ*1NkQmOUjr&7Af4@kob5P?~AMmjRFzrDRB&2I9&1_wzYKnIEx-o%Z-`NaD>Sr zjp>Y#S1gaw5BUpAg&V%Gtk4c@YVK@Wu!Hvqn?sF!#z95}zXfdv6`120V!66pTov{) z6j=sNWbdt$a{cw#sw2I zhLvA$@U${juGnKMV6Sj1L1Bfu;v7$-8CeW>AGEu?s_qb(=pxC}wWFVf=PyU7`=0K` xbvqb*lejnT_@@|hhhbIT78|*QW=19+hD{$5D;mvA3V@zx@O1TaS?83{1OS6ydX)eG literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_NumberOfDecimals.png b/legoresources/images/Identification_NumberOfDecimals.png new file mode 100644 index 0000000000000000000000000000000000000000..c94e87d8f02e01efd190197cd3f6ba0a740b6b8b GIT binary patch literal 438 zcmV;n0ZIOeP){QEb!ax*UBkr*fr{n-A2d=JwPY3A$N+2DW3Lq6=Zrq@PfT>_P=H@hja0Q!r z(LBj=oM242@ubo2tXK2qJ@2mPoHMtGnz>Qjg?|cvc#R$4i0EI0AvDI&2bMq#jIb75 zBV6a$<|s}BCh?gx&^aRMx?|Gs4SnuA#rv%V*F6^e^jnYp9Nz(3LSsNaA>WYudB>Jx zm~}_D59CX6n-Ts_3b#^i3;2Xv{cb$Hc@UXnkX}nE5kx|)iKCf(Up+s)zCSi+CE7bh zf>0eB2u(7jnVhp2qV|%X=l%6o$kF3;h{V!sgVLp{g|r6F#^4EC(J5?2foNM>1JOAI z)V-{YfH(fwHIM=?dP>eZ&IW|bY>Xj1xb#ZP#W`@ElBeVca$Bm$1+Gi=x5^`Q_WV|I ge1GUG#g_mB09C$^P-q_fy#N3J07*qoM6N<$f_mk;i~s-t literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_NumberRotations.png b/legoresources/images/Identification_NumberRotations.png new file mode 100644 index 0000000000000000000000000000000000000000..8e9a8004faf7d96ff9a1e648acf91c70aef13b56 GIT binary patch literal 561 zcmV-10?z%3P)Px#24YJ`L;(K){{a7>y{D4^000SaNLh0L01FcU01FcV0GgZ_00007bV*G`2iyY@ z0XHzQF~)HK00FT{L_t(I%k7l0b=yD?M8D_)2xra!S70@O^Qi){15p(as=#ywqAD=l z0Xxv@E>S3T0IC5~p)&`b)7uAwl$<&6MtHY-bF;I9g?}MJ8$Z9b_T&|y8dw7nXk2O! zY=J&yyPLZEZUXGf?rFFSZ9E6=fm5Io*uBa==zLk%O;gv6?Vg689%nWJT>+hA1<(Uc z%Jx2GJ4@LJwn6O@Dd(0v~d;M zc&qPkp^eum+oSXc==^YJPJ;N#pqD_UmY0Quz`ZQLf!*W}wR$h{9S;5=p^ZQEYL&7*hc;eFx8h|J z_+Ad`r18t$;;7k(ppCUE4~bDT#ZI=X{P`Go>!+KteRqTHTz(-b9$n7gp9J1(;w#74 zTsQs5-{;O|n}bV8h2`ZgWxF|I#S4K|z&d67dUU(#Lhp3%fvpBQ*8n@`q&{W4eAC(# z^UY{oj$<#TH-Ed2=W@ux{dvV|WgkEDKaRyOEjh6xj6`bE00000NkvXXu0mjf+T{05 literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Numeric.png b/legoresources/images/Identification_Numeric.png new file mode 100644 index 0000000000000000000000000000000000000000..fa081b45fcbbed866db512325313fa2789c82a3c GIT binary patch literal 297 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|-F|7srr_TSt>We{fW zJ#fKzM(YHoYU|_73S39*Dl+VqL*6h=xa2OTeEjIQfL}^i0vKm3G%%dR%O>@x;mBTw zrMwf4@IAP6x}kZxT1(ELS<@eLPGhKiL(I@)wC*2<6KVEEm*Bb10Hv<_&0& z;^L3r(y`ki&&o_epita{iz~}TrgpQ*71kyXC-H?zZ5~O|j!8RWy3Zfwi!fpglx&u1 nmh~{4QMhG+{4O?T76}H6JZDCW$KifJA24{j`njxgN@xNAea2ig literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutVolts.png b/legoresources/images/Identification_OutVolts.png new file mode 100644 index 0000000000000000000000000000000000000000..9ce5e62cc3212597b5cb68fe7ab8111c74e8009a GIT binary patch literal 293 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|+q&7srr_TSt>We{fW zJ+R`S^Nj?t7@==veR>XA=2Ko*eYo(?HlWZ^p;WxXv4k~X&tw&GXWm`xPur9{Tb+1o z`HyTq!P|8;;1=uI1OW@~Eq`oJIyR;hSPE!6Hb2u5kX{_wC2Ama>XHMq6~6?}sVk=xstYz~ k7Jtl8G&#h>#$mvql3_M|Vu|@Dpz9etUHx3vIVCg!01@Y7`~Uy| literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutWatts.png b/legoresources/images/Identification_OutWatts.png new file mode 100644 index 0000000000000000000000000000000000000000..91e8b096c203823baee9827989a5a3ab84f6e493 GIT binary patch literal 305 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|-e57srr_TSt>Wq7>e z;9@pmvm5u$U1arm+g3D{U+z{tzpsw0h8efUGM1G4u42w+?VNYj7Bty9yt1A0nrUh8 z#3>SsPc|NqD=D5)@Z*V&oO42sqedxBd59&AlKD;suIs7<<2onXK*@ljIF!#z@(9Upd0n{e=iA#a~T xhRWT;)1^EL4RlQ~{OkF$JT_N36P_REx zgyP)(K|EJZ;`Jr5X{8qqx4h<^ckX#NH+CGy);z+VhPYO%B@g$39uP!P^f49j)ANgi zLYT?$ywwSr3TfkP066Z{sEFtN$BB_*b(Qhpbte#y&ps8o}$$c1W;6S79xE&;(< z?X&d$ia{J|PlxtW73msS1opZ70NfC*JIiVwcx!Ftxn~l)>;fGvpaaMOr##@2hb3_& z_9n?Lqy>V(x>rVgM8H-0|nK2vteCHYW@rv;2Uhnc0#%k2#D&RbEf^s>6#)suHE$e+_!0 ngFH zK~#9!)RpZGfv^Ycp-qPpmXTD zuFFP3$zneq8*$Fi!x-or7>9jzE!ZQ>>iKS6X5w6If|AU{ngCnQD?#tjodz12pgJ%` z=`)lh2A~tr6nnw9qHBu>K*m>1C6uG>egbP84N!L2$pMmk-bg5=seSER9-2yZi4|CL z{g(Aa&lHqvQdy(B;_w z0##{9pcKSK<=iwN)Jlb+o<8f4Qvf4&7V)>mzK{R!*Yt}#1Q-B2|C_WP@)sEZ0000< KMNUMnLSTZXfvXMx literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputBrickButton.xml b/legoresources/images/Identification_OutputBrickButton.xml new file mode 100644 index 00000000..3eea9a5d --- /dev/null +++ b/legoresources/images/Identification_OutputBrickButton.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_OutputBrickButtonID.png b/legoresources/images/Identification_OutputBrickButtonID.png new file mode 100644 index 0000000000000000000000000000000000000000..5a69f14c7aaed74c3e1df7a66931681a444a7178 GIT binary patch literal 305 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4fk|nMYCBgY=CFO}lsSJ)O`AMk? zp1FzXsX?iUDV2pMQ*D5XE_=E-hE&{2`t$$4J+m%@FmvyL3&t~8=P%hi_c4=#Xutc( zL(T2q)F(ViQsQB4tXN_7h)3;Gz@E0pMTItnafH*MR(e7(YuCaTZOYONLWdJI?XSo%s+l-uG1M(k7MXEj zkE4KrP}nEI7qi(zopr04*19 AIRF3v literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputBrickButtonID.xml b/legoresources/images/Identification_OutputBrickButtonID.xml new file mode 100644 index 00000000..52ad571a --- /dev/null +++ b/legoresources/images/Identification_OutputBrickButtonID.xml @@ -0,0 +1,9 @@ + + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_OutputBrickButtonID_0.png b/legoresources/images/Identification_OutputBrickButtonID_0.png new file mode 100644 index 0000000000000000000000000000000000000000..5a69f14c7aaed74c3e1df7a66931681a444a7178 GIT binary patch literal 305 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4fk|nMYCBgY=CFO}lsSJ)O`AMk? zp1FzXsX?iUDV2pMQ*D5XE_=E-hE&{2`t$$4J+m%@FmvyL3&t~8=P%hi_c4=#Xutc( zL(T2q)F(ViQsQB4tXN_7h)3;Gz@E0pMTItnafH*MR(e7(YuCaTZOYONLWdJI?XSo%s+l-uG1M(k7MXEj zkE4KrP}nEI7qi(zopr04*19 AIRF3v literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputBrickButtonID_0_Selected.png b/legoresources/images/Identification_OutputBrickButtonID_0_Selected.png new file mode 100644 index 0000000000000000000000000000000000000000..4de41c997e49201c4298359b69a33c14ec27a07c GIT binary patch literal 266 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4fjKx9jP7LeL$-D$|*pj^6T^Rm@ z;DWu&Cj&(|3p^r=85p>QL70(Y)*K0-AbW|YuPgf<4rx&VUW0p&?f`|lJY5_^EKWZS zjpkxdZ_kG2u+!?u~6z z4lflB;(NcW(81-}!&S?Ed^$7r^A!otHbd+GT4kT+CY;ezE4{eGVY9G1tDCB8quaE7 zj~+eAluDhs$78MU>xKZ%dw27~A~k9@WtA`aXkR};nz5jC-I3$c)I$ztaD0e F0stLmU%dbT literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputBrickButtonID_0_Unselected.png b/legoresources/images/Identification_OutputBrickButtonID_0_Unselected.png new file mode 100644 index 0000000000000000000000000000000000000000..4de41c997e49201c4298359b69a33c14ec27a07c GIT binary patch literal 266 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4fjKx9jP7LeL$-D$|*pj^6T^Rm@ z;DWu&Cj&(|3p^r=85p>QL70(Y)*K0-AbW|YuPgf<4rx&VUW0p&?f`|lJY5_^EKWZS zjpkxdZ_kG2u+!?u~6z z4lflB;(NcW(81-}!&S?Ed^$7r^A!otHbd+GT4kT+CY;ezE4{eGVY9G1tDCB8quaE7 zj~+eAluDhs$78MU>xKZ%dw27~A~k9@WtA`aXkR};nz5jC-I3$c)I$ztaD0e F0stLmU%dbT literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputBrickButtonID_1.png b/legoresources/images/Identification_OutputBrickButtonID_1.png new file mode 100644 index 0000000000000000000000000000000000000000..c549041cb223f3aa99860e42737eca63ae86ed30 GIT binary patch literal 344 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|;IQ7srr_TSt>We{fW zJ#fKz2J8GKd*?o8QV{KTKY6IR{hRuPCrL^?tc?{btRC^GT?*LK_PD6frqi)&rQDRh zkBQdN?f;i_95%4|lxM`n%Ah%6`j5n;5;_~}5pu3sOy`JH-&TdBLyt|9 lc#cQzGVBZUHDC}(VCZj{=_>V8Dir8p22WQ%mvv4FO#mf*d|Lnj literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputBrickButtonID_1_Selected.png b/legoresources/images/Identification_OutputBrickButtonID_1_Selected.png new file mode 100644 index 0000000000000000000000000000000000000000..b0670fca4bf825406f8e77b0bc7db97f3cde97d3 GIT binary patch literal 308 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4fjKx9jP7LeL$-D$|*pj^6T^Rm@ z;DWu&Cj&(|3p^r=85p>QL70(Y)*K0-AbW|YuPgf<7G7Z)p`|&NSAjxXJY5_^EKVo? z`TyUZS(ibWx%a>Y;~A{;m+YOZ?8wX~cgufPcc-Dqd@D6Co}r6r#E@c)1Po*U<` zHL4U!w7K8&bz8{5#@5El!^88(!0_w;_Yx;L+nU?IEndPU;(Re#_GSZ+^Vo;?#-SPW zqYh^0KkrET;GQK}^Wj3BNVD(;Nj`3-8Q(Xu^4^=X{NMk(Y(T(R6w}UYkfd$qc~;?u u&Vu}xZW@|`i|2J-*|1on$32agi6P=gm2JAu^dzAB89ZJ6T-G@yGywqLpKf3P literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputBrickButtonID_1_Unselected.png b/legoresources/images/Identification_OutputBrickButtonID_1_Unselected.png new file mode 100644 index 0000000000000000000000000000000000000000..f607721ecddd4b2670da48486d1384e9d999340b GIT binary patch literal 296 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4fjKx9jP7LeL$-D$|*pj^6T^Rm@ z;DWu&Cj&(|3p^r=85p>QL70(Y)*K0-AbW|YuPgf<7G7a#wh!N{^MOJuJY5_^EKa|j z>d4okz~frqS?#aVXFfx@V#`j>L%q*f=8AI8;1d%S7M@+gJYW3B6sI#iVu=?t-m$;) zn!I?f8Kd2fU9#B=ROebU>Asv@$&;qHOg1j`vEl9~7WoYF47EjuTaL5I$ApPWmeju1 zJiz{ayOc`*@6B&y-%e@VKg)H=g&z-$KIj}=%=+<1cf#4Fp^ibf*VHOpy1Z}O?%b)9 l-14(_PYZKDe_iA;`#P0PvBl>%gah5o;OXk;vd$@?2>@4ZYzzPZ literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputBrickButtonID_2.png b/legoresources/images/Identification_OutputBrickButtonID_2.png new file mode 100644 index 0000000000000000000000000000000000000000..91e1e08773cd9131dd3a2a5965b83eb4a0ab7dde GIT binary patch literal 329 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|-C{7srr_TSt>We{fW zJ#fKz2J8GKd*?o8QV{KTKY6IR{hRuPCrL^?tc?{btRC^GT?*LK_PD6frqi)&rQDRh zkBQdN?f;i_95&#d^qsjudLk3S*KbLh*2~7ZTpLqQM literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputBrickButtonID_2_Selected.png b/legoresources/images/Identification_OutputBrickButtonID_2_Selected.png new file mode 100644 index 0000000000000000000000000000000000000000..e11ced16af48555ebdd7e86cdcb63f66ba9ea07d GIT binary patch literal 277 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4fjKx9jP7LeL$-D$|*pj^6T^Rm@ z;DWu&Cj&(|3p^r=85p>QL70(Y)*K0-AbW|YuPgf<7G7aR(ZB~!P5_0bdb&74XxfAoNNgy)0;=#dF9M?UD`G6PjdqMd3QL6n)E5Y zZ16s7vm^V(M#t|nCzVWc@wDQ1OAfxJu$cMY+`OPjw~t|~?ke~G|Jf{4w6ILYKXzLI P(18q|u6{1-oD!MQL70(Y)*K0-AbW|YuPgf<7G7aR?$z&at_BMAdAc};Se$+u zdXejZ0>_mX+tWUuUR-y^mba>4nM&pQy3GJ#kQtm6CyOyXpPiRYAvS_u3 zZcLQo)(^K$*aQvd_8E)pw~fADnRUje?b_Zv zwO-TC`uOrmrIhGQn=9ASN*uPZywBUdLPyHZb!+scAM@=`u(C`oTQB|Swm;Bi44$rj JF6*2UngGWTW9R?? literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputBrickButtonID_3.png b/legoresources/images/Identification_OutputBrickButtonID_3.png new file mode 100644 index 0000000000000000000000000000000000000000..83ea496d494fc4f856b6423e458231e01f5925a1 GIT binary patch literal 321 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|-P07srr_TSt>Wq7>e zpo?Tq{_`CS9!DQv-2dUh!oQpI+1wBf2qnD{w+R@oM)x4Fer%IJD6E8&VIN-fuT~q?P4?A*}?@ooLuAr z4znq!I;{HKur67}>iNS0-nfQ&O$DhFT2*H4E=V}dHEUX)@_IH#4g&_^zU|VN%d%Gj Pea7JF>gTe~DWM4f-H~{S literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputBrickButtonID_3_Selected.png b/legoresources/images/Identification_OutputBrickButtonID_3_Selected.png new file mode 100644 index 0000000000000000000000000000000000000000..4613017e170bde56c89f10dd8b78d7dd8d289505 GIT binary patch literal 304 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4fjKx9jP7LeL$-D$|*pj^6T^Rm@ z;DWu&Cj&(|3p^r=85p>QL70(Y)*K0-AbW|YuPgf<7G7algG_PH0-(?aPZ!4!i_^(} z{{OdU)@2Z8?mck9cn0hIC41*8J2Lah-SVH+-DxN?-%8Dk=jifzX^Ce({QqCS=f=5f zjVgr_X$POn#t1g^i_-R1VyuJ6Lsw>GVJxde@aS7h#43da9mL8 z`I&FTby4M$-Kzif?l%%51P<)!*Uh+a$bv!jxu9_1jfP+U%X@Adk=!Ucdr6u=4&UPZ smu^`b5`xdWWUX{vV|DD}Do!?r>#fywDp_LQK({k^y85}Sb4q9e0GMBEH~;_u literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputBrickButtonID_3_Unselected.png b/legoresources/images/Identification_OutputBrickButtonID_3_Unselected.png new file mode 100644 index 0000000000000000000000000000000000000000..fee5cafed02eefa0e09fc1450cd8b242e4afca28 GIT binary patch literal 301 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4fjKx9jP7LeL$-D$|*pj^6T^Rm@ z;DWu&Cj&(|3p^r=85p>QL70(Y)*K0-AbW|YuPgf<7G7al>7%PR7yyOVdb&7QJ2H|%m`1Q)hfmTdYh z$o{gR>$9Sx-pOej+d>ZgG+rXKFS_5+Wzq5DmqpggEh&mR^yb!vxf?_eSWo}L8Fh8L z`146o)A@itN$!{951#Y((az)(v%H-y*r=}iB6WWqGw-Yd?>WL qYK8XYh3Ob6Mw<&;$Sv=W?_F literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputBrickButtonID_4.png b/legoresources/images/Identification_OutputBrickButtonID_4.png new file mode 100644 index 0000000000000000000000000000000000000000..d287ef59cf1d2b07615e3440cb7f7a12f37ec9d4 GIT binary patch literal 341 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|+h#7srr_TSt>We{fW zJ#fKz2J8GMzHSRy9kk^7C$+x%e_wUNlO!b`*2anzR*!hpE(PpqGfwi(b7)mr?wBya zU=c?H&$0G=1CD>{t}<;8C#L5=mta`p5cjCPQ`Tn7{D~918-Gox{Vv!c-0;gxVL6wG z^ToX#ISeP9c-A{J*k6%hR5NkRVyIi7EHdN59!K5}f-e@cpI}o@FqRQxQFwpYVA=-P zvKWTIm50tcngTnXaq+5QLUTLw>8KbLh*2~7Yp?|G{L literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputBrickButtonID_4_Selected.png b/legoresources/images/Identification_OutputBrickButtonID_4_Selected.png new file mode 100644 index 0000000000000000000000000000000000000000..6b2a98ab0e0ab203fe1a94f2b290f84bedb8c7c7 GIT binary patch literal 306 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4fjKx9jP7LeL$-D$|*pj^6T^Rm@ z;DWu&Cj&(|3p^r=85p>QL70(Y)*K0-AbW|YuPgf<7G7a_My~(bCxAkmJY5_^EKVo? z`TyUZS(ibWx%a>Y;~A{;pZK~hWaZ)E`B*VUC*=Qsy+##r;Y1B)W@cxb5ZOXD;Y^LV z!;%|Sx6kfzQd#c!_5XW`K$d_1|M!dEPZ0Ry-(|sbSo!?DbApFO+4C_|L4Cboj%Ag?|frv~xB-vq@6oYJa_lfX-9=u{XuV#AiT6Z0)NV%rKu*thEn)8nZGtl)6p00i_>zopr0REQL70(Y)*K0-AbW|YuPgf<7G7aFT}7L+ETGUzPZ!4!i_=d- z1NoW_IF>GB|ELsZ>sh{~Qiw_YrtgR2x@nihl1w7qF3JC@IFRk#+;Kqk+CkTE)kijN zvt0I*lVK-QWXH#ct8O@OF-$O@(|f}sN>x8}&fH0IAC-b)GiMxmT)%!t_Wub}BxWz2 z_9#hvg2Z8SM#H*4+wVO#JiB+cg@nP8A6;U++pmSze|{Rtw<=)ny_sfaTPJ^0+flx& mGWFtzx#7EmrT#zX-^A4XuRh}mgK8bn(F~rhelF{r5}E+z{BYR- literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputBrickButtonID_5.png b/legoresources/images/Identification_OutputBrickButtonID_5.png new file mode 100644 index 0000000000000000000000000000000000000000..20dec88cc512dbf7c934f281c49e1210bd7c6d61 GIT binary patch literal 329 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|-C{7srr_TSt>Wq7>e zpo?Tq{_`CS9!DQv-2dUh!oQpeL?RLB%?pG{1~QN;Noue%w8O55R}x)qj8 zJ{e6{82&i8Yiw9h*(}vo&+_XTQL70(Y)*K0-AbW|YuPgf<7G7ZmweQ+n<^zQ`db&7 zYg8$eNIUpkHb&4{LjtI<-#%19x-aLzLFeC`QC^b`wrwvCS%!KLPC{p6JwjFm{Qs}l$Z}ZR t>8kMbI~^u6s~7U{@Z30Dk#bFeAzFW@d&r*KEkMUJc)I$ztaD0e0ssYca3uf$ literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputBrickButtonID_5_Unselected.png b/legoresources/images/Identification_OutputBrickButtonID_5_Unselected.png new file mode 100644 index 0000000000000000000000000000000000000000..8d6e34e87c5f591396ad6613c5ebef2a84501cd1 GIT binary patch literal 292 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4fjKx9jP7LeL$-D$|*pj^6T^Rm@ z;DWu&Cj&(|3p^r=85p>QL70(Y)*K0-AbW|YuPgf<7G7a_lNg`(uYp2KJY5_^EKWb2 zdXV?90*@I6NZNjaCU&N#AF{iNDC)lf^8&uhD!MZ9AURGHm3a|z{D)@gMtv;UAH zt5^A&DdNO*L#C~NF4+g1uAgztG4$-z=U2D>kDXjPH!QKrXv2iNqNaP;HUyZz5a^x0 zXYZW{96vT(nAh+kD*pfH$!-fzI&(dpxu@c5&bLjOEFB&nyCz33SeLMHJ9C_0{hGTD iKUBA@{AgT1f!Wu(?)__tw{k%DGI+ZBxvX + + + + + + + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_OutputButtonID_0.png b/legoresources/images/Identification_OutputButtonID_0.png new file mode 100644 index 0000000000000000000000000000000000000000..3e6c7dccb58e327405406e9cb9675944f1f4a1dc GIT binary patch literal 337 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|-b47srr_TSt>W#Bea zKVYB1IH61Z@|sp@vvuALg)=UwJk~5w>55ZhlVU7s77t1g>xy%Wa+SNbfWd7M^G3D@ zLEVp%7AOU*@ncA;Q~1Ymg!RCTxQ4?Hd$KOZ@&un?SgQV@P$zEd3%1X~4}{lF>ulK& z!*JH&iMt$M0>dGP!>k_XF0n9Jd}|c^(kO9M;^mJQ6N3vFv!#vQYG!?0xioT`oBwf% zn*uLN-DDyje;z2PZa6Fhw2ha~;nD}eQ^#LA)MRCb d$uYA?Fa+-k+B?VBb0^TJ44$rjF6*2UngG=Idldix literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputButtonID_1.png b/legoresources/images/Identification_OutputButtonID_1.png new file mode 100644 index 0000000000000000000000000000000000000000..37feb146691b4dcdee2c551f8574526b4c8667d8 GIT binary patch literal 347 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|*ud7srr_TSt>W#Bea zKVYB1IH61Z@|sp@vvuALg)=UwJk~5w>55ZhlVU7s77t1g>xy%Wa+SNbpkj%}BZoDN z2RM$e5<7a-f!T4R6=TQG#vjT8;wSFbZ)Rw3l*npanZ&3keptlF;U#BeoRZ`RucQ6+CIkBBtqQT%o0pq02CX5VywFxY>3T}pOR(4fSL}CuyI@TjNKdmM! zbK26t7#<$`o*a%ZR?2-Rj;x-R*DCOrhpj5Iv1QA;hSLxFU(_V*usx8-7q|5V8@od0 n500mgOBC$3nrQbkGVw5|uMK*f_`|CY=w}8`S3j3^P6t>W#Bea zKVYB1IH61Z@|sp@vvuALg)=UwJk~5w>55ZhlVU7s77t1g>xy%Wa+SNbpkj%}BZoDN z2RM$e5<7a-f!T4R6=TQG#vjT8;wSFbZ)Rw3l*npanZ&3keptlF;U#BeoRZ`RucQ6+CIkBBtqQT%o0pq02CX5VywFxY>3T}pOR(4fSL}CuyI@TjNKdmM! zbK262mkr&_Se7Nb$xQ5AC??_4Q=;GUBHh5CLd3)4HP;TFe;w!8+deYOJWE)?3Z!G$ r*cCE=a6ElnqF}exM7y7niHE`bcF^M*hGYCdk283>`njxgN@xNAyZm|e literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputButtonID_11.png b/legoresources/images/Identification_OutputButtonID_11.png new file mode 100644 index 0000000000000000000000000000000000000000..c49f7dd66304a8bf6fda6b5441c6b712ac3add02 GIT binary patch literal 352 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|;gY7srr_TSt>W#Bea zKVYB1IH61Z@|sp@vvuALg)=UwJk~5w>55ZhlVU7s77t1g>xy%Wa+SNbfWd7M^F}tC zAd!Qs#Eu?yV0PSS#n|z)@rSa2I74z3BOkNjl~Z@?H#1D{PUMnY@P);u@91i=y9sqn zHH)qa&AsC=lYLg>iGCZI0}L&VZQK*)EahYP^;N?TH`=wjd8cyO_U)6Rtrryumcs7a8pKaj`=lm*hM q1q_qg`UC9z&OZQZ|0JPsfWa_0=rP~VH8+4BXYh3Ob6Mw<&;$S(J%Ne< literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputButtonID_2.png b/legoresources/images/Identification_OutputButtonID_2.png new file mode 100644 index 0000000000000000000000000000000000000000..fc7dcdf434deb5bc671b9381af6ecb4c9c2cb5f9 GIT binary patch literal 348 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|-_I7srr_TSt>W#Bea zKVYB1IH61Z@|sp@vvuALg)=UwJk~5w>55ZhlVU7s77t1g>xy%Wa+SNbfWd7M^G3D@ zLEVp%7AOU*@ncA;Q~1Ymg!RCTxQ4?Hd$KOZ@&un?SgQV@P$zEd3%1X~4}{lF>ulK& z!*JH&iMt$M0>dGP!>k_XF0n9Jd}|c^(kO9M;^mJQ6N3vFv!#vQYG!?0xioT`Tj57# zSHYefjq?Az%6%t}1aR}Hx$P2n`eH00VZ)`eq?9#=t={E1^Wh(ie8mP=n1HliGxG$K onwC$6Rs!>*W=%cLz{tjs{32*?!oGK*Kut>Wl-L9 zknx`*cSDHH%rxCQ8wz8YdJea!N%}V`2YxX!yuh(Qdd~!=&0>#ul2e zu5vY>F`r?6##R?~^MGfKX$qSrN!ukb9CA3!+7Wohsp%k}0+Yl{c@I5phX*ev1{W}9 zOB=h@%=)-;Y2-9F|Kk!j1zwc8$xQ4F*S*W7_)C)K%O)ny%vi?h2jwsRJWx>Ga9Czf u)PaS{hP?MDzCdbSo!SK3o;!J-B$$db7GkCiCxvXi{ literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputButtonID_4.png b/legoresources/images/Identification_OutputButtonID_4.png new file mode 100644 index 0000000000000000000000000000000000000000..e8ac3af4e5ee69e8406fcc32d80fb61762a14bae GIT binary patch literal 349 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|+(-7srr_TSt>W#Bea zKVYB1IH61Z@|sp@vvuALg)=UwJk~5w>55ZhlVU7s77t1g>xy%Wa+SNbfWd7M^G3D@ zLEVp%7AOU*@ncA;Q~1Ymg!RCTxQ4?Hd$KOZ@&un?SgQV@P$zEd3%1X~4}{lF>ulK& z!*JH&iMt$M0>dGP!>k_XF0n9Jd}|c^(kO9M;^mJQ6N3vFv!#vQYG!?0xioT`oBwf% zn*uLN*Q~2sqS3T4?A- pU{cfasj!M|e$=d~#~B#e7?NKE?Y$vxp$YUggQu&X%Q~loCIErKeWd^Z literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputButtonID_5.png b/legoresources/images/Identification_OutputButtonID_5.png new file mode 100644 index 0000000000000000000000000000000000000000..2c65a6e9c2a7db8472d640fbbfb5b823d010aa47 GIT binary patch literal 346 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|t>Wl-L9 zknx`*cSDHH%rxCQ8wz8YdJea!N%}V`2YxX!yuh(Qdd~!=&0>#ul2kaS?|`m^y=@y+A$7Bc`3d^TiU11r)cwV5@J?YH93uILc(fb8NMk?WZ4{ zA3DRlONy9NerXiD{5Hs-q(DhC!*}<~Qb(sjM6_wnbce3AxF~I{c08 zwwj#2^kS*Bn;A>hTtWAgN1@)^ojU5+nD?%6aEb~)kov*B#LnQ3+yevl^-(3w%o9v% nT0Rw83Cxe0HT5_HBO61G?Hv1;L3xZoFEe<$`njxgN@xNAf75v; literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputButtonID_6.png b/legoresources/images/Identification_OutputButtonID_6.png new file mode 100644 index 0000000000000000000000000000000000000000..ce1556e342eb282e81ab1ecdd2d339d9c9ee49f3 GIT binary patch literal 356 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|-(E7srr_TSt>W#Bea zKVYB1IH61Z@|sp@vvuALg)=UwJk~5w>55ZhlVU7s77t1g>xy%Wa+SNbpkj%}BZoDN z2RM$e5<7a-f!T4R6=TQG#vjT8;wSFbZ)Rw3l*npanZ&3keptlF;U#BeoRZ`RucQ6+CIkBBtqQT%o0pq02CX5VywFxY>3T}pOR(4fSL}CuyI@TjNKdmM! zbK26t7#<$`o*a%ZR?2-oEepkFJd=DG$8qs|Lc#|Pfoutb3XuZIKZ0}lc^t>Wl-L9 zknx`*cSDHH%rxCQ8wz8YdJea!N%}V`2YxX!yuh(Qdd~!=&0>#ulB0G>h;{NEk^0~f zc%*Sg2xHe(PKPu6N8}rKFi2eHE|BP0820YpY}OqyJi#Xzma0D})QQ{rg6*^L1L3vP zUOZttWpjbYrS8c?1~vsAlb8mHqdF=QJbkqZDRl}v*Dy3LcK18Tx+eFG#K+8I%crG9 zN*z6VU`yvj-p0(yg6=6vD_GftmG5#Z{*vV3kz*CQw2Miv*?!UI#>77i?UoW*AbR>i qMh_`Fr=J$G9sas!PbD`nFf%+q7JAo=*?lR{-wd9velF{r5}E)Je|`c0 literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputButtonID_8.png b/legoresources/images/Identification_OutputButtonID_8.png new file mode 100644 index 0000000000000000000000000000000000000000..73d2c470fa214ec65e7d12aa9d47dc7cf03e4a4d GIT binary patch literal 341 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|+h#7srr_TSt>W#Bea zKVYB1IH61Z@|sp@vvuALg)=UwJk~5w>55ZhlVU7s77t1g>xy%Wa+SNbfWd7M^G3D@ zLEVp%7AOU*@ncA;Q~1Ymg!RCTxQ4?Hd$KOZ@&un?SgQV@P$zEd3%1X~4}{lF>ulK& z!*JH&iMt$M0>dGP!>k_XF0n9Jd}|c^(kO9M;^mJQ6N3vFv!#vQYG!?0xioT`Tj57# zSHYefjq?AzVd26--rJoz>e!g~u5nnCcp~c}@4t?7>}|K1Wu83t>W#Be? zK5@|rCIwOdWs%%Z-|hEoD3q8O%VRP_={YlRTFb_n5*aKPc;h@8BQ>fdGes*Snw1XN zpJEjXw hyR9bL{ftaJ40??bziq@n?go07!PC{xWt~$(69AN6dc*(# literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputChannel.png b/legoresources/images/Identification_OutputChannel.png new file mode 100644 index 0000000000000000000000000000000000000000..ae69d35d0f2e1aeb22d7c2f3cf309a8d6e98aed8 GIT binary patch literal 2874 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 Y0IX0M0ay)37XSbN07*qoM6N<$f-W^sS^xk5 literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputCompare.png b/legoresources/images/Identification_OutputCompare.png new file mode 100644 index 0000000000000000000000000000000000000000..06912ab75b1ffdca44b713e53b89f164bb652cfb GIT binary patch literal 462 zcmV;<0WtoGP)g(dfJ9IL z9JAJf4zq{P5BPA>YR!6Q*qz-2rL`_y92dBgccHveq@<{nH^(qc`wdHzcOo8~ zImGy6k3k+l5|4Dk^VDT($fHg@;C%i(x86KqK(r;kF@rb0zGL2F@mPs@x+GE4f+e{^ zkdK{-nUv(HIw;cPRdf11jvYzUT=T{`YkWU{O?v?b0MWaTDr)I#B>(^b07*qoM6N<$ Ef;O1GYXATM literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputCompareResult_1.png b/legoresources/images/Identification_OutputCompareResult_1.png new file mode 100644 index 0000000000000000000000000000000000000000..2b7849cf4fad0aaffc039cbd5689171aa15fe023 GIT binary patch literal 172 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP?4pli(^Q|t)xHy|JyU`G6*yG z9$0a3Ft>We{fW zJ+R{7;gb($_c*C6x6i41AusZ+tdGlK4`crywh2;`c-XQu7=pwbZpim9b|?~GkY&ig z&FA~qW7-4m;<}WrM~}>qIWn58Vf2t>`six2j`gIZ)72!V zfR}AO`34;S+{Kk!HojaKS(GfJ+wabMjDdlXjX|a_*_5+nKF})+44$rjF6*2UngGm& BR)GKj literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputHeading.png b/legoresources/images/Identification_OutputHeading.png new file mode 100644 index 0000000000000000000000000000000000000000..573df9055949ec5bb24b5107efe68af236efd4ff GIT binary patch literal 414 zcmV;P0b%}$P){LAx!9W<@7(F)-H*f+!gg&HT|2GXlkl$?NQHJkt^zzO1g=EZz=l3<1z zg*Wr&+x@<8UtTtwb;2+--$2HE34h@`vPp$Xx#lADzy??d)=LLD`O-&l4*JL)-f|29 zA7Kx6Mbs)6nBTMSHDNSYxlm(g#Ry&YrwgNLh~R;3rY2wq+;T3l$-H5o7w0@3#9W{5bLv4AwI<*eNd3az5o^Wh2u6-eYT;IiE-X>Q`HJJ5`mh4`!EqY! zHfQx9!3D1JpZKMFPv)_3Ub&BX6orSh-}r6e|9$+M!dC$X03$A3>M@7Bb^rhX07*qo IM6N<$f|0zhzyJUM literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_OutputNumeric.png b/legoresources/images/Identification_OutputNumeric.png new file mode 100644 index 0000000000000000000000000000000000000000..99d2bc3fe6aea4a2c8a2ac3544a9750c23957e60 GIT binary patch literal 294 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|;>j7srr_TSt>We{fW zJ+R_n!2zcprE2Trp$=Li9ol?yx9)R3k!HS`-tfbAg1$>U?F88$Br{93GXjUDKG22WQ%mvv4FO#mZWXJh~X literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_PlayType.xml b/legoresources/images/Identification_PlayType.xml new file mode 100644 index 00000000..a03f18cb --- /dev/null +++ b/legoresources/images/Identification_PlayType.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_PlayType_PlayOnce.png b/legoresources/images/Identification_PlayType_PlayOnce.png new file mode 100644 index 0000000000000000000000000000000000000000..e46df92e0c3bec0f9b5ef66bf31203390b4b1df1 GIT binary patch literal 424 zcmV;Z0ayNsP)V`cT6IXc5NzK)fDk_ylqdW<*bJ zK*P|}-$jt{hK=hUP&-wCg60CyLI+wTH&D>*2O3@g6S&DJ<^aODG_a81h>t37KAZ&_ zwgAYEN3sA!O$6cw_5ZIvkeoqe-+zutJ$7X>vY|*IAC!`SmI#n)@WPzK7ek=o&A=P# z#~^=ZHyESEMFFV>qj+DaJePr0NgkUzk_t>Wq3Tn zct)p;uesz=IfjkQS9#f(Di!YWo76B1XbbRkG5l9xRM^Vc@%H1)TRUHJ>IxUk8ThyzW>+9h`t96nacS#e0>+1X}?ISeH)nHS{CHmtL1IGxb3`J*%!*SdCx z7zUF9W)lv_E%q82AEkQu9S#fH9{RI#s#eD2KK8i>r6($#Vw`e%MPh-9fh$Wxk+4R1 zW0APY^oJ}5L<+e&bDK8{FiG8D@bYpv!!NA;eY4`RiRF!bK?h$YWk{tum`(905bv1F zDK`5;Q!1m5I@4u6<&%v(MiS!t4k}179O3`4@?fi^`)V}_1`Y#;Eu6E>lCn#00)v9V M)78&qol`;+08Bf8egFUf literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_PlayType_WaitForCompletion.png b/legoresources/images/Identification_PlayType_WaitForCompletion.png new file mode 100644 index 0000000000000000000000000000000000000000..1d49c8415fd7f589633eb6dfac689b8c6bae4193 GIT binary patch literal 697 zcmV;q0!ICbP)OX^K41tCKn%!$5vXK8kZu4fV*u+p zaNxi}5DgGOj8Fsq17!l3m>D(z=>A{M)CVA~05iJ)Bmi^?$Po`Q`&Jt)Q)85t%3Ljx4O z2k`}dJp&PdiGc(F5MYc9WB_PDfU^)Z;T;6|3*>KXfdO-R0yOeIq9qr7XaR5mn`NND z0#Xlw>g++`!-7Q($Q2)8$q42mm`jkv8$hlG2J{1-APmq;? z<#8DdN*j(y2L4BKC9)+G(83rL?i=vMG^k9I$0Gg#nl}zW4NyP}V^DAj!uYtt_yKwt zBe`}0Fd;Jl6LJHvYFKda5IE9ck^2Fk!8i+bkfq3Z4b8`RGi{kY=bVm4s|iD{M&Kjo%<&o}CNxOC!GrSx?R#YK8fm~vEIboZR- iB`?n3X~4!|z+m@AdwcppwWC0XFnGH9xvX3}vVq#+YgU?V7 z4vxPH3JS}YEnCL%?Afz*M5S|J*nOBYXO6k5s;UDpRXoNP&QelR=YRb8A@b$2_y!z>?4qG15AcSOiU~RK%oY*b7(+7P{RHD4~18)TE!2H zkF`L{1a9BH`xGjj0Lols84ffUlpH4j@dXec7|~y#V)ubG$WVn18`f|K}?Yg@-8Sn7pSPHG~Bs!X8|-G zCIDS}fTHposj?`LkdTOf@#4iqprI3}QdtbzIuszl07L8sW|-`sfdBvi07*qoM6N<$ Eg3tp38~^|S literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Pulse.png b/legoresources/images/Identification_Pulse.png new file mode 100644 index 0000000000000000000000000000000000000000..9098b0d649936671b177e5cf236a1df9df5d2077 GIT binary patch literal 499 zcmVE%LnxdX zkeqOlB##1v>O8h^XTqW00F5tzPcb@}fKPD(&}!rq_y8Wxc-##NQil^KkAc+z1Q;^| zjQ}H-_|b>@2RV6900w^{DF!p47dSxb0@Tm~AXWh41t2!GIIt%tA@@TyzlWw*WVw8p z961L6hvIkw^7cdr1)Aaw*c85EV_|r}#YQMq^TSdy3p8IG#Fv~vAjeQ90AwjJIUU5K z43q;7fXredA+#PqU4^fR4S*UTdDq6JWl-}?kghX9~u520e9WSRiY pc?Zcd7|DWoXgUXh1u#os006CBhJj#R)!_gD002ovPDHLkV1i;1vtIxJ literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Radius.png b/legoresources/images/Identification_Radius.png new file mode 100644 index 0000000000000000000000000000000000000000..f7525bfe6f48207eb708a210efdb55dc3d947caa GIT binary patch literal 482 zcmV<80UiE{P)bcMhdM1q}kWNTL@ z`UT-WbX~nTN$a7lc+yqU*zefB_H*N+D57mdymRp2`lgLXLY;ZdQ^<DiUhs-d3w z63k9BF1fc3>cMkb)OC4#s!u{slTfI{=^|1T*VeMxja8=SBzpzTDg0*gVrt?*{uq|g_t>We{fW zJ#fKz25anrd*?1Pc;qr9RVtmW;5fp_&i{6Q!}Wv}3z-~pI@U?FEAu&g)eta>kW14D zQD)x7dg778Hs%SH^HvzR8HqfZ#ca@gA%;`z_*3ngiR_=G>^UDDk>n}i)VL$mc!Tj7 z^9t_3Bb|Pt8EyIwpY1x{G6*ksvr;?t+hwG#p#K;=UHx3vIVCg!0EGl|VE_OC literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Rate.png b/legoresources/images/Identification_Rate.png new file mode 100644 index 0000000000000000000000000000000000000000..07513581594be7744ca480552021300b30d4fb74 GIT binary patch literal 355 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|*iZ7srr_TSt>Wq7>e z;9@r6{0)2ODn~qeu<&n>!N%D=PD~E37zN@3{{KJ6IRBtdMw=>wCac1~2IpEvfzQkz zSyog{a8=;uS@4O!fiJQl$siz*dBQ672hJ0Y@;9!#%kZ>Wr-S`bcYxgqr40vtGG;j( z5WM-@;~>MN>Fkf#R30*D)G}r%oO!Cj#;u@vNR&suv4UC5aKh@}jXxO7niHkO7@AWV zXJtD+T*3dz%0Obm;d-Vk?5!Dn&YgQWFLZonS7kG~ZlWLXOLy@&NtL;OXk;vd$@?2>_ + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_RateUnit_0.png b/legoresources/images/Identification_RateUnit_0.png new file mode 100644 index 0000000000000000000000000000000000000000..fb754feb6a6de7ee13075c1ea60ab25b6fb94e4c GIT binary patch literal 452 zcmV;#0XzPQP)Sr;bxmE#4`6CGlqOk>`mZXCOKn4J*voHlf{(B&<0I`{{xOO8p*I?tr zf&`t7%isk_e30uxq2W6V=$d-R|P&g|A@fobi4Vc6NfcOEF{U0WNgF#Rbh>ekx z5=ab5P6>(yk=3x^aVgWTnjSTft)gkiGXV_09|{59D`Z#$R(gqWY u0noJvXkqXIS`_pTXjRY`4B9#mAix0aa~x&Hp*PR~0000of7-x3WHsIG5*-nQvU-d$?dh+xN~gLshYfq9R8kPH>#Q^h4yl zRn0`lzyGb>BG^1PUp=1r;Gpww$--R{YMtlQRQk`P9a`QgaA5hg&Y0eoD@GR&ZFM$& xZrCtMTCt|t@q@jYnVpZZxG~>OD}IFo3}tS0L2O?h!~)&L;OXk;vd$@?2>|gqTn7LE literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_ReceivingBrickName.png b/legoresources/images/Identification_ReceivingBrickName.png new file mode 100644 index 0000000000000000000000000000000000000000..b8443c01449c65db712fb1ae565b441fddd674ca GIT binary patch literal 488 zcmVP)v6V7tdihhJ_kI zfbMFLubFTKftHpg$R%JpF)0DeK6Lm1n4h1Y2j*|tx|u;nMw+-Vh5=VsSB57~o`UI5 zpFc62JaG~%Zf;@D;OgeeU}x(9HuTe{&sg;{;W9WlBnX8D0gy$Bi3vc%K7lca52A@S z804bs*RC@(H@ARk5RjIUVbBBy!`e0L!2D&)mx3`UXs`jSK>_kM2!mV$Gx!>i{tV=U zXoiW9AbI-a3E0&{8;tBd7#kMG$d=;+EX1ZuX!;fa%6%Xv=`j(TMuCPd08$HxRnI~w zYXZT-j~_oC0MhYL3mW+O`4wP%q724XP5=!u08;0XgzAA71po8Fa{aQk42mZh)+N*CO%alr49r15)W63!D=ulZ1I(F=wVNcT1H~4CQ@C@#6Tm! eNUO>eAix02=eP$Zd4)d!0000 + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_SensorPort_0.png b/legoresources/images/Identification_SensorPort_0.png new file mode 100644 index 0000000000000000000000000000000000000000..2d00e6b38b1ce9d7bce3d6fa3f54474a0e05197d GIT binary patch literal 293 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|+q&7srr_TSt>We{fW zJ#fKz2J5kck`fVyAnAr1^L#e*F%=&8_xHE`g55KOoFx}jnJ4U!IC-JfAzIkOQ1HcV zRtGJ)n~4&MJ*O`m@3|!Fut$2fjG3*@ksTZv3OXC#FU(ps;qU(`f*zqgX#%H=I3`YH zPu6BW{8#QMo3nENrUeaZWo$-996f6p7D*;PH4J#b&>ATf6USiO&Ah9dc>yaYvudkA k&tZ$G<_mWc8W@-vTEAN`rv8|a3Uob#r>mdKI;Vst0HeKSI{*Lx literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_SensorPort_1.png b/legoresources/images/Identification_SensorPort_1.png new file mode 100644 index 0000000000000000000000000000000000000000..39f086618971e488cadcc0d055d36a05ba549a1c GIT binary patch literal 342 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|;&g7srr_TSt>We{fW zJ#fKz2J5kck`fVyAnAr1^L#e*F%=&8_xHE`g55KOoFx}jnJ4U!IC-JfAzIkOQ1HcV zRtGJ)n~4&MJ$WyZ-7=FE?3j=IUs$20XnVwMo}s||iGTl35%ieNP$+f6Xpu6%ID?c0 zcV~5f*vVW`fpR8YYwwNS3m@umEGc9D7`b4fXh@;qg#dAdQt^&-Mqc0LX#p)vh9{01 ze_YB_q{RQ^R7uxqu8gE~1?A=gH@FmL35Llrv+@PZSbFd&tHEZA1-mU6q9zyw1aTa+ j=vi#aah8{j!+;_Cw%^NR9PIf(?=pD0`njxgN@xNAKHPQ2 literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_SensorPort_2.png b/legoresources/images/Identification_SensorPort_2.png new file mode 100644 index 0000000000000000000000000000000000000000..87aa7690f1b8124484962947d2943749f3f887c4 GIT binary patch literal 346 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|t>We{fW zJ#fKz2J5kck`fVyAnAr1^L#e*F%=&8_xHE`g55KOoFx}jnJ4U!IC-JfAzIkOQ1HcV zRtGJ)n~4&MJ$WyZ-7>`${`I$%3tw^$d2;e!{Vw(nNk@qjp=?RX3mz`K;wRb^P&4gC zh$9C>Y^At|CSxJ%g|FXNJWE=TxFA7*>5<6-)l3m-9+MO`f$57`TNO-WYQ$c71!S^v z@dc!m1<4$9a86@f87VSd^um#I4sL9X8$}&Vl-Jm>amg$&@NPcMosd@OP+rKeMImv) m5`m^d3HNM)S<*ZL2@Ft>We{fW zJ#fKz2J5kck`fVyAnAr1^L#e*F%=&8_xHE`g55KOoFx}jnJ4U!IC-JfAzIkOQ1HcV zRtGJ)n~4&MJ*O`m@44jVP$S+^F1)yX#R+C9HI5}=j2necPIPBzh^Z9onz~}rodt3A z`oI5YT1B4Z4d20}DX#I`ep9MLcg#sMi4{NPCM3BS6{u-wa7cR1pX1J>pgLz}fl3*h zkr7AFT82fEiBAm!9x${SkWR%E_$SD$sM-BC7eqorDGkW(Lirt|7-& SJDh>uWAJqKb6Mw<&;$U96K~%D literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_SetOfChannels.xml b/legoresources/images/Identification_SetOfChannels.xml new file mode 100644 index 00000000..cf9ddb7f --- /dev/null +++ b/legoresources/images/Identification_SetOfChannels.xml @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_SetOfChannels_1.png b/legoresources/images/Identification_SetOfChannels_1.png new file mode 100644 index 0000000000000000000000000000000000000000..dca4ea050135adb3fd1a671fc47995e0ad0946e0 GIT binary patch literal 430 zcmV;f0a5;mP)_-G77XZKU7k zeuYgsAC^Bd1qD#pf8WDPfR8L>Ktmfq9Do1= Y0J;Wt&WC5NumAu607*qoM6N<$g6+MWZ~y=R literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_SetOfChannels_2.png b/legoresources/images/Identification_SetOfChannels_2.png new file mode 100644 index 0000000000000000000000000000000000000000..156a17609f26296cadf55f576875bfea1613ad4e GIT binary patch literal 473 zcmV;~0Ve*5P)lH&rkd;l%@($5b%cjF}zGKAud&5OSiz- zJ^+nEO$6cwP^2@FV<;#$8b5vo<}(YTWXgP4 zPQ_{PBSn$_$QV6Ga=F+s$e-EGpz`h(7>m#Bfysk%Y5_T691ml>>zvGRM@Ws~^Xg3u z0%>u`t}nnD#&Y-Hpe8L~sz8pUZ+i}bX^^W~mE;*-S2Q#HeGku1{1m4OkgGq=TFf9+ zo(r~sV5-2DZh^6V02=#XuY+6&ayiIAP%wb#-}fGZq(8Edk;6bqDxXP^pFyOf25cb6 z0+7pL!2^n5Mo^tcO0MGk{f8m_=w$}UPha854Jm9v;3Cjx28`rXrqHxp0LA=J;g2Af g0u5~daR34g0RE?%c$Cp4OaK4?07*qoM6N<$g896_E&u=k literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_SetOfChannels_4.png b/legoresources/images/Identification_SetOfChannels_4.png new file mode 100644 index 0000000000000000000000000000000000000000..83d309795e35e615b7defbc4d691ba15fd821090 GIT binary patch literal 447 zcmV;w0YLtVP)EO$6cwP^2@FV<;#$8b5vo7h@KLXUu$9 zP9-NOU^x;DctiadRNmcUkUz558r&M_ z^z0arBMIbvsa10r-gQm}yBZDflbtF+hQcg>VPp$%x;PK$LM&PQ05tX)zV11Q9BJs_ zBMTWh43wnuK|ufmTrLntd|tf?9>I*DI**iG#rgXWL;BIn43eL|;!<)E=raRGaw=13 pS}uTMewg<`E(IFe0O9}y7yx-|byBE+i!lHI002ovPDHLkV1j_ro%{d* literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Speed.xml b/legoresources/images/Identification_Speed.xml new file mode 100644 index 00000000..caf2ab26 --- /dev/null +++ b/legoresources/images/Identification_Speed.xml @@ -0,0 +1,12 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_Speed_0.png b/legoresources/images/Identification_Speed_0.png new file mode 100644 index 0000000000000000000000000000000000000000..04f77b4096e0a2790955e289f94494d7c2b75e41 GIT binary patch literal 3294 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 literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Speed_Minus100.png b/legoresources/images/Identification_Speed_Minus100.png new file mode 100644 index 0000000000000000000000000000000000000000..426b63cb54220708fd22a21f6ddafc269028508c GIT binary patch literal 3335 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 UlKC&Z-T(jq07*qoM6N<$f_{lN$N&HU literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Speed_Minus50.png b/legoresources/images/Identification_Speed_Minus50.png new file mode 100644 index 0000000000000000000000000000000000000000..4190ea152a35e917c9181b3c3ac18a57b91f91b8 GIT binary patch literal 3399 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 KMNUMnLSTaDJTs*L literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Speed_Plus25.png b/legoresources/images/Identification_Speed_Plus25.png new file mode 100644 index 0000000000000000000000000000000000000000..94ca83543c21708da09b2bcb48317e457e921277 GIT binary patch literal 3301 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 literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Speed_Plus50.png b/legoresources/images/Identification_Speed_Plus50.png new file mode 100644 index 0000000000000000000000000000000000000000..17b986cc5a58964726833f1b82bda254bfb58c13 GIT binary patch literal 3370 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 AwEzGB literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Speed_Plus75.png b/legoresources/images/Identification_Speed_Plus75.png new file mode 100644 index 0000000000000000000000000000000000000000..80d0db599dc4b508cdfb4107f1028c575b0b86c7 GIT binary patch literal 3408 zcmV-W4X^TvP)KLZ*U+IBfRsybQWXdwQbLP>6pAqfylh#{fb6;Z(vMMVS~$e@S=j*ftg6;Uhf59&ghTmgWD0l;*T zI709Y^p6lP1rIRMx#05C~cW=H_Aw*bJ-5DT&Z2n+x)QHX^p z00esgV8|mQcmRZ%02D^@S3L16t`O%c004NIvOKvYIYoh62rY33S640`D9%Y2D-rV&neh&#Q1i z007~1e$oCcFS8neI|hJl{-P!B1ZZ9hpmq0)X0i`JwE&>$+E?>%_LC6RbVIkUx0b+_+BaR3cnT7Zv!AJxW zizFb)h!jyGOOZ85F;a?DAXP{m@;!0_IfqH8(HlgRxt7s3}k3K`kFu>>-2Q$QMFfPW!La{h336o>X zu_CMttHv6zR;&ZNiS=X8v3CR#fknUxHUxJ0uoBa_M6WNWeqIg~6QE69c9o#eyhGvpiOA@W-aonk<7r1(?fC{oI5N*U!4 zfg=2N-7=cNnjjOr{yriy6mMFgG#l znCF=fnQv8CDz++o6_Lscl}eQ+l^ZHARH>?_s@|##Rr6KLRFA1%Q+=*RRWnoLsR`7U zt5vFIcfW3@?wFpwUVxrVZ>QdQz32KIeJ}k~{cZZE^+ya? z2D1z#2HOnI7(B%_ac?{wFUQ;QQA1tBKtrWrm0_3Rgps+?Jfqb{jYbcQX~taRB;#$y zZN{S}1|}gUOHJxc?wV3fxuz+mJ4`!F$IZ;mqRrNsHJd##*D~ju=bP7?-?v~|cv>vB zsJ6IeNwVZxrdjT`yl#bBIa#GxRa#xMMy;K#CDyyGyQdMSxlWT#tDe?p!?5wT$+oGt z8L;Kp2HUQ-ZMJ=3XJQv;x5ci*?vuTfeY$;({XGW_huIFR9a(?@3)XSs8O^N5RyOM=TTmp(3=8^+zpz2r)C z^>JO{deZfso3oq3?Wo(Y?l$ge?uXo;%ru`Vo>?<<(8I_>;8Eq#KMS9gFl*neeosSB zfoHYnBQIkwkyowPu(zdms`p{<7e4kra-ZWq<2*OsGTvEV%s0Td$hXT+!*8Bnh2KMe zBmZRodjHV?r+_5^X9J0WL4jKW`}lf%A-|44I@@LTvf1rHjG(ze6+w@Jt%Bvjts!X0 z?2xS?_ve_-kiKB_KiJlZ$9G`c^=E@oNG)mWWaNo-3TIW8)$Hg0Ub-~8?KhvJ>$ z3*&nim@mj(aCxE5!t{lw7O5^0EIO7zOo&c6l<+|iDySBWCGrz@C5{St!X3hAA}`T4 z(TLbXTq+(;@<=L8dXnssyft|w#WSTW<++3>sgS%(4NTpeI-VAqb|7ssJvzNHgOZVu zaYCvgO_R1~>SyL=cFU|~g|hy|Zi}}s9+d~lYqOB71z9Z$wnC=pR9Yz4DhIM>Wmjgu z&56o6maCpC&F##y%G;1PobR9i?GnNg;gYtchD%p19a!eQtZF&3JaKv33gZ<8D~47E ztUS1iwkmDaPpj=$m#%)jCVEY4fnLGNg2A-`YwHVD3gv};>)hAvT~AmqS>Lr``i7kw zJ{5_It`yrBmlc25DBO7E8;5VoznR>Ww5hAaxn$2~(q`%A-YuS64wkBy=9dm`4cXeX z4c}I@?e+FW+b@^RDBHV(wnMq2zdX3SWv9u`%{xC-q*U}&`cyXV(%rRT*Z6MH?i+i& z_B8C(+grT%{XWUQ+f@NoP1R=AW&26{v-dx)iK^-Nmiuj8txj!m?Z*Ss1N{dh4z}01 z)YTo*JycSU)+_5r4#yw9{+;i4Ee$peRgIj+;v;ZGdF1K$3E%e~4LaI(jC-u%2h$&R z9cLXcYC@Xwnns&bn)_Q~Te?roKGD|d-g^8;+aC{{G(1^(O7m37Y1-+6)01cN&y1aw zoqc{T`P^XJqPBbIW6s}d4{z_f5Om?vMgNQEJG?v2T=KYd^0M3I6IZxbny)%vZR&LD zJpPl@Psh8QyPB@KTx+@RdcC!KX7}kEo;S|j^u2lU7XQ}Oo;f|;z4Ll+_r>@1-xl3| zawq-H%e&ckC+@AhPrP6BKT#_XdT7&;F71j}Joy zkC~6lh7E@6o;W@^IpRNZ{ptLtL(gQ-CY~4mqW;US7Zxvm_|@yz&e53Bp_lTPlfP|z zrTyx_>lv@x#=^!PzR7qqF<$gm`|ZJZ+;<)Cqu&ot2z=0000WV@Og>004R=004l4008;_004mL004C`008P>0026e000+nl3&F} z0007eNkl|Oj;be#M^YZ^AZp`h(*CgC?r|h(8b(P zJ4thcLUc$RbubBbE3KxJPPywH*e>Si;*daY)I~0moI;hjd?(j7*90No@_4-O{oen3 z-}k=942MHZ!&pqon4kqolv4mQ08#+r$ChmX8i2ZC>e@tLNtELNssywE)M+e}ivmEP zLj^iOF-+YG1WTfvC4f!Nns2R4pqydqwlAtOMWh&}UONFMXcd5Mn0g}MYMQ>Qr~{}N zrtV0h+$DIi}AkC>LmM1E@-(EcmO!uQW|}I*ECL6xyqKxd@TE z6af*G?zz~J`I)Pi5s5}exvInh3%~)O8>ap~ zfLl5Lx`a@24x!{67%qmv>Qm(NONd4zNBRdb8Xi~!AP1=pha<|lySG(-Z%5g;9qWSI_-8xq1K=pre0*}8COVom0F`SfpUxCx%AJAyxMMeyndq@rd~YWHhHQ+ m;Xi*P3qab-6Em&P^zQ&jtM~(pyDWPE0000 + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/legoresources/images/Identification_Steering_Backward_+1.png b/legoresources/images/Identification_Steering_Backward_+1.png new file mode 100644 index 0000000000000000000000000000000000000000..89b66dd417e40bea0ffcfff334182b9fc4d68ab7 GIT binary patch literal 264 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|;LR7srr_TSthd+_2# z$HIjF|Ni#yurLTS_a0bra4}oIluZf`+cbHmA3vt-s9>74ko|(_27$yAZVKPrg}d3M zI2Lg)XnQsJ@gq))Baa(@=$Scp8c9TaYl@lD;T+Ym=mfLWK8F5>QUBZrzgZ#GD^hAC&)A~Ff;T|R!i7B)zKK}Kn71&KbLh* G2~7ZZfm!JQ literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Steering_Backward_+2.png b/legoresources/images/Identification_Steering_Backward_+2.png new file mode 100644 index 0000000000000000000000000000000000000000..5d9bf98555c81d42c9f1deb17d95d6b4f8e3236a GIT binary patch literal 263 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|*}m7srr_TSthd+_2# z$HIjF|Ni#yurLTS_a0brQ2Ay;LJ`k`somF^dHolJ2Apv>pEE0w$7oMu*u-#tlN!d3 zgC2g7jw}%#tDmSj^cP6fP{4zQD?7srr_TW_X3CU!7Bx$B|l*$9z}t_70E=FMB)%xEPPqHX+eBD=})k_0Eoqx;w|A3Bw| z(xk>vxrAeS^To>0!%5n_<*dzAxC}HDpfvfw z`1|Fz8hFY$O3=6^?QsRSs6p`3=n_P0b%fSZD1sp~z#l?2tYFT@@Du)ynTnj5-_~h6 zX6(k*aV8u_V0LC%T3lz=>bXhu~{{^v2-sifXH;4$vb9ZA5Hb@Ig!TS7-!iCaq|F`Ge4*I$FyU=%yc1FYplgKk!F@ Z0RZ4)g6evVyIcSO002ovPDHLkV1f=JsYw6; literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Steering_Backward_-1.png b/legoresources/images/Identification_Steering_Backward_-1.png new file mode 100644 index 0000000000000000000000000000000000000000..667123ee0aafe97edcfaf58b4205a0959ec569ce GIT binary patch literal 254 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*Jz1i(^Q|t)xHy|JySwK6vq> zV`0Yse}8*^d@(S*z|kXRll5W6!RA8=2|E=U`u#h*`4>oUF%v;_dCDreG z)~$%AO|nkBqqX3K{{ody1(LHkbh`NitV0`kVjYT}2zoG{?lcvd-Oc-9#Z@KMmlK6V venm`Dy14QYlZMNLpAPTq71U*!StJ;iEK|1H8F)|==qv_LS3j3^P6sWeDLB$ z$HI*N|Ni#;_+nsqful#t<_-^=+Iogn(mW<6j2>&3uR0ju{5;rHqoK_#;BVgdt&5-C*I*} z;$gLV!sPhckxe-{Aw`YhV|__skYSkPf`g1xq|SKwTy+Vvk}G0kW|3e}NnMk$aBF}b P(5Vcbu6{1-oD!M<-nv=q literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Steering_Backward_-3.png b/legoresources/images/Identification_Steering_Backward_-3.png new file mode 100644 index 0000000000000000000000000000000000000000..87d83f511b073b83786e35611b94e1f60fd76583 GIT binary patch literal 354 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|b$>rg;Lim$-X&?b2-7%|({1-uIk3C1{eSVtu_xDJg`=ojJp0wl uRh(I@!n?H>Z$H>{(C}AtJ%1gy0Yh4RTGE{3s^5TKXYh3Ob6Mw<&;$Sx8-ySL literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Steering_Backward_-4.png b/legoresources/images/Identification_Steering_Backward_-4.png new file mode 100644 index 0000000000000000000000000000000000000000..ed04e48020cfdd45d46507837c8d1e399ddd348a GIT binary patch literal 426 zcmV;b0agBqP)1~P%Tflh$0re{v2?to=aTMTZ#IL+cU?>D``M(e2 zPS^?Y>Mcc0b!|rp4wIxBy}%8iRya;wG#U^j7P_KgO8{a^_s~UM1)1DxS6qbrP0d$C z!n<5*H|b<^>K3#4jh!J~b}C6h$t1@>NO%~9l^~h632FbeD*&fY-*+7Cch8GU$TBFu zECW>4?h2Y5JPs|OXWDL!*CtM`xGMtNDS02Ko%S(b>P(L--+a+{K>D=*13v{A0QC@& UMb2YS=>Px#07*qoM6N<$g6M>)@&Et; literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Steering_Backward_0.png b/legoresources/images/Identification_Steering_Backward_0.png new file mode 100644 index 0000000000000000000000000000000000000000..74c6a248ff2a0553bb28657d612d1a14bb45ce0f GIT binary patch literal 242 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*J_7i(^Q|t)xHy|JySwK6vq> zV`0Yse}8*^d@(S*z|kXRll5W6!NqLC%o2rD^9~5TWtwnF{ZLQ$fl22YM8vHdOazTY zR`vZ@z_9BPGvncdZBADONW3Sf~{ kI2JI8N6zG>gu(%ay7gwkHT7ithJaF-1 zAcKdb0%z=v{q_IZCE8nAocS0w+S#QBm?j)>={XoM-GbqxYf|kImo-i+9$x>Tv9sY! zqKa8ht>We{fW zJ@CNv#>I<<4Pkn5{3bSyVUC9KcMIH{Rx+({Wbp81NMcu*rk-%{(BI$R)dgNZVpHf- zKNKL)!ETkpxKU3{ePRBR(4yZ5oS2;tKJ=M((4n`-qG^?&278wt>We{fW zJ+R_n!2zcpC3kmsMuk*{BmCdq-~ZnrVcWAKi1o?_CIvr+q)L^Q{SJE=JJcC;cREZu z=-|w|VAfMki#38770iKb&aqsd^z0`dv;=Y)4JU4IWN~&>kbfb;zK6|O^u}X@2TF2> zId@qwcB=)XSTgP9<|=noi0g3eWmatF-H^d_^dF-Dvq$}bXI43m?RgvQ#C*9YSOy%{ zJYRVvt>fU-r3*FH7(CV=2Kt^``}_=bcQPg;z|{TEN!GbH5``gM)!Zg28Y?yrn=C=MG>nFnGH9xvX$3Fx!rR;R0d z9Ez}HB?8}fK0o`2rfJ%&Vew`qTMhi;dzq%`D}KlgKN{d)ecwOkz>!pA014E<_sY5} zyu}7X5E#IO7Qpks6Mq0+ht&A807_ONna&GFfbZx&%dxf=OTi-Dm4zdVMwY?1Ld-Xb zY>WEa6}19ABDe|AV9T3!ZYhiaJ=st)$_QTI@23!-Nj2UHfsLoGt?=wks`0;OMrM)I z+mz8cP|){yX6o#Xs1?fqXi2fLrMzo}aEfjQUUJM|jiu2%AZrbNRK)I<^zn@*((MqQ zxZHvk;$4A2Qo7R4=!$8<6THjRONg6)P+Cs}2VL|$jz($z=e{63S%#G#p8-d{k11dH ghBs}NfPVxS09!qg0B>-wr~m)}07*qoM6N<$f(5m?1poj5 literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Steering_Forward_-1.png b/legoresources/images/Identification_Steering_Forward_-1.png new file mode 100644 index 0000000000000000000000000000000000000000..dc0f07a968c3c2823285c250abdbaf2fa2d62e38 GIT binary patch literal 269 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|++;7srr_TSu6v9Pk@ zV$ft}W7)Bx{{KIIo)iW#6T1@^{+?iRI6Yyfc;k&miPJMY3Ro_-B^m!l7ma{UeI;4t)nd++csiBGdMJ zat>We{fW zWvJyXD=FbwuMv<7=k{sT(M_)#Ox5Wq5l6rewJ9D zB?}c4_(QKd7-%%KJ=vxvD(RO67?B^6m`-h7v73|)qY3|vq0W-w?t z31v?D+|Z`KVA?|oOa8111%s^|0Z9hjW{wLUO1pKR4QyV?&%ngPpzLNO&-dj04WL6A NJYD@<);T3K0RS?1RX+d# literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Steering_Forward_-3.png b/legoresources/images/Identification_Steering_Forward_-3.png new file mode 100644 index 0000000000000000000000000000000000000000..13dc7ddf82454b8494c01b07708223ff1b678ffe GIT binary patch literal 370 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|<%+7srr_TW==6@`=fxD$yRkPB8sp2(DSqtB{ zDXNQ%o=cg0YcL93H0#&Ft?%zJ?5vHrzp|z0!HgRb2e0o~m$NM3`gPr{jm}BIc2@*G zYAtWP;9~aSNXM}$Ejh1w)%bSpeqj-PBJ9PAn#lCS#d7?=pE0 znxyDX=fjqs<);s#zVByKNIaWJCIe1FjM6k+VA((wZ?({_X`0UE6Ztp>AORK7t;6I9 z)wrMy1_o$}WgqzR0|kH!E?$lST8#iDd4<;Ar`!?E%VUoBF>Nuq?z1;=kAD&l_W zxZsJBYFEY10XpE2qk9u<>BU7X01q+`z{~_C!MElMZBY`(8^N&j@T!Hq^_63#6h-+N zn4lL#T3g8;)GKVFm<{s)&|Cmrd1nP2sz1PUwy`A>_RcpPv!j%ZcL@~HW{#?8#g^u- z`)!Z|RfKh}xq8;VIu>UIoQcbe4eCmkAs_H5oMRJ*yE|I?WR~B54SE`%%50+KLBKQ5 olIEPb#P{F zxWZ)OEIA=Y&tcQS0AGdauO0_1>OWtgX2h$SVWDjJQeuUmv!FqZB)f`izm!eZhZP4G fvk5aZF!3;W)vF%qseN4lbO(c{tDnm{r-UW|8%|1- literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_StringB.png b/legoresources/images/Identification_StringB.png new file mode 100644 index 0000000000000000000000000000000000000000..1521aa4aa9e2211d3c21e912d92d1f4007281613 GIT binary patch literal 452 zcmV;#0XzPQP)tz1~aq6Ki0IM5gH6cLx6m5E&-I;2goYZ0=sxkb4JE}44>jtP2%0r#9t zT=MaUAUh@ahmr%&==JbS$L#`BJRd2pWAREZPdqImN6WdssG3K((rf5clpBVjspD30 z?L^2^)$6F=!(~NJE{}Y>A%EagrY>*7zI8c059GD-_LMgq$U7-3ornFfO?);@#MGw0000A(b1wObWqwuo(KJ(pV_+Ac>x~sRzWeB%g~$dj zfES20zpZ0*yNvJ*Q8SAbwFpl7C6lS+&+w3>w?H?BE2u@*-v`!Vivz}N&mSJQxrDbi zw;Ko+=m7O8{0bNXPrzVG&R*YKl@nnWEr8X?hVFs0fVkvxIUv>(?Nbp{EqpeL=Lko@ z4s#d5FLUG=NM6=Ks+k zS(|;DjS@@0{Qf*1dq!DnN54@Xd^UZl*&ecxfwVUmn?t9aqDrJYffk*?*ql)gv_QR) zX;WHmsu<%MBMF)C%CeDl&WT5R;vp|+^5Elb{72#AmGwEAYG_e0o8e?gGbTRbF`A{tHvb?4 bBO62YMwOcdd5=~DoxtGf>gTe~DWM4f&iqW@ literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Threshold_Current.xml b/legoresources/images/Identification_Threshold_Current.xml new file mode 100644 index 00000000..61aa809d --- /dev/null +++ b/legoresources/images/Identification_Threshold_Current.xml @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_Threshold_Current_Out.xml b/legoresources/images/Identification_Threshold_Current_Out.xml new file mode 100644 index 00000000..39d1e401 --- /dev/null +++ b/legoresources/images/Identification_Threshold_Current_Out.xml @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_Threshold_Degrees.xml b/legoresources/images/Identification_Threshold_Degrees.xml new file mode 100644 index 00000000..9921c0fd --- /dev/null +++ b/legoresources/images/Identification_Threshold_Degrees.xml @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_Threshold_Equal_+1.png b/legoresources/images/Identification_Threshold_Equal_+1.png new file mode 100644 index 0000000000000000000000000000000000000000..0a60a336ce99d652c39e443fef1373694e4fa0e5 GIT binary patch literal 221 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*Ikri(^Q|t)xHy|JyU`G6*yG zGH{zYR$IGI+Ee)9LY>*JtqMY}JDDy}>TY}1{rUgjo>`Yccq!YR6cI0mN9+!78g$Mz`EJ}h zSJ^Q?VsFjy2fsh4HXHC&ip5Cr%iTKfabl^%D#nhdE2TtU{lBlvkkrbWwMpTf^Q!ib zhJ}g~RJj~#8dkAg)(P#AvdQ|e;-K=OggH+Q4O?yP4p?Nowuxa-IKbdPLFsE@&{R&K PI~Y7&{an^LB{Ts5c7jgy literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Threshold_Equal_-1.png b/legoresources/images/Identification_Threshold_Equal_-1.png new file mode 100644 index 0000000000000000000000000000000000000000..88b6663180ec701bf69ccd00f336d1fb5c4d657b GIT binary patch literal 220 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*J9*i(^Q|t)xHy|JyU`G6*yG zGH{zYR$IGI+Ee)9LY>|N zi_S1e_Vm5Yk!`qA&#ogeJ&Nb!#S_Xga?Gc1{tfXKbym_~VB%r87#$&H`|#{xprs6+ Lu6{1-oD!Mi;S2V^iEV!M)6Kmxc0*M~hh*I1CsL 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 PI~Y7&{an^LB{Ts5c7jgy literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Threshold_Greater_-1.png b/legoresources/images/Identification_Threshold_Greater_-1.png new file mode 100644 index 0000000000000000000000000000000000000000..19ddc9fd752cf1f49e02c1807dca11812db54a6a GIT binary patch literal 249 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4fk|nMYCBgY=CFO}lsSJ)O`AMk? zp1FzXsX?iUDV2pMQ*D5XW_!9ghE&{2`t$$4J+m%@axCw*?Zql5w>7taGhWoa@j*~d zLPmpP*~34qi*%Ed76?k1R$O@y*xY#F)l=)X**#AD4L2HB==k9>V`P`H_=? vw@AYehS(t1b0?IyZjisRs#A(V;Q)g}RA$CXj=PCKXEJ!Y`njxgN@xNAjaXj0 literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Threshold_Greater_-2.png b/legoresources/images/Identification_Threshold_Greater_-2.png new file mode 100644 index 0000000000000000000000000000000000000000..4baf5ef34e41fe9db345c19f0cc10068f9cb4bb1 GIT binary patch literal 216 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4fk|nMYCBgY=CFO}lsSJ)O`AMk? zp1FzXsX?iUDV2pMQ*D5XsytmBLn>}1{rdmko>|vGn7NmM+sv`r`uKm9S%*24_~dT& z-%k)QFfchFu)E+N(?zq3IvQ@ga;6nm9w_F1SaVo>Wxm0#g&~GFUOlxI_{z{B%Q5Zv z5vdoyKd3f;I3KUD&L)u6c4ex*=EUP3Onxkn+9lW;wCti78W@-vbQ5A*EnEW%fUaQh MboFyt=akR{0L$P>=Kufz literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Threshold_Greater_0.png b/legoresources/images/Identification_Threshold_Greater_0.png new file mode 100644 index 0000000000000000000000000000000000000000..e2129715e25e9f636a2313585584369d1a051e74 GIT binary patch literal 249 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4fk|nMYCBgY=CFO}lsSJ)O`AMk? zp1FzXsX?iUDV2pMQ*D5XW_!9ghE&{2`t$$4J+m%@axCw*?Zql5w>7taGhWoa@j*~d zLPmpP*~34qi*%Ed76?k1R&Yq>F6lpNx zu-dk{^hdw1jO6_U0Uw4(><)kAyJROkJ;}%Q_5XV@hK+}qOd|!pD_%YPW5y1F6GE&C vb_TQh+B*+g7;~&_{d*wH_X-08BOAkp!pw{}U5A)}&Sda(^>bP0l+XkKTlZX& literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Threshold_Gyro.xml b/legoresources/images/Identification_Threshold_Gyro.xml new file mode 100644 index 00000000..6ba57d40 --- /dev/null +++ b/legoresources/images/Identification_Threshold_Gyro.xml @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_Threshold_IRBeaconHeading.xml b/legoresources/images/Identification_Threshold_IRBeaconHeading.xml new file mode 100644 index 00000000..b75f787a --- /dev/null +++ b/legoresources/images/Identification_Threshold_IRBeaconHeading.xml @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_Threshold_Less_+1.png b/legoresources/images/Identification_Threshold_Less_+1.png new file mode 100644 index 0000000000000000000000000000000000000000..2e5b6d088fb933c07d07032170f74aaaf9f3933e GIT binary patch literal 260 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|-wB7srr_TSt>We{fW zW#Be*thRQaw5RaHg*vxIJja&K5OKetqoHATuwKKi5}?S*3RR!S4^M%^%LkA6d?obilAs(SVKB_0Zbm{43>-DIC7~ ze}6E;BW7pi&>kt9tPcsgFD{;DEn;{)VfAMQCLV@a=k@ftK5&72$KdJe=d#Wzp$Pyg CS6Y_< literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Threshold_Less_+2.png b/legoresources/images/Identification_Threshold_Less_+2.png new file mode 100644 index 0000000000000000000000000000000000000000..eda3e032a082c5f9b0b06b60c5059f8cb58055ac GIT binary patch literal 240 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*JU?i(^Q|t)xHy|JyVBGMq^8 z`oPO}kVT=6;RxS}M>;ojHg7LhdBMAS`g@5Q`F$w@#}v;uc`t5U$k=wH^|N>fAE#JR z^M@Hb1SFbc<`umD=v-2%=Jl8(Wyi1osmL!ir0z*JfT*>y7>>8j$7(8A5T-G@yGywqqC{x}5 literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Threshold_Less_-1.png b/legoresources/images/Identification_Threshold_Less_-1.png new file mode 100644 index 0000000000000000000000000000000000000000..22f8ecde1029a9e178998cff596c86c21af02092 GIT binary patch literal 258 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*K09i(^Q|t)xHy|JyU`G6*yG zGH{zYR$IGI+Ee)9LY>CXJ$#%b8U$UkCpVGb(Wi}aMai-*e0F^scei;S2V^iEV!M)6Kmxc0*M~hh*I1CsL X7{{$X=6n4d(0&F_S3j3^P6t>We{fW zW#Be*thRQaw5RaHg*vxIJja&K5OKetqv6IY$HW%Bx8``kcYAI`@gd2W+*z_3u!fQ{Al(AwktE9H(U z9KQO0e=x%%=EW~7W=QlH?^IkKS;X*o!s^cqOgs#wCVKkZE6#BO9mnA5>gTe~DWM4f D9Pe1G literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Threshold_NotEqual_+1.png b/legoresources/images/Identification_Threshold_NotEqual_+1.png new file mode 100644 index 0000000000000000000000000000000000000000..1b7397849a95f4e5a497dcd4722c1a170271fc5e GIT binary patch literal 230 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*Jg`i(^Q|t)xHy|JyU`G6*yG zGH{z6WcaTzY0t*Q$5w8Oc-RLr$|RK;%Ku_xlDyJjt@MvOFKP z!`BJO9y8(Y3T$@gl{2k~kUZ1m%@p2fY_VD`i=lymnPI(Cn)X`>FOY*7JYD@<);T3K F0RS!LKdt}( literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Threshold_NotEqual_-1.png b/legoresources/images/Identification_Threshold_NotEqual_-1.png new file mode 100644 index 0000000000000000000000000000000000000000..740225ae612551cee41bf18fd1de934a997bb066 GIT binary patch literal 228 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*I_$i(^Q|t)xHy|JyU`G6*yG zGH{z6WcaTzY0t*Q$5w8Oc-RYEVHW5tP%3`{%>jhEBS U6=Jtt1zOJF>FVdQ&MBb@0P1B(zW@LL literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Threshold_NotEqual_-2.png b/legoresources/images/Identification_Threshold_NotEqual_-2.png new file mode 100644 index 0000000000000000000000000000000000000000..e7a0d2bbe411ba8befa31d549315af67d16f5a8a GIT binary patch literal 217 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*Iwvi(^Q|t)xHy|JyU`GAPIL z@_pb}I=PKk`nutw?u`$E)+}D!tXTH+l;|Se07qH? literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Threshold_Rotations.xml b/legoresources/images/Identification_Threshold_Rotations.xml new file mode 100644 index 00000000..1c21ed19 --- /dev/null +++ b/legoresources/images/Identification_Threshold_Rotations.xml @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_Threshold_Speed.xml b/legoresources/images/Identification_Threshold_Speed.xml new file mode 100644 index 00000000..d0e72554 --- /dev/null +++ b/legoresources/images/Identification_Threshold_Speed.xml @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_Threshold_TemperatureCelsius.xml b/legoresources/images/Identification_Threshold_TemperatureCelsius.xml new file mode 100644 index 00000000..1619e3ec --- /dev/null +++ b/legoresources/images/Identification_Threshold_TemperatureCelsius.xml @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_Threshold_TemperatureFahrenheit.xml b/legoresources/images/Identification_Threshold_TemperatureFahrenheit.xml new file mode 100644 index 00000000..d9af4fb6 --- /dev/null +++ b/legoresources/images/Identification_Threshold_TemperatureFahrenheit.xml @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_Threshold_Timer.xml b/legoresources/images/Identification_Threshold_Timer.xml new file mode 100644 index 00000000..b6f29ee4 --- /dev/null +++ b/legoresources/images/Identification_Threshold_Timer.xml @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_Threshold_UltrasonicCm.xml b/legoresources/images/Identification_Threshold_UltrasonicCm.xml new file mode 100644 index 00000000..d6cf27d7 --- /dev/null +++ b/legoresources/images/Identification_Threshold_UltrasonicCm.xml @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_Threshold_UltrasonicInches.xml b/legoresources/images/Identification_Threshold_UltrasonicInches.xml new file mode 100644 index 00000000..17d31819 --- /dev/null +++ b/legoresources/images/Identification_Threshold_UltrasonicInches.xml @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_Threshold_Voltage_Out.xml b/legoresources/images/Identification_Threshold_Voltage_Out.xml new file mode 100644 index 00000000..0f32f309 --- /dev/null +++ b/legoresources/images/Identification_Threshold_Voltage_Out.xml @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_Threshold_Wattage.xml b/legoresources/images/Identification_Threshold_Wattage.xml new file mode 100644 index 00000000..9907d522 --- /dev/null +++ b/legoresources/images/Identification_Threshold_Wattage.xml @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_Threshold_Wattage_Out.xml b/legoresources/images/Identification_Threshold_Wattage_Out.xml new file mode 100644 index 00000000..80afcaf8 --- /dev/null +++ b/legoresources/images/Identification_Threshold_Wattage_Out.xml @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_Time.png b/legoresources/images/Identification_Time.png new file mode 100644 index 0000000000000000000000000000000000000000..605b6e32e8ce38457f99df79802f0c7c17d60b7c GIT binary patch literal 482 zcmV<80UiE{P)=6Qpes5sj zNE76>C-$yTB0V{lpPwghW*p_cuap7>sNB9)wa~LZf^!QPK=XVATxpY< z^B5M8SO?TBwBx0k52ASoOXNdHIEFE%2ljxK)|q3O(@X0~#E7)#h+0ImDU~}Vtwh_g#MpDN*D5*pg!v}ByJPD!|@71Sv-WhOtO6P^b zBNu=2Ai_@!cfbqqNXZjuHESfo2ObIHd*B(buvo6lgF(&Xz_YU!15fm`; + + + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_TimerID_0.png b/legoresources/images/Identification_TimerID_0.png new file mode 100644 index 0000000000000000000000000000000000000000..7c4f79ac04d836f0cc3d9fc49eeeb604cf2f6792 GIT binary patch literal 591 zcmV-V0m*pD#UEe_IyfeyP_TloQfG%|b8LP>>L0N93n~bX3Aj46 z4h{}tDGn~0P9muByKsrGF|Uoq9(?5W-QD-@?%lg;K@f;pNM5BdO*8dG*LAfl#5pk| z$&bz7M9IXM;u9R{p&s#g< z<5VV%aovDTpx0IfUQhdFJf%eeLm1)LiIH=CO`*M~CqN)D#_^Hc-o}%wcUGld< d|6lSgzyOP-&2M&W7BBz+002ovPDHLkV1lvn{Y?M> literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_TimerID_1.png b/legoresources/images/Identification_TimerID_1.png new file mode 100644 index 0000000000000000000000000000000000000000..28d1d248a5e79745ffe28455b6c15517c37aba25 GIT binary patch literal 630 zcmV-+0*U>JP)P>xB2HQ*hXhwn`KZnT8W z7dXsQZAxmwZP|V);z~)$W76+5FhC`TjkcJS>Uf<tSz zc6uxlcjq34R+eO}&M_TghqD$wDUN_=U>YZwo=MsAH~S{Up+!x zQo3?kp0UOa)UxrHXVZJA_Ny1kC=H^8{pWG3s}DV8UstN+cMtu4*{1*l0F5mY`E;9w Q%m4rY07*qoM6N<$f>6^9ng9R* literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_TimerID_2.png b/legoresources/images/Identification_TimerID_2.png new file mode 100644 index 0000000000000000000000000000000000000000..0c69ebba6a29c69996df7ff047f13e05327bb5b9 GIT binary patch literal 665 zcmV;K0%rY*P)nIK(yTi$>y&*a(mc&6VO3J7JGu!6ZH&&;jfLzJ!{9ByhqwELn?13_>ns@=qWK zWU=@-v}q?k8DIw31SXN=zh?zWU9LxRG2-C3Q3f02@g=e(k5nw>uf9cErE4gn08CZ0 zCFlxznhQv=$P;TKhvepD?dx^}!LS@u*7BNj#rMdC)D!P3t#DnJ!C@#!S!I%N2Y3V~ z5Ze!8XHJ_Z2iPc6Wr}Lo=U&)~Caa}_GWmN5Xkg1>qZJ`#AJ3Dtra9m>8_Y{A_RXW> zd!SX6ChG?J)wkWhs_pW?p!v^okeig87h+#jtB@7jz%B3t6^u&xW?V1-R_86<>Skk0 zHB65yOMS-fV^bavfPE^YMN#Wo7r?B(`?q6$P<5iKLzU+i)zekkwxyzvkEP)~Aypw# z`de}L>&J#vZEufJe9zq` z#ly}x7sQGB&y%ZeKlD^zLKUSCJ@lV7o&^{HwpJU@OE(}c00000NkvXXu0mjf&>beB literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_TimerID_3.png b/legoresources/images/Identification_TimerID_3.png new file mode 100644 index 0000000000000000000000000000000000000000..38bc150c94e9956acf2644330e29b63e3606f270 GIT binary patch literal 615 zcmV-t0+{`YP)_8vA@6+bZ|^Zp8I@S^YYYjBm`q>+XaOBIB>)X*lO2+rL?Q+u9i+``Km{n{@V)QS z3?>8E0nUIT_H;%`L8LmJ$7VYuadeS^3+k8&Wg-vtn8QCFMjB8x}D|~ja+(1y^M3p^S)0#bsoJmdA{OwAQyvHT(u-C#T#X0Z>tRR974!=L9mKH^_x-UNN+I~k2FENFn$pkQ| z&ED!Dl_9#}r)o#yb?;Doy>$J=s!NQ6b#7C`Ln@ebpsP}~>QB~jL5xANgms?D4dQlG z04cer_AVRZJ*kG}q#N{B)VZY#LEXoRDS6jq;+~dQ<U%295!TO%WgpT#+3u*$qStLOMv!<3JY3;P9m< zXb(OqAPMXP^YC%LYXy;7bRNzHpNpeFDFn#jOUMwpZ^m5yPCe2ZQ$tDQfrVOaQBy%Z z%_>qHvbiQJ4}mf;2iu9V z-58xVU!cjV5+&6oZ*6ZYBHBo)GU@ji5T=nspe-h)IbIF5nkFC^6kwHYfj5sbeg!%> z(`K2T& zKRVJ$uSwD~Y~}x>M~Fu%>XwR0&@PSS7_%Jv&9mt~RC|T9o*)Zi`2FYcs_PFuWna{$ h@002ovPDHLkV1nWL5;Xt- literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_TimerID_5.png b/legoresources/images/Identification_TimerID_5.png new file mode 100644 index 0000000000000000000000000000000000000000..67ac0a90fd53bfc485605b816c24666978b9f6eb GIT binary patch literal 651 zcmV;60(AX}P)chQn89EHoj?h&#nl4DfJ^p6lFdNGAmoJ{JOX5a3>IH_ zHtoWY0v3Q>U5}erE55e0x(-m7S$E3 zX;zV9ktNdjn#5*h?bmh#!KfTmM$?+-ir1S1J6J|Dj1jYslK;|TGvcn$vMb5esk_ zkL%kGTjkz%?DVpu<~c^i|L75tmWruX(=uf%p_k*oc{bgLYO8qK736{#e*bxL)%Ay- lvp>?hJP);lx`%Fr6ydCRJBmlvn1Gd>0`Q}l^AHV=- zY9@BK#NgA72OUe4gD^Sfhq%I73!fC{z#A}$3KqG1QQh1T4}D`2@0SJf^<0%JTUsZk z5=_+qCUrSm3#6( z(eTglIzKvjKdIJzY26!ZqHSUv*&d3pm>5q%j_*E^x*_*p&N*e-1!B_m_2@J(rs+qB zN6I8}O;=?l$dLTYvnd~{6Zdu`$^|jP{`2^%>kmC;U(}|gxrhG0>|1~V0ACXBqyZq- QNdN!<07*qoM6N<$f(ft*nE(I) literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_TimerID_7.png b/legoresources/images/Identification_TimerID_7.png new file mode 100644 index 0000000000000000000000000000000000000000..850b9741c5344b239a16dd5869e5c70bc202af0f GIT binary patch literal 654 zcmV;90&)F`P)tOGO23MJo#n(+M_SX_?rWM)A{V6VXl~ z!PG*uu(0ymCMW&{UEi#;vN?0{6dibMZfExG%-h+GC8ZSqVIe<9EEX%fVo-v|)(%;kd;TV9PJ!2|{eXa|k}mtBoO1UM%@Bv}bW3_@B+!9ze2NMP}qXVVT0 zabO161||^WekTQy+O!_QS)YTWjpEoKjggQba^H-({N+ldWx9rv$N-b&WYJwgnkF?V z7C9`9uW@XW*M4m`5DfD{B@C@;F8duhlRB(@sT8(tlXDmuM2#|uFbBK>+ z@BudP)D0!oCa)c@6pcnp=`!hi0H~vu!$yltN_{*}q*YCtS8XuQzQ8w+GJXbHI8*9l z(Y(1NS_>x%4GVKRHo`HV#4cwoJW}iek3cUf80GRscx*tSI5jICwsu7Q?6felkDJ6) zLPQ?`lV&+v8>D%oWbw406EBCyD$|<&K5>^?7jMNIQ zCJc`as_#mDJj0Jp+J{u7RSOxY^k-y#pW0Brt9!ajVwBO%BcSclfD71q&cuaiaR7PM z)FmJH4kX!Y!Iig5Ym(*}j*kD)Bg8GGI)gGbv?V)2FGqj#Y^sN9HGA3-|KBX0Kp6sfYqr-6aWAK07*qoM6N<$f_}>lCjbBd literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Touch.png b/legoresources/images/Identification_Touch.png new file mode 100644 index 0000000000000000000000000000000000000000..74c037498d7af6999f1a0781c4856af27cde9f6e GIT binary patch literal 233 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*Itui(^Q|t)xHy|JyU`G6*yG zGMwc}Tj;X6xtZC^Le8R~p-_VLsIS{X69rS@Q>KCc|G(2QTd!O_J3@T_a`%8ciQ75ne#`*6fWgz%&t;ucLK6VE6Hjpf literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_TouchState.xml b/legoresources/images/Identification_TouchState.xml new file mode 100644 index 00000000..620d112b --- /dev/null +++ b/legoresources/images/Identification_TouchState.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_TouchState2_Pressed.png b/legoresources/images/Identification_TouchState2_Pressed.png new file mode 100644 index 0000000000000000000000000000000000000000..10d38a0d5ec948cf40c81463eac8ff4f95c7e11f GIT binary patch literal 235 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*H`ai(^Q|t)xHy|JyU`GCV$E za^v7Z#-kIM+4&5N3@>n8IFlgewU_Uc*-gD|+lxgOga*hcTrEiAy{3M(K#a-pgM9Zx zz9UPPHhSi<^S@1JN!0kRq~XZ$Q+|cyF%?O#u7f~g%fTg5US;PFPrc1%7us`8A%u~E bk&U5ft<||Xe%s~&-N4}K>gTe~DWM4fRDVs% literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_TouchState2_Released.png b/legoresources/images/Identification_TouchState2_Released.png new file mode 100644 index 0000000000000000000000000000000000000000..1e2ed7a4e7ab143d46cc260a61af6aa53d23b99b GIT binary patch literal 235 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*H`ai(^Q|t)xHy|JyU`G6*yG zGMwc}TiB+^$H%Afu=2qH#$$p)A}8Y5D`)43-@a|h6=18epiOSUs)HVFuY%7elsGs3 z`LAG8QGD;9^KbhGAqIi?mQRw7Gqm*F%;&6H$#k;d)pMH_54W7J+);GFVdQ&MBb@02FFZYybcN literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_TouchState_Bumped.png b/legoresources/images/Identification_TouchState_Bumped.png new file mode 100644 index 0000000000000000000000000000000000000000..66b25abfca581587c62f127a5e38b8f6e3103de3 GIT binary patch literal 275 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|*TU7srr_TSt>We{fW zWjM=|wy;f+kB?8|VdaAZjK>6pL{7x9SI%D0{r0U4>juq3s(v8>4yN)47QSOx*=D>@ za#g?cT)UNRn-@rPJ!wAt{=ve(JqBj89`YSoqIyf!e8FkE1|_Ku{X;QahhF5Y*uxxR zTd3z|F2k*GGGNLA2P2v6OR7f$dJK*&of+bM@?7PPqT3hr`X$|0t4T0$7%=pEdS-cF SOMDD;D}$%2pUXO@geCxJ{$Pgy literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_TouchState_Pressed.png b/legoresources/images/Identification_TouchState_Pressed.png new file mode 100644 index 0000000000000000000000000000000000000000..10d38a0d5ec948cf40c81463eac8ff4f95c7e11f GIT binary patch literal 235 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*H`ai(^Q|t)xHy|JyU`GCV$E za^v7Z#-kIM+4&5N3@>n8IFlgewU_Uc*-gD|+lxgOga*hcTrEiAy{3M(K#a-pgM9Zx zz9UPPHhSi<^S@1JN!0kRq~XZ$Q+|cyF%?O#u7f~g%fTg5US;PFPrc1%7us`8A%u~E bk&U5ft<||Xe%s~&-N4}K>gTe~DWM4fRDVs% literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_TouchState_Released.png b/legoresources/images/Identification_TouchState_Released.png new file mode 100644 index 0000000000000000000000000000000000000000..1e2ed7a4e7ab143d46cc260a61af6aa53d23b99b GIT binary patch literal 235 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*H`ai(^Q|t)xHy|JyU`G6*yG zGMwc}TiB+^$H%Afu=2qH#$$p)A}8Y5D`)43-@a|h6=18epiOSUs)HVFuY%7elsGs3 z`LAG8QGD;9^KbhGAqIi?mQRw7Gqm*F%;&6H$#k;d)pMH_54W7J+);GFVdQ&MBb@02FFZYybcN literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_TrueFalse.png b/legoresources/images/Identification_TrueFalse.png new file mode 100644 index 0000000000000000000000000000000000000000..4e42018fed71ddf7ef1076d7d89a970fd53cff66 GIT binary patch literal 458 zcmV;*0X6=KP)f36<{Wy1_A$_4#Yi$Rx7t=n+{QqE1?$*-@B962&?z*R&mei93LStE$Vz$S7rE}?YsNso7JKZ<%rA|zub__B z7w=ORdMn&YHG*56(4L^eo}7FHw6<@dEL&FVdvK0@Jtd%pCW2qfH<7>b&T-6-(qq)m zIFmC$XZ8f;DNs!hlNZp3ptK7c`VAa2QtIgjI)>h5H}1=qkAT`eJ#%_q4#4`G@xy=U z=}uR^^!Vb@3vE4FB;RP|`wh@Y+m);#I~XAc z_FXylZ^jg~VMsCn!j1%$rN)4aC zQF8kqkti=Qf0vsG5f4HMXosNWI~ianVBZ4shOyRC1gL3H>IZ{pU|$CLGhzvF#d|9P zFslN5xYAi6%sHn;EDy!clmLPI^z!WNY)Md2TUT6SQ3p!AFQW0#L4V zx7uyG)syzv)Lc`k*$nmVAf|&_&Tzi77!OLsOlnAFDW8^~n#{4)=}a_Gg05Iz6~305 z6YHe-s9zMsj~pYK)QIJQUB+TWX#P^MT5qE!UIZcIU7xhWLC>!Vhfq-B>PZ-({RX^+ zH(t~L{W@Cnmd{26)i2apza~|dRBNaFm~^&AtN91vz&#K2!3Y`Hx3@qy8Q)_43NQc; W#n585TcQu;yAwNcOO10Yi;xw&)HDJy}F2hO+267Cc<($k>v}ObdsGz;vm31e3uMiC z3A^ar0ySWy|82#ju!7QMfTj{JPLRcH5 zWcLW%W30P~s{v`srLm$wW2X(*B|Trj6w2#RW)6jh&5>f$SeN!8ZFpNB9S{(a;%5TJ zWgkYUjrkxIVpX_|^1`TxYF7!xPrV{%w@iRq!xiz+79#bEL*s!_$+hiE7#;l==|Cx| z(Q|E*YZEf0E(UB}av2j}KT*CLgk4QJIb)uFt>We{fW zWvJ!Zw!K)zGA7T6>+kZ_-H|7*cDxCai2nQE+O3PXO_Iq-* zz4;7B*c&VueQTHm@)?pClVaaAq;Z^C#A)E{FpW`jf|Ni#(?&LPhC+rb3=`aHHU2Z6 z2%7QKVGm;mcS2UD;SYvMj0(Qe{BpPcGiv2EsMIlN)G@wdU~OV!7PWWyw2t|T!;DtO zfcP8Eu|4kunpP$;o4jGVz!TPRDz@cU6Qia_hmph*fhC2EXLbiPC$Om~{1gz`DIQSL zd@5OD+vd_A{b!c5TwX7rwETrjcSV6;ip<(s2@DDc7$!fOarxC98(^?8FnGH9xvXR$LVbP7D&R(KCTlu|S8bUIBQ?(fJ=^Oj7fQ@=Bxz!zX!Rn@n( z83zM`#cm~4?a2VuDSZ^$o4Rpmi=5je&C=}RiHe;HmFq+kdKLQK@Kicz`Mrg}?00000NkvXXu0mjfTVe0U literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Value.png b/legoresources/images/Identification_Value.png new file mode 100644 index 0000000000000000000000000000000000000000..6c2e91e37006449ec0c5141e0c4a9cf1fb57fd3f GIT binary patch literal 206 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP*Jp}i(^Q|t)xHy|JyU`G6*yG z9=KpUqjdsPwYB@2i3J}n)VX!>982TSJN-gPr02v*-WQWt9kk~8Y!+jxoz`&r=tmI? xqdF7Wekq$fym20lk=%u8FE1J_<7D74V0gDmLUjR0?LDA144$rjF6*2UngG&0L5KhV literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Volume.xml b/legoresources/images/Identification_Volume.xml new file mode 100644 index 00000000..f17d6378 --- /dev/null +++ b/legoresources/images/Identification_Volume.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_Volume_0.png b/legoresources/images/Identification_Volume_0.png new file mode 100644 index 0000000000000000000000000000000000000000..79a0acb8f90a3f6671f224e9634c433b5160599f GIT binary patch literal 189 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4fk|nMYCBgY=CFO}lsSJ)O`AMk? zp1FzXsX?iUDV2pMQ*D5X;yqm)Ln>}1{rvymp4qfvX{%|MqYuv&W`$&M8DBVc z^o!w))=M5%b&oWZO=Eewm;67h-qRkqO2O>g$x_3EH{^TwF#3p2IcBFQemLp>`HXYF k`9{>OV literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Volume_100.png b/legoresources/images/Identification_Volume_100.png new file mode 100644 index 0000000000000000000000000000000000000000..fef483934d73197fcb51479115bac0e9a3564378 GIT binary patch literal 204 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4fk|nMYCBgY=CFO}lsSJ)O`AMk? zp1FzXsX?iUDV2pMQ*D5X@;qG}Ln>}1Z86!Nv_R-b|CvNa!Q*~1OK*f|b7!;tXQ*%M zl{Rbo>BD2fZFE`hdoTio0T$uw0<=35cfT?VG!DenRlk`hZBU yyf=?a4OKVV*BqK57%}soyZGTS%Sl>%0tpN`J<|Suy*wayGkCiCxvX}1{rUgjp4qfvX{%|MqYuv&W`$&M8DBVc z^o!w))=M5%b&oWZO=Eewm;67h-qRkqO2O>g$x_3EH{^TwF#3p2Ic66p{`>dui)tGG z{{DBDZvOx8@96^`-E+3*zAmfzDzWjAh9sxL0S3KY^7lSBv*rV>X7F_Nb6Mw<&;$U% CNKi8X literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Volume_50.png b/legoresources/images/Identification_Volume_50.png new file mode 100644 index 0000000000000000000000000000000000000000..a7206913a929b3182dd4ecd1f2cf3f179bf0d578 GIT binary patch literal 242 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4fk|nMYCBgY=CFO}lsSJ)O`AMk? zp1FzXsX?iUDV2pMQ*D5Xrg*wIhE&{2`t$$4J+o=U(pJ+hN1v1#2Roeq*oX8@jA`!t zq$JGT%W#$_ZK27ezWElXJWR!%d6SQb-*eXQX%AerVcRBFcOH$?%?9gksGmMsSGVs9 zKUc&qxPffUs-ZUTB_}E=y<)fqtjT>$(56f*561id`@-AuC(>=V>W=hky o7np6b*k>fUQm>_(nMH!(1-orVe#*h8K=(0ty85}Sb4q9e00!S$ZU6uP literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_Volume_75.png b/legoresources/images/Identification_Volume_75.png new file mode 100644 index 0000000000000000000000000000000000000000..7f9946217432a5d6ebfdad5ce15dd7fa9187b219 GIT binary patch literal 219 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4fk|nMYCBgY=CFO}lsSJ)O`AMk? zp1FzXsX?iUDV2pMQ*D5XYCT;XLn>}1{rUgjp4qfvX{%|MqYuv&W`$&M8DBVc z^o!w)qo)qdnzNy$Ia$5WD9Kbp%X7<0h4vrpKa6wkY$%-3`cc3~v_h$K#SQh-M;F|X z@7;57uGT;0>EcU{*~N(m3;jN<-Xp1dcI}1iV7Hv7dU}Nsa~6azV_;-sC`(sNkgGf) Q0(1z2r>mdKI;Vst0N?LXumAu6 literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_WaitForChange.xml b/legoresources/images/Identification_WaitForChange.xml new file mode 100644 index 00000000..5feec482 --- /dev/null +++ b/legoresources/images/Identification_WaitForChange.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/legoresources/images/Identification_WaitForChange_Both.png b/legoresources/images/Identification_WaitForChange_Both.png new file mode 100644 index 0000000000000000000000000000000000000000..d4333191af92fe9912a0cd9109567bf1da126efc GIT binary patch literal 404 zcmV;F0c-w=P)%Uio=IA$LrTT@1T^5*Lq-46t57mPh1 zMknG(0No(n695S{*pwH;*NhV>6xT<}()5}1fz5B!(Z1mhw5>T8g~!-yO6zWcTE#b- zvTJVut7(*-0nnloF^y)$IHUq-rH{8+iap~LX?5phFBxeyfn`s}L+M2Nmb9h&;@np% y+uBUYftyCvj|`D!V;6nQEc*OEe@$cMDZl_u{D~K)mjO`#0000fJv}@jc<(|;RPkT z6o3j~VSrlnte~^w5#wMAbDCJv43VF;U_e8d*UWw$0MB)$NEUnuiL%DjeUAaSQsd<1 z5n~W>z<^$mu81tvJP%Z0mjO)?m1xpkbH*K0UM;2Dhd!1_x}~)0IZ#>BLP59R1z;^n z*_r??2N9Dr8;wK6fHr-3%cY17-L6N#F-Ouuft8};K3CF?A#Luw$W)~=jm?N0bZQj+ sNJudJc`OYk)u7L34f?+HUIzs07*qoM6N<$g6q|rP5=M^ literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_WaitForChange_Up.png b/legoresources/images/Identification_WaitForChange_Up.png new file mode 100644 index 0000000000000000000000000000000000000000..4b2da864700f9a51c47ff9b26fe1ae3a985dbb0f GIT binary patch literal 384 zcmV-`0e}99P)75D@2~MzyOV5o-P3JF;twO7wpv>6~#{6wq-pf{vj0w86Irflyxkb>g-PFa5Y1mXtaKtG(XX=x5rJS(`OCt>Wq7>e z;9|C92DKO=#($1XEhdkH54SisGfl8^XgSQsa8*hm)gT~|VZttkBfnfE*6^F!Fswi5 zz{=~8Wh?M`vcMdLt*;kW1uFAPg>g6Bn19H^nxp7`TkmT-gFs8engg@$EV#F_{bQq< zv5<%8iOj76E9#i88L)XZ@RYGU>Q~tzwB(xL&44v4nN~1NIpg5@LP@Z#>57EI*Pdyj gi`jr)V`O9az9VYt6%n-)K$kOky85}Sb4q9e0BU4nWdHyG literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_angle.png b/legoresources/images/Identification_angle.png new file mode 100644 index 0000000000000000000000000000000000000000..16174937242e7c67cd08399850643db544780eb9 GIT binary patch literal 274 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|t>We{fW zJz!vHalrnCy?}K^3Am-o+eZEWx4X@RHX-$Kk92o1_H85%CpL zA`b5#muLp+?K`P4jo}E>7LUBojXxMKd|--Nl3b_oj$LYBLztw>JdwkmzM>zGuyI?S zT-!K^+!GOA`f<~UBE8tq>?7#wunbg_r*#s1|}YcyX&<~zBEqO Q20E3&)78&qol`;+00FyLOaK4? literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_x.png b/legoresources/images/Identification_x.png new file mode 100644 index 0000000000000000000000000000000000000000..3513b2d17a7ac74b0cee1c1e2d0e415fd40995d4 GIT binary patch literal 332 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|;0K7srr_TSt>We{fW zJ+R{77V{ab(_I?sCol_rKiJm$TF&7pYr_=ANq1Nm++h!jxx;Ye_rf0xR~!UpG^p%j zn4abq^HL(~0;|Hbb}n6(NQNVy7yjvYc*9WgmUR+On-t%tPn9Z)6B7Rflqp@fz?$MJ zcg3{R!^yx|{E_jL8zCDRUj?OXXplOY%RI^ZVUov0&s_%{&Mpv1=oi^1KCvlv=Lx3(9&WMf6-SS#o3Ai;e8}0R5z_FI!O6&@vyZDUGLvtvYMi}N;?j$E*KU3M_05l% zwOfPTP3Fvct)&7G>owz6H7ttxDnh2icy|H>-dw+k~!1vDIw zk-lLpA7xsd;2{&ow|=$0X4mu^evK{6oh$Bholg#KVANc!ni7~F+xSS}No@{$#L|KT zeTTGaWEjFHdHH;B3T55+;`XLi-P{Ve|)PWpNWTI Y%AX`g?#_vEz>s6`boFyt=akR{09|O6`~Uy| literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_x2.png b/legoresources/images/Identification_x2.png new file mode 100644 index 0000000000000000000000000000000000000000..fbd140fc9516ce70da398dfdb0fa84ccc2168a34 GIT binary patch literal 435 zcmV;k0ZjghP)|ME&_T!zZg9=XRN(xv z{z!`n>wx3~QbroBHJ*7p`ZKmE%Q9%gIzdZzec+pO3)18{#Ljt?i)1GuQ9VBv^e=X80_8lVw#)!qbpv=!)Fk_MUt zXx0F=@CSyz0F6)Wap*ip9%xLdx(an9JpA&|?JJH1zF=a)SRFd#JQO+?s7i3~fdHTb z*t1jVe8u8NNU|hUH^pnX#B>042aw8I!DanaUyGdZ7peUJ3PO$w5YKB9cUQ2{%>R%6 ddci*e3;;pDevDKyQc(Z^002ovPDHLkV1h(qw15Br literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_xColumn.png b/legoresources/images/Identification_xColumn.png new file mode 100644 index 0000000000000000000000000000000000000000..a0cf60a85fe623cddc4cd755d22d10ea10fe7ec7 GIT binary patch literal 336 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|;ma7srr_TSt>We{fW zWw`Tz;lD!H+`b&Px3M-^2Hbj`vwM=b9I_avL@)UF|0?T>9n2H57#{IEY-E@e%X8%m zgGVkyQuPE@2WD0WiL9BnA$@xmFi6=kdgQVs)vnNXY&*sL(PhCMrcF&uoGJ_-85Pd8 zf8uB2)m>omsiCc=L5hc2dc`EIhKEuNrEgso{&5`n>tM*-#nUFWfkD$lXu%ui3mqzV z6PAb^;6Kv3;0fE21qm}aL~lEIJ`r^|ENR&zozT{#(|(NcBU^H($(~1xTLt_MSUh=U d)4;&Y@JQHy_f<2;KR}N%c)I$ztaD0e0s!dXbuRz_ literal 0 HcmV?d00001 diff --git a/legoresources/images/Identification_y.png b/legoresources/images/Identification_y.png new file mode 100644 index 0000000000000000000000000000000000000000..3daef419533ee5a54e82d40a502a2b0cda201dfe GIT binary patch literal 327 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4foCO|{#S9GG!XV7ZFl&wkP*AeO zHKHUqKdq!Zu_%?nF(p4KRlzeiF+DXXH8G{K@MNkDP|+1n7srr_TSt>We{fW zJ+R{77V{ab(_I?s0~kA+iu7}C>{!R(na4OGsG&%m;i=h#M~|2ta`=z_bU4hipsk6g z$9t>We{fW zJ#fKzMyt?S#($3N32%6%uUiJ>7+i3epvdWv<8LbN9GmGM5^yI)gt^-J@Bh`zCnh-* zvMR71;%_M8Khe2|)nSi(MgYSsn+TZ>*$Ib*IwTu?+>?0Oev6#ls-R!bva5`7=SkjW zhH@DT7-p#opYS_=;lu5Yv;?MEOH6W!5QG&-Lfmy?5A)DWVBU=>? zbj0jpjO8*ikUv$+vBjscr{oQXk16|w(_NeqO>M7IS@oK^8zLC`_i-l(iHI1~G&`0s z3jAk(#Czh=lY}n|7=; zMmCq2IFm;-qq&?;x6-X7C$!cEhma^ZkQ^WI$(T#&?Olw;C{tUMFRk_ocPSnKQ!F#+ zh3B}Y3j%zPp~7qcrA(m3J{Q=Xme#hGmU_=%CUemK5#On7t`v{llT*`i`YbEP^OEJlLu1rOzDm*yRN{Cl1}k(nUR)s0;n0vRx)iB=tAB3(-noH!#T}7pi{~8 zR7|8X(FN@c2r|9I@*(ZSOC?^C_CU$!gJ&?bGzgNdN18t>We{fW zW#H}+d?4>4x;+2Jjy^#bW4@gW7VJN0E_sxx;fK9|{Q;%#j9SYbHXVHRKR%Zsh`%vH zE~9~Y(n3y$F8K~~rmHpz<{D-WFIiMJGHC2&nD4e{CDW^`za9PvzOZ6ch-Wxa$N!0Q z!g`0YCyslo1fG;;2nalln!?k>-oUf5T}sPg%|Vw`fdH)rHwk8wOH3=K_DzhnXq+Ya zglP(!>n+ACsThZ@>`o(zS(aZqdrg9ZST#;sGJRxEFsM$B>F!NeL2q4T7C(`HwJ# zm`JBwb1QMI)~aU6lM}XW>h8Q(c!>W9TZqYTW`TH_30GX-c7!uLYCWu7deL@ATZ&K} z!x8?Cu2<@{9{qY4zGlM$QD*iPGV091nJ1YGnMBXBwVpb7@rvn>$1Q0L3I`Yr^GyE) TY?$f;w4A}y)z4*}Q$iB}lI%-I literal 0 HcmV?d00001 diff --git a/legoresources/images/KeepAlive.png b/legoresources/images/KeepAlive.png new file mode 100644 index 0000000000000000000000000000000000000000..3b5db2b66953b28459d9ca257b8089e7aa968dcb GIT binary patch literal 2093 zcmV+|2-5e7P)O2M3tVV8nz{GP_nq&2XGXhn4hdcLci_=M!(qJX z9fed1TQf7r%*`RYuz=+_bQ?T4_r&9&(F|U9Yotch$_jc!7;OcTn*Ak&P!%5|D-&g6`0v z>pC0`hXVE=gWCM%7c71A4YnRWtjE_h;TRf%mP|tL?}sB4!lS2i*j`zMscZ1>72uQT z`FD2U5uSKnJVz;?M{RNv?y(6tT~0VO2SVXcXTtXav?h_6zjh7zr6o9mLFgw>LOXgC z9s%X^`QY_>;g<9)u5HL~zuJf!T4f9Q)H-xYv3KcTaILMPvbTpyr3%l~J8-#NthP4? z#R%DeoMU6q-hCII~Yj)dO~6gk9{*?{y57Z4a3QJaP&U5pN&)F$lt^XC;X3a~vgzx{>>|M;46 zje?YXO|JEdNET-v!I&6FBpN}jR%@)$D8Fu?NNRG3DPx2PC?1cakCi16;^xhZ#rk6V z0PQ?~j)$LqimIe67l~r^%=;)DJ%)4yIl<mPBDYXkz*FBqGAA{=R;d-lHFW2wm2yioR_Nu)F|gw3>l+1Vv#~|C9=2l@Sy< zbeIU)fYN~=mW0ePkqiQ2%149(N6wx>Kq9ZAB@a$e;!t`=ib}0IxabfU6j%%5W;uJyklmxq%&CD+% zTr4AG*7;<&2L9Cz9Tlsx57161jHg3K1W>X8$mMon{Mh)uNc#k^0#zuWTrRf}{lJ_A zgbxD)0}7Nw7eLS&ri{R15;z-BE*isQUN0LC2@iu*f9Y|9LxT!j^YDaUizfNhDhmgK z8coD8DxqfUC>2XcZKTvj1XbHi;pNrORoRz>dp`$E#h)V*DH~8CnLvNM|Fw1r73dJG z?C!y4uj5IvAMEr|X`Jz7Tx~G>WEL)`OYx(&xrxFTR}~;g_y5uDRiqvn9#L9mr)pQ$ zxbf``WTd@_nXFfqMA$7{VyrY->(HR+hX{(*LDl`~$DiOdoN!0o>RjQ=YogS7I435s zbm|n$^%RDW3?mYW?Bfn2Ln(<#YMVWIbvq5RNE4~CZA=@eRzajeqaUiQtl-woTgn54 zlM(?w@mF7{)?(_>OUHM&fp?2K3ftm)F?aq;)M_zmC%Ows@%t zxK5u|4@FQNiQYW!-nolfwT75flOa5*{BTb>#vK8%e*IfmgM$bK>!fCbJ#2&sXj|Ne zA!*a;&m_{e6>8;l8z^?|pmg|vXqCe}fviN%`uRQrdj zJB!V8f53`ZYa3MNSkAy!e86m5Us2~hL-Mw{WugFbZd8g9m@adAF5%^4>N-+ZsV0VRX8 z`8B=U+Ra77PeEQf%m3!5pyoc->qW!9p3Qqx#9D!p6s+F9eS44<(W&LUrH^Gww4XhD zR{xz&r~fuRJ^fdC(HtYLyXpNIYjgP-zd{w=@& XAy`~4;hBqb00000NkvXXu0mjfo0i-A literal 0 HcmV?d00001 diff --git a/legoresources/images/LEGO_Add_Block.png b/legoresources/images/LEGO_Add_Block.png new file mode 100644 index 0000000000000000000000000000000000000000..2a487d358f983440b5533a20f9b004473a465574 GIT binary patch literal 1515 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 literal 0 HcmV?d00001 diff --git a/legoresources/images/LEGO_Display_Palette.png b/legoresources/images/LEGO_Display_Palette.png new file mode 100644 index 0000000000000000000000000000000000000000..59c561e3bc456f123a1eb5452561d3525277e6ae GIT binary patch literal 3436 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 FV1glGB&q-a literal 0 HcmV?d00001 diff --git a/legoresources/images/LEGO_Light_Sensor_Block.png b/legoresources/images/LEGO_Light_Sensor_Block.png new file mode 100644 index 0000000000000000000000000000000000000000..aa6b24504e8aa094c9320a498dceeabd0c923787 GIT binary patch literal 3004 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 FV1ld1tbG6g literal 0 HcmV?d00001 diff --git a/legoresources/images/LEGO_Motor_Block.png b/legoresources/images/LEGO_Motor_Block.png new file mode 100644 index 0000000000000000000000000000000000000000..f9aa8e8e12839123233a04b69276bfa97ac66218 GIT binary patch literal 3205 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 literal 0 HcmV?d00001 diff --git a/legoresources/images/LEGO_Move_Block.png b/legoresources/images/LEGO_Move_Block.png new file mode 100644 index 0000000000000000000000000000000000000000..4944908f6d039f08ee7c32cfbc0f51f2857cb896 GIT binary patch literal 6016 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 Hu0mjfC2n(q literal 0 HcmV?d00001 diff --git a/legoresources/images/LEGO_Play_Note_Block.png b/legoresources/images/LEGO_Play_Note_Block.png new file mode 100644 index 0000000000000000000000000000000000000000..d85f802a4ec156bf6febbfabab331e3c5387babe GIT binary patch literal 2794 zcmVRCwC# znQ2Uv>lMe}Sz(3|Sp*SLQBaWGCGJtFxHnpt8*AO07}F0;+NQDhreB&gO}tI|@y6PI zxYwJ;=#3Z~S2QSYRooX)E{Le8fPlz0%)rdN{hjGMWE_W45KT<_CQq1o=6#>{|D5wb z|8vfRPE}RqbG!7)XLx;}$EYVP(KN$H*MOK1K{0@ z7A=~zZrwVI*=#ldRu>TwVeIJW7|kuQ3`5{^{AS|5g;7yaU#(oZay_3T-`9x752Zv; zPtWe<%a>1CwQ7}70Ao3YO~}x}KeP6Zx9H(;I6MGN&CJYP5AZImKJWVV>$@5o8=v#D z^P_+UaJI|k`ey0UrIS~$UTv~iEc$l^^0sZ;V%TI@OG`_8VPRnx7Jks$+8VKJ*|PY^ z$VjhO&Ye5=M>bv)3b=8AfU`Uv&+f&G7w4{7v!)ktV3adF0m_t&Re!;=>iqfhf4Fer zLMaw5B6!ym7j8DQ6xFG_eEIU3wxvA!9~M7?_TYWvftPwzpK8$8=SU`q>NaQs~W&%s`HexXTw&Dyk4o(EXX0Wa7dIgTe4Vn^g(2&bGF;Xp|)v znxygFP*PIzExf*V=gyt^#D=-Lx_TC1ucI2JXU?2S-M)RhZO)uIo~o*PHR(^Z!+O-#`Q3~;5B0&wq+KT~RC9>`xly3pR z{mDf38*>jHJWxiB8l@0e{RshyMORHt&BaTXE-fJWi~)=dtNs#M`xAibZr;2Z0X@P| zk7Ph6v7raIZ{JR2gEr>PymuDs9A?z}bNekfLxY~cIY|~sQ@;xvXl26fPvPv@TeoiY zU|9p)o-ks>h-u6nWlk@ioIQKCjk(+>PoCUIO;p~e&YL$cjG&D{zf)Px=AWQ~>TBQy zRg{4=3qlb%*+Yz!*4Ea#pq+t0Gb4Ai;Bplka*`Q)CQh8F=eH#I@3?>eek~Svp*#v3 zu_BA` z0*-|9ip_Ls%H?$w^VUy75C02AXd}2986HVWq<+1Ch0m{iR1$z#+5+fy=+WXwF-cPT zkb(Fi?N*4(Lr^;Xi+r%?0~-UeCLRzy?$NNQ{(t)gnincqXuya`%O;*5A{LVhPqM90 zf<$HWs|daKG8aMiw1tY1w~)Xmg-Dko{eRg9umq53uGfV&o2}oV;cyI;h?Qqac?j=6S>;eh|?&_j0lhSvr z)D?g?96fr}b@%Swrx?YKl}AmQG|7g?Tr>%8>XHf(G_5Rk_i5>U`}X~gKa&~pzH>ON zB1Ow)#sq3#_q%{=pmk6q5z8gg2y|jOl_LKNX}p%&Jb%fOCDtofuBazZo@{;e=+RvY zsgYBrOo?J6u0w|oc?isAyl|hTo@q@$$i`OqQz|*%=ML%JP=#_p{{>5C;%+yVF(65O zW>85a(%6!&%`~lb@U{XAUX_C#8iFJwwEO$-zgMyH9oDL!Fk!-68W8Cr9W=lS+`r2* zPc+bucY$^WIVjPw^Hzd$Ct&`{cj2iEjWr7JV3#Nb@!#P^xjgf~RsRL+$(b z@3)~2KSF_P1qB7ESbh{V?B26ykAYgH1}!gRnM$d*G>`ZD2th2~K}7$DzdIRU3-HX$ z%pR;{3I<%#n+@K#cp%~Q^`j6T8&$wdY zuLrugki|PBu-n=*O@US($g!9|@UNiDF6fda!6~UX5IDcPHA_kKI{|ct>{kP*SnlmY zMN+3uoth`W_U_%QrvWa5hL`z%L$k7Du+H*)z%K##OROza=?zX_aT6>+%gf7Kw6fEj zlapgc4&{i~Qdn5%EGa3eAown7A|QNj?d!aHp!KE~IJLngK<@nwIwFl*V`VEdta6*Tyl#~<|Fgh}v)XknC z&v-AX>ZtC%L!-}dn;g8qWK?T_T_GFKzS43(n^!r3nnNw|8vqQKwh0|>!GiyWyT|0b z$JdPnJQt>&Y3McXcZIUBuhtn1(7nK=-e-(wL}@Rt)%e*MOa%h|L-1Y)D}xEz2Oyjg wp|$&}X1UHFR{o%W$?5+8Z{|;Q{a1hi05q-XSw|Ucd;kCd07*qoM6N<$f>M}SPXGV_ literal 0 HcmV?d00001 diff --git a/legoresources/images/LEGO_Play_Note_Palette.png b/legoresources/images/LEGO_Play_Note_Palette.png new file mode 100644 index 0000000000000000000000000000000000000000..25609da6817b7300a208a64cdd5c2782a74a9249 GIT binary patch literal 4761 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 n^sRCwC# znQ2Uv>lMe}Sz(3|Sp*SLQBaWGCGJtFxHnpt8*AO07}F0;+NQDhreB&gO}tI|@y6PI zxYwJ;=#3Z~S2QSYRooX)E{Le8fPlz0%)rdN{hjGMWE_W45KT<_CQq1o=6#>{|D5wb z|8vfRPE}RqbG!7)XLx;}$EYVP(KN$H*MOK1K{0@ z7A=~zZrwVI*=#ldRu>TwVeIJW7|kuQ3`5{^{AS|5g;7yaU#(oZay_3T-`9x752Zv; zPtWe<%a>1CwQ7}70Ao3YO~}x}KeP6Zx9H(;I6MGN&CJYP5AZImKJWVV>$@5o8=v#D z^P_+UaJI|k`ey0UrIS~$UTv~iEc$l^^0sZ;V%TI@OG`_8VPRnx7Jks$+8VKJ*|PY^ z$VjhO&Ye5=M>bv)3b=8AfU`Uv&+f&G7w4{7v!)ktV3adF0m_t&Re!;=>iqfhf4Fer zLMaw5B6!ym7j8DQ6xFG_eEIU3wxvA!9~M7?_TYWvftPwzpK8$8=SU`q>NaQs~W&%s`HexXTw&Dyk4o(EXX0Wa7dIgTe4Vn^g(2&bGF;Xp|)v znxygFP*PIzExf*V=gyt^#D=-Lx_TC1ucI2JXU?2S-M)RhZO)uIo~o*PHR(^Z!+O-#`Q3~;5B0&wq+KT~RC9>`xly3pR z{mDf38*>jHJWxiB8l@0e{RshyMORHt&BaTXE-fJWi~)=dtNs#M`xAibZr;2Z0X@P| zk7Ph6v7raIZ{JR2gEr>PymuDs9A?z}bNekfLxY~cIY|~sQ@;xvXl26fPvPv@TeoiY zU|9p)o-ks>h-u6nWlk@ioIQKCjk(+>PoCUIO;p~e&YL$cjG&D{zf)Px=AWQ~>TBQy zRg{4=3qlb%*+Yz!*4Ea#pq+t0Gb4Ai;Bplka*`Q)CQh8F=eH#I@3?>eek~Svp*#v3 zu_BA` z0*-|9ip_Ls%H?$w^VUy75C02AXd}2986HVWq<+1Ch0m{iR1$z#+5+fy=+WXwF-cPT zkb(Fi?N*4(Lr^;Xi+r%?0~-UeCLRzy?$NNQ{(t)gnincqXuya`%O;*5A{LVhPqM90 zf<$HWs|daKG8aMiw1tY1w~)Xmg-Dko{eRg9umq53uGfV&o2}oV;cyI;h?Qqac?j=6S>;eh|?&_j0lhSvr z)D?g?96fr}b@%Swrx?YKl}AmQG|7g?Tr>%8>XHf(G_5Rk_i5>U`}X~gKa&~pzH>ON zB1Ow)#sq3#_q%{=pmk6q5z8gg2y|jOl_LKNX}p%&Jb%fOCDtofuBazZo@{;e=+RvY zsgYBrOo?J6u0w|oc?isAyl|hTo@q@$$i`OqQz|*%=ML%JP=#_p{{>5C;%+yVF(65O zW>85a(%6!&%`~lb@U{XAUX_C#8iFJwwEO$-zgMyH9oDL!Fk!-68W8Cr9W=lS+`r2* zPc+bucY$^WIVjPw^Hzd$Ct&`{cj2iEjWr7JV3#Nb@!#P^xjgf~RsRL+$(b z@3)~2KSF_P1qB7ESbh{V?B26ykAYgH1}!gRnM$d*G>`ZD2th2~K}7$DzdIRU3-HX$ z%pR;{3I<%#n+@K#cp%~Q^`j6T8&$wdY zuLrugki|PBu-n=*O@US($g!9|@UNiDF6fda!6~UX5IDcPHA_kKI{|ct>{kP*SnlmY zMN+3uoth`W_U_%QrvWa5hL`z%L$k7Du+H*)z%K##OROza=?zX_aT6>+%gf7Kw6fEj zlapgc4&{i~Qdn5%EGa3eAown7A|QNj?d!aHp!KE~IJLngK<@nwIwFl*V`VEdta6*Tyl#~<|Fgh}v)XknC z&v-AX>ZtC%L!-}dn;g8qWK?T_T_GFKzS43(n^!r3nnNw|8vqQKwh0|>!GiyWyT|0b z$JdPnJQt>&Y3McXcZIUBuhtn1(7nK=-e-(wL}@Rt)%e*MOa%h|L-1Y)D}xEz2Oyjg wp|$&}X1UHFR{o%W$?5+8Z{|;Q{a1hi05q-XSw|Ucd;kCd07*qoM6N<$f>M}SPXGV_ literal 0 HcmV?d00001 diff --git a/legoresources/images/LEGO_Random_Block.png b/legoresources/images/LEGO_Random_Block.png new file mode 100644 index 0000000000000000000000000000000000000000..c9d4810a07275fcfb57863781ee8428a68ef09be GIT binary patch literal 3004 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 V<-o=kqqqP7002ovPDHLkV1k>iqx=8> literal 0 HcmV?d00001 diff --git a/legoresources/images/LEGO_Range_Sensor_ActivityPortClaim.png b/legoresources/images/LEGO_Range_Sensor_ActivityPortClaim.png new file mode 100644 index 0000000000000000000000000000000000000000..d4a7e3d38d18a1c52039fd19e74249b81d0a1628 GIT binary patch literal 1319 zcmV+?1=#wDP)sUjKaC#xXH5 zBr7Y6ASKq;)`-Poxqj!4CZa4Pkx0}fB_$t)hli7dgajE(eR|tEe}8`x6cj|f;init zPshf_eyy&qmIE;QL6BPhB0oPrlAD`L5Hwo#UI4*KKOP?+pU%k0xSq4wZ1{M@Uz?tu zPTh6&-uHm;lno6Hy0o-3zWeaOIL-wJ2UE*jTwM5$)aZXski=0@QQDfC8o8&95J+}* zHa);ya+_NVf!QB*c6L4yvJqM^Ffh=GH+U#iuK}H(pHsD3twgC*E~loZdfX&3GLkB~ zN-me9mDM;73k&VSVCJ3BjH1E?Ro0)!txFmOUePEL+YKyE@XxW2ltuTL{SKfkxMv?SGN zG?LNL(RfIrY(zu^SzllO43>W@8W5TsPJ?;oIYx~uxxBo@$1#RDj%Q|Oia}YmT21Qe z>g1c7n>764a1wNXW@aW)sZ`J4HyTel=7zSkwCLfa=Elax_pBQ+o6T%%YwIOg;dp9l z>bSkV{SaJc1On6d;5Pa^Jw0XNJsl4X4Pp4b;(yaoohE?L^vCZ^?^uW!R*Vb|4l*W_ ziH@tPs^}8|c64;m@xsCa0{YP%ASaidot^zx93RJcBp?^koB~fIS0&{}_+vS7D5_FX z9O~)mIl&)t(dJ4F1_K6w9n^ZImeti&D-s-k9~~V{*X{4`lhV>sI!0azsZ%!;HvIC9 z?u|$H7>!0e?hdFLG!-&+$===`eK#;LK)HibQBlEiyn-OX4EdcX4q?G8Dk}QR6QJ$w zZCq?bE21@;nwq{pJUnD4CMMYF>FI0EY;A4P@yN&su0IB?7Ym5?X}Gxn3vFZGij9pW ziHV6Cuz(ik{)BR4tF5hNpxI-fF=H_uz&uvmZ}7n003zMp-RJHAZES2%Kn~u=RzxY4 zN>yOB92mcZJoGv_Ie8z(W(;?(UGWN#LZNu&F6{MsJs*%OQSpvf*mrhWy@O_9`6$>nvU7MSmEgWy!+S+Ih za|rw2eeq4Vq|VRJC(t?&$VDVBE)L240xUy80H;_;fVR20IkvaA7XcZ34d~W>2o*U4 z7eT|y%1SR<3G(GjKt49R5Bzwb&R3IAhPJrLHS=b%CS+o=or4Qm&uNvMSc1N#3D dE1vu-zyLhHFAc+S{}uoM002ovPDHLkV1mZ3RA&GH literal 0 HcmV?d00001 diff --git a/legoresources/images/LEGO_Range_Sensor_Block.png b/legoresources/images/LEGO_Range_Sensor_Block.png new file mode 100644 index 0000000000000000000000000000000000000000..73059efbbf5a615609c97a0fb6877746af013354 GIT binary patch literal 2308 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 Hu0mjfl~BL| literal 0 HcmV?d00001 diff --git a/legoresources/images/LEGO_Start_Block.png b/legoresources/images/LEGO_Start_Block.png new file mode 100644 index 0000000000000000000000000000000000000000..8411a6cf45e3442b77710d78684e67624b1b975d GIT binary patch literal 3537 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 LNkvXXu0mjfgM;OI literal 0 HcmV?d00001 diff --git a/legoresources/images/LEGO_Start_Palette.png b/legoresources/images/LEGO_Start_Palette.png new file mode 100644 index 0000000000000000000000000000000000000000..8411a6cf45e3442b77710d78684e67624b1b975d GIT binary patch literal 3537 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 LNkvXXu0mjfgM;OI literal 0 HcmV?d00001 diff --git a/legoresources/images/LEGO_Stop_If_True.png b/legoresources/images/LEGO_Stop_If_True.png new file mode 100644 index 0000000000000000000000000000000000000000..8d07e74082615b31770f1e26bd5be523df9334d7 GIT binary patch literal 3372 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 literal 0 HcmV?d00001 diff --git a/legoresources/images/LEGO_Touch_Sensor_Palette.png b/legoresources/images/LEGO_Touch_Sensor_Palette.png new file mode 100644 index 0000000000000000000000000000000000000000..1a19e1f52f6d5bf5e63a5dbdf5b6b4e3ffb45701 GIT binary patch literal 3884 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 literal 0 HcmV?d00001 diff --git a/legoresources/images/LEGO_Wait_Time_Block.png b/legoresources/images/LEGO_Wait_Time_Block.png new file mode 100644 index 0000000000000000000000000000000000000000..2596a44d877b05a4c32a0774db151363df80f61f GIT binary patch literal 825 zcmV-91IGM`P)(*1 zK~#9!v{g@Q6HyRfvq{X7w63vY5+hj*_@^qapyDmtn>T|L1yAeITfTuyLGaj*5Cw~R zO25GiUi6kAt+rma{;3ga*hEMIA>hn*o=#rU+8!Jj-tK#Ee)F4oGw*5If085nE#ABT z;1~=Js7-2uHb8w)@%q(D^H9J9SRv(LJ~^;RalQf$>i+}=(5o=i2yht{3_Eg7vV`vv z3?4;PB?lde6P*Goh)J1mRE1bBfXy8O#z?MBFoq2U0uf6yqR zDmtdL*)&&!xrewxm%x`UU%`b0=xrR~-@Ja~rjt9Jt#mqFw^%G%i;H)ydi{-M7{;w! zF019w6aq{cfW3qLEldrJVr}jHR)n#_T)D^s*@Cfs{=zvgolck4G^A2VGkqfM&Cg#f zv(!AJXff|vgyvm5ae2CUFaTPi5H($oi~;NVZlLj_aW9iO#U0~eJD65!Ax}1xxs!7? z&4mK&6~?JQ-VX7q@X)uvZP&=z#No+`kkae*gxpJIi@-txBT$*TFLc!U-oknends5KU_9RNxFJvW5aO#7zXccozRDv3bfNxp00000NkvXXu0mjf DO&Wc( literal 0 HcmV?d00001 diff --git a/legoresources/images/LEGO_Wait_Touch_Block.png b/legoresources/images/LEGO_Wait_Touch_Block.png new file mode 100644 index 0000000000000000000000000000000000000000..1a19e1f52f6d5bf5e63a5dbdf5b6b4e3ffb45701 GIT binary patch literal 3884 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 literal 0 HcmV?d00001 diff --git a/legoresources/images/LoopIcon.png b/legoresources/images/LoopIcon.png new file mode 100644 index 0000000000000000000000000000000000000000..98087f6266b2c3ec1683e6bc510083b8efa2c07e GIT binary patch literal 5243 zcmV->6ol)EP)KLZ*U+IBfRsybQWXdwQbLP>6pAqfylh#{fb6;Z(vMMVS~$e@S=j*ftg6;Uhf59&ghTmgWD0l;*T zI709Y^p6lP1rIRMx#05C~cW=H_Aw*bJ-5DT&Z2n+x)QHX^p z00esgV8|mQcmRZ%02D^@S3L16t`O%c004NIvOKvYIYoh62rY33S640`D9%Y2D-rV&neh&#Q1i z007~1e$oCcFS8neI|hJl{-P!B1ZZ9hpmq0)X0i`JwE&>$+E?>%_LC6RbVIkUx0b+_+BaR3cnT7Zv!AJxW zizFb)h!jyGOOZ85F;a?DAXP{m@;!0_IfqH8(HlgRxt7s3}k3K`kFu>>-2Q$QMFfPW!La{h336o>X zu_CMttHv6zR;&ZNiS=X8v3CR#fknUxHUxJ0uoBa_M6WNWeqIg~6QE69c9o#eyhGvpiOA@W-aonk<7r1(?fC{oI5N*U!4 zfg=2N-7=cNnjjOr{yriy6mMFgG#l znCF=fnQv8CDz++o6_Lscl}eQ+l^ZHARH>?_s@|##Rr6KLRFA1%Q+=*RRWnoLsR`7U zt5vFIcfW3@?wFpwUVxrVZ>QdQz32KIeJ}k~{cZZE^+ya? z2D1z#2HOnI7(B%_ac?{wFUQ;QQA1tBKtrWrm0_3Rgps+?Jfqb{jYbcQX~taRB;#$y zZN{S}1|}gUOHJxc?wV3fxuz+mJ4`!F$IZ;mqRrNsHJd##*D~ju=bP7?-?v~|cv>vB zsJ6IeNwVZxrdjT`yl#bBIa#GxRa#xMMy;K#CDyyGyQdMSxlWT#tDe?p!?5wT$+oGt z8L;Kp2HUQ-ZMJ=3XJQv;x5ci*?vuTfeY$;({XGW_huIFR9a(?@3)XSs8O^N5RyOM=TTmp(3=8^+zpz2r)C z^>JO{deZfso3oq3?Wo(Y?l$ge?uXo;%ru`Vo>?<<(8I_>;8Eq#KMS9gFl*neeosSB zfoHYnBQIkwkyowPu(zdms`p{<7e4kra-ZWq<2*OsGTvEV%s0Td$hXT+!*8Bnh2KMe zBmZRodjHV?r+_5^X9J0WL4jKW`}lf%A-|44I@@LTvf1rHjG(ze6+w@Jt%Bvjts!X0 z?2xS?_ve_-kiKB_KiJlZ$9G`c^=E@oNG)mWWaNo-3TIW8)$Hg0Ub-~8?KhvJ>$ z3*&nim@mj(aCxE5!t{lw7O5^0EIO7zOo&c6l<+|iDySBWCGrz@C5{St!X3hAA}`T4 z(TLbXTq+(;@<=L8dXnssyft|w#WSTW<++3>sgS%(4NTpeI-VAqb|7ssJvzNHgOZVu zaYCvgO_R1~>SyL=cFU|~g|hy|Zi}}s9+d~lYqOB71z9Z$wnC=pR9Yz4DhIM>Wmjgu z&56o6maCpC&F##y%G;1PobR9i?GnNg;gYtchD%p19a!eQtZF&3JaKv33gZ<8D~47E ztUS1iwkmDaPpj=$m#%)jCVEY4fnLGNg2A-`YwHVD3gv};>)hAvT~AmqS>Lr``i7kw zJ{5_It`yrBmlc25DBO7E8;5VoznR>Ww5hAaxn$2~(q`%A-YuS64wkBy=9dm`4cXeX z4c}I@?e+FW+b@^RDBHV(wnMq2zdX3SWv9u`%{xC-q*U}&`cyXV(%rRT*Z6MH?i+i& z_B8C(+grT%{XWUQ+f@NoP1R=AW&26{v-dx)iK^-Nmiuj8txj!m?Z*Ss1N{dh4z}01 z)YTo*JycSU)+_5r4#yw9{+;i4Ee$peRgIj+;v;ZGdF1K$3E%e~4LaI(jC-u%2h$&R z9cLXcYC@Xwnns&bn)_Q~Te?roKGD|d-g^8;+aC{{G(1^(O7m37Y1-+6)01cN&y1aw zoqc{T`P^XJqPBbIW6s}d4{z_f5Om?vMgNQEJG?v2T=KYd^0M3I6IZxbny)%vZR&LD zJpPl@Psh8QyPB@KTx+@RdcC!KX7}kEo;S|j^u2lU7XQ}Oo;f|;z4Ll+_r>@1-xl3| zawq-H%e&ckC+@AhPrP6BKT#_XdT7&;F71j}Joy zkC~6lh7E@6o;W@^IpRNZ{ptLtL(gQ-CY~4mqW;US7Zxvm_|@yz&e53Bp_lTPlfP|z zrTyx_>lv@x#=^!PzR7qqF<$gm`|ZJZ+;<)Cqu&ot2z=0000WV@Og>004R=004l4008;_004mL004C`008P>0026e000+nl3&F} z000T5NklRa75?th@Acl(Jv}fB(=#KEFu<@#T!<(VqDG7XqZktqOQ}RL z6-~uRRK$v!MI~0ErJ{*qB|(B3i6)4+fXE_hP!x$wWQM_E_U`HBb@%Ij+r9ZQ3M zwPjDIsip^ml=XL)yb_pI)&F2AN_ zA%uf*)zu%=*VmV+s#+Hcmmsq50Nk%`g>}|+-TKbOZ;I0J9{{<1RF3Z2y=T~$l+toa z>0>P|Em!V+{{ytQx5F?D2;r>F=klwkPM_Yi_}V43SS+3cLYDhWBa5rrx@dIOY7oXy zTzLz`yxC7FZujj@(a4U(2ptXtW30}$?XB-@-+twm&6^QV#NiM4bK!9K8jshzOm(}P zTrL*?2ukT5O32b&yziUM<&lGJ>mP$NCJN83_dtDS!;NM#^(I_AHWDLr7$%~&Wo_EM zYuBXK!-o-xL=cTe^B#}qyAtyGVK-y+ZK37nv?r6>+8((V_UX0Yk39?b`j^iUsr0Mh ze9WkU5JCXpiT(TcPfDj!C@U*NFc^f-=lgLW5O~w$@jwVM{8>{PhiNY8OvHC~J#sIk zX@RZZ2=(=MrdWA>o#hB_SvF2JIs_XFySlm-X_*X4qooK2gYXCZ8@)d7pF^P#VzC%1 zDk@;x_DC6)L!o$0hp>;P9=#9Pvlnd3cJL4OU1U1WPYu(AVHhVFKV<`Mn&v&JWFJbx zB?Igfg%EcS=nW+l;Yb*TLSbYuly;hl>wBn;=I}Cp{Aw=j^kj2fPXd9 z-Sbl7=4$~$fi2sieA*P0mVLV|1Z>+rZYKc|LR??S=fM~Qr8G+^ZKIU_iF1wlUyqGmbPd<;F!SP{ZN{kLzI$*1O$Xo zsA0Ge+=Vh*v(B`g=&bQpz+^Ujr zi7llBrR>DiK500PGi=Z@#`@Ptxh+eHW?ncesIGYiYAB<$-w7clw;cOOVNyLneZbL9kk&SM^ukN^;mElZAEh0;FGf@+smt zH$e!n`QMs9?%ji*ZPa5`&z&5()1nLZ8L#M2W2?)t5e(lSjGl+qzn)Z_8M zkOt&Z9j&@1*B`{oK+y=a;#=e?b2YIn0|0m?llhyAP&C%m z63arTI<~A9ZEaBZeFpW4OD36&)x~15)@(M5bUHmKg@q7MRdv|(1^~u6s1Q4v_kJ`x zIj-vWXFdD)!e~YLjodIbdCWNu0?eE_13`~RTCu8+WL>P5G#`O$&tCXV+oKUOR|wJS z_xlkD1cv;OWm$;#_CiA9L@2IfLP!~f6atE^B-5Q;*X@_GVy0W|Di(?uSU_uHF_e!T z3#(X!6Ao>%&zu5`D+g&lgwW@$V1C~ZMx!Hzf)4YP(oQJ>V-%#ny@0AJCj`;t)IZg{=kCxsB5BLg7>(zbr5FS`6~=lrvQv1N$db{{I; z-tkbCzep+7VVQApbaZr}?Ta=flS$-qxrTf`zcQ<3kxV8b0aV9gEmFz{2lXvOWr8qF z+wuFZ)qisRA#uqZ&?D`ryz4=Xt*DqUIa?>C^bFew5sFkg1udgRbzR?}Xibi3U*NGVgJyI>Il7)FPvuAHA+d25rs=rXuo-h!IDSEHh;>MFR^EkcNfq1OV8 zvO3GQHl@?)sqx-kD2j^N7hGUPN=vV^ZF|T6b<+a?QYbc~x?-NbdeuLR_pgAmc^m3( z_&I6`zd((IcOUESs|Fe*(=fSV7)v!x+m(nX&ao{UjZ>%Lvdh2S7L7(1*tWf4*l)$- ziQ(?O15GrTqQIbJDQRlH&AoQRRMyss{B>6$KKTr!(6xPLB!*W3Vg>Hl>PmD|1P2-#i-cn~HH2B{sl~qTy&- zrYL~4Q8apm5S<{{=h)6}$8qAL`Wx_7`BC$~0RS32H9F*)tiAvM002ovPDHLkV1hu~ BYmyG(7W4QgbxR+kZ&{6$g5{IEGZrN&4~szdf_% z3?1LaQl1xoe0b=*^Ua$#nm0cD`udu=Aj_uq*A`CZ01jzAP0g3bR(`yM$YtbP0l+XkKTn