ESP32 and Arduino IDE tabs

Firstly I'm new to all this so please feel free to point me to the right forum if I have this wrong.
I have an ESP32 board and some other peripherals which I I hope to use for an internet radio. The board I have is here
The project I'm trying to use is here
I have tried a simple sketch just to see things working, this was a wifi scanner and worked perfectly so I have something right. The issue I'm having is when I save the 4 files in the same folder and then try to verify I get the following message.

"internet_radio_code:41:58: fatal error: helloMp3.h: No such file or directory
compilation terminated.
exit status 1
helloMp3.h: No such file or directory"

There are the 4 tabs in Arduino IDE I was expecting. Some if the includes are in red and the ones that dont work (including "hellomp3" and in black
Now I'm stuck and don't really know where to start. I would appreciate any help or pointers you can provide.

Many Thanks in advance
Mark

helloMp3.h is not the same as hellomp3.h

What is the exact name of the file ?

Please post your full sketch

Thank you for such a quick reply. I posted a link to the project page which has the sketch, I thought it easier and more accurate that way. is is HERE. Its an old project so I assume the originator has given up on it.

Please post your code copied from the IDE so that we can see exactly what you actually have rather than what you should have

Please follow the advice given in the link below when posting code, in particular the section entitled 'Posting code and common code problems'

Use code tags (the </> icon above the compose window) to make it easier to read and copy for examination

internet_radio_code.ino

// internet_radio.ino
/*
  internet radio; combined code from
  Simple_esp32_radio - https://www.hackster.io/mircemk/simple-esp32-internet-radio-with-oled-display-83e49d
  with
  ESP-radio-github - https://github.com/Edzelf/Esp-radio

  ESP32 libraries used:
  - ESP32 for Arduino - https://dl.espressif.com/dl/package_esp32_index.json (include in Menu | Preferences | Board managers)
  - Preferences       - https://github.com/espressif/arduino-esp32/blob/master/libraries/Preferences/src/Preferences.h
  - helloMp3.h        - included with code
  - radiostations.h   - included with code
  - WiFi.h            - WIFININA - to include via Library manager
  - HTTPClient.h      - https://github.com/espressif/arduino-esp32/blob/master/libraries/HTTPClient/src/HTTPClient.h
  - Adafruit_GFX      - https://github.com/adafruit/Adafruit-GFX-Library
  - Adafruit_ST7735.h - https://github.com/adafruit/Adafruit-ST7735-Library
  - SPI.h             - Part of ESP8266 Arduino default libraries.
  - Ticker.h          - https://github.com/sstaub/Ticker
  - esp_wifi.h        - https://github.com/madhephaestus/Esp32WifiManager
  - Arduino.h         - Part of ESP8266 Arduino default libraries.
  - IRremoteESP8266.h - https://github.com/esp8266/Basic/tree/master/libraries/IRremoteESP8266
  - IRrecv.h          - https://github.com/esp8266/Basic/tree/master/libraries/IRremoteESP8266
  - IRutils.h         - https://github.com/esp8266/Basic/tree/master/libraries/IRremoteESP8266
  - VS1053.h          - https://github.com/baldram/ESP_VS1053_Library/tree/master/src

  hardware
  - ESP32             - https://www.aliexpress.com/item/32799253567.html?spm=a2g0s.9042311.0.0.27424c4dLpU1BO
  - Rotary decoder    - https://www.aliexpress.com/item/32969404416.html?spm=a2g0s.9042311.0.0.27424c4dLpU1BO
  - IR set            - https://www.aliexpress.com/item/32859719981.html?spm=a2g0s.9042311.0.0.27424c4dLpU1BO
  - TFT display       - https://www.aliexpress.com/item/32817839166.html?spm=a2g0s.9042311.0.0.27424c4dLpU1BO
  - VS1053            - https://www.aliexpress.com/item/32966454016.html?spm=a2g0s.9042311.0.0.27424c4dLpU1BO

  If possible streaming info of artist and song title is shown. For some reason i've not been able to show this streaming information
  for all streams.....
  Please let me know if you are able to show more streaming info and I'd be honered if you will share the updated code with me!


*/


#include "hellomp3.h"       // to say 'Hello' to listener
#include "radiostations.h"  // all streaming channels used in this player
#include <Preferences.h>    //For reading and writing into the FLASH memory

// display
#include <Adafruit_GFX.h>    // Core graphics library
#include <Adafruit_ST7735.h> // Hardware-specific library
#include <SPI.h>
#include <Ticker.h>
// ESP32
#include <esp_wifi.h>
#include <WiFi.h>
#include <HTTPClient.h>
// IR
#include <Arduino.h>
#include <IRremoteESP8266.h>
#include <IRrecv.h>
#include <IRutils.h>
// This ESP_VS1053_Library
#include <VS1053.h>

Preferences preferences; // instance to acces NVRAM

bool DEBUG = false;  // if "true" all info will be shown in serial monitor; id "false" no info is shown on serial monitor

// Rotary Encoder start
const int PinSW = 5; // Rotary Encoder Switch
const int PinDT = 4;  // DATA signal
const int PinCLK = 2;  // CLOCK signal
// Variables to debounce Rotary Encoder start
long TimeOfLastDebounce = 0;
int DelayofDebounce = 0.01;
unsigned long previousMillisrotating = 0;
unsigned long previousMillispressed = 0;
unsigned long interval = 2000;
// Store previous Pins state
int PreviousCLK;
int PreviousDATA;
int rotary_step_counter = 0;
bool rotating = false;
bool pressed = false;
// Rotary Encoder end

// IR init start
unsigned long key_value = 0;
const uint16_t kRecvPin = 27; // An IR detector/demodulator is connected to GPIO pin 27
IRrecv irrecv(kRecvPin);
decode_results results;
unsigned long previousMillisIR = 0;
unsigned long IR_interval = 2000; // after 2 seconds no input : stop waiting and activate info received
bool IR_volume = false;
bool IR_station = false;
bool digitinput = false;
unsigned int IR_value, Nbr_chars;
//IR init end

// Display init start
// pin definition for ESP32 for display
// VCC - +5Volt
// Gnd - Gnd
#define TFT_CS   17
#define TFT_Rst  16
#define TFT_DC   15 // A0
// SDA - 23
// SCK - 18
// LED - backlight +5 Volt via Resistor
Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS,  TFT_DC, TFT_Rst);
// Display init end

// WiFi init start
//WiFi network info
char ssid[] = "hcg";    //  your network SSID (name)
char pass[] = "!!snapper123hans";   // your network password
String LocalIP = "";
int status = WL_IDLE_STATUS;
WiFiClient  client;
// WiFi init end

/* VS1053 player init start
  VS1053 - connections detail
  XRST = EN (D3)
  MISO = D19
  MOSI = D23
  SCLK = D18
  VCC = 5V / 3.3 V
  Gnd = Gnd
*/
// Wiring of VS1053 board (SPI connected in a standard way)
#define VS1053_CS    32 //32
#define VS1053_DCS   33  //33
#define VS1053_DREQ  35 //15
uint8_t mp3buff[32];   // vs1053 likes 32 bytes at a time
VS1053 player(VS1053_CS, VS1053_DCS, VS1053_DREQ);
int my_volume = 75; // volume level 0-100
// VS1053 init end

// data definitions for getting radio data and playing it start
#define RINGBFSIZ 20000                                     // Ringbuffer for smooth playing. 20000 bytes is 160 Kbits, about 1.5 seconds at 128kb bitrate.
uint8_t*         ringbuf ;                                  // Ringbuffer for VS1053
uint16_t         rbwindex = 0 ;                             // Fill pointer in ringbuffer
uint16_t         rbrindex = RINGBFSIZ - 1 ;                 // Emptypointer in ringbuffer
uint16_t         rcount = 0 ;                               // Number of bytes in ringbuffer

String           icystreamtitle ;                           // Streamtitle from metadata
String           icyname ;                                  // Icecast station name

enum datamode_t { INIT = 1, HEADER = 2, DATA = 4,
                  METADATA = 8, NoMETA = 16,
                  PLAYLISTHEADER = 32, PLAYLISTDATA = 64,
                  STOPREQD = 128, STOPPED = 256
                } ;          // State for datastream
datamode_t       datamode ;                                 // State of datastream
bool             chunked = false ;                          // Station provides chunked transfer
int              chunkcount = 0 ;                           // Counter for chunked transfer
int              metaint = 0 ;                              // Number of databytes between metadata
int              bitrate ;                                  // Bitrate in kb/sec
uint32_t         totalcount = 0 ;                           // Counter mp3 data
String           metaline ;                                 // Readable line in metadata
int              datacount ;                                // Counter databytes before metadata
int              metacount ;                                // Number of bytes in metadata
int8_t           playlist_num = 0 ;                         // Nonzero for selection from playlist
char             newstreamtitle[150] = "";                  // storeStreamtitle from metadata
Ticker           tckr ;                                    // For timing 100 msec

int radioStation, old_radioStation, new_radioStation;
// data definitions for getting radio data and playing it end

// start music code
// Ringbuffer code start
//******************************************************************************************
// Ringbuffer (fifo) routines.                                                             *
//******************************************************************************************
//******************************************************************************************
//                              R I N G S P A C E                                          *
//******************************************************************************************
inline bool ringspace()
{
  return ( rcount < RINGBFSIZ ) ;     // True is at least one byte of free space is available
}

//******************************************************************************************
//                              R I N G A V A I L                                          *
//******************************************************************************************
inline uint16_t ringavail()
{
  return rcount ;                     // Return number of bytes available
}

//******************************************************************************************
//                                P U T R I N G                                            *
//******************************************************************************************
void putring ( uint8_t b )                 // Put one byte in the ringbuffer
{
  // No check on available space.  See ringspace()
  *(ringbuf + rbwindex) = b ;         // Put byte in ringbuffer
  if ( ++rbwindex == RINGBFSIZ )      // Increment pointer and
  {
    rbwindex = 0 ;                    // wrap at end
  }
  rcount++ ;                          // Count number of bytes in the ringbuffer
}

