Browse Source

Initial import

jamesbowman 5 years ago
parent
commit
180a5a442b
77 changed files with 20215 additions and 0 deletions
  1. 4 0
      .gitignore
  2. 874 0
      GD2.cpp
  3. 973 0
      GD2.h
  4. 61 0
      blobs.ino
  5. 312 0
      chess.ino
  6. 440 0
      cobra.ino
  7. 982 0
      converted-assets/blobs_assets.h
  8. 275 0
      converted-assets/chess_assets.h
  9. 46 0
      converted-assets/cobra_assets.h
  10. 17 0
      converted-assets/examples2_assets.h
  11. 27 0
      converted-assets/examples_assets.h
  12. 1089 0
      converted-assets/fonts_assets.h
  13. 1891 0
      converted-assets/formats_assets.h
  14. 288 0
      converted-assets/frogger_assets.h
  15. 28 0
      converted-assets/invaders_assets.h
  16. 819 0
      converted-assets/jnr_assets.h
  17. 673 0
      converted-assets/kenney_assets.h
  18. 22 0
      converted-assets/logo_assets.h
  19. 7 0
      converted-assets/mono_assets.h
  20. 66 0
      converted-assets/nightstrike_0_assets.h
  21. 66 0
      converted-assets/nightstrike_1_assets.h
  22. 66 0
      converted-assets/nightstrike_2_assets.h
  23. 66 0
      converted-assets/nightstrike_3_assets.h
  24. 66 0
      converted-assets/nightstrike_4_assets.h
  25. 17 0
      converted-assets/nightstrike_welcome_assets.h
  26. 32 0
      converted-assets/noisy_assets.h
  27. 12 0
      converted-assets/reflection_assets.h
  28. 2 0
      converted-assets/sdcard_assets.h
  29. 38 0
      converted-assets/selftest_assets.h
  30. 12 0
      converted-assets/slotgag_assets.h
  31. 2517 0
      converted-assets/sprites_assets.h
  32. 7 0
      converted-assets/tiled_assets.h
  33. 124 0
      converted-assets/walk_assets.h
  34. 853 0
      examples.ino
  35. 24 0
      fizz.ino
  36. 44 0
      fonts.ino
  37. 27 0
      formats.ino
  38. 434 0
      frogger.ino
  39. 51 0
      glow.ino
  40. 17 0
      helloworld.ino
  41. 1727 0
      ino-cobra.ino/.build/environment.pickle
  42. 47 0
      ino-cobra.ino/.build/pro328/Makefile
  43. 22 0
      ino-cobra.ino/.build/pro328/Makefile.deps
  44. 9 0
      ino-cobra.ino/.build/pro328/Makefile.sketch
  45. 0 0
      ino-cobra.ino/.build/pro328/src/dependencies.d
  46. 1 0
      ino-cobra.ino/lib/Gameduino2
  47. 1196 0
      invaders.ino
  48. 173 0
      jnr.ino
  49. 19 0
      jpeg.ino
  50. 26 0
      jpeg2.ino
  51. 275 0
      kenney.ino
  52. 31 0
      keywords.txt
  53. 29 0
      lines.ino
  54. 100 0
      logo.ino
  55. 14 0
      mkino
  56. 25 0
      mono.ino
  57. 945 0
      nightstrike.ino
  58. 41 0
      noisy.ino
  59. 52 0
      publish.py
  60. 95 0
      radarchart.ino
  61. 95 0
      reflection.ino
  62. 479 0
      selftest.ino
  63. 115 0
      simon.ino
  64. 25 0
      sketch.ino
  65. 38 0
      slotgag.ino
  66. 28 0
      song.ino
  67. 46 0
      sprites.ino
  68. 72 0
      tempest.ino
  69. 23 0
      tiled.ino
  70. 30 0
      tilt.ino
  71. 39 0
      transports/dump.h
  72. 34 0
      transports/serial.h
  73. 275 0
      transports/spidev.h
  74. 275 0
      transports/wiring.h
  75. 301 0
      viewer.ino
  76. 33 0
      walk.ino
  77. 111 0
      widgets.ino

+ 4 - 0
.gitignore

@@ -0,0 +1,4 @@
+Gameduino2.zip
+ino-*
+mkino
+go

File diff suppressed because it is too large
+ 874 - 0
GD2.cpp


+ 973 - 0
GD2.h

@@ -0,0 +1,973 @@
+/*
+ * Copyright (C) 2013 by James Bowman <jamesb@excamera.com>
+ * Gameduino 2 library for Arduino, Raspberry Pi.
+ *
+ */
+
+#ifndef _GD2_H_INCLUDED
+#define _GD2_H_INCLUDED
+
+#if defined(RASPBERRY_PI) || defined(EMUPC)
+#include "wiring.h"
+#endif
+
+#if defined(RASPBERRY_PI)
+#define REPORT(VAR) fprintf(stderr, #VAR "=%d\n", (VAR))
+#else
+#define REPORT(VAR) (Serial.print(#VAR "="), Serial.println(VAR, DEC))
+#endif
+
+#include "Arduino.h"
+#include <stdarg.h>
+
+#define RGB(r, g, b)    ((uint32_t)((((r) & 0xffL) << 16) | (((g) & 0xffL) << 8) | ((b) & 0xffL)))
+#define F8(x)           (int((x) * 256L))
+#define F16(x)          ((int32_t)((x) * 65536L))
+
+#define GD_CALIBRATE    1
+#define GD_TRIM         2
+#define GD_STORAGE      4
+
+////////////////////////////////////////////////////////////////////////
+#if !defined(RASPBERRY_PI) && !defined(EMUPC)
+#define VERBOSE 0
+
+struct dirent {
+  char name[8];
+  char ext[3];
+  byte attribute;
+  byte reserved[8];
+  uint16_t cluster_hi;  // FAT32 only
+  uint16_t time;
+  uint16_t date;
+  uint16_t cluster;
+  uint32_t size;
+};
+
+// https://www.sdcard.org/downloads/pls/simplified_specs/Part_1_Physical_Layer_Simplified_Specification_Ver_3.01_Final_100518.pdf
+// page 22
+// http://mac6.ma.psu.edu/space2008/RockSat/microController/sdcard_appnote_foust.pdf
+// http://elm-chan.org/docs/mmc/mmc_e.html
+// http://www.pjrc.com/tech/8051/ide/fat32.html
+
+#define FAT16 0
+#define FAT32 1
+
+class sdcard {
+  public:
+  void sel() {
+    digitalWrite(pin, LOW);
+    delay(1);
+  }
+  void desel() {
+    digitalWrite(pin, HIGH);
+    SPI.transfer(0xff); // force DO release
+  }
+  void sd_delay(byte n) {
+    while (n--)
+      SPI.transfer(0xff);
+  }
+
+  void cmd(byte cmd, uint32_t lba = 0, uint8_t crc = 0x95) {
+#if VERBOSE
+    Serial.print("cmd ");
+    Serial.print(cmd, DEC);
+    Serial.print(" ");
+    Serial.print(lba, HEX);
+    Serial.println();
+#endif
+
+    sel();
+    SPI.transfer(0xff);
+    SPI.transfer(0x40 | cmd);
+    SPI.transfer(0xff & (lba >> 24));
+    SPI.transfer(0xff & (lba >> 16));
+    SPI.transfer(0xff & (lba >> 8));
+    SPI.transfer(0xff & (lba));
+    SPI.transfer(crc);
+    SPI.transfer(0xff);
+  }
+
+  byte R1() {   // read response R1
+    byte r;
+    while ((r = SPI.transfer(0xff)) & 0x80)
+      ;
+    desel();
+    SPI.transfer(0xff);   // trailing byte
+    return r;
+  }
+
+  byte sdR3(uint32_t &ocr) {  // read response R3
+    uint32_t r;
+    while ((r = SPI.transfer(0xff)) & 0x80)
+      ;
+    for (byte i = 4; i; i--)
+      ocr = (ocr << 8) | SPI.transfer(0xff);
+    SPI.transfer(0xff);   // trailing byte
+
+    desel();
+    return r;
+  }
+
+  byte sdR7() {  // read response R3
+    uint32_t r;
+    while ((r = SPI.transfer(0xff)) & 0x80)
+      ;
+    for (byte i = 4; i; i--)
+      // Serial.println(SPI.transfer(0xff), HEX);
+      SPI.transfer(0xff);
+    desel();
+
+    return r;
+  }
+
+  void appcmd(byte cc, uint32_t lba = 0) {
+    cmd(55); R1();
+    cmd(cc, lba);
+  }
+
+  void begin(byte p) {
+    byte type_code;
+    byte sdhc;
+    pin = p;
+
+    pinMode(pin, OUTPUT);
+    SPI.setClockDivider(SPI_CLOCK_DIV64);
+    desel();
+
+    delay(10);      // wait for boot
+    sd_delay(10);   // deselected, 80 pulses
+
+    // Tty.printf("Attempting card reset... ");
+    // attempt reset
+    byte r1;
+    int attempts = 0;
+    do {       // reset, enter idle
+      cmd(0);
+      while ((r1 = SPI.transfer(0xff)) & 0x80)
+        if (++attempts == 1000)
+          goto finished;
+      desel();
+      SPI.transfer(0xff);   // trailing byte
+    } while (r1 != 1);
+    // Tty.printf("reset ok\n");
+
+    sdhc = 0;
+    cmd(8, 0x1aa, 0x87);
+    r1 = sdR7();
+    sdhc = (r1 == 1);
+
+    // Tty.printf("card %s SDHC\n", sdhc ? "is" : "is not");
+
+    // Tty.printf("Sending card init command... ");
+    while (1) {
+      appcmd(41, sdhc ? (1UL << 30) : 0); // card init
+      r1 = R1();
+      if ((r1 & 1) == 0)
+        break;
+      delay(100);
+    }
+    // Tty.printf("OK\n");
+
+    if (sdhc) {
+      cmd(58);
+      uint32_t OCR = 0;
+      sdR3(OCR);
+      ccs = 1UL & (OCR >> 30);
+      // Tty.printf("OCR register is %#010lx\n", long(OCR));
+    } else {
+      ccs = 0;
+    }
+    // Tty.printf("ccs = %d\n", ccs);
+  // REPORT(ccs);
+
+    type_code = rd(0x1be + 0x4);
+    switch (type_code) {
+      default:
+        type = FAT16;
+        break;
+      case 0x0b:
+      case 0x0c:
+        type = FAT32;
+        break;
+    }
+  // REPORT(type_code);
+    // Tty.printf("Type code %#02x means FAT%d\n", type_code, (type == FAT16) ? 16 : 32);
+#if VERBOSE
+    Serial.print("Type ");
+    Serial.print(type_code, HEX);
+    Serial.print(" so FAT");
+    Serial.println((type == FAT16) ? 16 : 32, DEC);
+#endif
+
+    o_partition = 512L * rd4(0x1be + 0x8);
+    sectors_per_cluster = rd(o_partition + 0xd);
+    reserved_sectors = rd2(o_partition + 0xe);
+    cluster_size = 512L * sectors_per_cluster;
+// REPORT(sectors_per_cluster);
+
+    // Tty.printf("Bytes per sector:    %d\n", rd2(o_partition + 0xb));
+    // Tty.printf("Sectors per cluster: %d\n", sectors_per_cluster);
+
+    if (type == FAT16) {
+      max_root_dir_entries = rd2(o_partition + 0x11);
+      sectors_per_fat = rd2(o_partition + 0x16);
+      o_fat = o_partition + 512L * reserved_sectors;
+      o_root = o_fat + (2 * 512L * sectors_per_fat);
+      // data area starts with cluster 2, so offset it here
+      o_data = o_root + (max_root_dir_entries * 32L) - (2L * cluster_size); 
+    } else {
+      uint32_t sectors_per_fat = rd4(o_partition + 0x24);
+      root_dir_first_cluster = rd4(o_partition + 0x2c);
+      uint32_t fat_begin_lba = (o_partition >> 9) + reserved_sectors;
+      uint32_t cluster_begin_lba = (o_partition >> 9) + reserved_sectors + (2 * sectors_per_fat);
+
+      o_fat = 512L * fat_begin_lba;
+      o_root = (512L * (cluster_begin_lba + (root_dir_first_cluster - 2) * sectors_per_cluster));
+      o_data = (512L * (cluster_begin_lba - 2 * sectors_per_cluster));
+    }
+  finished:
+    // Serial.println("finished");
+    SPI.setClockDivider(SPI_CLOCK_DIV2);
+    SPSR = (1 << SPI2X);
+  }
+  void cmd17(uint32_t off) {
+    if (ccs)
+      cmd(17, off >> 9);
+    else
+      cmd(17, off & ~511L);
+    R1();
+    sel();
+    while (SPI.transfer(0xff) != 0xfe)
+      ;
+  }
+  void rdn(byte *d, uint32_t off, uint16_t n) {
+    cmd17(off);
+    uint16_t i;
+    uint16_t bo = (off & 511);
+    for (i = 0; i < bo; i++)
+      SPI.transfer(0xff);
+    for (i = 0; i < n; i++)
+      *d++ = SPI.transfer(0xff);
+    for (i = 0; i < (514 - bo - n); i++)
+      SPI.transfer(0xff);
+    desel();
+  }
+
+  uint32_t rd4(uint32_t off) {
+    uint32_t r;
+    rdn((byte*)&r, off, sizeof(r));
+    return r;
+  }
+
+  uint16_t rd2(uint32_t off) {
+    uint16_t r;
+    rdn((byte*)&r, off, sizeof(r));
+    return r;
+  }
+
+  byte rd(uint32_t off) {
+    byte r;
+    rdn((byte*)&r, off, sizeof(r));
+    return r;
+  }
+  byte pin;
+  byte ccs;
+
+  byte type;
+  uint16_t sectors_per_cluster;
+  uint16_t reserved_sectors;
+  uint16_t max_root_dir_entries;
+  uint16_t sectors_per_fat;
+  uint16_t cluster_size;
+  uint32_t root_dir_first_cluster;
+
+  // These are all linear addresses, hence the o_ prefix
+  uint32_t o_partition;
+  uint32_t o_fat;
+  uint32_t o_root;
+  uint32_t o_data;
+};
+
+static void dos83(byte dst[11], const char *ps)
+{
+  byte i = 0;
+  while (*ps) {
+    if (*ps != '.')
+      dst[i++] = toupper(*ps);
+    else {
+      while (i < 8)
+        dst[i++] = ' ';
+    }
+    ps++;
+  }
+  while (i < 11)
+    dst[i++] = ' ';
+}
+
+#else
+class sdcard {
+public:
+  void begin(int p) {};
+};
+#endif
+
+////////////////////////////////////////////////////////////////////////
+
+class GDClass {
+public:
+  void begin(uint8_t options = (GD_CALIBRATE | GD_TRIM | GD_STORAGE));
+
+  uint16_t random();
+  uint16_t random(uint16_t n);
+  void seed(uint16_t n);
+  int16_t rsin(int16_t r, uint16_t th);
+  int16_t rcos(int16_t r, uint16_t th);
+  void polar(int &x, int &y, int16_t r, uint16_t th);
+  uint16_t atan2(int16_t y, int16_t x);
+
+  void copy(const PROGMEM uint8_t *src, int count);
+  void copyram(byte *src, int count);
+
+  void self_calibrate(void);
+
+  void swap(void);
+  void flush(void);
+  void finish(void);
+
+  void play(uint8_t instrument, uint8_t note = 0);
+  void sample(uint32_t start, uint32_t len, uint16_t freq, uint16_t format, int loop = 0);
+
+  void get_inputs(void);
+  void get_accel(int &x, int &y, int &z);
+  struct {
+    uint16_t track_tag;
+    uint16_t track_val;
+    uint16_t rz;
+    uint16_t __dummy_1;
+    int16_t y;
+    int16_t x;
+    int16_t tag_y;
+    int16_t tag_x;
+    uint8_t tag;
+    uint8_t ptag;
+  } inputs;
+
+  void AlphaFunc(byte func, byte ref);
+  void Begin(byte prim);
+  void BitmapHandle(byte handle);
+  void BitmapLayout(byte format, uint16_t linestride, uint16_t height);
+  void BitmapSize(byte filter, byte wrapx, byte wrapy, uint16_t width, uint16_t height);
+  void BitmapSource(uint32_t addr);
+  void BitmapTransformA(int32_t a);
+  void BitmapTransformB(int32_t b);
+  void BitmapTransformC(int32_t c);
+  void BitmapTransformD(int32_t d);
+  void BitmapTransformE(int32_t e);
+  void BitmapTransformF(int32_t f);
+  void BlendFunc(byte src, byte dst);
+  void Call(uint16_t dest);
+  void Cell(byte cell);
+  void ClearColorA(byte alpha);
+  void ClearColorRGB(byte red, byte green, byte blue);
+  void ClearColorRGB(uint32_t rgb);
+  void Clear(byte c, byte s, byte t);
+  void Clear(void);
+  void ClearStencil(byte s);
+  void ClearTag(byte s);
+  void ColorA(byte alpha);
+  void ColorMask(byte r, byte g, byte b, byte a);
+  void ColorRGB(byte red, byte green, byte blue);
+  void ColorRGB(uint32_t rgb);
+  void Display(void);
+  void End(void);
+  void Jump(uint16_t dest);
+  void LineWidth(uint16_t width);
+  void Macro(byte m);
+  void PointSize(uint16_t size);
+  void RestoreContext(void);
+  void Return(void);
+  void SaveContext(void);
+  void ScissorSize(uint16_t width, uint16_t height);
+  void ScissorXY(uint16_t x, uint16_t y);
+  void StencilFunc(byte func, byte ref, byte mask);
+  void StencilMask(byte mask);
+  void StencilOp(byte sfail, byte spass);
+  void TagMask(byte mask);
+  void Tag(byte s);
+  void Vertex2f(int16_t x, int16_t y);
+  void Vertex2ii(uint16_t x, uint16_t y, byte handle = 0, byte cell = 0);
+
+  // Higher-level graphics commands
+
+  void cmd_append(uint32_t ptr, uint32_t num);
+  void cmd_bgcolor(uint32_t c);
+  void cmd_button(int16_t x, int16_t y, uint16_t w, uint16_t h, byte font, uint16_t options, const char *s);
+  void cmd_calibrate(void);
+  void cmd_clock(int16_t x, int16_t y, int16_t r, uint16_t options, uint16_t h, uint16_t m, uint16_t s, uint16_t ms);
+  void cmd_coldstart(void);
+  void cmd_dial(int16_t x, int16_t y, int16_t r, uint16_t options, uint16_t val);
+  void cmd_dlstart(void);
+  void cmd_fgcolor(uint32_t c);
+  void cmd_gauge(int16_t x, int16_t y, int16_t r, uint16_t options, uint16_t major, uint16_t minor, uint16_t val, uint16_t range);
+  void cmd_getmatrix(void);
+  void cmd_getprops(uint32_t &ptr, uint32_t &w, uint32_t &h);
+  void cmd_getptr(void);
+  void cmd_gradcolor(uint32_t c);
+  void cmd_gradient(int16_t x0, int16_t y0, uint32_t rgb0, int16_t x1, int16_t y1, uint32_t rgb1);
+  void cmd_inflate(uint32_t ptr);
+  void cmd_interrupt(uint32_t ms);
+  void cmd_keys(int16_t x, int16_t y, int16_t w, int16_t h, byte font, uint16_t options, const char*s);
+  void cmd_loadidentity(void);
+  void cmd_loadimage(uint32_t ptr, int32_t options);
+  void cmd_memcpy(uint32_t dest, uint32_t src, uint32_t num);
+  void cmd_memset(uint32_t ptr, byte value, uint32_t num);
+  uint32_t cmd_memcrc(uint32_t ptr, uint32_t num);
+  void cmd_memwrite(uint32_t ptr, uint32_t num);
+  void cmd_regwrite(uint32_t ptr, uint32_t val);
+  void cmd_number(int16_t x, int16_t y, byte font, uint16_t options, uint32_t n);
+  void cmd_progress(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t options, uint16_t val, uint16_t range);
+  void cmd_regread(uint32_t ptr);
+  void cmd_rotate(int32_t a);
+  void cmd_scale(int32_t sx, int32_t sy);
+  void cmd_screensaver(void);
+  void cmd_scrollbar(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t options, uint16_t val, uint16_t size, uint16_t range);
+  void cmd_setfont(byte font, uint32_t ptr);
+  void cmd_setmatrix(void);
+  void cmd_sketch(int16_t x, int16_t y, uint16_t w, uint16_t h, uint32_t ptr, uint16_t format);
+  void cmd_slider(int16_t x, int16_t y, uint16_t w, uint16_t h, uint16_t options, uint16_t val, uint16_t range);
+  void cmd_snapshot(uint32_t ptr);
+  void cmd_spinner(int16_t x, int16_t y, byte style, byte scale);
+  void cmd_stop(void);
+  void cmd_swap(void);
+  void cmd_text(int16_t x, int16_t y, byte font, uint16_t options, const char *s);
+  void cmd_toggle(int16_t x, int16_t y, int16_t w, byte font, uint16_t options, uint16_t state, const char *s);
+  void cmd_track(int16_t x, int16_t y, uint16_t w, uint16_t h, byte tag);
+  void cmd_translate(int32_t tx, int32_t ty);
+
+  byte rd(uint32_t addr);
+  void wr(uint32_t addr, uint8_t v);
+  uint16_t rd16(uint32_t addr);
+  void wr16(uint32_t addr, uint16_t v);
+  uint32_t rd32(uint32_t addr);
+  void wr32(uint32_t addr, uint32_t v);
+  void wr_n(uint32_t addr, byte *src, uint32_t n);
+
+  void cmd32(uint32_t b);
+
+  void bulkrd(uint32_t a);
+  void resume(void);
+  void __end(void);
+  void reset(void);
+
+  void dumpscreen(void);
+  byte load(const char *filename, void (*progress)(long, long) = NULL);
+  void safeload(const char *filename);
+
+  sdcard SD;
+
+  void storage(void);
+  void tune(void);
+
+private:
+  static void cFFFFFF(byte v);
+  static void cI(uint32_t);
+  static void ci(int32_t);
+  static void cH(uint16_t);
+  static void ch(int16_t);
+  static void cs(const char *);
+  static void fmtcmd(const char *fmt, ...);
+
+  static void align(byte n);
+  void cmdbyte(uint8_t b);
+
+  uint32_t measure_freq(void);
+
+  uint32_t rseed;
+};
+
+extern GDClass GD;
+
+#if !defined(RASPBERRY_PI) && !defined(EMUPC)
+class Reader {
+public:
+  int openfile(const char *filename) {
+    int i = 0;
+    byte dosname[11];
+    dirent de;
+
+    dos83(dosname, filename);
+    do {
+      GD.SD.rdn((byte*)&de, GD.SD.o_root + i * 32, sizeof(de));
+      // Serial.println(de.name);
+      if (0 == memcmp(de.name, dosname, 11)) {
+        begin(de);
+        return 1;
+      }
+      i++;
+    } while (de.name[0]);
+    return 0;
+  }
+  void begin(dirent &de) {
+    size = de.size;
+    cluster = de.cluster;
+    if (GD.SD.type == FAT32)
+      cluster |= ((long)de.cluster_hi << 16);
+    sector = 0;
+    offset = 0;
+  }
+  void nextcluster() {
+    if (GD.SD.type == FAT16)
+      cluster = GD.SD.rd2(GD.SD.o_fat + 2 * cluster);
+    else
+      cluster = GD.SD.rd4(GD.SD.o_fat + 4 * cluster);
+#if VERBOSE
+    Serial.print("nextcluster=");
+    Serial.println(cluster, DEC);
+#endif
+  }
+  void skipcluster() {
+    nextcluster();
+    offset += GD.SD.cluster_size;
+  }
+  void skipsector() {
+    if (sector == GD.SD.sectors_per_cluster) {
+      sector = 0;
+      nextcluster();
+    }
+    sector++;
+    offset += 512;
+  }
+  void seek(uint32_t o) {
+    while (offset < o) {
+      if ((sector == GD.SD.sectors_per_cluster) && ((o - offset) > (long)GD.SD.cluster_size))
+        skipcluster();
+      else
+        skipsector();
+    }
+  }
+  void readsector() {
+    if (sector == GD.SD.sectors_per_cluster) {
+      sector = 0;
+      nextcluster();
+    }
+    uint32_t off = GD.SD.o_data + ((long)GD.SD.cluster_size * cluster) + (512L * sector);
+#if VERBOSE
+    Serial.print("off=0x");
+    Serial.println(off, HEX);
+#endif
+    GD.SD.cmd17(off & ~511L);
+// Serial.println(2 * (micros() - t0), DEC);
+    sector++;
+    offset += 512;
+  }
+  void readsector(byte *dst) {
+    readsector();
+    for (int i = 0; i < 64; i++) {
+      *dst++ = SPI.transfer(0xff);
+      *dst++ = SPI.transfer(0xff);
+      *dst++ = SPI.transfer(0xff);
+      *dst++ = SPI.transfer(0xff);
+      *dst++ = SPI.transfer(0xff);
+      *dst++ = SPI.transfer(0xff);
+      *dst++ = SPI.transfer(0xff);
+      *dst++ = SPI.transfer(0xff);
+    }
+    SPI.transfer(0xff);   // consume CRC
+    SPI.transfer(0xff);
+    GD.SD.desel();
+  }
+  uint32_t cluster;
+  uint32_t offset;
+  uint32_t size;
+  byte sector;
+};
+#endif
+
+typedef struct {
+  byte handle;
+  uint16_t w, h;
+  uint16_t size;
+} shape_t;
+
+// Convert degrees to Furmans
+#define DEGREES(n) ((65536UL * (n)) / 360)
+
+#define NEVER                0
+#define LESS                 1
+#define LEQUAL               2
+#define GREATER              3
+#define GEQUAL               4
+#define EQUAL                5
+#define NOTEQUAL             6
+#define ALWAYS               7
+
+#define ARGB1555             0
+#define L1                   1
+#define L4                   2
+#define L8                   3
+#define RGB332               4
+#define ARGB2                5
+#define ARGB4                6
+#define RGB565               7
+#define PALETTED             8
+#define TEXT8X8              9
+#define TEXTVGA              10
+#define BARGRAPH             11
+
+#define NEAREST              0
+#define BILINEAR             1
+
+#define BORDER               0
+#define REPEAT               1
+
+#define KEEP                 1
+#define REPLACE              2
+#define INCR                 3
+#define DECR                 4
+#define INVERT               5
+
+#define DLSWAP_DONE          0
+#define DLSWAP_LINE          1
+#define DLSWAP_FRAME         2
+
+#define INT_SWAP             1
+#define INT_TOUCH            2
+#define INT_TAG              4
+#define INT_SOUND            8
+#define INT_PLAYBACK         16
+#define INT_CMDEMPTY         32
+#define INT_CMDFLAG          64
+#define INT_CONVCOMPLETE     128
+
+#define TOUCHMODE_OFF        0
+#define TOUCHMODE_ONESHOT    1
+#define TOUCHMODE_FRAME      2
+#define TOUCHMODE_CONTINUOUS 3
+
+#define ZERO                 0
+#define ONE                  1
+#define SRC_ALPHA            2
+#define DST_ALPHA            3
+#define ONE_MINUS_SRC_ALPHA  4
+#define ONE_MINUS_DST_ALPHA  5
+
+#define BITMAPS              1
+#define POINTS               2
+#define LINES                3
+#define LINE_STRIP           4
+#define EDGE_STRIP_R         5
+#define EDGE_STRIP_L         6
+#define EDGE_STRIP_A         7
+#define EDGE_STRIP_B         8
+#define RECTS                9
+
+#define OPT_MONO             1
+#define OPT_NODL             2
+#define OPT_FLAT             256
+#define OPT_CENTERX          512
+#define OPT_CENTERY          1024
+#define OPT_CENTER           (OPT_CENTERX | OPT_CENTERY)
+#define OPT_NOBACK           4096
+#define OPT_NOTICKS          8192
+#define OPT_NOHM             16384
+#define OPT_NOPOINTER        16384
+#define OPT_NOSECS           32768
+#define OPT_NOHANDS          49152
+#define OPT_RIGHTX           2048
+#define OPT_SIGNED           256
+
+#define LINEAR_SAMPLES       0
+#define ULAW_SAMPLES         1
+#define ADPCM_SAMPLES        2
+
+// 'instrument' argument to GD.play()
+
+#define SILENCE              0x00
+
+#define SQUAREWAVE           0x01
+#define SINEWAVE             0x02
+#define SAWTOOTH             0x03
+#define TRIANGLE             0x04
+
+#define BEEPING              0x05
+#define ALARM                0x06
+#define WARBLE               0x07
+#define CAROUSEL             0x08
+
+#define PIPS(n)              (0x0f + (n))
+
+#define HARP                 0x40
+#define XYLOPHONE            0x41
+#define TUBA                 0x42
+#define GLOCKENSPIEL         0x43
+#define ORGAN                0x44
+#define TRUMPET              0x45
+#define PIANO                0x46
+#define CHIMES               0x47
+#define MUSICBOX             0x48
+#define BELL                 0x49
+
+#define CLICK                0x50
+#define SWITCH               0x51
+#define COWBELL              0x52
+#define NOTCH                0x53
+#define HIHAT                0x54
+#define KICKDRUM             0x55
+#define POP                  0x56
+#define CLACK                0x57
+#define CHACK                0x58
+
+#define MUTE                 0x60
+#define UNMUTE               0x61
+
+#define RAM_CMD              1081344UL
+#define RAM_DL               1048576UL
+#define RAM_PAL              1056768UL
+
+#define REG_CLOCK            1057800UL
+#define REG_CMD_DL           1058028UL
+#define REG_CMD_READ         1058020UL
+#define REG_CMD_WRITE        1058024UL
+#define REG_CPURESET         1057820UL
+#define REG_CSPREAD          1057892UL
+#define REG_DITHER           1057884UL
+#define REG_DLSWAP           1057872UL
+#define REG_FRAMES           1057796UL
+#define REG_FREQUENCY        1057804UL
+#define REG_GPIO             1057936UL
+#define REG_GPIO_DIR         1057932UL
+#define REG_HCYCLE           1057832UL
+#define REG_HOFFSET          1057836UL
+#define REG_HSIZE            1057840UL
+#define REG_HSYNC0           1057844UL
+#define REG_HSYNC1           1057848UL
+#define REG_ID               1057792UL
+#define REG_INT_EN           1057948UL
+#define REG_INT_FLAGS        1057944UL
+#define REG_INT_MASK         1057952UL
+#define REG_MACRO_0          1057992UL
+#define REG_MACRO_1          1057996UL
+#define REG_OUTBITS          1057880UL
+#define REG_PCLK             1057900UL
+#define REG_PCLK_POL         1057896UL
+#define REG_PLAY             1057928UL
+#define REG_PLAYBACK_FORMAT  1057972UL
+#define REG_PLAYBACK_FREQ    1057968UL
+#define REG_PLAYBACK_LENGTH  1057960UL
+#define REG_PLAYBACK_LOOP    1057976UL
+#define REG_PLAYBACK_PLAY    1057980UL
+#define REG_PLAYBACK_READPTR 1057964UL
+#define REG_PLAYBACK_START   1057956UL
+#define REG_PWM_DUTY         1057988UL
+#define REG_PWM_HZ           1057984UL
+#define REG_ROTATE           1057876UL
+#define REG_SOUND            1057924UL
+#define REG_SWIZZLE          1057888UL
+#define REG_TAG              1057912UL
+#define REG_TAG_X            1057904UL
+#define REG_TAG_Y            1057908UL
+#define REG_TOUCH_ADC_MODE   1058036UL
+#define REG_TOUCH_CHARGE     1058040UL
+#define REG_TOUCH_DIRECT_XY  1058164UL
+#define REG_TOUCH_DIRECT_Z1Z2 1058168UL
+#define REG_TOUCH_MODE       1058032UL
+#define REG_TOUCH_OVERSAMPLE 1058048UL
+#define REG_TOUCH_RAW_XY     1058056UL
+#define REG_TOUCH_RZ         1058060UL
+#define REG_TOUCH_RZTHRESH   1058052UL
+#define REG_TOUCH_SCREEN_XY  1058064UL
+#define REG_TOUCH_SETTLE     1058044UL
+#define REG_TOUCH_TAG        1058072UL
+#define REG_TOUCH_TAG_XY     1058068UL
+#define REG_TOUCH_TRANSFORM_A 1058076UL
+#define REG_TOUCH_TRANSFORM_B 1058080UL
+#define REG_TOUCH_TRANSFORM_C 1058084UL
+#define REG_TOUCH_TRANSFORM_D 1058088UL
+#define REG_TOUCH_TRANSFORM_E 1058092UL
+#define REG_TOUCH_TRANSFORM_F 1058096UL
+#define REG_TRACKER          1085440UL
+#define REG_VCYCLE           1057852UL
+#define REG_VOFFSET          1057856UL
+#define REG_VOL_PB           1057916UL
+#define REG_VOL_SOUND        1057920UL
+#define REG_VSIZE            1057860UL
+#define REG_VSYNC0           1057864UL
+#define REG_VSYNC1           1057868UL
+
+#define VERTEX2II(x, y, handle, cell) \
+        ((2UL << 30) | (((x) & 511UL) << 21) | (((y) & 511UL) << 12) | (((handle) & 31) << 7) | (((cell) & 127) << 0))
+
+#define ROM_PIXEL_FF        0xc0400UL
+
+class Poly {
+    int x0, y0, x1, y1;
+    int x[8], y[8];
+    byte n;
+    void restart() {
+      n = 0;
+      x0 = 16 * 480;
+      x1 = 0;
+      y0 = 16 * 272;
+      y1 = 0;
+    }
+    void perim() {
+      for (byte i = 0; i < n; i++)
+        GD.Vertex2f(x[i], y[i]);
+      GD.Vertex2f(x[0], y[0]);
+    }
+  public:
+    void begin() {
+      restart();
+
+      GD.ColorMask(0,0,0,0);
+      GD.StencilOp(KEEP, INVERT);
+      GD.StencilFunc(ALWAYS, 255, 255);
+    }
+    void v(int _x, int _y) {
+      x0 = min(x0, _x >> 4);
+      x1 = max(x1, _x >> 4);
+      y0 = min(y0, _y >> 4);
+      y1 = max(y1, _y >> 4);
+      x[n] = _x;
+      y[n] = _y;
+      n++;
+    }
+    void paint() {
+      x0 = max(0, x0);
+      y0 = max(0, y0);
+      x1 = min(16 * 480, x1);
+      y1 = min(16 * 272, y1);
+      GD.ScissorXY(x0, y0);
+      GD.ScissorSize(x1 - x0 + 1, y1 - y0 + 1);
+      GD.Begin(EDGE_STRIP_B);
+      perim();
+    }
+    void finish() {
+      GD.ColorMask(1,1,1,1);
+      GD.StencilFunc(EQUAL, 255, 255);
+
+      GD.Begin(EDGE_STRIP_B);
+      GD.Vertex2ii(0, 0);
+      GD.Vertex2ii(511, 0);
+    }
+    void draw() {
+      paint();
+      finish();
+    }
+    void outline() {
+      GD.Begin(LINE_STRIP);
+      perim();
+    }
+};
+
+#if !defined(RASPBERRY_PI) && !defined(EMUPC)
+class Streamer {
+public:
+  void begin(const char *rawsamples,
+             uint16_t freq = 44100,
+             byte format = ADPCM_SAMPLES,
+             uint32_t _base = (0x40000UL - 8192), uint16_t size = 8192) {
+    r.openfile(rawsamples);
+
+    base = _base;
+    mask = size - 1;
+    wp = 0;
+
+    for (byte i = 10; i; i--)
+      feed();
+
+    GD.sample(base, size, freq, format, 1);
+  }
+  int feed() {
+    uint16_t rp = GD.rd32(REG_PLAYBACK_READPTR) - base;
+    uint16_t freespace = mask & ((rp - 1) - wp);
+    if (freespace >= 512) {
+      // REPORT(base);
+      // REPORT(rp);
+      // REPORT(wp);
+      // REPORT(freespace);
+      // Serial.println();
+      byte buf[512];
+      // uint16_t n = min(512, r.size - r.offset);
+      // n = (n + 3) & ~3;   // force 32-bit alignment
+      GD.__end();
+      r.readsector(buf);
+      GD.resume();
+      GD.cmd_memwrite(base + wp, 512);
+      GD.copyram(buf, 512);
+      wp = (wp + 512) & mask;
+    }
+    return r.offset < r.size;
+  }
+  void progress(uint16_t &val, uint16_t &range) {
+    uint32_t m = r.size;
+    uint32_t p = min(r.offset, m);
+    while (m > 0x10000) {
+      m >>= 1;
+      p >>= 1;
+    }
+    val = p;
+    range = m;
+  }
+private:
+  Reader r;
+  uint32_t base;
+  uint16_t mask;
+  uint16_t wp;
+};
+#else
+class Streamer {
+public:
+  void begin(const char *rawsamples,
+             uint16_t freq = 44100,
+             byte format = ADPCM_SAMPLES,
+             uint32_t _base = (0x40000UL - 4096), uint16_t size = 4096) {}
+  int feed() {}
+  void progress(uint16_t &val, uint16_t &range) {}
+};
+
+#endif
+
+static byte sinus(byte x)
+{
+  return 128 + GD.rsin(128, -16384 + (x << 7));
+}
+
+// JCB{
+static void caption(int t, const char *text)
+{
+
+  if ((0 <= t) && (t < 128)) {
+    int sz = strlen(text) * 8;
+    GD.RestoreContext();
+    GD.Begin(LINES);
+    GD.LineWidth(9 * 16);
+    byte fade;
+    if (t < 96)
+      fade = 0xff;
+    else
+      fade = 0xff - ((t - 96) * 8);
+    GD.ColorA(fade >> 1);
+    GD.ColorRGB(0x000000);
+    int y = 259;
+
+    byte slide = sinus(min(255, t * 16));
+    int x = ((slide * (long)sz) >> 8);
+    GD.Vertex2ii(480, y);
+    GD.Vertex2ii(470 - x, y);
+
+    GD.ColorRGB(0xffffff);
+    if (t < 16) {
+      GD.ColorA(fade >> 2);
+      for (int i = 8; i >= 0; i -= 2)
+        GD.cmd_text(470 - x + sz + i, y, 26, OPT_CENTERY | OPT_RIGHTX, text);
+    } else {
+      GD.ColorA(fade);
+      GD.cmd_text(470 - x + sz, y, 26, OPT_CENTERY | OPT_RIGHTX, text);
+    }
+  }
+}
+// }JCB
+
+#endif

