text:
/*
  Arduino Starter Kit example
  Project 8 - Digital Hourglass

  This sketch is written to accompany Project 8 in the Arduino Starter Kit

  Parts required:
  - 10 kilohm resistor
  - six 220 ohm resistors
  - six LEDs
  - tilt switch

  created 13 Sep 2012
  by Scott Fitzgerald

  https://store.arduino.cc/genuino-starter-kit

  This example code is part of the public domain.
*/

// named constant for the switch pin
const int switchPin = 8;

unsigned long previousTime = 0;  // store the last time an LED was updated
int switchState = 0;             // the current switch state
int prevSwitchState = 0;         // the previous switch state
int led = 2;                     // a variable to refer to the LEDs

// 600000 = 10 minutes in milliseconds
long interval = 600000;  // interval at which to light the next LED

void setup() {
  // set the LED pins as outputs
  for (int x = 2; x < 8; x++) {
    pinMode(x, OUTPUT);
  }
  // set the tilt switch pin as input
  pinMode(switchPin, INPUT);
}

void loop() {
  // store the time since the Arduino started running in a variable
  unsigned long currentTime = millis();

  // compare the current time to the previous time an LED turned on
  // if it is greater than your interval, run the if statement
  if (currentTime - previousTime > interval) {
    // save the current time as the last time you changed an LED
    previousTime = currentTime;
    // Turn the LED on
    digitalWrite(led, HIGH);
    // increment the led variable
    // in 10 minutes the next LED will light up
    led++;

    if (led == 7) {
      // the hour is up
    }
  }

  // read the switch value
  switchState = digitalRead(switchPin);

  // if the switch has changed
  if (switchState != prevSwitchState) {
    // turn all the LEDs low
    for (int x = 2; x < 8; x++) {
      digitalWrite(x, LOW);
    }

    // reset the LED variable to the first one
    led = 2;

    //reset the timer
    previousTime = currentTime;
  }
  // set the previous switch state to the current state
  prevSwitchState = switchState;
}


text:
/*
  Arduino Starter Kit example
  Project 5 - Servo Mood Indicator

  This sketch is written to accompany Project 5 in the Arduino Starter Kit

  Parts required:
  - servo motor
  - 10 kilohm potentiometer
  - two 100 uF electrolytic capacitors

  created 13 Sep 2012
  by Scott Fitzgerald

  https://store.arduino.cc/genuino-starter-kit

  This example code is part of the public domain.
*/

// include the Servo library
#include <Servo.h>

Servo myServo;  // create a servo object

int const potPin = A0;  // analog pin used to connect the potentiometer
int potVal;             // variable to read the value from the analog pin
int angle;              // variable to hold the angle for the servo motor

void setup() {
  myServo.attach(9);   // attaches the servo on pin 9 to the servo object
  Serial.begin(9600);  // open a serial connection to your computer
}

void loop() {
  potVal = analogRead(potPin);  // read the value of the potentiometer
  // print out the value to the Serial Monitor
  Serial.print("potVal: ");
  Serial.print(potVal);

  // scale the numbers from the pot
  angle = map(potVal, 0, 1023, 0, 179);

  // print out the angle for the servo motor
  Serial.print(", angle: ");
  Serial.println(angle);

  // set the servo position
  myServo.write(angle);

  // wait for the servo to get there
  delay(15);
}

repo_name: arduino/arduino-examples

repo_language: Shell

mime_type: text/plain


text:
/*
  Arduino Starter Kit example
  Project 10 - Zoetrope

  This sketch is written to accompany Project 10 in the Arduino Starter Kit

  Parts required:
  - two 10 kilohm resistors
  - two momentary pushbuttons
  - one 10 kilohm potentiometer
  - motor
  - 9V battery
  - H-Bridge

  created 13 Sep 2012
  by Scott Fitzgerald
  Thanks to Federico Vanzati for improvements

  https://store.arduino.cc/genuino-starter-kit

  This example code is part of the public domain.
*/

const int controlPin1 = 2;                // connected to pin 7 on the H-bridge
const int controlPin2 = 3;                // connected to pin 2 on the H-bridge
const int enablePin = 9;                  // connected to pin 1 on the H-bridge
const int directionSwitchPin = 4;         // connected to the switch for direction
const int onOffSwitchStateSwitchPin = 5;  // connected to the switch for turning the motor on and off
const int potPin = A0;                    // connected to the potentiometer's output

// create some variables to hold values from your inputs
int onOffSwitchState = 0;              // current state of the on/off switch
int previousOnOffSwitchState = 0;      // previous position of the on/off switch
int directionSwitchState = 0;          // current state of the direction switch
int previousDirectionSwitchState = 0;  // previous state of the direction switch

int motorEnabled = 0;    // Turns the motor on/off
int motorSpeed = 0;      // speed of the motor
int motorDirection = 1;  // current direction of the motor

void setup() {
  // initialize the inputs and outputs
  pinMode(directionSwitchPin, INPUT);
  pinMode(onOffSwitchStateSwitchPin, INPUT);
  pinMode(controlPin1, OUTPUT);
  pinMode(controlPin2, OUTPUT);
  pinMode(enablePin, OUTPUT);

  // pull the enable pin LOW to start
  digitalWrite(enablePin, LOW);
}

void loop() {
  // read the value of the on/off switch
  onOffSwitchState = digitalRead(onOffSwitchStateSwitchPin);
  delay(1);

  // read the value of the direction switch
  directionSwitchState = digitalRead(directionSwitchPin);

  // read the value of the pot and divide by 4 to get a value that can be
  // used for PWM
  motorSpeed = analogRead(potPin) / 4;

  // if the on/off button changed state since the last loop()
  if (onOffSwitchState != previousOnOffSwitchState) {
    // change the value of motorEnabled if pressed
    if (onOffSwitchState == HIGH) {
      motorEnabled = !motorEnabled;
    }
  }

  // if the direction button changed state since the last loop()
  if (directionSwitchState != previousDirectionSwitchState) {
    // change the value of motorDirection if pressed
    if (directionSwitchState == HIGH) {
      motorDirection = !motorDirection;
    }
  }

  // change the direction the motor spins by talking to the control pins
  // on the H-Bridge
  if (motorDirection == 1) {
    digitalWrite(controlPin1, HIGH);
    digitalWrite(controlPin2, LOW);
  } else {
    digitalWrite(controlPin1, LOW);
    digitalWrite(controlPin2, HIGH);
  }

  // if the motor is supposed to be on
  if (motorEnabled == 1) {
    // PWM the enable pin to vary the speed
    analogWrite(enablePin, motorSpeed);
  } else {  // if the motor is not supposed to be on
    //turn the motor off
    analogWrite(enablePin, 0);
  }
  // save the current on/off switch state as the previous
  previousDirectionSwitchState = directionSwitchState;
  // save the current switch state as the previous
  previousOnOffSwitchState = onOffSwitchState;
}


text:
/*
  Arduino Starter Kit example
  Project 6 - Light Theremin

  This sketch is written to accompany Project 6 in the Arduino Starter Kit

  Parts required:
  - photoresistor
  - 10 kilohm resistor
  - piezo

  created 13 Sep 2012
  by Scott Fitzgerald

  https://store.arduino.cc/genuino-starter-kit

  This example code is part of the public domain.
*/

// variable to hold sensor value
int sensorValue;
// variable to calibrate low value
int sensorLow = 1023;
// variable to calibrate high value
int sensorHigh = 0;
// LED pin
const int ledPin = 13;

void setup() {
  // Make the LED pin an output and turn it on
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, HIGH);

  // calibrate for the first five seconds after program runs
  while (millis() < 5000) {
    // record the maximum sensor value
    sensorValue = analogRead(A0);
    if (sensorValue > sensorHigh) {
      sensorHigh = sensorValue;
    }
    // record the minimum sensor value
    if (sensorValue < sensorLow) {
      sensorLow = sensorValue;
    }
  }
  // turn the LED off, signaling the end of the calibration period
  digitalWrite(ledPin, LOW);
}

void loop() {
  //read the input from A0 and store it in a variable
  sensorValue = analogRead(A0);

  // map the sensor values to a wide range of pitches
  int pitch = map(sensorValue, sensorLow, sensorHigh, 50, 4000);

  // play the tone for 20 ms on pin 8
  tone(8, pitch, 20);

  // wait for a moment
  delay(10);
}


text:
// ArduinoISP
// Copyright (c) 2008-2011 Randall Bohn
// If you require a license, see
// https://opensource.org/licenses/bsd-license.php
//
// This sketch turns the Arduino into a AVRISP using the following Arduino pins:
//
// Pin 10 is used to reset the target microcontroller.
//
// By default, the hardware SPI pins MISO, MOSI and SCK are used to communicate
// with the target. On all Arduinos, these pins can be found
// on the ICSP/SPI header:
//
//               MISO °. . 5V (!) Avoid this pin on Due, Zero...
//               SCK   . . MOSI
//                     . . GND
//
// On some Arduinos (Uno,...), pins MOSI, MISO and SCK are the same pins as
// digital pin 11, 12 and 13, respectively. That is why many tutorials instruct
// you to hook up the target to these pins. If you find this wiring more
// practical, have a define USE_OLD_STYLE_WIRING. This will work even when not
// using an Uno. (On an Uno this is not needed).
//
// Alternatively you can use any other digital pin by configuring
// software ('BitBanged') SPI and having appropriate defines for PIN_MOSI,
// PIN_MISO and PIN_SCK.
//
// IMPORTANT: When using an Arduino that is not 5V tolerant (Due, Zero, ...) as
// the programmer, make sure to not expose any of the programmer's pins to 5V.
// A simple way to accomplish this is to power the complete system (programmer
// and target) at 3V3.
//
// Put an LED (with resistor) on the following pins:
// 9: Heartbeat   - shows the programmer is running
// 8: Error       - Lights up if something goes wrong (use red if that makes sense)
// 7: Programming - In communication with the target
//

#include "Arduino.h"
#undef SERIAL

#define PROG_FLICKER true

// Configure SPI clock (in Hz).
// E.g. for an ATtiny @ 128 kHz: the datasheet states that both the high and low
// SPI clock pulse must be > 2 CPU cycles, so take 3 cycles i.e. divide target
// f_cpu by 6:
//     #define SPI_CLOCK            (128000/6)
//
// A clock slow enough for an ATtiny85 @ 1 MHz, is a reasonable default:

#define SPI_CLOCK (1000000 / 6)

// Select hardware or software SPI, depending on SPI clock.
// Currently only for AVR, for other architectures (Due, Zero,...), hardware SPI
// is probably too fast anyway.

#if defined(ARDUINO_ARCH_AVR)

#if SPI_CLOCK > (F_CPU / 128)
#define USE_HARDWARE_SPI
#endif

#endif

// Configure which pins to use:

// The standard pin configuration.
#ifndef ARDUINO_HOODLOADER2

#define RESET 10  // Use pin 10 to reset the target rather than SS
#define LED_HB 9
#define LED_ERR 8
#define LED_PMODE 7

// Uncomment following line to use the old Uno style wiring
// (using pin 11, 12 and 13 instead of the SPI header) on Leonardo, Due...

// #define USE_OLD_STYLE_WIRING

#ifdef USE_OLD_STYLE_WIRING

#define PIN_MOSI 11
#define PIN_MISO 12
#define PIN_SCK 13

#endif

// HOODLOADER2 means running sketches on the ATmega16U2 serial converter chips
// on Uno or Mega boards. We must use pins that are broken out:
#else

#define RESET 4
#define LED_HB 7
#define LED_ERR 6
#define LED_PMODE 5

#endif

// By default, use hardware SPI pins:
#ifndef PIN_MOSI
#define PIN_MOSI MOSI
#endif

#ifndef PIN_MISO
#define PIN_MISO MISO
#endif

#ifndef PIN_SCK
#define PIN_SCK SCK
#endif

// Force bitbanged SPI if not using the hardware SPI pins:
#if (PIN_MISO != MISO) || (PIN_MOSI != MOSI) || (PIN_SCK != SCK)
#undef USE_HARDWARE_SPI
#endif

// Configure the serial port to use.
//
// Prefer the USB virtual serial port (aka. native USB port), if the Arduino has one:
//   - it does not autoreset (except for the magic baud rate of 1200).
//   - it is more reliable because of USB handshaking.
//
// Leonardo and similar have an USB virtual serial port: 'Serial'.
// Due and Zero have an USB virtual serial port: 'SerialUSB'.
//
// On the Due and Zero, 'Serial' can be used too, provided you disable autoreset.
// To use 'Serial': #define SERIAL Serial

#ifdef SERIAL_PORT_USBVIRTUAL
#define SERIAL SERIAL_PORT_USBVIRTUAL
#else
#define SERIAL Serial
#endif

// Configure the baud rate:

#define BAUDRATE 19200
// #define BAUDRATE	115200
// #define BAUDRATE	1000000

#define HWVER 2
#define SWMAJ 1
#define SWMIN 18

// STK Definitions
#define STK_OK 0x10
#define STK_FAILED 0x11
#define STK_UNKNOWN 0x12
#define STK_INSYNC 0x14
#define STK_NOSYNC 0x15
#define CRC_EOP 0x20  //ok it is a space...

void pulse(int pin, int times);

#ifdef USE_HARDWARE_SPI
#include "SPI.h"
#else

#define SPI_MODE0 0x00

#if !defined(ARDUINO_API_VERSION) || ARDUINO_API_VERSION != 10001  // A SPISettings class is declared by ArduinoCore-API 1.0.1
class SPISettings {
public:
  // clock is in Hz
  SPISettings(uint32_t clock, uint8_t bitOrder, uint8_t dataMode)
    : clockFreq(clock) {
    (void)bitOrder;
    (void)dataMode;
  };

  uint32_t getClockFreq() const {
    return clockFreq;
  }

private:
  uint32_t clockFreq;
};
#endif                                                             // !defined(ARDUINO_API_VERSION)

class BitBangedSPI {
public:
  void begin() {
    digitalWrite(PIN_SCK, LOW);
    digitalWrite(PIN_MOSI, LOW);
    pinMode(PIN_SCK, OUTPUT);
    pinMode(PIN_MOSI, OUTPUT);
    pinMode(PIN_MISO, INPUT);
  }

  void beginTransaction(SPISettings settings) {
    pulseWidth = (500000 + settings.getClockFreq() - 1) / settings.getClockFreq();
    if (pulseWidth == 0) {
      pulseWidth = 1;
    }
  }

  void end() {}

  uint8_t transfer(uint8_t b) {
    for (unsigned int i = 0; i < 8; ++i) {
      digitalWrite(PIN_MOSI, (b & 0x80) ? HIGH : LOW);
      digitalWrite(PIN_SCK, HIGH);
      delayMicroseconds(pulseWidth);
      b = (b << 1) | digitalRead(PIN_MISO);
      digitalWrite(PIN_SCK, LOW);  // slow pulse
      delayMicroseconds(pulseWidth);
    }
    return b;
  }

private:
  unsigned long pulseWidth;  // in microseconds
};

static BitBangedSPI SPI;

#endif

void setup() {
  SERIAL.begin(BAUDRATE);

  pinMode(LED_PMODE, OUTPUT);
  pulse(LED_PMODE, 2);
  pinMode(LED_ERR, OUTPUT);
  pulse(LED_ERR, 2);
  pinMode(LED_HB, OUTPUT);
  pulse(LED_HB, 2);
}

int ISPError = 0;
int pmode = 0;
// address for reading and writing, set by 'U' command
unsigned int here;
uint8_t buff[256];  // global block storage

#define beget16(addr) (*addr * 256 + *(addr + 1))
typedef struct param {
  uint8_t devicecode;
  uint8_t revision;
  uint8_t progtype;
  uint8_t parmode;
  uint8_t polling;
  uint8_t selftimed;
  uint8_t lockbytes;
  uint8_t fusebytes;
  uint8_t flashpoll;
  uint16_t eeprompoll;
  uint16_t pagesize;
  uint16_t eepromsize;
  uint32_t flashsize;
} parameter;

parameter param;

// this provides a heartbeat on pin 9, so you can tell the software is running.
uint8_t hbval = 128;
int8_t hbdelta = 8;
void heartbeat() {
  static unsigned long last_time = 0;
  unsigned long now = millis();
  if ((now - last_time) < 40) {
    return;
  }
  last_time = now;
  if (hbval > 192) {
    hbdelta = -hbdelta;
  }
  if (hbval < 32) {
    hbdelta = -hbdelta;
  }
  hbval += hbdelta;
  analogWrite(LED_HB, hbval);
}

static bool rst_active_high;

void reset_target(bool reset) {
  digitalWrite(RESET, ((reset && rst_active_high) || (!reset && !rst_active_high)) ? HIGH : LOW);
}

void loop(void) {
  // is pmode active?
  if (pmode) {
    digitalWrite(LED_PMODE, HIGH);
  } else {
    digitalWrite(LED_PMODE, LOW);
  }
  // is there an error?
  if (ISPError) {
    digitalWrite(LED_ERR, HIGH);
  } else {
    digitalWrite(LED_ERR, LOW);
  }

  // light the heartbeat LED
  heartbeat();
  if (SERIAL.available()) {
    avrisp();
  }
}

uint8_t getch() {
  while (!SERIAL.available())
    ;
  return SERIAL.read();
}
void fill(int n) {
  for (int x = 0; x < n; x++) {
    buff[x] = getch();
  }
}

#define PTIME 30
void pulse(int pin, int times) {
  do {
    digitalWrite(pin, HIGH);
    delay(PTIME);
    digitalWrite(pin, LOW);
    delay(PTIME);
  } while (times--);
}

void prog_lamp(int state) {
  if (PROG_FLICKER) {
    digitalWrite(LED_PMODE, state);
  }
}

uint8_t spi_transaction(uint8_t a, uint8_t b, uint8_t c, uint8_t d) {
  SPI.transfer(a);
  SPI.transfer(b);
  SPI.transfer(c);
  return SPI.transfer(d);
}

void empty_reply() {
  if (CRC_EOP == getch()) {
    SERIAL.print((char)STK_INSYNC);
    SERIAL.print((char)STK_OK);
  } else {
    ISPError++;
    SERIAL.print((char)STK_NOSYNC);
  }
}

void breply(uint8_t b) {
  if (CRC_EOP == getch()) {
    SERIAL.print((char)STK_INSYNC);
    SERIAL.print((char)b);
    SERIAL.print((char)STK_OK);
  } else {
    ISPError++;
    SERIAL.print((char)STK_NOSYNC);
  }
}

void get_version(uint8_t c) {
  switch (c) {
    case 0x80:
      breply(HWVER);
      break;
    case 0x81:
      breply(SWMAJ);
      break;
    case 0x82:
      breply(SWMIN);
      break;
    case 0x93:
      breply('S');  // serial programmer
      break;
    default:
      breply(0);
  }
}

void set_parameters() {
  // call this after reading parameter packet into buff[]
  param.devicecode = buff[0];
  param.revision = buff[1];
  param.progtype = buff[2];
  param.parmode = buff[3];
  param.polling = buff[4];
  param.selftimed = buff[5];
  param.lockbytes = buff[6];
  param.fusebytes = buff[7];
  param.flashpoll = buff[8];
  // ignore buff[9] (= buff[8])
  // following are 16 bits (big endian)
  param.eeprompoll = beget16(&buff[10]);
  param.pagesize = beget16(&buff[12]);
  param.eepromsize = beget16(&buff[14]);

  // 32 bits flashsize (big endian)
  param.flashsize = buff[16] * 0x01000000
                    + buff[17] * 0x00010000
                    + buff[18] * 0x00000100
                    + buff[19];

  // AVR devices have active low reset, AT89Sx are active high
  rst_active_high = (param.devicecode >= 0xe0);
}

void start_pmode() {

  // Reset target before driving PIN_SCK or PIN_MOSI

  // SPI.begin() will configure SS as output, so SPI master mode is selected.
  // We have defined RESET as pin 10, which for many Arduinos is not the SS pin.
  // So we have to configure RESET as output here,
  // (reset_target() first sets the correct level)
  reset_target(true);
  pinMode(RESET, OUTPUT);
  SPI.begin();
  SPI.beginTransaction(SPISettings(SPI_CLOCK, MSBFIRST, SPI_MODE0));

  // See AVR datasheets, chapter "SERIAL_PRG Programming Algorithm":

  // Pulse RESET after PIN_SCK is low:
  digitalWrite(PIN_SCK, LOW);
  delay(20);  // discharge PIN_SCK, value arbitrarily chosen
  reset_target(false);
  // Pulse must be minimum 2 target CPU clock cycles so 100 usec is ok for CPU
  // speeds above 20 KHz
  delayMicroseconds(100);
  reset_target(true);

  // Send the enable programming command:
  delay(50);  // datasheet: must be > 20 msec
  spi_transaction(0xAC, 0x53, 0x00, 0x00);
  pmode = 1;
}

void end_pmode() {
  SPI.end();
  // We're about to take the target out of reset so configure SPI pins as input
  pinMode(PIN_MOSI, INPUT);
  pinMode(PIN_SCK, INPUT);
  reset_target(false);
  pinMode(RESET, INPUT);
  pmode = 0;
}

void universal() {
  uint8_t ch;

  fill(4);
  ch = spi_transaction(buff[0], buff[1], buff[2], buff[3]);
  breply(ch);
}

void flash(uint8_t hilo, unsigned int addr, uint8_t data) {
  spi_transaction(0x40 + 8 * hilo,
                  addr >> 8 & 0xFF,
                  addr & 0xFF,
                  data);
}
void commit(unsigned int addr) {
  if (PROG_FLICKER) {
    prog_lamp(LOW);
  }
  spi_transaction(0x4C, (addr >> 8) & 0xFF, addr & 0xFF, 0);
  if (PROG_FLICKER) {
    delay(PTIME);
    prog_lamp(HIGH);
  }
}

unsigned int current_page() {
  if (param.pagesize == 32) {
    return here & 0xFFFFFFF0;
  }
  if (param.pagesize == 64) {
    return here & 0xFFFFFFE0;
  }
  if (param.pagesize == 128) {
    return here & 0xFFFFFFC0;
  }
  if (param.pagesize == 256) {
    return here & 0xFFFFFF80;
  }
  return here;
}