//******************************************************************************************
//                                G E T R I N G                                            *
//******************************************************************************************
uint8_t getring()
{
  // Assume there is always something in the bufferpace.  See ringavail()
  if ( ++rbrindex == RINGBFSIZ )      // Increment pointer and
  {
    rbrindex = 0 ;                    // wrap at end
  }
  rcount-- ;                          // Count is now one less
  return *(ringbuf + rbrindex) ;      // return the oldest byte
}

//******************************************************************************************
//                               E M P T Y R I N G                                         *
//******************************************************************************************
void emptyring()
{
  rbwindex = 0 ;                      // Reset ringbuffer administration
  rbrindex = RINGBFSIZ - 1 ;
  rcount = 0 ;
}
// Ringbuffer code end

// data evaluation to find streaming info and play music start
//******************************************************************************************
//                            C H K H D R L I N E                                          *
//******************************************************************************************
// Check if a line in the header is a reasonable headerline.                               *
// Normally it should contain something like "icy-xxxx:abcdef".                            *
//******************************************************************************************
bool chkhdrline ( const char* str )
{
  char    b ;                                         // Byte examined
  int     len = 0 ;                                   // Lengte van de string

  while ( ( b = *str++ ) )                            // Search to end of string
  {
    len++ ;                                           // Update string length
    if ( ! isalpha ( b ) )                            // Alpha (a-z, A-Z)
    {
      if ( b != '-' )                                 // Minus sign is allowed
      {
        if ( b == ':' )                               // Found a colon?
        {
          return ( ( len > 5 ) && ( len < 50 ) ) ;    // Yes, okay if length is okay
        }
        else
        {
          return false ;                              // Not a legal character
        }
      }
    }
  }
  return false ;                                      // End of string without colon
}

//******************************************************************************************
//                           H A N D L E B Y T E _ C H                                     *
//******************************************************************************************
// Handle the next byte of data from server.                                               *
// Chunked transfer encoding aware. Chunk extensions are not supported.                    *
//******************************************************************************************
void handlebyte_ch ( uint8_t b, bool force )
{
  static int  chunksize = 0 ;                         // Chunkcount read from stream

  if ( chunked && !force &&
       ( datamode & ( DATA |                          // Test op DATA handling
                      METADATA |
                      PLAYLISTDATA ) ) )
  {
    if ( chunkcount == 0 )                            // Expecting a new chunkcount?
    {
      if ( b == '\r' )                               // Skip CR
      {
        return ;
      }
      else if ( b == '\n' )                          // LF ?
      {
        chunkcount = chunksize ;                     // Yes, set new count
        chunksize = 0 ;                              // For next decode
        return ;
      }
      // We have received a hexadecimal character.  Decode it and add to the result.
      b = toupper ( b ) - '0' ;                      // Be sure we have uppercase
      if ( b > 9 )
      {
        b = b - 7 ;                                  // Translate A..F to 10..15
      }
      chunksize = ( chunksize << 4 ) + b ;
    }
    else
    {
      handlebyte ( b, force ) ;                       // Normal data byte
      chunkcount-- ;                                  // Update count to next chunksize block
    }
  }
  else
  {
    handlebyte ( b, force ) ;                         // Normal handling of this byte
  }
}

//******************************************************************************************
//                           H A N D L E B Y T E                                           *
//******************************************************************************************
// Handle the next byte of data from server.                                               *
// This byte will be send to the VS1053 most of the time.                                  *
// Note that the buffer the data chunk must start at an address that is a muttiple of 4.   *
// Set force to true if chunkbuffer must be flushed.                                       *
//******************************************************************************************
void handlebyte ( uint8_t b, bool force )
{
  static uint16_t  playlistcnt ;                       // Counter to find right entry in playlist
  static bool      firstmetabyte ;                     // True if first metabyte (counter)
  static int       LFcount ;                           // Detection of end of header
  static __attribute__((aligned(4))) uint8_t buf[32] ; // Buffer for chunk
  static int       bufcnt = 0 ;                        // Data in chunk
  static bool      firstchunk = true ;                 // First chunk as input
  String           lcml ;                              // Lower case metaline
  String           ct ;                                // Contents type
  static bool      ctseen = false ;                    // First line of header seen or not
  int              inx ;                               // Pointer in metaline
  int              i ;                                 // Loop control

  if ( datamode == INIT )                              // Initialize for header receive
  {
    ctseen = false ;                                   // Contents type not seen yet
    metaint = 0 ;                                      // No metaint found
    LFcount = 0 ;                                      // For detection end of header
    bitrate = 0 ;                                      // Bitrate still unknown
    if (DEBUG == true) Serial.println ( "Switch to HEADER" ) ;
    datamode = HEADER ;                                // Handle header
    totalcount = 0 ;                                   // Reset totalcount
    metaline = "" ;                                    // No metadata yet
    firstchunk = true ;                                // First chunk expected
  }
  if ( datamode == DATA )                              // Handle next byte of MP3/Ogg data
  {
    buf[bufcnt++] = b ;                                // Save byte in chunkbuffer
    if ( bufcnt == sizeof(buf) || force )              // Buffer full?
    {
      if ( firstchunk )
      {
        firstchunk = false ;
        if (DEBUG == true) {
          Serial.println ( "First chunk:" ) ;            // Header for printout of first chunk
          for ( i = 0 ; i < 32 ; i += 8 )                // Print 4 lines
          { Serial.printf ( "%02X %02X %02X %02X %02X %02X %02X %02X",
                            buf[i], buf[i + 1], buf[i + 2], buf[i + 3],
                            buf[i + 4], buf[i + 5], buf[i + 6], buf[i + 7] ) ;
            Serial.println ("");
          }
        }
      }
      player.playChunk ( buf, bufcnt ) ;               // Yes, send to player
      bufcnt = 0 ;                                     // Reset count
    }
    totalcount++ ;                                     // Count number of bytes, ignore overflow
    if ( metaint != 0 )                                // No METADATA on Ogg streams or mp3 files
    {
      if ( --datacount == 0 )                          // End of datablock?
      {
        if ( bufcnt )                                  // Yes, still data in buffer?
        {
          player.playChunk ( buf, bufcnt ) ;           // Yes, send to player
          bufcnt = 0 ;                                 // Reset count
        }
        if (DEBUG == true)  Serial.println ( "Switch to METADATA" ) ;
        datamode = METADATA ;
        firstmetabyte = true ;                         // Expecting first metabyte (counter)
      }
    } else {
      if (DEBUG == true)  Serial.println("Switching to NoMeta");
      datamode = NoMETA;
      station_connect(radioStation);
    }
    return ;
  }
  if ( datamode == HEADER )                            // Handle next byte of MP3 header
  {
    if ( ( b > 0x7F ) ||                               // Ignore unprintable characters
         ( b == '\r' ) ||                              // Ignore CR
         ( b == '\0' ) )                               // Ignore NULL
    {
      // Yes, ignore
    }
    else if ( b == '\n' )                              // Linefeed ?
    {
      LFcount++ ;                                      // Count linefeeds

      if ( chkhdrline ( metaline.c_str() ) )           // Reasonable input?
      {
        lcml = metaline ;                              // Use lower case for compare
        lcml.toLowerCase() ;
        if (DEBUG == true) {
          Serial.println("metaline :");
          Serial.printf ( metaline.c_str() ) ;           // Yes, Show it
          Serial.println("");
        }
        if ( lcml.indexOf ( "content-type" ) >= 0 )    // Line with "Content-Type: xxxx/yyy"
        {
          ctseen = true ;                              // Yes, remember seeing this
          ct = metaline.substring ( 14 ) ;             // Set contentstype. Not used yet
          if (DEBUG == true) {
            Serial.printf ( "%s seen.", ct.c_str() ) ;
            Serial.println("");
          }
        }
        if ( lcml.startsWith ( "icy-br:" ) )
        {
          bitrate = metaline.substring(7).toInt() ;    // Found bitrate tag, read the bitrate
          if ( bitrate == 0 )                          // For Ogg br is like "Quality 2"
          {
            bitrate = 87 ;                             // Dummy bitrate
          }
        }
        else if ( lcml.startsWith ( "icy-metaint:" ) )
        {
          metaint = metaline.substring(12).toInt() ;   // Found metaint tag, read the value
        }
        else if ( lcml.startsWith ( "icy-name:" ) )
        {
          icyname = metaline.substring(9) ;            // Get station name
          icyname.trim() ;                             // Remove leading and trailing spaces
          if (DEBUG == true) {
            Serial.println(icyname);
            Serial.println("");
          }
        }
        else if ( lcml.startsWith ( "transfer-encoding:" ) )
        {
          // Station provides chunked transfer
          if ( lcml.endsWith ( "chunked" ) )
          {
            chunked = true ;                           // Remember chunked transfer mode
            chunkcount = 0 ;                           // Expect chunkcount in DATA
          }
        }
      }
      metaline = "" ;                                  // Reset this line
      if ( ( LFcount == 2 ) && ctseen )                // Some data seen and a double LF? ( ( LFcount == 2 ) && ctseen )
      {
        if (DEBUG == true) {
          Serial.printf ( "Switch to DATA, bitrate is %d"     // Show bitrate
                          ", metaint is %d",                  // and metaint
                          bitrate, metaint ) ;
          Serial.println("");
        }
        datamode = DATA ;                              // Expecting data now
        datacount = metaint ;                          // Number of bytes before first metadata
        bufcnt = 0 ;                                   // Reset buffer count
        player.startSong() ;                           // Start a new song
      }
    }
    else
    {
      metaline += (char)b ;                            // Normal character, put new char in metaline
      LFcount = 0 ;                                    // Reset double CRLF detection
    }
    return ;
  }
  if ( datamode == METADATA )                          // Handle next byte of metadata
  {
    if ( firstmetabyte )                               // First byte of metadata?
    {
      firstmetabyte = false ;                          // Not the first anymore
      metacount = b * 16 + 1 ;                         // New count for metadata including length byte
      if ( metacount > 1 )
      {
        if (DEBUG == true)  Serial.printf ( "Metadata block %d bytes",
                                              metacount - 1 ) ;                   // Most of the time there are zero bytes of metadata
      }
      metaline = "" ;                                  // Set to empty
    }
    else
    {
      metaline += (char)b ;                            // Normal character, put new char in metaline
    }
    if ( --metacount == 0 )
    {
      if ( metaline.length() )                         // Any info present?
      {
        // metaline contains artist and song name.  For example:
        // "StreamTitle='Don McLean - American Pie';StreamUrl='';"
        // Sometimes it is just other info like:
        // "StreamTitle='60s 03 05 Magic60s';StreamUrl='';"
        // Isolate the StreamTitle, remove leading and trailing quotes if present.
        showstreamtitle ( metaline.c_str(), false ) ;        // Show artist and title if present in metadata
      }
      if ( metaline.length() > 1500 )                  // Unlikely metaline length?
      {
        if (DEBUG == true)  Serial.printf ( "Metadata block too long! Skipping all Metadata from now on." ) ;
        metaint = 0 ;                                  // Probably no metadata
        metaline = "" ;                                // Do not waste memory on this
      }
      datacount = metaint ;                            // Reset data count
      bufcnt = 0 ;                                     // Reset buffer count
      if (DEBUG == true) Serial.println ( "Switch to DATA" ) ;
      datamode = DATA ;                                // Expecting data
    }
  }
}
// end song tilte code