+ 61 - 0
blobs.ino

@@ -0,0 +1,61 @@
+#include <EEPROM.h>
+#include <SPI.h>
+#include <GD2.h>
+
+#define NBLOBS      128 //' a{
+#define OFFSCREEN   -16384
+
+struct xy {
+  int x, y;
+} blobs[NBLOBS];
+
+void setup()
+{
+  GD.begin();
+
+  for (int i = 0; i < NBLOBS; i++) {
+    blobs[i].x = OFFSCREEN;
+    blobs[i].y = OFFSCREEN;
+  }
+  Serial.begin(1000000);    // JCB
+} //' }a
+
+void loop() //' b{
+{
+  static byte blob_i;
+  GD.get_inputs();
+  if (GD.inputs.x != -32768) {
+    blobs[blob_i].x = GD.inputs.x << 4; //' xy{
+    blobs[blob_i].y = GD.inputs.y << 4; //' }xy
+  } else {
+    blobs[blob_i].x = OFFSCREEN;
+    blobs[blob_i].y = OFFSCREEN;
+  }
+  blob_i = (blob_i + 1) & (NBLOBS - 1);
+
+  GD.ClearColorRGB(0xd0d0c0); // JCB
+  GD.ClearColorRGB(0xe0e0e0);
+  GD.Clear();
+  GD.Begin(BITMAPS);      // JCB
+  GD.BitmapSize(NEAREST, REPEAT, REPEAT, 480, 272); // JCB
+  GD.Vertex2ii(0, 0); // JCB
+
+  // Draw the blobs from oldest to youngest // JCB
+  GD.Begin(POINTS);
+  for (int i = 0; i < NBLOBS; i++) {
+    // Blobs fade away and swell as they age
+    GD.ColorA(i << 1);
+    GD.PointSize((1024 + 16) - (i << 3));
+
+    // Random color for each blob, keyed from (blob_i + i)
+    uint8_t j = (blob_i + i) & (NBLOBS - 1);
+    byte r = j * 17;
+    byte g = j * 23;
+    byte b = j * 147;
+    GD.ColorRGB(r, g, b);
+
+    // Draw it!
+    GD.Vertex2f(blobs[j].x, blobs[j].y);
+  }
+  GD.swap();
+} //' }b

+ 312 - 0
chess.ino