void write_flash(int length) {
  fill(length);
  if (CRC_EOP == getch()) {
    SERIAL.print((char)STK_INSYNC);
    SERIAL.print((char)write_flash_pages(length));
  } else {
    ISPError++;
    SERIAL.print((char)STK_NOSYNC);
  }
}

uint8_t write_flash_pages(int length) {
  int x = 0;
  unsigned int page = current_page();
  while (x < length) {
    if (page != current_page()) {
      commit(page);
      page = current_page();
    }
    flash(LOW, here, buff[x++]);
    flash(HIGH, here, buff[x++]);
    here++;
  }

  commit(page);

  return STK_OK;
}

#define EECHUNK (32)
uint8_t write_eeprom(unsigned int length) {
  // here is a word address, get the byte address
  unsigned int start = here * 2;
  unsigned int remaining = length;
  if (length > param.eepromsize) {
    ISPError++;
    return STK_FAILED;
  }
  while (remaining > EECHUNK) {
    write_eeprom_chunk(start, EECHUNK);
    start += EECHUNK;
    remaining -= EECHUNK;
  }
  write_eeprom_chunk(start, remaining);
  return STK_OK;
}
// write (length) bytes, (start) is a byte address
uint8_t write_eeprom_chunk(unsigned int start, unsigned int length) {
  // this writes byte-by-byte, page writing may be faster (4 bytes at a time)
  fill(length);
  prog_lamp(LOW);
  for (unsigned int x = 0; x < length; x++) {
    unsigned int addr = start + x;
    spi_transaction(0xC0, (addr >> 8) & 0xFF, addr & 0xFF, buff[x]);
    delay(45);
  }
  prog_lamp(HIGH);
  return STK_OK;
}

void program_page() {
  char result = (char)STK_FAILED;
  unsigned int length = 256 * getch();
  length += getch();
  char memtype = getch();
  // flash memory @here, (length) bytes
  if (memtype == 'F') {
    write_flash(length);
    return;
  }
  if (memtype == 'E') {
    result = (char)write_eeprom(length);
    if (CRC_EOP == getch()) {
      SERIAL.print((char)STK_INSYNC);
      SERIAL.print(result);
    } else {
      ISPError++;
      SERIAL.print((char)STK_NOSYNC);
    }
    return;
  }
  SERIAL.print((char)STK_FAILED);
  return;
}

uint8_t flash_read(uint8_t hilo, unsigned int addr) {
  return spi_transaction(0x20 + hilo * 8,
                         (addr >> 8) & 0xFF,
                         addr & 0xFF,
                         0);
}

char flash_read_page(int length) {
  for (int x = 0; x < length; x += 2) {
    uint8_t low = flash_read(LOW, here);
    SERIAL.print((char)low);
    uint8_t high = flash_read(HIGH, here);
    SERIAL.print((char)high);
    here++;
  }
  return STK_OK;
}

char eeprom_read_page(int length) {
  // here again we have a word address
  int start = here * 2;
  for (int x = 0; x < length; x++) {
    int addr = start + x;
    uint8_t ee = spi_transaction(0xA0, (addr >> 8) & 0xFF, addr & 0xFF, 0xFF);
    SERIAL.print((char)ee);
  }
  return STK_OK;
}

void read_page() {
  char result = (char)STK_FAILED;
  int length = 256 * getch();
  length += getch();
  char memtype = getch();
  if (CRC_EOP != getch()) {
    ISPError++;
    SERIAL.print((char)STK_NOSYNC);
    return;
  }
  SERIAL.print((char)STK_INSYNC);
  if (memtype == 'F') {
    result = flash_read_page(length);
  }
  if (memtype == 'E') {
    result = eeprom_read_page(length);
  }
  SERIAL.print(result);
}

void read_signature() {
  if (CRC_EOP != getch()) {
    ISPError++;
    SERIAL.print((char)STK_NOSYNC);
    return;
  }
  SERIAL.print((char)STK_INSYNC);
  uint8_t high = spi_transaction(0x30, 0x00, 0x00, 0x00);
  SERIAL.print((char)high);
  uint8_t middle = spi_transaction(0x30, 0x00, 0x01, 0x00);
  SERIAL.print((char)middle);
  uint8_t low = spi_transaction(0x30, 0x00, 0x02, 0x00);
  SERIAL.print((char)low);
  SERIAL.print((char)STK_OK);
}
//////////////////////////////////////////
//////////////////////////////////////////

////////////////////////////////////
////////////////////////////////////
void avrisp() {
  uint8_t ch = getch();
  switch (ch) {
    case '0':  // signon
      ISPError = 0;
      empty_reply();
      break;
    case '1':
      if (getch() == CRC_EOP) {
        SERIAL.print((char)STK_INSYNC);
        SERIAL.print("AVR ISP");
        SERIAL.print((char)STK_OK);
      } else {
        ISPError++;
        SERIAL.print((char)STK_NOSYNC);
      }
      break;
    case 'A':
      get_version(getch());
      break;
    case 'B':
      fill(20);
      set_parameters();
      empty_reply();
      break;
    case 'E':  // extended parameters - ignore for now
      fill(5);
      empty_reply();
      break;
    case 'P':
      if (!pmode) {
        start_pmode();
      }
      empty_reply();
      break;
    case 'U':  // set address (word)
      here = getch();
      here += 256 * getch();
      empty_reply();
      break;

    case 0x60:  //STK_PROG_FLASH
      getch();  // low addr
      getch();  // high addr
      empty_reply();
      break;
    case 0x61:  //STK_PROG_DATA
      getch();  // data
      empty_reply();
      break;

    case 0x64:  //STK_PROG_PAGE
      program_page();
      break;

    case 0x74:  //STK_READ_PAGE 't'
      read_page();
      break;

    case 'V':  //0x56
      universal();
      break;
    case 'Q':  //0x51
      ISPError = 0;
      end_pmode();
      empty_reply();
      break;

    case 0x75:  //STK_READ_SIGN 'u'
      read_signature();
      break;

    // expecting a command, not CRC_EOP
    // this is how we can get back in sync
    case CRC_EOP:
      ISPError++;
      SERIAL.print((char)STK_NOSYNC);
      break;

    // anything else we will return STK_UNKNOWN
    default:
      ISPError++;
      if (CRC_EOP == getch()) {
        SERIAL.print((char)STK_UNKNOWN);
      } else {
        SERIAL.print((char)STK_NOSYNC);
      }
  }
}


text:
/*
  Memsic2125

  Read the Memsic 2125 two-axis accelerometer. Converts the pulses output by the
  2125 into milli-g's (1/1000 of Earth's gravity) and prints them over the
  serial connection to the computer.

  The circuit:
	- X output of accelerometer to digital pin 2
	- Y output of accelerometer to digital pin 3
	- +V of accelerometer to +5V
	- GND of accelerometer to ground

  created 6 Nov 2008
  by David A. Mellis
  modified 30 Aug 2011
  by Tom Igoe

  This example code is in the public domain.

  https://www.arduino.cc/en/Tutorial/BuiltInExamples/Memsic2125
*/

// these constants won't change:
const int xPin = 2;  // X output of the accelerometer
const int yPin = 3;  // Y output of the accelerometer

void setup() {
  // initialize serial communications:
  Serial.begin(9600);
  // initialize the pins connected to the accelerometer as inputs:
  pinMode(xPin, INPUT);
  pinMode(yPin, INPUT);
}

void loop() {
  // variables to read the pulse widths:
  int pulseX, pulseY;
  // variables to contain the resulting accelerations
  int accelerationX, accelerationY;

  // read pulse from x- and y-axes:
  pulseX = pulseIn(xPin, HIGH);
  pulseY = pulseIn(yPin, HIGH);

  // convert the pulse width into acceleration
  // accelerationX and accelerationY are in milli-g's:
  // Earth's gravity is 1000 milli-g's, or 1 g.
  accelerationX = ((pulseX / 10) - 500) * 8;
  accelerationY = ((pulseY / 10) - 500) * 8;

  // print the acceleration
  Serial.print(accelerationX);
  // print a tab character:
  Serial.print("\t");
  Serial.print(accelerationY);
  Serial.println();

  delay(100);
}


text:
/*
  Knock Sensor

  This sketch reads a piezo element to detect a knocking sound.
  It reads an analog pin and compares the result to a set threshold.
  If the result is greater than the threshold, it writes "knock" to the serial
  port, and toggles the LED on pin 13.

  The circuit:
	- positive connection of the piezo attached to analog in 0
	- negative connection of the piezo attached to ground
	- 1 megohm resistor attached from analog in 0 to ground

  created 25 Mar 2007
  by David Cuartielles <http://www.0j0.org>
  modified 30 Aug 2011
  by Tom Igoe

  This example code is in the public domain.

  https://www.arduino.cc/en/Tutorial/BuiltInExamples/Knock
*/

// these constants won't change:
const int ledPin = 13;       // LED connected to digital pin 13
const int knockSensor = A0;  // the piezo is connected to analog pin 0
const int threshold = 100;   // threshold value to decide when the detected sound is a knock or not

// these variables will change:
int sensorReading = 0;  // variable to store the value read from the sensor pin
int ledState = LOW;     // variable used to store the last LED status, to toggle the light

void setup() {
  pinMode(ledPin, OUTPUT);  // declare the ledPin as as OUTPUT
  Serial.begin(9600);       // use the serial port
}

void loop() {
  // read the sensor and store it in the variable sensorReading:
  sensorReading = analogRead(knockSensor);

  // if the sensor reading is greater than the threshold:
  if (sensorReading >= threshold) {
    // toggle the status of the ledPin:
    ledState = !ledState;
    // update the LED pin itself:
    digitalWrite(ledPin, ledState);
    // send the string "Knock!" back to the computer, followed by newline
    Serial.println("Knock!");
  }
  delay(100);  // delay to avoid overloading the serial port buffer
}


text:
/*
  ADXL3xx

  Reads an Analog Devices ADXL3xx accelerometer and communicates the
  acceleration to the computer. The pins used are designed to be easily
  compatible with the breakout boards from SparkFun, available from:
  https://www.sparkfun.com/categories/80

  The circuit:
  - analog 0: accelerometer self test
  - analog 1: z-axis
  - analog 2: y-axis
  - analog 3: x-axis
  - analog 4: ground
  - analog 5: vcc

  created 2 Jul 2008
  by David A. Mellis
  modified 30 Aug 2011
  by Tom Igoe

  This example code is in the public domain.

  https://www.arduino.cc/en/Tutorial/BuiltInExamples/ADXL3xx
*/

// these constants describe the pins. They won't change:
const int groundpin = 18;  // analog input pin 4 -- ground
const int powerpin = 19;   // analog input pin 5 -- voltage
const int xpin = A3;       // x-axis of the accelerometer
const int ypin = A2;       // y-axis
const int zpin = A1;       // z-axis (only on 3-axis models)

void setup() {
  // initialize the serial communications:
  Serial.begin(9600);

  // Provide ground and power by using the analog inputs as normal digital pins.
  // This makes it possible to directly connect the breakout board to the
  // Arduino. If you use the normal 5V and GND pins on the Arduino,
  // you can remove these lines.
  pinMode(groundpin, OUTPUT);
  pinMode(powerpin, OUTPUT);
  digitalWrite(groundpin, LOW);
  digitalWrite(powerpin, HIGH);
}

void loop() {
  // print the sensor values:
  Serial.print(analogRead(xpin));
  // print a tab between values:
  Serial.print("\t");
  Serial.print(analogRead(ypin));
  // print a tab between values:
  Serial.print("\t");
  Serial.print(analogRead(zpin));
  Serial.println();
  // delay before next reading:
  delay(100);
}


text:
/*
  Ping))) Sensor

  This sketch reads a PING))) ultrasonic rangefinder and returns the distance
  to the closest object in range. To do this, it sends a pulse to the sensor to
  initiate a reading, then listens for a pulse to return. The length of the
  returning pulse is proportional to the distance of the object from the sensor.

  The circuit:
	- +V connection of the PING))) attached to +5V
	- GND connection of the PING))) attached to ground
	- SIG connection of the PING))) attached to digital pin 7

  created 3 Nov 2008
  by David A. Mellis
  modified 30 Aug 2011
  by Tom Igoe

  This example code is in the public domain.

  https://www.arduino.cc/en/Tutorial/BuiltInExamples/Ping
*/

// this constant won't change. It's the pin number of the sensor's output:
const int pingPin = 7;

void setup() {
  // initialize serial communication:
  Serial.begin(9600);
}

void loop() {
  // establish variables for duration of the ping, and the distance result
  // in inches and centimeters:
  long duration, inches, cm;

  // The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
  // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
  pinMode(pingPin, OUTPUT);
  digitalWrite(pingPin, LOW);
  delayMicroseconds(2);
  digitalWrite(pingPin, HIGH);
  delayMicroseconds(5);
  digitalWrite(pingPin, LOW);

  // The same pin is used to read the signal from the PING))): a HIGH pulse
  // whose duration is the time (in microseconds) from the sending of the ping
  // to the reception of its echo off of an object.
  pinMode(pingPin, INPUT);
  duration = pulseIn(pingPin, HIGH);

  // convert the time into a distance
  inches = microsecondsToInches(duration);
  cm = microsecondsToCentimeters(duration);

  Serial.print(inches);
  Serial.print("in, ");
  Serial.print(cm);
  Serial.print("cm");
  Serial.println();

  delay(100);
}

long microsecondsToInches(long microseconds) {
  // According to Parallax's datasheet for the PING))), there are 73.746
  // microseconds per inch (i.e. sound travels at 1130 feet per second).
  // This gives the distance travelled by the ping, outbound and return,
  // so we divide by 2 to get the distance of the obstacle.
  // See: https://www.parallax.com/package/ping-ultrasonic-distance-sensor-downloads/
  return microseconds / 74 / 2;
}

long microsecondsToCentimeters(long microseconds) {
  // The speed of sound is 340 m/s or 29 microseconds per centimeter.
  // The ping travels out and back, so to find the distance of the object we
  // take half of the distance travelled.
  return microseconds / 29 / 2;
}


text:
#include "pico/stdlib.h"
#include "hardware/pio.h"
#include "emmc.pio.h"
#include "pins.h"
#include "glitch.h"
#include <stdio.h>
#include "misc.h"
#include "board_detect.h"
#include "hardware/structs/rosc.h"

extern uint32_t gsniff_pio_offset;
extern uint32_t dsniff_pio_offset;
extern uint32_t gtrig_pio_offset;

void init_gsniff_pio() {
    pio_sm_config c = glitch_sniff_cmd_program_get_default_config(gsniff_pio_offset);
    sm_config_set_in_pins(&c, PIN_CMD);
    sm_config_set_jmp_pin(&c, PIN_CMD);
    sm_config_set_in_shift(&c, false, true, 32);
    sm_config_set_out_shift(&c, false, false, 32);
    sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_RX);
    pio_sm_init(pio1, G_SNIFF_SM, gsniff_pio_offset, &c);
    pio_sm_set_enabled(pio1, G_SNIFF_SM, true);
}

void init_dat0_pio() {
    pio_sm_config c = glitch_dat_waiter_program_get_default_config(dsniff_pio_offset);
    sm_config_set_in_pins(&c, PIN_DAT);
    sm_config_set_jmp_pin(&c, PIN_DAT);
    sm_config_set_in_shift(&c, false, true, 32);
    sm_config_set_out_shift(&c, false, false, 32);
    sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_RX);
    pio_sm_init(pio1, G_DAT0_SM, dsniff_pio_offset, &c);
    pio_sm_set_enabled(pio1, G_DAT0_SM, true);
}

extern bool mariko;

void init_trigger_pio() {
    uint offset = gtrig_pio_offset;
    pio_sm_config c = glitch_trigger_program_get_default_config(offset);
    sm_config_set_sideset_pins (&c, gli_pin());
    sm_config_set_out_shift(&c, false, true, 32);

    pio_sm_set_consecutive_pindirs(pio1, G_TRIG_SM, gli_pin(), 1, true);
    pio_sm_init(pio1, G_TRIG_SM, offset, &c);
    pio_sm_set_enabled(pio1, G_TRIG_SM, true);
    pio_gpio_init(pio1, gli_pin());
    gpio_set_slew_rate(gli_pin(), GPIO_SLEW_RATE_FAST);
}

void init_glitch_pio() {
    for (int i = PIN_CLK; i <= PIN_DAT; i++)
    {
        gpio_init(i);
        gpio_enable_input_output(i);
        gpio_pull_up(i);
    }
    gpio_init(gli_pin());
    init_gsniff_pio();
    init_dat0_pio();
    init_trigger_pio();
}

void deinit_glitch_pio() {
    pio_set_sm_mask_enabled(pio1, 0x3, false);
    for (int i = PIN_CLK; i <= PIN_DAT; i++)
    {
            gpio_deinit(i);
            gpio_disable_pulls(i);
            gpio_disable_input_output(i);
    }
    gpio_deinit(gli_pin());
}

int do_glitch(int delay, int width, int total_ms, int after_ms) {
    // at this point CPU must be reset
    init_glitch_pio();
    pio_sm_put_blocking(pio1, G_TRIG_SM, delay);
    pio_sm_put_blocking(pio1, G_TRIG_SM, width);

    bool glitch_started = false;

    uint32_t last_word = 0;

    uint32_t data_count = 0;

    int result = GLITCH_RESULT_MISSING;
    bool detected = false;

    absolute_time_t detect_time = make_timeout_time_ms(20);
    absolute_time_t full_time = make_timeout_time_ms(total_ms);
    absolute_time_t tio_time = detect_time;

    while (!time_reached(tio_time)) {
        if (!pio_sm_is_rx_fifo_empty(pio1, G_DAT0_SM)) {
            uint32_t temp = pio_sm_get(pio1, G_DAT0_SM);
        }
        if (!pio_sm_is_rx_fifo_empty(pio1, G_SNIFF_SM)) {
           uint32_t cur_word = pio_sm_get(pio1, G_SNIFF_SM);
           if (!detected && (cur_word >> 24) == 0x3F) {
               tio_time = full_time;
               detected = true;
           }
           if (glitch_started)
               data_count += 1;
           if (last_word == 0x51000000 && cur_word == 0x1351) {
               if (!glitch_started)
                   tio_time = make_timeout_time_ms(after_ms);
               glitch_started = true;
           }
           if (last_word == 0x51000000 && cur_word == 0x142F) {
               result = GLITCH_RESULT_FAILURE;
               break;
           }
           if (last_word == 0x40aa5458 && cur_word == 0xba3b) {
               result = GLITCH_RESULT_SUCCESS;
               break;
           }
           if (data_count == 10) {
               tio_time = full_time;
           }
           last_word = cur_word;
        }
    }
    deinit_glitch_pio();
    if (result == GLITCH_RESULT_MISSING && glitch_started) {
        result = GLITCH_RESULT_TIMEOUT;
    }
    return result;
}

int tries = 0;

// Blue pulsing implementation.
void inc_tries()
{
    tries += 1;
    if(tries & 1)
        put_pixel(PIX_b);
    else
        put_pixel(PIX_blu);
}

// random() for glitch offset array generation
static uint32_t get_random_word(int cycles) {
    uint32_t byte;
    assert(rosc_hw->status & ROSC_STATUS_ENABLED_BITS);
    for(int i=0; i < cycles; i++) {
        busy_wait_at_least_cycles(100);
        byte = ((byte << 1) | rosc_hw->randombit);
    }
    return byte;
}

int offsets_array[OFFSET_CNT];
void prepare_random_array()
{
    for(int i = 0; i < OFFSET_CNT; i++)
        offsets_array[i] = OFFSET_MIN + OFFSET_DIV*i;
    for (int i = OFFSET_CNT - 1; i > 0; i--) {
            size_t j = get_random_word(32) % (i+1);
            int t = offsets_array[j];
            offsets_array[j] = offsets_array[i];
            offsets_array[i] = t;
    }
}

bool glitch_try_offset(int offset, int * width, int edge_limit) {
    int last_res = GLITCH_RESULT_SUCCESS;
    int edges = 0;
    int step = tries == 0 ? 32 : 8; // first ever edge search should be faster
    int missing_count = 0;
    inc_tries();
    while (1) {
        reset_cpu();
        int gres = do_glitch(offset + get_random_word(3), *width, 300, 6);
        if (gres == GLITCH_RESULT_MISSING)
            missing_count +=1; // MMC has failed to initialize
        else
            missing_count = 0;
        if (missing_count >= 5)
            halt_with_error(4, 3); // something wrong with eMMC, cannot init properly
        if (*width == 1) {
            halt_with_error(5, 3);
        }
        if (*width >= 1000) {  // no reaction to the glitch, hardware failure or bad mosfet wire
            halt_with_error(6, 3);
        }
        if ((last_res == GLITCH_RESULT_TIMEOUT && gres == GLITCH_RESULT_FAILURE)
          || (gres == GLITCH_RESULT_TIMEOUT && last_res == GLITCH_RESULT_FAILURE)) {
            if (step != 1)
                step /= 2; // we have found the edge, now increase search presicion
            else
                edges += 1; // max precision, start walking around the edge
        }
        last_res = gres;
        if (gres == GLITCH_RESULT_FAILURE) // not enough glitch, need more width
            *width += step;
        if (gres == GLITCH_RESULT_TIMEOUT) { // too much glitch, need less width
            *width -= step;
            if (*width <= 1)
                *width = 1;
        }
        if (gres == GLITCH_RESULT_SUCCESS)
            return true;
        if (edges > edge_limit) // this offset did not work
            return false;
    }
}

repo_name: rehius/usk

repo_language: C


text:
#define PIN_GLI_WS 15
#define PIN_GLI_XIAO 6
#define PIN_GLI_PICO 21
#define PIN_GLI_ITSY 24

#define PIN_LED_WS 16
#define PIN_LED_ITSY 17
#define PIN_LED_XIAO 12
#define PIN_LED_PICO 25