//******************************************************************************************
//                                  T I M E R 1 0 S E C                                    *
//******************************************************************************************
// Extra watchdog.  Called every 10 seconds.                                               *
// If totalcount has not been changed, there is a problem and playing will stop.           *
// Note that a "yield()" within this routine or in called functions will cause a crash!    *
//******************************************************************************************
void timer10sec()
{
  static uint32_t oldtotalcount = 7321 ;          // Needed foor change detection
  static uint8_t  morethanonce = 0 ;              // Counter for succesive fails
  static uint8_t  t600 = 0 ;                      // Counter for 10 minutes
  if (DEBUG == true) Serial.println("timer10sec");

  if ( datamode & ( INIT | HEADER | DATA |        // Test op playing
                    METADATA | NoMETA ) )
  {
    if ( totalcount == oldtotalcount )            // Still playing?
    {
      if (DEBUG == true) Serial.println ( "No data input" ) ;              // No data detected!
      if ( morethanonce > 10 )                    // Happened too many times?
      {
        if (DEBUG == true) Serial.println ( "Going to restart connection" ) ;
        datamode = INIT ;
        station_connect(radioStation);
        if (DEBUG == true) Serial.println ( "Switch to INIT" ) ;

      }
      morethanonce++ ;                            // Count the fails
    }
    else
    {
      if ( morethanonce )                         // Recovered from data loss?
      {
        if (DEBUG == true) Serial.println ( "Recovered from dataloss" ) ;
        morethanonce = 0 ;                        // Data see, reset failcounter
      }
      oldtotalcount = totalcount ;                // Save for comparison in next cycle
    }
    if ( t600++ == 60 )                           // 10 minutes over?
    {
      t600 = 0 ;                                  // Yes, reset counter
      if (DEBUG == true) Serial.println ( "10 minutes over" ) ;
      //      publishIP() ;                               // Re-publish IP
    }
  }
}
// data evaluation to find streaming info and play music end

void setup () {
  // Start display
  tft.initR(INITR_BLACKTAB);   // initialize a ST7735S chip, black tab
  tft.fillScreen(ST7735_BLACK);
  tft.setRotation(1);
  display_Title();
  // rotary decoder
  pinMode (PinCLK, INPUT_PULLUP);                  // Set pinA (Clk) as input
  pinMode (PinDT, INPUT_PULLUP);                   // Set pinB as input
  // Put current pins state in variables
  PreviousCLK = digitalRead(PinCLK);
  PreviousDATA = digitalRead(PinDT);
  // Set the Switch pin to use Arduino PULLUP resistors
  pinMode(PinSW, INPUT_PULLUP);

  // IR Start
  irrecv.enableIRIn();  // Start the receiver
  // IR end

  // play part buffer and timer initialisation
  ringbuf = (uint8_t *) malloc ( RINGBFSIZ ) ;         // Create ring buffer
  tckr.attach ( 10.0, timer10sec ) ;                   // Every 10 sec

  // start serial port
  Serial.begin(115200);

  // get data from ESP NVRAM
  preferences.begin("my-app", false);
  radioStation = preferences.getUInt("radioStation", 0);
  my_volume    = preferences.getUInt("Volume", 70);

  // initialize SPI bus;
  SPI.begin();

  // initialize VS1053 player
  player.begin();
  //    player.switchToMp3Mode(); // optional, some boards require this
  player.setVolume(my_volume);

  // connect tot FiFi
  WiFi.begin(ssid, pass);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    if (DEBUG == true)  Serial.print(".");
  }
  if (DEBUG == true) {
    Serial.println("WiFi connected");
    Serial.print("IP address:");
  }
  LocalIP = WiFi.localIP().toString();
  if (DEBUG == true) Serial.println(LocalIP);
  display_Connectto();
  displayIP();
  display_Volume(my_volume);

  // store staion for later reference
  old_radioStation = radioStation;
  if (DEBUG == true)  Serial.printf("Current radioStation value: %u\n", radioStation);
  delay(100);
  // play 'HELLO' text
  player.playChunk(hello2, sizeof(hello2)); //VS1053 is wake up & running
  // connect to stored station
  if (DEBUG == true) Serial.println ( "Switch to INIT" ) ;
  datamode = INIT ;
  station_connect(radioStation);
  display_Station(radioStation);
}

// update radiostation after new input from IR or rotary decoder
void change_radiostation() {
  new_radioStation = radioStation;
  if (old_radioStation != new_radioStation) {
    if (DEBUG == true) {
      Serial.printf("Set radioStation to new_value: %u\n", radioStation);
      Serial.println ( "Switch to INIT" ) ;
    }
    player.softReset();
    datamode = INIT ;
  }
  station_connect(new_radioStation);
  preferences.putUInt("radioStation", new_radioStation); // save station in nvram
  display_Station(new_radioStation);
  old_radioStation = new_radioStation;
}

// update volume after new input from IR or rotary decoder
void change_volume() {
  player.setVolume(my_volume);
  if (DEBUG == true)  Serial.printf("Volume: %u\n", my_volume);
  preferences.putUInt("Volume", my_volume);
  display_Volume(my_volume);
  player.startSong();
}

// rotary extra code start
// update display information on volume or station after IR or rotary switch change
void update_vol_or_station() {
  if (rotating != true) {
    rotating = true;
    if (DEBUG == true) Serial.println("rotating = true");
    if (pressed != true) rotary_step_counter = radioStation;
  }
  previousMillisrotating = millis();
  if (pressed == true) {
    previousMillispressed = millis();
    if (rotary_step_counter >= 101) rotary_step_counter = 100;
    if (rotary_step_counter <= 0) rotary_step_counter = 0;
    if (DEBUG == true) {
      Serial.print("Volume = ");
      Serial.println(rotary_step_counter);
    }
    display_Volume(rotary_step_counter);
  } else {
    if (rotary_step_counter == nbrStations) rotary_step_counter = 0;
    if (rotary_step_counter <= -1) rotary_step_counter = nbrStations - 1;
    if (DEBUG == true) {
      Serial.print("Station = ");
      Serial.println(rotary_step_counter);
    }
    display_Station(rotary_step_counter);
  }
}

// Check if Rotary Encoder was moved
void check_rotary() {
  if ((PreviousCLK == 0) && (PreviousDATA == 1)) {
    if ((digitalRead(PinCLK) == 1) && (digitalRead(PinDT) == 0)) {
      rotary_step_counter++;
      update_vol_or_station();
    }
    if ((digitalRead(PinCLK) == 1) && (digitalRead(PinDT) == 1)) {
      rotary_step_counter--;
      update_vol_or_station();
    }
  }
  if ((PreviousCLK == 1) && (PreviousDATA == 1)) {
    if ((digitalRead(PinCLK) == 0) && (digitalRead(PinDT) == 1)) {
      rotary_step_counter++;
      update_vol_or_station();
    }
    if ((digitalRead(PinCLK) == 0) && (digitalRead(PinDT) == 0)) {
      rotary_step_counter--;
      update_vol_or_station();
    }
  }
}
// rotary extra code end

// IR code start
// show debug info on serial monitor
void check_for_input() {
  if (IR_value >= 0) {
    if (IR_volume == true) {
      if (DEBUG == true) {
        Serial.print("Volume update naar : ");
        Serial.println(IR_value);
      }
    }
    if (IR_station == true) {
      if (DEBUG == true) {
        Serial.print("Station update naar : ");
        Serial.println(IR_value);
      }
    }
  }
}

// if IR receives digit ('0' .. '9') without leading '#' or '*' act on it as input for volume
void setdigitinput() {
  previousMillisIR  = millis();
  if (DEBUG == true) Serial.println("IR actief zonder keuze -> volume");
  IR_volume = true;
  digitinput = true;
  IR_value = 0;
  Nbr_chars = 0;
  display_Volume(my_volume);
}

// Set volume to new value in player
void Update_volume() {
  if (DEBUG == true) {
    Serial.println("Update_volume()");
    Serial.print("Volume update naar : ");
    Serial.println(my_volume);
  }
  change_volume();
}

// Set station to new value in player
void Update_Station() {
  if (DEBUG == true) {
    Serial.println("Update_Station()");
    Serial.print("Station update naar : ");
    Serial.println(radioStation);
  }
  change_radiostation();
}
// IR code end