@@ -0,0 +1,312 @@
+#include <EEPROM.h>
+#include <SPI.h>
+#include <GD2.h>
+
+#include "chess_assets.h"
+
+void setup()
+{
+  Serial.begin(1000000);    // JCB
+  GD.begin();
+  LOAD_ASSETS();
+  GD.BitmapHandle(1);
+  GD.BitmapSource(CHECKER);
+  GD.BitmapSize(NEAREST, REPEAT, REPEAT, 256, 256);
+  GD.BitmapLayout(L8, CHECKER_WIDTH, CHECKER_HEIGHT);
+}
+
+/***************************************************************************/
+/*                               micro-Max,                                */
+/* A chess program smaller than 2KB (of non-blank source), by H.G. Muller  */
+/* Port to Atmel ATMega644 and AVR GCC, by Andre Adrian                    */
+/***************************************************************************/
+/* version 4.8 (1953 characters) features:                                 */
+/* - recursive negamax search                                              */
+/* - all-capture MVV/LVA quiescence search                                 */
+/* - (internal) iterative deepening                                        */
+/* - best-move-first 'sorting'                                             */
+/* - a hash table storing score and best move                              */
+/* - futility pruning                                                      */
+/* - king safety through magnetic, frozen king in middle-game              */
+/* - R=2 null-move pruning                                                 */
+/* - keep hash and repetition-draw detection                               */
+/* - better defense against passers through gradual promotion              */
+/* - extend check evasions in inner nodes                                  */
+/* - reduction of all non-Pawn, non-capture moves except hash move (LMR)   */
+/* - full FIDE rules (expt under-promotion) and move-legality checking     */
+
+/* 26nov2008 no hash table                                                 */
+/* 29nov2008 all IO via myputchar(), mygetchar(), pseudo random generator  */
+
+#define VERBOSE
+
+#define W while
+#define M 0x88
+#define S 128
+#define I 8000
+
+long N, T;                  /* N=evaluated positions+S, T=recursion limit */
+short Q,O,K,R,k=16;        /* k=moving side */
+char *p,c[5],Z;   /* p=pointer to c, c=user input, computer output, Z=recursion counter */
+
+char L,
+w[]={0,2,2,7,-1,8,12,23},                      /* relative piece values    */
+o[]={-16,-15,-17,0,1,16,0,1,16,15,17,0,14,18,31,33,0, /* step-vector lists */
+     7,-1,11,6,8,3,6,                          /* 1st dir. in o[] per piece*/
+     6,3,5,7,4,5,3,6},                         /* initial piece setup      */
+b[]={     /* board is left part, center-pts table is right part, and dummy */
+  22, 19, 21, 23, 20, 21, 19, 22, 28, 21, 16, 13, 12, 13, 16, 21, 
+  18, 18, 18, 18, 18, 18, 18, 18, 22, 15, 10,  7,  6,  7, 10, 15, 
+   0,  0,  0,  0,  0,  0,  0,  0, 18, 11,  6,  3,  2,  3,  6, 11, 
+   0,  0,  0,  0,  0,  0,  0,  0, 16,  9,  4,  1,  0,  1,  4,  9, 
+   0,  0,  0,  0,  0,  0,  0,  0, 16,  9,  4,  1,  0,  1,  4,  9, 
+   0,  0,  0,  0,  0,  0,  0,  0, 18, 11,  6,  3,  2,  3,  6, 11, 
+   9,  9,  9,  9,  9,  9,  9,  9, 22, 15, 10,  7,  6,  7, 10, 15, 
+  14, 11, 13, 15, 12, 13, 11, 14, 28, 21, 16, 13, 12, 13, 16, 21, 0
+};
+
+volatile char breakpoint; /* for debugger */
+                                
+/* User interface routines */
+void myputchar(char c) {
+#ifdef EMUPC    // JCB{
+  fprintf(stderr, "%c", c);
+#endif    // }JCB
+}
+
+void myputs(const char *s) {
+  while(*s) myputchar(*s++);
+  myputchar('\n');
+}
+
+char mygetchar(void) {
+  return 10;                          /* self play computer with computer */
+#ifdef VERBOSE
+  return getchar();
+#else  
+  return 10;                          /* self play computer with computer */
+#endif  
+}
+
+/* 16bit pseudo random generator */
+#define MYRAND_MAX 65535
+
+unsigned short r = 1;                     /* pseudo random generator seed */
+
+void mysrand(unsigned short r_) {
+ r = r_;
+}
+
+unsigned short myrand(void) {
+ return r=((r<<11)+(r<<7)+r)>>1;
+}
+
+static void sp()
+{
+  void* x;
+  x = &x;
+  Serial.println((size_t)x, HEX);
+}
+
+short D(short q, short l, short e, byte E,byte z, byte n)                          /* recursive minimax search */
+     /* (q,l)=window, e=current eval. score, */
+     /* E=e.p. sqr.z=prev.dest, n=depth; return score */        
+{                       
+ short m,v,i,P,V,s;
+ unsigned char t,p,u,x,y,X,Y,H,B,j,d,h,F,G,C;
+ signed char r;
+
+ // if (0) { REPORT(Z); sp(); }
+ if (++Z>30) {                                     /* stack underrun check */
+  breakpoint=1;               /* AVR Studio 4 Breakpoint for stack underrun */
+  myputchar('u');
+  --Z;return e;                                    
+ }
+ 
+ q--;                                          /* adj. window: delay bonus */
+ k^=24;                                        /* change sides             */
+ d=Y=0;                                        /* start iter. from scratch */
+ X=myrand()&~M;                                /* start at random field    */
+ W(d++<n||d<3||                                /* iterative deepening loop */
+   z&K==I&&(N<T&d<98||                         /* root: deepen upto time   */
+   (K=X,L=Y&~M,d=3)))                          /* time's up: go do best    */
+ {x=B=X;                                       /* start scan at prev. best */
+  h=Y&S;                                       /* request try noncastl. 1st*/
+  P=d<3?I:D(-l,1-l,-e,S,0,d-3);                /* Search null move         */
+  m=-P<l|R>35?d>2?-I:e:-P;                     /* Prune or stand-pat       */
+  ++N;                                         /* node count (for timing)  */
+  do{u=b[x];                                   /* scan board looking for   */
+   if(u&k)                                     /*  own piece (inefficient!)*/
+   {r=p=u&7;                                   /* p = piece type (set r>0) */
+    j=o[p+16];                                 /* first step vector f.piece*/
+    W(r=p>2&r<0?-r:-o[++j])                    /* loop over directions o[] */
+    {A:                                        /* resume normal after best */
+     y=x;F=G=S;                                /* (x,y)=move, (F,G)=castl.R*/
+     do{                                       /* y traverses ray, or:     */
+      H=y=h?Y^h:y+r;                           /* sneak in prev. best move */
+      if(y&M)break;                            /* board edge hit           */
+      m=E-S&b[E]&&y-E<2&E-y<2?I:m;             /* bad castling             */
+      if(p<3&y==E)H^=16;                       /* shift capt.sqr. H if e.p.*/
+      t=b[H];if(t&k|p<3&!(y-x&7)-!t)break;     /* capt. own, bad pawn mode */
+      i=37*w[t&7]+(t&192);                     /* value of capt. piece t   */
+      m=i<0?I:m;                               /* K capture                */
+      if(m>=l&d>1)goto C;                      /* abort on fail high       */
+      v=d-1?e:i-p;                             /* MVV/LVA scoring          */
+      if(d-!t>1)                               /* remaining depth          */
+      {v=p<6?b[x+8]-b[y+8]:0;                  /* center positional pts.   */
+       b[G]=b[H]=b[x]=0;b[y]=u|32;             /* do move, set non-virgin  */
+       if(!(G&M))b[F]=k+6,v+=50;               /* castling: put R & score  */
+       v-=p-4|R>29?0:20;                       /* penalize mid-game K move */
+       if(p<3)                                 /* pawns:                   */
+       {v-=9*((x-2&M||b[x-2]-u)+               /* structure, undefended    */
+              (x+2&M||b[x+2]-u)-1              /*        squares plus bias */
+             +(b[x^16]==k+36))                 /* kling to non-virgin King */
+             -(R>>2);                          /* end-game Pawn-push bonus */
+        V=y+r+1&S?647-p:2*(u&y+16&32);         /* promotion or 6/7th bonus */
+        b[y]+=V;i+=V;                          /* change piece, add score  */
+       }
+       v+=e+i;V=m>q?m:q;                       /* new eval and alpha       */
+       C=d-1-(d>5&p>2&!t&!h);
+       C=R>29|d<3|P-I?C:d;                     /* extend 1 ply if in check */
+       do
+        s=C>2|v>V?-D(-l,-V,-v,                 /* recursive eval. of reply */
+                              F,0,C):v;        /* or fail low if futile    */
+       W(s>q&++C<d);v=s;
+       if(z&&K-I&&v+I&&x==K&y==L)              /* move pending & in root:  */
+       {Q=-e-i;O=F;                            /*   exit if legal & found  */
+        R+=i>>7;--Z;return l;                  /* captured non-P material  */
+       }
+       b[G]=k+6;b[F]=b[y]=0;b[x]=u;b[H]=t;     /* undo move,G can be dummy */
+      }
+      if(v>m)                                  /* new best, update max,best*/
+       m=v,X=x,Y=y|S&F;                        /* mark double move with S  */
+      if(h){h=0;goto A;}                       /* redo after doing old best*/
+      if(x+r-y|u&32|                           /* not 1st step,moved before*/
+         p>2&(p-4|j-7||                        /* no P & no lateral K move,*/
+         b[G=x+3^r>>1&7]-k-6                   /* no virgin R in corner G, */
+         ||b[G^1]|b[G^2])                      /* no 2 empty sq. next to R */
+        )t+=p<5;                               /* fake capt. for nonsliding*/
+      else F=y;                                /* enable e.p.              */
+     }W(!t);                                   /* if not capt. continue ray*/
+  }}}W((x=x+9&~M)-B);                          /* next sqr. of board, wrap */
+C:if(m>I-M|m<M-I)d=98;                         /* mate holds to any depth  */
+  m=m+I|P==I?m:0;                              /* best loses K: (stale)mate*/
+  if(z&&d>2)
+   {*c='a'+(X&7);c[1]='8'-(X>>4);c[2]='a'+(Y&7);c[3]='8'-(Y>>4&7);c[4]=0;
+    breakpoint=2;           /* AVR Studio 4 Breakpoint for moves, watch c[] */
+#ifdef EMUPC    // JCB{
+    fprintf(stderr, "%2d ply, %9d searched, score=%6d by %c%c%c%c\n",d-1,N-S,m,
+     'a'+(X&7),'8'-(X>>4),'a'+(Y&7),'8'-(Y>>4&7)); /* uncomment for Kibitz */   
+#else
+    REPORT(d);
+    Serial.println(c);
+#endif          // }JCB
+  }  
+ }                                             /*    encoded in X S,8 bits */
+ k^=24;                                        /* change sides back        */
+ --Z;return m+=m<e;                            /* delayed-loss bonus       */
+}
+
+void print_board()
+{
+ short N=-1;
+ W(++N<121)
+  myputchar(N&8&&(N+=7)?10:".?inkbrq?I?NKBRQ"[b[N]&15]);      /* Pawn is i */
+}
+
+static void p2(int &x, int &y, const char *c)
+{
+  x = 16 * (32 + 32 * (c[0] - 'a'));
+  y = 16 * ( 8 + 32 * ('8' - c[1]));
+}
+
+#define MOVETIME    10
+#define OVERSAMPLE  8
+
+int clocks[2];
+
+void draw_board()
+{
+//                .  ?  i  n  k  b  r  q  ?  I  ?  N  K  B  R  Q
+  byte xlat[] = { 0, 0, 0, 1, 5, 2, 3, 4, 0, 6, 0, 7, 11,8, 9,10 };
+
+  for (int i = 0; i < MOVETIME; i++) {
+    GD.cmd_gradient(0, 0, 0x101010, 480, 272, 0x202060);
+    GD.cmd_bgcolor(0x101020);
+
+    GD.Begin(BITMAPS);
+    GD.SaveContext();
+    GD.ColorRGB(0xfff0c0);
+    GD.ColorA(0xc0);
+    GD.cmd_scale(F16(32), F16(32));
+    GD.cmd_setmatrix();
+    GD.Vertex2ii(32, 8, 1, 0);
+    GD.RestoreContext();
+
+    int moving = -1;
+    if (c[0])
+      moving = 16 * ('8' - c[3]) + (c[2] - 'a');
+
+    GD.Begin(BITMAPS);
+    GD.ColorRGB(0xe0e0e0);
+    for (int y = 0; y < 8; y++)
+      for (int x = 0; x < 8; x++) {
+        int pos = 16 * y + x;
+        byte piece = b[pos] & 15;
+        if (pos != moving && piece != 0)
+          GD.Vertex2ii(32 + 32 * x, 8 + 32 * y, 0, xlat[piece]);
+      }
+
+    if (c[0]) {
+      GD.Begin(BITMAPS);
+      byte piece = b[moving] & 15;
+      GD.Cell(xlat[piece]);
+      int x0, y0, x1, y1;
+      p2(x0, y0, c + 0);
+      p2(x1, y1, c + 2);
+      GD.ColorRGB(0xffffff);    //' a{
+      GD.ColorA((255 / OVERSAMPLE) + 50);
+      for (int j = 0; j < OVERSAMPLE; j++) {
+        byte linear = 255 * (i * OVERSAMPLE + j) /
+                            (OVERSAMPLE * MOVETIME - 1);
+        byte scurve = sinus(linear);
+        int x = x0 + (long)(x1 - x0) * scurve / 255;
+        int y = y0 + (long)(y1 - y0) * scurve / 255;
+
+        GD.Vertex2f(x, y);
+      } //' }a
+      GD.ColorA(255);
+    }
+
+    GD.ColorRGB((k == 16) ? 0xffffffUL : 0x606060);
+    GD.cmd_clock(384,       60, 50, OPT_FLAT | OPT_NOSECS, 0, 0, clocks[0], 0);
+    GD.ColorRGB((k != 16) ? 0xffffffUL : 0x606060);
+    GD.cmd_clock(384, 272 - 60, 50, OPT_FLAT | OPT_NOSECS, 0, 0, clocks[1], 0);
+
+    GD.ColorRGB(0xffffff);
+    GD.cmd_text(384, 136, 30, OPT_CENTER, c);
+
+    GD.swap();
+  }
+}
+
+void loop()
+{
+
+#ifdef VERBOSE  // JCB{
+  print_board();
+#endif          // }JCB
+  draw_board();
+  K=I;                                               /* invalid move       */
+#if 0           // JCB{
+  p=c;W((*p++=mygetchar())>10);                      /* read input line    */
+  if(*c-10)K=*c-16*c[1]+799,L=c[2]-16*c[3]+799;      /* parse entered move */
+#endif          // }JCB
+  N=0;T=0x9;                                  /* T=Computer Play strength */
+ long t0 = millis();
+ if(!(D(-I,I,Q,O,1,3)>-I+1))                           /* think or check & do*/
+   for (;;);
+ int took = 60 * (millis() - t0) / 1000;
+ clocks[(k==16)] += took;
+}
+

+ 440 - 0
cobra.ino

@@ -0,0 +1,440 @@
+#include <EEPROM.h>
+#include <SPI.h>
+#include <GD2.h>
+
+#include "cobra_assets.h"
+
+////////////////////////////////////////////////////////////////////////////////
+//                                  3D Projection
+////////////////////////////////////////////////////////////////////////////////
+
+static float model_mat[9] = { 1.0, 0.0, 0.0,
+                        0.0, 1.0, 0.0,
+                        0.0, 0.0, 1.0 };
+static float normal_mat[9] = { 1.0, 0.0, 0.0,
+                        0.0, 1.0, 0.0,
+                        0.0, 0.0, 1.0 };
+
+#define M(nm,i,j)       ((nm)[3 * (i) + (j)])
+
+void mult_matrices(float *a, float *b, float *c)
+{
+  int i, j, k;
+  float result[9];
+  for(i = 0; i < 3; i++) {
+    for(j = 0; j < 3; j++) {
+      M(result,i,j) = 0.0f;
+      for(k = 0; k < 3; k++) {
+        M(result,i,j) +=  M(a,i,k) *  M(b,k,j);
+      }
+    }
+  }
+  memcpy(c, result, sizeof(result));
+}
+
+// Based on glRotate()
+// Returns 3x3 rotation matrix in 'm'
+// and its invese in 'mi'
+
+static void rotate(float *m, float *mi, float angle, float *axis)
+{
+  float x = axis[0];
+  float y = axis[1];
+  float z = axis[2];
+
+  float s = sin(angle);
+  float c = cos(angle);
+
+  float xx = x*x*(1-c);
+  float xy = x*y*(1-c);
+  float xz = x*z*(1-c);
+  float yy = y*y*(1-c);
+  float yz = y*z*(1-c);
+  float zz = z*z*(1-c);
+
+  float xs = x * s;
+  float ys = y * s;
+  float zs = z * s;
+
+  m[0] = xx + c;
+  m[1] = xy - zs;
+  m[2] = xz + ys;
+
+  m[3] = xy + zs;
+  m[4] = yy + c;
+  m[5] = yz - xs;
+
+  m[6] = xz - ys;
+  m[7] = yz + xs;
+  m[8] = zz + c;
+
+  mi[0] = m[0];
+  mi[1] = xy + zs;
+  mi[2] = xz - ys;
+
+  mi[3] = xy - zs;
+  mi[4] = m[4];
+  mi[5] = yz + xs;
+
+  mi[6] = xz + ys;
+  mi[7] = yz - xs;
+  mi[8] = m[8];
+}
+
+static void rotation(float angle, float *axis)
+{
+  float mat[9];
+  float mati[9];
+
+  rotate(mat, mati, angle, axis);
+  mult_matrices(model_mat, mat, model_mat);
+  mult_matrices(mati, normal_mat, normal_mat);
+}
+
+#if 0 // JCB{
+class Vector3
+{
+public:
+    float x, y, z;
+
+    void set(float _x, float _y, float _z) {
+        x = _x;
+        y = _y;
+        z = _z;
+    }
+
+    // functions
+    void normalize() {
+      float invLength = 1 / sqrtf(x*x + y*y + z*z);
+      x *= invLength;
+      y *= invLength;
+      z *= invLength;
+    }
+    Vector3& operator-=(const Vector3& rhs) {
+      x -= rhs.x;
+      y -= rhs.y;
+      z -= rhs.z;
+    }
+    void cross(const Vector3& rhs) {
+        float _x = y*rhs.z - z*rhs.y;
+        float _y = z*rhs.x - x*rhs.z;
+        float _z = x*rhs.y - y*rhs.x;
+        set(_x, _y, _z);
+    }
+};
+#endif
+// }JCB
+
+#define N_VERTICES  (sizeof(COBRA_vertices) / 3)
+
+typedef struct {
+  int x, y;
+  float z;
+} xyz;
+
+static xyz projected[N_VERTICES];
+
+void project(float distance)
+{
+  byte vx;
+  const PROGMEM int8_t *pm = COBRA_vertices; 
+  const PROGMEM int8_t *pm_e = pm + sizeof(COBRA_vertices);
+  xyz *dst = projected;
+  int8_t x, y, z;
+
+  while (pm < pm_e) {
+    x = pgm_read_byte_near(pm++);
+    y = pgm_read_byte_near(pm++);
+    z = pgm_read_byte_near(pm++);
+    float xx = x * model_mat[0] + y * model_mat[3] + z * model_mat[6];
+    float yy = x * model_mat[1] + y * model_mat[4] + z * model_mat[7];
+    float zz = x * model_mat[2] + y * model_mat[5] + z * model_mat[8] + distance;
+    float q = 240 / (100 + zz);
+    dst->x = 16 * (240 + xx * q);
+    dst->y = 16 * (136 + yy * q);
+    dst->z = zz;
+    dst++;
+  }
+}
+
+static void transform_normal(int8_t &nx, int8_t &ny, int8_t &nz)
+{
+  int8_t xx = nx * normal_mat[0] + ny * normal_mat[1] + nz * normal_mat[2];
+  int8_t yy = nx * normal_mat[3] + ny * normal_mat[4] + nz * normal_mat[5];
+  int8_t zz = nx * normal_mat[6] + ny * normal_mat[7] + nz * normal_mat[8];
+  nx = xx;
+  ny = yy;
+  nz = zz;
+}
+
+#define EDGE_BYTES  5
+static byte visible_edges[EDGE_BYTES];
+
+void draw_faces()
+{
+  memset(visible_edges, 0, sizeof(visible_edges));
+
+  const PROGMEM uint8_t *p = COBRA_faces; 
+  byte n;
+  int c = 1;
+  Poly po;
+  while ((n = pgm_read_byte_near(p++)) != 0xff) {
+    int8_t nx = pgm_read_byte_near(p++);
+    int8_t ny = pgm_read_byte_near(p++);
+    int8_t nz = pgm_read_byte_near(p++);
+    byte face_edges[EDGE_BYTES];
+    for (byte i = 0; i < EDGE_BYTES; i++)
+      face_edges[i] = pgm_read_byte_near(p++);
+    byte v1 = pgm_read_byte_near(p);
+    byte v2 = pgm_read_byte_near(p + 1);
+    byte v3 = pgm_read_byte_near(p + 2);
+    long x1 = projected[v1].x;
+    long y1 = projected[v1].y;
+    long x2 = projected[v2].x;
+    long y2 = projected[v2].y;
+    long x3 = projected[v3].x;
+    long y3 = projected[v3].y;
+    long area = (x1 - x3) * (y2 - y1) - (x1 - x2) * (y3 - y1);
+
+    if (area > 0) {
+      for (byte i = 0; i < EDGE_BYTES; i++)
+        visible_edges[i] |= face_edges[i];
+      po.begin();
+      for (int i = 0; i < n; i++) {
+        byte vi = pgm_read_byte_near(p++);
+        xyz *v = &projected[vi];
+        po.v(v->x, v->y);
+      }
+      {
+        transform_normal(nx, ny, nz);
+
+        uint16_t r = 10, g = 10, b = 20;  // Ambient
+
+        int d = -ny;                      // diffuse light from +ve Y
+        if (d > 0) {
+          r += d >> 2;
+          g += d >> 1;
+          b += d;
+        }
+                                          // use specular half angle
+        d = ny * -90 + nz * -90;          // Range -16384 to +16384
+        if (d > 8192) {
+          byte l = pgm_read_byte_near(shiny + ((d - 8192) >> 4));
+          r += l;
+          g += l;
+          b += l;
+        }
+
+        /*  JCB{
+        d = nx;
+        if (d > 0)  
+          r += d >> 3;
+        d = -nx;
+        if (d > 0) 
+          g += d >> 3; }JCB */  
+        GD.ColorRGB(min(255, r), min(255, g), min(255, b));
+      }
+      po.draw();
+    } else {
+      p += n;
+    }
+    c += 1;
+  }
+}
+
+void draw_edges()
+{
+  GD.ColorRGB(0x2e666e);
+  GD.Begin(LINES);
+  GD.LineWidth(20);
+
+  const PROGMEM uint8_t *p = COBRA_edges; 
+  byte *pvis = visible_edges;
+  byte vis;
+
+  for (byte i = 0; i < sizeof(COBRA_edges) / 2; i++) {
+    if ((i & 7) == 0)
+      vis = *pvis++;
+    byte v0 = pgm_read_byte_near(p++);
+    byte v1 = pgm_read_byte_near(p++);
+
+    if (vis & 1) {
+      int x0 = projected[v0].x;
+      int y0 = projected[v0].y;
+      int x1 = projected[v1].x;
+      int y1 = projected[v1].y;
+
+      GD.Vertex2f(x0,y0);
+      GD.Vertex2f(x1,y1);
+    }
+    vis >>= 1;
+  }
+}
+
+static void draw_navlight(byte nf)
+{
+  float l0z = projected[N_VERTICES - 2].z;
+  float l1z = projected[N_VERTICES - 1].z;
+  byte i;
+  if (nf == 0)  // draw the one with smallest z
+    i = (l0z < l1z) ? (N_VERTICES - 2) : (N_VERTICES - 1);
+  else
+    i = (l0z < l1z) ? (N_VERTICES - 1) : (N_VERTICES - 2);
+
+  GD.SaveContext();
+  GD.BlendFunc(SRC_ALPHA, ONE);
+  GD.Begin(BITMAPS);
+  GD.BitmapHandle(LIGHT_HANDLE);
+ 
+  GD.ColorRGB((i == N_VERTICES - 2) ? 0xfe2b18 : 0x4fff82);
+  GD.Vertex2f(projected[i].x - (16 * LIGHT_WIDTH / 2),
+              projected[i].y - (16 * LIGHT_WIDTH / 2));
+  GD.RestoreContext();
+}
+
+/*****************************************************************/
+
+/* simple trackball-like motion control */
+/* Based on projtex.c - by David Yu and David Blythe, SGI */
+
+float angle, axis[3] = {0,1,0};
+float lastPos[3];
+
+void
+ptov(int x, int y, int width, int height, float v[3])
+{
+  float d, a;
+
+  /* project x,y onto a hemi-sphere centered within width, height */
+  v[0] = (2.0 * x - width) / width;
+  v[1] = (2.0 * y - height) / height;
+  d = sqrt(v[0] * v[0] + v[1] * v[1]);
+  v[2] = cos((M_PI / 2.0) * ((d < 1.0) ? d : 1.0));
+  a = 1.0 / sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+  v[0] *= a;
+  v[1] *= a;
+  v[2] *= a;
+}
+
+void
+startMotion(int x, int y)
+{
+  angle = 0.0;
+  ptov(x, y, 480, 272, lastPos);
+}
+
+void
+trackMotion(int x, int y)
+{
+  float curPos[3], dx, dy, dz;
+
+  ptov(x, y, 480, 272, curPos);
+
+  dx = curPos[0] - lastPos[0];
+  dy = curPos[1] - lastPos[1];
+  dz = curPos[2] - lastPos[2];
+  angle = (M_PI / 2) * sqrt(dx * dx + dy * dy + dz * dz);
+
+  axis[0] = lastPos[1] * curPos[2] - lastPos[2] * curPos[1];
+  axis[1] = lastPos[2] * curPos[0] - lastPos[0] * curPos[2];
+  axis[2] = lastPos[0] * curPos[1] - lastPos[1] * curPos[0];
+
+  float mag = 1 / sqrt(axis[0] * axis[0] + axis[1] * axis[1] + axis[2] * axis[2]);
+  axis[0] *= mag;
+  axis[1] *= mag;
+  axis[2] *= mag;
+
+  lastPos[0] = curPos[0];
+  lastPos[1] = curPos[1];
+  lastPos[2] = curPos[2];
+}
+
+/*****************************************************************/
+
+
+void setup()
+{
+  Serial.begin(57600);
+  GD.begin();
+  LOAD_ASSETS();
+  GD.BitmapHandle(BACKGROUND_HANDLE);
+  GD.BitmapSize(BILINEAR, REPEAT, REPEAT, 480, 272);
+#ifdef EMUPC    // JCB{
+  // startMotion(240, 136);
+  // trackMotion(240, 138);
+#endif          // }JCB
+}
+
+static byte prev_touching;
+static uint16_t t;
+
+static void draw_sun(int x, int y, int rot)
+{
+  GD.cmd_loadidentity();
+  GD.cmd_translate(F16(SUN_WIDTH / 2), F16(SUN_WIDTH / 2));
+  GD.cmd_rotate(rot);
+  GD.cmd_translate(-F16(SUN_WIDTH / 2), -F16(SUN_WIDTH / 2));
+  GD.cmd_setmatrix();
+  GD.Vertex2f(x - (16 * SUN_WIDTH / 2), y - (16 * SUN_WIDTH / 2));
+}
+
+void loop()
+{
+  GD.Begin(BITMAPS);
+  GD.SaveContext();
+  GD.BitmapHandle(BACKGROUND_HANDLE);
+  GD.cmd_translate(-(long)t << 14, (long)t << 13);
+  GD.cmd_rotate(3312);
+  GD.cmd_setmatrix();
+  GD.Vertex2ii(0, 0, 0, 0);
+  GD.RestoreContext();
+
+  int et = t - 720;
+  int sun_x = (480 * 16) - (et << 2),
+      sun_y = (100 * 16) + (et << 1);
+  GD.SaveContext();
+  GD.PointSize(52 * 16);
+  GD.ColorRGB(0x000000);
+  GD.Begin(POINTS);
+  GD.Vertex2f(sun_x, sun_y);
+  GD.RestoreContext();
+
+  GD.SaveContext();
+  GD.Begin(BITMAPS);
+  GD.BlendFunc(ONE, ONE);
+  GD.BitmapHandle(SUN_HANDLE);
+  GD.ColorRGB(0xb0a090);
+  draw_sun(sun_x, sun_y, t << 6);
+  draw_sun(sun_x, sun_y, -t << 6);
+  GD.RestoreContext();
+
+  GD.get_inputs();
+  byte touching = (GD.inputs.x != -32768);
+  if (!prev_touching && touching)
+    startMotion(GD.inputs.x, GD.inputs.y);
+  else if (touching)
+    trackMotion(GD.inputs.x, GD.inputs.y);
+  prev_touching = touching;
+
+  unsigned long t0 = micros();
+
+  if (angle != 0.0f)
+    rotation(angle, axis);
+
+  project(0);
+  draw_navlight(1);
+  draw_faces();
+  GD.RestoreContext();
+  draw_edges();
+  draw_navlight(0);
+  GD.RestoreContext();
+#ifndef EMUPC // JCB{
+  GD.cmd_number(240, 7, 26, OPT_CENTER, micros() - t0);
+#else
+  // GD.cmd_number(240, 7, 26, OPT_CENTER, t);
+#endif        // }JCB
+
+  GD.swap();
+
+  t++;
+}