#define PIN_LED_PWR_XIAO 11
#define PIN_LED_RED_XIAO 17
#define PIN_LED_GRN_XIAO 16
#define PIN_LED_BLU_XIAO 25

#define PIN_SDA_WS 12
#define PIN_SDA_XIAO 3
#define PIN_SDA_PICO 19
#define PIN_SDA_ITSY 18
#define PIN_SDA_SQC 18

#define PIN_SCL_WS 13
#define PIN_SCL_XIAO 4
#define PIN_SCL_PICO 20
#define PIN_SCL_ITSY 19
#define PIN_SCL_SQC 19

#define PIN_LED_PWR_ITSY 16

#define PIN_RGB_MODE_WS 25

#define PIN_DAT 29
#define PIN_CMD 28
#define PIN_CLK 27
#define PIN_RST 26

#define PIN_TEMP_PICO 29


text:
const uint8_t mariko_bct_sign[] = {
	0x03, 0xA2, 0x6C, 0xA5, 0x5A, 0x73, 0x47, 0xC7, 0x78, 0xD7, 0x40, 0x62, 0x2D, 0xA5, 0x38, 0xC0,
	0x89, 0x00, 0xC5, 0x65, 0xA2, 0x75, 0x25, 0xE8, 0xC6, 0xD3, 0x46, 0xE9, 0xC4, 0x41, 0xFE, 0x7B,
	0x47, 0xD4, 0xC1, 0x49, 0x70, 0x57, 0x22, 0xFD, 0x32, 0x4F, 0x09, 0x8A, 0x87, 0xEC, 0x40, 0x5D,
	0xC2, 0x24, 0xDC, 0x45, 0x4A, 0xBA, 0x4A, 0x2F, 0x27, 0x02, 0xD9, 0x34, 0xB0, 0x1D, 0xE2, 0xA3,
	0xAE, 0x9C, 0xB8, 0xC4, 0x47, 0x26, 0xCC, 0x29, 0xDB, 0x11, 0xA5, 0xE6, 0x98, 0xE8, 0xE5, 0x7B,
	0xB2, 0x4B, 0x63, 0xFC, 0x53, 0x8C, 0xD2, 0x71, 0x95, 0xA7, 0x81, 0x9D, 0xE7, 0x20, 0x94, 0x67,
	0xF3, 0x53, 0x78, 0xB4, 0x0D, 0xBD, 0xBD, 0xAF, 0xEC, 0xD7, 0xB2, 0xC3, 0xE9, 0x7E, 0xD6, 0xC8,
	0xB9, 0xD1, 0x72, 0x74, 0x0E, 0x4F, 0x8C, 0x24, 0x4E, 0xB7, 0x4A, 0xB1, 0x4A, 0x16, 0x89, 0x59,
	0x56, 0x7F, 0x27, 0x12, 0xFB, 0x7C, 0x67, 0xD3, 0x04, 0x6E, 0x34, 0xCC, 0x8D, 0x73, 0x47, 0x02,
	0xA7, 0x57, 0x64, 0xC7, 0x2C, 0x8A, 0x88, 0xDA, 0xBC, 0x5A, 0xE4, 0x46, 0x1A, 0x34, 0xD5, 0xE7,
	0x83, 0x74, 0xFF, 0x6D, 0x67, 0xC7, 0x72, 0x81, 0x63, 0x4A, 0x25, 0x7A, 0xB6, 0xEE, 0xFF, 0x30,
	0x98, 0xBF, 0xCE, 0x38, 0xD7, 0x4B, 0xA6, 0xFE, 0x94, 0xF7, 0x89, 0xE6, 0x2A, 0x1F, 0xE9, 0x8E,
	0xB4, 0xF8, 0xA4, 0xA9, 0x4A, 0xE9, 0x14, 0x59, 0x07, 0xAD, 0xD6, 0x50, 0x4D, 0xBB, 0x36, 0xB7,
	0xD1, 0x65, 0x32, 0x32, 0x37, 0x74, 0x8E, 0xF3, 0x0A, 0xCC, 0x9E, 0x00, 0xAE, 0x3A, 0x82, 0xEA,
	0xCB, 0x10, 0x65, 0xFC, 0x96, 0xBE, 0x67, 0xC3, 0x76, 0x42, 0xE6, 0x1A, 0xA5, 0x5B, 0x1B, 0x8E,
	0x8F, 0xA6, 0x71, 0x0A, 0xA7, 0xE8, 0x0C, 0xA8, 0xE1, 0x9B, 0x8B, 0x2E, 0xEB, 0x82, 0x20, 0x6A
};