void process_IR_Digit(int digit) {
  if (DEBUG == true) {
    Serial.print("digit 1 : ");
    Serial.println(digit);
    Serial.print("Nbr_chars 1 : ");
    Serial.println(Nbr_chars);
  }
  if (Nbr_chars == 0) {
    Serial.println("clear IR_Value and my_volume; volume was set to 100 and new input was detected; so we start over again ");
    IR_value = 0;
    my_volume = 0;
  }
  if (DEBUG == true) {
    Serial.print("digit 2 : ");
    Serial.println(digit);
    Serial.print("Nbr_chars 2 : ");
    Serial.println(Nbr_chars);
  }
  if ((IR_volume == false) && (IR_station == false)) {
    if (DEBUG == true) {
      Serial.println(" - setdigitinput");
      Serial.println(digit);
    }
    setdigitinput();
  }
  if (Nbr_chars = 0) {
    IR_value = digit;
    Nbr_chars++;
  } else {
    if (Nbr_chars = 1) {
      IR_value = 10 * IR_value + digit;
      Nbr_chars++;
    }
  }
}

void loop() {
  // IR code start
  unsigned long currentMillis = millis();
  if ( (IR_volume == true) || (IR_station == true)) {
    if (currentMillis - previousMillisIR >= IR_interval) {
      if (DEBUG == true) Serial.println("currentMillis - previousMillisIR >= IR_interval");
      if (digitinput == true) {
        check_for_input();
        if (IR_volume == true) {
          my_volume = IR_value;
        } else {
          radioStation = IR_value;
        }
      }
      IR_value = 0;
      Nbr_chars = 0;
      digitinput = false;
      if (DEBUG == true) {
        Serial.println("Took to long after last key input; use input end start waiting for new input on IR");
        Serial.print("Volume 0 : ");
        Serial.println(my_volume);
        Serial.print("Radiostation 0 : ");
        Serial.println(radioStation);
      }
      if (IR_volume == true) {
        Update_volume();
      }
      if (IR_station == true) {
        Update_Station();
      }
      IR_volume = false;
      IR_station = false;
    }
  }
  if (irrecv.decode(&results)) {
    if (results.value == 0XFFFFFFFF) // repeat
      results.value = key_value;
    previousMillisIR  = millis();
    switch (results.value) {
      case 0xFF38C7:  // OK pressed; activate value entered to player
        if (DEBUG == true) Serial.println("OK");
        if (digitinput == true) {
          if (DEBUG == true) {
            Serial.print("OK : ");
            Serial.println(IR_value);
          }
          check_for_input();
          if (IR_volume == true) {
            my_volume = IR_value;
          } else {
            radioStation = IR_value;
          }
        }
        digitinput = false;
        IR_value = 0;
        Nbr_chars = 0;
        if (DEBUG == true) {
          Serial.println("Update IR data to player");
          Serial.print("Volume 1 : ");
          Serial.println(my_volume);
          Serial.print("Radiostation 1 : ");
          Serial.println(radioStation);
        }
        if (IR_volume == true) {
          Update_volume();
        }
        if (IR_station == true) {
          Update_Station();
        }
        IR_volume = false;
        IR_station = false;
        break ;
      case 0xFF18E7:
        if (DEBUG == true) Serial.println("Volume Up (Up)");
        IR_volume = true;
        digitinput = false;
        my_volume++;
        if (my_volume >= 101) my_volume = 100;
        if (DEBUG == true)  {
          Serial.print("Volume 2 : ");
          Serial.println(my_volume);
        }
        display_Volume(my_volume);
        break ;
      case 0xFF10EF:
        if (DEBUG == true) Serial.println("Station terug (Left)");
        IR_station = true;
        digitinput = false;
        radioStation--;
        if (radioStation < 0) {
          radioStation = nbrStations - 1;
        }
        display_Station(radioStation);
        break ;
      case 0xFF5AA5:
        if (DEBUG == true) Serial.println("Station vooruit (Right)");
        IR_station = true;
        digitinput = false;
        radioStation++;
        if (radioStation >= nbrStations) radioStation = 0;
        if (DEBUG == true) {
          Serial.print("Radiostation 3 : ");
          Serial.println(radioStation);
        }
        display_Station(radioStation);
        break ;
      case 0xFF4AB5:
        if (DEBUG == true) Serial.println("Volume Down (Down)");
        IR_volume = true;
        digitinput = false;
        my_volume--;
        if (my_volume < 0) my_volume = 0;
        if (DEBUG == true) {
          Serial.print("Volume 3 : ");
          Serial.println(my_volume);
        }
        display_Volume(my_volume);
        break ;
      case 0xFFA25D:
        process_IR_Digit(1);
        break;
      case 0xFF629D:
        process_IR_Digit(2);
        break;
      case 0xFFE21D:
        process_IR_Digit(3);
        break;
      case 0xFF22DD:
        process_IR_Digit(4);
        break;
      case 0xFF02FD:
        process_IR_Digit(5);
        break ;
      case 0xFFC23D:
        process_IR_Digit(6);
        break ;
      case 0xFFE01F:
        process_IR_Digit(7);
        break ;
      case 0xFFA857:
        process_IR_Digit(8);
        break ;
      case 0xFF906F:
        process_IR_Digit(9);
        break ;
      case 0xFF9867:
        process_IR_Digit(0);
        break ;
      case 0xFF6897:
        if (DEBUG == true) Serial.println("* - volume");
        if ((IR_volume == false) && (IR_station == false)) {
          if (DEBUG == true) {
            Serial.println(" - setdigitinput");
            Serial.println("*");
          }
          setdigitinput();
        }
        IR_volume = true;
        IR_station = false;
        IR_value = 0;
        Nbr_chars = 0;
        display_Volume(my_volume);
        break ;
      case 0xFFB04F:
        if (DEBUG == true) Serial.println("# - station");
        if ((IR_volume == false) && (IR_station == false)) {
          if (DEBUG == true) {
            Serial.println(" - setdigitinput");
            Serial.println("#");
          }
          setdigitinput();
        }
        IR_volume = false;
        IR_station = true;
        IR_value = 0;
        Nbr_chars = 0;
        display_Station(radioStation);
        break ;
    }
    // do check on entered data to keep it in right value 0 <-> 100 for volume; 0 <-> nbrStations-1 for stations and update player
    if (digitinput == true) {
      if (DEBUG == true) {
        Serial.print("IR_value 1 : ");
        Serial.println(IR_value);
      }
      if (IR_station == true) {
        if (DEBUG == true) Serial.println("IR_station == true");
        if (IR_value >= nbrStations) {
          if (DEBUG == true) Serial.println("IR_value >= nbrStations");
          IR_value = 0;
        } else {
          if (IR_value < 0) {
            if (DEBUG == true) Serial.println("IR_value < 0");
            IR_value = nbrStations - 1;
          }
        }
        radioStation = IR_value;
        if (DEBUG == true)  {
          Serial.print("Radiostation 2 : ");
          Serial.println(radioStation);
        }
        display_Station(radioStation);
      }
      if (IR_volume == true) {
        if (DEBUG == true) Serial.println("IR_volume == true");
        if (IR_value > 100) {
          if (DEBUG == true) Serial.println("IR_value > 100");
          IR_value = 100;
          Nbr_chars = 0;
        } else {
          if (IR_value < 0) {
            if (DEBUG == true) Serial.println("IR_value < 0");
            IR_value = 0;
          }
        }
        my_volume = IR_value;
        if (DEBUG == true) {
          Serial.print("Volume 4 : ");
          Serial.println(my_volume);
        }
        display_Volume(my_volume);
      }
    }
    key_value = results.value;
    delay(100);
    irrecv.resume();
  }
  // IR code end

  // rotary decoder code start
  currentMillis = millis(); // get actual time for rotary routines
  if (pressed == true) {
    if (currentMillis - previousMillispressed >= interval) {
      // volume aanpassen
      my_volume = rotary_step_counter;
      pressed = false;
      rotating = false;
      if (DEBUG == true) Serial.println("pressed = false");
      change_volume();
    }
  }
  if (rotating == true) {
    if (currentMillis - previousMillisrotating >= interval) {
      // station aanpassen
      radioStation = rotary_step_counter;
      rotating = false;
      if (DEBUG == true) Serial.println("rotating = false");
      change_radiostation();
    }
  }
  // If enough time has passed check the rotary encoder
  if ((millis() - TimeOfLastDebounce) > DelayofDebounce) {
    check_rotary();  // Rotary Encoder check routine below
    PreviousCLK = digitalRead(PinCLK);
    PreviousDATA = digitalRead(PinDT);
    TimeOfLastDebounce = millis(); // Set variable to current millis() timer
  }
  // Check if Rotary Encoder switch was pressed
  if (digitalRead(PinSW) == LOW) {
    if ((pressed == false) && (rotating == false)) {
      pressed = true;
      previousMillispressed = millis();
      if (DEBUG == true) {
        Serial.println("pressed = true");
        Serial.println(my_volume);
      }
      display_Volume(my_volume);
      rotary_step_counter = my_volume;
    }
  }
  // rotary decoder code end

  // get next data from stream and put it in the ringbuffer
  uint32_t maxfilechunk  ;                           // Max number of bytes to read from stream
  static __attribute__((aligned(4))) uint8_t buf[32] ;  // Buffer for chunk
  // Try to keep the ringbuffer filled up by adding as much bytes as possible
  if ( datamode & ( INIT | HEADER | DATA |               // Test op playing
                    METADATA | NoMETA ) )
  {
    while ( (client.available() > 0) && ringspace()) // && maxfilechunk-- )
    {
      //uint8_t* b;
      uint8_t bytesread = client.read(mp3buff, 1);
      putring ( mp3buff[0] ) ;                // Yes, store one byte in ringbuffer
      yield() ;
    }
    yield() ;
  }
  // send data to player if player needs data and there is data availible in the ringbuffer
  while ( player.data_request() && ringavail() ) // Try to keep VS1053 filled
  {
    if (datamode != NoMETA) {
      handlebyte_ch ( getring(), false ) ;                      // Yes, handle it
    } else {
      int i = 0;
      while ((i != 32) && ringavail() ) {
        buf[i++] = getring() ;
      }
      player.playChunk ( buf, i ) ;
      //yield() ;
      totalcount++ ;                                     // Count number of bytes, ignore overflow
    }
  }
}