+ 982 - 0
converted-assets/blobs_assets.h

@@ -0,0 +1,982 @@
+static const PROGMEM uint8_t __assets[14648] = {
+0, 0, 0, 5, 0, 0, 0, 1, 128, 0, 1, 8, 128, 0, 25, 7, 34, 255, 255,
+255, 0, 0, 0, 0, 120, 156, 21, 187, 103, 144, 36, 233, 125, 230, 119,
+113, 138, 80, 92, 156, 116, 188, 56, 146, 34, 9, 194, 145, 4, 22, 192,
+98, 23, 235, 237, 172, 157, 153, 29, 179, 227, 93, 123, 223, 213, 93,
+222, 123, 95, 89, 46, 51, 43, 125, 86, 86, 150, 247, 222, 251, 174,
+170, 246, 102, 252, 204, 58, 236, 98, 1, 66, 32, 113, 36, 168, 160,
+36, 138, 148, 66, 10, 221, 7, 125, 211, 59, 29, 211, 17, 53, 221, 149,
+249, 230, 251, 190, 255, 255, 243, 252, 158, 202, 236, 108, 46, 140,
+227, 120, 32, 128, 194, 30, 139, 203, 176, 242, 254, 194, 138, 216,
+135, 162, 36, 23, 230, 89, 138, 37, 48, 2, 103, 131, 108, 152, 99,
+105, 126, 107, 212, 109, 14, 135, 19, 255, 205, 69, 165, 213, 31, 137,
+196, 115, 161, 80, 40, 76, 194, 28, 67, 96, 8, 78, 34, 20, 133, 6, 60,
+186, 229, 121, 14, 183, 163, 86, 189, 217, 161, 81, 73, 21, 82, 185,
+94, 38, 214, 26, 165, 18, 141, 203, 195, 37, 163, 56, 201, 6, 19, 122,
+149, 195, 9, 193, 72, 32, 146, 140, 69, 51, 185, 108, 50, 23, 167, 41,
+28, 37, 16, 31, 6, 67, 86, 253, 202, 39, 107, 98, 129, 155, 165, 248,
+76, 34, 204, 18, 52, 139, 83, 193, 16, 205, 131, 75, 136, 166, 6, 147,
+78, 165, 63, 57, 177, 221, 90, 82, 217, 97, 46, 146, 202, 114, 177,
+16, 11, 190, 2, 36, 133, 80, 36, 140, 145, 88, 192, 107, 218, 152, 39,
+112, 135, 223, 100, 182, 88, 117, 18, 145, 82, 173, 210, 202, 196, 58,
+155, 70, 161, 176, 250, 249, 80, 152, 75, 164, 88, 70, 166, 119, 185,
+125, 48, 226, 230, 114, 217, 120, 54, 23, 79, 37, 19, 17, 26, 39, 24,
+52, 0, 38, 224, 52, 74, 110, 136, 213, 70, 140, 227, 194, 133, 124,
+156, 167, 8, 134, 123, 54, 121, 46, 18, 229, 226, 185, 222, 120, 88,
+108, 245, 247, 29, 215, 102, 54, 109, 24, 207, 103, 243, 177, 84, 44,
+20, 226, 192, 200, 28, 129, 177, 1, 56, 128, 17, 62, 135, 120, 14,
+229, 32, 175, 221, 98, 82, 169, 164, 74, 181, 81, 39, 219, 20, 27,
+156, 58, 161, 194, 228, 12, 50, 177, 88, 152, 199, 188, 155, 42, 23,
+12, 123, 81, 15, 25, 137, 71, 179, 201, 72, 56, 26, 143, 80, 20, 19,
+196, 9, 154, 132, 221, 78, 237, 45, 25, 196, 132, 162, 241, 116, 53,
+159, 77, 242, 33, 150, 11, 133, 192, 32, 177, 72, 56, 148, 29, 238,
+244, 43, 245, 250, 174, 241, 242, 212, 38, 4, 135, 34, 233, 84, 46,
+205, 51, 97, 134, 9, 96, 65, 6, 167, 41, 36, 64, 19, 46, 163, 118, 17,
+13, 185, 221, 86, 135, 73, 34, 53, 218, 12, 90, 157, 74, 162, 49, 58,
+181, 10, 179, 205, 1, 83, 233, 72, 36, 195, 226, 171, 74, 59, 10, 57,
+252, 126, 58, 149, 74, 68, 82, 41, 158, 15, 135, 192, 242, 7, 49, 148,
+13, 184, 253, 176, 234, 146, 210, 194, 70, 19, 153, 84, 45, 31, 75,
+167, 57, 58, 20, 101, 99, 17, 14, 188, 39, 146, 220, 218, 233, 212,
+90, 189, 19, 249, 181, 101, 185, 27, 166, 162, 217, 88, 58, 30, 98,
+130, 76, 0, 37, 131, 65, 134, 197, 48, 38, 136, 121, 181, 186, 85,
+134, 247, 217, 44, 22, 131, 92, 101, 116, 186, 229, 70, 133, 72, 165,
+52, 169, 52, 144, 221, 135, 35, 209, 116, 50, 194, 208, 98, 153, 41,
+224, 245, 160, 88, 44, 145, 73, 68, 248, 100, 144, 99, 194, 56, 236,
+199, 80, 80, 105, 24, 142, 75, 47, 57, 220, 68, 58, 89, 170, 182, 26,
+201, 116, 134, 39, 163, 197, 120, 36, 21, 14, 5, 99, 209, 124, 103,
+212, 45, 119, 118, 182, 164, 211, 2, 181, 203, 71, 48, 177, 92, 54,
+202, 243, 65, 10, 134, 3, 60, 19, 34, 253, 44, 71, 33, 94, 141, 100,
+45, 25, 67, 29, 6, 179, 86, 173, 178, 216, 189, 122, 249, 166, 64,
+166, 80, 105, 229, 54, 39, 204, 122, 67, 41, 10, 67, 146, 98, 129, 30,
+66, 112, 156, 138, 70, 83, 241, 40, 27, 101, 24, 138, 165, 176, 0, 18,
+8, 248, 73, 206, 239, 151, 220, 128, 60, 108, 166, 80, 175, 214, 155,
+181, 82, 38, 30, 141, 149, 114, 217, 84, 12, 140, 158, 200, 181, 39,
+91, 149, 222, 110, 83, 188, 44, 55, 64, 94, 130, 166, 83, 153, 112,
+48, 72, 83, 40, 225, 167, 105, 142, 68, 48, 60, 136, 57, 53, 27, 107,
+217, 8, 230, 179, 232, 13, 74, 133, 217, 225, 50, 108, 174, 46, 139,
+149, 18, 181, 202, 229, 66, 66, 4, 151, 74, 50, 72, 86, 184, 98, 3,
+51, 197, 232, 72, 44, 147, 137, 178, 52, 69, 146, 20, 75, 147, 24, 70,
+248, 25, 2, 117, 137, 175, 251, 184, 124, 186, 86, 170, 151, 219, 157,
+74, 38, 204, 135, 192, 171, 84, 50, 149, 204, 228, 51, 221, 209, 86,
+183, 213, 206, 75, 54, 212, 58, 7, 140, 211, 108, 40, 12, 214, 37,
+192, 248, 9, 156, 32, 232, 128, 7, 37, 40, 194, 44, 91, 90, 75, 49,
+62, 135, 77, 173, 53, 106, 181, 90, 189, 112, 121, 105, 94, 44, 148,
+171, 117, 86, 27, 40, 121, 62, 149, 205, 112, 137, 53, 161, 131, 197,
+81, 138, 142, 199, 64, 245, 179, 44, 193, 17, 44, 195, 51, 52, 205, 7,
+105, 18, 113, 138, 175, 147, 185, 108, 166, 80, 168, 55, 154, 173,
+106, 62, 26, 79, 148, 218, 213, 98, 62, 30, 206, 165, 114, 253, 209,
+120, 88, 41, 196, 101, 82, 171, 217, 13, 106, 238, 217, 49, 116, 144,
+192, 240, 0, 29, 64, 241, 0, 230, 15, 32, 152, 93, 58, 179, 150, 38,
+237, 6, 173, 6, 236, 190, 78, 34, 89, 93, 156, 157, 95, 90, 21, 202,
+12, 122, 139, 27, 242, 147, 177, 84, 153, 11, 204, 41, 141, 48, 130,
+176, 193, 72, 34, 150, 140, 5, 41, 140, 38, 57, 42, 196, 211, 160,
+215, 35, 172, 223, 165, 152, 99, 42, 241, 112, 188, 216, 108, 180, 43,
+149, 82, 54, 95, 109, 150, 58, 141, 124, 152, 203, 36, 179, 64, 124,
+90, 149, 92, 66, 38, 113, 64, 62, 47, 246, 76, 150, 80, 132, 35, 16,
+220, 135, 251, 224, 0, 137, 249, 32, 167, 223, 40, 157, 89, 225, 253,
+102, 149, 72, 46, 215, 56, 77, 122, 245, 234, 204, 194, 252, 34, 248,
+143, 78, 172, 49, 89, 3, 12, 31, 206, 224, 208, 130, 64, 105, 118,
+248, 72, 160, 40, 160, 183, 49, 2, 69, 80, 138, 162, 129, 208, 97, 84,
+8, 236, 165, 69, 156, 76, 112, 124, 44, 221, 172, 181, 42, 229, 114,
+173, 216, 104, 86, 91, 181, 82, 42, 156, 76, 231, 43, 253, 30, 248,
+89, 86, 38, 177, 57, 189, 16, 28, 32, 40, 216, 231, 11, 209, 48, 234,
+246, 120, 2, 8, 226, 114, 90, 237, 46, 149, 124, 117, 153, 178, 104,
+20, 50, 185, 88, 109, 213, 107, 21, 203, 11, 139, 171, 2, 137, 70, 43,
+93, 19, 43, 173, 72, 144, 96, 146, 180, 123, 118, 126, 67, 235, 176,
+121, 112, 156, 193, 8, 196, 239, 131, 125, 64, 123, 185, 16, 133, 67,
+1, 2, 163, 89, 183, 42, 66, 5, 153, 104, 166, 82, 174, 150, 242, 213,
+106, 189, 222, 107, 52, 234, 185, 68, 34, 151, 74, 229, 219, 141, 74,
+177, 20, 151, 2, 1, 129, 108, 46, 36, 224, 113, 250, 221, 62, 10, 241,
+89, 172, 70, 155, 213, 225, 178, 154, 204, 122, 137, 116, 97, 201, 35,
+83, 42, 149, 218, 77, 169, 78, 37, 22, 47, 172, 44, 207, 205, 139,
+212, 42, 193, 178, 66, 175, 117, 98, 40, 202, 145, 174, 197, 233, 5,
+141, 197, 236, 241, 185, 92, 110, 183, 203, 106, 115, 219, 32, 167,
+11, 230, 113, 143, 221, 13, 187, 40, 6, 209, 209, 30, 138, 142, 38,
+51, 201, 72, 44, 22, 75, 23, 43, 173, 122, 189, 154, 79, 38, 98, 17,
+38, 146, 45, 23, 51, 28, 35, 18, 43, 77, 90, 131, 211, 227, 241, 128,
+19, 216, 60, 1, 175, 94, 171, 84, 40, 77, 54, 157, 66, 41, 22, 108,
+78, 77, 217, 100, 98, 153, 76, 50, 63, 187, 176, 180, 177, 185, 182,
+178, 52, 181, 32, 148, 201, 54, 230, 69, 38, 157, 205, 235, 245, 16,
+152, 252, 246, 226, 138, 82, 107, 49, 168, 149, 6, 189, 73, 175, 215,
+235, 4, 50, 225, 134, 10, 242, 106, 84, 54, 187, 45, 64, 250, 92, 81,
+187, 7, 38, 185, 40, 232, 80, 130, 11, 133, 51, 249, 68, 42, 30, 33,
+48, 18, 70, 8, 54, 25, 163, 156, 214, 141, 117, 177, 72, 44, 213, 89,
+156, 118, 157, 70, 111, 130, 92, 118, 173, 68, 176, 42, 16, 11, 133,
+75, 11, 179, 51, 119, 174, 92, 214, 11, 215, 132, 162, 233, 75, 31,
+158, 58, 123, 235, 214, 212, 237, 155, 215, 174, 206, 78, 47, 47, 220,
+92, 87, 42, 141, 14, 15, 132, 120, 23, 47, 222, 89, 82, 72, 36, 155,
+203, 2, 241, 166, 68, 178, 182, 190, 112, 115, 238, 214, 237, 217,
+245, 181, 213, 101, 9, 152, 133, 195, 6, 197, 77, 22, 179, 222, 230,
+50, 218, 125, 110, 6, 20, 5, 142, 16, 1, 200, 104, 178, 106, 20, 42,
+139, 199, 101, 150, 172, 207, 93, 157, 153, 158, 190, 189, 40, 148,
+138, 214, 231, 86, 69, 26, 133, 112, 109, 97, 250, 230, 252, 220, 220,
+244, 141, 203, 55, 207, 125, 116, 230, 140, 96, 250, 218, 237, 219,
+159, 124, 240, 147, 31, 191, 248, 202, 27, 111, 191, 249, 193, 155,
+175, 124, 248, 225, 233, 79, 206, 221, 156, 95, 86, 168, 205, 102,
+163, 252, 234, 135, 151, 102, 22, 102, 167, 166, 111, 223, 6, 75, 180,
+112, 231, 202, 217, 215, 95, 126, 229, 221, 115, 103, 206, 93, 248,
+248, 244, 149, 155, 235, 192, 124, 160, 229, 69, 225, 202, 134, 80,
+44, 183, 128, 229, 213, 171, 197, 114, 133, 112, 254, 214, 141, 75,
+151, 79, 95, 152, 89, 156, 187, 125, 246, 237, 119, 222, 120, 247,
+226, 212, 234, 166, 80, 33, 153, 187, 189, 56, 183, 120, 231, 198,
+165, 115, 103, 62, 186, 116, 225, 253, 143, 78, 189, 242, 218, 75,
+175, 190, 250, 254, 197, 247, 222, 248, 224, 227, 215, 127, 250, 195,
+31, 254, 213, 75, 175, 253, 226, 187, 47, 254, 244, 123, 223, 255,
+254, 207, 94, 122, 245, 212, 59, 111, 95, 188, 114, 225, 234, 149,
+143, 94, 254, 201, 203, 239, 190, 246, 202, 59, 239, 127, 112, 250,
+227, 11, 31, 189, 254, 252, 75, 47, 106, 157, 86, 44, 75, 37, 88, 119,
+32, 94, 222, 221, 107, 99, 14, 187, 151, 98, 243, 131, 81, 119, 247,
+151, 95, 252, 234, 233, 131, 175, 127, 255, 15, 191, 121, 210, 205,
+82, 33, 36, 90, 44, 103, 179, 245, 201, 209, 238, 227, 167, 79, 246,
+31, 61, 125, 242, 104, 183, 217, 105, 118, 187, 245, 156, 199, 96,
+131, 180, 66, 181, 120, 69, 173, 91, 95, 186, 42, 114, 59, 60, 126,
+147, 82, 126, 103, 74, 239, 210, 137, 20, 160, 23, 180, 86, 157, 80,
+170, 209, 123, 104, 2, 227, 131, 190, 53, 129, 114, 67, 19, 170, 148,
+170, 141, 184, 107, 126, 106, 69, 152, 4, 69, 190, 221, 28, 109, 213,
+75, 147, 7, 199, 251, 125, 154, 138, 242, 177, 120, 99, 178, 187, 51,
+185, 255, 217, 239, 126, 247, 47, 255, 247, 255, 245, 175, 255, 252,
+127, 252, 254, 219, 167, 247, 143, 30, 126, 249, 187, 191, 255, 167,
+127, 250, 63, 159, 236, 127, 246, 249, 189, 193, 193, 189, 251, 7,
+253, 118, 179, 15, 44, 169, 16, 134, 131, 169, 168, 15, 179, 233, 33,
+189, 112, 254, 170, 11, 243, 147, 12, 230, 70, 13, 2, 35, 236, 52,
+219, 125, 126, 46, 24, 130, 201, 98, 46, 215, 185, 127, 239, 219, 127,
+253, 231, 95, 230, 162, 249, 100, 123, 119, 188, 61, 60, 172, 135, 48,
+79, 58, 29, 75, 86, 218, 163, 237, 131, 189, 173, 230, 225, 163, 163,
+126, 39, 154, 30, 15, 91, 141, 230, 214, 209, 246, 254, 241, 189, 175,
+190, 254, 221, 31, 254, 151, 175, 190, 250, 226, 120, 167, 209, 239,
+85, 91, 147, 227, 163, 71, 223, 228, 19, 181, 65, 51, 95, 107, 183,
+106, 133, 90, 173, 158, 5, 39, 8, 56, 176, 80, 192, 237, 116, 234,
+237, 154, 205, 235, 51, 36, 130, 4, 99, 184, 15, 148, 138, 217, 237,
+243, 161, 84, 50, 30, 97, 176, 104, 171, 213, 29, 61, 248, 234, 225,
+215, 127, 251, 56, 18, 10, 103, 135, 213, 114, 189, 221, 42, 133, 35,
+225, 116, 177, 148, 202, 247, 38, 135, 199, 119, 15, 182, 78, 30, 238,
+245, 170, 220, 248, 171, 135, 199, 189, 230, 232, 240, 232, 193, 227,
+7, 223, 252, 230, 183, 255, 240, 251, 39, 39, 251, 251, 123, 163, 131,
+221, 193, 120, 235, 240, 224, 193, 125, 60, 88, 109, 87, 147, 201,
+106, 163, 85, 43, 102, 11, 149, 84, 148, 69, 220, 48, 31, 194, 237,
+62, 8, 117, 8, 167, 150, 227, 241, 16, 159, 228, 72, 200, 105, 133,
+16, 2, 216, 82, 42, 158, 9, 133, 147, 213, 201, 246, 221, 123, 15, 14,
+30, 253, 230, 113, 44, 146, 171, 116, 27, 165, 102, 189, 210, 78, 87,
+202, 149, 65, 189, 209, 233, 111, 29, 222, 125, 120, 184, 251, 224,
+100, 191, 159, 39, 78, 126, 115, 124, 178, 59, 220, 59, 218, 63, 188,
+255, 224, 171, 95, 127, 245, 235, 111, 31, 109, 239, 157, 128, 129,
+143, 6, 147, 163, 147, 71, 95, 126, 77, 243, 133, 106, 62, 21, 47, 54,
+42, 153, 116, 190, 83, 79, 199, 128, 239, 99, 33, 142, 65, 193, 96,
+198, 141, 235, 11, 233, 124, 34, 148, 15, 227, 144, 15, 49, 232, 157,
+136, 215, 23, 139, 4, 249, 112, 190, 210, 221, 61, 56, 62, 126, 240,
+232, 201, 211, 112, 178, 208, 233, 55, 107, 149, 122, 163, 150, 203,
+151, 234, 157, 118, 111, 176, 211, 63, 121, 242, 248, 238, 209, 195,
+131, 73, 59, 31, 124, 244, 251, 71, 15, 142, 118, 15, 246, 118, 39, 7,
+119, 31, 63, 253, 226, 139, 47, 15, 143, 238, 63, 56, 153, 236, 77, 6,
+245, 225, 209, 195, 95, 126, 201, 176, 209, 52, 240, 165, 92, 185, 16,
+47, 87, 218, 221, 90, 138, 9, 177, 24, 199, 2, 12, 13, 192, 154, 245,
+171, 243, 89, 48, 221, 82, 148, 242, 123, 156, 86, 27, 66, 161, 112,
+144, 103, 249, 88, 169, 63, 220, 63, 58, 56, 124, 242, 217, 253, 199,
+217, 104, 185, 219, 6, 199, 213, 171, 213, 124, 190, 208, 46, 55, 251,
+253, 241, 232, 248, 139, 175, 142, 143, 14, 182, 6, 141, 92, 248, 248,
+243, 39, 143, 238, 29, 15, 183, 247, 187, 227, 131, 227, 135, 79, 239,
+63, 5, 227, 63, 188, 183, 189, 187, 213, 169, 54, 247, 78, 30, 31, 4,
+112, 0, 101, 225, 68, 170, 90, 72, 149, 138, 205, 78, 167, 204, 167,
+98, 120, 144, 227, 24, 216, 237, 182, 111, 94, 154, 77, 230, 227, 133,
+114, 42, 76, 83, 110, 39, 202, 177, 108, 24, 112, 116, 50, 83, 27,
+236, 109, 31, 28, 236, 159, 60, 62, 250, 44, 73, 85, 59, 205, 74, 161,
+82, 45, 86, 11, 137, 116, 171, 82, 175, 142, 182, 39, 247, 159, 60,
+186, 187, 183, 211, 110, 85, 242, 225, 254, 163, 251, 247, 78, 14,
+183, 198, 59, 253, 237, 189, 157, 123, 15, 239, 62, 62, 57, 57, 120,
+112, 119, 111, 175, 89, 173, 116, 123, 195, 187, 119, 17, 56, 196,
+115, 137, 80, 162, 82, 203, 103, 74, 173, 65, 171, 2, 196, 153, 102,
+105, 156, 198, 97, 47, 162, 184, 49, 27, 207, 101, 43, 213, 118, 54,
+30, 132, 9, 14, 112, 59, 11, 0, 175, 92, 172, 245, 119, 118, 15, 14,
+38, 91, 71, 143, 254, 150, 167, 11, 181, 78, 181, 80, 169, 20, 203,
+185, 120, 58, 83, 170, 181, 135, 187, 7, 143, 239, 221, 63, 30, 118,
+90, 245, 92, 149, 111, 60, 220, 219, 63, 57, 217, 59, 60, 220, 26,
+237, 238, 63, 122, 112, 252, 248, 193, 253, 189, 163, 123, 123, 147,
+70, 37, 209, 31, 180, 79, 142, 3, 112, 144, 98, 34, 116, 172, 82, 201,
+36, 11, 165, 97, 175, 144, 76, 198, 41, 64, 80, 52, 88, 127, 88, 55,
+61, 149, 79, 39, 203, 165, 90, 58, 198, 177, 145, 84, 60, 72, 81, 128,
+158, 27, 197, 114, 119, 119, 119, 178, 63, 232, 13, 238, 125, 19, 15,
+229, 43, 173, 118, 33, 87, 47, 21, 178, 209, 116, 42, 89, 28, 14, 119,
+239, 30, 223, 61, 222, 25, 183, 154, 77, 64, 212, 141, 167, 253, 163,
+207, 30, 236, 129, 221, 216, 218, 62, 124, 120, 114, 242, 240, 222,
+189, 187, 247, 142, 199, 173, 118, 35, 215, 218, 238, 222, 125, 234,
+119, 224, 56, 201, 49, 92, 174, 16, 79, 101, 114, 237, 38, 176, 7, 64,
+127, 40, 202, 82, 94, 216, 109, 88, 157, 138, 167, 99, 133, 76, 156,
+231, 35, 97, 62, 17, 231, 88, 138, 142, 4, 211, 249, 250, 214, 112,
+114, 176, 211, 111, 13, 142, 191, 141, 50, 133, 114, 173, 154, 41,
+148, 243, 89, 192, 195, 233, 116, 181, 55, 28, 143, 119, 143, 70, 219,
+91, 160, 163, 82, 177, 96, 254, 113, 247, 228, 209, 201, 241, 225,
+100, 60, 222, 217, 57, 190, 119, 116, 15, 140, 127, 247, 100, 220, 29,
+245, 42, 213, 206, 232, 139, 199, 14, 59, 138, 163, 28, 206, 229, 210,
+225, 84, 52, 3, 150, 140, 99, 104, 198, 233, 69, 131, 64, 222, 236,
+178, 249, 169, 112, 38, 93, 42, 196, 195, 97, 176, 245, 201, 100, 144,
+14, 144, 76, 40, 153, 107, 111, 183, 219, 195, 81, 175, 219, 187, 247,
+91, 138, 76, 166, 147, 201, 104, 161, 16, 201, 68, 227, 217, 116, 174,
+209, 239, 110, 245, 199, 187, 227, 113, 183, 93, 47, 166, 56, 95, 248,
+238, 224, 222, 147, 147, 227, 227, 237, 173, 201, 214, 214, 254, 193,
+241, 201, 221, 227, 221, 163, 163, 225, 160, 63, 172, 53, 155, 237,
+207, 119, 45, 118, 31, 17, 224, 249, 88, 54, 202, 197, 34, 113, 48,
+19, 54, 196, 195, 78, 23, 48, 75, 14, 215, 45, 223, 188, 147, 204,
+117, 106, 141, 52, 88, 121, 62, 28, 141, 81, 176, 7, 176, 86, 60, 219,
+108, 181, 26, 189, 110, 163, 61, 58, 248, 45, 79, 145, 108, 136, 12,
+70, 179, 96, 129, 194, 249, 108, 173, 209, 27, 244, 90, 253, 201, 100,
+220, 105, 53, 106, 25, 198, 22, 188, 59, 121, 240, 217, 221, 227, 195,
+237, 253, 237, 237, 157, 195, 163, 195, 123, 199, 39, 123, 187, 163,
+193, 160, 51, 108, 54, 43, 249, 135, 67, 139, 203, 15, 18, 79, 50, 22,
+161, 217, 96, 40, 146, 43, 69, 64, 12, 243, 90, 237, 8, 199, 51, 176,
+122, 237, 242, 98, 46, 55, 104, 215, 202, 137, 16, 29, 139, 71, 57,
+194, 11, 130, 37, 21, 6, 219, 212, 237, 15, 39, 157, 198, 240, 248,
+247, 89, 20, 165, 120, 10, 15, 230, 64, 143, 132, 210, 249, 126, 179,
+211, 239, 246, 58, 163, 241, 160, 217, 237, 212, 10, 152, 34, 241,
+232, 222, 195, 7, 135, 39, 247, 14, 246, 182, 119, 247, 239, 63, 60,
+184, 187, 127, 114, 188, 59, 26, 247, 7, 131, 114, 171, 86, 125, 212,
+182, 121, 81, 20, 97, 195, 241, 20, 129, 48, 108, 40, 82, 140, 128,
+136, 228, 212, 154, 188, 52, 233, 179, 138, 22, 206, 207, 198, 18,
+221, 78, 177, 148, 14, 147, 209, 104, 144, 65, 93, 30, 156, 162, 226,
+121, 48, 252, 214, 104, 50, 234, 142, 63, 251, 109, 14, 112, 69, 38,
+68, 4, 147, 201, 112, 48, 146, 41, 183, 218, 189, 110, 191, 211, 30,
+244, 187, 195, 97, 183, 90, 12, 75, 71, 95, 126, 253, 224, 100, 12,
+20, 119, 188, 191, 123, 247, 225, 253, 147, 131, 253, 131, 157, 195,
+209, 160, 215, 110, 166, 65, 1, 28, 117, 61, 62, 132, 242, 19, 209,
+100, 10, 176, 55, 71, 51, 137, 48, 67, 227, 22, 141, 213, 137, 193,
+118, 195, 218, 252, 39, 171, 197, 116, 163, 148, 203, 167, 57, 156,
+15, 145, 12, 129, 216, 49, 22, 36, 173, 102, 167, 55, 26, 143, 183,
+119, 118, 30, 126, 153, 198, 130, 169, 20, 136, 124, 137, 4, 31, 76,
+215, 234, 173, 110, 127, 176, 213, 110, 117, 59, 141, 222, 168, 95,
+45, 36, 77, 223, 124, 245, 237, 227, 187, 187, 147, 209, 96, 2, 20,
+243, 209, 221, 195, 61, 32, 133, 135, 91, 221, 70, 163, 28, 201, 181,
+128, 113, 217, 32, 159, 31, 245, 70, 210, 49, 154, 138, 128, 240, 18,
+139, 96, 24, 234, 52, 152, 61, 28, 106, 214, 174, 45, 93, 180, 109,
+53, 178, 177, 68, 46, 19, 37, 67, 44, 137, 121, 108, 222, 0, 21, 138,
+231, 218, 253, 65, 111, 180, 127, 180, 119, 114, 255, 105, 131, 136,
+164, 147, 92, 16, 28, 8, 42, 180, 214, 232, 182, 251, 253, 118, 181,
+219, 110, 52, 193, 6, 87, 10, 233, 192, 239, 190, 250, 250, 233, 195,
+163, 201, 206, 246, 225, 209, 222, 225, 209, 209, 193, 104, 50, 222,
+61, 4, 191, 42, 23, 227, 197, 74, 239, 120, 223, 102, 247, 97, 148,
+63, 86, 140, 4, 248, 112, 128, 196, 249, 176, 15, 245, 121, 13, 102,
+23, 142, 216, 76, 138, 245, 107, 254, 97, 39, 159, 138, 70, 11, 81,
+62, 68, 80, 62, 183, 25, 166, 104, 46, 154, 111, 143, 6, 192, 100,
+199, 199, 71, 135, 95, 215, 32, 154, 143, 69, 131, 112, 56, 26, 226,
+195, 149, 70, 103, 208, 237, 183, 75, 237, 126, 173, 217, 106, 183,
+202, 229, 36, 251, 119, 79, 159, 126, 249, 232, 224, 104, 111, 114,
+112, 114, 180, 187, 183, 115, 176, 11, 198, 31, 131, 210, 173, 22,
+242, 185, 92, 239, 233, 158, 21, 2, 129, 159, 140, 101, 211, 108, 40,
+134, 224, 40, 136, 82, 8, 234, 51, 154, 1, 45, 249, 236, 26, 225, 29,
+127, 173, 144, 79, 68, 195, 32, 213, 51, 12, 225, 116, 187, 1, 218,
+179, 161, 116, 125, 210, 173, 131, 13, 222, 155, 76, 190, 106, 65,
+160, 248, 147, 97, 10, 132, 250, 112, 188, 82, 233, 13, 186, 131, 38,
+40, 189, 102, 187, 85, 5, 177, 43, 20, 250, 187, 251, 247, 63, 123,
+240, 232, 222, 225, 120, 114, 247, 222, 209, 33, 104, 129, 189, 189,
+253, 81, 171, 211, 174, 128, 246, 40, 245, 62, 31, 90, 97, 10, 103,
+67, 201, 76, 34, 204, 241, 44, 78, 186, 60, 30, 31, 6, 217, 157, 86,
+64, 61, 22, 217, 218, 20, 149, 79, 229, 67, 124, 52, 83, 204, 176, 36,
+225, 247, 122, 25, 218, 79, 179, 169, 202, 168, 87, 171, 246, 71, 163,
+193, 248, 87, 93, 59, 8, 130, 153, 120, 144, 102, 194, 145, 84, 173,
+55, 236, 247, 187, 157, 65, 187, 81, 31, 116, 74, 205, 74, 139, 47,
+125, 123, 255, 201, 195, 135, 143, 159, 30, 141, 6, 123, 199, 128, 8,
+70, 15, 14, 15, 246, 198, 253, 209, 160, 214, 30, 244, 58, 227, 199,
+59, 62, 156, 33, 249, 104, 170, 156, 137, 241, 28, 138, 16, 94, 23,
+228, 119, 99, 78, 135, 195, 230, 117, 153, 13, 51, 55, 153, 82, 50,
+19, 79, 36, 226, 217, 12, 29, 192, 16, 28, 161, 73, 148, 166, 19, 149,
+97, 189, 86, 110, 181, 90, 131, 147, 175, 58, 110, 58, 149, 203, 39,
+67, 33, 138, 139, 165, 193, 53, 13, 39, 189, 173, 173, 86, 167, 55,
+238, 213, 91, 213, 122, 164, 250, 205, 131, 47, 62, 127, 244, 228,
+139, 163, 237, 246, 0, 24, 214, 33, 232, 190, 227, 157, 65, 183, 215,
+107, 212, 219, 221, 222, 232, 151, 199, 8, 205, 5, 131, 9, 16, 138,
+57, 134, 199, 124, 20, 234, 114, 65, 118, 12, 118, 65, 86, 187, 197,
+161, 159, 185, 225, 175, 230, 98, 233, 100, 26, 48, 28, 129, 18, 56,
+5, 122, 148, 10, 113, 169, 74, 173, 81, 46, 215, 7, 221, 206, 254,
+103, 3, 7, 216, 188, 92, 150, 143, 115, 124, 52, 91, 111, 239, 109,
+141, 6, 195, 157, 126, 127, 48, 233, 247, 0, 83, 241, 157, 95, 29,
+221, 127, 250, 240, 225, 87, 15, 247, 7, 227, 189, 221, 163, 147, 131,
+227, 163, 221, 157, 110, 187, 57, 168, 55, 251, 131, 254, 225, 175,
+31, 34, 4, 195, 197, 147, 201, 60, 79, 83, 4, 205, 112, 126, 171, 201,
+5, 249, 48, 191, 23, 50, 105, 53, 242, 197, 75, 80, 49, 159, 74, 101,
+178, 201, 16, 80, 94, 2, 101, 253, 116, 48, 20, 226, 83, 133, 82, 57,
+251, 236, 250, 123, 135, 95, 117, 157, 68, 162, 94, 202, 103, 226,
+225, 68, 56, 213, 236, 142, 183, 38, 195, 93, 32, 175, 147, 73, 191,
+86, 235, 180, 66, 123, 191, 123, 240, 244, 225, 131, 39, 95, 221, 223,
+155, 236, 31, 156, 220, 191, 183, 127, 120, 52, 153, 12, 154, 189, 86,
+177, 53, 2, 130, 240, 217, 93, 156, 192, 194, 249, 40, 15, 28, 38, 68,
+19, 20, 230, 51, 232, 29, 14, 63, 29, 240, 130, 246, 83, 136, 36, 83,
+76, 171, 28, 5, 188, 21, 165, 24, 144, 136, 221, 224, 155, 14, 243,
+124, 180, 88, 40, 100, 250, 195, 78, 119, 252, 244, 127, 222, 242,
+135, 235, 157, 86, 177, 92, 72, 23, 83, 217, 122, 125, 60, 2, 44, 122,
+52, 222, 218, 30, 244, 154, 141, 86, 53, 184, 243, 237, 195, 199, 95,
+222, 127, 250, 197, 253, 195, 147, 163, 7, 247, 1, 120, 29, 156, 236,
+13, 65, 238, 7, 149, 58, 222, 159, 140, 31, 157, 64, 20, 48, 208, 100,
+140, 137, 134, 40, 130, 98, 113, 171, 77, 111, 180, 121, 159, 173,
+181, 219, 104, 208, 201, 55, 249, 102, 46, 24, 226, 128, 37, 135, 105,
+212, 235, 10, 120, 80, 62, 9, 136, 51, 147, 203, 213, 122, 189, 254,
+232, 232, 139, 127, 28, 34, 89, 160, 134, 149, 114, 179, 86, 46, 100,
+242, 149, 209, 206, 49, 216, 228, 201, 206, 86, 107, 180, 5, 168, 148,
+217, 249, 221, 147, 39, 191, 124, 240, 232, 179, 187, 119, 31, 62,
+188, 123, 255, 225, 253, 35, 192, 34, 187, 3, 208, 34, 205, 173, 225,
+246, 168, 245, 232, 192, 203, 197, 74, 181, 44, 23, 140, 4, 9, 2, 39,
+125, 102, 155, 90, 103, 178, 250, 25, 22, 247, 24, 237, 102, 181, 50,
+84, 200, 179, 76, 178, 192, 211, 188, 223, 235, 4, 243, 135, 35, 201,
+120, 52, 150, 77, 38, 43, 141, 173, 93, 48, 216, 111, 91, 193, 124,
+173, 63, 110, 54, 70, 163, 84, 42, 89, 234, 1, 184, 188, 119, 23, 224,
+237, 206, 8, 52, 121, 173, 30, 191, 251, 205, 221, 207, 62, 187, 119,
+252, 248, 238, 131, 187, 247, 31, 28, 62, 125, 242, 240, 0, 184, 240,
+100, 210, 237, 181, 183, 122, 195, 73, 255, 222, 158, 159, 143, 103,
+10, 233, 32, 31, 36, 88, 194, 235, 118, 90, 77, 58, 157, 209, 224, 70,
+169, 128, 219, 228, 180, 153, 13, 124, 37, 23, 36, 66, 153, 36, 17,
+192, 45, 46, 200, 227, 134, 185, 112, 44, 22, 77, 102, 43, 165, 238,
+248, 112, 178, 53, 250, 117, 45, 88, 110, 183, 71, 237, 222, 254, 48,
+29, 205, 54, 186, 123, 219, 39, 15, 238, 238, 239, 237, 238, 110, 79,
+58, 229, 122, 53, 254, 248, 155, 131, 131, 195, 123, 219, 71, 199,
+251, 119, 159, 220, 63, 122, 252, 244, 241, 189, 157, 221, 221, 163,
+193, 168, 63, 30, 14, 118, 38, 59, 143, 246, 97, 142, 207, 132, 163,
+116, 144, 68, 41, 198, 225, 113, 121, 45, 70, 189, 197, 234, 243, 34,
+152, 223, 227, 114, 90, 28, 68, 62, 19, 139, 49, 64, 149, 17, 191, 13,
+242, 88, 141, 110, 140, 98, 194, 225, 92, 173, 220, 28, 236, 239, 180,
+186, 219, 191, 42, 49, 133, 214, 160, 221, 172, 15, 187, 185, 88, 174,
+222, 28, 237, 126, 246, 240, 238, 201, 201, 104, 60, 234, 116, 234,
+173, 126, 241, 203, 111, 247, 198, 251, 135, 59, 39, 251, 123, 15,
+159, 60, 184, 251, 217, 211, 7, 119, 15, 246, 247, 119, 183, 182, 71,
+227, 173, 193, 222, 94, 251, 139, 109, 34, 194, 199, 8, 134, 162, 97,
+152, 9, 249, 253, 48, 106, 180, 26, 65, 5, 216, 44, 94, 196, 235, 68,
+220, 110, 119, 42, 18, 43, 133, 131, 56, 17, 240, 64, 38, 157, 82,
+168, 66, 60, 94, 46, 95, 203, 100, 171, 237, 73, 167, 214, 28, 126,
+85, 8, 23, 128, 154, 21, 27, 227, 94, 137, 77, 130, 162, 62, 249, 226,
+151, 143, 30, 62, 60, 236, 246, 123, 189, 241, 100, 82, 126, 242, 229,
+225, 62, 200, 86, 247, 15, 247, 159, 124, 246, 244, 238, 23, 159, 223,
+155, 28, 236, 31, 237, 140, 118, 7, 147, 97, 31, 244, 233, 103, 19, 2,
+32, 37, 135, 209, 132, 219, 22, 240, 218, 221, 62, 191, 213, 162, 149,
+172, 203, 180, 26, 187, 201, 131, 144, 132, 211, 21, 69, 248, 52, 129,
+187, 2, 110, 143, 67, 47, 92, 88, 89, 183, 251, 92, 124, 49, 31, 75,
+150, 0, 94, 149, 42, 195, 199, 153, 12, 192, 238, 114, 186, 217, 239,
+22, 136, 116, 161, 187, 119, 248, 245, 183, 191, 250, 226, 33, 232,
+128, 195, 222, 225, 189, 195, 254, 131, 251, 199, 79, 190, 2, 213,
+247, 249, 238, 189, 175, 62, 127, 244, 217, 147, 35, 160, 193, 39, 39,
+91, 119, 247, 39, 163, 94, 167, 63, 121, 186, 79, 4, 169, 100, 2, 229,
+57, 143, 195, 99, 215, 107, 205, 144, 219, 162, 145, 76, 175, 200,
+228, 46, 141, 5, 70, 81, 63, 20, 135, 41, 150, 180, 24, 204, 102, 179,
+94, 186, 41, 22, 172, 88, 172, 158, 20, 104, 247, 100, 185, 214, 0,
+67, 55, 31, 102, 129, 204, 231, 178, 197, 74, 37, 27, 99, 82, 213,
+206, 222, 211, 111, 191, 253, 205, 23, 79, 159, 124, 126, 124, 120,
+239, 219, 95, 255, 237, 221, 207, 127, 253, 135, 255, 231, 191, 253,
+203, 255, 246, 135, 63, 252, 230, 243, 175, 255, 254, 55, 191, 253,
+234, 209, 195, 123, 123, 79, 159, 236, 142, 31, 236, 142, 59, 131,
+221, 163, 47, 198, 193, 116, 182, 81, 226, 146, 81, 158, 9, 6, 44, 38,
+163, 51, 224, 50, 235, 52, 58, 189, 1, 245, 184, 34, 241, 96, 132, 42,
+160, 62, 22, 211, 217, 172, 118, 187, 76, 36, 209, 217, 237, 72, 170,
+186, 119, 188, 51, 26, 109, 55, 178, 57, 16, 24, 30, 84, 90, 131, 74,
+187, 51, 6, 126, 80, 41, 54, 78, 198, 143, 191, 252, 195, 191, 253,
+127, 255, 239, 191, 253, 235, 255, 254, 15, 255, 242, 111, 255, 237,
+15, 95, 62, 2, 172, 121, 116, 255, 112, 119, 111, 255, 248, 241, 175,
+126, 253, 197, 47, 191, 248, 250, 239, 255, 235, 63, 255, 227, 255,
+250, 79, 191, 253, 175, 127, 247, 245, 211, 111, 254, 241, 111, 191,
+25, 87, 182, 159, 193, 208, 184, 61, 222, 218, 233, 69, 8, 31, 130,
+82, 56, 100, 179, 107, 229, 82, 173, 214, 23, 32, 67, 92, 62, 28, 202,
+101, 192, 191, 74, 134, 9, 178, 36, 106, 55, 96, 92, 166, 154, 206,
+247, 182, 90, 165, 206, 214, 100, 255, 225, 224, 232, 241, 227, 147,
+195, 81, 191, 91, 143, 129, 182, 204, 238, 75, 29, 100, 50, 68, 56,
+45, 118, 175, 213, 40, 153, 189, 117, 241, 242, 149, 169, 229, 149,
+169, 213, 245, 37, 169, 70, 174, 176, 152, 44, 86, 152, 171, 108, 111,
+53, 91, 135, 195, 76, 50, 27, 143, 150, 73, 187, 94, 190, 46, 216, 16,
+72, 133, 66, 233, 213, 15, 63, 120, 227, 157, 143, 222, 123, 229, 197,
+23, 159, 251, 209, 143, 126, 244, 243, 231, 223, 120, 251, 141, 55,
+222, 125, 247, 236, 217, 179, 231, 110, 174, 108, 174, 9, 230, 46,
+159, 251, 228, 204, 219, 31, 222, 184, 125, 231, 246, 178, 194, 170,
+51, 250, 80, 174, 178, 211, 75, 134, 96, 163, 106, 67, 184, 186, 120,
+254, 226, 165, 171, 55, 215, 212, 38, 31, 236, 210, 131, 179, 109, 46,
+47, 207, 206, 94, 57, 125, 101, 86, 106, 50, 233, 45, 90, 169, 88, 38,
+150, 232, 180, 98, 161, 80, 165, 81, 128, 5, 54, 25, 101, 46, 140,
+202, 54, 188, 90, 229, 230, 220, 204, 236, 244, 194, 252, 226, 212,
+59, 207, 255, 244, 133, 23, 94, 122, 233, 149, 55, 95, 120, 241, 231,
+63, 255, 201, 91, 47, 189, 241, 254, 171, 63, 122, 254, 249, 231, 158,
+123, 225, 181, 215, 222, 63, 243, 214, 135, 239, 191, 255, 201, 141,
+75, 51, 51, 18, 165, 90, 164, 180, 66, 6, 155, 221, 134, 23, 15, 82,
+168, 67, 33, 17, 8, 165, 139, 119, 102, 230, 151, 215, 132, 66, 31,
+22, 3, 243, 71, 28, 16, 100, 213, 107, 180, 27, 119, 4, 74, 29, 138,
+122, 136, 128, 59, 128, 66, 14, 103, 192, 227, 14, 80, 225, 68, 16,
+167, 163, 20, 149, 76, 101, 7, 91, 152, 203, 101, 214, 88, 204, 74,
+163, 86, 181, 118, 238, 131, 183, 223, 124, 235, 204, 153, 211, 159,
+188, 119, 230, 227, 179, 239, 157, 253, 232, 244, 213, 119, 95, 250,
+248, 204, 71, 231, 174, 220, 186, 177, 176, 50, 191, 112, 231, 246,
+226, 218, 204, 230, 154, 206, 173, 83, 106, 108, 88, 128, 11, 194, 92,
+123, 151, 13, 226, 144, 214, 96, 177, 170, 100, 70, 131, 211, 104,
+245, 16, 108, 38, 31, 139, 134, 112, 204, 107, 51, 27, 109, 122, 145,
+198, 236, 12, 133, 152, 20, 8, 215, 73, 158, 101, 184, 112, 40, 28,
+173, 53, 114, 209, 4, 232, 219, 6, 40, 215, 161, 215, 97, 55, 27, 32,
+135, 193, 106, 210, 202, 110, 127, 114, 230, 157, 143, 63, 185, 120,
+243, 214, 205, 233, 107, 87, 47, 125, 242, 193, 217, 43, 31, 188, 113,
+245, 211, 79, 111, 109, 202, 164, 90, 189, 82, 182, 41, 216, 148, 173,
+172, 10, 117, 0, 78, 108, 116, 40, 24, 101, 217, 72, 183, 143, 81,
+164, 95, 15, 192, 200, 227, 114, 249, 88, 220, 23, 138, 199, 11, 149,
+124, 33, 77, 51, 152, 215, 172, 247, 57, 165, 110, 4, 230, 115, 229,
+106, 171, 211, 40, 21, 242, 217, 124, 58, 157, 1, 240, 84, 4, 81, 51,
+215, 216, 238, 15, 239, 54, 157, 14, 200, 101, 119, 251, 237, 144,
+219, 166, 18, 220, 58, 125, 238, 220, 217, 139, 115, 139, 18, 225,
+210, 212, 212, 167, 31, 94, 185, 240, 238, 219, 51, 119, 110, 47, 232,
+140, 102, 191, 67, 111, 183, 106, 84, 234, 77, 137, 74, 229, 65, 96,
+15, 197, 211, 192, 23, 99, 131, 17, 10, 168, 20, 38, 72, 159, 31, 241,
+250, 34, 124, 40, 145, 207, 228, 203, 121, 32, 16, 28, 75, 56, 28,
+176, 93, 230, 65, 240, 28, 96, 157, 209, 100, 208, 170, 54, 171, 245,
+124, 186, 210, 3, 194, 9, 98, 74, 125, 123, 103, 50, 222, 233, 120,
+109, 78, 143, 211, 134, 120, 220, 144, 83, 35, 154, 62, 255, 201, 149,
+219, 183, 22, 151, 132, 82, 193, 194, 220, 237, 171, 55, 206, 191,
+247, 250, 181, 249, 217, 13, 131, 213, 205, 34, 122, 7, 100, 209, 232,
+149, 74, 173, 26, 69, 16, 146, 100, 131, 32, 239, 100, 135, 35, 12,
+199, 97, 54, 204, 250, 1, 155, 97, 124, 40, 157, 45, 164, 211, 133,
+66, 169, 146, 2, 118, 142, 250, 125, 70, 185, 155, 204, 2, 175, 219,
+222, 25, 247, 91, 189, 110, 179, 81, 77, 183, 6, 59, 7, 189, 54, 8,
+199, 67, 0, 36, 173, 33, 110, 134, 92, 122, 131, 7, 114, 250, 156,
+122, 197, 250, 236, 157, 133, 197, 149, 13, 241, 202, 186, 104, 109,
+113, 246, 206, 237, 107, 103, 95, 189, 184, 184, 164, 181, 216, 8, 14,
+181, 88, 45, 78, 163, 81, 171, 87, 104, 80, 216, 71, 2, 232, 139, 132,
+50, 213, 173, 29, 12, 133, 169, 112, 42, 4, 187, 33, 63, 193, 241,
+177, 124, 58, 145, 45, 213, 26, 207, 146, 111, 144, 64, 188, 38, 169,
+139, 175, 213, 90, 32, 124, 236, 111, 141, 135, 245, 106, 171, 92,
+220, 25, 239, 238, 142, 75, 173, 122, 29, 200, 223, 164, 53, 70, 29,
+46, 155, 74, 13, 160, 27, 117, 154, 213, 178, 213, 91, 139, 43, 43,
+66, 249, 218, 154, 104, 115, 110, 106, 102, 230, 214, 153, 23, 206,
+47, 45, 219, 45, 86, 150, 241, 91, 237, 38, 167, 197, 164, 82, 202,
+53, 144, 63, 64, 17, 44, 160, 178, 98, 99, 127, 226, 112, 153, 252,
+145, 108, 28, 0, 11, 76, 227, 0, 164, 114, 169, 12, 72, 33, 237, 76,
+242, 217, 141, 32, 167, 105, 131, 72, 84, 26, 189, 254, 214, 254, 201,
+206, 24, 4, 178, 106, 113, 107, 107, 114, 176, 187, 93, 170, 247, 219,
+91, 227, 237, 97, 99, 31, 55, 155, 237, 58, 19, 193, 192, 136, 15, 50,
+170, 87, 174, 77, 175, 205, 45, 111, 110, 174, 174, 111, 174, 222,
+153, 93, 186, 250, 241, 139, 103, 151, 151, 77, 6, 7, 70, 194, 207,
+62, 93, 54, 42, 68, 50, 185, 198, 230, 195, 113, 134, 79, 102, 203,
+221, 206, 246, 196, 102, 208, 58, 193, 78, 208, 94, 138, 197, 88, 62,
+149, 138, 243, 169, 54, 72, 150, 233, 120, 132, 231, 2, 14, 221, 42,
+157, 105, 54, 218, 253, 173, 221, 163, 157, 97, 191, 93, 175, 22, 128,
+43, 237, 236, 238, 0, 78, 238, 29, 28, 143, 134, 205, 19, 194, 234,
+182, 217, 189, 24, 129, 226, 132, 203, 164, 18, 206, 220, 153, 159,
+157, 95, 222, 88, 94, 223, 88, 152, 158, 95, 185, 241, 201, 139, 231,
+215, 165, 58, 147, 19, 102, 72, 143, 223, 169, 87, 110, 10, 69, 34,
+165, 209, 129, 6, 130, 161, 108, 165, 222, 104, 79, 38, 22, 139, 198,
+73, 7, 131, 20, 66, 226, 4, 203, 39, 146, 177, 88, 172, 81, 171, 228,
+83, 177, 72, 132, 197, 204, 194, 121, 182, 80, 45, 183, 134, 227, 237,
+131, 30, 200, 235, 173, 114, 161, 114, 188, 59, 217, 29, 247, 6, 157,
+193, 189, 227, 253, 113, 247, 49, 109, 244, 66, 54, 107, 0, 195, 41,
+210, 110, 52, 138, 214, 151, 230, 166, 231, 23, 133, 235, 98, 233,
+194, 236, 194, 202, 141, 183, 126, 124, 105, 97, 93, 100, 241, 35, 44,
+131, 120, 32, 157, 112, 77, 46, 217, 144, 41, 44, 40, 21, 162, 51,
+160, 169, 90, 141, 177, 5, 178, 129, 0, 133, 4, 124, 64, 173, 105,
+254, 89, 138, 231, 139, 197, 82, 34, 150, 102, 56, 22, 81, 75, 5, 177,
+210, 179, 207, 25, 182, 183, 247, 134, 253, 122, 163, 94, 47, 151,
+119, 246, 134, 219, 123, 163, 94, 191, 11, 114, 72, 167, 123, 226, 51,
+192, 168, 221, 130, 32, 14, 24, 3, 192, 47, 90, 92, 95, 152, 158, 154,
+19, 137, 196, 242, 229, 233, 249, 169, 233, 183, 158, 187, 120, 123,
+69, 98, 35, 189, 207, 62, 142, 113, 105, 132, 27, 114, 145, 72, 166,
+53, 248, 131, 113, 62, 86, 174, 214, 107, 141, 93, 13, 240, 105, 63,
+137, 251, 60, 207, 238, 154, 176, 64, 106, 34, 108, 50, 149, 140, 132,
+99, 1, 212, 165, 213, 40, 69, 113, 144, 131, 58, 91, 219, 187, 7, 147,
+97, 187, 86, 45, 23, 235, 187, 199, 131, 225, 120, 220, 169, 116, 119,
+158, 113, 248, 177, 207, 69, 160, 176, 3, 242, 185, 188, 30, 179, 213,
+40, 155, 91, 91, 94, 89, 90, 16, 73, 55, 215, 150, 230, 22, 167, 110,
+124, 248, 252, 167, 171, 90, 147, 195, 239, 198, 17, 220, 167, 51,
+139, 215, 196, 27, 34, 141, 70, 235, 10, 38, 226, 233, 66, 167, 94,
+172, 140, 244, 74, 192, 69, 176, 199, 102, 71, 96, 140, 8, 115, 207,
+110, 29, 130, 176, 16, 227, 9, 20, 131, 205, 58, 233, 102, 166, 81,
+40, 55, 39, 123, 7, 39, 163, 221, 81, 29, 40, 195, 120, 124, 184, 53,
+26, 130, 232, 223, 222, 158, 244, 71, 237, 163, 128, 159, 194, 81,
+151, 3, 193, 32, 155, 201, 106, 146, 204, 44, 9, 86, 69, 107, 27, 210,
+205, 213, 133, 153, 149, 197, 169, 115, 47, 95, 16, 152, 28, 22, 200,
+231, 245, 33, 118, 179, 77, 184, 184, 177, 170, 208, 2, 119, 38, 163,
+209, 92, 185, 95, 73, 102, 39, 106, 169, 222, 227, 245, 128, 222, 132,
+221, 24, 27, 137, 130, 44, 137, 209, 209, 88, 148, 199, 233, 48, 230,
+212, 105, 4, 153, 122, 173, 51, 216, 6, 233, 115, 124, 56, 6, 18, 88,
+156, 108, 109, 131, 221, 239, 130, 252, 8, 138, 114, 171, 115, 136,
+65, 40, 48, 7, 200, 23, 128, 60, 14, 155, 65, 182, 178, 178, 190, 180,
+50, 187, 34, 149, 172, 79, 223, 17, 172, 221, 62, 247, 218, 197, 77,
+167, 205, 77, 184, 125, 16, 226, 54, 106, 4, 11, 155, 27, 98, 173,
+193, 104, 67, 216, 84, 169, 211, 204, 242, 201, 190, 66, 164, 5, 89,
+209, 106, 118, 5, 16, 152, 13, 5, 3, 68, 192, 235, 13, 23, 66, 44, 78,
+68, 8, 155, 195, 38, 1, 49, 231, 217, 231, 109, 123, 135, 147, 221,
+73, 61, 158, 111, 111, 247, 6, 195, 65, 175, 183, 213, 157, 236, 140,
+119, 182, 250, 99, 147, 21, 65, 81, 204, 227, 10, 248, 49, 191, 89,
+39, 95, 93, 17, 47, 206, 46, 173, 110, 8, 87, 102, 103, 5, 203, 215,
+78, 255, 252, 252, 178, 205, 236, 69, 33, 200, 131, 5, 116, 74, 209,
+220, 186, 80, 101, 48, 88, 44, 40, 145, 44, 86, 43, 97, 146, 169, 72,
+55, 52, 46, 31, 12, 217, 80, 146, 193, 184, 48, 67, 211, 168, 211,
+199, 87, 211, 88, 32, 16, 38, 189, 30, 167, 110, 178, 219, 61, 188,
+127, 116, 247, 104, 111, 103, 50, 172, 70, 10, 189, 193, 94, 175, 219,
+235, 12, 59, 189, 201, 168, 15, 48, 180, 39, 55, 248, 61, 94, 204, 23,
+64, 9, 34, 96, 181, 40, 86, 150, 5, 203, 115, 115, 43, 130, 205, 213,
+249, 165, 245, 213, 229, 179, 127, 115, 106, 6, 114, 248, 72, 8, 130,
+24, 202, 166, 149, 47, 172, 111, 232, 44, 22, 171, 211, 139, 113, 169,
+92, 58, 228, 182, 115, 155, 43, 70, 135, 7, 71, 60, 4, 129, 97, 193,
+32, 104, 1, 212, 229, 141, 230, 10, 32, 41, 165, 56, 196, 99, 51, 247,
+118, 182, 38, 71, 251, 247, 39, 91, 91, 219, 147, 82, 12, 172, 250,
+94, 15, 132, 207, 241, 160, 61, 216, 26, 237, 12, 219, 105, 161, 200,
+234, 134, 81, 47, 139, 81, 68, 192, 105, 213, 8, 103, 87, 214, 23,
+151, 54, 215, 229, 130, 229, 197, 197, 233, 245, 11, 63, 122, 71, 136,
+248, 220, 1, 155, 203, 7, 236, 214, 105, 16, 44, 110, 170, 29, 78,
+155, 199, 6, 147, 97, 224, 48, 6, 163, 103, 67, 162, 183, 185, 81,
+176, 61, 20, 236, 5, 17, 134, 99, 80, 135, 155, 75, 20, 48, 148, 75,
+70, 48, 143, 73, 62, 188, 183, 219, 219, 219, 222, 235, 119, 135, 123,
+187, 121, 46, 215, 235, 110, 119, 135, 32, 127, 111, 181, 39, 163,
+201, 206, 100, 139, 91, 151, 153, 156, 4, 234, 15, 226, 28, 6, 44,
+219, 32, 188, 51, 191, 178, 182, 33, 88, 81, 11, 103, 23, 214, 151,
+22, 206, 254, 224, 212, 38, 138, 219, 93, 86, 127, 32, 193, 35, 1, 72,
+57, 191, 41, 210, 57, 93, 14, 135, 215, 135, 19, 56, 164, 209, 88,
+229, 2, 181, 205, 227, 135, 93, 46, 134, 68, 48, 42, 128, 163, 94,
+139, 141, 140, 39, 17, 42, 11, 66, 139, 71, 191, 177, 123, 8, 68, 98,
+52, 104, 117, 251, 227, 81, 137, 78, 12, 91, 253, 206, 112, 107, 11,
+4, 166, 254, 214, 104, 180, 213, 11, 46, 74, 13, 110, 218, 11, 193,
+126, 42, 0, 116, 8, 52, 192, 226, 170, 104, 229, 246, 154, 100, 101,
+118, 70, 44, 89, 188, 240, 87, 175, 79, 195, 164, 201, 229, 69, 35,
+133, 40, 78, 194, 234, 117, 217, 186, 210, 10, 236, 30, 241, 195, 48,
+228, 80, 27, 97, 181, 84, 173, 133, 124, 176, 199, 141, 250, 221, 224,
+71, 144, 207, 166, 117, 114, 60, 15, 19, 169, 82, 146, 67, 101, 146,
+225, 65, 187, 54, 158, 140, 123, 91, 157, 110, 187, 152, 72, 53, 91,
+205, 94, 7, 184, 95, 62, 219, 26, 15, 219, 197, 86, 120, 78, 96, 116,
+147, 126, 183, 31, 7, 242, 99, 50, 154, 164, 64, 124, 229, 43, 11,
+130, 229, 165, 197, 37, 129, 112, 254, 236, 143, 79, 45, 64, 152, 3,
+242, 99, 169, 92, 132, 38, 113, 163, 76, 178, 38, 54, 185, 220, 118,
+63, 202, 194, 86, 151, 70, 75, 170, 165, 50, 157, 219, 233, 241, 66,
+46, 27, 228, 179, 59, 157, 144, 81, 99, 245, 80, 28, 12, 167, 234,
+225, 160, 91, 44, 29, 142, 90, 117, 144, 134, 6, 189, 86, 165, 144, 2,
+86, 216, 44, 183, 74, 165, 38, 24, 191, 218, 223, 106, 228, 70, 145,
+57, 169, 1, 72, 15, 140, 226, 94, 163, 195, 106, 54, 40, 86, 151, 5,
+155, 43, 203, 107, 75, 171, 75, 66, 201, 234, 194, 249, 191, 124, 119,
+195, 15, 16, 6, 102, 18, 153, 8, 141, 251, 109, 26, 145, 64, 104, 112,
+184, 221, 78, 55, 133, 91, 221, 26, 165, 91, 180, 172, 180, 120, 124,
+94, 143, 203, 102, 117, 216, 109, 6, 163, 94, 173, 86, 154, 220, 60,
+236, 226, 243, 137, 128, 117, 197, 212, 232, 12, 155, 221, 65, 191,
+221, 77, 197, 19, 201, 173, 70, 185, 80, 106, 148, 243, 165, 78, 62,
+83, 169, 215, 43, 185, 65, 112, 73, 99, 178, 65, 14, 4, 129, 32, 155,
+197, 164, 215, 202, 215, 22, 214, 4, 98, 225, 166, 112, 121, 97, 77,
+184, 186, 112, 246, 251, 31, 26, 252, 40, 140, 19, 193, 104, 152, 33,
+81, 155, 78, 45, 223, 216, 52, 64, 32, 25, 186, 217, 128, 206, 172,
+148, 184, 102, 23, 149, 102, 183, 215, 14, 150, 196, 106, 182, 88, 65,
+118, 48, 152, 109, 46, 27, 129, 186, 130, 105, 14, 181, 78, 43, 226,
+185, 18, 136, 7, 227, 110, 63, 147, 137, 230, 118, 90, 149, 76, 182,
+86, 79, 103, 114, 241, 120, 186, 88, 45, 22, 219, 193, 37, 181, 196,
+234, 115, 131, 227, 157, 122, 157, 82, 173, 16, 173, 206, 11, 132,
+155, 82, 161, 96, 99, 67, 176, 121, 235, 218, 197, 159, 221, 177, 152,
+17, 152, 38, 48, 142, 193, 16, 212, 32, 81, 75, 133, 155, 58, 167,
+209, 96, 65, 25, 204, 162, 81, 26, 60, 55, 215, 85, 102, 187, 207,
+225, 116, 58, 189, 192, 191, 44, 58, 147, 135, 65, 125, 54, 139, 209,
+193, 177, 1, 151, 226, 214, 50, 29, 228, 234, 160, 246, 183, 7, 165,
+12, 240, 129, 126, 165, 152, 207, 23, 195, 233, 108, 152, 12, 102,
+139, 217, 122, 159, 156, 21, 203, 13, 46, 143, 29, 216, 152, 73, 46,
+209, 168, 164, 43, 171, 2, 129, 88, 178, 178, 46, 89, 91, 93, 190,
+118, 229, 220, 27, 139, 64, 221, 48, 128, 82, 4, 74, 99, 30, 131, 82,
+42, 89, 91, 214, 218, 109, 102, 39, 26, 240, 88, 37, 66, 157, 249,
+146, 0, 176, 41, 228, 241, 184, 109, 110, 175, 94, 103, 210, 235, 236,
+76, 192, 102, 215, 72, 52, 30, 196, 169, 221, 184, 114, 217, 12, 145,
+85, 32, 129, 59, 205, 124, 178, 221, 109, 117, 10, 133, 76, 46, 201,
+197, 34, 44, 74, 70, 82, 133, 76, 195, 191, 176, 188, 161, 181, 251,
+77, 122, 200, 170, 150, 136, 85, 82, 197, 250, 210, 198, 134, 28, 84,
+193, 250, 226, 242, 252, 212, 141, 203, 239, 47, 233, 93, 94, 43, 236,
+71, 128, 1, 5, 156, 94, 245, 202, 134, 96, 73, 105, 5, 204, 4, 136,
+215, 170, 21, 40, 101, 83, 235, 203, 34, 169, 217, 11, 89, 29, 78,
+175, 78, 171, 215, 111, 128, 126, 50, 170, 132, 43, 66, 179, 195, 36,
+95, 63, 127, 81, 100, 11, 166, 106, 157, 157, 94, 38, 26, 42, 181, 26,
+249, 98, 37, 147, 142, 114, 193, 48, 226, 39, 72, 46, 17, 78, 232,
+230, 150, 231, 101, 22, 179, 86, 101, 53, 136, 4, 155, 27, 155, 10,
+96, 187, 235, 235, 138, 205, 165, 165, 153, 229, 27, 215, 175, 156,
+127, 111, 14, 204, 17, 108, 169, 7, 69, 252, 1, 15, 174, 92, 95, 95,
+23, 72, 205, 96, 28, 151, 213, 103, 82, 173, 138, 4, 55, 23, 23, 22,
+86, 245, 94, 208, 60, 54, 187, 65, 188, 33, 189, 179, 180, 38, 215,
+111, 44, 206, 172, 106, 116, 178, 141, 133, 247, 78, 45, 169, 240,
+104, 162, 92, 77, 242, 20, 91, 172, 100, 83, 217, 108, 26, 76, 30, 65,
+33, 151, 7, 198, 104, 140, 22, 207, 222, 153, 146, 169, 149, 26, 153,
+73, 185, 178, 184, 58, 183, 36, 152, 189, 116, 25, 156, 98, 105, 126,
+254, 198, 236, 217, 79, 78, 191, 253, 252, 167, 43, 122, 131, 94, 166,
+181, 122, 124, 52, 5, 187, 84, 2, 225, 202, 202, 154, 214, 168, 214,
+217, 204, 58, 245, 250, 188, 88, 112, 126, 126, 121, 110, 70, 14, 198,
+214, 170, 21, 202, 213, 181, 249, 203, 55, 151, 150, 87, 102, 174, 93,
+155, 93, 94, 93, 153, 189, 253, 198, 243, 31, 204, 25, 97, 31, 75,
+160, 136, 7, 73, 135, 72, 150, 37, 105, 38, 132, 57, 45, 14, 19, 224,
+94, 171, 195, 42, 248, 244, 226, 149, 117, 145, 92, 186, 46, 93, 186,
+115, 237, 210, 237, 249, 169, 169, 43, 167, 79, 1, 230, 158, 190, 249,
+233, 153, 87, 78, 189, 255, 214, 247, 62, 92, 219, 144, 137, 54, 197,
+18, 163, 205, 27, 176, 9, 230, 22, 102, 103, 103, 166, 4, 10, 129, 64,
+33, 187, 121, 103, 250, 218, 242, 245, 15, 46, 92, 59, 119, 113, 70,
+186, 186, 44, 221, 156, 155, 189, 51, 55, 245, 209, 7, 87, 46, 94,
+188, 114, 225, 195, 139, 119, 0, 62, 95, 127, 243, 7, 111, 93, 21, 41,
+212, 118, 173, 66, 161, 212, 224, 1, 131, 195, 97, 113, 251, 96, 199,
+179, 62, 219, 148, 8, 215, 100, 155, 183, 78, 189, 119, 230, 206, 134,
+104, 243, 230, 237, 115, 103, 206, 156, 186, 112, 254, 220, 249, 179,
+111, 191, 252, 246, 165, 75, 231, 62, 122, 255, 205, 31, 125, 231,
+251, 63, 252, 179, 215, 46, 223, 94, 88, 154, 91, 5, 85, 161, 181, 76,
+95, 186, 248, 233, 245, 75, 231, 175, 223, 88, 184, 114, 105, 106,
+230, 220, 197, 15, 207, 92, 120, 245, 149, 119, 222, 125, 227, 221,
+211, 211, 119, 174, 223, 184, 57, 53, 251, 241, 249, 11, 175, 189,
+241, 198, 75, 63, 127, 254, 103, 207, 189, 244, 238, 91, 31, 158, 255,
+232, 165, 255, 244, 221, 183, 46, 94, 156, 94, 90, 188, 53, 117, 251,
+150, 68, 188, 60, 189, 180, 178, 46, 86, 73, 230, 102, 231, 174, 93,
+190, 113, 237, 202, 165, 203, 111, 157, 122, 245, 173, 11, 119, 46,
+159, 63, 245, 214, 43, 127, 243, 55, 127, 241, 253, 31, 254, 245, 15,
+159, 255, 139, 63, 249, 193, 75, 207, 255, 248, 167, 207, 253, 79,
+127, 242, 223, 253, 247, 127, 252, 71, 63, 123, 253, 236, 39, 231,
+206, 93, 252, 228, 244, 135, 151, 79, 191, 251, 198, 107, 239, 158,
+250, 197, 79, 127, 242, 194, 199, 239, 188, 242, 218, 123, 191, 120,
+254, 185, 87, 95, 252, 243, 239, 253, 245, 115, 207, 61, 255, 243,
+151, 222, 126, 247, 189, 247, 223, 62, 245, 226, 43, 167, 126, 252,
+147, 239, 127, 231, 79, 254, 252, 123, 63, 248, 209, 95, 255, 213,
+143, 159, 255, 179, 63, 253, 119, 255, 238, 127, 252, 233, 79, 94,
+123, 243, 213, 215, 222, 248, 232, 210, 252, 210, 212, 167, 23, 175,
+95, 186, 118, 235, 242, 219, 207, 253, 228, 199, 207, 253, 236, 103,
+63, 252, 179, 31, 126, 231, 47, 254, 252, 47, 95, 62, 253, 222, 155,
+63, 251, 254, 119, 254, 232, 79, 255, 250, 249, 151, 95, 249, 217,
+223, 252, 241, 127, 254, 143, 127, 244, 159, 254, 203, 127, 249, 227,
+255, 240, 31, 254, 253, 127, 252, 207, 127, 252, 220, 235, 31, 95,
+186, 62, 61, 55, 35, 84, 185, 80, 183, 65, 46, 156, 187, 116, 233,
+212, 217, 21, 173, 224, 198, 213, 119, 223, 126, 243, 181, 95, 124,
+239, 79, 255, 242, 135, 223, 253, 201, 143, 190, 251, 195, 87, 95,
+250, 238, 95, 126, 239, 79, 255, 234, 199, 235, 194, 165, 185, 171,
+183, 22, 230, 230, 193, 78, 188, 255, 242, 159, 255, 251, 63, 125,
+243, 244, 179, 229, 153, 19, 56, 163, 189, 78, 156, 165, 216, 0, 42,
+87, 204, 190, 249, 250, 27, 231, 110, 92, 185, 114, 125, 122, 250,
+230, 141, 155, 74, 200, 42, 186, 51, 187, 182, 40, 117, 152, 117, 42,
+209, 117, 176, 15, 175, 252, 224, 133, 43, 183, 46, 157, 126, 249,
+253, 23, 127, 240, 142, 208, 193, 176, 225, 100, 188, 94, 171, 53,
+235, 237, 118, 62, 93, 72, 179, 169, 237, 7, 163, 118, 145, 134, 157,
+86, 203, 198, 156, 104, 3, 104, 194, 202, 188, 68, 118, 245, 198, 157,
+249, 249, 105, 160, 133, 226, 165, 27, 55, 46, 93, 185, 115, 229, 221,
+247, 94, 254, 225, 255, 240, 243, 85, 169, 218, 134, 210, 40, 21, 72,
+29, 54, 99, 81, 44, 152, 138, 55, 6, 73, 10, 131, 185, 100, 58, 86,
+168, 166, 40, 6, 4, 72, 133, 80, 105, 246, 218, 181, 122, 173, 100,
+99, 121, 238, 234, 167, 211, 215, 47, 207, 9, 13, 234, 141, 235, 23,
+62, 122, 101, 214, 25, 7, 160, 17, 226, 147, 32, 81, 132, 99, 76, 132,
+198, 48, 60, 60, 153, 116, 218, 121, 158, 163, 220, 62, 139, 194, 102,
+244, 90, 84, 138, 117, 160, 153, 98, 185, 203, 172, 119, 195, 118,
+139, 114, 225, 230, 244, 210, 252, 173, 79, 175, 126, 244, 214, 95,
+157, 17, 155, 124, 16, 65, 250, 113, 127, 184, 150, 163, 104, 31, 30,
+75, 245, 118, 202, 213, 50, 31, 138, 22, 99, 92, 49, 232, 15, 250,
+188, 122, 185, 202, 232, 101, 8, 179, 193, 164, 148, 172, 175, 10,
+150, 196, 18, 185, 74, 169, 214, 8, 111, 92, 59, 243, 198, 58, 148,
+174, 85, 98, 33, 134, 138, 196, 120, 46, 24, 138, 5, 17, 134, 203,
+117, 119, 118, 91, 37, 160, 36, 188, 31, 146, 72, 53, 234, 13, 141,
+94, 34, 17, 172, 173, 45, 233, 84, 207, 158, 192, 49, 105, 133, 107,
+82, 21, 232, 254, 217, 107, 31, 189, 115, 77, 96, 12, 0, 120, 138, 39,
+184, 72, 173, 193, 5, 130, 177, 120, 190, 209, 2, 22, 68, 82, 209,
+124, 154, 207, 7, 220, 65, 30, 115, 121, 253, 38, 44, 232, 119, 3, 11,
+18, 75, 149, 70, 169, 222, 239, 112, 66, 122, 251, 250, 212, 252, 185,
+159, 173, 192, 145, 103, 105, 154, 9, 144, 17, 16, 184, 227, 177, 32,
+25, 79, 181, 90, 205, 78, 57, 95, 205, 164, 146, 188, 79, 162, 53, 43,
+87, 116, 58, 153, 84, 42, 94, 91, 145, 172, 169, 158, 9, 149, 219,
+100, 176, 104, 21, 162, 205, 133, 107, 151, 79, 157, 93, 55, 99, 24,
+29, 207, 52, 106, 153, 98, 53, 207, 134, 138, 249, 76, 169, 80, 201,
+68, 130, 12, 93, 46, 39, 227, 48, 196, 133, 115, 153, 28, 231, 167,
+233, 128, 207, 97, 213, 233, 141, 78, 191, 203, 134, 16, 36, 234, 116,
+73, 87, 166, 222, 125, 126, 222, 79, 113, 225, 72, 0, 246, 64, 72, 56,
+200, 3, 178, 78, 68, 50, 149, 124, 173, 243, 236, 121, 166, 92, 56,
+203, 40, 212, 22, 189, 194, 232, 208, 152, 149, 34, 129, 92, 186, 169,
+66, 24, 16, 123, 125, 192, 137, 213, 50, 165, 228, 206, 181, 115, 31,
+111, 58, 67, 60, 159, 206, 214, 170, 165, 112, 178, 24, 97, 115, 133,
+68, 182, 152, 227, 248, 32, 23, 76, 36, 81, 196, 231, 162, 66, 133,
+108, 49, 134, 4, 240, 0, 100, 1, 37, 96, 243, 120, 253, 206, 0, 205,
+194, 62, 135, 116, 245, 210, 43, 175, 207, 6, 120, 6, 231, 17, 151,
+203, 75, 70, 121, 62, 158, 140, 38, 18, 233, 114, 185, 81, 207, 21,
+210, 185, 108, 161, 25, 218, 144, 171, 52, 64, 126, 237, 136, 93, 43,
+87, 74, 165, 22, 79, 0, 35, 49, 18, 135, 28, 38, 149, 70, 180, 116,
+231, 147, 143, 150, 133, 100, 48, 28, 143, 231, 178, 89, 130, 143,
+211, 124, 50, 18, 3, 198, 23, 164, 195, 33, 54, 202, 187, 9, 200, 238,
+103, 210, 185, 84, 16, 243, 3, 112, 83, 91, 117, 106, 35, 142, 160,
+78, 59, 141, 251, 92, 38, 201, 212, 185, 215, 95, 88, 69, 194, 97,
+150, 193, 253, 126, 156, 75, 39, 163, 169, 108, 56, 149, 205, 23, 243,
+237, 70, 181, 92, 2, 4, 156, 143, 175, 201, 196, 42, 149, 215, 231,
+241, 219, 159, 61, 158, 169, 210, 123, 201, 103, 55, 35, 121, 194,
+227, 52, 232, 196, 242, 165, 179, 239, 108, 206, 218, 137, 112, 42,
+158, 76, 179, 126, 150, 15, 210, 65, 38, 154, 202, 167, 25, 152, 13,
+243, 49, 6, 162, 252, 122, 31, 29, 141, 112, 4, 230, 67, 32, 147, 82,
+167, 211, 89, 97, 239, 51, 115, 112, 56, 237, 90, 233, 244, 165, 247,
+127, 38, 9, 113, 153, 2, 72, 19, 56, 14, 142, 75, 70, 99, 137, 84,
+161, 93, 204, 182, 155, 157, 122, 181, 152, 15, 179, 241, 117, 157,
+66, 37, 51, 59, 29, 176, 221, 108, 178, 90, 77, 102, 56, 25, 39, 227,
+233, 20, 75, 128, 61, 208, 202, 22, 111, 124, 48, 63, 175, 113, 69,
+50, 133, 120, 56, 136, 163, 36, 78, 83, 161, 120, 42, 29, 227, 224, 0,
+21, 138, 145, 110, 194, 167, 129, 2, 36, 67, 186, 97, 159, 7, 210,
+171, 12, 90, 189, 53, 128, 98, 14, 167, 203, 5, 25, 117, 146, 181, 27,
+31, 188, 162, 141, 39, 75, 205, 12, 73, 210, 56, 155, 74, 38, 65, 192,
+78, 52, 218, 197, 124, 173, 212, 6, 69, 156, 137, 20, 242, 66, 131,
+221, 160, 118, 185, 173, 48, 100, 49, 155, 237, 14, 40, 80, 204, 132,
+99, 133, 76, 132, 65, 32, 143, 69, 45, 90, 188, 177, 180, 160, 129,
+57, 0, 63, 65, 0, 48, 94, 55, 73, 211, 92, 56, 17, 38, 224, 0, 75,
+145, 126, 23, 138, 24, 189, 8, 73, 144, 30, 55, 4, 104, 86, 97, 208,
+218, 92, 52, 21, 240, 59, 128, 51, 185, 76, 106, 217, 250, 233, 247,
+92, 209, 116, 173, 88, 136, 82, 65, 14, 9, 242, 73, 54, 150, 204, 180,
+58, 217, 108, 165, 212, 4, 37, 144, 75, 148, 203, 203, 70, 72, 103,
+128, 188, 32, 189, 25, 245, 86, 27, 4, 113, 233, 76, 44, 81, 204, 167,
+163, 132, 223, 239, 84, 75, 23, 239, 24, 23, 116, 100, 60, 27, 143,
+226, 132, 31, 70, 221, 110, 10, 128, 76, 44, 76, 51, 65, 150, 10, 248,
+172, 80, 64, 165, 246, 130, 204, 232, 243, 67, 118, 139, 74, 166, 209,
+67, 126, 16, 7, 253, 94, 139, 30, 132, 81, 171, 86, 113, 251, 156, 21,
+204, 38, 153, 12, 99, 4, 73, 248, 153, 8, 19, 139, 166, 27, 181, 124,
+178, 92, 109, 22, 42, 5, 96, 231, 37, 177, 193, 170, 49, 64, 144, 215,
+14, 214, 222, 232, 66, 125, 209, 76, 60, 146, 72, 149, 83, 60, 141,
+187, 236, 170, 205, 107, 183, 173, 235, 16, 155, 203, 177, 44, 78,
+249, 157, 48, 228, 244, 211, 24, 194, 132, 131, 36, 203, 199, 195,
+132, 215, 139, 201, 148, 174, 0, 65, 32, 132, 199, 10, 230, 111, 114,
+121, 220, 1, 220, 11, 249, 29, 102, 163, 201, 104, 49, 169, 4, 215,
+12, 65, 46, 30, 225, 227, 184, 199, 199, 160, 1, 38, 24, 74, 102, 26,
+173, 122, 42, 92, 171, 21, 42, 149, 124, 34, 154, 149, 27, 141, 26,
+131, 205, 233, 180, 58, 244, 102, 13, 16, 177, 108, 46, 26, 202, 164,
+243, 153, 100, 40, 136, 217, 164, 194, 171, 119, 52, 10, 52, 145, 143,
+4, 57, 50, 224, 118, 249, 32, 151, 23, 35, 124, 48, 31, 225, 193, 246,
+199, 200, 0, 68, 105, 196, 6, 24, 15, 160, 232, 179, 231, 14, 141, 14,
+167, 199, 14, 123, 189, 184, 215, 238, 52, 25, 76, 46, 171, 110, 237,
+83, 67, 52, 158, 204, 130, 218, 241, 81, 84, 52, 147, 46, 240, 217,
+74, 190, 87, 139, 198, 226, 217, 82, 183, 7, 244, 163, 170, 84, 26,
+85, 90, 139, 75, 103, 129, 0, 21, 194, 108, 188, 156, 79, 166, 10,
+249, 108, 58, 145, 14, 249, 61, 18, 201, 213, 37, 189, 5, 78, 68, 193,
+73, 120, 208, 235, 22, 163, 203, 15, 83, 126, 140, 15, 133, 240, 32,
+31, 4, 137, 142, 23, 45, 27, 60, 24, 140, 250, 253, 118, 27, 236, 116,
+184, 252, 46, 216, 225, 163, 16, 175, 211, 174, 50, 106, 77, 170, 165,
+139, 146, 72, 46, 158, 143, 99, 129, 16, 79, 36, 249, 104, 26, 156,
+63, 151, 207, 4, 67, 92, 56, 222, 232, 148, 51, 177, 166, 194, 100,
+215, 200, 1, 245, 155, 44, 78, 183, 159, 9, 197, 74, 233, 100, 54,
+155, 72, 231, 210, 96, 199, 125, 96, 253, 54, 157, 30, 16, 29, 227,
+137, 84, 208, 239, 177, 153, 108, 46, 156, 162, 96, 148, 69, 105, 130,
+97, 200, 24, 131, 241, 107, 27, 42, 23, 30, 112, 185, 253, 46, 48,
+186, 211, 9, 195, 126, 187, 199, 135, 6, 64, 245, 105, 85, 106, 197,
+226, 69, 67, 33, 203, 199, 163, 20, 18, 137, 176, 201, 0, 73, 70, 138,
+149, 114, 46, 201, 178, 108, 144, 47, 86, 154, 197, 84, 221, 100, 112,
+169, 101, 96, 116, 147, 215, 141, 6, 184, 120, 180, 4, 0, 183, 80, 46,
+100, 211, 233, 4, 71, 24, 20, 23, 76, 33, 154, 163, 130, 161, 84, 62,
+228, 246, 2, 85, 247, 96, 49, 46, 224, 37, 253, 20, 65, 249, 201, 48,
+138, 81, 27, 107, 160, 0, 124, 54, 7, 226, 129, 204, 144, 199, 139,
+147, 62, 15, 236, 113, 186, 61, 58, 181, 193, 168, 217, 152, 185, 224,
+111, 101, 19, 32, 123, 80, 9, 14, 166, 104, 138, 202, 230, 10, 245,
+66, 24, 15, 243, 209, 68, 30, 184, 88, 121, 203, 164, 116, 234, 212,
+42, 133, 222, 228, 245, 4, 80, 54, 29, 77, 87, 114, 229, 82, 163, 144,
+72, 102, 83, 81, 218, 165, 157, 193, 75, 233, 52, 75, 178, 169, 116,
+20, 65, 124, 126, 127, 0, 227, 163, 136, 143, 1, 150, 128, 131, 149,
+64, 56, 114, 125, 83, 7, 249, 189, 86, 167, 195, 3, 217, 65, 172, 123,
+246, 216, 141, 31, 182, 155, 76, 26, 29, 100, 84, 173, 207, 92, 68,
+70, 213, 124, 58, 23, 165, 89, 208, 165, 20, 195, 103, 50, 169, 82,
+28, 20, 34, 17, 6, 50, 92, 76, 22, 123, 90, 165, 219, 164, 209, 72,
+53, 118, 200, 23, 164, 168, 84, 50, 87, 204, 20, 106, 157, 114, 58,
+147, 76, 71, 48, 144, 23, 130, 229, 114, 142, 38, 216, 72, 130, 15,
+224, 132, 15, 165, 113, 42, 132, 251, 73, 152, 196, 80, 138, 98, 153,
+124, 98, 77, 172, 53, 195, 78, 139, 207, 139, 98, 30, 191, 7, 225, 40,
+143, 15, 193, 220, 86, 189, 222, 0, 60, 68, 178, 112, 141, 26, 215,
+193, 73, 227, 36, 198, 210, 40, 29, 138, 100, 51, 169, 92, 20, 33,
+113, 44, 20, 137, 101, 242, 225, 204, 200, 168, 179, 153, 244, 54,
+189, 206, 225, 198, 130, 161, 96, 182, 80, 44, 229, 203, 205, 97, 51,
+145, 201, 196, 24, 15, 224, 204, 106, 191, 158, 14, 146, 36, 199, 51,
+44, 73, 18, 236, 179, 219, 215, 60, 195, 32, 132, 207, 13, 179, 60,
+95, 136, 10, 132, 34, 35, 236, 116, 129, 45, 71, 96, 194, 71, 69, 130,
+62, 63, 6, 7, 28, 38, 171, 221, 232, 181, 41, 110, 77, 39, 234, 149,
+120, 60, 14, 236, 55, 22, 194, 105, 150, 11, 179, 177, 52, 233, 5,
+221, 68, 242, 108, 34, 147, 171, 118, 180, 50, 187, 75, 109, 55, 106,
+93, 40, 6, 26, 53, 149, 43, 20, 74, 245, 110, 167, 0, 94, 68, 105,
+212, 170, 218, 28, 238, 181, 210, 161, 0, 208, 93, 156, 167, 112, 63,
+27, 34, 113, 14, 148, 50, 140, 249, 33, 140, 224, 18, 217, 240, 166,
+80, 110, 245, 251, 64, 126, 198, 80, 140, 132, 137, 96, 16, 71, 200,
+128, 7, 132, 89, 39, 228, 2, 253, 63, 155, 106, 228, 99, 49, 142, 10,
+208, 113, 158, 4, 251, 200, 177, 201, 8, 98, 15, 164, 195, 48, 65, 63,
+123, 216, 171, 166, 22, 130, 56, 226, 210, 27, 188, 8, 193, 199, 146,
+137, 76, 179, 92, 105, 212, 59, 165, 98, 50, 17, 231, 16, 151, 81,
+214, 216, 239, 228, 210, 56, 202, 50, 100, 36, 72, 193, 12, 31, 12,
+208, 60, 135, 121, 188, 14, 27, 73, 81, 193, 108, 92, 176, 160, 54,
+123, 80, 24, 129, 41, 12, 37, 80, 20, 11, 146, 16, 141, 218, 129, 158,
+249, 73, 159, 92, 46, 93, 8, 54, 235, 113, 142, 225, 40, 32, 219, 52,
+67, 5, 130, 145, 44, 27, 176, 64, 177, 36, 73, 5, 227, 201, 90, 171,
+101, 22, 138, 213, 82, 179, 218, 233, 1, 198, 23, 206, 228, 11, 221,
+70, 179, 219, 238, 131, 6, 72, 70, 67, 4, 100, 91, 107, 28, 247, 202,
+37, 214, 135, 163, 161, 56, 71, 224, 28, 197, 178, 124, 140, 14, 192,
+40, 228, 101, 194, 84, 168, 156, 94, 157, 81, 104, 188, 120, 0, 3,
+149, 225, 195, 129, 113, 51, 28, 130, 147, 118, 224, 134, 126, 18, 81,
+75, 214, 4, 76, 179, 10, 212, 50, 6, 190, 41, 6, 39, 3, 225, 100, 2,
+209, 107, 80, 62, 29, 142, 103, 178, 201, 218, 176, 103, 217, 144,
+107, 20, 90, 173, 27, 130, 193, 214, 84, 139, 205, 97, 171, 221, 233,
+212, 203, 133, 116, 42, 198, 6, 28, 230, 141, 242, 126, 191, 148, 141,
+122, 159, 201, 87, 136, 198, 131, 28, 27, 138, 69, 1, 81, 128, 197,
+102, 131, 76, 188, 86, 157, 95, 18, 235, 97, 54, 64, 19, 56, 21, 192,
+41, 224, 202, 65, 18, 163, 124, 24, 225, 71, 40, 196, 172, 218, 88,
+230, 210, 185, 120, 54, 198, 135, 104, 138, 192, 253, 4, 30, 77, 146,
+14, 133, 26, 13, 68, 163, 177, 76, 46, 81, 105, 109, 153, 87, 229, 50,
+133, 206, 2, 74, 23, 104, 115, 173, 92, 217, 234, 15, 27, 181, 42,
+160, 228, 104, 152, 198, 236, 106, 121, 173, 217, 206, 69, 89, 143,
+135, 162, 226, 97, 142, 99, 131, 92, 34, 25, 75, 68, 128, 157, 134,
+19, 108, 172, 144, 175, 8, 5, 26, 8, 76, 44, 200, 2, 23, 10, 3, 44,
+73, 114, 52, 195, 128, 82, 246, 83, 84, 192, 99, 222, 220, 136, 196,
+242, 249, 76, 154, 197, 80, 134, 240, 249, 192, 69, 243, 62, 131, 74,
+13, 33, 108, 166, 156, 201, 36, 243, 173, 161, 75, 104, 209, 202, 164,
+6, 63, 228, 195, 249, 84, 181, 218, 218, 217, 25, 52, 186, 205, 114,
+46, 5, 234, 159, 242, 27, 213, 165, 122, 171, 156, 196, 252, 110, 10,
+184, 222, 179, 39, 232, 184, 100, 46, 17, 139, 49, 113, 62, 150, 207,
+130, 214, 44, 72, 148, 54, 136, 162, 128, 35, 209, 36, 23, 5, 84, 150,
+6, 90, 19, 226, 41, 46, 128, 5, 220, 168, 71, 170, 42, 53, 170, 245,
+124, 130, 128, 189, 20, 238, 6, 170, 133, 18, 94, 141, 94, 227, 166,
+18, 229, 90, 53, 7, 214, 127, 100, 85, 186, 204, 74, 169, 213, 235,
+245, 161, 161, 108, 115, 56, 216, 61, 28, 52, 123, 195, 86, 54, 93,
+78, 177, 52, 229, 145, 38, 27, 141, 102, 134, 176, 35, 4, 155, 200,
+166, 83, 169, 104, 56, 154, 41, 240, 225, 104, 52, 149, 44, 150, 234,
+81, 62, 188, 33, 246, 32, 56, 23, 141, 129, 230, 228, 249, 103, 124,
+3, 172, 129, 79, 4, 89, 22, 243, 249, 16, 143, 217, 90, 219, 170, 20,
+114, 9, 220, 225, 38, 49, 220, 143, 194, 94, 151, 77, 103, 84, 97,
+108, 182, 154, 111, 183, 18, 229, 110, 223, 164, 177, 0, 214, 116, 65,
+46, 140, 136, 22, 235, 131, 241, 193, 118, 187, 219, 27, 52, 138, 137,
+108, 130, 229, 72, 159, 46, 91, 170, 87, 83, 4, 232, 46, 138, 77, 21,
+18, 185, 84, 228, 217, 7, 151, 209, 96, 56, 145, 200, 132, 89, 135,
+61, 42, 93, 80, 120, 105, 46, 25, 102, 216, 96, 24, 96, 98, 38, 29,
+229, 185, 104, 38, 18, 142, 210, 126, 140, 14, 56, 124, 197, 70, 187,
+148, 138, 179, 46, 103, 24, 195, 92, 78, 143, 91, 175, 211, 104, 92,
+108, 168, 84, 47, 214, 26, 197, 76, 165, 100, 80, 232, 141, 38, 29,
+228, 116, 123, 217, 124, 179, 59, 217, 57, 158, 244, 250, 237, 94,
+175, 2, 128, 147, 15, 49, 62, 125, 238, 217, 159, 125, 160, 54, 159,
+151, 136, 230, 91, 185, 122, 129, 36, 129, 52, 199, 153, 68, 44, 193,
+249, 156, 106, 21, 171, 92, 220, 116, 17, 64, 76, 184, 68, 60, 149,
+76, 165, 75, 149, 100, 56, 150, 75, 198, 64, 218, 160, 104, 158, 241,
+121, 43, 173, 18, 80, 242, 160, 223, 197, 122, 157, 22, 192, 230, 122,
+147, 74, 1, 211, 185, 114, 5, 224, 71, 173, 84, 137, 105, 229, 128,
+19, 244, 54, 136, 192, 194, 165, 238, 225, 221, 157, 195, 237, 225,
+118, 191, 211, 108, 87, 242, 37, 144, 26, 32, 109, 175, 29, 226, 40,
+151, 209, 75, 144, 177, 66, 54, 26, 167, 29, 110, 10, 64, 28, 128,
+208, 84, 2, 115, 104, 141, 172, 118, 69, 228, 102, 2, 12, 30, 42, 54,
+11, 165, 76, 178, 92, 207, 37, 211, 169, 92, 46, 21, 5, 212, 17, 137,
+96, 68, 99, 144, 142, 167, 72, 216, 97, 115, 65, 110, 39, 130, 219,
+173, 102, 149, 14, 38, 138, 181, 114, 38, 26, 207, 231, 35, 25, 141,
+200, 104, 214, 107, 53, 254, 16, 145, 40, 142, 191, 120, 114, 178,
+191, 51, 153, 140, 134, 163, 113, 167, 81, 75, 165, 19, 168, 183, 21,
+15, 167, 73, 191, 211, 142, 249, 232, 68, 24, 243, 186, 32, 59, 14,
+19, 113, 32, 200, 145, 18, 175, 147, 233, 131, 166, 13, 177, 19, 7,
+155, 147, 107, 212, 43, 141, 84, 36, 223, 170, 84, 154, 165, 106, 54,
+155, 230, 19, 197, 66, 150, 160, 247, 6, 153, 44, 7, 1, 184, 245, 64,
+56, 194, 164, 67, 62, 149, 92, 239, 33, 203, 157, 104, 52, 20, 75,
+242, 92, 204, 162, 48, 168, 13, 6, 3, 196, 248, 169, 212, 246, 175,
+191, 124, 116, 124, 120, 116, 242, 160, 183, 55, 30, 237, 108, 213,
+39, 189, 76, 164, 156, 76, 102, 56, 212, 195, 71, 25, 62, 26, 13, 227,
+4, 229, 66, 252, 4, 79, 211, 161, 120, 53, 239, 17, 89, 88, 143, 193,
+234, 10, 160, 8, 149, 105, 101, 115, 213, 90, 161, 62, 222, 62, 222,
+174, 215, 11, 217, 124, 97, 56, 236, 245, 178, 133, 7, 187, 173, 122,
+206, 103, 49, 67, 126, 44, 204, 81, 201, 10, 101, 85, 42, 61, 225,
+122, 39, 93, 42, 148, 138, 192, 136, 189, 110, 132, 13, 184, 28, 16,
+237, 116, 208, 131, 175, 127, 253, 205, 175, 190, 252, 251, 191, 255,
+246, 233, 23, 15, 159, 62, 126, 120, 239, 193, 110, 39, 71, 187, 220,
+30, 187, 149, 40, 22, 34, 225, 76, 58, 157, 47, 68, 48, 220, 105, 177,
+251, 2, 88, 56, 93, 97, 45, 8, 205, 98, 193, 104, 44, 28, 171, 140,
+182, 123, 195, 227, 163, 221, 163, 131, 167, 15, 142, 6, 221, 70, 163,
+214, 236, 118, 250, 187, 227, 201, 147, 7, 199, 195, 173, 36, 76, 32,
+116, 170, 211, 142, 23, 39, 85, 218, 227, 141, 54, 119, 119, 218, 147,
+241, 110, 59, 139, 130, 78, 1, 42, 18, 4, 226, 79, 6, 139, 199, 223,
+252, 254, 247, 161, 120, 140, 113, 88, 84, 27, 107, 75, 115, 151, 78,
+159, 121, 243, 231, 63, 248, 238, 119, 126, 248, 131, 239, 190, 240,
+246, 187, 31, 156, 187, 120, 99, 122, 118, 250, 198, 153, 143, 222,
+61, 245, 201, 251, 103, 63, 62, 127, 123, 81, 36, 213, 122, 96, 189,
+86, 38, 22, 168, 92, 158, 128, 5, 116, 150, 114, 125, 117, 126, 118,
+122, 246, 198, 133, 91, 151, 206, 159, 63, 253, 201, 133, 79, 47, 223,
+184, 115, 254, 131, 143, 94, 127, 233, 204, 199, 151, 215, 148, 107,
+87, 174, 206, 207, 159, 187, 120, 101, 73, 105, 145, 109, 104, 53, 27,
+107, 243, 75, 152, 87, 52, 55, 7, 222, 124, 238, 194, 165, 219, 2,
+141, 92, 71, 109, 46, 47, 174, 204, 205, 222, 158, 154, 157, 155, 191,
+254, 233, 185, 55, 94, 126, 225, 133, 95, 188, 246, 242, 219, 231,
+166, 166, 87, 214, 133, 66, 193, 220, 244, 157, 235, 159, 158, 57,
+127, 229, 194, 213, 91, 203, 11, 51, 226, 205, 117, 147, 77, 36, 19,
+47, 206, 204, 175, 207, 175, 221, 158, 91, 93, 153, 185, 62, 179, 180,
+177, 178, 48, 123, 229, 202, 212, 242, 220, 237, 153, 155, 87, 47,
+158, 191, 122, 225, 250, 249, 215, 126, 113, 234, 245, 215, 63, 250,
+224, 195, 119, 222, 191, 190, 242, 233, 169, 55, 78, 93, 3, 95, 43,
+43, 119, 102, 86, 55, 3, 142, 77, 193, 218, 220, 165, 143, 207, 95,
+189, 61, 183, 182, 178, 166, 18, 155, 76, 122, 189, 78, 169, 144, 172,
+175, 172, 47, 76, 223, 62, 253, 242, 171, 175, 189, 115, 230, 204,
+181, 21, 185, 213, 108, 208, 201, 20, 106, 133, 120, 101, 246, 230,
+173, 185, 149, 153, 69, 225, 186, 64, 173, 82, 58, 76, 74, 163, 90,
+173, 53, 232, 180, 38, 173, 222, 168, 83, 172, 175, 139, 117, 154,
+205, 245, 213, 185, 37, 161, 112, 121, 117, 125, 241, 250, 202, 234,
+236, 194, 220, 181, 51, 87, 62, 189, 121, 231, 250, 245, 171, 115,
+243, 210, 249, 79, 62, 254, 228, 206, 181, 101, 161, 193, 164, 146,
+234, 108, 113, 139, 92, 184, 177, 177, 62, 183, 180, 34, 18, 9, 52,
+54, 135, 222, 227, 116, 121, 92, 6, 147, 86, 33, 94, 91, 94, 154, 185,
+246, 230, 91, 167, 174, 221, 156, 90, 85, 153, 97, 143, 13, 132, 42,
+183, 70, 45, 21, 9, 54, 197, 10, 145, 72, 97, 112, 1, 215, 197, 141,
+98, 157, 222, 230, 118, 219, 92, 62, 151, 219, 102, 182, 168, 164,
+122, 151, 85, 41, 18, 202, 193, 53, 201, 69, 178, 213, 219, 98, 144,
+195, 86, 231, 110, 222, 190, 51, 51, 53, 53, 63, 35, 82, 137, 231, 46,
+158, 63, 119, 107, 78, 166, 181, 219, 33, 163, 219, 87, 180, 234, 228,
+82, 165, 84, 164, 146, 72, 21, 98, 131, 195, 235, 122, 118, 11, 34, 0,
+178, 167, 90, 161, 17, 11, 231, 111, 190, 247, 206, 7, 55, 230, 55,
+100, 38, 79, 192, 7, 209, 12, 233, 55, 155, 76, 155, 27, 42, 181, 193,
+100, 245, 97, 145, 100, 144, 229, 76, 66, 29, 228, 118, 195, 1, 156,
+33, 49, 167, 27, 246, 152, 172, 46, 143, 86, 109, 50, 216, 32, 179,
+82, 172, 18, 204, 43, 124, 118, 237, 250, 141, 5, 201, 250, 198, 210,
+237, 213, 205, 85, 131, 108, 233, 242, 181, 171, 139, 74, 8, 113, 3,
+102, 246, 65, 37, 147, 205, 8, 2, 168, 202, 104, 212, 106, 77, 102, 4,
+245, 179, 145, 24, 144, 61, 139, 197, 172, 179, 201, 164, 243, 215,
+63, 254, 248, 236, 236, 154, 220, 232, 246, 35, 96, 174, 20, 229, 54,
+27, 205, 90, 141, 209, 14, 202, 141, 75, 229, 43, 57, 42, 226, 151,
+106, 237, 168, 15, 102, 128, 21, 176, 168, 63, 16, 240, 162, 1, 216,
+238, 244, 58, 96, 47, 216, 71, 181, 100, 213, 232, 212, 27, 133, 215,
+4, 114, 129, 68, 48, 39, 16, 175, 138, 20, 51, 183, 55, 215, 54, 141,
+48, 77, 132, 64, 128, 244, 151, 77, 46, 167, 78, 165, 49, 67, 32, 90,
+192, 8, 224, 178, 84, 166, 144, 8, 194, 48, 2, 89, 108, 90, 213, 210,
+229, 79, 46, 92, 94, 85, 107, 173, 68, 192, 135, 194, 30, 12, 131,
+236, 6, 147, 201, 108, 115, 251, 57, 42, 85, 47, 55, 10, 129, 24, 165,
+82, 154, 1, 91, 70, 66, 153, 4, 128, 163, 16, 77, 4, 41, 192, 38, 192,
+123, 96, 179, 201, 108, 209, 108, 152, 204, 66, 185, 104, 118, 93,
+176, 161, 20, 175, 129, 107, 88, 17, 205, 11, 100, 34, 165, 33, 144,
+0, 124, 193, 248, 209, 178, 217, 238, 50, 168, 213, 38, 7, 100, 195,
+162, 28, 8, 58, 197, 82, 41, 3, 204, 19, 6, 17, 206, 174, 152, 249,
+228, 163, 115, 179, 75, 50, 147, 147, 70, 125, 56, 130, 6, 80, 175,
+195, 106, 179, 218, 157, 110, 130, 33, 147, 205, 102, 189, 128, 197,
+162, 74, 149, 211, 139, 71, 66, 192, 20, 226, 233, 100, 42, 200, 240,
+36, 226, 241, 160, 126, 204, 103, 118, 185, 44, 242, 53, 163, 121, 99,
+73, 184, 46, 94, 23, 106, 36, 66, 133, 76, 38, 85, 10, 197, 66, 177,
+210, 205, 166, 50, 124, 140, 195, 200, 178, 214, 96, 81, 233, 236,
+102, 59, 226, 101, 18, 137, 34, 176, 93, 16, 62, 194, 20, 137, 66,
+118, 167, 89, 189, 124, 250, 173, 115, 231, 151, 150, 133, 46, 6, 245,
+130, 194, 32, 253, 96, 112, 171, 221, 231, 69, 24, 156, 75, 55, 58,
+141, 52, 157, 229, 55, 55, 116, 54, 50, 150, 46, 167, 99, 185, 108,
+50, 198, 114, 60, 13, 46, 222, 143, 131, 252, 238, 246, 59, 181, 66,
+187, 75, 176, 44, 218, 216, 16, 136, 100, 34, 145, 74, 45, 215, 152,
+117, 146, 13, 137, 10, 229, 147, 241, 68, 216, 235, 131, 99, 98, 145,
+222, 104, 116, 187, 17, 176, 248, 169, 114, 190, 144, 169, 151, 75,
+185, 100, 136, 194, 61, 144, 69, 173, 95, 63, 247, 202, 135, 23, 166,
+230, 215, 92, 12, 5, 130, 63, 5, 146, 173, 195, 229, 178, 61, 187, 83,
+78, 196, 242, 237, 110, 171, 16, 169, 209, 139, 66, 173, 7, 11, 101,
+203, 201, 88, 46, 21, 138, 208, 100, 130, 193, 225, 128, 15, 121, 246,
+231, 159, 62, 143, 67, 108, 115, 170, 55, 197, 27, 203, 18, 165, 68,
+45, 86, 201, 229, 26, 163, 86, 190, 177, 169, 246, 209, 124, 44, 65,
+120, 221, 246, 160, 92, 100, 48, 154, 156, 16, 142, 122, 136, 92, 181,
+156, 47, 130, 84, 12, 0, 39, 136, 120, 28, 102, 179, 86, 56, 243, 206,
+219, 239, 223, 158, 87, 249, 216, 48, 78, 134, 66, 152, 15, 125, 118,
+175, 14, 163, 72, 150, 201, 22, 218, 157, 118, 41, 222, 32, 231, 21,
+6, 59, 28, 41, 20, 114, 105, 128, 121, 49, 38, 16, 161, 193, 27, 0,
+175, 51, 56, 129, 123, 204, 235, 22, 72, 187, 46, 151, 138, 244, 122,
+141, 94, 174, 6, 74, 161, 213, 63, 123, 6, 198, 30, 12, 198, 120, 212,
+15, 123, 195, 234, 77, 189, 221, 102, 245, 0, 160, 197, 243, 245, 122,
+169, 82, 200, 167, 178, 41, 128, 222, 110, 200, 227, 52, 43, 103, 94,
+127, 243, 189, 107, 11, 206, 0, 64, 119, 42, 194, 49, 8, 236, 3, 17,
+136, 225, 104, 54, 92, 110, 116, 91, 221, 114, 162, 14, 175, 138, 228,
+118, 132, 43, 20, 243, 201, 76, 4, 0, 34, 1, 46, 19, 4, 51, 6, 101,
+152, 32, 110, 144, 173, 106, 32, 163, 80, 166, 83, 106, 140, 86, 157,
+66, 102, 208, 40, 149, 50, 153, 16, 68, 38, 46, 26, 15, 145, 168, 219,
+193, 106, 5, 82, 163, 211, 232, 64, 80, 28, 205, 182, 58, 181, 98, 49,
+159, 74, 102, 120, 128, 254, 94, 183, 197, 34, 95, 122, 243, 197, 183,
+175, 104, 92, 94, 148, 161, 40, 142, 193, 64, 200, 9, 192, 1, 38, 194,
+209, 116, 177, 209, 237, 182, 155, 173, 58, 49, 61, 39, 179, 186, 65,
+150, 200, 196, 192, 178, 1, 232, 96, 131, 1, 20, 67, 2, 224, 5, 235,
+49, 74, 197, 38, 191, 85, 41, 81, 170, 165, 6, 167, 86, 34, 84, 105,
+197, 98, 169, 104, 93, 168, 52, 179, 177, 112, 24, 67, 112, 23, 171,
+149, 43, 205, 110, 43, 196, 50, 12, 145, 107, 215, 155, 185, 82, 37,
+19, 5, 94, 132, 249, 129, 110, 88, 100, 203, 175, 189, 253, 222, 13,
+131, 217, 9, 38, 29, 138, 50, 56, 88, 88, 28, 193, 0, 107, 17, 84,
+161, 51, 236, 117, 118, 119, 251, 145, 233, 25, 177, 209, 69, 3, 30,
+3, 240, 29, 99, 96, 42, 130, 61, 83, 1, 15, 195, 208, 24, 100, 16,
+173, 217, 113, 189, 72, 164, 55, 73, 245, 22, 131, 66, 166, 208, 138,
+148, 10, 225, 138, 72, 107, 5, 249, 47, 138, 251, 121, 36, 10, 126,
+99, 178, 59, 208, 72, 144, 11, 229, 219, 229, 122, 54, 91, 202, 6, 99,
+12, 201, 224, 110, 179, 206, 162, 88, 121, 253, 163, 139, 75, 22, 167,
+131, 96, 64, 178, 2, 29, 0, 6, 38, 217, 48, 27, 196, 208, 228, 112,
+171, 219, 219, 219, 57, 136, 205, 204, 139, 204, 46, 208, 0, 49, 140,
+140, 198, 89, 31, 69, 227, 94, 196, 235, 133, 41, 134, 197, 237, 42,
+193, 170, 219, 15, 66, 164, 201, 174, 80, 200, 133, 74, 169, 18, 84,
+160, 106, 125, 77, 104, 180, 194, 225, 98, 18, 108, 57, 27, 183, 136,
+180, 70, 187, 3, 225, 249, 104, 172, 80, 170, 212, 147, 153, 124, 2,
+33, 8, 28, 67, 189, 46, 163, 85, 179, 246, 246, 245, 219, 162, 0, 236,
+15, 128, 101, 101, 130, 36, 205, 4, 16, 38, 20, 98, 185, 96, 32, 58,
+216, 30, 109, 13, 198, 39, 204, 236, 156, 204, 225, 11, 71, 211, 160,
+245, 35, 60, 27, 96, 72, 2, 193, 65, 14, 35, 41, 4, 177, 42, 215, 23,
+97, 216, 238, 51, 233, 172, 122, 133, 68, 40, 151, 202, 149, 106, 137,
+82, 182, 190, 105, 116, 66, 209, 82, 18, 134, 41, 50, 103, 22, 155,
+141, 30, 63, 78, 70, 146, 137, 108, 166, 88, 74, 255, 255, 105, 197,
+94, 197
+};
+#define LOAD_ASSETS()  GD.copy(__assets, sizeof(__assets))
+#define PAPER_HANDLE 0
+#define PAPER_WIDTH 128
+#define PAPER_HEIGHT 128
+#define PAPER_CELLS 1
+#define ASSETS_END 16384UL
+static const shape_t PAPER_SHAPE = {0, 128, 128, 0};