const uint8_t mariko_bct_data[] = {
	0x17, 0x8B, 0x59, 0x4B, 0xB4, 0x11, 0xFE, 0x24, 0x07, 0x3E, 0xA9, 0xF0, 0xF4, 0xC8, 0x4E, 0xB0,
	0x95, 0x40, 0x03, 0x21, 0x05, 0x48, 0x60, 0xC4, 0xDF, 0xAE, 0x56, 0x32, 0xF6, 0x5E, 0x27, 0xE1,
	0x2B, 0x25, 0x25, 0xE8, 0x19, 0xC6, 0xBB, 0xC9, 0xA4, 0x28, 0x21, 0x2E, 0x62, 0x98, 0x5E, 0x20,
	0x0D, 0x3D, 0x61, 0x99, 0x84, 0x90, 0xC4, 0x73, 0x8B, 0xC9, 0x83, 0x78, 0xBF, 0x8E, 0x9C, 0x92,
	0xD9, 0xB2, 0x33, 0x33, 0x9F, 0x28, 0x4D, 0xF7, 0x43, 0xC5, 0x5D, 0x2A, 0x1F, 0x26, 0xA3, 0x41,
	0xB1, 0x72, 0xEB, 0x28, 0x64, 0x07, 0xA4, 0x2A, 0x89, 0x70, 0xEE, 0x86, 0x43, 0xC5, 0x9C, 0x19,
	0xEA, 0xDC, 0x6C, 0x90, 0xF2, 0x13, 0xDD, 0xBE, 0x06, 0xF4, 0xB5, 0x11, 0xD4, 0x33, 0x79, 0x45,
	0x5E, 0x63, 0xD4, 0x89, 0x0A, 0x46, 0x8C, 0xF8, 0x12, 0x59, 0x16, 0xC1, 0xBB, 0xA0, 0xE7, 0x79,
	0x11, 0xD4, 0x03, 0x26, 0xFD, 0x3A, 0xB0, 0xB4, 0x5F, 0x8E, 0x05, 0x0A, 0x1E, 0x9D, 0xAB, 0x31,
	0x31, 0xF2, 0x96, 0x37, 0x77, 0xAE, 0x56, 0xF3, 0x36, 0x17, 0xF3, 0x94, 0xF8, 0x90, 0x48, 0xD3,
	0xD1, 0x93, 0x2A, 0x4B, 0x2E, 0x90, 0x85, 0xCD, 0x04, 0xA3, 0x34, 0x7E, 0xC9, 0xEA, 0xB2, 0x84,
	0x58, 0x4C, 0xB7, 0xCD, 0xC8, 0xA6, 0x31, 0x84, 0xAB, 0xCD, 0x86, 0x71, 0xE3, 0x07, 0x0E, 0xAC,
	0x27, 0x94, 0x19, 0x3E, 0xE7, 0xB4, 0x61, 0x31, 0xA1, 0xF5, 0x87, 0xDF, 0x8B, 0xC0, 0xD0, 0x8C,
	0x2E, 0x7F, 0x92, 0x82, 0x9B, 0x78, 0x84, 0x31, 0x8F, 0x77, 0x03, 0xF1, 0x70, 0xB1, 0xA6, 0xEB,
	0xAF, 0x11, 0x5E, 0xC1, 0x33, 0x85, 0x44, 0xD7, 0x96, 0x3D, 0x33, 0x8D, 0x07, 0x6B, 0x58, 0x6B,
	0x66, 0x9D, 0x9C, 0x50, 0xEF, 0x45, 0x0F, 0x6F, 0xA7, 0x96, 0x71, 0x75, 0xCA, 0x41, 0x76, 0x6A,
	0x80, 0x67, 0xE8, 0x29, 0xC5, 0x50, 0x77, 0x2D, 0x2A, 0x8D, 0x38, 0x36, 0xFF, 0x04, 0x6A, 0x6C,
	0xDA, 0x22, 0x51, 0x4C, 0x6C, 0xB6, 0x1D, 0xD3, 0xA5, 0x15, 0x41, 0x43, 0x3B, 0x04, 0xE5, 0xD9,
	0x11, 0xBA, 0x46, 0xA9, 0x7F, 0x54, 0xFC, 0xD1, 0xFB, 0x88, 0x1F, 0x0C, 0xA1, 0x74, 0x21, 0x8A,
	0x83, 0x7E, 0xC1, 0x1C, 0xDB, 0x77, 0xC6, 0x6A, 0xFF, 0x21, 0xC2, 0x9A, 0x46, 0xEE, 0xEA, 0x9D,
	0x92, 0xD1, 0x04, 0x7A, 0x98, 0xD8, 0xB8, 0xA2, 0x22, 0xF5, 0xAA, 0xAE, 0x52, 0xD4, 0x66, 0x14,
	0x61, 0x18, 0x1C, 0x56, 0xCB, 0xA9, 0xA4, 0x84, 0x19, 0x08, 0xAE, 0xF1, 0x7E, 0x66, 0x4C, 0xA4,
	0xF6, 0xDE, 0xC4, 0x4B, 0x9D, 0xA1, 0x78, 0xFB, 0xE8, 0xA5, 0x9D, 0xFF, 0x20, 0xBB, 0x76, 0xAC,
	0xC8, 0x96, 0x31, 0x0F, 0x14, 0xE4, 0x51, 0x88, 0x08, 0xDC, 0x73, 0x6E, 0x43, 0x5A, 0x25, 0x14,
	0x49, 0x03, 0xA2, 0x44, 0x78, 0x37, 0xD8, 0xB6, 0x99, 0x31, 0xE1, 0xC8, 0x79, 0x9C, 0x4A, 0x5B,
	0x01, 0x68, 0x10, 0xC0, 0x77, 0x77, 0x1C, 0xA0, 0x3C, 0x92, 0xEC, 0xA7, 0x4D, 0x8C, 0xA3, 0x35,
	0xDE, 0xBA, 0xEE, 0xC0, 0xC1, 0x40, 0xE6, 0xB7, 0xF0, 0x63, 0x31, 0x6F, 0x22, 0x6B, 0x96, 0x3E,
	0xB1, 0xF1, 0xA2, 0x74, 0x26, 0xB7, 0x59, 0x9B, 0x5F, 0x77, 0x12, 0x42, 0x3E, 0x7D, 0xD1, 0x17,
	0x69, 0x65, 0x89, 0x3C, 0xDE, 0xCA, 0x6F, 0x07, 0xC2, 0x04, 0xF5, 0x57, 0xD7, 0x85, 0xDF, 0xB8,
	0x61, 0xC1, 0x02, 0x7E, 0xC1, 0x12, 0x07, 0x1E, 0xA9, 0x36, 0x8D, 0x65, 0x76, 0x46, 0x1E, 0x18,
	0x78, 0x9C, 0x93, 0x2B, 0x66, 0xB8, 0x6C, 0x3C, 0x50, 0x5C, 0x33, 0xE7, 0x0D, 0x7E, 0xA0, 0xFD,
	0xF9, 0x84, 0xE5, 0x96, 0x48, 0xF8, 0xCF, 0x45, 0x1D, 0x43, 0x7A, 0x78, 0xFB, 0xD4, 0x86, 0x1E,
	0x55, 0x3F, 0xB3, 0xC8, 0xE8, 0x8E, 0xE1, 0xD9, 0xF5, 0x57, 0x74, 0x70, 0xEB, 0x7F, 0xBC, 0xE5,
	0xC6, 0x63, 0x8A, 0x04, 0xDF, 0x9D, 0xD6, 0x2F, 0x95, 0xDC, 0xC6, 0x94, 0x89, 0x9B, 0xFE, 0x85,
	0x71, 0x31, 0x4A, 0x1A, 0x79, 0xFA, 0x48, 0x8E, 0xF1, 0x78, 0x34, 0x02, 0x7A, 0xA0, 0xEB, 0xD0,
	0x1E, 0xBF, 0xA3, 0x86, 0x3D, 0xDD, 0x38, 0x5C, 0x8B, 0xC3, 0x13, 0x39, 0xF7, 0x63, 0x88, 0x48,
	0xC3, 0x0D, 0x63, 0x62, 0x7D, 0xE0, 0x16, 0x51, 0x12, 0xA0, 0x67, 0x9B, 0xA7, 0x49, 0xAB, 0xDC,
	0x76, 0x44, 0xA3, 0xC3, 0xEC, 0x37, 0x87, 0xA0, 0x3F, 0xA3, 0x48, 0x5F, 0xE2, 0x97, 0x60, 0x3A,
	0x5F, 0xDA, 0x71, 0xF6, 0x3F, 0x72, 0xEA, 0x6A, 0x61, 0xF1, 0xB9, 0x04, 0x6F, 0xA9, 0x93, 0xA9,
	0x11, 0xA2, 0x06, 0x5B, 0x8D, 0xA1, 0x4F, 0x1B, 0x01, 0x05, 0xB5, 0xD7, 0x93, 0x53, 0x31, 0x7D,
	0xEC, 0xE6, 0x38, 0x18, 0x2C, 0x8A, 0x1D, 0x51, 0x9F, 0x33, 0x32, 0xD3, 0x19, 0x3E, 0xE1, 0x44,
	0x6F, 0x8D, 0x9F, 0x53, 0x43, 0xF4, 0x39, 0x44, 0xFE, 0x10, 0xF1, 0x9B, 0xC8, 0xA9, 0x86, 0x26,
	0xCC, 0xF2, 0x59, 0x8E, 0x86, 0x54, 0xAF, 0xA4, 0xCC, 0x91, 0x87, 0x7B, 0x64, 0xCE, 0x8B, 0x54,
	0x0C, 0xC6, 0x90, 0x5F, 0x64, 0x04, 0x3C, 0xE2, 0x1A, 0xB0, 0x48, 0xE3, 0x3A, 0x75, 0x00, 0x2E,
	0xC8, 0x7D, 0x9D, 0x85, 0x59, 0x2B, 0x19, 0x4D, 0x3A, 0x5E, 0x8A, 0x6C, 0x27, 0x2C, 0x4E, 0xF1,
	0x35, 0x5B, 0x58, 0x1B, 0x38, 0x7F, 0x29, 0xE3, 0xCD, 0x1D, 0x8B, 0x31, 0x1C, 0x14, 0x0E, 0xBA,
	0x17, 0xEE, 0x3C, 0x3B, 0x54, 0xBE, 0x4B, 0x01, 0x11, 0xD6, 0xCA, 0x03, 0xA4, 0xAC, 0x9D, 0xD9,
	0xA2, 0x09, 0x06, 0x06, 0x65, 0xBC, 0x89, 0xFD, 0x03, 0xC5, 0x87, 0xE5, 0xDB, 0x67, 0x5B, 0x58,
	0x35, 0x77, 0xFD, 0x52, 0x4F, 0xC7, 0xCF, 0xA9, 0x35, 0x4C, 0x72, 0x77, 0x9B, 0x50, 0x03, 0x9D,
	0xC5, 0x9E, 0xA2, 0x95, 0x52, 0xB5, 0xC0, 0xB6, 0x54, 0x86, 0x41, 0xD0, 0xC2, 0xE1, 0x58, 0xF9,
	0xA7, 0x1B, 0xDE, 0xE0, 0x4D, 0x8E, 0x3C, 0xA7, 0x8F, 0x09, 0x1A, 0xCE, 0x04, 0xE7, 0x02, 0xBA,
	0x5E, 0x2A, 0x9A, 0x87, 0xEF, 0xDE, 0x9B, 0xD1, 0x4E, 0x9F, 0x41, 0x4E, 0x45, 0xBA, 0xA5, 0x85,
	0x8E, 0xE6, 0x20, 0x79, 0xF9, 0x93, 0x68, 0x24, 0x3A, 0x71, 0xFB, 0x26, 0x3F, 0x59, 0x85, 0xAA,
	0xAD, 0xEA, 0x6F, 0x81, 0xFA, 0x8C, 0x0A, 0x33, 0x81, 0x29, 0xF1, 0xF8, 0x1B, 0xBA, 0x38, 0xC6,
	0x33, 0x07, 0xD1, 0x1A, 0x60, 0x3F, 0x0A, 0x35, 0x7F, 0x3C, 0x69, 0x35, 0xAF, 0x7C, 0x7F, 0x4A,
	0xFD, 0x2D, 0xF8, 0x05, 0x14, 0xFD, 0x0C, 0xC3, 0xB6, 0x4B, 0x9C, 0x3B, 0xC2, 0xA2, 0x63, 0x00,
	0x80, 0xF0, 0x7F, 0xFC, 0x94, 0x0A, 0x92, 0x08, 0xB0, 0x68, 0x4C, 0x39, 0x69, 0x95, 0x8F, 0xD6,
	0xAA, 0x05, 0x9B, 0x99, 0xDE, 0x37, 0xC3, 0x49, 0xD9, 0xA5, 0xED, 0xA4, 0x0A, 0x69, 0xDA, 0xE0,
	0x6D, 0x14, 0x10, 0x6C, 0x72, 0xBD, 0x7C, 0xE3, 0x0F, 0x2D, 0xE3, 0x0C, 0x25, 0x82, 0xFB, 0xED,
	0x80, 0x58, 0x24, 0x48, 0xCE, 0xA1, 0x40, 0x4C, 0x0C, 0x31, 0x61, 0xAE, 0xCD, 0x39, 0xFE, 0x95,
	0xE3, 0x64, 0x9B, 0x34, 0xC0, 0x1B, 0xB0, 0xFB, 0xF3, 0xAC, 0x71, 0x8B, 0xCF, 0x77, 0x67, 0x7A,
	0x9A, 0xA8, 0x3F, 0x25, 0x2B, 0xC9, 0x91, 0x31, 0x54, 0x8C, 0x98, 0xB4, 0xE3, 0x58, 0xB7, 0x32,
	0xDD, 0xC6, 0x19, 0xA0, 0x26, 0xBA, 0x6E, 0xC0, 0x7C, 0x74, 0x4C, 0x84, 0x5D, 0x41, 0x64, 0xCA,
	0xAA, 0xCD, 0xAA, 0xA0, 0xAF, 0x4D, 0xF2, 0xAB, 0xC6, 0x6F, 0x6D, 0xFE, 0x7D, 0x3D, 0xDC, 0x69,
	0xE9, 0x05, 0x88, 0xEF, 0xC9, 0xB6, 0x9C, 0x5D, 0x99, 0xEE, 0xD4, 0x90, 0xBF, 0xF4, 0x4A, 0x40,
	0x1D, 0xB9, 0xF7, 0x9C, 0x55, 0x68, 0x7C, 0x9C, 0x68, 0x78, 0xF6, 0xAF, 0xB9, 0x96, 0xF3, 0x4A,
	0x2C, 0x33, 0x0D, 0x02, 0x56, 0x5F, 0x9E, 0x67, 0x58, 0x33, 0xE9, 0x40, 0x21, 0xE7, 0x18, 0xEB,
	0xA5, 0xD9, 0x8D, 0x31, 0x67, 0xEB, 0x4C, 0x8D, 0x5E, 0x40, 0x93, 0xFE, 0x10, 0x6F, 0x5F, 0x39,
	0x6F, 0x99, 0xB6, 0x4D, 0x73, 0xFB, 0xB1, 0xF8, 0x95, 0x9E, 0x47, 0x3F, 0x83, 0x9C, 0x84, 0x5C,
	0x34, 0x0F, 0x91, 0x11, 0x6B, 0x83, 0x0B, 0x1B, 0xAA, 0x69, 0x46, 0xF3, 0x4E, 0xDA, 0xC3, 0xAF,
	0x92, 0xB9, 0x89, 0xB9, 0x40, 0x03, 0x27, 0x5F, 0x5C, 0x77, 0x9E, 0xEB, 0x67, 0xA6, 0x7F, 0xC2,
	0x20, 0xFB, 0xC3, 0xD4, 0x2E, 0xEC, 0xD6, 0x53, 0xCD, 0x3F, 0xC8, 0x5C, 0xD8, 0x2D, 0x40, 0x42,
	0xF4, 0x60, 0x92, 0xBF, 0x15, 0x3B, 0x18, 0x75, 0x56, 0x02, 0xE6, 0x8E, 0x14, 0xA3, 0x4F, 0x04,
	0x98, 0x04, 0x61, 0x52, 0x30, 0x16, 0x95, 0x09, 0x4F, 0x86, 0xFE, 0xE9, 0x79, 0xEB, 0x70, 0xB6,
	0x59, 0x2B, 0x9A, 0xF6, 0x5B, 0xFA, 0xF7, 0xE2, 0x0B, 0xD8, 0x6C, 0x54, 0x1B, 0x16, 0xAB, 0x06,
	0x5C, 0x70, 0xA1, 0x84, 0x88, 0x5A, 0xE5, 0xBA, 0xE6, 0x41, 0xF9, 0xF4, 0x7B, 0xE3, 0x34, 0xB9,
	0x12, 0xEC, 0xA3, 0x05, 0xF2, 0x99, 0x98, 0x00, 0x43, 0x1A, 0x52, 0xA3, 0xF6, 0xCC, 0x45, 0x90,
	0x3E, 0x42, 0xBA, 0xE3, 0x75, 0xFF, 0xC9, 0x5E, 0x3F, 0xAA, 0xA1, 0xAF, 0xEA, 0x5E, 0x82, 0x35,
	0x82, 0xD4, 0x47, 0x81, 0x79, 0xC7, 0x3B, 0x63, 0x45, 0xD4, 0xFD, 0x25, 0xAB, 0x32, 0x9E, 0xED,
	0x98, 0x14, 0x01, 0x75, 0xAD, 0x1C, 0xD8, 0xE4, 0x24, 0x4C, 0x34, 0x58, 0x6A, 0xAA, 0x35, 0xB1,
	0xAA, 0xF1, 0xDD, 0x7E, 0x44, 0x45, 0x8A, 0xA4, 0x15, 0x60, 0xC1, 0x28, 0x37, 0x8F, 0xC2, 0xAE,
	0xD8, 0x80, 0xCB, 0xB4, 0x9E, 0x92, 0xD2, 0xCB, 0x15, 0x59, 0x3B, 0x8D, 0x8E, 0x23, 0x72, 0xBE,
	0x39, 0x7B, 0x60, 0x7B, 0x7D, 0xCA, 0x59, 0x08, 0x9A, 0x90, 0x61, 0x78, 0xF0, 0xF1, 0x12, 0x4E,
	0x35, 0xC9, 0x56, 0x42, 0x6C, 0x58, 0xC4, 0xA1, 0xB9, 0x61, 0x27, 0x12, 0xF4, 0x83, 0x8E, 0x27,
	0x29, 0x0F, 0xE3, 0xA8, 0x2C, 0xEE, 0xD9, 0xFD, 0x8F, 0x0A, 0x34, 0xB1, 0x67, 0x0E, 0x90, 0x9A,
	0xC2, 0xEE, 0xBB, 0xFC, 0x49, 0x12, 0xBB, 0x0C, 0x62, 0xD1, 0x31, 0x32, 0x26, 0xAA, 0xCC, 0x56,
	0x3D, 0x20, 0x0F, 0xD9, 0x7D, 0xBC, 0x42, 0x1E, 0x86, 0x99, 0xEC, 0xAE, 0x97, 0x43, 0x78, 0x3C,
	0xDF, 0xD2, 0x6C, 0xBA, 0x8F, 0x9E, 0x95, 0x9E, 0x7F, 0x26, 0xEC, 0x56, 0x04, 0xF2, 0x57, 0x26,
	0xE1, 0xD8, 0x1F, 0x09, 0x8A, 0xC1, 0xBD, 0xE5, 0xE6, 0x6A, 0xE7, 0x2F, 0x40, 0xD2, 0xA2, 0x60,
	0x66, 0x19, 0x01, 0xB9, 0x9E, 0x49, 0x6A, 0x50, 0x9B, 0x6D, 0x82, 0x31, 0x72, 0x42, 0x8D, 0xF2,
	0xCD, 0x0B, 0xC5, 0x1E, 0x4E, 0xF8, 0x62, 0xBE, 0xF0, 0x4C, 0x30, 0x48, 0x01, 0x74, 0x01, 0xC2,
	0x24, 0x78, 0xFC, 0x0F, 0xDB, 0xED, 0xA5, 0xFA, 0x1A, 0x56, 0x3E, 0x67, 0x8B, 0x66, 0x8E, 0xD6,
	0x11, 0x54, 0xCD, 0x8B, 0xD0, 0xF8, 0x2A, 0x55, 0xB7, 0xC2, 0x09, 0x3E, 0x45, 0xF6, 0x9A, 0xC4,
	0xE5, 0x40, 0x26, 0x81, 0xB3, 0x62, 0x8F, 0xEC, 0x1D, 0xF4, 0x08, 0x0B, 0x6A, 0xB4, 0x2F, 0x3A,
	0xE5, 0xDF, 0x19, 0x67, 0x02, 0xF1, 0xF6, 0xE9, 0x17, 0x92, 0xDB, 0xA7, 0xB7, 0x10, 0x00, 0xBF,
	0x22, 0x5C, 0x5A, 0xA0, 0x00, 0xD5, 0x44, 0xA1, 0xD6, 0xCD, 0x24, 0xDA, 0xB6, 0x22, 0xD0, 0xA3,
	0xA2, 0xFD, 0xDF, 0x40, 0x24, 0xA0, 0xF3, 0xC0, 0xEB, 0xEE, 0xE0, 0x93, 0xD5, 0x04, 0x0C, 0x08,
	0x34, 0x79, 0xBC, 0x2B, 0x4B, 0xB5, 0xF4, 0xCD, 0x41, 0xBA, 0x8E, 0xFA, 0x8C, 0xAC, 0xF6, 0x50,
	0x0C, 0x75, 0xC0, 0x2B, 0x46, 0xA3, 0x0B, 0x8B, 0x2A, 0x6D, 0xE6, 0x5F, 0xF5, 0x39, 0x90, 0x9D,
	0x0C, 0x9F, 0x9B, 0x66, 0x21, 0xA3, 0x01, 0xD1, 0xCE, 0x0A, 0x32, 0xA4, 0x3F, 0x47, 0x61, 0x1E,
	0x33, 0xFD, 0x20, 0x7C, 0x38, 0x6B, 0x34, 0x11, 0xBA, 0xCC, 0x3F, 0x83, 0xEC, 0x73, 0x28, 0x78,
	0x96, 0x99, 0x19, 0x40, 0xAE, 0xB4, 0x1C, 0xE8, 0xD2, 0x7E, 0xED, 0x3A, 0xE2, 0x23, 0x06, 0xB9,
	0xBA, 0x0D, 0x95, 0x89, 0xEF, 0xDE, 0x97, 0xCD, 0x63, 0xC6, 0x55, 0xC0, 0x34, 0x21, 0x26, 0xD0,
	0xEC, 0xE7, 0x96, 0xBC, 0x3D, 0x4D, 0x50, 0x63, 0x8A, 0xAE, 0xD3, 0x16, 0x0E, 0x12, 0x46, 0xC1,
	0x62, 0x49, 0xF2, 0x4D, 0x3E, 0x6F, 0x93, 0x02, 0xB5, 0x1B, 0x9F, 0x71, 0x79, 0xEC, 0x2B, 0x99,
	0xDD, 0xCB, 0x7E, 0x10, 0xA1, 0x8F, 0xDC, 0x44, 0xBC, 0x4E, 0x90, 0x19, 0xEA, 0x23, 0x78, 0x79,
	0x96, 0x1C, 0xE7, 0xBF, 0x15, 0xBC, 0x32, 0x63, 0x8B, 0xE3, 0xD2, 0x23, 0xEB, 0xD9, 0x67, 0x4E,
	0xB3, 0x53, 0x93, 0x5E, 0x8D, 0xA7, 0xEE, 0xC3, 0x75, 0x28, 0x07, 0xB4, 0x35, 0x12, 0x06, 0xB6,
	0x70, 0x42, 0x2C, 0xAC, 0x67, 0xD2, 0x6D, 0xAE, 0x49, 0x35, 0xD8, 0x31, 0xB6, 0x36, 0xD5, 0x23,
	0x64, 0x6B, 0x09, 0xC4, 0x3C, 0x16, 0x8A, 0xA0, 0x13, 0x9D, 0x01, 0x6B, 0x3D, 0x65, 0xCC, 0xE0,
	0x77, 0x07, 0xDE, 0xBA, 0xAB, 0x70, 0x52, 0x8B, 0x6F, 0xCD, 0x06, 0x0B, 0xF3, 0x65, 0x30, 0x52,
	0x17, 0x9D, 0x31, 0xC9, 0x56, 0xFE, 0x05, 0x05, 0x78, 0xAA, 0x18, 0xDA, 0xFD, 0x77, 0x12, 0xA5,
	0x18, 0x57, 0x24, 0xB6, 0x57, 0xFC, 0xEC, 0x21, 0xBE, 0x48, 0xA9, 0x33, 0xA0, 0x10, 0xBF, 0x38,
	0xC6, 0xA2, 0x8E, 0xFB, 0x0D, 0x03, 0x03, 0xFC, 0xC1, 0xF5, 0x11, 0x46, 0xF1, 0x77, 0xC4, 0x91,
	0x92, 0x61, 0x30, 0x56, 0xB1, 0xFA, 0x38, 0x0E, 0x7A, 0x16, 0x1D, 0xFC, 0x9C, 0x5D, 0x07, 0xD0,
	0x68, 0xA1, 0xC8, 0x2F, 0x3D, 0x8E, 0x6D, 0x47, 0x98, 0x21, 0x0C, 0xD5, 0xB1, 0xF1, 0xC5, 0x3F,
	0xFE, 0x51, 0x0E, 0x70, 0xB7, 0x6C, 0x95, 0xDE, 0x1F, 0x73, 0x8C, 0x27, 0x11, 0x34, 0x21, 0x47,
	0x00, 0x5B, 0xC7, 0xD2, 0xE9, 0x35, 0x50, 0xF5, 0x7B, 0xD6, 0xB2, 0x38, 0x89, 0x48, 0x6A, 0x9B,
	0x76, 0x6D, 0x7D, 0x92, 0x31, 0xE6, 0xCE, 0x97, 0xE5, 0xA3, 0xAA, 0xA7, 0xE0, 0x77, 0x2E, 0x29,
	0xB2, 0xB8, 0x6F, 0x1C, 0x74, 0x6F, 0x04, 0xC7, 0x70, 0x92, 0x7E, 0x31, 0xB6, 0xBE, 0x75, 0xA0,
	0x2D, 0x8C, 0xC9, 0x1C, 0x36, 0x30, 0xE8, 0xAB, 0xEB, 0x39, 0x51, 0x5C, 0x58, 0x80, 0x3B, 0x9F,
	0xB4, 0x0F, 0x45, 0x9A, 0xE9, 0xE5, 0x61, 0xB1, 0x6B, 0x4D, 0x61, 0x9C, 0xA8, 0x2A, 0x0A, 0x97,
	0xE5, 0x2E, 0x76, 0x9B, 0x2F, 0xFE, 0x0D, 0x83, 0x8A, 0xFA, 0x9A, 0x48, 0x60, 0x60, 0x48, 0x35,
	0x3E, 0x86, 0x51, 0x06, 0xC4, 0x81, 0xC9, 0x9C, 0x5D, 0xE2, 0x18, 0xAE, 0x29, 0xE9, 0x06, 0x75,
	0x16, 0x7B, 0x1D, 0x21, 0x23, 0xDF, 0xDE, 0xD1, 0x77, 0xBC, 0x34, 0x9A, 0xFE, 0xB6, 0x7B, 0x9D,
	0x37, 0x61, 0x1D, 0x8B, 0x4C, 0x53, 0xD9, 0xCA, 0xFA, 0x72, 0xB4, 0x9D, 0x7C, 0x0C, 0x56, 0xBF,
	0x5B, 0x96, 0xE7, 0x56, 0xDE, 0x2F, 0x60, 0xB2, 0x54, 0x23, 0x7B, 0xAC, 0x2B, 0xC3, 0xF3, 0x28,
	0x86, 0xB5, 0xD6, 0x0E, 0x90, 0x35, 0x80, 0xF0, 0xFC, 0x07, 0x93, 0x67, 0xDB, 0x70, 0xAC, 0xBA,
	0xE3, 0xD7, 0xD8, 0x3B, 0x2A, 0xAF, 0x27, 0xBC, 0x51, 0x57, 0xCC, 0xE9, 0x10, 0x55, 0x66, 0x27,
	0x47, 0x7E, 0xB3, 0x82, 0x6B, 0x70, 0x26, 0x40, 0x0D, 0x43, 0x33, 0x8E, 0xCA, 0x91, 0x2F, 0x39,
	0x41, 0x93, 0x98, 0x5E, 0x96, 0x81, 0xEB, 0x5E, 0xBE, 0xB0, 0x5B, 0x5A, 0xE7, 0xA1, 0x7F, 0xFD,
	0x68, 0x62, 0xF9, 0x63, 0x31, 0x59, 0xB5, 0xEC, 0x65, 0x65, 0xE7, 0x57, 0x13, 0x4B, 0x35, 0xD5,
	0x18, 0x21, 0x1D, 0x71, 0xBA, 0x63, 0xE6, 0x4B, 0xA6, 0xF8, 0xD2, 0x02, 0xBD, 0x00, 0x2A, 0xAC,
	0xD0, 0xA9, 0x27, 0x92, 0x66, 0xAC, 0xAE, 0xEA, 0x96, 0xB9, 0x87, 0x73, 0xF8, 0x69, 0xE7, 0x56,
	0x7C, 0xCF, 0xB2, 0x1C, 0x39, 0x0C, 0xC5, 0xAD, 0x81, 0x9A, 0xAF, 0x01, 0x83, 0xD7, 0x6D, 0x8E,
	0x5C, 0x22, 0xBB, 0xAC, 0xD3, 0x62, 0x11, 0xB8, 0x29, 0x57, 0x9D, 0x8A, 0x09, 0xE3, 0x34, 0xB5,
	0x0F, 0x49, 0x2F, 0x8C, 0x97, 0x6D, 0xE7, 0x63, 0x0C, 0x97, 0x63, 0xD7, 0xF1, 0x6B, 0xF6, 0x98,
	0xE1, 0x1D, 0x5A, 0x20, 0xEA, 0xA1, 0xF3, 0x1D, 0x65, 0x6B, 0x2D, 0xF2, 0x0D, 0xE7, 0x99, 0xB5,
	0xD6, 0xE9, 0xCC, 0xD1, 0x2D, 0x74, 0xA5, 0x2B, 0x2B, 0xDC, 0x60, 0x1C, 0x92, 0x90, 0xC3, 0xB2,
	0x02, 0x6B, 0x2A, 0xE7, 0xC3, 0x70, 0x72, 0x5D, 0xD9, 0x29, 0xE1, 0xE0, 0x32, 0xB5, 0xE2, 0x52,
	0xF5, 0xF9, 0x35, 0x4E, 0xFF, 0x57, 0x8B, 0xBA, 0x47, 0x83, 0xCE, 0x43, 0x37, 0xD7, 0x85, 0x72,
	0x4A, 0xA0, 0xDD, 0xA5, 0x1B, 0xC3, 0xBA, 0x57, 0xE3, 0x6A, 0x09, 0x53, 0xAC, 0x3C, 0xC6, 0x4F,
	0xE0, 0x56, 0x5F, 0x52, 0x83, 0x45, 0x0D, 0xF7, 0x9B, 0x92, 0x2E, 0x57, 0xBE, 0xA1, 0x8F, 0x2B,
	0x90, 0x59, 0x79, 0x08, 0xD8, 0xE0, 0x9C, 0x01, 0x6D, 0xF3, 0xCC, 0x0A, 0x7C, 0xFA, 0xF5, 0x26,
	0xAD, 0xF9, 0x45, 0xEC, 0xDA, 0x77, 0x31, 0xDC, 0x89, 0x3D, 0x73, 0x77, 0xC1, 0xFE, 0xEC, 0x06,
	0x84, 0x26, 0xF1, 0xCB, 0xAC, 0xD9, 0x05, 0x1B, 0x51, 0x7A, 0x40, 0x21, 0x82, 0x1F, 0xEC, 0x6C,
	0xF8, 0x87, 0xA7, 0x6C, 0x7F, 0xB2, 0x2C, 0xD6, 0x35, 0x9E, 0x36, 0xAA, 0xEB, 0x10, 0x92, 0xEB,
	0x30, 0x77, 0x73, 0x10, 0x45, 0x8D, 0x66, 0x6C, 0xD0, 0x4B, 0x51, 0xBA, 0x01, 0x06, 0xC8, 0x50,
	0x80, 0xC5, 0x8A, 0x16, 0xC7, 0x97, 0xCC, 0x8E, 0x5A, 0x98, 0x26, 0x24, 0x6F, 0xE9, 0xEA, 0x0F,
	0x53, 0x27, 0x04, 0x3B, 0x62, 0x61, 0xD8, 0x67, 0x1F, 0x70, 0x51, 0xED, 0x31, 0x8C, 0xE0, 0x59,
	0xB6, 0xAE, 0x4C, 0x60, 0xE2, 0xFB, 0xF9, 0x78, 0xA0, 0x1A, 0xDB, 0x14, 0x1F, 0x8A, 0x7C, 0xDE,
	0x39, 0x74, 0x72, 0x3B, 0xAE, 0x76, 0xE5, 0x82, 0x50, 0xA9, 0xCE, 0xD0, 0x8E, 0x2F, 0x5F, 0x04,
	0x9E, 0x16, 0x06, 0x0D, 0xE6, 0xB7, 0x3E, 0x2A, 0x95, 0x3C, 0x06, 0xC9, 0xBE, 0x3D, 0x1B, 0x68,
	0x62, 0x9E, 0x73, 0x7E, 0x3A, 0xD4, 0x9F, 0xBC, 0x51, 0xAC, 0xC1, 0xE1, 0x84, 0x08, 0x5D, 0xD8,
	0x59, 0x07, 0xEB, 0x1E, 0x6C, 0xB1, 0xFC, 0x42, 0x23, 0x47, 0xF7, 0xF5, 0xBB, 0x19, 0x04, 0x6E,
	0xCC, 0x29, 0x3E, 0xC6, 0xB3, 0x1C, 0xA1, 0xAE, 0xA3, 0xCB, 0x5E, 0xC5, 0x11, 0x17, 0xAC, 0xC0,
	0x43, 0x30, 0xA2, 0x03, 0xC0, 0xCF, 0x33, 0x80, 0x0E, 0xA9, 0xC1, 0xAC, 0x5F, 0xF9, 0x12, 0x7D,
	0x24, 0xD4, 0x6E, 0x39, 0x3A, 0xF9, 0xFF, 0x64, 0x7C, 0x5D, 0x7D, 0xFB, 0xED, 0xDF, 0x1A, 0x6B,
	0x81, 0x36, 0x7F, 0x1D, 0x34, 0xD3, 0xEB, 0x01, 0xF0, 0xAE, 0xFD, 0xC7, 0xC5, 0x19, 0x72, 0xBA,
	0x4D, 0x4F, 0x38, 0xB6, 0x17, 0x2E, 0x87, 0x97, 0x89, 0x79, 0x03, 0x4C, 0x4A, 0x35, 0x13, 0x43,
	0xF5, 0xF4, 0xB2, 0xE1, 0x5C, 0x01, 0x60, 0xC7, 0xC8, 0x8B, 0x27, 0x21, 0x73, 0xBD, 0xB9, 0x1F,
	0xF4, 0x83, 0x2F, 0xC6, 0x67, 0x1A, 0x51, 0x3F, 0xEA, 0x31, 0xC9, 0x27, 0x69, 0xF6, 0x17, 0x6F,
	0xE6, 0xED, 0x3A, 0xB1, 0x55, 0x6D, 0xD8, 0x7E, 0xA0, 0x19, 0x2A, 0x86, 0x4A, 0x08, 0x04, 0x64,
	0x97, 0x80, 0xFF, 0xFE, 0x80, 0x00, 0xB2, 0x29, 0x6C, 0x6C, 0xE2, 0xAA, 0xD2, 0xD0, 0x69, 0x0D,
	0xA8, 0x0E, 0x77, 0xD9, 0xEE, 0x13, 0xE7, 0x47, 0xD2, 0xC3, 0x1F, 0x3D, 0x52, 0x9D, 0x38, 0x3E,
	0x93, 0x06, 0x82, 0x51, 0x09, 0x85, 0x92, 0x29, 0x33, 0x93, 0xAF, 0x86, 0x94, 0x30, 0x05, 0x89,
	0x2D, 0x12, 0x57, 0xC1, 0x20, 0x34, 0xC5, 0x55, 0x1C, 0x12, 0x0D, 0x14, 0x15, 0x75, 0x92, 0x7D,
	0x4B, 0x95, 0x2E, 0x62, 0x68, 0x90, 0x90, 0xDA, 0x74, 0x97, 0x3D, 0x22, 0x97, 0xCA, 0x22, 0xF6,
	0xA6, 0xC0, 0xF5, 0xFE, 0x45, 0xAF, 0x15, 0x75, 0x26, 0x86, 0x02, 0x11, 0x39, 0xEC, 0x3B, 0x38,
	0xD7, 0x65, 0x51, 0x95, 0xA3, 0x24, 0x0C, 0x89, 0xB1, 0xD6, 0x46, 0x84, 0xA1, 0x7B, 0x78, 0xD8,
	0xDD, 0x4C, 0x7F, 0x34, 0xE5, 0xAF, 0xE6, 0x4D, 0xE5, 0xF0, 0x05, 0xEA, 0x32, 0xCC, 0xB8, 0x1A,
	0x82, 0x91, 0x93, 0xF6, 0x4B, 0xAF, 0x6D, 0xAE, 0xF1, 0xE4, 0x16, 0x87, 0x3F, 0xA8, 0xDE, 0xE2,
	0xD6, 0xCA, 0xE8, 0x83, 0xD6, 0xCA, 0x9F, 0xC2, 0xC5, 0xEE, 0xE5, 0x68, 0x29, 0xF5, 0xB0, 0x55,
	0x15, 0x21, 0xF0, 0xE0, 0x26, 0x0C, 0x3B, 0xA3, 0x59, 0x77, 0x6F, 0xB2, 0x89, 0xC4, 0x74, 0xAA,
	0xF1, 0x2F, 0x5C, 0x68, 0x23, 0x41, 0x54, 0x0D, 0x4A, 0x38, 0x5D, 0x87, 0x3F, 0x46, 0x9D, 0x53,
	0xFD, 0x83, 0x55, 0x9D, 0xA3, 0x0D, 0xB4, 0xA4, 0x19, 0xA0, 0x8F, 0x20, 0x17, 0x7C, 0xC3, 0x59,
	0xE7, 0xE2, 0x5D, 0x2A, 0xD7, 0xCC, 0x88, 0x29, 0xB9, 0x38, 0x13, 0xCC, 0xD1, 0x7E, 0xCE, 0x94,
	0x43, 0xB2, 0x2C, 0x6A, 0xB0, 0x5D, 0xDC, 0xFE, 0x12, 0x28, 0x15, 0x51, 0x0C, 0xD2, 0xA5, 0xB2,
	0xF9, 0x87, 0x8E, 0x91, 0xD9, 0xA5, 0x3C, 0xD6, 0x43, 0xD6, 0xB2, 0x98, 0x95, 0x49, 0xDB, 0x41,
	0x1F, 0xEE, 0x79, 0x28, 0x26, 0x19, 0xFF, 0x51, 0xC8, 0x11, 0xCA, 0x82, 0x05, 0x61, 0xF7, 0x64,
	0xF6, 0x24, 0x18, 0x42, 0xCA, 0x82, 0xE0, 0xA9, 0xDE, 0x58, 0xAF, 0xFC, 0x7A, 0x5E, 0x84, 0xEE,
	0xC9, 0xB6, 0xEC, 0x11, 0x55, 0xDF, 0xC1, 0x6F, 0x6C, 0x17, 0xD5, 0xE4, 0xA8, 0xF1, 0xCD, 0xE0,
	0x84, 0xB4, 0x25, 0x58, 0xAD, 0xD3, 0xF7, 0x5E, 0xB3, 0x36, 0xCE, 0xE0, 0xFA, 0x7D, 0xEF, 0x03,
	0x62, 0x46, 0x8A, 0xA0, 0x7D, 0xBD, 0xA1, 0xA7, 0xF2, 0x0D, 0xEF, 0xC2, 0x55, 0xA2, 0xB4, 0x2E,
	0x12, 0x7F, 0xE2, 0x62, 0x7E, 0x1A, 0x95, 0x47, 0x7C, 0x49, 0x45, 0x46, 0x88, 0xE7, 0x6A, 0xC7,
	0x7C, 0x1E, 0x87, 0x0E, 0x9E, 0x55, 0x6E, 0x58, 0x31, 0xA8, 0x33, 0xA2, 0xC6, 0x1C, 0x29, 0x28,
	0xB0, 0xE4, 0x3E, 0x80, 0x22, 0xB1, 0x74, 0x4F, 0x83, 0xC7, 0x7D, 0x89, 0x4C, 0xED, 0x1A, 0x37,
	0x66, 0xCB, 0x92, 0xAA, 0xBC, 0x36, 0x0E, 0x2E, 0xAE, 0x81, 0x1F, 0x49, 0x8D, 0xC7, 0xC1, 0x0E,
	0x18, 0xA2, 0x64, 0xE9, 0x18, 0x05, 0xE0, 0x71, 0xF6, 0x94, 0x8A, 0x41, 0x86, 0x12, 0xE3, 0xDB,
	0x71, 0xDB, 0x70, 0xBA, 0xB5, 0x91, 0xF0, 0xED, 0xAA, 0x82, 0xFC, 0x99, 0x51, 0x8A, 0x49, 0xCF,
	0x36, 0xA9, 0x58, 0x8A, 0xCC, 0xB4, 0xE7, 0x5D, 0x9E, 0xB9, 0xFE, 0xEB, 0xE1, 0xC7, 0x08, 0x3B,
	0xB0, 0xDB, 0x7D, 0x2C, 0x03, 0x6F, 0x21, 0x1E, 0x5A, 0x12, 0x56, 0x9F, 0x97, 0xC5, 0x43, 0x1B,
	0xBC, 0xEB, 0x26, 0x0C, 0xFC, 0xEA, 0xA4, 0xAA, 0x91, 0x0C, 0xF7, 0xB7, 0xDC, 0x30, 0x5E, 0x65,
	0x0D, 0xCB, 0x37, 0xB9, 0x07, 0xD0, 0x4F, 0x70, 0x07, 0x15, 0x29, 0x6F, 0x1B, 0xF7, 0x7F, 0x8A,
	0xD3, 0xBE, 0x20, 0x81, 0x94, 0xF2, 0xF2, 0x2D, 0xA2, 0x44, 0x9C, 0x02, 0xCE, 0xAF, 0x95, 0xA5,
	0xB7, 0x60, 0x6A, 0x66, 0x8F, 0x99, 0x14, 0x14, 0x3C, 0xC3, 0x21, 0xA5, 0x57, 0x50, 0x7B, 0xDD,
	0x09, 0x02, 0x4F, 0xFE, 0x42, 0x71, 0xD7, 0xC5, 0x1E, 0xFD, 0x70, 0x64, 0x7E, 0xB9, 0x65, 0xB4,
	0xB1, 0xA9, 0xC6, 0x7E, 0x3B, 0xA8, 0x33, 0x9A, 0x57, 0x82, 0x05, 0x7B, 0x67, 0xF2, 0x6C, 0xCF,
	0xBC, 0x7D, 0x4D, 0x46, 0x9E, 0x4A, 0x40, 0xA5, 0xF2, 0x69, 0x7C, 0x01, 0x87, 0xAA, 0xBC, 0xA9,
	0xEC, 0xAA, 0x99, 0xB8, 0xD6, 0xDF, 0xFF, 0xEF, 0xAF, 0x24, 0x08, 0x41, 0xDE, 0x2A, 0x25, 0xBA,
	0x5A, 0x0D, 0x11, 0x10, 0xAA, 0xA0, 0x60, 0x0C, 0xFF, 0x2A, 0xBE, 0x8E, 0x2A, 0x27, 0x1F, 0x67,
	0xD1, 0x69, 0x72, 0x68, 0xD8, 0x87, 0xC9, 0xAF, 0xD7, 0x52, 0x52, 0x9F, 0xCE, 0x86, 0x09, 0xDF,
	0xD0, 0x0C, 0x3A, 0x6A, 0x0F, 0x98, 0x83, 0x92, 0x0C, 0x46, 0x54, 0x85, 0x8E, 0x49, 0x21, 0x40,
	0x0F, 0x4C, 0x61, 0xCF, 0x6D, 0x78, 0xDD, 0x32, 0xC9, 0x1E, 0x89, 0x23, 0xE5, 0x63, 0x80, 0xF2,
	0xAD, 0x82, 0x17, 0x09, 0x78, 0x95, 0xDC, 0x67, 0x72, 0x77, 0x9B, 0x41, 0x59, 0x8F, 0xF3, 0xF0,
	0x93, 0x00, 0x7C, 0x53, 0x86, 0x3E, 0x7C, 0xF7, 0xC3, 0xE1, 0xEC, 0xC4, 0xF4, 0x81, 0x2B, 0x43,
	0x3F, 0x9A, 0xA6, 0xBA, 0xFD, 0xD7, 0xEA, 0xF9, 0xE5, 0x10, 0x29, 0xDE, 0x6A, 0x5A, 0x13, 0xFE,
	0xC0, 0x89, 0x1B, 0xBB, 0x70, 0xEF, 0x59, 0xBB, 0xB1, 0xFB, 0xCA, 0x4D, 0x8B, 0x84, 0x55, 0xED,
	0x53, 0x63, 0x39, 0xBF, 0xF1, 0x81, 0x4B, 0x43, 0xCA, 0x3F, 0x7F, 0xA3, 0xB6, 0xCE, 0xD1, 0xC7,
	0xF7, 0xC7, 0x70, 0xA0, 0xD2, 0x27, 0xB9, 0xA1, 0xA2, 0x86, 0x1C, 0xBB, 0xC3, 0xCB, 0x39, 0x12,
	0x7C, 0xE7, 0x54, 0xC7, 0x77, 0x85, 0x42, 0x87, 0xFB, 0x0C, 0xCA, 0x29, 0x5F, 0x01, 0xCB, 0xFE,
	0x9C, 0xD2, 0x7B, 0xD1, 0x61, 0xB5, 0x8E, 0x0E, 0x79, 0x54, 0xFE, 0x9A, 0xC2, 0xDB, 0xF5, 0x4D,
	0x94, 0x46, 0x92, 0x28, 0x97, 0x0F, 0x6E, 0x28, 0xDE, 0x4C, 0xBF, 0xDF, 0x77, 0xC8, 0xF1, 0x4B,
	0xDF, 0x71, 0x98, 0xEF, 0xE8, 0x17, 0xD6, 0xCD, 0xEC, 0xBF, 0x37, 0x26, 0xCB, 0x10, 0x87, 0x7E,
	0x97, 0x9A, 0xAE, 0xAB, 0x82, 0x42, 0xE5, 0x82, 0xA3, 0x89, 0xDB, 0x30, 0x63, 0x30, 0x5E, 0x0E,
	0xD7, 0xA6, 0x3F, 0x6A, 0xF7, 0x61, 0xBE, 0x81, 0x0F, 0x43, 0xBA, 0x10, 0x32, 0x40, 0xFB, 0xCE,
	0xA1, 0xA9, 0xBD, 0x2B, 0x20, 0xB5, 0x65, 0xF8, 0xB6, 0x82, 0x55, 0x1D, 0x22, 0x6F, 0x3F, 0xF2,
	0x70, 0x41, 0xB6, 0xC9, 0x48, 0xD4, 0x94, 0x8F, 0x7D, 0x29, 0x20, 0x06, 0xDB, 0x87, 0xD2, 0xB9,
	0xCD, 0x92, 0x57, 0xEE, 0x11, 0xE4, 0x62, 0x25, 0x17, 0x1A, 0xE8, 0x47, 0x2C, 0x4E, 0xCE, 0x02,
	0xBF, 0x6C, 0x90, 0xE2, 0x1A, 0x88, 0x7B, 0xEE, 0xD9, 0x53, 0xB9, 0x9C, 0x4A, 0x65, 0x6B, 0xE0,
	0x71, 0x7E, 0x45, 0xCD, 0xC4, 0xAB, 0x66, 0xF6, 0xB7, 0x7D, 0x63, 0x88, 0x06, 0xE9, 0x25, 0x8D,
	0xFE, 0x2C, 0x3C, 0x2C, 0x6E, 0x13, 0xA5, 0x09, 0x17, 0xEE, 0x0E, 0x1A, 0xFA, 0xF9, 0xAF, 0xD6,
	0x34, 0xCA, 0x75, 0x85, 0xA4, 0xD0, 0x93, 0x5F, 0x77, 0x5B, 0x83, 0x9E, 0xDE, 0x9B, 0x13, 0x01,
	0xD2, 0x42, 0xF3, 0x8F, 0x3A, 0xE0, 0x39, 0xDB, 0x0F, 0x37, 0x27, 0x42, 0x08, 0x42, 0xE3, 0x26,
	0xE4, 0xCD, 0x63, 0xD1, 0x3F, 0x62, 0x1C, 0xE5, 0xF2, 0x29, 0x1C, 0x75, 0xE6, 0x84, 0x96, 0x48,
	0x6E, 0x59, 0x84, 0x2F, 0xE3, 0x98, 0xED, 0x2E, 0x8F, 0x79, 0x23, 0xD8, 0x44, 0x1E, 0x27, 0x08,
	0xC1, 0x86, 0x7A, 0xD8, 0xAD, 0x8D, 0x07, 0x0C, 0x65, 0xB7, 0xAB, 0x93, 0x91, 0x9F, 0x3F, 0xB7,
	0xE0, 0x82, 0x67, 0xD4, 0x69, 0x39, 0xA8, 0xAA, 0x1E, 0x4D, 0x3B, 0xF1, 0x06, 0x6E, 0x01, 0x47,
	0x66, 0xB1, 0xFC, 0x5A, 0x89, 0x63, 0x42, 0xD6, 0xE2, 0x85, 0xE1, 0x76, 0x78, 0x4B, 0x4B, 0x5D,
	0xEA, 0xD5, 0x45, 0x9E, 0x0F, 0xAA, 0x8D, 0x96, 0x1A, 0xCD, 0xE6, 0xE6, 0xCE, 0x99, 0x68, 0x01,
	0xF7, 0x78, 0x28, 0x0A, 0x3A, 0x4C, 0xB2, 0x0D, 0x34, 0x79, 0x9B, 0xBD, 0xBB, 0x55, 0xF7, 0x41,
	0x11, 0x71, 0xE1, 0x15, 0xFA, 0xE2, 0x1E, 0x74, 0xCB, 0xCF, 0xF7, 0x7A, 0x93, 0x1E, 0x2A, 0xB5,
	0x12, 0x1F, 0x43, 0x2B, 0x8E, 0x71, 0x99, 0x44, 0xA6, 0x68, 0xF7, 0x73, 0x05, 0xE6, 0xF5, 0x66,
	0x64, 0x33, 0x67, 0xCA, 0x51, 0x2F, 0xF3, 0xC2, 0xAB, 0xFB, 0x33, 0x92, 0xB1, 0x21, 0x4C, 0x74,
	0x61, 0xB8, 0x72, 0x0A, 0x34, 0x23, 0xCB, 0x9F, 0xA9, 0xE5, 0xB3, 0x2F, 0x07, 0xF9, 0x88, 0x3A,
	0xB8, 0x4C, 0xE6, 0x23, 0x7E, 0x98, 0x7B, 0x84, 0xC9, 0xC8, 0x62, 0xA5, 0x4B, 0x57, 0x2A, 0x78,
	0xEF, 0x43, 0x0E, 0x7E, 0x42, 0xF1, 0x51, 0xDD, 0xF3, 0xF2, 0xC9, 0xC5, 0x95, 0x42, 0xEC, 0x62,
	0x0C, 0x2C, 0x56, 0x0B, 0x20, 0x57, 0xBE, 0x4E, 0x2E, 0xE2, 0xE7, 0x99, 0x68, 0xCA, 0xF0, 0xCA,
	0xB4, 0xCF, 0x8F, 0x6C, 0x1F, 0xFA, 0x0D, 0x97, 0xFE, 0x10, 0x9A, 0x43, 0x1A, 0xE0, 0xA0, 0x1A,
	0x32, 0x48, 0xC8, 0xF4, 0x68, 0x3E, 0x7E, 0xF9, 0x82, 0x7C, 0xED, 0x76, 0x21, 0x97, 0x3D, 0x56,
	0x5A, 0x78, 0x2B, 0xF6, 0x66, 0x6B, 0xC2, 0x7E, 0xE8, 0xAC, 0x0D, 0x44, 0xF2, 0xEE, 0x32, 0x77,
	0xBD, 0x8E, 0x9B, 0x7C, 0x4F, 0xCC, 0xD1, 0x3F, 0xF7, 0x9B, 0x13, 0x7D, 0x07, 0xAC, 0xBC, 0x2C,
	0xDD, 0xB9, 0xD6, 0x38, 0x1F, 0x2A, 0xC7, 0xE2, 0x08, 0x79, 0x49, 0xA3, 0x6A, 0x90, 0x8F, 0x8F,
	0xA2, 0xB5, 0x5C, 0xF7, 0x14, 0x88, 0x88, 0x2F, 0x19, 0x52, 0x91, 0xEF, 0xEE, 0x6C, 0x37, 0x1F,
	0x2C, 0x95, 0xCC, 0xBA, 0xEC, 0xB2, 0xD2, 0xE8, 0x2A, 0x50, 0xB4, 0x64, 0x5A, 0xD1, 0xD1, 0xD0,
	0xE3, 0x28, 0x1A, 0xF8, 0x94, 0x88, 0x92, 0xB6, 0x17, 0xAF, 0x8B, 0xD3, 0x6B, 0xED, 0xAB, 0x06,
	0xD8, 0x0C, 0xA0, 0x7E, 0xBA, 0x4A, 0xAD, 0x78, 0xC4, 0xC4, 0xA7, 0x82, 0x5E, 0xB2, 0xA4, 0x47,
	0x85, 0x04, 0x5F, 0xE8, 0x87, 0xF8, 0x1B, 0x4B, 0xBF, 0x17, 0x4A, 0x9A, 0x76, 0xC5, 0x89, 0x47,
	0x1C, 0x03, 0x2F, 0x17, 0xEA, 0xB1, 0x22, 0x7F, 0x9D, 0xDA, 0xCE, 0x4C, 0x04, 0x36, 0x46, 0xFF,
	0xA3, 0x12, 0x2C, 0x55, 0x7D, 0x10, 0x1A, 0x9A, 0x71, 0x68, 0x52, 0xFA, 0x3D, 0x87, 0x7A, 0xEA,
	0x18, 0xAC, 0x53, 0xA1, 0x24, 0x36, 0x69, 0x64, 0x71, 0x45, 0xCD, 0x93, 0x0D, 0xBB, 0x3E, 0xE1,
	0x8F, 0xBD, 0xD8, 0x0A, 0xC5, 0x05, 0x69, 0xE6, 0x3C, 0x8F, 0x13, 0x0A, 0x94, 0x7B, 0x2D, 0x64,
	0xE1, 0xC2, 0x31, 0x96, 0x89, 0xF6, 0x8F, 0xB4, 0x2C, 0xD2, 0xA3, 0x70, 0xE6, 0xD1, 0x40, 0x59,
	0xE5, 0xAE, 0x01, 0x27, 0x16, 0x8E, 0x34, 0xCF, 0x42, 0x64, 0x46, 0xB4, 0x3A, 0xC2, 0x80, 0xFB,
	0x97, 0x0A, 0x63, 0xCB, 0xCD, 0xB0, 0x70, 0x5B, 0xE1, 0x38, 0xEB, 0x74, 0x69, 0xD0, 0x86, 0xF4,
	0xF3, 0xBC, 0xEC, 0x92, 0x92, 0x59, 0x0F, 0x56, 0xAF, 0x8D, 0x9B, 0x7C, 0x78, 0xB1, 0xB5, 0xE5,
	0x5B, 0xC8, 0x7F, 0x51, 0x33, 0xB0, 0x6E, 0xCD, 0x75, 0x55, 0x49, 0x64, 0xB6, 0x31, 0x9A, 0xEA,
	0x17, 0xFF, 0x9F, 0x1D, 0x7D, 0xB7, 0xA7, 0x16, 0x48, 0x49, 0xFB, 0x2E, 0x55, 0xB4, 0x2E, 0x1C,
	0x57, 0x2B, 0x69, 0xEE, 0x87, 0xD1, 0x4B, 0x28, 0x00, 0xDA, 0xB9, 0xDA, 0x01, 0xF9, 0xFB, 0x5A,
	0x81, 0x1A, 0x11, 0xEE, 0xB1, 0x36, 0x90, 0xD0, 0x8E, 0xC5, 0xF2, 0x9C, 0xCF, 0xA2, 0xC5, 0xA5,
	0x70, 0xC8, 0x20, 0x51, 0x6D, 0xBE, 0x5D, 0x76, 0xE0, 0xE7, 0x6F, 0x48, 0x91, 0x04, 0x2C, 0xA9,
	0xAB, 0x4C, 0xB3, 0xA0, 0xD4, 0xF2, 0x03, 0x99, 0x8A, 0xA7, 0x4F, 0x87, 0x98, 0xEE, 0x2C, 0x92,
	0x28, 0x07, 0x14, 0xA4, 0x96, 0xE5, 0x9F, 0xDF, 0x08, 0x33, 0x23, 0xC2, 0xEC, 0xFB, 0xA3, 0x6C,
	0x36, 0x3D, 0x94, 0x8F, 0x4E, 0x80, 0x3D, 0x03, 0x41, 0x59, 0xC0, 0x5B, 0xE8, 0x27, 0x8D, 0x9F,
	0xE4, 0xBA, 0x3F, 0x15, 0x11, 0x0B, 0x9D, 0x9E, 0x11, 0xE8, 0xDE, 0x2D, 0x9C, 0xD8, 0xF3, 0x73,
	0x68, 0x38, 0xE5, 0x49, 0x8E, 0x58, 0x71, 0xF6, 0x25, 0x29, 0x86, 0x93, 0xD8, 0x2A, 0xC9, 0xE6,
	0x9C, 0x2E, 0xFC, 0xD1, 0x0E, 0xEF, 0x3F, 0x74, 0x81, 0x24, 0x84, 0x24, 0xA9, 0x11, 0xCA, 0x8C,
	0xBE, 0x14, 0x65, 0xCD, 0xF5, 0xAA, 0xFB, 0x8B, 0x77, 0x7A, 0x80, 0xA8, 0x99, 0x68, 0x60, 0x8E,
	0xA6, 0x58, 0x0B, 0x1A, 0x1E, 0xBC, 0xD8, 0xCC, 0xCC, 0xD0, 0x91, 0x4C, 0x43, 0xFC, 0xE9, 0x44,
	0xD4, 0x33, 0xC3, 0x50, 0x63, 0xDC, 0x72, 0xCE, 0x9B, 0x69, 0x2D, 0x87, 0xA3, 0xBE, 0x4C, 0xFF,
	0x10, 0x6A, 0xC8, 0x68, 0xBC, 0x8E, 0x58, 0x5C, 0x2D, 0x08, 0xA3, 0x61, 0xD1, 0x23, 0x17, 0x14,
	0xAD, 0x24, 0x6C, 0x36, 0xDB, 0x4E, 0xCF, 0xF3, 0x59, 0x05, 0xDA, 0x24, 0xA1, 0x90, 0x7F, 0x29,
	0xC2, 0xC7, 0xD5, 0x6B, 0x1A, 0x35, 0xA2, 0xA7, 0xB1, 0x27, 0x0C, 0x3F, 0xC5, 0x1D, 0x12, 0x11,
	0xE7, 0xAE, 0x79, 0xB4, 0xEE, 0xD1, 0x5B, 0xF9, 0xB1, 0xEC, 0xB8, 0x3C, 0x00, 0x43, 0x83, 0x63,
	0xF6, 0xA5, 0x98, 0x4A, 0xF9, 0xF3, 0x32, 0xC9, 0xAB, 0xD2, 0xFF, 0x9E, 0xE3, 0xE4, 0x89, 0x22,
	0x61, 0x5B, 0xAE, 0xEA, 0x95, 0x50, 0xC5, 0x7D, 0x8C, 0x6D, 0x48, 0xFB, 0xBE, 0x50, 0xF9, 0x85,
	0xAD, 0xEB, 0x06, 0xA5, 0xCE, 0x0E, 0x71, 0x7F, 0x3A, 0xB7, 0xCC, 0x06, 0x2B, 0x9E, 0x90, 0x60,
	0xAD, 0xA2, 0x6C, 0x74, 0x92, 0xF6, 0x9C, 0xC6, 0x38, 0x1A, 0xD3, 0x45, 0x4E, 0xC2, 0x5D, 0x3F,
	0x42, 0x7B, 0x77, 0xA7, 0x63, 0x69, 0x2C, 0x9F, 0x85, 0xFF, 0x56, 0x1E, 0x0E, 0x9F, 0xB0, 0xDA,
	0x5A, 0x1A, 0x95, 0x5A, 0x11, 0x0C, 0xC1, 0x82, 0x54, 0xF9, 0x8A, 0xE2, 0x8E, 0x11, 0x94, 0x9F,
	0x2F, 0x62, 0x35, 0x2A, 0x3D, 0x7F, 0x38, 0x40, 0xA4, 0xED, 0x97, 0x95, 0x93, 0xC2, 0x98, 0xB0,
	0xEA, 0xA7, 0x80, 0x34, 0xBC, 0x6B, 0xD6, 0xC2, 0xC3, 0xF3, 0xB7, 0x87, 0xF6, 0x3F, 0x3E, 0xDA,
	0xD8, 0x9E, 0x1D, 0x10, 0x8C, 0x5C, 0xAC, 0xE5, 0xCA, 0x72, 0x6D, 0x92, 0xF5, 0xEC, 0x84, 0x31,
	0x12, 0x28, 0x3D, 0xA8, 0x30, 0xFE, 0x41, 0xD0, 0x20, 0x2B, 0xE9, 0xE9, 0x34, 0xE2, 0xBA, 0x8D,
	0xDB, 0xAA, 0x1E, 0x7E, 0x38, 0x7D, 0x32, 0x27, 0xB3, 0x83, 0x97, 0x9A, 0x1C, 0x6F, 0x45, 0xDC,
	0x74, 0x20, 0xBE, 0x8F, 0x7D, 0xC0, 0xDA, 0x78, 0x06, 0xBC, 0x2F, 0xF9, 0x44, 0x4B, 0xDA, 0xA2,
	0xAE, 0x09, 0x2C, 0x8E, 0xD2, 0xD4, 0x8E, 0xC4, 0x05, 0x26, 0xAB, 0xBB, 0xD9, 0x99, 0x7E, 0x48,
	0x6A, 0xB5, 0x97, 0x2A, 0x5A, 0xA1, 0xAF, 0x92, 0x03, 0xEF, 0x05, 0xC0, 0x7A, 0x07, 0x46, 0x12,
	0x0F, 0x8D, 0xCA, 0x62, 0x78, 0x69, 0x98, 0x00, 0x08, 0x2E, 0xF3, 0x55, 0xAA, 0x56, 0xEA, 0xEC,
	0xC6, 0xB6, 0x55, 0x60, 0x27, 0x35, 0x9A, 0x6F, 0xE2, 0xE1, 0x49, 0x6C, 0x83, 0x5B, 0x0F, 0x08,
	0x1E, 0x1A, 0x1E, 0x94, 0x81, 0xFB, 0xB5, 0x26, 0xD5, 0x09, 0x9C, 0xD7, 0xC4, 0xA2, 0x38, 0x47,
	0x2E, 0x87, 0xEB, 0xE7, 0xB0, 0x36, 0x7D, 0xFD, 0xE4, 0x95, 0x4A, 0xAD, 0xD5, 0xE2, 0x39, 0xCB,
	0xEB, 0x49, 0x2B, 0xBF, 0xB6, 0x5C, 0x84, 0x07, 0x8E, 0x12, 0x70, 0x7F, 0xBE, 0xFB, 0xDD, 0x9B,
	0x28, 0x18, 0x10, 0x6C, 0x12, 0x2F, 0x10, 0x9D, 0xB7, 0x39, 0x2B, 0x01, 0x54, 0xAC, 0x60, 0x4E,
	0xF7, 0x4D, 0x2F, 0x82, 0x0F, 0xBC, 0x20, 0xD9, 0xB7, 0x67, 0xBF, 0x41, 0x44, 0x27, 0xA1, 0xBC,
	0xA5, 0x81, 0x7C, 0x58, 0xC6, 0x9F, 0x79, 0x1F, 0x25, 0x6F, 0x46, 0x65, 0x29, 0xA6, 0x18, 0x0C,
	0xD6, 0xB5, 0x5F, 0x74, 0x47, 0xD0, 0x44, 0xD2, 0x97, 0x8B, 0x3C, 0x34, 0x96, 0xED, 0x57, 0x97,
	0xE8, 0xD8, 0x4B, 0xE9, 0x42, 0x09, 0xBE, 0xE2, 0xB2, 0x6C, 0x5A, 0xE9, 0xEA, 0x8A, 0xB2, 0x14,
	0x71, 0x7A, 0xC8, 0x6C, 0xE2, 0xAD, 0xEF, 0x04, 0x3D, 0x1A, 0x42, 0x16, 0xD8, 0x55, 0xE7, 0xA2,
	0xDE, 0xDB, 0xA5, 0x4A, 0x96, 0xCD, 0xE0, 0x6F, 0x64, 0x23, 0x5C, 0xCB, 0x3C, 0x6D, 0x80, 0x62,
	0xB7, 0xA4, 0x14, 0x2D, 0x10, 0x41, 0xF1, 0x93, 0x09, 0xAF, 0xCF, 0x1A, 0x79, 0x28, 0xB9, 0x76,
	0x0E, 0xAD, 0x3C, 0xE9, 0x5D, 0x0A, 0x2D, 0x8C, 0xA6, 0x18, 0xEA, 0xD1, 0xF3, 0x7B, 0x7D, 0x12,
	0x87, 0x34, 0x40, 0xCB, 0x56, 0xCB, 0xA1, 0x24, 0xF0, 0x09, 0x65, 0x39, 0x4F, 0x6D, 0x41, 0x50,
	0xD5, 0x41, 0x0E, 0x1B, 0x5E, 0x93, 0x39, 0xDF, 0x92, 0x86, 0x11, 0x7D, 0xD1, 0x30, 0x27, 0xFE,
	0xA9, 0x42, 0xA4, 0x07, 0xCA, 0x9D, 0x6E, 0xDD, 0x75, 0xBA, 0x49, 0xA5, 0x04, 0xFC, 0xF4, 0xFC,
	0x35, 0x22, 0x46, 0xC7, 0x50, 0x03, 0x28, 0xD0, 0xBE, 0x69, 0xCF, 0xD1, 0xD7, 0xE1, 0x17, 0xC1,
	0xE7, 0xC1, 0xFE, 0x24, 0xAB, 0x0C, 0x74, 0x6E, 0x43, 0x58, 0x8A, 0xD0, 0x05, 0xB2, 0x65, 0xE1,
	0xA3, 0xFE, 0x45, 0x59, 0xBC, 0x39, 0xA5, 0x92, 0xB6, 0x82, 0x09, 0x1F, 0xB2, 0x6A, 0x22, 0x1C,
	0xEC, 0x9C, 0x86, 0x3D, 0xA0, 0xEB, 0x51, 0x4F, 0x3D, 0x62, 0xD2, 0x50, 0x14, 0xD9, 0xF5, 0x3D,
	0xFD, 0x2B, 0x82, 0x3E, 0x4F, 0x9D, 0x3C, 0xCD, 0xF3, 0x33, 0x81, 0xC7, 0xD0, 0xF5, 0x9C, 0xFF,
	0x68, 0x46, 0x07, 0x9C, 0xB3, 0x38, 0x3C, 0xC8, 0x91, 0xB4, 0xFA, 0x9A, 0xD0, 0xDA, 0xD5, 0x2F,
	0x4C, 0x25, 0xED, 0xDE, 0xF0, 0xFD, 0xDD, 0x2D, 0x5D, 0xB7, 0x44, 0xA3, 0x98, 0x92, 0xAA, 0xA9,
	0x01, 0xDA, 0x1F, 0x96, 0xF7, 0xE7, 0x9F, 0x85, 0x7A, 0xB8, 0xF2, 0x97, 0xB2, 0x5B, 0xE3, 0x27,
	0x75, 0x4E, 0x18, 0xF9, 0xF7, 0x69, 0x90, 0xEC, 0x30, 0xE9, 0x4C, 0xB6, 0x8A, 0x1F, 0x81, 0xF8,
	0xE3, 0x52, 0x93, 0xF3, 0xC1, 0x78, 0x15, 0x32, 0x5D, 0x9F, 0xD3, 0x22, 0x3D, 0x02, 0x7C, 0x68,
	0x68, 0xAB, 0x1C, 0x3F, 0x8C, 0xF7, 0x38, 0x2B, 0x0C, 0x47, 0xF9, 0x04, 0xAF, 0xA3, 0xD5, 0xA1,
	0x16, 0xA8, 0xC5, 0x27, 0xD5, 0x10, 0x28, 0x94, 0x8F, 0x37, 0x55, 0x4C, 0x43, 0x50, 0x37, 0x5E,
	0xD3, 0xF8, 0xF3, 0xD8, 0xB0, 0x67, 0x07, 0x66, 0x7F, 0x20, 0x59, 0x0A, 0xD6, 0xD0, 0x65, 0x82,
	0x1D, 0xB1, 0xF6, 0xA4, 0x16, 0x2E, 0x51, 0x07, 0xC9, 0x9D, 0xFD, 0xCD, 0xDD, 0x67, 0xA1, 0x74,
	0x37, 0x4C, 0x39, 0x97, 0x84, 0x5F, 0x62, 0x85, 0xFD, 0x7C, 0xBE, 0xDA, 0x50, 0x1F, 0xF5, 0x01,
	0xC8, 0xA0, 0xE5, 0x90, 0xD4, 0xB0, 0x77, 0x41, 0xAD, 0x90, 0x17, 0xBC, 0x8B, 0x3C, 0x1E, 0x3E,
	0x51, 0x43, 0xDF, 0x61, 0x1D, 0xA2, 0x81, 0x34, 0x10, 0x35, 0x6F, 0xAE, 0xF8, 0x92, 0x6E, 0xA0,
	0x3E, 0xB5, 0x58, 0xBB, 0x4F, 0x35, 0x51, 0xE0, 0x94, 0x3E, 0x29, 0x3E, 0xFD, 0xC8, 0x59, 0xAF,
	0x3F, 0x66, 0x88, 0xEE, 0x7F, 0x31, 0x36, 0xA4, 0x4C, 0x7C, 0x3C, 0x9C, 0x02, 0x55, 0x97, 0xAB,
	0xDD, 0xB7, 0xDD, 0x49, 0x0C, 0xFF, 0xF8, 0xB7, 0x81, 0x5F, 0x10, 0xED, 0xA2, 0x4A, 0x47, 0xE1,
	0x80, 0xD4, 0x04, 0x05, 0x46, 0xCA, 0x87, 0xA3, 0x80, 0x29, 0xF3, 0x7D, 0xBF, 0xF9, 0x0D, 0xA1,
	0xC4, 0xF6, 0xCF, 0x6A, 0x5C, 0x7C, 0x5A, 0x78, 0xCE, 0x52, 0x70, 0x4D, 0xE1, 0x73, 0x56, 0xED,
	0xB5, 0x29, 0x5D, 0x92, 0xCF, 0xBC, 0x02, 0xBF, 0x04, 0xBA, 0x35, 0x33, 0x48, 0xA8, 0xCA, 0xD6,
	0xCD, 0xC6, 0x5F, 0xD8, 0x20, 0xD9, 0x78, 0x17, 0x7C, 0x3F, 0x45, 0x33, 0x25, 0xC0, 0x38, 0x18,
	0x7D, 0x43, 0xA7, 0xF8, 0x7A, 0x4B, 0x19, 0x9B, 0xFF, 0x8F, 0x18, 0x0F, 0xC3, 0xB7, 0x60, 0xA0,
	0x21, 0x7E, 0xC7, 0x91, 0xAD, 0x3D, 0xAA, 0x44, 0x64, 0x7A, 0x33, 0x4B, 0x2F, 0x4F, 0x76, 0x85,
	0x2D, 0xFE, 0xA7, 0x36, 0x04, 0x08, 0x4E, 0x3B, 0x83, 0x33, 0x1B, 0x25, 0xFD, 0xED, 0x69, 0x17,
	0x66, 0x0A, 0x4D, 0x21, 0x11, 0x42, 0xC6, 0xC7, 0xD9, 0x7E, 0xC0, 0x66, 0x1A, 0xD5, 0xF5, 0xA3,
	0x97, 0x6C, 0xEE, 0x63, 0xBA, 0xC5, 0x2C, 0xF0, 0x36, 0x8B, 0xE3, 0xC2, 0x23, 0x7A, 0x75, 0x7C,
	0x60, 0x78, 0x22, 0x8B, 0x26, 0xBA, 0x08, 0x3A, 0x9D, 0x92, 0x23, 0x14, 0xFA, 0xB0, 0x86, 0x75,
	0x8E, 0x31, 0x39, 0xD2, 0x54, 0xA6, 0xE5, 0xC3, 0x73, 0xA7, 0xA4, 0x23, 0x29, 0x98, 0xE5, 0x1C,
	0xF9, 0x6C, 0x24, 0xAA, 0x2A, 0x25, 0x39, 0xC3, 0xF0, 0x7C, 0xD2, 0x42, 0xFD, 0x56, 0xC0, 0x2B,
	0x4F, 0xBD, 0x1C, 0x99, 0x18, 0xF8, 0x4C, 0x50, 0xCF, 0x7F, 0x5D, 0xF2, 0x14, 0x90, 0x86, 0x09,
	0xBE, 0x03, 0x75, 0x17, 0x35, 0xA4, 0x52, 0x89, 0x6B, 0x24, 0x7E, 0x73, 0xA8, 0xCB, 0x7C, 0x05,
	0x0E, 0x73, 0x8C, 0x72, 0xCD, 0x58, 0x5C, 0xBB, 0x7A, 0xF4, 0xBC, 0x4F, 0x27, 0xE7, 0xA5, 0xF1,
	0x7E, 0x83, 0xED, 0x45, 0x9E, 0x34, 0x75, 0x1C, 0x15, 0x06, 0xDA, 0x6F, 0x8E, 0x26, 0x02, 0x2F,
	0x9B, 0x03, 0x03, 0x74, 0x10, 0x47, 0x33, 0x90, 0x23, 0x1D, 0xFE, 0x2F, 0x7B, 0x48, 0x59, 0xEE,
	0xF2, 0xA4, 0xA3, 0x7C, 0x60, 0xA6, 0x80, 0xDE, 0x82, 0x74, 0x53, 0xA9, 0x0A, 0xEB, 0x4E, 0x63,
	0x93, 0x16, 0xAC, 0x23, 0x37, 0x01, 0x61, 0x4A, 0xBE, 0x84, 0x5F, 0xCB, 0x08, 0x29, 0x77, 0x60,
	0xF5, 0xD9, 0x60, 0xE9, 0x75, 0x15, 0x20, 0xD6, 0xA5, 0x12, 0x90, 0xDB, 0x1E, 0x74, 0x9D, 0x91,
	0xCD, 0xD7, 0x6D, 0xAC, 0x75, 0xC5, 0xA3, 0xB9, 0xBE, 0xCF, 0xCE, 0xA7, 0xB2, 0x78, 0x58, 0xBB,
	0x5D, 0x19, 0x0D, 0x59, 0xF2, 0x4B, 0x0B, 0x40, 0x60, 0xA8, 0x34, 0x2F, 0x08, 0xE7, 0xE4, 0xBB,
	0x77, 0x4A, 0xB1, 0xC7, 0x2F, 0x31, 0x4C, 0x93, 0xE4, 0x59, 0xCE, 0x9D, 0x2F, 0x22, 0xC3, 0xC0,
	0x1B, 0xE3, 0x77, 0xFD, 0xA5, 0xB9, 0x9C, 0x32, 0x26, 0x81, 0x88, 0xAF, 0x18, 0xCC, 0xE5, 0x26,
	0x01, 0xE5, 0x5E, 0x25, 0xB3, 0x17, 0x19, 0x86, 0xAD, 0xAE, 0xF4, 0x13, 0x00, 0x1B, 0xA8, 0xA5,
	0xE0, 0x14, 0xC6, 0x54, 0x4B, 0x99, 0x3D, 0x68, 0xF0, 0xF3, 0xBA, 0x31, 0xF8, 0x74, 0x6D, 0xED,
	0xB0, 0xA7, 0x5E, 0xCD, 0x62, 0xFD, 0x38, 0x05, 0xAE, 0x26, 0xAC, 0x86, 0xE2, 0x20, 0x8A, 0xA4,
	0xC0, 0x3A, 0x0B, 0x57, 0x24, 0x62, 0x1A, 0x73, 0x7C, 0xFE, 0x42, 0x24, 0x94, 0x08, 0x56, 0x06,
	0xEE, 0x1E, 0xE2, 0xF2, 0x81, 0xCA, 0xB3, 0x72, 0xD4, 0x26, 0x79, 0xFD, 0xAA, 0x71, 0x70, 0x57,
	0x77, 0xC2, 0x28, 0xB9, 0xA0, 0x8F, 0x0C, 0xB7, 0x08, 0xAE, 0xD6, 0xB9, 0x80, 0x7D, 0xEC, 0x74,
	0x2A, 0xE7, 0x59, 0x08, 0x27, 0x43, 0x18, 0xDF, 0x78, 0xEB, 0xF6, 0xC9, 0xE2, 0xF1, 0x70, 0x77,
	0xC7, 0x3E, 0x7E, 0x1D, 0x5F, 0xED, 0x49, 0x0F, 0xF4, 0xBE, 0x76, 0x81, 0xC9, 0x91, 0xDC, 0x9E,
	0xF5, 0xEC, 0x2A, 0x14, 0xF7, 0xE5, 0x25, 0xD7, 0x61, 0x43, 0x62, 0x87, 0x4D, 0x5E, 0x30, 0xE7,
	0x1E, 0xF4, 0xFA, 0x78, 0x90, 0xDD, 0xD6, 0x99, 0x34, 0xF5, 0x2D, 0xE3, 0x77, 0x5A, 0x15, 0xB4,
	0x2B, 0xAC, 0xA8, 0x8E, 0xA0, 0x68, 0x89, 0xA3, 0xD2, 0x3A, 0xE1, 0xB6, 0x3A, 0x1F, 0xD3, 0x7D,
	0x6F, 0xBF, 0x47, 0xC4, 0x9A, 0x15, 0x66, 0x5B, 0xE6, 0x89, 0xBC, 0x37, 0xAE, 0xB9, 0xE2, 0xDD,
	0x23, 0xAF, 0xCF, 0x92, 0xB6, 0x50, 0x4E, 0x0D, 0xDE, 0x2C, 0x3C, 0x84, 0x36, 0x08, 0x96, 0xC3,
	0x91, 0x02, 0x97, 0x8F, 0xE9, 0x62, 0x74, 0x2C, 0x0C, 0xE1, 0xA4, 0x0C, 0x85, 0xD7, 0x7E, 0xB0,
	0xD9, 0x2D, 0x0B, 0x14, 0x53, 0x70, 0xC8, 0xC5, 0x1A, 0x92, 0x73, 0x5F, 0xD2, 0x76, 0x81, 0x5F,
	0x77, 0xAC, 0xEE, 0x7D, 0x1F, 0xFD, 0x1C, 0xFD, 0xE4, 0xEC, 0xBF, 0xBA, 0x2E, 0xDC, 0x8D, 0x5B,
	0xDE, 0x6F, 0xE0, 0xC7, 0xA3, 0x37, 0x51, 0xC5, 0xE9, 0x44, 0x16, 0x77, 0xDB, 0x48, 0x43, 0x9B,
	0xFD, 0x4D, 0x82, 0x25, 0xF3, 0xE4, 0x4D, 0xC6, 0x76, 0xF5, 0x34, 0xBA, 0x2A, 0xA3, 0x58, 0x42,
	0x99, 0x78, 0x2E, 0xAC, 0xB3, 0x04, 0x04, 0x2C, 0x91, 0xF4, 0xC3, 0x8A, 0xC9, 0xE7, 0x66, 0xF8,
	0x6D, 0xAE, 0xF5, 0x28, 0x99, 0xD9, 0x44, 0xB8, 0xFC, 0x29, 0x82, 0x3A, 0x82, 0x02, 0xEC, 0x2A,
	0x4F, 0x08, 0xF9, 0x9C, 0xE7, 0xDB, 0x64, 0xE9, 0x2B, 0x14, 0x50, 0xA2, 0xB2, 0x3A, 0x74, 0x1A,
	0x62, 0x51, 0xC6, 0xC1, 0x60, 0x88, 0x4E, 0x09, 0xB3, 0x44, 0x1E, 0x47, 0x31, 0x2C, 0x0B, 0x9D,
	0xAF, 0x3F, 0x5B, 0x6F, 0x70, 0x45, 0x5D, 0xBC, 0xDA, 0x6E, 0x7A, 0x3C, 0x07, 0x3D, 0x2E, 0x93,
	0x35, 0xF8, 0x4D, 0x42, 0x43, 0x14, 0x0B, 0x68, 0xF8, 0xE7, 0xD9, 0x5A, 0x78, 0x8E, 0x2C, 0xF4,
	0x36, 0xB5, 0x07, 0x8A, 0xD2, 0x21, 0x3A, 0x29, 0xB6, 0x7B, 0x12, 0xD2, 0x22, 0x4A, 0xC7, 0x5B,
	0xCC, 0x66, 0x04, 0xE8, 0x8B, 0xB2, 0x5E, 0xB2, 0x59, 0x39, 0x39, 0x6D, 0x21, 0x16, 0x24, 0x10,
	0x04, 0xC3, 0xC7, 0xA2, 0x50, 0x37, 0x8D, 0xAF, 0x2C, 0x87, 0xF3, 0x36, 0x85, 0xC4, 0x42, 0x3F,
	0x44, 0xFB, 0x7B, 0xB9, 0x8D, 0xF1, 0x58, 0x5C, 0xCD, 0xA4, 0x88, 0x5C, 0xF1, 0x53, 0x45, 0xF5,
	0x63, 0xF9, 0x63, 0x72, 0x39, 0x8B, 0x62, 0xBC, 0xF6, 0xB3, 0xF3, 0x9E, 0xD7, 0xC3, 0x96, 0x3A,
	0xF6, 0x6B, 0x09, 0xB8, 0x08, 0x6A, 0x00, 0x52, 0xAC, 0x73, 0x91, 0x38, 0x72, 0x5D, 0xE4, 0x1A,
	0x1F, 0xE7, 0x81, 0xED, 0x9C, 0xB2, 0xFD, 0x72, 0xDE, 0xE2, 0x18, 0x25, 0x70, 0xE8, 0x2E, 0x56,
	0x5C, 0xED, 0xFD, 0x21, 0x43, 0x99, 0x20, 0x3D, 0x82, 0x20, 0x4F, 0xDF, 0x4C, 0xCF, 0x37, 0xC5,
	0xB1, 0x48, 0x2D, 0x26, 0x92, 0xE5, 0x2B, 0xB5, 0xC8, 0xBB, 0xC4, 0x31, 0x4E, 0x5B, 0x29, 0x42,
	0xF8, 0xFF, 0x93, 0x19, 0x4B, 0xBE, 0x87, 0x46, 0xC0, 0x04, 0xE0, 0x11, 0xA2, 0xB6, 0x63, 0x5D,
	0xF3, 0x29, 0xFC, 0xC3, 0xF9, 0x3A, 0xBF, 0xDD, 0xA4, 0xBA, 0x8D, 0x35, 0x65, 0x90, 0xE6, 0x61,
	0x9C, 0xB1, 0xBF, 0x50, 0x03, 0xF8, 0x24, 0xA4, 0xC5, 0x95, 0xC5, 0x84, 0x8D, 0x33, 0x31, 0xC0,
	0x3B, 0x92, 0x01, 0x8C, 0xA5, 0xA2, 0xD8, 0xB6, 0xCB, 0xC5, 0xE6, 0x83, 0x30, 0x6D, 0xA0, 0xCC,
	0x18, 0x4E, 0x11, 0xE6, 0x20, 0x66, 0xC3, 0x45, 0x85, 0x9A, 0x19, 0x36, 0x10, 0x20, 0x86, 0xB3,
	0x7D, 0x73, 0xAA, 0x1D, 0xE6, 0x2D, 0x5B, 0xE0, 0xC1, 0xA1, 0x10, 0xDC, 0xBC, 0x86, 0xCE, 0x35,
	0x13, 0xEA, 0x8F, 0x66, 0x5E, 0x53, 0x42, 0x10, 0x28, 0xB3, 0x5D, 0x62, 0xC6, 0xC1, 0x76, 0x99,
	0x82, 0xAA, 0x1D, 0xEF, 0x9C, 0x96, 0xD7, 0x6F, 0x15, 0x40, 0x11, 0x8D, 0xC4, 0x14, 0x88, 0x99,
	0x26, 0x53, 0x0D, 0x8B, 0xA9, 0xAF, 0xCE, 0x1B, 0x28, 0x18, 0x6E, 0x0F, 0x12, 0x24, 0x34, 0xC0,
	0x82, 0x48, 0x7C, 0xD2, 0xE8, 0xD6, 0xCE, 0xB7, 0xDC, 0xD5, 0x37, 0xD5, 0x93, 0x12, 0x02, 0x40,
	0xEA, 0xE8, 0x3B, 0x22, 0x1A, 0x54, 0x6B, 0x62, 0x59, 0xDB, 0x3A, 0x8C, 0xA8, 0xFC, 0x70, 0x94,
	0xC7, 0x75, 0x14, 0x0E, 0xF5, 0x54, 0x16, 0x17, 0x85, 0xC5, 0x7E, 0x65, 0x71, 0xFF, 0x1E, 0x3D,
	0x90, 0x7B, 0xCD, 0xE3, 0xD8, 0x37, 0x2C, 0x69, 0xD2, 0xAF, 0xF4, 0xA0, 0x4A, 0x33, 0x9E, 0x58,
	0x26, 0x01, 0x7F, 0xFD, 0xE6, 0x47, 0x68, 0x27, 0x6B, 0xC4, 0xC3, 0xB8, 0x9D, 0x49, 0x2B, 0x6B,
	0x42, 0xE4, 0x08, 0xB4, 0xA4, 0xB5, 0x8F, 0xB6, 0xCB, 0x4C, 0x61, 0x6C, 0x78, 0x57, 0xC1, 0x52,
	0xA3, 0x07, 0xEE, 0xAC, 0xB8, 0xB6, 0xBB, 0x62, 0xEB, 0x4B, 0xC7, 0x9B, 0xE5, 0xA7, 0x3F, 0x7E,
	0x3E, 0x5C, 0x42, 0x4E, 0x74, 0x14, 0x7B, 0x44, 0x01, 0x27, 0x53, 0x02, 0x5D, 0x35, 0x72, 0x1A,
	0xFC, 0x70, 0xBD, 0xFE, 0xCB, 0x8B, 0x29, 0x9E, 0x6D, 0x1A, 0x44, 0x3E, 0x84, 0xFF, 0xFA, 0xE5,
	0x1B, 0xB7, 0x35, 0xDF, 0xE6, 0x28, 0x92, 0xD3, 0xEC, 0xD0, 0xEF, 0x38, 0x4F, 0x57, 0xD7, 0xDD,
	0x01, 0xE9, 0xBE, 0x7D, 0x51, 0x95, 0xA8, 0xB6, 0x58, 0xD6, 0x88, 0xD8, 0x34, 0x25, 0x7B, 0xF6,
	0x5C, 0xD6, 0xB2, 0x70, 0x2B, 0x86, 0x29, 0xD1, 0x3E, 0x9D, 0x5E, 0xC3, 0xD1, 0x4C, 0xDC, 0xAF,
	0x88, 0x58, 0x72, 0x22, 0x06, 0x1A, 0x9A, 0xA2, 0x1F, 0x7B, 0x59, 0x2C, 0x3B, 0x52, 0x8F, 0x76,
	0xB2, 0x89, 0x8D, 0xDD, 0x39, 0xDD, 0xC9, 0x35, 0x0C, 0x8F, 0x6C, 0xA6, 0x6B, 0xC5, 0xCB, 0xC3,
	0xBA, 0xE5, 0x7F, 0x54, 0xA3, 0xC3, 0x00, 0x26, 0x0E, 0xAB, 0x17, 0xAA, 0x45, 0x33, 0x6F, 0x1D,
	0x8A, 0x48, 0x0D, 0xAA, 0xA4, 0x5B, 0x73, 0xAE, 0x7C, 0x67, 0x40, 0xB2, 0x65, 0x7C, 0x4B, 0xC3,
	0x0E, 0x3B, 0xD2, 0x29, 0x52, 0xFB, 0x2D, 0x35, 0x9D, 0x9D, 0x9B, 0xD3, 0xA4, 0x92, 0x04, 0x62,
	0x1C, 0x54, 0x96, 0xA3, 0x9A, 0x2A, 0xFE, 0x46, 0x38, 0x2E, 0x51, 0x56, 0x95, 0x5E, 0x2B, 0xBF,
	0x27, 0xF4, 0x2F, 0x79, 0x25, 0x2D, 0xA3, 0xC7, 0x34, 0xEF, 0xA6, 0xD3, 0x52, 0x19, 0x46, 0xCA,
	0x4D, 0xCE, 0xF0, 0xA6, 0x76, 0xFD, 0x6A, 0x3D, 0x31, 0x77, 0x61, 0xAC, 0x1F, 0xEC, 0x9A, 0x0F,
	0x4D, 0xEA, 0x7B, 0xD5, 0x99, 0xE9, 0xD5, 0x95, 0x5D, 0xEF, 0x81, 0x6C, 0x62, 0x92, 0xA4, 0x81,
	0x97, 0x95, 0x43, 0x16, 0xFA, 0xC0, 0xF8, 0x30, 0x3A, 0xA3, 0xCC, 0x32, 0x31, 0x2B, 0xA1, 0x87,
	0x40, 0x40, 0xDA, 0x4D, 0x97, 0x53, 0x27, 0xB9, 0x90, 0xDA, 0xD5, 0xCD, 0xA4, 0xB7, 0x59, 0x27,
	0x34, 0xAD, 0xC4, 0x9B, 0x25, 0x9C, 0xB6, 0xB3, 0x41, 0x56, 0xC3, 0x90, 0xD7, 0xC7, 0xB1, 0x24,
	0x40, 0x82, 0x59, 0x29, 0x1C, 0x1B, 0x4B, 0xE4, 0x99, 0xEC, 0x67, 0xA2, 0x51, 0x80, 0x31, 0x4C,
	0x18, 0x1E, 0x7B, 0x5C, 0x2E, 0xF0, 0xAF, 0x90, 0xB1, 0x0B, 0x22, 0x81, 0xE6, 0x0F, 0x57, 0x20,
	0xFC, 0x81, 0xC2, 0x09, 0x78, 0xBD, 0x84, 0xE7, 0xE0, 0xC1, 0x03, 0x47, 0xFD, 0x4C, 0xAB, 0x86,
	0x87, 0x1D, 0x21, 0x3E, 0x75, 0x41, 0xDF, 0x64, 0xD3, 0x51, 0xEA, 0x13, 0xEC, 0x05, 0x83, 0x40,
	0x4D, 0xD7, 0xEC, 0x91, 0x8C, 0x35, 0x6A, 0xC2, 0xC8, 0x47, 0xDB, 0x50, 0x5A, 0x98, 0xA2, 0x45,
	0xE8, 0x3A, 0x6E, 0x33, 0x67, 0x01, 0x88, 0x23, 0xDF, 0xD6, 0x86, 0x54, 0x4E, 0x76, 0x9E, 0xF0,
	0x24, 0x5A, 0xD2, 0xBD, 0x00, 0x81, 0xCB, 0x87, 0xC5, 0xA0, 0x29, 0x4B, 0xEF, 0x1E, 0xB8, 0x88,
	0x7E, 0xC2, 0xE3, 0x3F, 0x68, 0x38, 0xBA, 0x31, 0x3F, 0x51, 0x05, 0x3B, 0xA5, 0x24, 0x1F, 0x26,
	0x45, 0xE5, 0xBF, 0xB4, 0x2F, 0x27, 0x39, 0x7F, 0x1F, 0x1B, 0x17, 0x0A, 0xEA, 0x87, 0x30, 0xA3,
	0x75, 0x5B, 0x70, 0xF0, 0x94, 0xC6, 0xCB, 0x96, 0xB2, 0x20, 0x62, 0x2A, 0x90, 0xBE, 0x8F, 0xB9,
	0x21, 0xD9, 0x7D, 0x01, 0x8F, 0x75, 0x21, 0x05, 0x06, 0x3D, 0xBC, 0xD6, 0xE1, 0xEB, 0x3A, 0x24,
	0x4C, 0x53, 0x72, 0x6D, 0x6C, 0xF0, 0xDA, 0xAD, 0xE7, 0x18, 0x01, 0x93, 0x21, 0x30, 0x19, 0xB1,
	0x2E, 0xDB, 0x39, 0x1C, 0xC7, 0xDA, 0x99, 0xA7, 0xA0, 0x09, 0x14, 0x48, 0xDC, 0xDD, 0x00, 0x65,
	0x2A, 0x54, 0x94, 0x10, 0xCF, 0xE4, 0x41, 0x36, 0xE9, 0xA1, 0x45, 0xA5, 0xA2, 0x1B, 0x66, 0x3E,
	0x2B, 0x81, 0xB9, 0x66, 0x62, 0x39, 0xB7, 0xB1, 0x48, 0x37, 0x63, 0xBC, 0x56, 0xED, 0x68, 0x64,
	0x3D, 0xCC, 0xB8, 0x11, 0xD0, 0xFC, 0x5D, 0x8B, 0x1D, 0x9B, 0xEB, 0x1B, 0x28, 0x78, 0x58, 0xC9,
	0x45, 0x85, 0x17, 0xF5, 0x50, 0x84, 0x26, 0xBC, 0x34, 0xAD, 0x76, 0xB8, 0xDD, 0xA4, 0xC9, 0x5E,
	0x72, 0xDD, 0xE6, 0x3B, 0x6F, 0x83, 0x4D, 0x00, 0x45, 0x33, 0x63, 0xCC, 0xB1, 0xEF, 0xB3, 0x18,
	0xE3, 0x83, 0x4E, 0xF8, 0xFD, 0x90, 0x8C, 0x54, 0x81, 0xD6, 0x3B, 0xE2, 0x18, 0x9A, 0xB7, 0x57,
	0x2F, 0xC2, 0x40, 0xAB, 0x5B, 0x67, 0x71, 0x22, 0x92, 0x33, 0xC4, 0xD2, 0xA9, 0xD3, 0xD1, 0xF9,
	0x90, 0xCC, 0xF7, 0xF9, 0x77, 0xE0, 0x9C, 0xBC, 0x6C, 0xD7, 0x17, 0x12, 0x02, 0x6F, 0xFD, 0x64,
	0x69, 0x13, 0xF7, 0x81, 0xC5, 0x80, 0x88, 0xFD, 0xD0, 0x16, 0x05, 0xB0, 0x59, 0x36, 0x8C, 0xF2,
	0x6D, 0x13, 0x4C, 0x7D, 0x4F, 0x80, 0x26, 0x3E, 0x87, 0x8F, 0x71, 0xB2, 0x4A, 0x7C, 0x21, 0xF9,
	0x06, 0xA0, 0xC3, 0xCB, 0xD0, 0x61, 0xFE, 0xCF, 0xC1, 0x05, 0x38, 0xE6, 0xDF, 0x84, 0xE0, 0x73,
	0x5A, 0xA3, 0xBC, 0x88, 0x79, 0xB5, 0x7E, 0x61, 0x3A, 0x06, 0x27, 0xC4, 0x69, 0x53, 0x49, 0x4C,
	0xB3, 0x9B, 0xD4, 0xB7, 0x16, 0x17, 0xF1, 0x45, 0x05, 0xF0, 0xC1, 0x80, 0x96, 0xA6, 0xFC, 0x8C,
	0x2B, 0x07, 0x3A, 0x9E, 0xB1, 0x18, 0x6E, 0xCF, 0xCE, 0x40, 0x6C, 0x75, 0xA3, 0x97, 0xAA, 0xA8,
	0xF3, 0xEE, 0x63, 0x34, 0x74, 0x48, 0xBC, 0x83, 0xE3, 0x60, 0xB9, 0xA4, 0x76, 0x44, 0x22, 0xE7,
	0x27, 0xA8, 0x1B, 0x9B, 0x6E, 0x64, 0x08, 0x78, 0x42, 0xA0, 0xF6, 0x94, 0x2F, 0x78, 0x05, 0xEB,
	0x6B, 0x2A, 0x55, 0x31, 0xC0, 0x5F, 0xD5, 0x52, 0x7B, 0x98, 0xEE, 0xEA, 0xFF, 0xB0, 0xC4, 0xCF,
	0xF8, 0x81, 0xE3, 0x68, 0x1C, 0x4B, 0xB8, 0xA0, 0xAD, 0xDD, 0xBD, 0x74, 0x09, 0x45, 0x96, 0x97,
	0xD2, 0xCA, 0x3E, 0x19, 0xBA, 0x46, 0x6B, 0x14, 0x3A, 0x29, 0x20, 0x0E, 0x21, 0x31, 0x2F, 0x32,
	0x2B, 0x11, 0xCE, 0x95, 0x22, 0xC1, 0xC0, 0x05, 0x8E, 0xD5, 0x1B, 0x47, 0x05, 0x76, 0x81, 0x01,
	0x1A, 0x24, 0x8F, 0x61, 0xAF, 0x12, 0xD0, 0x84, 0x2F, 0x8E, 0x8F, 0x90, 0x48, 0xBE, 0xC6, 0x22,
	0x22, 0x5B, 0xD6, 0x5C, 0x44, 0x78, 0xB7, 0x9D, 0xAC, 0x03, 0x6D, 0x0D, 0xB6, 0x47, 0xD2, 0xCD,
	0x8F, 0xC6, 0xC7, 0x97, 0x8F, 0xC0, 0x5E, 0x0A, 0x55, 0x25, 0xB6, 0xA4, 0x82, 0xD4, 0xB8, 0x8A,
	0x82, 0xF9, 0xC6, 0x86, 0x7F, 0xE7, 0x84, 0x09, 0x80, 0xF6, 0x3B, 0x4D, 0x1D, 0xB6, 0x6B, 0x7F,
	0x76, 0x61, 0xDF, 0x52, 0x86, 0x7B, 0x11, 0x04, 0xB9, 0x69, 0xBC, 0xEB, 0x4C, 0x5E, 0xA6, 0x85,
	0x99, 0x78, 0xF4, 0x9E, 0x72, 0x06, 0x11, 0x77, 0xE5, 0x28, 0xD9, 0x37, 0x3D, 0x0B, 0x9F, 0x58,
	0xBD, 0xAD, 0x62, 0x9B, 0xBE, 0x2E, 0xB0, 0x9A, 0xD7, 0xB7, 0x57, 0x17, 0xCA, 0x0A, 0xE0, 0x55,
	0x6E, 0x4C, 0x9D, 0xFB, 0xFE, 0x1D, 0x17, 0x92, 0xCE, 0xCC, 0x02, 0x4B, 0x2A, 0xAF, 0x86, 0xE1,
	0x8B, 0x40, 0x7F, 0x4F, 0xC1, 0x7C, 0x18, 0xB0, 0x34, 0xE6, 0xB2, 0x3F, 0x22, 0xB4, 0x54, 0x79,
	0x16, 0x02, 0x0E, 0x44, 0x5F, 0xA4, 0xEC, 0xA4, 0x73, 0x4D, 0x5E, 0xB4, 0x79, 0xAC, 0x97, 0x9D,
	0x32, 0x6E, 0xB3, 0x32, 0xDD, 0x69, 0x0E, 0xC2, 0x76, 0x80, 0x55, 0x03, 0x1A, 0x2A, 0x1D, 0xA0,
	0x3D, 0x9F, 0xEA, 0xFC, 0xA6, 0xC4, 0x86, 0xE4, 0x4E, 0xF6, 0x0B, 0x17, 0x38, 0x0D, 0xC1, 0xBC,
	0x19, 0x7F, 0xB5, 0x21, 0x3B, 0x4B, 0x94, 0x59, 0x77, 0xFC, 0xF2, 0xCE, 0x80, 0x0F, 0x09, 0x0E,
	0x09, 0xE4, 0x70, 0xD7, 0x13, 0x51, 0xDB, 0x76, 0xC1, 0x9A, 0x81, 0xC9, 0xB9, 0x4F, 0x34, 0xEE,
	0x53, 0x63, 0x2B, 0x00, 0x07, 0x87, 0x02, 0xE7, 0x6D, 0x18, 0x34, 0x51, 0x6C, 0x22, 0x15, 0xB1,
	0x08, 0x15, 0xB5, 0x38, 0xA1, 0xCF, 0x4B, 0x7B, 0x04, 0x4D, 0x41, 0x04, 0x5A, 0x77, 0x30, 0x5F,
	0xAA, 0xD4, 0x0D, 0x05, 0xEB, 0x69, 0x32, 0xF7, 0xD4, 0xA1, 0x2B, 0x40, 0x96, 0x6F, 0xFA, 0x11,
	0xE4, 0xE8, 0xA7, 0x5B, 0xEA, 0xA2, 0x13, 0xD7, 0xA7, 0xFC, 0xBE, 0x27, 0xBE, 0x4B, 0x31, 0x17,
	0x5D, 0xAC, 0xB5, 0x25, 0x40, 0x4C, 0x50, 0x71, 0xFC, 0x28, 0x7A, 0x55, 0x03, 0x04, 0x88, 0x33,
	0x5F, 0x8E, 0x2F, 0x28, 0xF5, 0x06, 0x56, 0xC1, 0x5B, 0x50, 0x9F, 0x13, 0xFB, 0x46, 0xE9, 0xC0,
	0xD7, 0xEB, 0xE6, 0xBC, 0xE0, 0xB2, 0x7D, 0xB7, 0xF0, 0x48, 0x0B, 0x46, 0x1E, 0xCF, 0xC4, 0x67,
	0xFC, 0x65, 0x4E, 0x47, 0x30, 0x6D, 0x8E, 0xDD, 0x7D, 0xE7, 0x0A, 0xBA, 0x66, 0xE2, 0x60, 0x1A,
	0x4B, 0x81, 0x56, 0xE0, 0x9C, 0xB3, 0x31, 0x14, 0xBF, 0xA0, 0xC5, 0x6A, 0xC7, 0xD2, 0x12, 0xC0,
	0x3D, 0x74, 0xA1, 0xF8, 0x73, 0xD8, 0xAA, 0xDC, 0x52, 0xAE, 0xDD, 0xCA, 0x63, 0xAE, 0xD2, 0x7C,
	0x45, 0xA3, 0xF6, 0x89, 0xEC, 0xE2, 0xCB, 0x0F, 0x51, 0xBA, 0x35, 0x99, 0xE5, 0xC7, 0xF6, 0x3B,
	0x2E, 0x2D, 0xB0, 0x72, 0x39, 0xAF, 0x91, 0xD4, 0xFD, 0xB8, 0x82, 0x2A, 0x08, 0xAD, 0xCB, 0xD6,
	0x08, 0x2B, 0xF8, 0x40, 0x7C, 0xFF, 0xC5, 0x9F, 0x88, 0x6E, 0x13, 0x90, 0x77, 0x23, 0x19, 0xC7,
	0xA5, 0x83, 0x38, 0xAB, 0xC6, 0x31, 0x5B, 0x2F, 0xA0, 0x4E, 0x4D, 0x05, 0x15, 0xFD, 0xB2, 0xBD,
	0x44, 0x34, 0xF0, 0x90, 0x84, 0x83, 0x71, 0x69, 0x5E, 0x09, 0xD1, 0x44, 0x02, 0x11, 0x07, 0x55,
	0x9C, 0x08, 0x60, 0x43, 0x92, 0xAA, 0x63, 0x64, 0x4B, 0x3B, 0x7F, 0x4C, 0xC4, 0x2A, 0x70, 0x76,
	0x38, 0x63, 0x71, 0xBF, 0x3C, 0x98, 0x96, 0x75, 0x63, 0xB9, 0x08, 0xD3, 0x5B, 0x39, 0xC9, 0xEE,
	0x9C, 0x41, 0x85, 0x40, 0x42, 0x60, 0x49, 0xAE, 0x5B, 0x2F, 0x3A, 0xA7, 0xFB, 0x7F, 0xE7, 0x81,
	0x68, 0x3C, 0xAF, 0x19, 0x89, 0x45, 0x10, 0xBD, 0x23, 0xF1, 0x54, 0x5C, 0xD4, 0x23, 0xE0, 0xB9,
	0xC5, 0x4D, 0x88, 0x76, 0x18, 0x7D, 0xF0, 0x6D, 0xD2, 0x72, 0x6D, 0x57, 0xBD, 0x2F, 0x71, 0x29,
	0x50, 0x67, 0x4D, 0x8C, 0x3E, 0xCE, 0xC4, 0xC9, 0xD9, 0x84, 0x6D, 0x35, 0x21, 0x4F, 0x09, 0x1A,
	0xF4, 0x02, 0xC3, 0xBA, 0x0F, 0xEC, 0xE1, 0x0F, 0xCE, 0xE4, 0x68, 0xE3, 0x4B, 0x6D, 0xD4, 0xF4,
	0xC9, 0x78, 0x0F, 0xCD, 0xFB, 0xA9, 0xD3, 0xD8, 0xBF, 0x18, 0xA6, 0xF0, 0x2F, 0x5A, 0x11, 0x4F,
	0x6A, 0x79, 0xC1, 0xBC, 0x00, 0xE0, 0x25, 0x46, 0x92, 0x34, 0x48, 0xEC, 0xC7, 0x41, 0x3C, 0x1D,
	0x97, 0xB3, 0x60, 0x4F, 0x5D, 0xB5, 0xB3, 0xAC, 0xC5, 0xE1, 0xD9, 0xF2, 0xB0, 0x7D, 0xF2, 0x1B,
	0xB9, 0x6B, 0xBB, 0x86, 0x43, 0x8F, 0x6F, 0xD9, 0xB1, 0x84, 0xC9, 0x39, 0x04, 0xE8, 0xFC, 0x16,
	0xB6, 0xAB, 0xF2, 0xCD, 0xFA, 0x4D, 0xD3, 0xFD, 0xB1, 0xC2, 0x02, 0x8C, 0x69, 0x30, 0x52, 0x53,
	0xFA, 0x5D, 0xAF, 0x2E, 0xE1, 0x83, 0x8B, 0x40, 0xFE, 0xFD, 0x68, 0x0C, 0xE5, 0x79, 0xE5, 0x2A,
	0x77, 0x0E, 0x31, 0x4B, 0x5D, 0xDE, 0xD7, 0x23, 0xEB, 0x37, 0xAE, 0xA8, 0x4A, 0x09, 0xEE, 0x52,
	0xB1, 0xD7, 0xEF, 0x7E, 0xA4, 0xEE, 0x00, 0xB1, 0xEA, 0x84, 0xF8, 0xCF, 0xA6, 0x15, 0xCC, 0xBF,
	0x83, 0xDF, 0x54, 0x90, 0x72, 0xD5, 0x56, 0xF3, 0x74, 0x27, 0x26, 0xB9, 0x9B, 0x32, 0xC2, 0xC7,
	0x0F, 0xE5, 0xA5, 0x71, 0x61, 0xB0, 0x8C, 0x69, 0x32, 0x79, 0x45, 0x6D, 0x5E, 0x2D, 0x7E, 0xF2,
	0x60, 0x2D, 0xBE, 0x4D, 0x2C, 0x97, 0x7A, 0x27, 0xFF, 0xB8, 0x84, 0x6C, 0x2C, 0x2A, 0x8D, 0x4B,
	0xE2, 0x65, 0x42, 0x62, 0x0E, 0x5A, 0x8C, 0x0B, 0x3B, 0x21, 0x7D, 0x6C, 0xDD, 0xFC, 0x11, 0x66,
	0x3B, 0xDF, 0x01, 0x4C, 0x74, 0xAE, 0x88, 0x86, 0xD9, 0xDA, 0x55, 0x0F, 0xAA, 0xB5, 0xA8, 0x79,
	0xF1, 0xCD, 0x1E, 0x13, 0xBF, 0x07, 0x51, 0x02, 0x98, 0x95, 0x4B, 0xF9, 0x9D, 0xA4, 0x72, 0x5D,
	0xA4, 0xFF, 0x66, 0xED, 0x74, 0xB0, 0x73, 0x58, 0x59, 0x88, 0x4E, 0x22, 0x98, 0x64, 0x7E, 0xBC,
	0xA2, 0x6A, 0x2B, 0x89, 0x21, 0xC4, 0x4D, 0x04, 0x96, 0xBB, 0xE2, 0x80, 0x0D, 0x31, 0x1B, 0x5D,
	0x87, 0x1F, 0xDC, 0xD8, 0xF1, 0x29, 0xF0, 0x35, 0x12, 0x7C, 0x89, 0x88, 0x96, 0xBD, 0x51, 0xED,
	0x8E, 0x87, 0x1E, 0xF3, 0x37, 0x26, 0x8A, 0xA7, 0x46, 0x81, 0x73, 0x7E, 0xBF, 0x0E, 0xCF, 0x3A,
	0xC3, 0x2B, 0xD9, 0x2B, 0xF0, 0x17, 0x4F, 0xFC, 0x39, 0x32, 0xDA, 0x7D, 0xA7, 0x18, 0xA8, 0x6D,
	0xA2, 0x0A, 0x70, 0xA3, 0x72, 0xE6, 0x8E, 0x76, 0x4B, 0x06, 0x10, 0x70, 0xA6, 0x8F, 0xF2, 0x05,
	0x75, 0x4C, 0xEA, 0xF6, 0xD2, 0x72, 0x24, 0x5F, 0xAA, 0xEC, 0x31, 0x6B, 0x0D, 0xBB, 0x49, 0x8F,
	0x01, 0x2D, 0x18, 0x9B, 0xFF, 0x04, 0x8C, 0xDF, 0xD8, 0xC1, 0xA5, 0xB6, 0xCA, 0x4C, 0x64, 0xA1,
	0xF9, 0x63, 0x30, 0x0D, 0xB2, 0xC9, 0x4A, 0x14, 0x08, 0x2D, 0x20, 0x8A, 0x51, 0xBE, 0xD5, 0x44,
	0xBA, 0x6B, 0xB8, 0x08, 0x11, 0xF7, 0xEF, 0x05, 0x19, 0x47, 0xA8, 0xD8, 0xA9, 0x61, 0x2F, 0xB3,
	0xFC, 0x53, 0xC7, 0xC0, 0xBD, 0x44, 0x58, 0xEF, 0xB9, 0x9B, 0xBF, 0x75, 0x44, 0xB0, 0x22, 0xBC,
	0x91, 0x62, 0x79, 0x53, 0x86, 0xC9, 0x10, 0xBF, 0x7B, 0xFC, 0xD5, 0xCD, 0x4B, 0x89, 0xB2, 0x21,
	0x21, 0x24, 0x7D, 0xC6, 0x16, 0x95, 0x75, 0xAF, 0xB1, 0xCE, 0xC0, 0xDF, 0x34, 0x14, 0xB5, 0x81,
	0x1D, 0xDF, 0x45, 0x57, 0x3D, 0xB0, 0xEC, 0xDD, 0x18, 0x43, 0xE2, 0xC8, 0x6E, 0x84, 0x1F, 0x82,
	0xB1, 0x44, 0xD2, 0x5A, 0xE5, 0x46, 0xDA, 0xF9, 0xAE, 0xCA, 0x7D, 0xF8, 0xD4, 0x28, 0x7B, 0xD1,
	0xE9, 0x9E, 0x9E, 0x47, 0x3B, 0x49, 0x8F, 0x5D, 0xE1, 0xF6, 0xC6, 0xC4, 0xC3, 0x2B, 0xF7, 0xD4,
	0xC3, 0x9E, 0xB2, 0x02, 0xAC, 0xFF, 0xFD, 0x40, 0x87, 0xFF, 0xB2, 0x6F, 0x18, 0xD4, 0x35, 0x42,
	0x20, 0xC8, 0xE8, 0x45, 0xD0, 0x22, 0xF2, 0xE9, 0x8D, 0x7B, 0x87, 0x37, 0x75, 0x90, 0x88, 0xB4,
	0x94, 0x79, 0xD5, 0x4A, 0x01, 0x59, 0x1C, 0x5F, 0x81, 0x0A, 0xF8, 0x6F, 0x10, 0xC9, 0x4A, 0x3A,
	0xBF, 0xBD, 0xAD, 0x46, 0x8B, 0xA2, 0xE6, 0x79, 0xBC, 0x94, 0x13, 0xD0, 0x6C, 0x91, 0x9F, 0xEE,
	0x47, 0x26, 0x28, 0x21, 0x1C, 0xB0, 0x68, 0x68, 0x1D, 0x35, 0x33, 0x8F, 0x40, 0x16, 0x87, 0x09,
	0xD5, 0x2F, 0xD7, 0x52, 0xFF, 0x03, 0x72, 0xE6, 0xAD, 0xD6, 0x40, 0xD9, 0x23, 0x7D, 0xFE, 0x5D,
	0xE5, 0x1A, 0x2C, 0x2A, 0x1C, 0xDE, 0x4E, 0xAC, 0x47, 0x91, 0x40, 0x07, 0xDF, 0xFF, 0xE7, 0xE8,
	0x69, 0x3A, 0x8E, 0x04, 0xCF, 0x90, 0x2A, 0x51, 0xFE, 0xDA, 0x12, 0xFC, 0x50, 0xFD, 0x56, 0x65,
	0x8A, 0x31, 0x42, 0x7E, 0xB8, 0xB6, 0xED, 0x81, 0xE8, 0x7B, 0x9F, 0xB9, 0x6A, 0xBF, 0x05, 0xCA,
	0xC5, 0x1B, 0x52, 0xA2, 0xC7, 0x78, 0x99, 0x16, 0x01, 0xCE, 0x22, 0x84, 0xB4, 0xF4, 0xE6, 0x28,
	0xD1, 0x2B, 0xA7, 0xB0, 0xBE, 0x60, 0x41, 0xE7, 0xBE, 0x29, 0x8D, 0x2E, 0x60, 0x55, 0x19, 0x5B,
	0x15, 0x69, 0x84, 0x1A, 0xBF, 0x50, 0xF9, 0x65, 0x31, 0xF8, 0x47, 0x01, 0xD2, 0x7E, 0x49, 0x9E,
	0xCA, 0x17, 0xD8, 0x4C, 0x52, 0x91, 0x73, 0x6F, 0x23, 0xAF, 0x37, 0x46, 0x25, 0x6C, 0x56, 0x86,
	0x1E, 0x54, 0xC9, 0xCA, 0x9B, 0xEB, 0x51, 0x56, 0x46, 0xE3, 0x29, 0x48, 0xE2, 0x16, 0x90, 0x83,
	0x7C, 0x66, 0x1C, 0x8E, 0x29, 0x32, 0x32, 0x5B, 0x58, 0x9A, 0xD0, 0xE5, 0xA9, 0xC4, 0x6E, 0x17,
	0xBA, 0x07, 0xFC, 0x1F, 0xF4, 0xAA, 0x77, 0x54, 0x46, 0xD2, 0x64, 0xE6, 0x65, 0xC3, 0x25, 0x15,
	0x1B, 0xAC, 0x4D, 0x09, 0xDA, 0xFE, 0x5B, 0x9F, 0x65, 0xF6, 0xA4, 0x70, 0xD3, 0x47, 0x4B, 0xEC,
	0x29, 0x09, 0x3A, 0x9F, 0x1E, 0x93, 0xB0, 0xD4, 0x9D, 0xCF, 0xBC, 0xDC, 0x35, 0x80, 0x78, 0xA8,
	0xB9, 0x1C, 0x86, 0x11, 0x77, 0x0F, 0xD3, 0xEE, 0x38, 0x4A, 0x3E, 0xBA, 0x47, 0xB1, 0x1C, 0xA9,
	0x9E, 0x9E, 0x61, 0xFD, 0x39, 0x02, 0xA8, 0x79, 0x1B, 0xCF, 0xE7, 0xE0, 0xB0, 0xE3, 0x8D, 0x32,
	0xB9, 0x1D, 0xA8, 0x81, 0xCE, 0xF6, 0x93, 0xEC, 0x64, 0x76, 0x05, 0x2B, 0x51, 0xD5, 0x9B, 0x4C,
	0xBD, 0x91, 0xF0, 0x72, 0x18, 0x13, 0x08, 0xCC, 0x96, 0x76, 0xF2, 0x59, 0x75, 0x9B, 0x81, 0xDA,
	0x2F, 0x89, 0x59, 0x26, 0x87, 0x67, 0xB0, 0xFF, 0x4F, 0x0A, 0x58, 0xF9, 0xE9, 0x1B, 0x40, 0xF0,
	0x83, 0x07, 0xFD, 0xF0, 0x5B, 0x43, 0xCC, 0x1B, 0x66, 0x44, 0x74, 0xC7, 0xDB, 0xC6, 0x78, 0xCD,
	0xDA, 0xC8, 0xB9, 0xBE, 0xDC, 0x0B, 0x26, 0x3B, 0x46, 0x55, 0x14, 0xDE, 0x8B, 0x60, 0x5F, 0x36,
	0xCD, 0x7B, 0x01, 0x72, 0x11, 0xB2, 0x17, 0x4C, 0x93, 0x07, 0x2D, 0x0E, 0x11, 0x10, 0x59, 0x8E,
	0x65, 0x09, 0x40, 0x22, 0x4C, 0x5B, 0x8C, 0x38, 0x48, 0x22, 0x96, 0x60, 0x8F, 0x61, 0xC5, 0x19,
	0x31, 0xC8, 0xF2, 0x27, 0xC3, 0x2A, 0x19, 0x94, 0xAF, 0x1E, 0xD3, 0xFF, 0x0D, 0xAE, 0x84, 0x05,
	0x50, 0x92, 0xE2, 0x4A, 0x14, 0x8A, 0xB1, 0xA8, 0xAC, 0x5E, 0xCC, 0xC8, 0xDC, 0xED, 0x68, 0xD9,
	0xEB, 0x3C, 0x36, 0x44, 0x8F, 0x3D, 0xAC, 0xC3, 0xCD, 0xE7, 0xE4, 0x2B, 0x9C, 0xF6, 0x3B, 0xD1,
	0x19, 0x72, 0xE0, 0x44, 0x2C, 0xB4, 0xE4, 0xCA, 0x63, 0x71, 0x5F, 0xAF, 0xEC, 0x1B, 0x7D, 0xA7,
	0x43, 0xD1, 0x6B, 0xFC, 0x3D, 0xA2, 0xE9, 0xCE, 0x8F, 0x75, 0x98, 0xE8, 0x00, 0x39, 0x2E, 0x19,
	0xF5, 0x28, 0xF2, 0x74, 0x5F, 0x75, 0x18, 0x54, 0xD0, 0x25, 0x01, 0x5A, 0x5C, 0x59, 0xBB, 0x7A,
	0xFA, 0x35, 0x29, 0xE9, 0x29, 0x2C, 0x16, 0x4D, 0x5C, 0xD8, 0xD9, 0x0E, 0xEF, 0xEC, 0x54, 0x7B,
	0xFB, 0xF4, 0x60, 0x04, 0xD9, 0xC7, 0xF9, 0xCB, 0x46, 0x3C, 0xC8, 0x49, 0x50, 0x49, 0x96, 0xAE,
	0xD8, 0x2C, 0x8C, 0xEC, 0x90, 0xFA, 0x3A, 0xDE, 0x09, 0x3E, 0x66, 0x0E, 0x3F, 0x4D, 0x2A, 0x9D,
	0xFC, 0x96, 0xAB, 0x59, 0xC7, 0xE6, 0xA8, 0x85, 0xBB, 0x08, 0x69, 0x24, 0x19, 0x6D, 0xF0, 0xF5,
	0x65, 0x86, 0xC4, 0x8B, 0x92, 0x84, 0x2A, 0x29, 0x5E, 0x6B, 0x58, 0x7B, 0x50, 0x78, 0x2A, 0x92,
	0xBD, 0x29, 0x11, 0xA5, 0x4D, 0x70, 0x68, 0x5A, 0x11, 0x40, 0x4D, 0xD2, 0x61, 0xEC, 0x50, 0xAE,
	0xE2, 0xAF, 0x9C, 0x9E, 0x55, 0xE9, 0xEB, 0xF4, 0xDC, 0xCB, 0xF4, 0x30, 0xC9, 0xC0, 0x1B, 0xDE,
	0xA1, 0x2F, 0x91, 0xB9, 0x4F, 0xA6, 0x3E, 0x78, 0x7D, 0xED, 0xD8, 0x97, 0x2E, 0x64, 0x02, 0x51,
	0x90, 0xF8, 0xF7, 0xB1, 0x80, 0x3E, 0xD7, 0xE5, 0x6A, 0x3A, 0x7A, 0xC6, 0x62, 0x45, 0x4E, 0xAE,
	0x5F, 0xF4, 0xDC, 0x09, 0xAD, 0x78, 0x19, 0xC2, 0x3A, 0x02, 0x6B, 0xB0, 0xCF, 0x3A, 0x25, 0xFD,
	0x85, 0x66, 0x19, 0x91, 0x0F, 0xA2, 0xD2, 0x96, 0x21, 0xBF, 0xC7, 0x46, 0xE7, 0xC7, 0xC9, 0x8D,
	0xD8, 0x61, 0xB0, 0x0A, 0xC1, 0x29, 0xFB, 0x10, 0xEF, 0x49, 0x5C, 0xB8, 0xCB, 0xA9, 0x3D, 0x36,
	0xA3, 0xA0, 0x21, 0x97, 0x10, 0x46, 0xF8, 0x95, 0x3B, 0xC3, 0x06, 0xD6, 0x74, 0x7D, 0xAB, 0xB9,
	0x6F, 0xE8, 0xE1, 0xD1, 0xA5, 0x29, 0x76, 0x12, 0xEC, 0x14, 0x49, 0x0C, 0xE9, 0x88, 0x1C, 0x88,
	0x0F, 0x43, 0x56, 0xDE, 0x5A, 0x22, 0x26, 0x10, 0x89, 0xF2, 0xAC, 0x82, 0x53, 0x51, 0x61, 0x10,
	0x40, 0xD6, 0x02, 0x32, 0xE8, 0x83, 0x7E, 0x0E, 0xD6, 0xDD, 0x4B, 0x99, 0x51, 0x87, 0x4D, 0x19,
	0x7B, 0xD3, 0xFF, 0xBE, 0xC0, 0xB8, 0x18, 0x92, 0xDC, 0x22, 0x1B, 0x10, 0xEE, 0x74, 0xB2, 0xD1,
	0xE5, 0xE4, 0x8F, 0xDB, 0x81, 0xA7, 0xF2, 0x4C, 0x7B, 0x56, 0x35, 0x99, 0xFB, 0xF9, 0xCC, 0x1A,
	0xD9, 0x4D, 0x26, 0x36, 0x57, 0x18, 0x8D, 0x72, 0x67, 0xD8, 0xD0, 0x4B, 0x25, 0x48, 0xFC, 0x35,
	0xD8, 0x66, 0xF3, 0x1A, 0x45, 0xBB, 0xF5, 0x5A, 0xB5, 0x6A, 0x80, 0x40, 0x0D, 0xBC, 0xA2, 0xF4,
	0x9B, 0xBB, 0x00, 0x43, 0x40, 0x64, 0x26, 0xCE, 0x8C, 0x72, 0x4E, 0xC6, 0xC1, 0x31, 0x38, 0x27
};