// connect to streaming station
void station_connect (int station_no ) {
  if (client.connect(host[station_no], port[station_no]) ) {
    if (DEBUG == true) Serial.println("Connected now");
  }
  client.print("GET / HTTP/1.1\r\n"); //Send the Header to the Server.
  client.print("\r\n");
  delay(500);
  if (DEBUG == true) {
    Serial.print(host[station_no]);
    Serial.println (path[station_no]);
  }
  if (datamode == NoMETA) {
    if (DEBUG == true) Serial.println("Zonder Icy data");
    client.print(String("GET ") + path[station_no] + " HTTP/1.1\r\n" +
                 "Host: " + host[station_no] + "\r\n" +
                 "Connection: close\r\n\r\n");
  } else {
    if (DEBUG == true) Serial.println("Met Icy data");
    client.print(String("GET ") + path[station_no] + " HTTP/1.1\r\n" +
                 "Host: " + host[station_no] + "\r\n" +
                 String ( "icy-metadata:1\r\n" ) +
                 "Connection: close\r\n\r\n");
    //String ( "Icy-MetaData:1\r\n" ) +
  }
  newstreamtitle[0] = '\0';                // make sure we show who is playing
}

// display "title" on display
void display_Title() {
  displayinfoString ( "Internet radio V.1.0", 22, 5, 8, ST7735_MAGENTA ) ;  // Program title
}

// display "WiFi SSID" on display
void display_Connectto() {
  displayinfoString ( "WiFiNW:", 5, 17, 8, ST7735_YELLOW ) ; // Label
  displayinfoString ( ssid, 50, 17, 8, ST7735_GREEN ) ; // SSID
}

// display "IP-address" on display
void displayIP() {
  displayinfoString ( "IP    :", 5, 29, 8, ST7735_YELLOW ) ;
  displayinfoString ( LocalIP, 50, 29, 8, ST7735_GREEN ) ;
}

// display "station connected to" on display
void display_Station(int station) {
  clear_Playing_area();
  displayinfoString("Zender:", 5, 41, 8, ST7735_YELLOW);
  displayinfoString(sname[station], 50, 41, 8, ST7735_GREEN);
}

// display "volume" on display
void display_Volume(int volume) {
  displayinfoString("Volume:", 5, 53, 8, ST7735_YELLOW);
  char myStg[10];
  sprintf(myStg, "%d", volume);
  displayinfoString(myStg, 50, 53, 8, ST7735_GREEN);
}

// clear area used to diaplay artist and song tilte when changing stations
void clear_Playing_area() {
  // clear space below 'Playing' line in case artist + song title use more thant 1 line
  displayinfoString ( " ", 0, 62, 100, ST7735_YELLOW ) ;  // clear line
}

// display artist and song title
void display_Streamtitle(char streamtitle[150]) {
  clear_Playing_area();
  // display artist + song title
  displayinfoString ( "Playing:", 5, 65, 8, ST7735_YELLOW ) ;  // Label
  displayinfo ( streamtitle, 55, 65, 8, ST7735_GREEN ) ;   // Show title
}


//******************************************************************************************
//                              U T F 8 A S C I I                                          *
//******************************************************************************************
// UTF8-Decoder: convert UTF8-string to extended ASCII.                                    *
// Convert a single Character from UTF8 to Extended ASCII.                                 *
// Return "0" if a byte has to be ignored.                                                 *
//******************************************************************************************
byte utf8ascii ( byte ascii )
{
  static const byte lut_C3[] =
  { "AAAAAAACEEEEIIIIDNOOOOO#0UUUU###aaaaaaaceeeeiiiidnooooo##uuuuyyy" } ;
  static byte       c1 ;              // Last character buffer
  byte              res = 0 ;         // Result, default 0

  if ( ascii <= 0x7F )                // Standard ASCII-set 0..0x7F handling
  {
    c1 = 0 ;
    res = ascii ;                     // Return unmodified
  }
  else
  {
    switch ( c1 )                     // Conversion depending on first UTF8-character
    {
      case 0xC2: res = '~' ;
        break ;
      case 0xC3: res = lut_C3[ascii - 128] ;
        break ;
      case 0x82: if ( ascii == 0xAC )
        {
          res = 'E' ;       // Special case Euro-symbol
        }
    }
    c1 = ascii ;                      // Remember actual character
  }
  return res ;                        // Otherwise: return zero, if character has to be ignored
}

//******************************************************************************************
//                              U T F 8 A S C I I                                          *
//******************************************************************************************
// In Place conversion UTF8-string to Extended ASCII (ASCII is shorter!).                  *
//******************************************************************************************
void utf8ascii ( char* s )
{
  int  i, k = 0 ;                     // Indexes for in en out string
  char c ;

  for ( i = 0 ; s[i] ; i++ )          // For every input character
  {
    c = utf8ascii ( s[i] ) ;          // Translate if necessary
    if ( c )                          // Good translation?
    {
      s[k++] = c ;                    // Yes, put in output string
    }
  }
  s[k] = 0 ;                          // Take care of delimeter
}

//******************************************************************************************
//                              D I S P L A Y I N F O                                      *
//******************************************************************************************
// Show a char string on the LCD at a specified y-position in a specified color            *
//******************************************************************************************
void displayinfo ( const char* str, uint16_t posx, uint16_t posy, uint16_t height, uint16_t color )
{
  char buf [ strlen ( str ) + 1 ] ;             // Need some buffer space
  strcpy ( buf, str ) ;                         // Make a local copy of the string
  utf8ascii ( buf ) ;                           // Convert possible UTF8
  tft.fillRect ( posx, posy, 160, height, ST7735_BLACK ) ; // Clear the space for new info
  tft.setTextColor ( color ) ;                  // Set the requested color
  tft.setCursor ( posx, posy ) ;                    // Prepare to show the info
  tft.println ( buf ) ;                         // Show the string
}

//******************************************************************************************
//                              D I S P L A Y I N F O S T R I N G                                      *
//******************************************************************************************
// Show a string on the LCD at a specified y-position in a specified color                 *
//******************************************************************************************

void displayinfoString ( const String str, uint16_t posx, uint16_t posy, uint16_t height, uint16_t color )
{
  //  String s = str;
  int n = str.length();
  char char_array[n + 1]; // declaring character array
  strcpy(char_array, str.c_str()); // copying the contents of the string to char array
  displayinfo ( char_array, posx, posy, height, color ) ;  // Program title
}

//******************************************************************************************
//                        S H O W S T R E A M T I T L E                                    *
//******************************************************************************************
// Show artist and songtitle if present in metadata.                                       *
// Show always if full=true.                                                               *
//******************************************************************************************
void showstreamtitle ( const char *ml, bool full )
{
  char*             p1 ;
  char*             p2 ;
  char              streamtitle[150] ;           // Streamtitle from metadata
  char              infotext;

  if ( strstr ( ml, "StreamTitle=" ) )
  {
    if (DEBUG == true) {
      Serial.println("");
      Serial.printf("Streamtitle found, %d bytes", strlen ( ml ));
      Serial.println(ml);
    }
    //    dbgprint ( "Streamtitle found, %d bytes", strlen ( ml ) ) ;
    //    dbgprint ( ml ) ;
    p1 = (char*)ml + 12 ;                       // Begin of artist and title
    if ( ( p2 = strstr ( ml, ";" ) ) )          // Search for end of title
    {
      if ( *p1 == '\'' )                        // Surrounded by quotes?
      {
        p1++ ;
        p2-- ;
      }
      *p2 = '\0' ;                              // Strip the rest of the line
    }
    // Save last part of string as streamtitle.  Protect against buffer overflow
    strncpy ( streamtitle, p1, sizeof ( streamtitle ) ) ;
    streamtitle[sizeof ( streamtitle ) - 1] = '\0' ;
  }
  else if ( full )
  {
    // Info probably from playlist
    strncpy ( streamtitle, ml, sizeof ( streamtitle ) ) ;
    streamtitle[sizeof ( streamtitle ) - 1] = '\0' ;
  }
  else
  {
    icystreamtitle = "" ;                       // Unknown type
    return ;                                    // Do not show
  }
  // Save for status request from browser ;
  icystreamtitle = streamtitle ;
  if ( ( p1 = strstr ( streamtitle, " - " ) ) ) // look for artist/title separator
  {
    *p1++ = '\n' ;  *p1++ = '\n' ;              // Found: replace 3 characters by newline
    p2 = p1 + 1 ;
    if ( *p2 == ' ' )                           // Leading space in title?
    {
      p2++ ;
    }
    strcpy ( p1, p2 ) ;                         // Shift 2nd part of title 2 or 3 places
  }
  if (newstreamtitle != streamtitle) {
    newstreamtitle != streamtitle;
    display_Streamtitle(streamtitle);
    if (DEBUG == true) {
      Serial.print("Streamtitle: ");
      Serial.println(streamtitle);
    }
  }
}

hellomp3_h.ino

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