+ 275 - 0
converted-assets/chess_assets.h

@@ -0,0 +1,275 @@
+static const PROGMEM uint8_t __assets[3937] = {
+0, 0, 0, 5, 0, 0, 0, 1, 32, 64, 16, 8, 32, 128, 48, 7, 34, 255, 255,
+255, 0, 0, 0, 0, 120, 156, 237, 92, 59, 114, 172, 188, 18, 102, 9,
+120, 7, 148, 87, 64, 149, 55, 64, 224, 5, 76, 226, 156, 200, 49, 153,
+83, 66, 135, 164, 206, 136, 29, 145, 59, 97, 1, 14, 102, 3, 174, 154,
+21, 184, 252, 126, 142, 61, 151, 175, 91, 18, 146, 144, 132, 24, 159,
+255, 220, 243, 223, 123, 90, 129, 61, 3, 159, 144, 90, 82, 191, 153,
+36, 249, 131, 41, 79, 202, 100, 149, 100, 123, 162, 219, 228, 78, 180,
+106, 15, 116, 163, 208, 104, 197, 98, 252, 198, 192, 183, 191, 29,
+223, 26, 248, 114, 49, 190, 50, 240, 249, 143, 158, 190, 116, 13, 154,
+9, 26, 109, 21, 137, 78, 157, 232, 187, 164, 143, 196, 23, 30, 252,
+102, 232, 57, 134, 242, 31, 226, 127, 58, 254, 36, 169, 157, 248, 34,
+26, 111, 175, 62, 198, 190, 4, 157, 77, 86, 112, 179, 96, 253, 87,
+214, 222, 31, 231, 159, 69, 161, 221, 220, 227, 81, 204, 245, 144, 5,
+208, 49, 107, 48, 221, 247, 118, 43, 3, 104, 223, 202, 235, 109, 189,