text:
#include "hardware/clocks.h"
#include "hardware/gpio.h"
#include "hardware/pio.h"
#include "pins.h"
#include "pico/stdlib.h"
#include "glitch.h"
#include "misc.h"
#include "fuses.h"

bool mariko = true;
bool board_detected = false;

bool wait_for_boot(int timeout_ms) {
    absolute_time_t tio_full = make_timeout_time_ms(timeout_ms);
    absolute_time_t tio_cmd1 = tio_full;
    init_glitch_pio();
    reset_cpu();
    uint32_t word=0, last_word=0;
    bool was_read_zero = false;
    bool was_cmd1 = false;
    int reset_attempts = 0;

    while(!time_reached(tio_full)) {
        if (time_reached(tio_cmd1))
        {
            if (reset_attempts > 4)
            {
                halt_with_error(0, 3);
            }
            reset_attempts++;
            reset_cpu();
            tio_cmd1 = tio_full;
        }
        if(!pio_sm_is_rx_fifo_empty(pio1, 0))
        {
            word = pio_sm_get(pio1, 0);
            if (last_word == 0x41000000 && word == 0x00F9) // cmd1 request
            {
                tio_cmd1 = make_timeout_time_ms(20);
                was_cmd1 = true;
            }
            else if (last_word == 0x00F9 && (word >> 24) == 0x3F) // cmd1 responce
            {
                tio_cmd1 = tio_full;
            }
            else if (last_word == 0x51000000 && word == 0x0055) //read block 0
            {
                tio_full = make_timeout_time_ms(100);
                was_read_zero = true;
            } else if (was_read_zero && last_word == 0x4D000200 && word == 0x00B1) // read status - erista only
            {
                mariko = false;
            } else if (last_word == 0x51000000 && word == 0x0147) // read block 1, can finish now
            {
                deinit_glitch_pio();
                return true;
            }
            last_word = word;
        }
    }
    if (was_read_zero) {
        halt_with_error(1, 3);
    }
    else if (was_cmd1) {
        halt_with_error(2, 3);
    } else {
        halt_with_error(3, 3);
    }
    return false;
}


text:
bool wait_for_boot(int timeout_ms);

// type of NS is detected in wait_for_boot
extern bool mariko;