unsigned char hello2[] = {
  0xFF,0xF2,0x40,0xC0,0x19,0xB7,0x00,0x14,0x02,0xE6,0x5C, /* ..@.......\ */
  0x01,0x92,0x68,0x01,0xF1,0x5E,0x03,0x08,0xF0,0x24,0x80, /* ..h..^...$. */
  0x05,0x9E,0x20,0xC6,0xFC,0x12,0x32,0x5C,0xBF,0xF9,0xB9, /* .. ...2\... */
  0x20,0x4A,0x7F,0x85,0xEC,0x4C,0xCD,0xC7,0x27,0xFE,0x5C, /*  J...L..'.\ */
  0x34,0x25,0xCB,0xE6,0xFF,0xFF,0x8E,0x42,0xE1,0xA0,0x5E, /* 4%.....B..^ */
  0xCA,0x6E,0x30,0x9F,0xFF,0xF8,0xC2,0x12,0x84,0xB9,0x7C, /* .n0.......| */
  0xDC,0x61,0x09,0x4A,0x7F,0xFF,0xFF,0xF9,0x7D,0x32,0x51, /* .a.J....}2Q */
  0x09,0x7C,0xE1,0xA5,0x6E,0xB4,0xFF,0xFF,0xFF,0xFF,0xD3, /* .|..n...... */
  0x34,0x41,0x91,0xF0,0x11,0x8F,0x00,0x0F,0x81,0x9C,0x10, /* 4A......... */
  0xEE,0x59,0xCE,0x56,0x67,0xFF,0xF2,0x42,0xC0,0xEC,0x53, /* .Y.Vg..B..S */
  0x09,0x15,0xF9,0xAA,0xA8,0x0D,0xD9,0x40,0x00,0xCA,0x34, /* .......@..4 */
  0x53,0xD9,0x18,0xAB,0x7D,0xF7,0x89,0x3F,0x11,0x38,0x94, /* S...}..?.8. */
  0x82,0x59,0x93,0x20,0x6A,0x0C,0xEE,0x8E,0x58,0xFA,0x38, /* .Y. j...X.8 */
  0x82,0xCA,0xF0,0x58,0xBB,0xDA,0x0C,0x50,0x56,0x1F,0xBB, /* ...X...PV.. */
  0x18,0x5D,0x8B,0x9F,0xDA,0x71,0x4F,0xFF,0xBD,0xFE,0xEF, /* .]...qO.... */
  0x69,0x36,0x86,0x3C,0x50,0xBB,0x0A,0x07,0x89,0x54,0xF0, /* i6.<P....T. */
  0x88,0x9F,0x90,0x95,0x30,0x94,0x2E,0x7E,0xF0,0x64,0x96, /* ....0..~.d. */
  0x79,0x08,0x3E,0x20,0x97,0x28,0x34,0x9C,0x09,0x7F,0xD2, /* y.> .(4.... */
  0xC0,0x01,0x75,0xF8,0x05,0x6B,0x5F,0x41,0x17,0x0B,0xE7, /* ..u..k_A... */
  0xFF,0xF2,0x40,0xC0,0x61,0xE5,0x0B,0x16,0x09,0xC6,0xC5, /* ..@.a...... */
  0x74,0x7B,0xCC,0x94,0x7A,0xF7,0x80,0x76,0xB2,0xD2,0xF8, /* t{..z..v... */
  0x39,0x06,0x38,0xFD,0x71,0xC5,0xDE,0x3A,0x38,0xBF,0xD5, /* 9.8.q..:8.. */
  0xF7,0x12,0x37,0xCB,0xF5,0x63,0x0C,0x9B,0xCE,0x77,0x25, /* ..7..c...w% */
  0xED,0xFB,0x3D,0x6B,0x35,0xF9,0x6D,0xD7,0xF9,0x2C,0xD1, /* ..=k5.m..,. */
  0x97,0x15,0x87,0x93,0xA4,0x49,0x4A,0x18,0x16,0x07,0xA1, /* .....IJ.... */
  0x60,0xF7,0x52,0x94,0xDB,0x02,0x16,0x70,0xB2,0xD8,0x80, /* `.R....p... */
  0x30,0xC2,0x94,0x40,0x81,0x74,0x5A,0x19,0x7A,0x80,0x60, /* 0..@.tZ.z.` */
  0x41,0x21,0x46,0x95,0xD5,0xC4,0x40,0xD2,0x01,0xC0,0x01, /* A!F...@.... */
  0xDA,0xD9,0xA0,0xB1,0x01,0xFF,0xF2,0x42,0xC0,0x82,0x10, /* .......B... */
  0x0B,0x12,0xF9,0x9E,0xC9,0x7E,0x7A,0xC6,0x95,0x55,0x09, /* .....~z..U. */
  0x8B,0x19,0x5E,0x8B,0x26,0xCA,0xEB,0x68,0x8A,0x05,0x8F, /* ..^.&..h... */
  0x36,0xA5,0xA5,0x03,0xB8,0x9C,0xED,0x24,0x51,0x59,0x90, /* 6......$QY. */
  0xF6,0xC5,0x7D,0xB5,0xAD,0xAF,0xF6,0x3B,0x18,0xEF,0x3F, /* ..}....;..? */
  0xFF,0xFF,0x4E,0xDE,0x16,0x66,0x0B,0xAA,0x33,0x23,0xDD, /* ..N..f..3#. */
  0x9C,0x4E,0x6E,0x55,0x22,0x9D,0xA2,0x40,0xA6,0x36,0x31, /* .NnU"..@.61 */
  0x69,0xA5,0xE1,0xD9,0x7F,0xF7,0xC6,0xCC,0x48,0x00,0x0E, /* i.......H.. */
  0x90,0x16,0x00,0x0F,0xDE,0x6E,0x80,0x11,0x0C,0x9A,0x4F, /* .....n....O */
  0x56,0xDB,0x88,0xD3,0xB2,0x1C,0x00,0xE0,0x2E,0x3E,0xAC, /* V........>. */
  0xFF,0xF2,0x40,0xC0,0x1C,0xE5,0x19,0x13,0x31,0x4E,0xCD, /* ..@.....1N. */
  0x9E,0xC3,0x06,0x71,0x03,0x85,0xE5,0xB5,0x6D,0x88,0x50, /* ...q....m.P */
  0x8E,0x0E,0x17,0x3B,0x19,0xFB,0x4E,0x3B,0x99,0xEF,0x4C, /* ...;..N;..L */
  0x9E,0xF7,0x7B,0x31,0x7C,0x3C,0x5F,0xFF,0xF4,0xF8,0xE3, /* ..{1|<_.... */
  0x92,0x42,0x07,0x8E,0x83,0x8E,0x0F,0x05,0x08,0x91,0xA3, /* .B......... */
  0x16,0xE2,0xDF,0xB7,0x62,0x60,0x48,0x31,0x3C,0xFF,0xD4, /* ....b`H1<.. */
  0x9E,0x0C,0x68,0x00,0x77,0x54,0xE3,0x1E,0x05,0xC5,0xF8, /* ..h.wT..... */
  0xEA,0x8D,0x82,0x9D,0x08,0xA9,0x06,0x8D,0x1E,0x5D,0x7C, /* .........]| */
  0x7F,0x08,0xC0,0x50,0x45,0x42,0xD0,0x36,0xF8,0xB2,0x4D, /* ...PEB.6..M */
  0x53,0x0C,0x80,0x3B,0x4D,0xFF,0xF2,0x42,0xC0,0x2F,0x3C, /* S..;M..B./< */
  0x25,0x19,0x29,0xFE,0xBC,0x2E,0xC4,0xD0,0x99,0x4C,0x48, /* %.)......LH */
  0xB0,0x9C,0x49,0xD2,0x1A,0x2D,0x02,0xC2,0x79,0x69,0x16, /* ..I..-..yi. */
  0x92,0xA8,0xC5,0xAB,0x45,0x5A,0x68,0xE8,0x75,0x57,0xCD, /* ....EZh.uW. */
  0xF1,0xB9,0xAA,0x13,0x88,0xE4,0x87,0x42,0x15,0xB3,0x58, /* .......B..X */
  0xF5,0xA3,0x46,0xB1,0xCF,0xD3,0x59,0x7E,0xBA,0xB5,0xA7, /* ..F...Y~... */
  0x6B,0x0B,0x17,0x57,0x6B,0x5C,0x4A,0xCD,0x53,0x76,0x2A, /* k..Wk\J.Sv* */
  0x1D,0x28,0xC5,0x1C,0x76,0x5C,0xDD,0x0A,0x00,0x4B,0xC0, /* .(..v\...K. */
  0x1B,0xCA,0xA8,0xE9,0x81,0x5B,0xA6,0xDC,0xA4,0x59,0x13, /* .....[...Y. */
  0xFC,0xBA,0x8F,0x98,0x79,0x44,0x25,0xC9,0x35,0x38,0xCA, /* ....yD%.58. */
  0xFF,0xF2,0x40,0xC0,0xB9,0x7D,0x1A,0x13,0x79,0x6A,0xC8, /* ..@..}..yj. */
  0x3E,0xC4,0x46,0x94,0x8D,0x3C,0x67,0x85,0xB1,0xA8,0x89, /* >.F..<g.... */
  0xC0,0xF2,0xE6,0x2F,0x9D,0x7C,0xC9,0xB4,0xBE,0xCF,0xE1, /* .../.|..... */
  0x7D,0xFE,0x1F,0x03,0x00,0x12,0x84,0x72,0x8C,0xE7,0xD8, /* }......r... */
  0x5E,0xC9,0xA9,0x01,0xBA,0x9B,0xC4,0x10,0x5C,0x70,0x2E, /* ^.......\p. */
  0x6C,0x48,0xE7,0x8C,0x15,0x0B,0x06,0x01,0xE5,0xFF,0xFF, /* lH......... */
  0xD4,0x0D,0x00,0x0F,0xCE,0x58,0x95,0x61,0xA8,0x9E,0x7B, /* .....X.a..{ */
  0x19,0x98,0xB0,0xF0,0xC6,0x72,0x82,0xD5,0x27,0x06,0x47, /* .....r..'.G */
  0x41,0x22,0x0F,0x65,0x93,0xC9,0x8A,0x09,0x19,0x48,0x1B, /* A".e.....H. */
  0xBD,0xD6,0x64,0x1A,0xAC,0xFF,0xF2,0x42,0xC0,0xF1,0x11, /* ..d....B... */
  0x25,0x14,0x22,0x06,0xBC,0x0E,0xD4,0x4E,0x99,0x90,0xA8, /* %."....N... */
  0xD8,0xB7,0xAD,0x5D,0x3E,0xAF,0x6E,0xBE,0x66,0x83,0xA4, /* ...]>.n.f.. */
  0xE3,0xC2,0xE0,0x29,0x43,0x87,0x5F,0x4F,0x27,0x9C,0x2C, /* ...)C._O'., */
  0xD0,0x91,0xF3,0x87,0x9B,0x54,0xED,0xD1,0xB4,0xF3,0x39, /* .....T....9 */
  0x87,0x22,0x06,0x86,0x0D,0x71,0xE4,0x6F,0x2A,0x08,0x04, /* ."...q.o*.. */
  0xC0,0x03,0x2A,0xB1,0xE2,0x05,0x4D,0x64,0xA1,0x9C,0xA6, /* ..*...Md... */
  0x0D,0x41,0xA6,0xF2,0x7A,0xC1,0x30,0xC3,0x38,0x26,0x09, /* .A..z.0.8&. */
  0x50,0x08,0xC4,0xF6,0x30,0x0C,0xA6,0xA9,0x17,0x00,0x13, /* P...0...... */
  0x0C,0xDC,0xC4,0x2F,0x28,0xEB,0x3F,0xCD,0x7A,0x3D,0x2F, /* .../(.?.z=/ */
  0xFF,0xF2,0x40,0xC0,0x18,0x6F,0x2E,0x13,0xA1,0xF2,0xBC, /* ..@..o..... */
  0x36,0xCB,0x4E,0x99,0x6E,0xFC,0xEE,0xC5,0xF0,0xA0,0xB7, /* 6.N.n...... */
  0x92,0xD4,0xEE,0x79,0x7C,0x50,0x5D,0xE5,0x04,0x94,0xA9, /* ...y|P].... */
  0x76,0xCF,0x6C,0x70,0xDD,0x0D,0xD4,0xEE,0xED,0x98,0xE8, /* v.lp....... */
  0xC8,0x35,0x36,0x7A,0x0C,0x05,0x80,0x03,0xBC,0xBE,0x91, /* .56z....... */
  0x00,0x7C,0xAE,0x65,0xB8,0x91,0xA3,0x33,0xBA,0x68,0x60, /* .|.e...3.h` */
  0xD4,0x1A,0x66,0xF8,0x43,0xA0,0x20,0x89,0xE7,0x80,0xD8, /* ..f.C. .... */
  0x1E,0x4F,0xA0,0x04,0x60,0x06,0x0A,0xA4,0x91,0x24,0xFA, /* .O..`....$. */
  0x9F,0x57,0x53,0xF4,0x7A,0xDB,0x5F,0x56,0xE3,0x6E,0x0B, /* .WS.z._V.n. */
  0x8B,0x3A,0x1C,0xF9,0x5E,0xFF,0xF2,0x42,0xC0,0xB1,0x00, /* .:..^..B... */
  0x38,0x14,0x09,0xEE,0xB4,0x36,0xD3,0x4E,0x99,0xA4,0x78, /* 8....6.N..x */
  0x94,0x73,0xC4,0x66,0x30,0xF5,0xEA,0xDB,0xBA,0x67,0x67, /* .s.f0....gg */
  0x95,0x6B,0xAB,0x68,0x5D,0x08,0xA1,0x39,0x56,0xAB,0x1E, /* .k.h]..9V.. */
  0xD5,0x03,0xE8,0x01,0x70,0x00,0xB3,0x93,0x33,0x19,0x8C, /* ....p...3.. */
  0x61,0x8F,0xBB,0x5D,0x24,0x12,0x63,0xD3,0x4B,0x5D,0x91, /* a..]$.c.K]. */
  0x08,0x43,0x22,0x56,0x1A,0xC5,0x10,0x21,0x84,0xA8,0xEA, /* .C"V...!... */
  0x80,0xBF,0x16,0x8E,0x3D,0x46,0x18,0x9C,0x6E,0x9A,0x91, /* ....=F..n.. */
  0xE6,0xC9,0x6F,0xD2,0x7D,0x27,0xD7,0xE9,0x6B,0xFF,0x0A, /* ..o.}'..k.. */
  0x03,0x43,0x89,0xD5,0xBF,0x52,0x97,0x0A,0x25,0x95,0x0D, /* .C...R..%.. */
  0xFF,0xF2,0x40,0xC0,0xF5,0xC3,0x41,0x13,0x81,0xEE,0xA8, /* ..@...A.... */
  0x5E,0xD3,0x44,0x98,0xFC,0xCF,0x97,0xF9,0x58,0xB5,0x33, /* ^.D.....X.3 */
  0xB1,0x85,0x47,0x86,0xD7,0x98,0x01,0x3B,0xA3,0x4F,0x7E, /* ..G....;.O~ */
  0x04,0xA6,0xC3,0x39,0x21,0x70,0x27,0x62,0xB5,0x18,0x10, /* ...9!p'b... */
  0x09,0x99,0x00,0x8B,0x7E,0xF2,0xBF,0x52,0x18,0x26,0x30, /* ....~..R.&0 */
  0x1C,0xB0,0x01,0x49,0x30,0xE0,0xC3,0x11,0x46,0x05,0xCC, /* ...I0...F.. */
  0x49,0x14,0x28,0xB2,0xED,0x4B,0x57,0x5A,0x2F,0xB7,0x46, /* I.(..KWZ/.F */
  0x63,0x34,0xD2,0xDA,0x9F,0x56,0x32,0xB7,0xA2,0x25,0xFF, /* c4...V2..%. */
  0x94,0x28,0x33,0x7F,0x3B,0xC4,0x50,0xEC,0xB1,0xE2,0x26, /* .(3.;.P...& */
  0xA1,0xB7,0x07,0x7F,0xFB,0xFF,0xF2,0x42,0xC0,0x67,0x6A, /* .......B.gj */
  0x4C,0x13,0xF9,0x6A,0x90,0x7E,0xDB,0x44,0x94,0x3F,0xFF, /* L..j.~.D.?. */
  0x14,0xD6,0x2A,0xFF,0xFF,0xC1,0x34,0x8C,0x48,0x22,0x00, /* ..*...4.H". */
  0x06,0x8F,0x21,0xFD,0x64,0x60,0x04,0x92,0x42,0xEA,0x74, /* ..!.d`..B.t */
  0x32,0x37,0xAA,0x5A,0x9F,0x67,0x01,0x8B,0x3F,0x37,0x31, /* 27.Z.g..?71 */
  0xDD,0x06,0x3C,0x01,0x34,0x30,0xE0,0x5C,0x78,0x78,0xCB, /* ..<.40.\xx. */
  0xD6,0xF1,0x31,0x8A,0x69,0x61,0x93,0x92,0x42,0xCE,0x4B, /* ..1.ia..B.K */
  0xC5,0x02,0x4E,0x73,0xC6,0x24,0x30,0xCD,0x08,0x66,0xC6, /* ..Ns.$0..f. */
  0x35,0xAB,0xA2,0x3D,0x2F,0xB3,0xBD,0x34,0x87,0x13,0xEE, /* 5..=/..4... */
  0x71,0x45,0x68,0xFA,0xEA,0x05,0x84,0x41,0x36,0x4C,0x9A, /* qEh....A6L. */
  0xFF,0xF2,0x40,0xC0,0xC9,0x92,0x56,0x13,0xD0,0x6E,0x70, /* ..@...V..np */
  0x54,0xD3,0xCC,0x28,0x06,0xD7,0x0E,0xA4,0x1D,0x9C,0x9D, /* T..(....... */
  0xD9,0xA9,0x88,0x7B,0xB5,0xA3,0x56,0xB7,0x4B,0x4B,0x5A, /* ...{..V.KKZ */
  0x9B,0x2C,0xA9,0xAD,0x6F,0x99,0x6C,0xC0,0x4C,0x14,0x14, /* .,..o.l.L.. */
  0xEF,0xB4,0x20,0x91,0x5F,0xBC,0x81,0x41,0x41,0x5D,0xD4, /* .. ._..AA]. */
  0x20,0xBD,0x05,0x1A,0x6F,0xE2,0x68,0x56,0x41,0x41,0x57, /*  ...o.hVAAW */
  0xF9,0xBF,0x89,0x82,0x8E,0xC7,0x8F,0x0A,0x0A,0x09,0x37, /* ..........7 */
  0xF1,0x05,0x0A,0x0A,0x0A,0x0A,0x09,0x05,0x37,0xFF,0x10, /* ........7.. */
  0x50,0x50,0x53,0x65,0xFF,0xFF,0xFD,0x75,0xDF,0xFF,0xFF, /* PPSe...u... */
  0x68,0x4F,0xFF,0x84,0x70,0xFF,0xF2,0x42,0xC0,0x27,0x50, /* hO..p..B.'P */
  0x5F,0x17,0xE8,0x82,0x3C,0x11,0x58,0x18,0x01,0x55,0x48, /* _...<.X..UH */
  0xBC,0x52,0xFC,0x4A,0x4C,0x3C,0xD5,0xF6,0x11,0x2D,0xBF, /* .R.JL<...-. */
  0xEA,0x03,0x5C,0x57,0x29,0xBF,0xC3,0x75,0x1C,0xE6,0xDD, /* ..\W)..u... */
  0xBF,0xED,0xEF,0xD0,0x98,0x77,0x71,0x95,0x73,0xFF,0xED, /* .....wq.s.. */
  0x54,0xBE,0xD5,0xEE,0xAE,0xC2,0xD5,0x0B,0xFF,0xF1,0x97, /* T.......... */
  0x8A,0xE4,0x42,0x09,0x99,0xB1,0xEA,0x94,0xDC,0x78,0xB5, /* ..B......x. */
  0x34,0x0F,0xF1,0x8F,0xFC,0x15,0xF6,0xFA,0xB1,0x47,0xA9, /* 4........G. */
  0x6C,0x67,0x43,0x8B,0xF2,0x76,0x22,0xED,0xDA,0x85,0xBA, /* lgC..v".... */
  0x2F,0xC7,0xF9,0xCF,0xFC,0xDB,0x46,0x2E,0x50,0x0A,0x84, /* /.....F.P.. */
  0xFF,0xF2,0x40,0xC0,0xC6,0x4A,0x59,0x28,0x2B,0x19,0xE0, /* ..@..JY(+.. */
  0x01,0x89,0x78,0x00,0x52,0x85,0x3C,0x8E,0x54,0x9A,0x48, /* ..x.R.<.T.H */
  0x5A,0x72,0x32,0x94,0xBF,0x43,0x4F,0x24,0x53,0x4B,0xEC, /* Zr2..CO$SK. */
  0x4B,0x99,0x0E,0x66,0x1F,0xFF,0xCE,0x7F,0xFF,0x3F,0x10, /* K..f.....?. */
  0xAE,0x82,0x62,0x71,0x34,0x18,0x59,0x9B,0x51,0xC7,0x59, /* ..bq4.Y.Q.Y */
  0xCE,0xEE,0xA5,0xFE,0x02,0xBB,0x30,0x91,0x49,0xD5,0x4B, /* ......0.I.K */
  0xF3,0xDC,0x9A,0xA9,0x57,0x8E,0x72,0x10,0xC0,0x5D,0x60, /* ....W.r..]` */
  0x67,0xFC,0x7D,0xD6,0xBA,0xDD,0xB3,0x8B,0x5A,0x0A,0x4C, /* g.}.....Z.L */
  0x41,0x4D,0x45,0x33,0x2E,0x39,0x33,0xAA,0xAA,0xAA,0xAA, /* AME3.93.... */
  0xAA,0xAA,0xAA,0xAA,0xAA,0x54,0x41,0x47,0x48,0x65,0x6C, /* .....TAGHel */
  0x6C,0x6F,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20, /* lo          */
  0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20, /*             */
  0x20,0x20,0x20,0x20,0x20,0x50,0x61,0x6E,0x75,0x2D,0x4B, /*      Panu-K */
  0x72,0x69,0x73,0x74,0x69,0x61,0x6E,0x20,0x50,0x6F,0x69, /* ristian Poi */
  0x6B,0x73,0x61,0x6C,0x6F,0x20,0x20,0x20,0x20,0x20,0x20, /* ksalo       */
  0x20,0x20,0x56,0x53,0x44,0x53,0x50,0x20,0x54,0x65,0x73, /*   VSDSP Tes */
  0x74,0x69,0x6E,0x67,0x20,0x20,0x20,0x20,0x20,0x20,0x20, /* ting        */
  0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20, /*             */
  0x20,0x20,0x20,0x4D,0x50,0x33,0x20,0x48,0x65,0x6C,0x6C, /*    MP3 Hell */
  0x6F,0x2C,0x20,0x57,0x6F,0x72,0x6C,0x64,0x21,0x20,0x20, /* o, World!   */
  0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20, /*             */
  0x00, /* . */
};

preferences_h.ino

// Preferences.h
// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef _PREFERENCES_H_
#define _PREFERENCES_H_

#include "Arduino.h"

class Preferences {
    protected:
        uint32_t _handle;
        bool _started;
        bool _readOnly;
    public:
        Preferences();
        ~Preferences();

        bool begin(const char * name, bool readOnly=false);
        void end();

        bool clear();
        bool remove(const char * key);

        size_t putChar(const char* key, int8_t value);
        size_t putUChar(const char* key, uint8_t value);
        size_t putShort(const char* key, int16_t value);
        size_t putUShort(const char* key, uint16_t value);
        size_t putInt(const char* key, int32_t value);
        size_t putUInt(const char* key, uint32_t value);
        size_t putLong(const char* key, int32_t value);
        size_t putULong(const char* key, uint32_t value);
        size_t putLong64(const char* key, int64_t value);
        size_t putULong64(const char* key, uint64_t value);
        size_t putFloat(const char* key, float_t value);
        size_t putDouble(const char* key, double_t value);
        size_t putBool(const char* key, bool value);
        size_t putString(const char* key, const char* value);
        size_t putString(const char* key, String value);
        size_t putBytes(const char* key, const void* value, size_t len);

        int8_t getChar(const char* key, int8_t defaultValue = 0);
        uint8_t getUChar(const char* key, uint8_t defaultValue = 0);
        int16_t getShort(const char* key, int16_t defaultValue = 0);
        uint16_t getUShort(const char* key, uint16_t defaultValue = 0);
        int32_t getInt(const char* key, int32_t defaultValue = 0);
        uint32_t getUInt(const char* key, uint32_t defaultValue = 0);
        int32_t getLong(const char* key, int32_t defaultValue = 0);
        uint32_t getULong(const char* key, uint32_t defaultValue = 0);
        int64_t getLong64(const char* key, int64_t defaultValue = 0);
        uint64_t getULong64(const char* key, uint64_t defaultValue = 0);
        float_t getFloat(const char* key, float_t defaultValue = NAN);
        double_t getDouble(const char* key, double_t defaultValue = NAN);
        bool getBool(const char* key, bool defaultValue = false);
        size_t getString(const char* key, char* value, size_t maxLen);
        String getString(const char* key, String defaultValue = String());
	size_t getBytesLength(const char* key);
        size_t getBytes(const char* key, void * buf, size_t maxLen);
        size_t freeEntries();
};

#endif

radiostations_h.ino

// radiostations.h
// Number of radio stations
const int nbrStations = 14;
// Radio Stations - main URL
char *host[nbrStations] = {"icecast.omroep.nl",
                           "icecast.omroep.nl",
                           "icecast.omroep.nl",
                           "icecast.omroep.nl",
                           "icecast.omroep.nl",
                           "21233.live.streamtheworld.com",
                           "18973.live.streamtheworld.com",
                           "icecast-qmusicnl-cdp.triple-it.nl",
                           "19993.live.streamtheworld.com",
                           "20873.live.streamtheworld.com",
                           "19993.live.streamtheworld.com",
                           "19983.live.streamtheworld.com",
                           "rva.ice.infomaniak.ch",
                           "stream.gal.io"};
// Radio Stations - part following main URL
char *path[nbrStations] = {"/radio1-bb-mp3",
                           "/radio2-bb-mp3",
                           "/3fm-bb-mp3",
                           "/radio4-bb-mp3",
                           "/radio5-bb-mp3",
                           "/100PNL_MP3_SC?",
                           "/RADIO538.mp3",
                           "/Qmusic_nl_live_96.mp3",
                           "/RADIO10.mp3",
                           "/VERONICA.mp3",
                           "/SKYRADIO.mp3",
                           "/SLAM_MP3_SC?",
                           "/rva-high.mp3",
                           "/arrow"};
// Radio Stations - port number
int   port[nbrStations] = {80,80,80,80,80,80,80,80,80,80,80,80,80,80};
// Radio Stations - info shown on display
char *sname[nbrStations] = {"Radio 1",
                            "Radio 2",
                            "Radio 3",
                            "Radio 4",
                            "Radio 5",
                            "100% NL",
                            "RADIO 538",
                            "QMusic",
                            "Radio 10",
                            "Veronica",
                            "Sky Radio",
                            "Slam",
                            "RVA",
                            "Arrow Classic Rock"};
#include "hellomp3.h"       // to say 'Hello' to listener

This statement expects to find a file named hellomp3.h in the same folder as your sketch or failing that in the standard Arduino library locations. Do you have that file on your system and, if so, where is it located ?

This looks like your attempt to create the file, but look at the name of it

Ah that simple, thank you. I have changed the names of the other files in the folder too and that works. Now I get "Adafruit_ST7735.h: No such file or directory". I'm assuming this is something to do with a hardware specific files I need to install in Arduino IDE?

You can install this library from the Library Manager in the IDE

Thanks for your help, its been brilliant. I have now installed a few more libraries, as I get errors. All goes well until I get to "ESP_VS1053".
I now get the error
"Multiple libraries were found for "WiFi.h"
internet_radio_code:60:20: fatal error: VS1053.h: No such file or directory
Used: /home/mark/.arduino15/packages/esp32/hardware/esp32/1.0.6/libraries/WiFi
compilation terminated.
Not used: /app/Arduino/libraries/WiFi
exit status 1
VS1053.h: No such file or directory"

when I try to install the library i get a message to say I need to install some dependencies but then I get
"Multiple libraries were found for "WiFi.h"
internet_radio_code:60:20: fatal error: VS1053.h: No such file or directory
Used: /home/mark/.arduino15/packages/esp32/hardware/esp32/1.0.6/libraries/WiFi
compilation terminated.
Not used: /app/Arduino/libraries/WiFi
exit status 1
VS1053.h: No such file or directory"

It seems I am so close

How exactly did you install the VS1053 library ?
Did you install the one listed in the sketch comments ?

- VS1053.h          - https://github.com/baldram/ESP_VS1053_Library/tree/master/src

You are in good hands with UKHeliBob's help, but I will chime in to explain one thing:

Unfortunately, the Arduino IDE sometimes interlaces the compilation output from different processes it is running in parallel. That is the case here, which makes the error a little more difficult to interpret. I'll untangle them for you.

This is the output from one process:

Multiple libraries were found for "WiFi.h"
Used: /home/mark/.arduino15/packages/esp32/hardware/esp32/1.0.6/libraries/WiFi
Not used: /app/Arduino/libraries/WiFi

This is nothing to worry about. It is only some helpful information the IDE provides when multiple libraries contain the file name in an #include directive.

You can safely ignore these "Multiple libraries were found ..." messages, except for when they show that a different library than intended was used. The IDE is pretty smart about picking the right library, and in this case it did pick the correct one so all is well here.


This is the output from the other process:

internet_radio_code:60:20: fatal error: VS1053.h: No such file or directory
compilation terminated.
exit status 1
VS1053.h: No such file or directory"

That is the real error you need to fix.

I was just getting to that but I see there are several files there, I dont know how to install those

Well, thank you for all your help. I downloaded the zip file from github, extracted it to the library folder and now it all compiles without errors. I really wasnt expecting so much help as quickly as this so I'm doubly impressed.

THANK YOU

I am glad that you got it working and no doubt learnt something along the way about managing libraries

Good luck with this and future projects

lots learned today. I have yet to get the project finished but I'm a significant way forward and better prepared for any future projects.