diff --git a/TVB/TVB.pde b/TVB/TVB.pde
new file mode 100644
index 0000000..f221ec9
--- /dev/null
+++ b/TVB/TVB.pde
@@ -0,0 +1,455 @@
+/*
+TV-B-Gone for Arduino version 1.2, Oct 23 2010
+Ported to Arduino by Ken Shirriff=
+http://www.arcfn.com/2009/12/tv-b-gone-for-arduino.html
+
+The hardware for this project uses an Arduino:
+ Connect an IR LED to pin 3 (RLED).
+ Connect a visible LED to pin 13 (or use builtin LED in some Arduinos).
+ Connect a pushbutton between pin 2 (TRIGGER) and ground.
+ Pin 5 (REGIONSWITCH) is floating for North America, or wired to ground for Europe.
+
+The original code is:
+TV-B-Gone Firmware version 1.2
+ for use with ATtiny85v and v1.2 hardware
+ (c) Mitch Altman + Limor Fried 2009
+ Last edits, August 16 2009
+
+
+ I added universality for EU or NA,
+ and Sleep mode to Ken's Arduino port
+      -- Mitch Altman  18-Oct-2010
+ Thanks to ka1kjz for the code for adding Sleep
+      <http://www.ka1kjz.com/561/adding-sleep-to-tv-b-gone-code/>
+
+
+ With some code from:
+ Kevin Timmerman & Damien Good 7-Dec-07
+
+ Distributed under Creative Commons 2.5 -- Attib & Share Alike
+
+ */
+
+#include "main.h"
+#include <avr/sleep.h>
+
+void xmitCodeElement(uint16_t ontime, uint16_t offtime, uint8_t PWM_code );
+void quickflashLEDx( uint8_t x );
+void delay_ten_us(uint16_t us);
+void quickflashLED( void );
+uint8_t read_bits(uint8_t count);
+
+#define putstring_nl(s) Serial.println(s)
+#define putstring(s) Serial.print(s)
+#define putnum_ud(n) Serial.print(n, DEC)
+#define putnum_uh(n) Serial.print(n, HEX)
+
+/*
+This project transmits a bunch of TV POWER codes, one right after the other,
+ with a pause in between each.  (To have a visible indication that it is
+ transmitting, it also pulses a visible LED once each time a POWER code is
+ transmitted.)  That is all TV-B-Gone does.  The tricky part of TV-B-Gone
+ was collecting all of the POWER codes, and getting rid of the duplicates and
+ near-duplicates (because if there is a duplicate, then one POWER code will
+ turn a TV off, and the duplicate will turn it on again (which we certainly
+ do not want).  I have compiled the most popular codes with the
+ duplicates eliminated, both for North America (which is the same as Asia, as
+ far as POWER codes are concerned -- even though much of Asia USES PAL video)
+ and for Europe (which works for Australia, New Zealand, the Middle East, and
+ other parts of the world that use PAL video).
+
+ Before creating a TV-B-Gone Kit, I originally started this project by hacking
+ the MiniPOV kit.  This presents a limitation, based on the size of
+ the Atmel ATtiny2313 internal flash memory, which is 2KB.  With 2KB we can only
+ fit about 7 POWER codes into the firmware's database of POWER codes.  However,
+ the more codes the better! Which is why we chose the ATtiny85 for the
+ TV-B-Gone Kit.
+
+ This version of the firmware has the most popular 100+ POWER codes for
+ North America and 100+ POWER codes for Europe. You can select which region
+ to use by soldering a 10K pulldown resistor.
+ */
+
+
+/*
+This project is a good example of how to use the AVR chip timers.
+ */
+
+extern PGM_P *NApowerCodes[] PROGMEM;
+extern PGM_P *EUpowerCodes[] PROGMEM;
+extern uint8_t num_NAcodes, num_EUcodes;
+
+/* This function is the 'workhorse' of transmitting IR codes.
+ Given the on and off times, it turns on the PWM output on and off
+ to generate one 'pair' from a long code. Each code has ~50 pairs! */
+void xmitCodeElement(uint16_t ontime, uint16_t offtime, uint8_t PWM_code )
+{
+  TCNT2 = 0;
+  if(PWM_code) {
+    pinMode(IRLED, OUTPUT);
+    // Fast PWM, setting top limit, divide by 8
+    // Output to pin 3
+    TCCR2A = _BV(COM2A0) | _BV(COM2B1) | _BV(WGM21) | _BV(WGM20);
+    TCCR2B = _BV(WGM22) | _BV(CS21);
+  }
+  else {
+    // However some codes dont use PWM in which case we just turn the IR
+    // LED on for the period of time.
+    digitalWrite(IRLED, HIGH);
+  }
+
+  // Now we wait, allowing the PWM hardware to pulse out the carrier
+  // frequency for the specified 'on' time
+  delay_ten_us(ontime);
+
+  // Now we have to turn it off so disable the PWM output
+  TCCR2A = 0;
+  TCCR2B = 0;
+  // And make sure that the IR LED is off too (since the PWM may have
+  // been stopped while the LED is on!)
+  digitalWrite(IRLED, LOW);
+
+  // Now we wait for the specified 'off' time
+  delay_ten_us(offtime);
+}
+
+/* This is kind of a strange but very useful helper function
+ Because we are using compression, we index to the timer table
+ not with a full 8-bit byte (which is wasteful) but 2 or 3 bits.
+ Once code_ptr is set up to point to the right part of memory,
+ this function will let us read 'count' bits at a time which
+ it does by reading a byte into 'bits_r' and then buffering it. */
+
+uint8_t bitsleft_r = 0;
+uint8_t bits_r=0;
+PGM_P code_ptr;
+
+// we cant read more than 8 bits at a time so dont try!
+uint8_t read_bits(uint8_t count)
+{
+  uint8_t i;
+  uint8_t tmp=0;
+
+  // we need to read back count bytes
+  for (i=0; i<count; i++) {
+    // check if the 8-bit buffer we have has run out
+    if (bitsleft_r == 0) {
+      // in which case we read a new byte in
+      bits_r = pgm_read_byte(code_ptr++);
+      // and reset the buffer size (8 bites in a byte)
+      bitsleft_r = 8;
+    }
+    // remove one bit
+    bitsleft_r--;
+    // and shift it off of the end of 'bits_r'
+    tmp |= (((bits_r >> (bitsleft_r)) & 1) << (count-1-i));
+  }
+  // return the selected bits in the LSB part of tmp
+  return tmp;
+}
+
+
+/*
+The C compiler creates code that will transfer all constants into RAM when
+ the microcontroller resets.  Since this firmware has a table (powerCodes)
+ that is too large to transfer into RAM, the C compiler needs to be told to
+ keep it in program memory space.  This is accomplished by the macro PROGMEM
+ (this is used in the definition for powerCodes).  Since the C compiler assumes
+ that constants are in RAM, rather than in program memory, when accessing
+ powerCodes, we need to use the pgm_read_word() and pgm_read_byte macros, and
+ we need to use powerCodes as an address.  This is done with PGM_P, defined
+ below.
+ For example, when we start a new powerCode, we first point to it with the
+ following statement:
+ PGM_P thecode_p = pgm_read_word(powerCodes+i);
+ The next read from the powerCode is a byte that indicates the carrier
+ frequency, read as follows:
+ const uint8_t freq = pgm_read_byte(code_ptr++);
+ After that is a byte that tells us how many 'onTime/offTime' pairs we have:
+ const uint8_t numpairs = pgm_read_byte(code_ptr++);
+ The next byte tells us the compression method. Since we are going to use a
+ timing table to keep track of how to pulse the LED, and the tables are
+ pretty short (usually only 4-8 entries), we can index into the table with only
+ 2 to 4 bits. Once we know the bit-packing-size we can decode the pairs
+ const uint8_t bitcompression = pgm_read_byte(code_ptr++);
+ Subsequent reads from the powerCode are n bits (same as the packing size)
+ that index into another table in ROM that actually stores the on/off times
+ const PGM_P time_ptr = (PGM_P)pgm_read_word(code_ptr);
+ */
+
+uint16_t ontime, offtime;
+uint8_t i,num_codes, Loop;
+uint8_t region;
+uint8_t startOver;
+
+#define FALSE 0
+#define TRUE 1
+
+void setup()   {
+  Serial.begin(9600);
+
+  TCCR2A = 0;
+  TCCR2B = 0;
+
+  digitalWrite(LED, LOW);
+  digitalWrite(IRLED, LOW);
+  digitalWrite(DBG, LOW);     // debug
+  pinMode(LED, OUTPUT);
+  pinMode(IRLED, OUTPUT);
+  pinMode(DBG, OUTPUT);       // debug
+  pinMode(REGIONSWITCH, INPUT);
+  pinMode(TRIGGER, INPUT);
+  digitalWrite(REGIONSWITCH, HIGH); //Pull-up
+  digitalWrite(TRIGGER, HIGH);
+
+  delay_ten_us(5000);            // Let everything settle for a bit
+
+  // determine region
+  if (digitalRead(REGIONSWITCH)) {
+    region = NA;
+    DEBUGP(putstring_nl("NA"));
+  }
+  else {
+    region = EU;
+    DEBUGP(putstring_nl("EU"));
+  }
+
+  // Indicate how big our database is
+  DEBUGP(putstring("\n\rNA Codesize: ");
+  putnum_ud(num_NAcodes);
+  );
+  DEBUGP(putstring("\n\rEU Codesize: ");
+  putnum_ud(num_EUcodes);
+  );
+
+  // Tell the user what region we're in  - 3 flashes is NA, 6 is EU
+  delay_ten_us(65500); // wait maxtime
+  delay_ten_us(65500); // wait maxtime
+  delay_ten_us(65500); // wait maxtime
+  delay_ten_us(65500); // wait maxtime
+  quickflashLEDx(3);
+  if (region == EU) {
+    quickflashLEDx(3);
+  }
+}
+
+void sendAllCodes() {
+Start_transmission:
+  // startOver will become TRUE if the user pushes the Trigger button while transmitting the sequence of all codes
+  startOver = FALSE;
+
+  // determine region from REGIONSWITCH: 1 = NA, 0 = EU
+  if (digitalRead(REGIONSWITCH)) {
+    region = NA;
+    num_codes = num_NAcodes;
+  }
+  else {
+    region = EU;
+    num_codes = num_EUcodes;
+  }
+
+  // for every POWER code in our collection
+  for (i=0 ; i < num_codes; i++) {
+    PGM_P data_ptr;
+
+    // print out the code # we are about to transmit
+    DEBUGP(putstring("\n\r\n\rCode #: ");
+    putnum_ud(i));
+
+    // point to next POWER code, from the right database
+    if (region == NA) {
+      data_ptr = (PGM_P)pgm_read_word(NApowerCodes+i);
+    }
+    else {
+      data_ptr = (PGM_P)pgm_read_word(EUpowerCodes+i);
+    }
+
+    // print out the address in ROM memory we're reading
+    DEBUGP(putstring("\n\rAddr: ");
+    putnum_uh((uint16_t)data_ptr));
+
+    // Read the carrier frequency from the first byte of code structure
+    const uint8_t freq = pgm_read_byte(data_ptr++);
+    // set OCR for Timer1 to output this POWER code's carrier frequency
+    OCR2A = freq;
+    OCR2B = freq / 3; // 33% duty cycle
+
+    // Print out the frequency of the carrier and the PWM settings
+    DEBUGP(putstring("\n\rOCR1: ");
+    putnum_ud(freq);
+    );
+    DEBUGP(uint16_t x = (freq+1) * 2;
+    putstring("\n\rFreq: ");
+    putnum_ud(F_CPU/x);
+    );
+
+    // Get the number of pairs, the second byte from the code struct
+    const uint8_t numpairs = pgm_read_byte(data_ptr++);
+    DEBUGP(putstring("\n\rOn/off pairs: ");
+    putnum_ud(numpairs));
+
+    // Get the number of bits we use to index into the timer table
+    // This is the third byte of the structure
+    const uint8_t bitcompression = pgm_read_byte(data_ptr++);
+    DEBUGP(putstring("\n\rCompression: ");
+    putnum_ud(bitcompression);
+    putstring("\n\r"));
+
+    // Get pointer (address in memory) to pulse-times table
+    // The address is 16-bits (2 byte, 1 word)
+    PGM_P time_ptr = (PGM_P)pgm_read_word(data_ptr);
+    data_ptr+=2;
+    code_ptr = (PGM_P)pgm_read_word(data_ptr);
+
+    // Transmit all codeElements for this POWER code
+    // (a codeElement is an onTime and an offTime)
+    // transmitting onTime means pulsing the IR emitters at the carrier
+    // frequency for the length of time specified in onTime
+    // transmitting offTime means no output from the IR emitters for the
+    // length of time specified in offTime
+
+#if 0
+
+    // print out all of the pulse pairs
+    for (uint8_t k=0; k<numpairs; k++) {
+      uint8_t ti;
+      ti = (read_bits(bitcompression)) * 4;
+      // read the onTime and offTime from the program memory
+      ontime = pgm_read_word(time_ptr+ti);
+      offtime = pgm_read_word(time_ptr+ti+2);
+      DEBUGP(putstring("\n\rti = ");
+      putnum_ud(ti>>2);
+      putstring("\tPair = ");
+      putnum_ud(ontime));
+      DEBUGP(putstring("\t");
+      putnum_ud(offtime));
+    }
+    continue;
+#endif
+
+    // For EACH pair in this code....
+    cli();
+    for (uint8_t k=0; k<numpairs; k++) {
+      uint16_t ti;
+
+      // Read the next 'n' bits as indicated by the compression variable
+      // The multiply by 4 because there are 2 timing numbers per pair
+      // and each timing number is one word long, so 4 bytes total!
+      ti = (read_bits(bitcompression)) * 4;
+
+      // read the onTime and offTime from the program memory
+      ontime = pgm_read_word(time_ptr+ti);  // read word 1 - ontime
+      offtime = pgm_read_word(time_ptr+ti+2);  // read word 2 - offtime
+      // transmit this codeElement (ontime and offtime)
+      xmitCodeElement(ontime, offtime, (freq!=0));
+    }
+    sei();
+
+    //Flush remaining bits, so that next code starts
+    //with a fresh set of 8 bits.
+    bitsleft_r=0;
+
+    // delay 205 milliseconds before transmitting next POWER code
+    delay_ten_us(20500);
+
+    // visible indication that a code has been output.
+    quickflashLED();
+
+    // if user is pushing Trigger button, stop transmission
+    if (digitalRead(TRIGGER) == 0) {
+      startOver = TRUE;
+      break;
+    }
+  }
+
+  if (startOver) goto Start_transmission;
+  while (Loop == 1);
+
+  // flash the visible LED on PB0  8 times to indicate that we're done
+  delay_ten_us(65500); // wait maxtime
+  delay_ten_us(65500); // wait maxtime
+  quickflashLEDx(8);
+
+}
+
+void loop() {
+  sleepNow();
+  // if the user pushes the Trigger button and lets go, then start transmission of all POWER codes
+  if (digitalRead(TRIGGER) == 0) {
+    delay_ten_us(3000);  // delay 30ms
+    if (digitalRead(TRIGGER) == 1) {
+      sendAllCodes();
+    }
+  }
+}
+
+
+/****************************** LED AND DELAY FUNCTIONS ********/
+
+
+// This function delays the specified number of 10 microseconds
+// it is 'hardcoded' and is calibrated by adjusting DELAY_CNT
+// in main.h Unless you are changing the crystal from 8mhz, dont
+// mess with this.
+void delay_ten_us(uint16_t us) {
+  uint8_t timer;
+  while (us != 0) {
+    // for 8MHz we want to delay 80 cycles per 10 microseconds
+    // this code is tweaked to give about that amount.
+    for (timer=0; timer <= DELAY_CNT; timer++) {
+      NOP;
+      NOP;
+    }
+    NOP;
+    us--;
+  }
+}
+
+
+// This function quickly pulses the visible LED (connected to PB0, pin 5)
+// This will indicate to the user that a code is being transmitted
+void quickflashLED( void ) {
+  digitalWrite(LED, HIGH);
+  delay_ten_us(3000);   // 30 millisec delay
+  digitalWrite(LED, LOW);
+}
+
+// This function just flashes the visible LED a couple times, used to
+// tell the user what region is selected
+void quickflashLEDx( uint8_t x ) {
+  quickflashLED();
+  while(--x) {
+    delay_ten_us(15000);     // 150 millisec delay between flahes
+    quickflashLED();
+  }
+}
+
+
+
+
+/****************************** SLEEP and WAKE FUNCTIONS ********/
+// from kaqkjz:
+// http://www.ka1kjz.com/561/adding-sleep-to-tv-b-gone-code/
+
+void sleepNow()
+{
+  set_sleep_mode(TRIGGER);                    // sleep mode is set here
+
+  sleep_enable();                             // enables the sleep bit in the mcucr register
+
+  attachInterrupt(0, wakeUpNow, LOW);         // use interrupt 0 (pin 2) and run function
+  // wakeUpNow when pin 2 gets LOW
+
+  sleep_mode();                               // here the device is actually put to sleep!!
+  // THE PROGRAM CONTINUES FROM HERE ON WAKE
+
+  sleep_disable();                            // first thing after waking, disable sleep
+
+  detachInterrupt(0);                         // disables int 0 as the wakeupnow code will
+                                              // not be executed during normal runtime
+}
+
+void wakeUpNow()
+{
+  // any needed wakeup code can be placed here
+}
diff --git a/TVB/WORLDcodes.cpp b/TVB/WORLDcodes.cpp
new file mode 100644
index 0000000..393738c
--- /dev/null
+++ b/TVB/WORLDcodes.cpp
@@ -0,0 +1,8790 @@
+/*
+TV-B-Gone for Arduino version 0.001
+Ported to Arduino by Ken Shirriff, Dec 3, 2009
+http://arcfn.com
+
+The original code is:
+TV-B-Gone Firmware version 1.2
+ for use with ATtiny85v and v1.2 hardware
+ (c) Mitch Altman + Limor Fried 2009
+
+*/
+#include "main.h"
+
+//Codes captured from Generation 3 TV-B-Gone by Limor Fried & Mitch Altman
+// table of POWER codes
+
+const uint16_t code_na000Times[] PROGMEM = {
+  60, 60,
+  60, 2700,
+  120, 60,
+  240, 60,
+};
+const uint8_t code_na000Codes[] PROGMEM = {
+  0xE2,
+  0x20,
+  0x80,
+  0x78,
+  0x88,
+  0x20,
+  0x10,
+};
+const struct IrCode code_na000Code PROGMEM = {
+  freq_to_timerval(38400),
+  26,             // # of pairs
+  2,              // # of bits per index
+  code_na000Times,
+  code_na000Codes
+};
+
+const uint16_t code_na001Times[] PROGMEM = {
+  50, 100,
+  50, 200,
+  50, 800,
+  400, 400,
+};
+const uint8_t code_na001Codes[] PROGMEM = {
+  0xD5,
+  0x41,
+  0x11,
+  0x00,
+  0x14,
+  0x44,
+  0x6D,
+  0x54,
+  0x11,
+  0x10,
+  0x01,
+  0x44,
+  0x45,
+};
+const struct IrCode code_na001Code PROGMEM = {
+  freq_to_timerval(57143),
+  52,		// # of pairs
+  2,		// # of bits per index
+  code_na001Times,
+  code_na001Codes
+};
+const uint16_t code_na002Times[] PROGMEM = {
+  42, 46,
+  42, 133,
+  42, 7519,
+  347, 176,
+  347, 177,
+};
+const uint8_t code_na002Codes[] PROGMEM = {
+  0x60,
+  0x80,
+  0x00,
+  0x00,
+  0x00,
+  0x08,
+  0x00,
+  0x00,
+  0x00,
+  0x20,
+  0x00,
+  0x00,
+  0x04,
+  0x12,
+  0x48,
+  0x04,
+  0x12,
+  0x48,
+  0x2A,
+  0x02,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x20,
+  0x00,
+  0x00,
+  0x00,
+  0x80,
+  0x00,
+  0x00,
+  0x10,
+  0x49,
+  0x20,
+  0x10,
+  0x49,
+  0x20,
+  0x80,
+};
+const struct IrCode code_na002Code PROGMEM = {
+  freq_to_timerval(37037),
+  100,		// # of pairs
+  3,		// # of bits per index
+  code_na002Times,
+  code_na002Codes
+};
+const uint16_t code_na003Times[] PROGMEM = {
+  26, 185,
+  27, 80,
+  27, 185,
+  27, 4549,
+};
+const uint8_t code_na003Codes[] PROGMEM = {
+  0x15,
+  0x5A,
+  0x65,
+  0x67,
+  0x95,
+  0x65,
+  0x9A,
+  0x9B,
+  0x95,
+  0x5A,
+  0x65,
+  0x67,
+  0x95,
+  0x65,
+  0x9A,
+  0x99,
+};
+const struct IrCode code_na003Code PROGMEM = {
+  freq_to_timerval(38610),
+  64,		// # of pairs
+  2,		// # of bits per index
+  code_na003Times,
+  code_na003Codes
+};
+const uint16_t code_na004Times[] PROGMEM = {
+  55, 57,
+  55, 170,
+  55, 3949,
+  55, 9623,
+  56, 0,
+  898, 453,
+  900, 226,
+};
+const uint8_t code_na004Codes[] PROGMEM = {
+  0xA0,
+  0x00,
+  0x01,
+  0x04,
+  0x92,
+  0x48,
+  0x20,
+  0x80,
+  0x40,
+  0x04,
+  0x12,
+  0x09,
+  0x2B,
+  0x3D,
+  0x00,
+};
+const struct IrCode code_na004Code PROGMEM = {
+  freq_to_timerval(38610),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na004Times,
+  code_na004Codes
+};
+const uint16_t code_na005Times[] PROGMEM = {
+  88, 90,
+  88, 91,
+  88, 181,
+  88, 8976,
+  177, 91,
+};
+const uint8_t code_na005Codes[] PROGMEM = {
+  0x10,
+  0x92,
+  0x49,
+  0x46,
+  0x33,
+  0x09,
+  0x24,
+  0x94,
+  0x60,
+};
+const struct IrCode code_na005Code PROGMEM = {
+  freq_to_timerval(35714),
+  24,		// # of pairs
+  3,		// # of bits per index
+  code_na005Times,
+  code_na005Codes
+};
+const uint16_t code_na006Times[] PROGMEM = {
+  50, 62,
+  50, 172,
+  50, 4541,
+  448, 466,
+  450, 465,
+};
+const uint8_t code_na006Codes[] PROGMEM = {
+  0x64,
+  0x90,
+  0x00,
+  0x04,
+  0x90,
+  0x00,
+  0x00,
+  0x80,
+  0x00,
+  0x04,
+  0x12,
+  0x49,
+  0x2A,
+  0x12,
+  0x40,
+  0x00,
+  0x12,
+  0x40,
+  0x00,
+  0x02,
+  0x00,
+  0x00,
+  0x10,
+  0x49,
+  0x24,
+  0x90,
+};
+const struct IrCode code_na006Code PROGMEM = {
+  freq_to_timerval(38462),
+  68,		// # of pairs
+  3,		// # of bits per index
+  code_na006Times,
+  code_na006Codes
+};
+const uint16_t code_na007Times[] PROGMEM = {
+  49, 49,
+  49, 50,
+  49, 410,
+  49, 510,
+  49, 12107,
+};
+const uint8_t code_na007Codes[] PROGMEM = {
+  0x09,
+  0x94,
+  0x53,
+  0x29,
+  0x94,
+  0xD9,
+  0x85,
+  0x32,
+  0x8A,
+  0x65,
+  0x32,
+  0x9B,
+  0x20,
+};
+const struct IrCode code_na007Code PROGMEM = {
+  freq_to_timerval(39216),
+  34,		// # of pairs
+  3,		// # of bits per index
+  code_na007Times,
+  code_na007Codes
+};
+const uint16_t code_na008Times[] PROGMEM = {
+  56, 58,
+  56, 170,
+  56, 4011,
+  898, 450,
+  900, 449,
+};
+const uint8_t code_na008Codes[] PROGMEM = {
+  0x64,
+  0x00,
+  0x49,
+  0x00,
+  0x92,
+  0x00,
+  0x20,
+  0x82,
+  0x01,
+  0x04,
+  0x10,
+  0x48,
+  0x2A,
+  0x10,
+  0x01,
+  0x24,
+  0x02,
+  0x48,
+  0x00,
+  0x82,
+  0x08,
+  0x04,
+  0x10,
+  0x41,
+  0x20,
+  0x90,
+};
+const struct IrCode code_na008Code PROGMEM = {
+  freq_to_timerval(38462),
+  68,		// # of pairs
+  3,		// # of bits per index
+  code_na008Times,
+  code_na008Codes
+};
+const uint16_t code_na009Times[] PROGMEM = {
+  53, 56,
+  53, 171,
+  53, 3950,
+  53, 9599,
+  898, 451,
+  900, 226,
+};
+const uint8_t code_na009Codes[] PROGMEM = {
+  0x84,
+  0x90,
+  0x00,
+  0x20,
+  0x80,
+  0x08,
+  0x00,
+  0x00,
+  0x09,
+  0x24,
+  0x92,
+  0x40,
+  0x0A,
+  0xBA,
+  0x40,
+};
+const struct IrCode code_na009Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na009Times,
+  code_na009Codes
+};
+const uint16_t code_na010Times[] PROGMEM = {
+  51, 55,
+  51, 158,
+  51, 2286,
+  841, 419,
+};
+const uint8_t code_na010Codes[] PROGMEM = {
+  0xD4,
+  0x00,
+  0x15,
+  0x10,
+  0x25,
+  0x00,
+  0x05,
+  0x44,
+  0x09,
+  0x40,
+  0x01,
+  0x51,
+  0x01,
+};
+const struct IrCode code_na010Code PROGMEM = {
+  freq_to_timerval(38462),
+  52,		// # of pairs
+  2,		// # of bits per index
+  code_na010Times,
+  code_na010Codes
+};
+const uint16_t code_na011Times[] PROGMEM = {
+  55, 55,
+  55, 172,
+  55, 4039,
+  55, 9348,
+  56, 0,
+  884, 442,
+  885, 225,
+};
+const uint8_t code_na011Codes[] PROGMEM = {
+  0xA0,
+  0x00,
+  0x41,
+  0x04,
+  0x92,
+  0x08,
+  0x24,
+  0x90,
+  0x40,
+  0x00,
+  0x02,
+  0x09,
+  0x2B,
+  0x3D,
+  0x00,
+};
+const struct IrCode code_na011Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na011Times,
+  code_na011Codes
+};
+const uint16_t code_na012Times[] PROGMEM = {
+  81, 87,
+  81, 254,
+  81, 3280,
+  331, 336,
+  331, 337,
+};
+const uint8_t code_na012Codes[] PROGMEM = {
+  0x64,
+  0x12,
+  0x08,
+  0x24,
+  0x00,
+  0x08,
+  0x20,
+  0x10,
+  0x09,
+  0x2A,
+  0x10,
+  0x48,
+  0x20,
+  0x90,
+  0x00,
+  0x20,
+  0x80,
+  0x40,
+  0x24,
+  0x90,
+};
+const struct IrCode code_na012Code PROGMEM = {
+  freq_to_timerval(38462),
+  52,		// # of pairs
+  3,		// # of bits per index
+  code_na012Times,
+  code_na012Codes
+};
+const uint16_t code_na013Times[] PROGMEM = {
+  53, 55,
+  53, 167,
+  53, 2304,
+  53, 9369,
+  893, 448,
+  895, 447,
+};
+const uint8_t code_na013Codes[] PROGMEM = {
+  0x80,
+  0x12,
+  0x40,
+  0x04,
+  0x00,
+  0x09,
+  0x00,
+  0x12,
+  0x41,
+  0x24,
+  0x82,
+  0x01,
+  0x00,
+  0x10,
+  0x48,
+  0x24,
+  0xAA,
+  0xE8,
+};
+const struct IrCode code_na013Code PROGMEM = {
+  freq_to_timerval(38462),
+  48,		// # of pairs
+  3,		// # of bits per index
+  code_na013Times,
+  code_na013Codes
+};
+
+/* Duplicate timing table, same as na004 !
+ const uint16_t code_na014Times[] PROGMEM = {
+ 	55, 57,
+ 	55, 170,
+ 	55, 3949,
+ 	55, 9623,
+ 	56, 0,
+ 	898, 453,
+ 	900, 226,
+ };
+ */
+const uint8_t code_na014Codes[] PROGMEM = {
+  0xA0,
+  0x00,
+  0x09,
+  0x04,
+  0x92,
+  0x40,
+  0x24,
+  0x80,
+  0x00,
+  0x00,
+  0x12,
+  0x49,
+  0x2B,
+  0x3D,
+  0x00,
+};
+const struct IrCode code_na014Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na004Times,
+  code_na014Codes
+};
+
+/* Duplicate timing table, same as na004 !
+ const uint16_t code_na015Times[] PROGMEM = {
+ 	55, 57,
+ 	55, 170,
+ 	55, 3949,
+ 	55, 9623,
+ 	56, 0,
+ 	898, 453,
+ 	900, 226,
+ };
+ */
+const uint8_t code_na015Codes[] PROGMEM = {
+  0xA0,
+  0x80,
+  0x01,
+  0x04,
+  0x12,
+  0x48,
+  0x24,
+  0x00,
+  0x00,
+  0x00,
+  0x92,
+  0x49,
+  0x2B,
+  0x3D,
+  0x00,
+};
+const struct IrCode code_na015Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na004Times,
+  code_na015Codes
+};
+const uint16_t code_na016Times[] PROGMEM = {
+  28, 90,
+  28, 211,
+  28, 2507,
+};
+const uint8_t code_na016Codes[] PROGMEM = {
+  0x54,
+  0x04,
+  0x10,
+  0x00,
+  0x95,
+  0x01,
+  0x04,
+  0x00,
+  0x10,
+};
+const struct IrCode code_na016Code PROGMEM = {
+  freq_to_timerval(34483),
+  34,		// # of pairs
+  2,		// # of bits per index
+  code_na016Times,
+  code_na016Codes
+};
+const uint16_t code_na017Times[] PROGMEM = {
+  56, 57,
+  56, 175,
+  56, 4150,
+  56, 9499,
+  898, 227,
+  898, 449,
+};
+const uint8_t code_na017Codes[] PROGMEM = {
+  0xA0,
+  0x02,
+  0x48,
+  0x04,
+  0x90,
+  0x01,
+  0x20,
+  0x80,
+  0x40,
+  0x04,
+  0x12,
+  0x09,
+  0x2A,
+  0x38,
+  0x00,
+};
+const struct IrCode code_na017Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na017Codes
+};
+const uint16_t code_na018Times[] PROGMEM = {
+  51, 55,
+  51, 161,
+  51, 2566,
+  849, 429,
+  849, 430,
+};
+const uint8_t code_na018Codes[] PROGMEM = {
+  0x60,
+  0x82,
+  0x08,
+  0x24,
+  0x10,
+  0x41,
+  0x00,
+  0x12,
+  0x40,
+  0x04,
+  0x80,
+  0x09,
+  0x2A,
+  0x02,
+  0x08,
+  0x20,
+  0x90,
+  0x41,
+  0x04,
+  0x00,
+  0x49,
+  0x00,
+  0x12,
+  0x00,
+  0x24,
+  0xA8,
+  0x08,
+  0x20,
+  0x82,
+  0x41,
+  0x04,
+  0x10,
+  0x01,
+  0x24,
+  0x00,
+  0x48,
+  0x00,
+  0x92,
+  0xA0,
+  0x20,
+  0x82,
+  0x09,
+  0x04,
+  0x10,
+  0x40,
+  0x04,
+  0x90,
+  0x01,
+  0x20,
+  0x02,
+  0x48,
+};
+const struct IrCode code_na018Code PROGMEM = {
+  freq_to_timerval(38462),
+  136,		// # of pairs
+  3,		// # of bits per index
+  code_na018Times,
+  code_na018Codes
+};
+const uint16_t code_na019Times[] PROGMEM = {
+  40, 42,
+  40, 124,
+  40, 4601,
+  325, 163,
+  326, 163,
+};
+const uint8_t code_na019Codes[] PROGMEM = {
+  0x60,
+  0x10,
+  0x40,
+  0x04,
+  0x80,
+  0x09,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x10,
+  0x00,
+  0x20,
+  0x10,
+  0x00,
+  0x20,
+  0x80,
+  0x00,
+  0x0A,
+  0x00,
+  0x41,
+  0x00,
+  0x12,
+  0x00,
+  0x24,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x40,
+  0x00,
+  0x80,
+  0x40,
+  0x00,
+  0x82,
+  0x00,
+  0x00,
+  0x00,
+};
+const struct IrCode code_na019Code PROGMEM = {
+  freq_to_timerval(38462),
+  100,		// # of pairs
+  3,		// # of bits per index
+  code_na019Times,
+  code_na019Codes
+};
+const uint16_t code_na020Times[] PROGMEM = {
+  60, 55,
+  60, 163,
+  60, 4099,
+  60, 9698,
+  61, 0,
+  898, 461,
+  900, 230,
+};
+const uint8_t code_na020Codes[] PROGMEM = {
+  0xA0,
+  0x10,
+  0x00,
+  0x04,
+  0x82,
+  0x49,
+  0x20,
+  0x02,
+  0x00,
+  0x04,
+  0x90,
+  0x49,
+  0x2B,
+  0x3D,
+  0x00,
+};
+const struct IrCode code_na020Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na020Times,
+  code_na020Codes
+};
+const uint16_t code_na021Times[] PROGMEM = {
+  48, 52,
+  48, 160,
+  48, 400,
+  48, 2335,
+  799, 400,
+};
+const uint8_t code_na021Codes[] PROGMEM = {
+  0x80,
+  0x10,
+  0x40,
+  0x08,
+  0x82,
+  0x08,
+  0x01,
+  0xC0,
+  0x08,
+  0x20,
+  0x04,
+  0x41,
+  0x04,
+  0x00,
+  0x00,
+};
+const struct IrCode code_na021Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na021Times,
+  code_na021Codes
+};
+const uint16_t code_na022Times[] PROGMEM = {
+  53, 60,
+  53, 175,
+  53, 4463,
+  53, 9453,
+  892, 450,
+  895, 225,
+};
+const uint8_t code_na022Codes[] PROGMEM = {
+  0x80,
+  0x02,
+  0x40,
+  0x00,
+  0x02,
+  0x40,
+  0x00,
+  0x00,
+  0x01,
+  0x24,
+  0x92,
+  0x48,
+  0x0A,
+  0xBA,
+  0x00,
+};
+const struct IrCode code_na022Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na022Times,
+  code_na022Codes
+};
+const uint16_t code_na023Times[] PROGMEM = {
+  48, 52,
+  48, 409,
+  48, 504,
+  48, 10461,
+};
+const uint8_t code_na023Codes[] PROGMEM = {
+  0xA1,
+  0x18,
+  0x61,
+  0xA1,
+  0x18,
+  0x7A,
+  0x11,
+  0x86,
+  0x1A,
+  0x11,
+  0x86,
+};
+const struct IrCode code_na023Code PROGMEM = {
+  freq_to_timerval(40000),
+  44,		// # of pairs
+  2,		// # of bits per index
+  code_na023Times,
+  code_na023Codes
+};
+const uint16_t code_na024Times[] PROGMEM = {
+  58, 60,
+  58, 2569,
+  118, 60,
+  237, 60,
+  238, 60,
+};
+const uint8_t code_na024Codes[] PROGMEM = {
+  0x69,
+  0x24,
+  0x10,
+  0x40,
+  0x03,
+  0x12,
+  0x48,
+  0x20,
+  0x80,
+  0x00,
+};
+const struct IrCode code_na024Code PROGMEM = {
+  freq_to_timerval(38462),
+  26,		// # of pairs
+  3,		// # of bits per index
+  code_na024Times,
+  code_na024Codes
+};
+const uint16_t code_na025Times[] PROGMEM = {
+  84, 90,
+  84, 264,
+  84, 3470,
+  346, 350,
+  347, 350,
+};
+const uint8_t code_na025Codes[] PROGMEM = {
+  0x64,
+  0x92,
+  0x49,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x02,
+  0x49,
+  0x2A,
+  0x12,
+  0x49,
+  0x24,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x09,
+  0x24,
+  0x90,
+};
+const struct IrCode code_na025Code PROGMEM = {
+  freq_to_timerval(38462),
+  52,		// # of pairs
+  3,		// # of bits per index
+  code_na025Times,
+  code_na025Codes
+};
+const uint16_t code_na026Times[] PROGMEM = {
+  49, 49,
+  49, 50,
+  49, 410,
+  49, 510,
+  49, 12582,
+};
+const uint8_t code_na026Codes[] PROGMEM = {
+  0x09,
+  0x94,
+  0x53,
+  0x65,
+  0x32,
+  0x99,
+  0x85,
+  0x32,
+  0x8A,
+  0x6C,
+  0xA6,
+  0x53,
+  0x20,
+};
+const struct IrCode code_na026Code PROGMEM = {
+  freq_to_timerval(39216),
+  34,		// # of pairs
+  3,		// # of bits per index
+  code_na026Times,
+  code_na026Codes
+};
+
+/* Duplicate timing table, same as na001 !
+ const uint16_t code_na027Times[] PROGMEM = {
+ 	50, 100,
+ 	50, 200,
+ 	50, 800,
+ 	400, 400,
+ };
+ */
+const uint8_t code_na027Codes[] PROGMEM = {
+  0xC5,
+  0x41,
+  0x11,
+  0x10,
+  0x14,
+  0x44,
+  0x6C,
+  0x54,
+  0x11,
+  0x11,
+  0x01,
+  0x44,
+  0x44,
+};
+const struct IrCode code_na027Code PROGMEM = {
+  freq_to_timerval(57143),
+  52,		// # of pairs
+  2,		// # of bits per index
+  code_na001Times,
+  code_na027Codes
+};
+const uint16_t code_na028Times[] PROGMEM = {
+  118, 121,
+  118, 271,
+  118, 4750,
+  258, 271,
+};
+const uint8_t code_na028Codes[] PROGMEM = {
+  0xC4,
+  0x45,
+  0x14,
+  0x04,
+  0x6C,
+  0x44,
+  0x51,
+  0x40,
+  0x44,
+};
+const struct IrCode code_na028Code PROGMEM = {
+  freq_to_timerval(38610),
+  36,		// # of pairs
+  2,		// # of bits per index
+  code_na028Times,
+  code_na028Codes
+};
+const uint16_t code_na029Times[] PROGMEM = {
+  88, 90,
+  88, 91,
+  88, 181,
+  177, 91,
+  177, 8976,
+};
+const uint8_t code_na029Codes[] PROGMEM = {
+  0x0C,
+  0x92,
+  0x53,
+  0x46,
+  0x16,
+  0x49,
+  0x29,
+  0xA2,
+  0xC0,
+};
+const struct IrCode code_na029Code PROGMEM = {
+  freq_to_timerval(35842),
+  22,		// # of pairs
+  3,		// # of bits per index
+  code_na029Times,
+  code_na029Codes
+};
+
+/* Duplicate timing table, same as na009 !
+ const uint16_t code_na030Times[] PROGMEM = {
+ 	53, 56,
+ 	53, 171,
+ 	53, 3950,
+ 	53, 9599,
+ 	898, 451,
+ 	900, 226,
+ };
+ */
+const uint8_t code_na030Codes[] PROGMEM = {
+  0x80,
+  0x00,
+  0x41,
+  0x04,
+  0x12,
+  0x08,
+  0x20,
+  0x00,
+  0x00,
+  0x04,
+  0x92,
+  0x49,
+  0x2A,
+  0xBA,
+  0x00,
+};
+const struct IrCode code_na030Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na009Times,
+  code_na030Codes
+};
+const uint16_t code_na031Times[] PROGMEM = {
+  88, 89,
+  88, 90,
+  88, 179,
+  88, 8977,
+  177, 90,
+};
+const uint8_t code_na031Codes[] PROGMEM = {
+  0x06,
+  0x12,
+  0x49,
+  0x46,
+  0x32,
+  0x61,
+  0x24,
+  0x94,
+  0x60,
+};
+const struct IrCode code_na031Code PROGMEM = {
+  freq_to_timerval(35842),
+  24,		// # of pairs
+  3,		// # of bits per index
+  code_na031Times,
+  code_na031Codes
+};
+
+/* Duplicate timing table, same as na009 !
+ const uint16_t code_na032Times[] PROGMEM = {
+ 	53, 56,
+ 	53, 171,
+ 	53, 3950,
+ 	53, 9599,
+ 	898, 451,
+ 	900, 226,
+ };
+ */
+const uint8_t code_na032Codes[] PROGMEM = {
+  0x80,
+  0x00,
+  0x41,
+  0x04,
+  0x12,
+  0x08,
+  0x20,
+  0x80,
+  0x00,
+  0x04,
+  0x12,
+  0x49,
+  0x2A,
+  0xBA,
+  0x00,
+};
+const struct IrCode code_na032Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na009Times,
+  code_na032Codes
+};
+const uint16_t code_na033Times[] PROGMEM = {
+  40, 43,
+  40, 122,
+  40, 5297,
+  334, 156,
+  336, 155,
+};
+const uint8_t code_na033Codes[] PROGMEM = {
+  0x60,
+  0x10,
+  0x40,
+  0x04,
+  0x80,
+  0x09,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x10,
+  0x00,
+  0x20,
+  0x82,
+  0x00,
+  0x20,
+  0x00,
+  0x00,
+  0x0A,
+  0x00,
+  0x41,
+  0x00,
+  0x12,
+  0x00,
+  0x24,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x40,
+  0x00,
+  0x82,
+  0x08,
+  0x00,
+  0x80,
+  0x00,
+  0x00,
+  0x00,
+};
+const struct IrCode code_na033Code PROGMEM = {
+  freq_to_timerval(38462),
+  100,		// # of pairs
+  3,		// # of bits per index
+  code_na033Times,
+  code_na033Codes
+};
+
+/* Duplicate timing table, same as na004 !
+ const uint16_t code_na034Times[] PROGMEM = {
+ 	55, 57,
+ 	55, 170,
+ 	55, 3949,
+ 	55, 9623,
+ 	56, 0,
+ 	898, 453,
+ 	900, 226,
+ };
+ */
+const uint8_t code_na034Codes[] PROGMEM = {
+  0xA0,
+  0x00,
+  0x41,
+  0x04,
+  0x92,
+  0x08,
+  0x24,
+  0x92,
+  0x48,
+  0x00,
+  0x00,
+  0x01,
+  0x2B,
+  0x3D,
+  0x00,
+};
+const struct IrCode code_na034Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na004Times,
+  code_na034Codes
+};
+const uint16_t code_na035Times[] PROGMEM = {
+  96, 93,
+  97, 93,
+  97, 287,
+  97, 3431,
+};
+const uint8_t code_na035Codes[] PROGMEM = {
+  0x16,
+  0x66,
+  0x5D,
+  0x59,
+  0x99,
+  0x50,
+};
+const struct IrCode code_na035Code PROGMEM = {
+  freq_to_timerval(41667),
+  22,		// # of pairs
+  2,		// # of bits per index
+  code_na035Times,
+  code_na035Codes
+};
+const uint16_t code_na036Times[] PROGMEM = {
+  82, 581,
+  84, 250,
+  84, 580,
+  85, 0,
+};
+const uint8_t code_na036Codes[] PROGMEM = {
+  0x15,
+  0x9A,
+  0x9C,
+};
+const struct IrCode code_na036Code PROGMEM = {
+  freq_to_timerval(37037),
+  11,		// # of pairs
+  2,		// # of bits per index
+  code_na036Times,
+  code_na036Codes
+};
+const uint16_t code_na037Times[] PROGMEM = {
+  39, 263,
+  164, 163,
+  514, 164,
+};
+const uint8_t code_na037Codes[] PROGMEM = {
+  0x80,
+  0x45,
+  0x00,
+};
+const struct IrCode code_na037Code PROGMEM = {
+  freq_to_timerval(41667),
+  11,		// # of pairs
+  2,		// # of bits per index
+  code_na037Times,
+  code_na037Codes
+};
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na038Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na038Codes[] PROGMEM = {
+  0xA4,
+  0x10,
+  0x40,
+  0x00,
+  0x82,
+  0x09,
+  0x20,
+  0x80,
+  0x40,
+  0x04,
+  0x12,
+  0x09,
+  0x2A,
+  0x38,
+  0x40,
+};
+const struct IrCode code_na038Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na038Codes
+};
+const uint16_t code_na039Times[] PROGMEM = {
+  113, 101,
+  688, 2707,
+};
+const uint8_t code_na039Codes[] PROGMEM = {
+  0x11,
+};
+const struct IrCode code_na039Code PROGMEM = {
+  freq_to_timerval(40000),
+  4,		// # of pairs
+  2,		// # of bits per index
+  code_na039Times,
+  code_na039Codes
+};
+const uint16_t code_na040Times[] PROGMEM = {
+  113, 101,
+  113, 201,
+  113, 2707,
+};
+const uint8_t code_na040Codes[] PROGMEM = {
+  0x06,
+  0x04,
+};
+const struct IrCode code_na040Code PROGMEM = {
+  freq_to_timerval(40000),
+  8,		// # of pairs
+  2,		// # of bits per index
+  code_na040Times,
+  code_na040Codes
+};
+const uint16_t code_na041Times[] PROGMEM = {
+  58, 62,
+  58, 2746,
+  117, 62,
+  242, 62,
+};
+const uint8_t code_na041Codes[] PROGMEM = {
+  0xE2,
+  0x20,
+  0x80,
+  0x78,
+  0x88,
+  0x20,
+  0x00,
+};
+const struct IrCode code_na041Code PROGMEM = {
+  freq_to_timerval(76923),
+  26,		// # of pairs
+  2,		// # of bits per index
+  code_na041Times,
+  code_na041Codes
+};
+const uint16_t code_na042Times[] PROGMEM = {
+  54, 65,
+  54, 170,
+  54, 4099,
+  54, 8668,
+  899, 226,
+  899, 421,
+};
+const uint8_t code_na042Codes[] PROGMEM = {
+  0xA4,
+  0x80,
+  0x00,
+  0x20,
+  0x82,
+  0x49,
+  0x00,
+  0x02,
+  0x00,
+  0x04,
+  0x90,
+  0x49,
+  0x2A,
+  0x38,
+  0x40,
+};
+const struct IrCode code_na042Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na042Times,
+  code_na042Codes
+};
+const uint16_t code_na043Times[] PROGMEM = {
+  43, 120,
+  43, 121,
+  43, 3491,
+  131, 45,
+};
+const uint8_t code_na043Codes[] PROGMEM = {
+  0x15,
+  0x75,
+  0x56,
+  0x55,
+  0x75,
+  0x54,
+};
+const struct IrCode code_na043Code PROGMEM = {
+  freq_to_timerval(40000),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_na043Times,
+  code_na043Codes
+};
+const uint16_t code_na044Times[] PROGMEM = {
+  51, 51,
+  51, 160,
+  51, 4096,
+  51, 9513,
+  431, 436,
+  883, 219,
+};
+const uint8_t code_na044Codes[] PROGMEM = {
+  0x84,
+  0x90,
+  0x00,
+  0x00,
+  0x02,
+  0x49,
+  0x20,
+  0x80,
+  0x00,
+  0x04,
+  0x12,
+  0x49,
+  0x2A,
+  0xBA,
+  0x40,
+};
+const struct IrCode code_na044Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na044Times,
+  code_na044Codes
+};
+const uint16_t code_na045Times[] PROGMEM = {
+  58, 53,
+  58, 167,
+  58, 4494,
+  58, 9679,
+  455, 449,
+  456, 449,
+};
+const uint8_t code_na045Codes[] PROGMEM = {
+  0x80,
+  0x90,
+  0x00,
+  0x00,
+  0x90,
+  0x00,
+  0x04,
+  0x92,
+  0x00,
+  0x00,
+  0x00,
+  0x49,
+  0x2A,
+  0x97,
+  0x48,
+};
+const struct IrCode code_na045Code PROGMEM = {
+  freq_to_timerval(38462),
+  40,		// # of pairs
+  3,		// # of bits per index
+  code_na045Times,
+  code_na045Codes
+};
+const uint16_t code_na046Times[] PROGMEM = {
+  51, 277,
+  52, 53,
+  52, 105,
+  52, 277,
+  52, 2527,
+  52, 12809,
+  103, 54,
+};
+const uint8_t code_na046Codes[] PROGMEM = {
+  0x0B,
+  0x12,
+  0x63,
+  0x44,
+  0x92,
+  0x6B,
+  0x44,
+  0x92,
+  0x50,
+};
+const struct IrCode code_na046Code PROGMEM = {
+  freq_to_timerval(29412),
+  23,		// # of pairs
+  3,		// # of bits per index
+  code_na046Times,
+  code_na046Codes
+};
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na047Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na047Codes[] PROGMEM = {
+  0xA0,
+  0x00,
+  0x40,
+  0x04,
+  0x92,
+  0x09,
+  0x24,
+  0x92,
+  0x09,
+  0x20,
+  0x00,
+  0x40,
+  0x0A,
+  0x38,
+  0x00,
+};
+const struct IrCode code_na047Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na047Codes
+};
+
+/* Duplicate timing table, same as na044 !
+ const uint16_t code_na048Times[] PROGMEM = {
+ 	51, 51,
+ 	51, 160,
+ 	51, 4096,
+ 	51, 9513,
+ 	431, 436,
+ 	883, 219,
+ };
+ */
+const uint8_t code_na048Codes[] PROGMEM = {
+  0x80,
+  0x00,
+  0x00,
+  0x04,
+  0x92,
+  0x49,
+  0x24,
+  0x92,
+  0x00,
+  0x00,
+  0x00,
+  0x49,
+  0x2A,
+  0xBA,
+  0x00,
+};
+const struct IrCode code_na048Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na044Times,
+  code_na048Codes
+};
+const uint16_t code_na049Times[] PROGMEM = {
+  274, 854,
+  274, 1986,
+};
+const uint8_t code_na049Codes[] PROGMEM = {
+  0x14,
+  0x11,
+  0x40,
+};
+const struct IrCode code_na049Code PROGMEM = {
+  freq_to_timerval(45455),
+  11,		// # of pairs
+  2,		// # of bits per index
+  code_na049Times,
+  code_na049Codes
+};
+const uint16_t code_na050Times[] PROGMEM = {
+  80, 88,
+  80, 254,
+  80, 3750,
+  359, 331,
+};
+const uint8_t code_na050Codes[] PROGMEM = {
+  0xC0,
+  0x00,
+  0x01,
+  0x55,
+  0x55,
+  0x52,
+  0xC0,
+  0x00,
+  0x01,
+  0x55,
+  0x55,
+  0x50,
+};
+const struct IrCode code_na050Code PROGMEM = {
+  freq_to_timerval(55556),
+  48,		// # of pairs
+  2,		// # of bits per index
+  code_na050Times,
+  code_na050Codes
+};
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na051Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na051Codes[] PROGMEM = {
+  0xA0,
+  0x10,
+  0x01,
+  0x24,
+  0x82,
+  0x48,
+  0x00,
+  0x02,
+  0x40,
+  0x04,
+  0x90,
+  0x09,
+  0x2A,
+  0x38,
+  0x00,
+};
+const struct IrCode code_na051Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na051Codes
+};
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na052Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na052Codes[] PROGMEM = {
+  0xA4,
+  0x90,
+  0x48,
+  0x00,
+  0x02,
+  0x01,
+  0x20,
+  0x80,
+  0x40,
+  0x04,
+  0x12,
+  0x09,
+  0x2A,
+  0x38,
+  0x40,
+};
+const struct IrCode code_na052Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na052Codes
+};
+const uint16_t code_na053Times[] PROGMEM = {
+  51, 232,
+  51, 512,
+  51, 792,
+  51, 2883,
+};
+const uint8_t code_na053Codes[] PROGMEM = {
+  0x22,
+  0x21,
+  0x40,
+  0x1C,
+  0x88,
+  0x85,
+  0x00,
+  0x40,
+};
+const struct IrCode code_na053Code PROGMEM = {
+  freq_to_timerval(55556),
+  30,		// # of pairs
+  2,		// # of bits per index
+  code_na053Times,
+  code_na053Codes
+};
+
+/* Duplicate timing table, same as na053 !
+ const uint16_t code_na054Times[] PROGMEM = {
+ 	51, 232,
+ 	51, 512,
+ 	51, 792,
+ 	51, 2883,
+ };
+ */
+const uint8_t code_na054Codes[] PROGMEM = {
+  0x22,
+  0x20,
+  0x15,
+  0x72,
+  0x22,
+  0x01,
+  0x54,
+};
+const struct IrCode code_na054Code PROGMEM = {
+  freq_to_timerval(55556),
+  28,		// # of pairs
+  2,		// # of bits per index
+  code_na053Times,
+  code_na054Codes
+};
+const uint16_t code_na055Times[] PROGMEM = {
+  3, 10,
+  3, 20,
+  3, 30,
+  3, 12778,
+};
+const uint8_t code_na055Codes[] PROGMEM = {
+  0x81,
+  0x51,
+  0x14,
+  0xB8,
+  0x15,
+  0x11,
+  0x44,
+};
+const struct IrCode code_na055Code PROGMEM = {
+  0,              // Non-pulsed code
+  27,		// # of pairs
+  2,		// # of bits per index
+  code_na055Times,
+  code_na055Codes
+};
+const uint16_t code_na056Times[] PROGMEM = {
+  55, 193,
+  57, 192,
+  57, 384,
+  58, 0,
+};
+const uint8_t code_na056Codes[] PROGMEM = {
+  0x2A,
+  0x57,
+};
+const struct IrCode code_na056Code PROGMEM = {
+  freq_to_timerval(37175),
+  8,		// # of pairs
+  2,		// # of bits per index
+  code_na056Times,
+  code_na056Codes
+};
+const uint16_t code_na057Times[] PROGMEM = {
+  45, 148,
+  46, 148,
+  46, 351,
+  46, 2781,
+};
+const uint8_t code_na057Codes[] PROGMEM = {
+  0x2A,
+  0x5D,
+  0xA9,
+  0x60,
+};
+const struct IrCode code_na057Code PROGMEM = {
+  freq_to_timerval(40000),
+  14,		// # of pairs
+  2,		// # of bits per index
+  code_na057Times,
+  code_na057Codes
+};
+const uint16_t code_na058Times[] PROGMEM = {
+  22, 101,
+  22, 219,
+  23, 101,
+  23, 219,
+  31, 218,
+};
+const uint8_t code_na058Codes[] PROGMEM = {
+  0x8D,
+  0xA4,
+  0x08,
+  0x04,
+  0x04,
+  0x92,
+  0x4C,
+};
+const struct IrCode code_na058Code PROGMEM = {
+  freq_to_timerval(33333),
+  18,		// # of pairs
+  3,		// # of bits per index
+  code_na058Times,
+  code_na058Codes
+};
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na059Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na059Codes[] PROGMEM = {
+  0xA4,
+  0x12,
+  0x09,
+  0x00,
+  0x80,
+  0x40,
+  0x20,
+  0x10,
+  0x40,
+  0x04,
+  0x82,
+  0x09,
+  0x2A,
+  0x38,
+  0x40,
+};
+const struct IrCode code_na059Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na059Codes
+};
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na060Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na060Codes[] PROGMEM = {
+  0xA0,
+  0x00,
+  0x08,
+  0x04,
+  0x92,
+  0x41,
+  0x24,
+  0x00,
+  0x40,
+  0x00,
+  0x92,
+  0x09,
+  0x2A,
+  0x38,
+  0x00,
+};
+const struct IrCode code_na060Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na060Codes
+};
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na061Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na061Codes[] PROGMEM = {
+  0xA0,
+  0x00,
+  0x08,
+  0x24,
+  0x92,
+  0x41,
+  0x04,
+  0x82,
+  0x00,
+  0x00,
+  0x10,
+  0x49,
+  0x2A,
+  0x38,
+  0x00,
+};
+const struct IrCode code_na061Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na061Codes
+};
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na062Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na062Codes[] PROGMEM = {
+  0xA0,
+  0x02,
+  0x08,
+  0x04,
+  0x90,
+  0x41,
+  0x24,
+  0x82,
+  0x00,
+  0x00,
+  0x10,
+  0x49,
+  0x2A,
+  0x38,
+  0x00,
+};
+const struct IrCode code_na062Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na062Codes
+};
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na063Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na063Codes[] PROGMEM = {
+  0xA4,
+  0x92,
+  0x49,
+  0x20,
+  0x00,
+  0x00,
+  0x04,
+  0x92,
+  0x48,
+  0x00,
+  0x00,
+  0x01,
+  0x2A,
+  0x38,
+  0x40,
+};
+const struct IrCode code_na063Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na063Codes
+};
+
+/* Duplicate timing table, same as na001 !
+ const uint16_t code_na064Times[] PROGMEM = {
+ 	50, 100,
+ 	50, 200,
+ 	50, 800,
+ 	400, 400,
+ };
+ */
+const uint8_t code_na064Codes[] PROGMEM = {
+  0xC0,
+  0x01,
+  0x51,
+  0x55,
+  0x54,
+  0x04,
+  0x2C,
+  0x00,
+  0x15,
+  0x15,
+  0x55,
+  0x40,
+  0x40,
+};
+const struct IrCode code_na064Code PROGMEM = {
+  freq_to_timerval(57143),
+  52,		// # of pairs
+  2,		// # of bits per index
+  code_na001Times,
+  code_na064Codes
+};
+const uint16_t code_na065Times[] PROGMEM = {
+  48, 98,
+  48, 197,
+  98, 846,
+  395, 392,
+  1953, 392,
+};
+const uint8_t code_na065Codes[] PROGMEM = {
+  0x84,
+  0x92,
+  0x01,
+  0x24,
+  0x12,
+  0x00,
+  0x04,
+  0x80,
+  0x08,
+  0x09,
+  0x92,
+  0x48,
+  0x04,
+  0x90,
+  0x48,
+  0x00,
+  0x12,
+  0x00,
+  0x20,
+  0x26,
+  0x49,
+  0x20,
+  0x12,
+  0x41,
+  0x20,
+  0x00,
+  0x48,
+  0x00,
+  0x80,
+  0x80,
+};
+const struct IrCode code_na065Code PROGMEM = {
+  freq_to_timerval(59172),
+  78,		// # of pairs
+  3,		// # of bits per index
+  code_na065Times,
+  code_na065Codes
+};
+const uint16_t code_na066Times[] PROGMEM = {
+  38, 276,
+  165, 154,
+  415, 155,
+  742, 154,
+};
+const uint8_t code_na066Codes[] PROGMEM = {
+  0xC0,
+  0x45,
+  0x02,
+  0x01,
+  0x14,
+  0x08,
+  0x04,
+  0x50,
+  0x00,
+};
+const struct IrCode code_na066Code PROGMEM = {
+  freq_to_timerval(38462),
+  33,		// # of pairs
+  2,		// # of bits per index
+  code_na066Times,
+  code_na066Codes
+};
+
+/* Duplicate timing table, same as na044 !
+ const uint16_t code_na067Times[] PROGMEM = {
+ 	51, 51,
+ 	51, 160,
+ 	51, 4096,
+ 	51, 9513,
+ 	431, 436,
+ 	883, 219,
+ };
+ */
+const uint8_t code_na067Codes[] PROGMEM = {
+  0x80,
+  0x02,
+  0x49,
+  0x24,
+  0x90,
+  0x00,
+  0x00,
+  0x80,
+  0x00,
+  0x04,
+  0x12,
+  0x49,
+  0x2A,
+  0xBA,
+  0x00,
+};
+const struct IrCode code_na067Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na044Times,
+  code_na067Codes
+};
+const uint16_t code_na068Times[] PROGMEM = {
+  43, 121,
+  43, 9437,
+  130, 45,
+  131, 45,
+};
+const uint8_t code_na068Codes[] PROGMEM = {
+  0x8C,
+  0x30,
+  0x0D,
+  0xCC,
+  0x30,
+  0x0C,
+};
+const struct IrCode code_na068Code PROGMEM = {
+  freq_to_timerval(40000),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_na068Times,
+  code_na068Codes
+};
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na069Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na069Codes[] PROGMEM = {
+  0xA0,
+  0x00,
+  0x00,
+  0x04,
+  0x92,
+  0x49,
+  0x24,
+  0x82,
+  0x00,
+  0x00,
+  0x10,
+  0x49,
+  0x2A,
+  0x38,
+  0x00,
+};
+const struct IrCode code_na069Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na069Codes
+};
+const uint16_t code_na070Times[] PROGMEM = {
+  27, 76,
+  27, 182,
+  27, 183,
+  27, 3199,
+};
+const uint8_t code_na070Codes[] PROGMEM = {
+  0x40,
+  0x02,
+  0x08,
+  0xA2,
+  0xE0,
+  0x00,
+  0x82,
+  0x28,
+  0x40,
+};
+const struct IrCode code_na070Code PROGMEM = {
+  freq_to_timerval(38462),
+  33,		// # of pairs
+  2,		// # of bits per index
+  code_na070Times,
+  code_na070Codes
+};
+const uint16_t code_na071Times[] PROGMEM = {
+  37, 181,
+  37, 272,
+};
+const uint8_t code_na071Codes[] PROGMEM = {
+  0x11,
+  0x40,
+};
+const struct IrCode code_na071Code PROGMEM = {
+  freq_to_timerval(55556),
+  8,		// # of pairs
+  2,		// # of bits per index
+  code_na071Times,
+  code_na071Codes
+};
+
+/* Duplicate timing table, same as na042 !
+ const uint16_t code_na072Times[] PROGMEM = {
+ 	54, 65,
+ 	54, 170,
+ 	54, 4099,
+ 	54, 8668,
+ 	899, 226,
+ 	899, 421,
+ };
+ */
+const uint8_t code_na072Codes[] PROGMEM = {
+  0xA0,
+  0x90,
+  0x00,
+  0x00,
+  0x90,
+  0x00,
+  0x00,
+  0x10,
+  0x40,
+  0x04,
+  0x82,
+  0x09,
+  0x2A,
+  0x38,
+  0x00,
+};
+const struct IrCode code_na072Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na042Times,
+  code_na072Codes
+};
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na073Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na073Codes[] PROGMEM = {
+  0xA0,
+  0x82,
+  0x08,
+  0x24,
+  0x10,
+  0x41,
+  0x00,
+  0x00,
+  0x00,
+  0x24,
+  0x92,
+  0x49,
+  0x0A,
+  0x38,
+  0x00,
+};
+const struct IrCode code_na073Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na073Codes
+};
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na074Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na074Codes[] PROGMEM = {
+  0xA4,
+  0x00,
+  0x41,
+  0x00,
+  0x92,
+  0x08,
+  0x20,
+  0x02,
+  0x00,
+  0x04,
+  0x90,
+  0x49,
+  0x2A,
+  0x38,
+  0x40,
+};
+const struct IrCode code_na074Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na074Codes
+};
+const uint16_t code_na075Times[] PROGMEM = {
+  51, 98,
+  51, 194,
+  102, 931,
+  390, 390,
+  390, 391,
+};
+const uint8_t code_na075Codes[] PROGMEM = {
+  0x60,
+  0x00,
+  0x01,
+  0x04,
+  0x10,
+  0x49,
+  0x24,
+  0x82,
+  0x08,
+  0x2A,
+  0x00,
+  0x00,
+  0x04,
+  0x10,
+  0x41,
+  0x24,
+  0x92,
+  0x08,
+  0x20,
+  0xA0,
+};
+const struct IrCode code_na075Code PROGMEM = {
+  freq_to_timerval(41667),
+  52,		// # of pairs
+  3,		// # of bits per index
+  code_na075Times,
+  code_na075Codes
+};
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na076Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na076Codes[] PROGMEM = {
+  0xA0,
+  0x92,
+  0x09,
+  0x04,
+  0x00,
+  0x40,
+  0x20,
+  0x10,
+  0x40,
+  0x04,
+  0x82,
+  0x09,
+  0x2A,
+  0x38,
+  0x00,
+};
+const struct IrCode code_na076Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na076Codes
+};
+
+/* Duplicate timing table, same as na031 !
+ const uint16_t code_na077Times[] PROGMEM = {
+ 	88, 89,
+ 	88, 90,
+ 	88, 179,
+ 	88, 8977,
+ 	177, 90,
+ };
+ */
+const uint8_t code_na077Codes[] PROGMEM = {
+  0x10,
+  0xA2,
+  0x62,
+  0x31,
+  0x98,
+  0x51,
+  0x31,
+  0x18,
+  0x00,
+};
+const struct IrCode code_na077Code PROGMEM = {
+  freq_to_timerval(35714),
+  22,		// # of pairs
+  3,		// # of bits per index
+  code_na031Times,
+  code_na077Codes
+};
+const uint16_t code_na078Times[] PROGMEM = {
+  40, 275,
+  160, 154,
+  480, 155,
+};
+const uint8_t code_na078Codes[] PROGMEM = {
+  0x80,
+  0x45,
+  0x04,
+  0x01,
+  0x14,
+  0x10,
+  0x04,
+  0x50,
+  0x40,
+};
+const struct IrCode code_na078Code PROGMEM = {
+  freq_to_timerval(38462),
+  34,		// # of pairs
+  2,		// # of bits per index
+  code_na078Times,
+  code_na078Codes
+};
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na079Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na079Codes[] PROGMEM = {
+  0xA0,
+  0x82,
+  0x08,
+  0x24,
+  0x10,
+  0x41,
+  0x04,
+  0x90,
+  0x08,
+  0x20,
+  0x02,
+  0x41,
+  0x0A,
+  0x38,
+  0x00,
+};
+const struct IrCode code_na079Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na079Codes
+};
+
+/* Duplicate timing table, same as na055 !
+ const uint16_t code_na080Times[] PROGMEM = {
+ 	3, 10,
+ 	3, 20,
+ 	3, 30,
+ 	3, 12778,
+ };
+ */
+const uint8_t code_na080Codes[] PROGMEM = {
+  0x81,
+  0x50,
+  0x40,
+  0xB8,
+  0x15,
+  0x04,
+  0x08,
+};
+const struct IrCode code_na080Code PROGMEM = {
+  0,              // Non-pulsed code
+  27,		// # of pairs
+  2,		// # of bits per index
+  code_na055Times,
+  code_na080Codes
+};
+const uint16_t code_na081Times[] PROGMEM = {
+  48, 52,
+  48, 409,
+  48, 504,
+  48, 9978,
+};
+const uint8_t code_na081Codes[] PROGMEM = {
+  0x18,
+  0x46,
+  0x18,
+  0x68,
+  0x47,
+  0x18,
+  0x46,
+  0x18,
+  0x68,
+  0x44,
+};
+const struct IrCode code_na081Code PROGMEM = {
+  freq_to_timerval(40000),
+  40,		// # of pairs
+  2,		// # of bits per index
+  code_na081Times,
+  code_na081Codes
+};
+const uint16_t code_na082Times[] PROGMEM = {
+  88, 89,
+  88, 90,
+  88, 179,
+  88, 8888,
+  177, 90,
+  177, 179,
+};
+const uint8_t code_na082Codes[] PROGMEM = {
+  0x0A,
+  0x12,
+  0x49,
+  0x2A,
+  0xB2,
+  0xA1,
+  0x24,
+  0x92,
+  0xA8,
+};
+const struct IrCode code_na082Code PROGMEM = {
+  freq_to_timerval(35714),
+  24,		// # of pairs
+  3,		// # of bits per index
+  code_na082Times,
+  code_na082Codes
+};
+
+/* Duplicate timing table, same as na031 !
+ const uint16_t code_na083Times[] PROGMEM = {
+ 	88, 89,
+ 	88, 90,
+ 	88, 179,
+ 	88, 8977,
+ 	177, 90,
+ };
+ */
+const uint8_t code_na083Codes[] PROGMEM = {
+  0x10,
+  0x92,
+  0x49,
+  0x46,
+  0x33,
+  0x09,
+  0x24,
+  0x94,
+  0x60,
+};
+const struct IrCode code_na083Code PROGMEM = {
+  freq_to_timerval(35714),
+  24,		// # of pairs
+  3,		// # of bits per index
+  code_na031Times,
+  code_na083Codes
+};
+
+const uint16_t code_na084Times[] PROGMEM = {
+  41, 43,
+  41, 128,
+  41, 7476,
+  336, 171,
+  338, 169,
+};
+const uint8_t code_na084Codes[] PROGMEM = {
+  0x60,
+  0x80,
+  0x00,
+  0x00,
+  0x00,
+  0x08,
+  0x00,
+  0x00,
+  0x40,
+  0x20,
+  0x00,
+  0x00,
+  0x04,
+  0x12,
+  0x48,
+  0x04,
+  0x12,
+  0x08,
+  0x2A,
+  0x02,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x20,
+  0x00,
+  0x01,
+  0x00,
+  0x80,
+  0x00,
+  0x00,
+  0x10,
+  0x49,
+  0x20,
+  0x10,
+  0x48,
+  0x20,
+  0x80,
+};
+const struct IrCode code_na084Code PROGMEM = {
+  freq_to_timerval(37037),
+  100,		// # of pairs
+  3,		// # of bits per index
+  code_na084Times,
+  code_na084Codes
+};
+const uint16_t code_na085Times[] PROGMEM = {
+  55, 60,
+  55, 165,
+  55, 2284,
+  445, 437,
+  448, 436,
+};
+const uint8_t code_na085Codes[] PROGMEM = {
+  0x64,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x40,
+  0x00,
+  0x80,
+  0xA1,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x10,
+  0x00,
+  0x20,
+  0x10,
+};
+const struct IrCode code_na085Code PROGMEM = {
+  freq_to_timerval(38462),
+  44,		// # of pairs
+  3,		// # of bits per index
+  code_na085Times,
+  code_na085Codes
+};
+const uint16_t code_na086Times[] PROGMEM = {
+  42, 46,
+  42, 126,
+  42, 6989,
+  347, 176,
+  347, 177,
+};
+const uint8_t code_na086Codes[] PROGMEM = {
+  0x60,
+  0x82,
+  0x08,
+  0x20,
+  0x82,
+  0x41,
+  0x04,
+  0x92,
+  0x00,
+  0x20,
+  0x80,
+  0x40,
+  0x00,
+  0x90,
+  0x40,
+  0x04,
+  0x00,
+  0x41,
+  0x2A,
+  0x02,
+  0x08,
+  0x20,
+  0x82,
+  0x09,
+  0x04,
+  0x12,
+  0x48,
+  0x00,
+  0x82,
+  0x01,
+  0x00,
+  0x02,
+  0x41,
+  0x00,
+  0x10,
+  0x01,
+  0x04,
+  0x80,
+};
+const struct IrCode code_na086Code PROGMEM = {
+  freq_to_timerval(37175),
+  100,		// # of pairs
+  3,		// # of bits per index
+  code_na086Times,
+  code_na086Codes
+};
+const uint16_t code_na087Times[] PROGMEM = {
+  56, 69,
+  56, 174,
+  56, 4165,
+  56, 9585,
+  880, 222,
+  880, 435,
+};
+const uint8_t code_na087Codes[] PROGMEM = {
+  0xA0,
+  0x02,
+  0x40,
+  0x04,
+  0x90,
+  0x09,
+  0x20,
+  0x02,
+  0x00,
+  0x04,
+  0x90,
+  0x49,
+  0x2A,
+  0x38,
+  0x00,
+};
+const struct IrCode code_na087Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na087Times,
+  code_na087Codes
+};
+
+/* Duplicate timing table, same as na009 !
+ const uint16_t code_na088Times[] PROGMEM = {
+ 	53, 56,
+ 	53, 171,
+ 	53, 3950,
+ 	53, 9599,
+ 	898, 451,
+ 	900, 226,
+ };
+ */
+const uint8_t code_na088Codes[] PROGMEM = {
+  0x80,
+  0x00,
+  0x40,
+  0x04,
+  0x12,
+  0x08,
+  0x04,
+  0x92,
+  0x40,
+  0x00,
+  0x00,
+  0x09,
+  0x2A,
+  0xBA,
+  0x00,
+};
+const struct IrCode code_na088Code PROGMEM = {
+  freq_to_timerval(38610),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na009Times,
+  code_na088Codes
+};
+
+/* Duplicate timing table, same as na004 !
+ const uint16_t code_na089Times[] PROGMEM = {
+ 	55, 57,
+ 	55, 170,
+ 	55, 3949,
+ 	55, 9623,
+ 	56, 0,
+ 	898, 453,
+ 	900, 226,
+ };
+ */
+const uint8_t code_na089Codes[] PROGMEM = {
+  0xA0,
+  0x02,
+  0x00,
+  0x04,
+  0x90,
+  0x49,
+  0x20,
+  0x80,
+  0x40,
+  0x04,
+  0x12,
+  0x09,
+  0x2B,
+  0x3D,
+  0x00,
+};
+const struct IrCode code_na089Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na004Times,
+  code_na089Codes
+};
+const uint16_t code_na090Times[] PROGMEM = {
+  88, 90,
+  88, 91,
+  88, 181,
+  88, 8976,
+  177, 91,
+  177, 181,
+};
+const uint8_t code_na090Codes[] PROGMEM = {
+  0x10,
+  0xAB,
+  0x11,
+  0x8C,
+  0xC2,
+  0xAC,
+  0x46,
+  0x00,
+};
+const struct IrCode code_na090Code PROGMEM = {
+  freq_to_timerval(35714),
+  20,		// # of pairs
+  3,		// # of bits per index
+  code_na090Times,
+  code_na090Codes
+};
+const uint16_t code_na091Times[] PROGMEM = {
+  48, 100,
+  48, 200,
+  48, 1050,
+  400, 400,
+};
+const uint8_t code_na091Codes[] PROGMEM = {
+  0xD5,
+  0x41,
+  0x51,
+  0x40,
+  0x14,
+  0x04,
+  0x2D,
+  0x54,
+  0x15,
+  0x14,
+  0x01,
+  0x40,
+  0x41,
+};
+const struct IrCode code_na091Code PROGMEM = {
+  freq_to_timerval(58824),
+  52,		// # of pairs
+  2,		// # of bits per index
+  code_na091Times,
+  code_na091Codes
+};
+const uint16_t code_na092Times[] PROGMEM = {
+  54, 56,
+  54, 170,
+  54, 4927,
+  451, 447,
+};
+const uint8_t code_na092Codes[] PROGMEM = {
+  0xD1,
+  0x00,
+  0x11,
+  0x00,
+  0x04,
+  0x00,
+  0x11,
+  0x55,
+  0x6D,
+  0x10,
+  0x01,
+  0x10,
+  0x00,
+  0x40,
+  0x01,
+  0x15,
+  0x55,
+};
+const struct IrCode code_na092Code PROGMEM = {
+  freq_to_timerval(38462),
+  68,		// # of pairs
+  2,		// # of bits per index
+  code_na092Times,
+  code_na092Codes
+};
+const uint16_t code_na093Times[] PROGMEM = {
+  55, 57,
+  55, 167,
+  55, 4400,
+  895, 448,
+  897, 447,
+};
+const uint8_t code_na093Codes[] PROGMEM = {
+  0x60,
+  0x90,
+  0x00,
+  0x20,
+  0x80,
+  0x00,
+  0x04,
+  0x02,
+  0x01,
+  0x00,
+  0x90,
+  0x48,
+  0x2A,
+  0x02,
+  0x40,
+  0x00,
+  0x82,
+  0x00,
+  0x00,
+  0x10,
+  0x08,
+  0x04,
+  0x02,
+  0x41,
+  0x20,
+  0x80,
+};
+const struct IrCode code_na093Code PROGMEM = {
+  freq_to_timerval(38462),
+  68,		// # of pairs
+  3,		// # of bits per index
+  code_na093Times,
+  code_na093Codes
+};
+
+/* Duplicate timing table, same as na005 !
+ const uint16_t code_na094Times[] PROGMEM = {
+ 	88, 90,
+ 	88, 91,
+ 	88, 181,
+ 	88, 8976,
+ 	177, 91,
+ };
+ */
+const uint8_t code_na094Codes[] PROGMEM = {
+  0x10,
+  0x94,
+  0x62,
+  0x31,
+  0x98,
+  0x4A,
+  0x31,
+  0x18,
+  0x00,
+};
+const struct IrCode code_na094Code PROGMEM = {
+  freq_to_timerval(35714),
+  22,		// # of pairs
+  3,		// # of bits per index
+  code_na005Times,
+  code_na094Codes
+};
+const uint16_t code_na095Times[] PROGMEM = {
+  56, 58,
+  56, 174,
+  56, 4549,
+  56, 9448,
+  440, 446,
+};
+const uint8_t code_na095Codes[] PROGMEM = {
+  0x80,
+  0x02,
+  0x00,
+  0x00,
+  0x02,
+  0x00,
+  0x04,
+  0x82,
+  0x00,
+  0x00,
+  0x10,
+  0x49,
+  0x2A,
+  0x17,
+  0x08,
+};
+const struct IrCode code_na095Code PROGMEM = {
+  freq_to_timerval(38462),
+  40,		// # of pairs
+  3,		// # of bits per index
+  code_na095Times,
+  code_na095Codes
+};
+
+/* Duplicate timing table, same as na009 !
+ const uint16_t code_na096Times[] PROGMEM = {
+ 	53, 56,
+ 	53, 171,
+ 	53, 3950,
+ 	53, 9599,
+ 	898, 451,
+ 	900, 226,
+ };
+ */
+const uint8_t code_na096Codes[] PROGMEM = {
+  0x80,
+  0x80,
+  0x40,
+  0x04,
+  0x92,
+  0x49,
+  0x20,
+  0x92,
+  0x00,
+  0x04,
+  0x00,
+  0x49,
+  0x2A,
+  0xBA,
+  0x00,
+};
+const struct IrCode code_na096Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na009Times,
+  code_na096Codes
+};
+
+/* Duplicate timing table, same as na009 !
+ const uint16_t code_na097Times[] PROGMEM = {
+ 	53, 56,
+ 	53, 171,
+ 	53, 3950,
+ 	53, 9599,
+ 	898, 451,
+ 	900, 226,
+ };
+ */
+const uint8_t code_na097Codes[] PROGMEM = {
+  0x84,
+  0x80,
+  0x00,
+  0x24,
+  0x10,
+  0x41,
+  0x00,
+  0x80,
+  0x01,
+  0x24,
+  0x12,
+  0x48,
+  0x0A,
+  0xBA,
+  0x40,
+};
+const struct IrCode code_na097Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na009Times,
+  code_na097Codes
+};
+
+/* Duplicate timing table, same as na004 !
+ const uint16_t code_na098Times[] PROGMEM = {
+ 	55, 57,
+ 	55, 170,
+ 	55, 3949,
+ 	55, 9623,
+ 	56, 0,
+ 	898, 453,
+ 	900, 226,
+ };
+ */
+const uint8_t code_na098Codes[] PROGMEM = {
+  0xA0,
+  0x00,
+  0x00,
+  0x04,
+  0x92,
+  0x49,
+  0x24,
+  0x00,
+  0x41,
+  0x00,
+  0x92,
+  0x08,
+  0x2B,
+  0x3D,
+  0x00,
+};
+const struct IrCode code_na098Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na004Times,
+  code_na098Codes
+};
+
+/* Duplicate timing table, same as na009 !
+ const uint16_t code_na099Times[] PROGMEM = {
+ 	53, 56,
+ 	53, 171,
+ 	53, 3950,
+ 	53, 9599,
+ 	898, 451,
+ 	900, 226,
+ };
+ */
+const uint8_t code_na099Codes[] PROGMEM = {
+  0x80,
+  0x00,
+  0x00,
+  0x04,
+  0x12,
+  0x48,
+  0x24,
+  0x00,
+  0x00,
+  0x00,
+  0x92,
+  0x49,
+  0x2A,
+  0xBA,
+  0x00,
+};
+const struct IrCode code_na099Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na009Times,
+  code_na099Codes
+};
+const uint16_t code_na100Times[] PROGMEM = {
+  43, 171,
+  45, 60,
+  45, 170,
+  54, 2301,
+};
+const uint8_t code_na100Codes[] PROGMEM = {
+  0x29,
+  0x59,
+  0x65,
+  0x55,
+  0xEA,
+  0x56,
+  0x59,
+  0x55,
+  0x70,
+};
+const struct IrCode code_na100Code PROGMEM = {
+  freq_to_timerval(35842),
+  34,		// # of pairs
+  2,		// # of bits per index
+  code_na100Times,
+  code_na100Codes
+};
+
+/* Duplicate timing table, same as na004 !
+ const uint16_t code_na101Times[] PROGMEM = {
+ 	55, 57,
+ 	55, 170,
+ 	55, 3949,
+ 	55, 9623,
+ 	56, 0,
+ 	898, 453,
+ 	900, 226,
+ };
+ */
+const uint8_t code_na101Codes[] PROGMEM = {
+  0xA0,
+  0x00,
+  0x09,
+  0x04,
+  0x92,
+  0x40,
+  0x20,
+  0x00,
+  0x00,
+  0x04,
+  0x92,
+  0x49,
+  0x2B,
+  0x3D,
+  0x00,
+};
+const struct IrCode code_na101Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na004Times,
+  code_na101Codes
+};
+const uint16_t code_na102Times[] PROGMEM = {
+  86, 87,
+  86, 258,
+  86, 3338,
+  346, 348,
+  348, 347,
+};
+const uint8_t code_na102Codes[] PROGMEM = {
+  0x64,
+  0x02,
+  0x08,
+  0x00,
+  0x02,
+  0x09,
+  0x04,
+  0x12,
+  0x49,
+  0x0A,
+  0x10,
+  0x08,
+  0x20,
+  0x00,
+  0x08,
+  0x24,
+  0x10,
+  0x49,
+  0x24,
+  0x10,
+};
+const struct IrCode code_na102Code PROGMEM = {
+  freq_to_timerval(40000),
+  52,		// # of pairs
+  3,		// # of bits per index
+  code_na102Times,
+  code_na102Codes
+};
+
+/* Duplicate timing table, same as na045 !
+ const uint16_t code_na103Times[] PROGMEM = {
+ 	58, 53,
+ 	58, 167,
+ 	58, 4494,
+ 	58, 9679,
+ 	455, 449,
+ 	456, 449,
+ };
+ */
+const uint8_t code_na103Codes[] PROGMEM = {
+  0x80,
+  0x02,
+  0x00,
+  0x00,
+  0x02,
+  0x00,
+  0x04,
+  0x92,
+  0x00,
+  0x00,
+  0x00,
+  0x49,
+  0x2A,
+  0x97,
+  0x48,
+};
+const struct IrCode code_na103Code PROGMEM = {
+  freq_to_timerval(38462),
+  40,		// # of pairs
+  3,		// # of bits per index
+  code_na045Times,
+  code_na103Codes
+};
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na104Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na104Codes[] PROGMEM = {
+  0xA4,
+  0x00,
+  0x49,
+  0x00,
+  0x92,
+  0x00,
+  0x20,
+  0x02,
+  0x00,
+  0x04,
+  0x90,
+  0x49,
+  0x2A,
+  0x38,
+  0x40,
+};
+const struct IrCode code_na104Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na104Codes
+};
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na105Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na105Codes[] PROGMEM = {
+  0xA4,
+  0x80,
+  0x00,
+  0x20,
+  0x12,
+  0x49,
+  0x04,
+  0x92,
+  0x49,
+  0x20,
+  0x00,
+  0x00,
+  0x0A,
+  0x38,
+  0x40,
+};
+const struct IrCode code_na105Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na105Codes
+};
+
+/* Duplicate timing table, same as na044 !
+ const uint16_t code_na106Times[] PROGMEM = {
+ 	51, 51,
+ 	51, 160,
+ 	51, 4096,
+ 	51, 9513,
+ 	431, 436,
+ 	883, 219,
+ };
+ */
+const uint8_t code_na106Codes[] PROGMEM = {
+  0x80,
+  0x02,
+  0x00,
+  0x04,
+  0x90,
+  0x49,
+  0x24,
+  0x92,
+  0x00,
+  0x00,
+  0x00,
+  0x49,
+  0x2A,
+  0xBA,
+  0x00,
+};
+const struct IrCode code_na106Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na044Times,
+  code_na106Codes
+};
+
+/* Duplicate timing table, same as na045 !
+ const uint16_t code_na107Times[] PROGMEM = {
+ 	58, 53,
+ 	58, 167,
+ 	58, 4494,
+ 	58, 9679,
+ 	455, 449,
+ 	456, 449,
+ };
+ */
+const uint8_t code_na107Codes[] PROGMEM = {
+  0x80,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x04,
+  0x92,
+  0x00,
+  0x00,
+  0x00,
+  0x49,
+  0x2A,
+  0x97,
+  0x48,
+};
+const struct IrCode code_na107Code PROGMEM = {
+  freq_to_timerval(38462),
+  40,		// # of pairs
+  3,		// # of bits per index
+  code_na045Times,
+  code_na107Codes
+};
+
+/* Duplicate timing table, same as na045 !
+ const uint16_t code_na108Times[] PROGMEM = {
+ 	58, 53,
+ 	58, 167,
+ 	58, 4494,
+ 	58, 9679,
+ 	455, 449,
+ 	456, 449,
+ };
+ */
+const uint8_t code_na108Codes[] PROGMEM = {
+  0x80,
+  0x90,
+  0x40,
+  0x00,
+  0x90,
+  0x40,
+  0x04,
+  0x92,
+  0x00,
+  0x00,
+  0x00,
+  0x49,
+  0x2A,
+  0x97,
+  0x48,
+};
+const struct IrCode code_na108Code PROGMEM = {
+  freq_to_timerval(38462),
+  40,		// # of pairs
+  3,		// # of bits per index
+  code_na045Times,
+  code_na108Codes
+};
+const uint16_t code_na109Times[] PROGMEM = {
+  58, 61,
+  58, 211,
+  58, 9582,
+  73, 4164,
+  883, 211,
+  1050, 494,
+};
+const uint8_t code_na109Codes[] PROGMEM = {
+  0xA0,
+  0x00,
+  0x08,
+  0x24,
+  0x92,
+  0x41,
+  0x00,
+  0x82,
+  0x00,
+  0x04,
+  0x10,
+  0x49,
+  0x2E,
+  0x28,
+  0x00,
+};
+const struct IrCode code_na109Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na109Times,
+  code_na109Codes
+};
+
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na110Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na110Codes[] PROGMEM = {
+  0xA4,
+  0x80,
+  0x00,
+  0x20,
+  0x12,
+  0x49,
+  0x00,
+  0x02,
+  0x00,
+  0x04,
+  0x90,
+  0x49,
+  0x2A,
+  0x38,
+  0x40,
+};
+const struct IrCode code_na110Code PROGMEM = {
+  freq_to_timerval(40161),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na110Codes
+};
+
+/* Duplicate timing table, same as na044 !
+ const uint16_t code_na111Times[] PROGMEM = {
+ 	51, 51,
+ 	51, 160,
+ 	51, 4096,
+ 	51, 9513,
+ 	431, 436,
+ 	883, 219,
+ };
+ */
+const uint8_t code_na111Codes[] PROGMEM = {
+  0x84,
+  0x92,
+  0x49,
+  0x20,
+  0x00,
+  0x00,
+  0x04,
+  0x92,
+  0x00,
+  0x00,
+  0x00,
+  0x49,
+  0x2A,
+  0xBA,
+  0x40,
+};
+const struct IrCode code_na111Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na044Times,
+  code_na111Codes
+};
+
+/* Duplicate timing table, same as na004 !
+ const uint16_t code_na112Times[] PROGMEM = {
+ 	55, 57,
+ 	55, 170,
+ 	55, 3949,
+ 	55, 9623,
+ 	56, 0,
+ 	898, 453,
+ 	900, 226,
+ };
+ */
+const uint8_t code_na112Codes[] PROGMEM = {
+  0xA4,
+  0x00,
+  0x00,
+  0x00,
+  0x92,
+  0x49,
+  0x24,
+  0x00,
+  0x00,
+  0x00,
+  0x92,
+  0x49,
+  0x2B,
+  0x3D,
+  0x00,
+};
+const struct IrCode code_na112Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na004Times,
+  code_na112Codes
+};
+const uint16_t code_na113Times[] PROGMEM = {
+  56, 54,
+  56, 166,
+  56, 3945,
+  896, 442,
+  896, 443,
+};
+const uint8_t code_na113Codes[] PROGMEM = {
+  0x60,
+  0x00,
+  0x00,
+  0x20,
+  0x02,
+  0x09,
+  0x04,
+  0x02,
+  0x01,
+  0x00,
+  0x90,
+  0x48,
+  0x2A,
+  0x00,
+  0x00,
+  0x00,
+  0x80,
+  0x08,
+  0x24,
+  0x10,
+  0x08,
+  0x04,
+  0x02,
+  0x41,
+  0x20,
+  0x80,
+};
+const struct IrCode code_na113Code PROGMEM = {
+  freq_to_timerval(40000),
+  68,		// # of pairs
+  3,		// # of bits per index
+  code_na113Times,
+  code_na113Codes
+};
+const uint16_t code_na114Times[] PROGMEM = {
+  44, 50,
+  44, 147,
+  44, 447,
+  44, 2236,
+  791, 398,
+  793, 397,
+};
+const uint8_t code_na114Codes[] PROGMEM = {
+  0x84,
+  0x10,
+  0x40,
+  0x08,
+  0x82,
+  0x08,
+  0x01,
+  0xD2,
+  0x08,
+  0x20,
+  0x04,
+  0x41,
+  0x04,
+  0x00,
+  0x40,
+};
+const struct IrCode code_na114Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na114Times,
+  code_na114Codes
+};
+
+
+const uint16_t code_na115Times[] PROGMEM = {
+  81, 86,
+  81, 296,
+  81, 3349,
+  328, 331,
+  329, 331,
+};
+const uint8_t code_na115Codes[] PROGMEM = {
+  0x60,
+  0x82,
+  0x00,
+  0x20,
+  0x80,
+  0x41,
+  0x04,
+  0x90,
+  0x41,
+  0x2A,
+  0x02,
+  0x08,
+  0x00,
+  0x82,
+  0x01,
+  0x04,
+  0x12,
+  0x41,
+  0x04,
+  0x80,
+};
+const struct IrCode code_na115Code PROGMEM = {
+  freq_to_timerval(40000),
+  52,		// # of pairs
+  3,		// # of bits per index
+  code_na115Times,
+  code_na115Codes
+};
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na116Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na116Codes[] PROGMEM = {
+  0xA0,
+  0x00,
+  0x40,
+  0x04,
+  0x92,
+  0x09,
+  0x24,
+  0x00,
+  0x40,
+  0x00,
+  0x92,
+  0x09,
+  0x2A,
+  0x38,
+  0x00,
+};
+const struct IrCode code_na116Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na116Codes
+};
+const uint16_t code_na117Times[] PROGMEM = {
+  49, 54,
+  49, 158,
+  49, 420,
+  49, 2446,
+  819, 420,
+  821, 419,
+};
+const uint8_t code_na117Codes[] PROGMEM = {
+  0x84,
+  0x00,
+  0x00,
+  0x08,
+  0x12,
+  0x40,
+  0x01,
+  0xD2,
+  0x00,
+  0x00,
+  0x04,
+  0x09,
+  0x20,
+  0x00,
+  0x40,
+};
+const struct IrCode code_na117Code PROGMEM = {
+  freq_to_timerval(41667),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na117Times,
+  code_na117Codes
+};
+
+/* Duplicate timing table, same as na044 !
+ const uint16_t code_na118Times[] PROGMEM = {
+ 	51, 51,
+ 	51, 160,
+ 	51, 4096,
+ 	51, 9513,
+ 	431, 436,
+ 	883, 219,
+ };
+ */
+const uint8_t code_na118Codes[] PROGMEM = {
+  0x84,
+  0x90,
+  0x49,
+  0x20,
+  0x02,
+  0x00,
+  0x04,
+  0x92,
+  0x00,
+  0x00,
+  0x00,
+  0x49,
+  0x2A,
+  0xBA,
+  0x40,
+};
+const struct IrCode code_na118Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na044Times,
+  code_na118Codes
+};
+const uint16_t code_na119Times[] PROGMEM = {
+  55, 63,
+  55, 171,
+  55, 4094,
+  55, 9508,
+  881, 219,
+  881, 438,
+};
+const uint8_t code_na119Codes[] PROGMEM = {
+  0xA0,
+  0x10,
+  0x00,
+  0x04,
+  0x82,
+  0x49,
+  0x20,
+  0x02,
+  0x00,
+  0x04,
+  0x90,
+  0x49,
+  0x2A,
+  0x38,
+  0x00,
+};
+const struct IrCode code_na119Code PROGMEM = {
+  freq_to_timerval(55556),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na119Times,
+  code_na119Codes
+};
+
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na120Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na120Codes[] PROGMEM = {
+  0xA0,
+  0x12,
+  0x00,
+  0x04,
+  0x80,
+  0x49,
+  0x24,
+  0x92,
+  0x40,
+  0x00,
+  0x00,
+  0x09,
+  0x2A,
+  0x38,
+  0x00,
+};
+const struct IrCode code_na120Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na120Codes
+};
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na121Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na121Codes[] PROGMEM = {
+  0xA0,
+  0x00,
+  0x40,
+  0x04,
+  0x92,
+  0x09,
+  0x20,
+  0x02,
+  0x00,
+  0x04,
+  0x90,
+  0x49,
+  0x2A,
+  0x38,
+  0x00,
+};
+const struct IrCode code_na121Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na121Codes
+};
+const uint16_t code_na122Times[] PROGMEM = {
+  80, 95,
+  80, 249,
+  80, 3867,
+  81, 0,
+  329, 322,
+};
+const uint8_t code_na122Codes[] PROGMEM = {
+  0x80,
+  0x00,
+  0x00,
+  0x00,
+  0x12,
+  0x49,
+  0x24,
+  0x90,
+  0x0A,
+  0x80,
+  0x00,
+  0x00,
+  0x00,
+  0x12,
+  0x49,
+  0x24,
+  0x90,
+  0x0B,
+};
+const struct IrCode code_na122Code PROGMEM = {
+  freq_to_timerval(52632),
+  48,		// # of pairs
+  3,		// # of bits per index
+  code_na122Times,
+  code_na122Codes
+};
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na123Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na123Codes[] PROGMEM = {
+  0xA0,
+  0x02,
+  0x48,
+  0x04,
+  0x90,
+  0x01,
+  0x20,
+  0x12,
+  0x40,
+  0x04,
+  0x80,
+  0x09,
+  0x2A,
+  0x38,
+  0x00,
+};
+const struct IrCode code_na123Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na123Codes
+};
+const uint16_t code_na124Times[] PROGMEM = {
+  54, 56,
+  54, 151,
+  54, 4092,
+  54, 8677,
+  900, 421,
+  901, 226,
+};
+const uint8_t code_na124Codes[] PROGMEM = {
+  0x80,
+  0x00,
+  0x48,
+  0x04,
+  0x92,
+  0x01,
+  0x20,
+  0x00,
+  0x00,
+  0x04,
+  0x92,
+  0x49,
+  0x2A,
+  0xBA,
+  0x00,
+};
+const struct IrCode code_na124Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na124Times,
+  code_na124Codes
+};
+
+/* Duplicate timing table, same as na119 !
+ const uint16_t code_na125Times[] PROGMEM = {
+ 	55, 63,
+ 	55, 171,
+ 	55, 4094,
+ 	55, 9508,
+ 	881, 219,
+ 	881, 438,
+ };
+ */
+const uint8_t code_na125Codes[] PROGMEM = {
+  0xA0,
+  0x02,
+  0x48,
+  0x04,
+  0x90,
+  0x01,
+  0x20,
+  0x80,
+  0x40,
+  0x04,
+  0x12,
+  0x09,
+  0x2A,
+  0x38,
+  0x00,
+};
+const struct IrCode code_na125Code PROGMEM = {
+  freq_to_timerval(55556),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na119Times,
+  code_na125Codes
+};
+
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na126Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na126Codes[] PROGMEM = {
+  0xA4,
+  0x10,
+  0x00,
+  0x20,
+  0x82,
+  0x49,
+  0x00,
+  0x02,
+  0x00,
+  0x04,
+  0x90,
+  0x49,
+  0x2A,
+  0x38,
+  0x40,
+};
+const struct IrCode code_na126Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na126Codes
+};
+const uint16_t code_na127Times[] PROGMEM = {
+  114, 100,
+  115, 100,
+  115, 200,
+  115, 2706,
+};
+const uint8_t code_na127Codes[] PROGMEM = {
+  0x1B,
+  0x59,
+};
+const struct IrCode code_na127Code PROGMEM = {
+  freq_to_timerval(25641),
+  8,		// # of pairs
+  2,		// # of bits per index
+  code_na127Times,
+  code_na127Codes
+};
+
+/* Duplicate timing table, same as na102 !
+ const uint16_t code_na128Times[] PROGMEM = {
+ 	86, 87,
+ 	86, 258,
+ 	86, 3338,
+ 	346, 348,
+ 	348, 347,
+ };
+ */
+const uint8_t code_na128Codes[] PROGMEM = {
+  0x60,
+  0x02,
+  0x08,
+  0x00,
+  0x02,
+  0x49,
+  0x04,
+  0x12,
+  0x49,
+  0x0A,
+  0x00,
+  0x08,
+  0x20,
+  0x00,
+  0x09,
+  0x24,
+  0x10,
+  0x49,
+  0x24,
+  0x00,
+};
+const struct IrCode code_na128Code PROGMEM = {
+  freq_to_timerval(40000),
+  52,		// # of pairs
+  3,		// # of bits per index
+  code_na102Times,
+  code_na128Codes
+};
+
+/* Duplicate timing table, same as na017 !
+ const uint16_t code_na129Times[] PROGMEM = {
+ 	56, 57,
+ 	56, 175,
+ 	56, 4150,
+ 	56, 9499,
+ 	898, 227,
+ 	898, 449,
+ };
+ */
+const uint8_t code_na129Codes[] PROGMEM = {
+  0xA4,
+  0x92,
+  0x49,
+  0x20,
+  0x00,
+  0x00,
+  0x00,
+  0x02,
+  0x00,
+  0x04,
+  0x90,
+  0x49,
+  0x2A,
+  0x38,
+  0x40,
+};
+const struct IrCode code_na129Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na017Times,
+  code_na129Codes
+};
+const uint16_t code_na130Times[] PROGMEM = {
+  88, 90,
+  88, 258,
+  88, 2247,
+  358, 349,
+  358, 350,
+};
+const uint8_t code_na130Codes[] PROGMEM = {
+  0x64,
+  0x00,
+  0x08,
+  0x24,
+  0x82,
+  0x09,
+  0x24,
+  0x10,
+  0x01,
+  0x0A,
+  0x10,
+  0x00,
+  0x20,
+  0x92,
+  0x08,
+  0x24,
+  0x90,
+  0x40,
+  0x04,
+  0x10,
+};
+const struct IrCode code_na130Code PROGMEM = {
+  freq_to_timerval(37037),
+  52,		// # of pairs
+  3,		// # of bits per index
+  code_na130Times,
+  code_na130Codes
+};
+
+/* Duplicate timing table, same as na042 !
+ const uint16_t code_na131Times[] PROGMEM = {
+ 	54, 65,
+ 	54, 170,
+ 	54, 4099,
+ 	54, 8668,
+ 	899, 226,
+ 	899, 421,
+ };
+ */
+const uint8_t code_na131Codes[] PROGMEM = {
+  0xA0,
+  0x10,
+  0x40,
+  0x04,
+  0x82,
+  0x09,
+  0x24,
+  0x82,
+  0x40,
+  0x00,
+  0x10,
+  0x09,
+  0x2A,
+  0x38,
+  0x00,
+};
+const struct IrCode code_na131Code PROGMEM = {
+  freq_to_timerval(40000),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na042Times,
+  code_na131Codes
+};
+const uint16_t code_na132Times[] PROGMEM = {
+  28, 106,
+  28, 238,
+  28, 370,
+  28, 1173,
+};
+const uint8_t code_na132Codes[] PROGMEM = {
+  0x22,
+  0x20,
+  0x00,
+  0x17,
+  0x22,
+  0x20,
+  0x00,
+  0x14,
+};
+const struct IrCode code_na132Code PROGMEM = {
+  freq_to_timerval(83333),
+  32,		// # of pairs
+  2,		// # of bits per index
+  code_na132Times,
+  code_na132Codes
+};
+const uint16_t code_na133Times[] PROGMEM = {
+  13, 741,
+  15, 489,
+  15, 740,
+  17, 4641,
+  18, 0,
+};
+const uint8_t code_na133Codes[] PROGMEM = {
+  0x09,
+  0x24,
+  0x49,
+  0x48,
+  0xB4,
+  0x92,
+  0x44,
+  0x94,
+  0x8C,
+};
+const struct IrCode code_na133Code PROGMEM = {
+  freq_to_timerval(41667),
+  24,		// # of pairs
+  3,		// # of bits per index
+  code_na133Times,
+  code_na133Codes
+};
+
+/* Duplicate timing table, same as na113 !
+ const uint16_t code_na134Times[] PROGMEM = {
+ 	56, 54,
+ 	56, 166,
+ 	56, 3945,
+ 	896, 442,
+ 	896, 443,
+ };
+ */
+const uint8_t code_na134Codes[] PROGMEM = {
+  0x60,
+  0x90,
+  0x00,
+  0x24,
+  0x10,
+  0x00,
+  0x04,
+  0x92,
+  0x00,
+  0x00,
+  0x00,
+  0x49,
+  0x2A,
+  0x02,
+  0x40,
+  0x00,
+  0x90,
+  0x40,
+  0x00,
+  0x12,
+  0x48,
+  0x00,
+  0x00,
+  0x01,
+  0x24,
+  0x80,
+};
+const struct IrCode code_na134Code PROGMEM = {
+  freq_to_timerval(40000),
+  68,		// # of pairs
+  3,		// # of bits per index
+  code_na113Times,
+  code_na134Codes
+};
+const uint16_t code_na135Times[] PROGMEM = {
+  53, 59,
+  53, 171,
+  53, 2301,
+  892, 450,
+  895, 448,
+};
+const uint8_t code_na135Codes[] PROGMEM = {
+  0x60,
+  0x12,
+  0x49,
+  0x00,
+  0x00,
+  0x09,
+  0x00,
+  0x00,
+  0x49,
+  0x24,
+  0x80,
+  0x00,
+  0x00,
+  0x12,
+  0x49,
+  0x24,
+  0xA8,
+  0x01,
+  0x24,
+  0x90,
+  0x00,
+  0x00,
+  0x90,
+  0x00,
+  0x04,
+  0x92,
+  0x48,
+  0x00,
+  0x00,
+  0x01,
+  0x24,
+  0x92,
+  0x48,
+};
+const struct IrCode code_na135Code PROGMEM = {
+  freq_to_timerval(38462),
+  88,		// # of pairs
+  3,		// # of bits per index
+  code_na135Times,
+  code_na135Codes
+};
+const uint16_t code_na136Times[] PROGMEM = {
+  53, 59,
+  53, 171,
+  53, 2301,
+  55, 0,
+  892, 450,
+  895, 448,
+};
+const uint8_t code_na136Codes[] PROGMEM = {
+  0x84,
+  0x82,
+  0x49,
+  0x00,
+  0x00,
+  0x00,
+  0x20,
+  0x00,
+  0x49,
+  0x24,
+  0x80,
+  0x00,
+  0x00,
+  0x12,
+  0x49,
+  0x24,
+  0xAA,
+  0x48,
+  0x24,
+  0x90,
+  0x00,
+  0x00,
+  0x02,
+  0x00,
+  0x04,
+  0x92,
+  0x48,
+  0x00,
+  0x00,
+  0x01,
+  0x24,
+  0x92,
+  0x4B,
+};
+const struct IrCode code_na136Code PROGMEM = {
+  freq_to_timerval(38610),
+  88,		// # of pairs
+  3,		// # of bits per index
+  code_na136Times,
+  code_na136Codes
+};
+
+
+
+
+const uint16_t code_eu000Times[] PROGMEM = {
+  43, 47,
+  43, 91,
+  43, 8324,
+  88, 47,
+  133, 133,
+  264, 90,
+  264, 91,
+};
+const uint8_t code_eu000Codes[] PROGMEM = {
+  0xA4,
+  0x08,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x64,
+  0x2C,
+  0x40,
+  0x80,
+  0x00,
+  0x00,
+  0x00,
+  0x06,
+  0x41,
+};
+const struct IrCode code_eu000Code PROGMEM = {
+  freq_to_timerval(35714),
+  40,		// # of pairs
+  3,		// # of bits per index
+  code_eu000Times,
+  code_eu000Codes
+};
+const uint16_t code_eu001Times[] PROGMEM = {
+  47, 265,
+  51, 54,
+  51, 108,
+  51, 263,
+  51, 2053,
+  51, 11647,
+  100, 109,
+};
+const uint8_t code_eu001Codes[] PROGMEM = {
+  0x04,
+  0x92,
+  0x49,
+  0x26,
+  0x35,
+  0x89,
+  0x24,
+  0x9A,
+  0xD6,
+  0x24,
+  0x92,
+  0x48,
+};
+const struct IrCode code_eu001Code PROGMEM = {
+  freq_to_timerval(30303),
+  31,		// # of pairs
+  3,		// # of bits per index
+  code_eu001Times,
+  code_eu001Codes
+};
+const uint16_t code_eu002Times[] PROGMEM = {
+  43, 206,
+  46, 204,
+  46, 456,
+  46, 3488,
+};
+const uint8_t code_eu002Codes[] PROGMEM = {
+  0x1A,
+  0x56,
+  0xA6,
+  0xD6,
+  0x95,
+  0xA9,
+  0x90,
+};
+const struct IrCode code_eu002Code PROGMEM = {
+  freq_to_timerval(33333),
+  26,		// # of pairs
+  2,		// # of bits per index
+  code_eu002Times,
+  code_eu002Codes
+};
+
+/* Duplicate timing table, same as na000 !
+ const uint16_t code_eu003Times[] PROGMEM = {
+ 	58, 60,
+ 	58, 2687,
+ 	118, 60,
+ 	237, 60,
+ 	238, 60,
+ };
+ */
+/*
+const uint8_t code_eu003Codes[] PROGMEM = {
+ 	0x68,
+ 	0x20,
+ 	0x80,
+ 	0x40,
+ 	0x03,
+ 	0x10,
+ 	0x41,
+ 	0x00,
+ 	0x80,
+ 	0x00,
+ };
+ const struct IrCode code_eu003Code PROGMEM = {
+ 	freq_to_timerval(38462),
+ 	26,		// # of pairs
+ 	3,		// # of bits per index
+ 	code_na000Times,
+ 	code_eu003Codes
+ };// Duplicate IR Code - same as na000
+ */
+
+const uint16_t code_eu004Times[] PROGMEM = {
+  44, 45,
+  44, 131,
+  44, 7462,
+  346, 176,
+  346, 178,
+};
+const uint8_t code_eu004Codes[] PROGMEM = {
+  0x60,
+  0x80,
+  0x00,
+  0x00,
+  0x00,
+  0x08,
+  0x00,
+  0x00,
+  0x00,
+  0x20,
+  0x00,
+  0x00,
+  0x04,
+  0x12,
+  0x48,
+  0x04,
+  0x12,
+  0x48,
+  0x2A,
+  0x02,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x20,
+  0x00,
+  0x00,
+  0x00,
+  0x80,
+  0x00,
+  0x00,
+  0x10,
+  0x49,
+  0x20,
+  0x10,
+  0x49,
+  0x20,
+  0x80,
+};
+const struct IrCode code_eu004Code PROGMEM = {
+  freq_to_timerval(37037),
+  100,		// # of pairs
+  3,		// # of bits per index
+  code_eu004Times,
+  code_eu004Codes
+};// Duplicate IR Code? Similar to NA002
+
+const uint16_t code_eu005Times[] PROGMEM = {
+  24, 190,
+  25, 80,
+  25, 190,
+  25, 4199,
+  25, 4799,
+};
+const uint8_t code_eu005Codes[] PROGMEM = {
+  0x04,
+  0x92,
+  0x52,
+  0x28,
+  0x92,
+  0x8C,
+  0x44,
+  0x92,
+  0x89,
+  0x45,
+  0x24,
+  0x53,
+  0x44,
+  0x92,
+  0x52,
+  0x28,
+  0x92,
+  0x8C,
+  0x44,
+  0x92,
+  0x89,
+  0x45,
+  0x24,
+  0x51,
+};
+const struct IrCode code_eu005Code PROGMEM = {
+  freq_to_timerval(38610),
+  64,		// # of pairs
+  3,		// # of bits per index
+  code_eu005Times,
+  code_eu005Codes
+};
+const uint16_t code_eu006Times[] PROGMEM = {
+  53, 63,
+  53, 172,
+  53, 4472,
+  54, 0,
+  455, 468,
+};
+const uint8_t code_eu006Codes[] PROGMEM = {
+  0x84,
+  0x90,
+  0x00,
+  0x04,
+  0x90,
+  0x00,
+  0x00,
+  0x80,
+  0x00,
+  0x04,
+  0x12,
+  0x49,
+  0x2A,
+  0x12,
+  0x40,
+  0x00,
+  0x12,
+  0x40,
+  0x00,
+  0x02,
+  0x00,
+  0x00,
+  0x10,
+  0x49,
+  0x24,
+  0xB0,
+};
+const struct IrCode code_eu006Code PROGMEM = {
+  freq_to_timerval(38462),
+  68,		// # of pairs
+  3,		// # of bits per index
+  code_eu006Times,
+  code_eu006Codes
+};
+const uint16_t code_eu007Times[] PROGMEM = {
+  50, 54,
+  50, 159,
+  50, 2307,
+  838, 422,
+};
+const uint8_t code_eu007Codes[] PROGMEM = {
+  0xD4,
+  0x00,
+  0x15,
+  0x10,
+  0x25,
+  0x00,
+  0x05,
+  0x44,
+  0x09,
+  0x40,
+  0x01,
+  0x51,
+  0x01,
+};
+const struct IrCode code_eu007Code PROGMEM = {
+  freq_to_timerval(38462),
+  52,		// # of pairs
+  2,		// # of bits per index
+  code_eu007Times,
+  code_eu007Codes
+};// Duplicate IR Code? - Similar to NA010
+
+
+/* Duplicate timing table, same as na004 !
+ const uint16_t code_eu008Times[] PROGMEM = {
+ 	55, 57,
+ 	55, 170,
+ 	55, 3949,
+ 	55, 9623,
+ 	56, 0,
+ 	898, 453,
+ 	900, 226,
+ };
+ */
+const uint8_t code_eu008Codes[] PROGMEM = {
+  0xA0,
+  0x00,
+  0x41,
+  0x04,
+  0x92,
+  0x08,
+  0x24,
+  0x90,
+  0x40,
+  0x00,
+  0x02,
+  0x09,
+  0x2B,
+  0x3D,
+  0x00,
+};
+const struct IrCode code_eu008Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na004Times,
+  code_eu008Codes
+};
+
+
+/* Duplicate timing table, same as na005 !
+ const uint16_t code_eu009Times[] PROGMEM = {
+ 	88, 90,
+ 	88, 91,
+ 	88, 181,
+ 	88, 8976,
+ 	177, 91,
+ };
+ */
+/*
+const uint8_t code_eu009Codes[] PROGMEM = {
+ 	0x10,
+ 	0x92,
+ 	0x49,
+ 	0x46,
+ 	0x33,
+ 	0x09,
+ 	0x24,
+ 	0x94,
+ 	0x60,
+ };
+ const struct IrCode code_eu009Code PROGMEM = {
+ 	freq_to_timerval(35714),
+ 	24,		// # of pairs
+ 	3,		// # of bits per index
+ 	code_na005Times,
+ 	code_eu009Codes
+ };// Duplicate IR Code - same as na005
+ */
+
+
+/* Duplicate timing table, same as na004 !
+ const uint16_t code_eu010Times[] PROGMEM = {
+ 	55, 57,
+ 	55, 170,
+ 	55, 3949,
+ 	55, 9623,
+ 	56, 0,
+ 	898, 453,
+ 	900, 226,
+ };
+ */
+/*
+const uint8_t code_eu010Codes[] PROGMEM = {
+ 	0xA0,
+ 	0x00,
+ 	0x01,
+ 	0x04,
+ 	0x92,
+ 	0x48,
+ 	0x20,
+ 	0x80,
+ 	0x40,
+ 	0x04,
+ 	0x12,
+ 	0x09,
+ 	0x2B,
+ 	0x3D,
+ 	0x00,
+ };
+ const struct IrCode code_eu010Code PROGMEM = {
+ 	freq_to_timerval(38462),
+ 	38,		// # of pairs
+ 	3,		// # of bits per index
+ 	code_na004Times,
+ 	code_eu010Codes
+ };// Duplicate IR Code - same as NA004
+ */
+
+/* Duplicate timing table, same as na009 !
+ const uint16_t code_eu011Times[] PROGMEM = {
+ 	53, 56,
+ 	53, 171,
+ 	53, 3950,
+ 	53, 9599,
+ 	898, 451,
+ 	900, 226,
+ };
+ */
+const uint8_t code_eu011Codes[] PROGMEM = {
+  0x84,
+  0x00,
+  0x48,
+  0x04,
+  0x02,
+  0x01,
+  0x04,
+  0x80,
+  0x09,
+  0x00,
+  0x12,
+  0x40,
+  0x2A,
+  0xBA,
+  0x40,
+};
+const struct IrCode code_eu011Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na009Times,
+  code_eu011Codes
+};
+const uint16_t code_eu012Times[] PROGMEM = {
+  46, 206,
+  46, 459,
+  46, 3447,
+};
+const uint8_t code_eu012Codes[] PROGMEM = {
+  0x05,
+  0x01,
+  0x51,
+  0x81,
+  0x40,
+  0x54,
+  0x40,
+};
+const struct IrCode code_eu012Code PROGMEM = {
+  freq_to_timerval(33445),
+  26,		// # of pairs
+  2,		// # of bits per index
+  code_eu012Times,
+  code_eu012Codes
+};
+const uint16_t code_eu013Times[] PROGMEM = {
+  53, 59,
+  53, 171,
+  53, 2302,
+  895, 449,
+};
+const uint8_t code_eu013Codes[] PROGMEM = {
+  0xD4,
+  0x55,
+  0x00,
+  0x00,
+  0x40,
+  0x15,
+  0x54,
+  0x00,
+  0x01,
+  0x55,
+  0x56,
+  0xD4,
+  0x55,
+  0x00,
+  0x00,
+  0x40,
+  0x15,
+  0x54,
+  0x00,
+  0x01,
+  0x55,
+  0x55,
+};
+const struct IrCode code_eu013Code PROGMEM = {
+  freq_to_timerval(38462),
+  88,		// # of pairs
+  2,		// # of bits per index
+  code_eu013Times,
+  code_eu013Codes
+};
+
+/* Duplicate timing table, same as na021 !
+ const uint16_t code_eu014Times[] PROGMEM = {
+ 	48, 52,
+ 	48, 160,
+ 	48, 400,
+ 	48, 2335,
+ 	799, 400,
+ };
+ */
+/*
+const uint8_t code_eu014Codes[] PROGMEM = {
+ 	0x80,
+ 	0x10,
+ 	0x40,
+ 	0x08,
+ 	0x82,
+ 	0x08,
+ 	0x01,
+ 	0xC0,
+ 	0x08,
+ 	0x20,
+ 	0x04,
+ 	0x41,
+ 	0x04,
+ 	0x00,
+ 	0x00,
+ };
+ const struct IrCode code_eu014Code PROGMEM = {
+ 	freq_to_timerval(38462),
+ 	38,		// # of pairs
+ 	3,		// # of bits per index
+ 	code_na021Times,
+ 	code_eu014Codes
+ };// Duplicate IR Code - same as NA021
+ */
+
+const uint16_t code_eu015Times[] PROGMEM = {
+  53, 54,
+  53, 156,
+  53, 2542,
+  851, 425,
+  853, 424,
+};
+const uint8_t code_eu015Codes[] PROGMEM = {
+  0x60,
+  0x82,
+  0x08,
+  0x24,
+  0x10,
+  0x41,
+  0x00,
+  0x12,
+  0x40,
+  0x04,
+  0x80,
+  0x09,
+  0x2A,
+  0x02,
+  0x08,
+  0x20,
+  0x90,
+  0x41,
+  0x04,
+  0x00,
+  0x49,
+  0x00,
+  0x12,
+  0x00,
+  0x24,
+  0xA8,
+  0x08,
+  0x20,
+  0x82,
+  0x41,
+  0x04,
+  0x10,
+  0x01,
+  0x24,
+  0x00,
+  0x48,
+  0x00,
+  0x92,
+  0xA0,
+  0x20,
+  0x82,
+  0x09,
+  0x04,
+  0x10,
+  0x40,
+  0x04,
+  0x90,
+  0x01,
+  0x20,
+  0x02,
+  0x48,
+};
+const struct IrCode code_eu015Code PROGMEM = {
+  freq_to_timerval(38462),
+  136,		// # of pairs
+  3,		// # of bits per index
+  code_eu015Times,
+  code_eu015Codes
+};// Duplicate IR Code? - Similar to NA018
+
+const uint16_t code_eu016Times[] PROGMEM = {
+  28, 92,
+  28, 213,
+  28, 214,
+  28, 2771,
+};
+const uint8_t code_eu016Codes[] PROGMEM = {
+  0x68,
+  0x08,
+  0x20,
+  0x00,
+  0xEA,
+  0x02,
+  0x08,
+  0x00,
+  0x10,
+};
+const struct IrCode code_eu016Code PROGMEM = {
+  freq_to_timerval(33333),
+  34,		// # of pairs
+  2,		// # of bits per index
+  code_eu016Times,
+  code_eu016Codes
+};
+const uint16_t code_eu017Times[] PROGMEM = {
+  15, 844,
+  16, 557,
+  16, 844,
+  16, 5224,
+};
+const uint8_t code_eu017Codes[] PROGMEM = {
+  0x1A,
+  0x9A,
+  0x9B,
+  0x9A,
+  0x9A,
+  0x99,
+};
+const struct IrCode code_eu017Code PROGMEM = {
+  freq_to_timerval(33333),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu017Times,
+  code_eu017Codes
+};
+
+/* Duplicate timing table, same as na004 !
+ const uint16_t code_eu018Times[] PROGMEM = {
+ 	55, 57,
+ 	55, 170,
+ 	55, 3949,
+ 	55, 9623,
+ 	56, 0,
+ 	898, 453,
+ 	900, 226,
+ };
+ */
+const uint8_t code_eu018Codes[] PROGMEM = {
+  0xA0,
+  0x02,
+  0x48,
+  0x04,
+  0x90,
+  0x01,
+  0x20,
+  0x12,
+  0x40,
+  0x04,
+  0x80,
+  0x09,
+  0x2B,
+  0x3D,
+  0x00,
+};
+const struct IrCode code_eu018Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na004Times,
+  code_eu018Codes
+};
+const uint16_t code_eu019Times[] PROGMEM = {
+  50, 54,
+  50, 158,
+  50, 418,
+  50, 2443,
+  843, 418,
+};
+const uint8_t code_eu019Codes[] PROGMEM = {
+  0x80,
+  0x80,
+  0x00,
+  0x08,
+  0x12,
+  0x40,
+  0x01,
+  0xC0,
+  0x40,
+  0x00,
+  0x04,
+  0x09,
+  0x20,
+  0x00,
+  0x00,
+};
+const struct IrCode code_eu019Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_eu019Times,
+  code_eu019Codes
+};
+const uint16_t code_eu020Times[] PROGMEM = {
+  48, 301,
+  48, 651,
+  48, 1001,
+  48, 3001,
+};
+const uint8_t code_eu020Codes[] PROGMEM = {
+  0x22,
+  0x20,
+  0x00,
+  0x01,
+  0xC8,
+  0x88,
+  0x00,
+  0x00,
+  0x40,
+};
+const struct IrCode code_eu020Code PROGMEM = {
+  freq_to_timerval(35714),
+  34,		// # of pairs
+  2,		// # of bits per index
+  code_eu020Times,
+  code_eu020Codes
+};
+
+/* Duplicate timing table, same as na009 !
+ const uint16_t code_eu021Times[] PROGMEM = {
+ 	53, 56,
+ 	53, 171,
+ 	53, 3950,
+ 	53, 9599,
+ 	898, 451,
+ 	900, 226,
+ };
+ */
+const uint8_t code_eu021Codes[] PROGMEM = {
+  0x84,
+  0x80,
+  0x00,
+  0x20,
+  0x82,
+  0x49,
+  0x00,
+  0x02,
+  0x00,
+  0x04,
+  0x90,
+  0x49,
+  0x2A,
+  0xBA,
+  0x40,
+};
+const struct IrCode code_eu021Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na009Times,
+  code_eu021Codes
+};
+
+/* Duplicate timing table, same as na004 !
+ const uint16_t code_eu022Times[] PROGMEM = {
+ 	55, 57,
+ 	55, 170,
+ 	55, 3949,
+ 	55, 9623,
+ 	56, 0,
+ 	898, 453,
+ 	900, 226,
+ };
+ */
+const uint8_t code_eu022Codes[] PROGMEM = {
+  0xA4,
+  0x80,
+  0x41,
+  0x00,
+  0x12,
+  0x08,
+  0x24,
+  0x90,
+  0x40,
+  0x00,
+  0x02,
+  0x09,
+  0x2B,
+  0x3D,
+  0x00,
+};
+const struct IrCode code_eu022Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na004Times,
+  code_eu022Codes
+};
+
+/* Duplicate timing table, same as na022 !
+ const uint16_t code_eu023Times[] PROGMEM = {
+ 	53, 60,
+ 	53, 175,
+ 	53, 4463,
+ 	53, 9453,
+ 	892, 450,
+ 	895, 225,
+ };
+ */
+/*
+const uint8_t code_eu023Codes[] PROGMEM = {
+ 	0x80,
+ 	0x02,
+ 	0x40,
+ 	0x00,
+ 	0x02,
+ 	0x40,
+ 	0x00,
+ 	0x00,
+ 	0x01,
+ 	0x24,
+ 	0x92,
+ 	0x48,
+ 	0x0A,
+ 	0xBA,
+ 	0x00,
+ };
+ const struct IrCode code_eu023Code PROGMEM = {
+ 	freq_to_timerval(38462),
+ 	38,		// # of pairs
+ 	3,		// # of bits per index
+ 	code_na022Times,
+ 	code_eu023Codes
+ };// Duplicate IR Code - Same as NA022
+ */
+
+
+/* Duplicate timing table, same as na004 !
+ const uint16_t code_eu024Times[] PROGMEM = {
+ 	55, 57,
+ 	55, 170,
+ 	55, 3949,
+ 	55, 9623,
+ 	56, 0,
+ 	898, 453,
+ 	900, 226,
+ };
+ */
+const uint8_t code_eu024Codes[] PROGMEM = {
+  0xA0,
+  0x02,
+  0x48,
+  0x04,
+  0x90,
+  0x01,
+  0x20,
+  0x00,
+  0x40,
+  0x04,
+  0x92,
+  0x09,
+  0x2B,
+  0x3D,
+  0x00,
+};
+const struct IrCode code_eu024Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na004Times,
+  code_eu024Codes
+};
+const uint16_t code_eu025Times[] PROGMEM = {
+  49, 52,
+  49, 102,
+  49, 250,
+  49, 252,
+  49, 2377,
+  49, 12009,
+  100, 52,
+  100, 102,
+};
+const uint8_t code_eu025Codes[] PROGMEM = {
+  0x47,
+  0x00,
+  0x23,
+  0x3C,
+  0x01,
+  0x59,
+  0xE0,
+  0x04,
+};
+const struct IrCode code_eu025Code PROGMEM = {
+  freq_to_timerval(31250),
+  21,		// # of pairs
+  3,		// # of bits per index
+  code_eu025Times,
+  code_eu025Codes
+};
+const uint16_t code_eu026Times[] PROGMEM = {
+  14, 491,
+  14, 743,
+  14, 4926,
+};
+const uint8_t code_eu026Codes[] PROGMEM = {
+  0x55,
+  0x40,
+  0x42,
+  0x55,
+  0x40,
+  0x41,
+};
+const struct IrCode code_eu026Code PROGMEM = {
+  freq_to_timerval(38462),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu026Times,
+  code_eu026Codes
+};
+
+/* Duplicate timing table, same as na004 !
+ const uint16_t code_eu027Times[] PROGMEM = {
+ 	55, 57,
+ 	55, 170,
+ 	55, 3949,
+ 	55, 9623,
+ 	56, 0,
+ 	898, 453,
+ 	900, 226,
+ };
+ */
+const uint8_t code_eu027Codes[] PROGMEM = {
+  0xA0,
+  0x82,
+  0x08,
+  0x24,
+  0x10,
+  0x41,
+  0x04,
+  0x10,
+  0x01,
+  0x20,
+  0x82,
+  0x48,
+  0x0B,
+  0x3D,
+  0x00,
+};
+const struct IrCode code_eu027Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na004Times,
+  code_eu027Codes
+};
+const uint16_t code_eu028Times[] PROGMEM = {
+  47, 267,
+  50, 55,
+  50, 110,
+  50, 265,
+  50, 2055,
+  50, 12117,
+  100, 57,
+};
+const uint8_t code_eu028Codes[] PROGMEM = {
+  0x04,
+  0x92,
+  0x49,
+  0x26,
+  0x34,
+  0x72,
+  0x24,
+  0x9A,
+  0xD1,
+  0xC8,
+  0x92,
+  0x48,
+};
+const struct IrCode code_eu028Code PROGMEM = {
+  freq_to_timerval(30303),
+  31,		// # of pairs
+  3,		// # of bits per index
+  code_eu028Times,
+  code_eu028Codes
+};
+const uint16_t code_eu029Times[] PROGMEM = {
+  50, 50,
+  50, 99,
+  50, 251,
+  50, 252,
+  50, 1445,
+  50, 11014,
+  102, 49,
+  102, 98,
+};
+const uint8_t code_eu029Codes[] PROGMEM = {
+  0x47,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x04,
+  0x64,
+  0x62,
+  0x00,
+  0xE0,
+  0x00,
+  0x2B,
+  0x23,
+  0x10,
+  0x07,
+  0x00,
+  0x00,
+  0x80,
+};
+const struct IrCode code_eu029Code PROGMEM = {
+  freq_to_timerval(34483),
+  46,		// # of pairs
+  3,		// # of bits per index
+  code_eu029Times,
+  code_eu029Codes
+};
+
+/* Duplicate timing table, same as na004 !
+ const uint16_t code_eu030Times[] PROGMEM = {
+ 	55, 57,
+ 	55, 170,
+ 	55, 3949,
+ 	55, 9623,
+ 	56, 0,
+ 	898, 453,
+ 	900, 226,
+ };
+ */
+const uint8_t code_eu030Codes[] PROGMEM = {
+  0xA0,
+  0x10,
+  0x00,
+  0x04,
+  0x82,
+  0x49,
+  0x20,
+  0x02,
+  0x00,
+  0x04,
+  0x90,
+  0x49,
+  0x2B,
+  0x3D,
+  0x00,
+};
+const struct IrCode code_eu030Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na004Times,
+  code_eu030Codes
+};// Duplicate IR Code? - Smilar to NA020
+
+const uint16_t code_eu031Times[] PROGMEM = {
+  53, 53,
+  53, 160,
+  53, 1697,
+  838, 422,
+};
+const uint8_t code_eu031Codes[] PROGMEM = {
+  0xD5,
+  0x50,
+  0x15,
+  0x11,
+  0x65,
+  0x54,
+  0x05,
+  0x44,
+  0x59,
+  0x55,
+  0x01,
+  0x51,
+  0x15,
+};
+const struct IrCode code_eu031Code PROGMEM = {
+  freq_to_timerval(38462),
+  52,		// # of pairs
+  2,		// # of bits per index
+  code_eu031Times,
+  code_eu031Codes
+};
+const uint16_t code_eu032Times[] PROGMEM = {
+  49, 205,
+  49, 206,
+  49, 456,
+  49, 3690,
+};
+const uint8_t code_eu032Codes[] PROGMEM = {
+  0x1A,
+  0x56,
+  0xA5,
+  0xD6,
+  0x95,
+  0xA9,
+  0x40,
+};
+const struct IrCode code_eu032Code PROGMEM = {
+  freq_to_timerval(33333),
+  26,		// # of pairs
+  2,		// # of bits per index
+  code_eu032Times,
+  code_eu032Codes
+};
+const uint16_t code_eu033Times[] PROGMEM = {
+  48, 150,
+  50, 149,
+  50, 347,
+  50, 2936,
+};
+const uint8_t code_eu033Codes[] PROGMEM = {
+  0x2A,
+  0x5D,
+  0xA9,
+  0x60,
+};
+const struct IrCode code_eu033Code PROGMEM = {
+  freq_to_timerval(38462),
+  14,		// # of pairs
+  2,		// # of bits per index
+  code_eu033Times,
+  code_eu033Codes
+};
+
+
+/* Duplicate timing table, same as na004 !
+ const uint16_t code_eu034Times[] PROGMEM = {
+ 	55, 57,
+ 	55, 170,
+ 	55, 3949,
+ 	55, 9623,
+ 	56, 0,
+ 	898, 453,
+ 	900, 226,
+ };
+ */
+const uint8_t code_eu034Codes[] PROGMEM = {
+  0xA0,
+  0x02,
+  0x40,
+  0x04,
+  0x90,
+  0x09,
+  0x20,
+  0x02,
+  0x00,
+  0x04,
+  0x90,
+  0x49,
+  0x2B,
+  0x3D,
+  0x00,
+};
+const struct IrCode code_eu034Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na004Times,
+  code_eu034Codes
+};
+
+/* Duplicate timing table, same as na005 !
+ const uint16_t code_eu035Times[] PROGMEM = {
+ 	88, 90,
+ 	88, 91,
+ 	88, 181,
+ 	88, 8976,
+ 	177, 91,
+ };
+ */
+/*
+const uint8_t code_eu035Codes[] PROGMEM = {
+ 	0x10,
+ 	0x92,
+ 	0x49,
+ 	0x46,
+ 	0x33,
+ 	0x09,
+ 	0x24,
+ 	0x94,
+ 	0x60,
+ };
+ const struct IrCode code_eu035Code PROGMEM = {
+ 	freq_to_timerval(35714),
+ 	24,		// # of pairs
+ 	3,		// # of bits per index
+ 	code_na005Times,
+ 	code_eu035Codes
+ };// Duplicate IR Code - same as eu009!
+ */
+
+/* Duplicate timing table, same as na004 !
+ const uint16_t code_eu036Times[] PROGMEM = {
+ 	55, 57,
+ 	55, 170,
+ 	55, 3949,
+ 	55, 9623,
+ 	56, 0,
+ 	898, 453,
+ 	900, 226,
+ };
+ */
+const uint8_t code_eu036Codes[] PROGMEM = {
+  0xA4,
+  0x00,
+  0x49,
+  0x00,
+  0x92,
+  0x00,
+  0x20,
+  0x02,
+  0x00,
+  0x04,
+  0x90,
+  0x49,
+  0x2B,
+  0x3D,
+  0x00,
+};
+const struct IrCode code_eu036Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na004Times,
+  code_eu036Codes
+};
+const uint16_t code_eu037Times[] PROGMEM = {
+  14, 491,
+  14, 743,
+  14, 5178,
+};
+const uint8_t code_eu037Codes[] PROGMEM = {
+  0x45,
+  0x50,
+  0x02,
+  0x45,
+  0x50,
+  0x01,
+};
+const struct IrCode code_eu037Code PROGMEM = {
+  freq_to_timerval(38462),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu037Times,
+  code_eu037Codes
+};
+const uint16_t code_eu038Times[] PROGMEM = {
+  3, 1002,
+  3, 1495,
+  3, 3059,
+};
+const uint8_t code_eu038Codes[] PROGMEM = {
+  0x05,
+  0x60,
+  0x54,
+};
+const struct IrCode code_eu038Code PROGMEM = {
+  0,              // Non-pulsed code
+  11,		// # of pairs
+  2,		// # of bits per index
+  code_eu038Times,
+  code_eu038Codes
+};
+const uint16_t code_eu039Times[] PROGMEM = {
+  13, 445,
+  13, 674,
+  13, 675,
+  13, 4583,
+};
+const uint8_t code_eu039Codes[] PROGMEM = {
+  0x6A,
+  0x82,
+  0x83,
+  0xAA,
+  0x82,
+  0x81,
+};
+const struct IrCode code_eu039Code PROGMEM = {
+  freq_to_timerval(40161),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu039Times,
+  code_eu039Codes
+};
+const uint16_t code_eu040Times[] PROGMEM = {
+  85, 89,
+  85, 264,
+  85, 3402,
+  347, 350,
+  348, 350,
+};
+const uint8_t code_eu040Codes[] PROGMEM = {
+  0x60,
+  0x90,
+  0x40,
+  0x20,
+  0x80,
+  0x40,
+  0x20,
+  0x90,
+  0x41,
+  0x2A,
+  0x02,
+  0x41,
+  0x00,
+  0x82,
+  0x01,
+  0x00,
+  0x82,
+  0x41,
+  0x04,
+  0x80,
+};
+const struct IrCode code_eu040Code PROGMEM = {
+  freq_to_timerval(35714),
+  52,		// # of pairs
+  3,		// # of bits per index
+  code_eu040Times,
+  code_eu040Codes
+};
+const uint16_t code_eu041Times[] PROGMEM = {
+  46, 300,
+  49, 298,
+  49, 648,
+  49, 997,
+  49, 3056,
+};
+const uint8_t code_eu041Codes[] PROGMEM = {
+  0x0C,
+  0xB2,
+  0xCA,
+  0x49,
+  0x13,
+  0x0B,
+  0x2C,
+  0xB2,
+  0x92,
+  0x44,
+  0xB0,
+};
+const struct IrCode code_eu041Code PROGMEM = {
+  freq_to_timerval(33333),
+  28,		// # of pairs
+  3,		// # of bits per index
+  code_eu041Times,
+  code_eu041Codes
+};
+
+/* Duplicate timing table, same as na009 !
+ const uint16_t code_eu042Times[] PROGMEM = {
+ 	53, 56,
+ 	53, 171,
+ 	53, 3950,
+ 	53, 9599,
+ 	898, 451,
+ 	900, 226,
+ };
+ */
+const uint8_t code_eu042Codes[] PROGMEM = {
+  0x80,
+  0x00,
+  0x00,
+  0x24,
+  0x92,
+  0x09,
+  0x00,
+  0x82,
+  0x00,
+  0x04,
+  0x10,
+  0x49,
+  0x2A,
+  0xBA,
+  0x00,
+};
+const struct IrCode code_eu042Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na009Times,
+  code_eu042Codes
+};
+const uint16_t code_eu043Times[] PROGMEM = {
+  1037, 4216,
+  1040, 0,
+};
+const uint8_t code_eu043Codes[] PROGMEM = {
+  0x10,
+};
+const struct IrCode code_eu043Code PROGMEM = {
+  freq_to_timerval(41667),
+  2,		// # of pairs
+  2,		// # of bits per index
+  code_eu043Times,
+  code_eu043Codes
+};
+
+/* Duplicate timing table, same as na004 !
+ const uint16_t code_eu044Times[] PROGMEM = {
+ 	55, 57,
+ 	55, 170,
+ 	55, 3949,
+ 	55, 9623,
+ 	56, 0,
+ 	898, 453,
+ 	900, 226,
+ };
+ */
+const uint8_t code_eu044Codes[] PROGMEM = {
+  0xA0,
+  0x02,
+  0x01,
+  0x04,
+  0x90,
+  0x48,
+  0x20,
+  0x00,
+  0x00,
+  0x04,
+  0x92,
+  0x49,
+  0x2B,
+  0x3D,
+  0x00,
+};
+const struct IrCode code_eu044Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na004Times,
+  code_eu044Codes
+};
+const uint16_t code_eu045Times[] PROGMEM = {
+  152, 471,
+  154, 156,
+  154, 469,
+  154, 2947,
+};
+const uint8_t code_eu045Codes[] PROGMEM = {
+  0x16,
+  0xE5,
+  0x90,
+};
+const struct IrCode code_eu045Code PROGMEM = {
+  freq_to_timerval(41667),
+  10,		// # of pairs
+  2,		// # of bits per index
+  code_eu045Times,
+  code_eu045Codes
+};
+const uint16_t code_eu046Times[] PROGMEM = {
+  15, 493,
+  16, 493,
+  16, 698,
+  16, 1414,
+};
+const uint8_t code_eu046Codes[] PROGMEM = {
+  0x16,
+  0xAB,
+  0x56,
+  0xA9,
+};
+const struct IrCode code_eu046Code PROGMEM = {
+  freq_to_timerval(34602),
+  16,		// # of pairs
+  2,		// # of bits per index
+  code_eu046Times,
+  code_eu046Codes
+};
+const uint16_t code_eu047Times[] PROGMEM = {
+  3, 496,
+  3, 745,
+  3, 1488,
+};
+const uint8_t code_eu047Codes[] PROGMEM = {
+  0x41,
+  0x24,
+  0x12,
+  0x41,
+  0x00,
+};
+const struct IrCode code_eu047Code PROGMEM = {
+  0,              // Non-pulsed code
+  17,		// # of pairs
+  2,		// # of bits per index
+  code_eu047Times,
+  code_eu047Codes
+};
+
+/* Duplicate timing table, same as na009 !
+ const uint16_t code_eu048Times[] PROGMEM = {
+ 	53, 56,
+ 	53, 171,
+ 	53, 3950,
+ 	53, 9599,
+ 	898, 451,
+ 	900, 226,
+ };
+ */
+const uint8_t code_eu048Codes[] PROGMEM = {
+  0x80,
+  0x00,
+  0x00,
+  0x24,
+  0x82,
+  0x49,
+  0x04,
+  0x80,
+  0x40,
+  0x00,
+  0x12,
+  0x09,
+  0x2A,
+  0xBA,
+  0x00,
+};
+const struct IrCode code_eu048Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na009Times,
+  code_eu048Codes
+};
+const uint16_t code_eu049Times[] PROGMEM = {
+  55, 55,
+  55, 167,
+  55, 4577,
+  55, 9506,
+  448, 445,
+  450, 444,
+};
+const uint8_t code_eu049Codes[] PROGMEM = {
+  0x80,
+  0x92,
+  0x00,
+  0x00,
+  0x92,
+  0x00,
+  0x00,
+  0x10,
+  0x40,
+  0x04,
+  0x82,
+  0x09,
+  0x2A,
+  0x97,
+  0x48,
+};
+const struct IrCode code_eu049Code PROGMEM = {
+  freq_to_timerval(38462),
+  40,		// # of pairs
+  3,		// # of bits per index
+  code_eu049Times,
+  code_eu049Codes
+};
+const uint16_t code_eu050Times[] PROGMEM = {
+  91, 88,
+  91, 267,
+  91, 3621,
+  361, 358,
+  361, 359,
+};
+const uint8_t code_eu050Codes[] PROGMEM = {
+  0x60,
+  0x00,
+  0x00,
+  0x00,
+  0x12,
+  0x49,
+  0x24,
+  0x92,
+  0x42,
+  0x80,
+  0x00,
+  0x00,
+  0x00,
+  0x12,
+  0x49,
+  0x24,
+  0x92,
+  0x40,
+};
+const struct IrCode code_eu050Code PROGMEM = {
+  freq_to_timerval(33333),
+  48,		// # of pairs
+  3,		// # of bits per index
+  code_eu050Times,
+  code_eu050Codes
+};
+const uint16_t code_eu051Times[] PROGMEM = {
+  84, 88,
+  84, 261,
+  84, 3360,
+  347, 347,
+  347, 348,
+};
+const uint8_t code_eu051Codes[] PROGMEM = {
+  0x60,
+  0x82,
+  0x00,
+  0x20,
+  0x80,
+  0x41,
+  0x04,
+  0x90,
+  0x41,
+  0x2A,
+  0x02,
+  0x08,
+  0x00,
+  0x82,
+  0x01,
+  0x04,
+  0x12,
+  0x41,
+  0x04,
+  0x80,
+};
+const struct IrCode code_eu051Code PROGMEM = {
+  freq_to_timerval(38462),
+  52,		// # of pairs
+  3,		// # of bits per index
+  code_eu051Times,
+  code_eu051Codes
+};// Duplicate IR Code? - Similar to NA115
+
+const uint16_t code_eu052Times[] PROGMEM = {
+  16, 838,
+  17, 558,
+  17, 839,
+  17, 6328,
+};
+const uint8_t code_eu052Codes[] PROGMEM = {
+  0x1A,
+  0x9A,
+  0x9B,
+  0x9A,
+  0x9A,
+  0x99,
+};
+const struct IrCode code_eu052Code PROGMEM = {
+  freq_to_timerval(31250),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu052Times,
+  code_eu052Codes
+};// Duplicate IR Code? -  Similar to EU017
+
+
+/* Duplicate timing table, same as eu046 !
+ const uint16_t code_eu053Times[] PROGMEM = {
+ 	15, 493,
+ 	16, 493,
+ 	16, 698,
+ 	16, 1414,
+ };
+ */
+const uint8_t code_eu053Codes[] PROGMEM = {
+  0x26,
+  0xAB,
+  0x66,
+  0xAA,
+};
+const struct IrCode code_eu053Code PROGMEM = {
+  freq_to_timerval(34483),
+  16,		// # of pairs
+  2,		// # of bits per index
+  code_eu046Times,
+  code_eu053Codes
+};
+const uint16_t code_eu054Times[] PROGMEM = {
+  49, 53,
+  49, 104,
+  49, 262,
+  49, 264,
+  49, 8030,
+  100, 103,
+};
+const uint8_t code_eu054Codes[] PROGMEM = {
+  0x40,
+  0x1A,
+  0x23,
+  0x00,
+  0xD0,
+  0x80,
+};
+const struct IrCode code_eu054Code PROGMEM = {
+  freq_to_timerval(31250),
+  14,		// # of pairs
+  3,		// # of bits per index
+  code_eu054Times,
+  code_eu054Codes
+};
+
+/* Duplicate timing table, same as na009 !
+ const uint16_t code_eu055Times[] PROGMEM = {
+ 	53, 56,
+ 	53, 171,
+ 	53, 3950,
+ 	53, 9599,
+ 	898, 451,
+ 	900, 226,
+ };
+ */
+const uint8_t code_eu055Codes[] PROGMEM = {
+  0x80,
+  0x00,
+  0x00,
+  0x20,
+  0x92,
+  0x49,
+  0x00,
+  0x02,
+  0x40,
+  0x04,
+  0x90,
+  0x09,
+  0x2A,
+  0xBA,
+  0x00,
+};
+const struct IrCode code_eu055Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na009Times,
+  code_eu055Codes
+};
+const uint16_t code_eu056Times[] PROGMEM = {
+  112, 107,
+  113, 107,
+  677, 2766,
+};
+const uint8_t code_eu056Codes[] PROGMEM = {
+  0x26,
+};
+const struct IrCode code_eu056Code PROGMEM = {
+  freq_to_timerval(38462),
+  4,		// # of pairs
+  2,		// # of bits per index
+  code_eu056Times,
+  code_eu056Codes
+};
+
+/* Duplicate timing table, same as na004 !
+ const uint16_t code_eu057Times[] PROGMEM = {
+ 	55, 57,
+ 	55, 170,
+ 	55, 3949,
+ 	55, 9623,
+ 	56, 0,
+ 	898, 453,
+ 	900, 226,
+ };
+ */
+/*
+const uint8_t code_eu057Codes[] PROGMEM = {
+ 	0xA0,
+ 	0x00,
+ 	0x41,
+ 	0x04,
+ 	0x92,
+ 	0x08,
+ 	0x20,
+ 	0x02,
+ 	0x00,
+ 	0x04,
+ 	0x90,
+ 	0x49,
+ 	0x2B,
+ 	0x3D,
+ 	0x00,
+ };
+ const struct IrCode code_eu057Code PROGMEM = {
+ 	freq_to_timerval(38462),
+ 	38,		// # of pairs
+ 	3,		// # of bits per index
+ 	code_na004Times,
+ 	code_eu057Codes
+ }; // Duplicate IR code - same as EU008
+ */
+/* Duplicate timing table, same as na009 !
+ const uint16_t code_eu058Times[] PROGMEM = {
+ 	53, 56,
+ 	53, 171,
+ 	53, 3950,
+ 	53, 9599,
+ 	898, 451,
+ 	900, 226,
+ };
+ */
+const uint8_t code_eu058Codes[] PROGMEM = {
+  0x80,
+  0x00,
+  0x00,
+  0x24,
+  0x10,
+  0x49,
+  0x00,
+  0x82,
+  0x00,
+  0x04,
+  0x10,
+  0x49,
+  0x2A,
+  0xBA,
+  0x00,
+};
+const struct IrCode code_eu058Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na009Times,
+  code_eu058Codes
+};
+const uint16_t code_eu059Times[] PROGMEM = {
+  310, 613,
+  310, 614,
+  622, 8312,
+};
+const uint8_t code_eu059Codes[] PROGMEM = {
+  0x26,
+};
+const struct IrCode code_eu059Code PROGMEM = {
+  freq_to_timerval(41667),
+  4,		// # of pairs
+  2,		// # of bits per index
+  code_eu059Times,
+  code_eu059Codes
+};// Duplicate IR Code? - Similar to EU056
+
+const uint16_t code_eu060Times[] PROGMEM = {
+  50, 158,
+  53, 51,
+  53, 156,
+  53, 2180,
+};
+const uint8_t code_eu060Codes[] PROGMEM = {
+  0x25,
+  0x59,
+  0x9A,
+  0x5A,
+  0xE9,
+  0x56,
+  0x66,
+  0x96,
+  0xA0,
+};
+const struct IrCode code_eu060Code PROGMEM = {
+  freq_to_timerval(38462),
+  34,		// # of pairs
+  2,		// # of bits per index
+  code_eu060Times,
+  code_eu060Codes
+};
+
+/* Duplicate timing table, same as na005 !
+ const uint16_t code_eu061Times[] PROGMEM = {
+ 	88, 90,
+ 	88, 91,
+ 	88, 181,
+ 	88, 8976,
+ 	177, 91,
+ };
+ */
+const uint8_t code_eu061Codes[] PROGMEM = {
+  0x10,
+  0x92,
+  0x54,
+  0x24,
+  0xB3,
+  0x09,
+  0x25,
+  0x42,
+  0x48,
+};
+const struct IrCode code_eu061Code PROGMEM = {
+  freq_to_timerval(35714),
+  24,		// # of pairs
+  3,		// # of bits per index
+  code_na005Times,
+  code_eu061Codes
+};
+
+/* Duplicate timing table, same as eu060 !
+ const uint16_t code_eu062Times[] PROGMEM = {
+ 	50, 158,
+ 	53, 51,
+ 	53, 156,
+ 	53, 2180,
+ };
+ */
+const uint8_t code_eu062Codes[] PROGMEM = {
+  0x25,
+  0x99,
+  0x9A,
+  0x5A,
+  0xE9,
+  0x66,
+  0x66,
+  0x96,
+  0xA0,
+};
+const struct IrCode code_eu062Code PROGMEM = {
+  freq_to_timerval(38462),
+  34,		// # of pairs
+  2,		// # of bits per index
+  code_eu060Times,
+  code_eu062Codes
+};
+
+/* Duplicate timing table, same as na009 !
+ const uint16_t code_eu063Times[] PROGMEM = {
+ 	53, 56,
+ 	53, 171,
+ 	53, 3950,
+ 	53, 9599,
+ 	898, 451,
+ 	900, 226,
+ };
+ */
+const uint8_t code_eu063Codes[] PROGMEM = {
+  0x80,
+  0x00,
+  0x00,
+  0x24,
+  0x90,
+  0x41,
+  0x00,
+  0x82,
+  0x00,
+  0x04,
+  0x10,
+  0x49,
+  0x2A,
+  0xBA,
+  0x00,
+};
+const struct IrCode code_eu063Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na009Times,
+  code_eu063Codes
+};
+const uint16_t code_eu064Times[] PROGMEM = {
+  47, 267,
+  50, 55,
+  50, 110,
+  50, 265,
+  50, 2055,
+  50, 12117,
+  100, 57,
+  100, 112,
+};
+const uint8_t code_eu064Codes[] PROGMEM = {
+  0x04,
+  0x92,
+  0x49,
+  0x26,
+  0x32,
+  0x51,
+  0xCB,
+  0xD6,
+  0x4A,
+  0x39,
+  0x72,
+};
+const struct IrCode code_eu064Code PROGMEM = {
+  freq_to_timerval(30395),
+  29,		// # of pairs
+  3,		// # of bits per index
+  code_eu064Times,
+  code_eu064Codes
+};
+const uint16_t code_eu065Times[] PROGMEM = {
+  47, 267,
+  50, 55,
+  50, 110,
+  50, 265,
+  50, 2055,
+  50, 12117,
+  100, 112,
+};
+const uint8_t code_eu065Codes[] PROGMEM = {
+  0x04,
+  0x92,
+  0x49,
+  0x26,
+  0x32,
+  0x4A,
+  0x38,
+  0x9A,
+  0xC9,
+  0x28,
+  0xE2,
+  0x48,
+};
+const struct IrCode code_eu065Code PROGMEM = {
+  freq_to_timerval(30303),
+  31,		// # of pairs
+  3,		// # of bits per index
+  code_eu065Times,
+  code_eu065Codes
+};
+
+/* Duplicate timing table, same as eu049 !
+ const uint16_t code_eu066Times[] PROGMEM = {
+ 	55, 55,
+ 	55, 167,
+ 	55, 4577,
+ 	55, 9506,
+ 	448, 445,
+ 	450, 444,
+ };
+ */
+const uint8_t code_eu066Codes[] PROGMEM = {
+  0x84,
+  0x82,
+  0x00,
+  0x04,
+  0x82,
+  0x00,
+  0x00,
+  0x82,
+  0x00,
+  0x04,
+  0x10,
+  0x49,
+  0x2A,
+  0x87,
+  0x41,
+};
+const struct IrCode code_eu066Code PROGMEM = {
+  freq_to_timerval(38462),
+  40,		// # of pairs
+  3,		// # of bits per index
+  code_eu049Times,
+  code_eu066Codes
+};
+const uint16_t code_eu067Times[] PROGMEM = {
+  94, 473,
+  94, 728,
+  102, 1637,
+};
+const uint8_t code_eu067Codes[] PROGMEM = {
+  0x41,
+  0x24,
+  0x12,
+};
+const struct IrCode code_eu067Code PROGMEM = {
+  freq_to_timerval(38462),
+  12,		// # of pairs
+  2,		// # of bits per index
+  code_eu067Times,
+  code_eu067Codes
+};
+const uint16_t code_eu068Times[] PROGMEM = {
+  49, 263,
+  50, 54,
+  50, 108,
+  50, 263,
+  50, 2029,
+  50, 10199,
+  100, 110,
+};
+const uint8_t code_eu068Codes[] PROGMEM = {
+  0x04,
+  0x92,
+  0x49,
+  0x26,
+  0x34,
+  0x49,
+  0x38,
+  0x9A,
+  0xD1,
+  0x24,
+  0xE2,
+  0x48,
+};
+const struct IrCode code_eu068Code PROGMEM = {
+  freq_to_timerval(38610),
+  31,		// # of pairs
+  3,		// # of bits per index
+  code_eu068Times,
+  code_eu068Codes
+};
+const uint16_t code_eu069Times[] PROGMEM = {
+  4, 499,
+  4, 750,
+  4, 4999,
+};
+const uint8_t code_eu069Codes[] PROGMEM = {
+  0x05,
+  0x54,
+  0x06,
+  0x05,
+  0x54,
+  0x04,
+};
+const struct IrCode code_eu069Code PROGMEM = {
+  0,              // Non-pulsed code
+  23,		// # of pairs
+  2,		// # of bits per index
+  code_eu069Times,
+  code_eu069Codes
+};
+
+/* Duplicate timing table, same as eu069 !
+ const uint16_t code_eu070Times[] PROGMEM = {
+ 	4, 499,
+ 	4, 750,
+ 	4, 4999,
+ };
+ */
+const uint8_t code_eu070Codes[] PROGMEM = {
+  0x14,
+  0x54,
+  0x06,
+  0x14,
+  0x54,
+  0x04,
+};
+const struct IrCode code_eu070Code PROGMEM = {
+  0,              // Non-pulsed code
+  23,		// # of pairs
+  2,		// # of bits per index
+  code_eu069Times,
+  code_eu070Codes
+};
+const uint16_t code_eu071Times[] PROGMEM = {
+  14, 491,
+  14, 743,
+  14, 4422,
+};
+const uint8_t code_eu071Codes[] PROGMEM = {
+  0x45,
+  0x44,
+  0x56,
+  0x45,
+  0x44,
+  0x55,
+};
+const struct IrCode code_eu071Code PROGMEM = {
+  freq_to_timerval(38462),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu071Times,
+  code_eu071Codes
+};
+const uint16_t code_eu072Times[] PROGMEM = {
+  5, 568,
+  5, 854,
+  5, 4999,
+};
+const uint8_t code_eu072Codes[] PROGMEM = {
+  0x55,
+  0x45,
+  0x46,
+  0x55,
+  0x45,
+  0x44,
+};
+const struct IrCode code_eu072Code PROGMEM = {
+  0,              // Non-pulsed code
+  23,		// # of pairs
+  2,		// # of bits per index
+  code_eu072Times,
+  code_eu072Codes
+};
+
+/* Duplicate timing table, same as eu046 !
+ const uint16_t code_eu073Times[] PROGMEM = {
+ 	15, 493,
+ 	16, 493,
+ 	16, 698,
+ 	16, 1414,
+ };
+ */
+const uint8_t code_eu073Codes[] PROGMEM = {
+  0x19,
+  0x57,
+  0x59,
+  0x55,
+};
+const struct IrCode code_eu073Code PROGMEM = {
+  freq_to_timerval(34483),
+  16,		// # of pairs
+  2,		// # of bits per index
+  code_eu046Times,
+  code_eu073Codes
+};
+
+/* Duplicate timing table, same as na031 !
+ const uint16_t code_eu074Times[] PROGMEM = {
+ 	88, 89,
+ 	88, 90,
+ 	88, 179,
+ 	88, 8977,
+ 	177, 90,
+ };
+ */
+const uint8_t code_eu074Codes[] PROGMEM = {
+  0x04,
+  0x92,
+  0x49,
+  0x28,
+  0xC6,
+  0x49,
+  0x24,
+  0x92,
+  0x51,
+  0x80,
+};
+const struct IrCode code_eu074Code PROGMEM = {
+  freq_to_timerval(35714),
+  26,		// # of pairs
+  3,		// # of bits per index
+  code_na031Times,
+  code_eu074Codes
+};
+const uint16_t code_eu075Times[] PROGMEM = {
+  6, 566,
+  6, 851,
+  6, 5474,
+};
+const uint8_t code_eu075Codes[] PROGMEM = {
+  0x05,
+  0x45,
+  0x46,
+  0x05,
+  0x45,
+  0x44,
+};
+const struct IrCode code_eu075Code PROGMEM = {
+  0,              // Non-pulsed code
+  23,		// # of pairs
+  2,		// # of bits per index
+  code_eu075Times,
+  code_eu075Codes
+};
+const uint16_t code_eu076Times[] PROGMEM = {
+  14, 843,
+  16, 555,
+  16, 841,
+  16, 4911,
+};
+const uint8_t code_eu076Codes[] PROGMEM = {
+  0x2A,
+  0x9A,
+  0x9B,
+  0xAA,
+  0x9A,
+  0x9A,
+};
+const struct IrCode code_eu076Code PROGMEM = {
+  freq_to_timerval(38462),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu076Times,
+  code_eu076Codes
+};
+
+/* Duplicate timing table, same as eu028 !
+ const uint16_t code_eu077Times[] PROGMEM = {
+ 	47, 267,
+ 	50, 55,
+ 	50, 110,
+ 	50, 265,
+ 	50, 2055,
+ 	50, 12117,
+ 	100, 57,
+ };
+ */
+const uint8_t code_eu077Codes[] PROGMEM = {
+  0x04,
+  0x92,
+  0x49,
+  0x26,
+  0x32,
+  0x51,
+  0xC8,
+  0x9A,
+  0xC9,
+  0x47,
+  0x22,
+  0x48,
+};
+const struct IrCode code_eu077Code PROGMEM = {
+  freq_to_timerval(30303),
+  31,		// # of pairs
+  3,		// # of bits per index
+  code_eu028Times,
+  code_eu077Codes
+};
+const uint16_t code_eu078Times[] PROGMEM = {
+  6, 925,
+  6, 1339,
+  6, 2098,
+  6, 2787,
+};
+const uint8_t code_eu078Codes[] PROGMEM = {
+  0x90,
+  0x0D,
+  0x00,
+};
+const struct IrCode code_eu078Code PROGMEM = {
+  0,              // Non-pulsed code
+  12,		// # of pairs
+  2,		// # of bits per index
+  code_eu078Times,
+  code_eu078Codes
+};
+const uint16_t code_eu079Times[] PROGMEM = {
+  53, 59,
+  53, 170,
+  53, 4359,
+  892, 448,
+  893, 448,
+};
+const uint8_t code_eu079Codes[] PROGMEM = {
+  0x60,
+  0x00,
+  0x00,
+  0x24,
+  0x80,
+  0x09,
+  0x04,
+  0x92,
+  0x00,
+  0x00,
+  0x00,
+  0x49,
+  0x2A,
+  0x00,
+  0x00,
+  0x00,
+  0x92,
+  0x00,
+  0x24,
+  0x12,
+  0x48,
+  0x00,
+  0x00,
+  0x01,
+  0x24,
+  0x80,
+};
+const struct IrCode code_eu079Code PROGMEM = {
+  freq_to_timerval(38462),
+  68,		// # of pairs
+  3,		// # of bits per index
+  code_eu079Times,
+  code_eu079Codes
+};
+const uint16_t code_eu080Times[] PROGMEM = {
+  55, 57,
+  55, 167,
+  55, 4416,
+  895, 448,
+  897, 447,
+};
+const uint8_t code_eu080Codes[] PROGMEM = {
+  0x60,
+  0x00,
+  0x00,
+  0x20,
+  0x10,
+  0x09,
+  0x04,
+  0x02,
+  0x01,
+  0x00,
+  0x90,
+  0x48,
+  0x2A,
+  0x00,
+  0x00,
+  0x00,
+  0x80,
+  0x40,
+  0x24,
+  0x10,
+  0x08,
+  0x04,
+  0x02,
+  0x41,
+  0x20,
+  0x80,
+};
+const struct IrCode code_eu080Code PROGMEM = {
+  freq_to_timerval(38462),
+  68,		// # of pairs
+  3,		// # of bits per index
+  code_eu080Times,
+  code_eu080Codes
+};
+
+const uint16_t code_eu081Times[] PROGMEM = {
+  26, 185,
+  27, 80,
+  27, 185,
+  27, 4249,
+};
+const uint8_t code_eu081Codes[] PROGMEM = {
+  0x1A,
+  0x5A,
+  0x65,
+  0x67,
+  0x9A,
+  0x65,
+  0x9A,
+  0x9B,
+  0x9A,
+  0x5A,
+  0x65,
+  0x67,
+  0x9A,
+  0x65,
+  0x9A,
+  0x9B,
+  0x9A,
+  0x5A,
+  0x65,
+  0x65,
+};
+const struct IrCode code_eu081Code PROGMEM = {
+  freq_to_timerval(38462),
+  80,		// # of pairs
+  2,		// # of bits per index
+  code_eu081Times,
+  code_eu081Codes
+};
+const uint16_t code_eu082Times[] PROGMEM = {
+  51, 56,
+  51, 162,
+  51, 2842,
+  848, 430,
+  850, 429,
+};
+const uint8_t code_eu082Codes[] PROGMEM = {
+  0x60,
+  0x82,
+  0x08,
+  0x24,
+  0x10,
+  0x41,
+  0x04,
+  0x82,
+  0x40,
+  0x00,
+  0x10,
+  0x09,
+  0x2A,
+  0x02,
+  0x08,
+  0x20,
+  0x90,
+  0x41,
+  0x04,
+  0x12,
+  0x09,
+  0x00,
+  0x00,
+  0x40,
+  0x24,
+  0x80,
+};
+const struct IrCode code_eu082Code PROGMEM = {
+  freq_to_timerval(40000),
+  68,		// # of pairs
+  3,		// # of bits per index
+  code_eu082Times,
+  code_eu082Codes
+};
+const uint16_t code_eu083Times[] PROGMEM = {
+  16, 559,
+  16, 847,
+  16, 5900,
+  17, 559,
+  17, 847,
+};
+const uint8_t code_eu083Codes[] PROGMEM = {
+  0x0E,
+  0x38,
+  0x21,
+  0x82,
+  0x26,
+  0x20,
+  0x82,
+  0x48,
+  0x23,
+};
+const struct IrCode code_eu083Code PROGMEM = {
+  freq_to_timerval(33333),
+  24,		// # of pairs
+  3,		// # of bits per index
+  code_eu083Times,
+  code_eu083Codes
+};
+const uint16_t code_eu084Times[] PROGMEM = {
+  16, 484,
+  16, 738,
+  16, 739,
+  16, 4795,
+};
+const uint8_t code_eu084Codes[] PROGMEM = {
+  0x6A,
+  0xA0,
+  0x03,
+  0xAA,
+  0xA0,
+  0x01,
+};
+const struct IrCode code_eu084Code PROGMEM = {
+  freq_to_timerval(38462),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu084Times,
+  code_eu084Codes
+};
+const uint16_t code_eu085Times[] PROGMEM = {
+  48, 52,
+  48, 160,
+  48, 400,
+  48, 2120,
+  799, 400,
+};
+const uint8_t code_eu085Codes[] PROGMEM = {
+  0x84,
+  0x82,
+  0x40,
+  0x08,
+  0x92,
+  0x48,
+  0x01,
+  0xC2,
+  0x41,
+  0x20,
+  0x04,
+  0x49,
+  0x24,
+  0x00,
+  0x40,
+};
+const struct IrCode code_eu085Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_eu085Times,
+  code_eu085Codes
+};
+const uint16_t code_eu086Times[] PROGMEM = {
+  16, 851,
+  17, 554,
+  17, 850,
+  17, 851,
+  17, 4847,
+};
+const uint8_t code_eu086Codes[] PROGMEM = {
+  0x45,
+  0x86,
+  0x5B,
+  0x05,
+  0xC6,
+  0x5B,
+  0x05,
+  0xB0,
+  0x42,
+};
+const struct IrCode code_eu086Code PROGMEM = {
+  freq_to_timerval(33333),
+  24,		// # of pairs
+  3,		// # of bits per index
+  code_eu086Times,
+  code_eu086Codes
+};
+const uint16_t code_eu087Times[] PROGMEM = {
+  14, 491,
+  14, 743,
+  14, 5126,
+};
+const uint8_t code_eu087Codes[] PROGMEM = {
+  0x55,
+  0x50,
+  0x02,
+  0x55,
+  0x50,
+  0x01,
+};
+const struct IrCode code_eu087Code PROGMEM = {
+  freq_to_timerval(38462),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu087Times,
+  code_eu087Codes
+};
+const uint16_t code_eu088Times[] PROGMEM = {
+  14, 491,
+  14, 743,
+  14, 4874,
+};
+const uint8_t code_eu088Codes[] PROGMEM = {
+  0x45,
+  0x54,
+  0x42,
+  0x45,
+  0x54,
+  0x41,
+};
+const struct IrCode code_eu088Code PROGMEM = {
+  freq_to_timerval(38462),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu088Times,
+  code_eu088Codes
+};
+
+/* Duplicate timing table, same as na021 !
+ const uint16_t code_eu089Times[] PROGMEM = {
+ 	48, 52,
+ 	48, 160,
+ 	48, 400,
+ 	48, 2335,
+ 	799, 400,
+ };
+ */
+const uint8_t code_eu089Codes[] PROGMEM = {
+  0x84,
+  0x10,
+  0x40,
+  0x08,
+  0x82,
+  0x08,
+  0x01,
+  0xC2,
+  0x08,
+  0x20,
+  0x04,
+  0x41,
+  0x04,
+  0x00,
+  0x40,
+};
+const struct IrCode code_eu089Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na021Times,
+  code_eu089Codes
+};
+const uint16_t code_eu090Times[] PROGMEM = {
+  3, 9,
+  3, 19,
+  3, 29,
+  3, 39,
+  3, 9968,
+};
+const uint8_t code_eu090Codes[] PROGMEM = {
+  0x60,
+  0x00,
+  0x88,
+  0x00,
+  0x02,
+  0xE3,
+  0x00,
+  0x04,
+  0x40,
+  0x00,
+  0x16,
+};
+const struct IrCode code_eu090Code PROGMEM = {
+  0,              // Non-pulsed code
+  29,		// # of pairs
+  3,		// # of bits per index
+  code_eu090Times,
+  code_eu090Codes
+};
+const uint16_t code_eu091Times[] PROGMEM = {
+  15, 138,
+  15, 446,
+  15, 605,
+  15, 6565,
+};
+const uint8_t code_eu091Codes[] PROGMEM = {
+  0x80,
+  0x01,
+  0x00,
+  0x2E,
+  0x00,
+  0x04,
+  0x00,
+  0xA0,
+};
+const struct IrCode code_eu091Code PROGMEM = {
+  freq_to_timerval(38462),
+  30,		// # of pairs
+  2,		// # of bits per index
+  code_eu091Times,
+  code_eu091Codes
+};
+const uint16_t code_eu092Times[] PROGMEM = {
+  48, 50,
+  48, 148,
+  48, 149,
+  48, 1424,
+};
+const uint8_t code_eu092Codes[] PROGMEM = {
+  0x48,
+  0x80,
+  0x0E,
+  0x22,
+  0x00,
+  0x10,
+};
+const struct IrCode code_eu092Code PROGMEM = {
+  freq_to_timerval(40000),
+  22,		// # of pairs
+  2,		// # of bits per index
+  code_eu092Times,
+  code_eu092Codes
+};
+const uint16_t code_eu093Times[] PROGMEM = {
+  87, 639,
+  88, 275,
+  88, 639,
+};
+const uint8_t code_eu093Codes[] PROGMEM = {
+  0x15,
+  0x9A,
+  0x94,
+};
+const struct IrCode code_eu093Code PROGMEM = {
+  freq_to_timerval(35714),
+  11,		// # of pairs
+  2,		// # of bits per index
+  code_eu093Times,
+  code_eu093Codes
+};
+const uint16_t code_eu094Times[] PROGMEM = {
+  3, 8,
+  3, 18,
+  3, 24,
+  3, 38,
+  3, 9969,
+};
+const uint8_t code_eu094Codes[] PROGMEM = {
+  0x60,
+  0x80,
+  0x88,
+  0x00,
+  0x00,
+  0xE3,
+  0x04,
+  0x04,
+  0x40,
+  0x00,
+  0x06,
+};
+const struct IrCode code_eu094Code PROGMEM = {
+  0,              // Non-pulsed code
+  29,		// # of pairs
+  3,		// # of bits per index
+  code_eu094Times,
+  code_eu094Codes
+};
+
+/* Duplicate timing table, same as eu046 !
+ const uint16_t code_eu095Times[] PROGMEM = {
+ 	15, 493,
+ 	16, 493,
+ 	16, 698,
+ 	16, 1414,
+ };
+ */
+const uint8_t code_eu095Codes[] PROGMEM = {
+  0x2A,
+  0xAB,
+  0x6A,
+  0xAA,
+};
+const struct IrCode code_eu095Code PROGMEM = {
+  freq_to_timerval(34483),
+  16,		// # of pairs
+  2,		// # of bits per index
+  code_eu046Times,
+  code_eu095Codes
+};
+const uint16_t code_eu096Times[] PROGMEM = {
+  13, 608,
+  14, 141,
+  14, 296,
+  14, 451,
+  14, 606,
+  14, 608,
+  14, 6207,
+};
+const uint8_t code_eu096Codes[] PROGMEM = {
+  0x04,
+  0x94,
+  0x4B,
+  0x24,
+  0x95,
+  0x35,
+  0x24,
+  0xA2,
+  0x59,
+  0x24,
+  0xA8,
+  0x40,
+};
+const struct IrCode code_eu096Code PROGMEM = {
+  freq_to_timerval(38462),
+  30,		// # of pairs
+  3,		// # of bits per index
+  code_eu096Times,
+  code_eu096Codes
+};
+
+/* Duplicate timing table, same as eu046 !
+ const uint16_t code_eu097Times[] PROGMEM = {
+ 	15, 493,
+ 	16, 493,
+ 	16, 698,
+ 	16, 1414,
+ };
+ */
+const uint8_t code_eu097Codes[] PROGMEM = {
+  0x19,
+  0xAB,
+  0x59,
+  0xA9,
+};
+const struct IrCode code_eu097Code PROGMEM = {
+  freq_to_timerval(34483),
+  16,		// # of pairs
+  2,		// # of bits per index
+  code_eu046Times,
+  code_eu097Codes
+};
+const uint16_t code_eu098Times[] PROGMEM = {
+  3, 8,
+  3, 18,
+  3, 28,
+  3, 12731,
+};
+const uint8_t code_eu098Codes[] PROGMEM = {
+  0x80,
+  0x01,
+  0x00,
+  0xB8,
+  0x55,
+  0x10,
+  0x08,
+};
+const struct IrCode code_eu098Code PROGMEM = {
+  0,              // Non-pulsed code
+  27,		// # of pairs
+  2,		// # of bits per index
+  code_eu098Times,
+  code_eu098Codes
+};
+const uint16_t code_eu099Times[] PROGMEM = {
+  46, 53,
+  46, 106,
+  46, 260,
+  46, 1502,
+  46, 10962,
+  93, 53,
+  93, 106,
+};
+const uint8_t code_eu099Codes[] PROGMEM = {
+  0x46,
+  0x80,
+  0x00,
+  0x00,
+  0x00,
+  0x03,
+  0x44,
+  0x52,
+  0x00,
+  0x00,
+  0x0C,
+  0x22,
+  0x22,
+  0x90,
+  0x00,
+  0x00,
+  0x60,
+  0x80,
+};
+const struct IrCode code_eu099Code PROGMEM = {
+  freq_to_timerval(35714),
+  46,		// # of pairs
+  3,		// # of bits per index
+  code_eu099Times,
+  code_eu099Codes
+};
+
+
+/* Duplicate timing table, same as eu098 !
+ const uint16_t code_eu100Times[] PROGMEM = {
+ 	3, 8,
+ 	3, 18,
+ 	3, 28,
+ 	3, 12731,
+ };
+ */
+const uint8_t code_eu100Codes[] PROGMEM = {
+  0x80,
+  0x04,
+  0x00,
+  0xB8,
+  0x55,
+  0x40,
+  0x08,
+};
+const struct IrCode code_eu100Code PROGMEM = {
+  0,              // Non-pulsed code
+  27,		// # of pairs
+  2,		// # of bits per index
+  code_eu098Times,
+  code_eu100Codes
+};
+
+
+
+const uint16_t code_eu101Times[] PROGMEM = {
+  14, 491,
+  14, 743,
+  14, 4674,
+};
+const uint8_t code_eu101Codes[] PROGMEM = {
+  0x55,
+  0x50,
+  0x06,
+  0x55,
+  0x50,
+  0x05,
+};
+const struct IrCode code_eu101Code PROGMEM = {
+  freq_to_timerval(38462),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu101Times,
+  code_eu101Codes
+};
+
+/* Duplicate timing table, same as eu087 !
+ const uint16_t code_eu102Times[] PROGMEM = {
+ 	14, 491,
+ 	14, 743,
+ 	14, 5126,
+ };
+ */
+const uint8_t code_eu102Codes[] PROGMEM = {
+  0x45,
+  0x54,
+  0x02,
+  0x45,
+  0x54,
+  0x01,
+};
+const struct IrCode code_eu102Code PROGMEM = {
+  freq_to_timerval(38462),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu087Times,
+  code_eu102Codes
+};
+const uint16_t code_eu103Times[] PROGMEM = {
+  44, 815,
+  45, 528,
+  45, 815,
+  45, 5000,
+};
+const uint8_t code_eu103Codes[] PROGMEM = {
+  0x29,
+  0x9A,
+  0x9B,
+  0xA9,
+  0x9A,
+  0x9A,
+};
+const struct IrCode code_eu103Code PROGMEM = {
+  freq_to_timerval(34483),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu103Times,
+  code_eu103Codes
+};
+const uint16_t code_eu104Times[] PROGMEM = {
+  14, 491,
+  14, 743,
+  14, 5881,
+};
+const uint8_t code_eu104Codes[] PROGMEM = {
+  0x44,
+  0x40,
+  0x02,
+  0x44,
+  0x40,
+  0x01,
+};
+const struct IrCode code_eu104Code PROGMEM = {
+  freq_to_timerval(38462),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu104Times,
+  code_eu104Codes
+};
+
+/* Duplicate timing table, same as na009 !
+ const uint16_t code_eu105Times[] PROGMEM = {
+ 	53, 56,
+ 	53, 171,
+ 	53, 3950,
+ 	53, 9599,
+ 	898, 451,
+ 	900, 226,
+ };
+ */
+const uint8_t code_eu105Codes[] PROGMEM = {
+  0x84,
+  0x10,
+  0x00,
+  0x20,
+  0x90,
+  0x01,
+  0x00,
+  0x80,
+  0x40,
+  0x04,
+  0x12,
+  0x09,
+  0x2A,
+  0xBA,
+  0x40,
+};
+const struct IrCode code_eu105Code PROGMEM = {
+  freq_to_timerval(38610),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na009Times,
+  code_eu105Codes
+};
+const uint16_t code_eu106Times[] PROGMEM = {
+  48, 246,
+  50, 47,
+  50, 94,
+  50, 245,
+  50, 1488,
+  50, 10970,
+  100, 47,
+  100, 94,
+};
+const uint8_t code_eu106Codes[] PROGMEM = {
+  0x0B,
+  0x12,
+  0x49,
+  0x24,
+  0x92,
+  0x49,
+  0x8D,
+  0x1C,
+  0x89,
+  0x27,
+  0xFC,
+  0xAB,
+  0x47,
+  0x22,
+  0x49,
+  0xFF,
+  0x2A,
+  0xD1,
+  0xC8,
+  0x92,
+  0x7F,
+  0xC9,
+  0x00,
+};
+const struct IrCode code_eu106Code PROGMEM = {
+  freq_to_timerval(38462),
+  59,		// # of pairs
+  3,		// # of bits per index
+  code_eu106Times,
+  code_eu106Codes
+};
+const uint16_t code_eu107Times[] PROGMEM = {
+  16, 847,
+  16, 5900,
+  17, 559,
+  17, 846,
+  17, 847,
+};
+const uint8_t code_eu107Codes[] PROGMEM = {
+  0x62,
+  0x08,
+  0xA0,
+  0x8A,
+  0x19,
+  0x04,
+  0x08,
+  0x40,
+  0x83,
+};
+const struct IrCode code_eu107Code PROGMEM = {
+  freq_to_timerval(33333),
+  24,		// # of pairs
+  3,		// # of bits per index
+  code_eu107Times,
+  code_eu107Codes
+};
+const uint16_t code_eu108Times[] PROGMEM = {
+  14, 491,
+  14, 743,
+  14, 4622,
+};
+const uint8_t code_eu108Codes[] PROGMEM = {
+  0x45,
+  0x54,
+  0x16,
+  0x45,
+  0x54,
+  0x15,
+};
+const struct IrCode code_eu108Code PROGMEM = {
+  freq_to_timerval(38462),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu108Times,
+  code_eu108Codes
+};
+const uint16_t code_eu109Times[] PROGMEM = {
+  24, 185,
+  27, 78,
+  27, 183,
+  27, 1542,
+};
+const uint8_t code_eu109Codes[] PROGMEM = {
+  0x19,
+  0x95,
+  0x5E,
+  0x66,
+  0x55,
+  0x50,
+};
+const struct IrCode code_eu109Code PROGMEM = {
+  freq_to_timerval(38462),
+  22,		// # of pairs
+  2,		// # of bits per index
+  code_eu109Times,
+  code_eu109Codes
+};
+
+
+const uint16_t code_eu110Times[] PROGMEM = {
+  56, 55,
+  56, 168,
+  56, 4850,
+  447, 453,
+  448, 453,
+};
+const uint8_t code_eu110Codes[] PROGMEM = {
+  0x64,
+  0x10,
+  0x00,
+  0x04,
+  0x10,
+  0x00,
+  0x00,
+  0x80,
+  0x00,
+  0x04,
+  0x12,
+  0x49,
+  0x2A,
+  0x10,
+  0x40,
+  0x00,
+  0x10,
+  0x40,
+  0x00,
+  0x02,
+  0x00,
+  0x00,
+  0x10,
+  0x49,
+  0x24,
+  0x90,
+};
+const struct IrCode code_eu110Code PROGMEM = {
+  freq_to_timerval(38462),
+  68,		// # of pairs
+  3,		// # of bits per index
+  code_eu110Times,
+  code_eu110Codes
+};
+const uint16_t code_eu111Times[] PROGMEM = {
+  49, 52,
+  49, 250,
+  49, 252,
+  49, 2377,
+  49, 12009,
+  100, 52,
+  100, 102,
+};
+const uint8_t code_eu111Codes[] PROGMEM = {
+  0x22,
+  0x80,
+  0x1A,
+  0x18,
+  0x01,
+  0x10,
+  0xC0,
+  0x02,
+};
+const struct IrCode code_eu111Code PROGMEM = {
+  freq_to_timerval(31250),
+  21,		// # of pairs
+  3,		// # of bits per index
+  code_eu111Times,
+  code_eu111Codes
+};
+const uint16_t code_eu112Times[] PROGMEM = {
+  55, 55,
+  55, 167,
+  55, 5023,
+  55, 9506,
+  448, 445,
+  450, 444,
+};
+const uint8_t code_eu112Codes[] PROGMEM = {
+  0x80,
+  0x02,
+  0x00,
+  0x00,
+  0x02,
+  0x00,
+  0x04,
+  0x92,
+  0x00,
+  0x00,
+  0x00,
+  0x49,
+  0x2A,
+  0x97,
+  0x48,
+};
+const struct IrCode code_eu112Code PROGMEM = {
+  freq_to_timerval(38462),
+  40,		// # of pairs
+  3,		// # of bits per index
+  code_eu112Times,
+  code_eu112Codes
+};
+
+
+/* Duplicate timing table, same as eu054 !
+ const uint16_t code_eu113Times[] PROGMEM = {
+ 	49, 53,
+ 	49, 104,
+ 	49, 262,
+ 	49, 264,
+ 	49, 8030,
+ 	100, 103,
+ };
+ */
+const uint8_t code_eu113Codes[] PROGMEM = {
+  0x46,
+  0x80,
+  0x23,
+  0x34,
+  0x00,
+  0x80,
+};
+const struct IrCode code_eu113Code PROGMEM = {
+  freq_to_timerval(31250),
+  14,		// # of pairs
+  3,		// # of bits per index
+  code_eu054Times,
+  code_eu113Codes
+};
+
+/* Duplicate timing table, same as eu028 !
+ const uint16_t code_eu114Times[] PROGMEM = {
+ 	47, 267,
+ 	50, 55,
+ 	50, 110,
+ 	50, 265,
+ 	50, 2055,
+ 	50, 12117,
+ 	100, 57,
+ };
+ */
+const uint8_t code_eu114Codes[] PROGMEM = {
+  0x04,
+  0x92,
+  0x49,
+  0x26,
+  0x34,
+  0x71,
+  0x44,
+  0x9A,
+  0xD1,
+  0xC5,
+  0x12,
+  0x48,
+};
+const struct IrCode code_eu114Code PROGMEM = {
+  freq_to_timerval(30303),
+  31,		// # of pairs
+  3,		// # of bits per index
+  code_eu028Times,
+  code_eu114Codes
+};
+
+
+const uint16_t code_eu115Times[] PROGMEM = {
+  48, 98,
+  48, 196,
+  97, 836,
+  395, 388,
+  1931, 389,
+};
+const uint8_t code_eu115Codes[] PROGMEM = {
+  0x84,
+  0x92,
+  0x01,
+  0x24,
+  0x12,
+  0x00,
+  0x04,
+  0x80,
+  0x08,
+  0x09,
+  0x92,
+  0x48,
+  0x04,
+  0x90,
+  0x48,
+  0x00,
+  0x12,
+  0x00,
+  0x20,
+  0x26,
+  0x49,
+  0x20,
+  0x12,
+  0x41,
+  0x20,
+  0x00,
+  0x48,
+  0x00,
+  0x82,
+};
+const struct IrCode code_eu115Code PROGMEM = {
+  freq_to_timerval(58824),
+  77,		// # of pairs
+  3,		// # of bits per index
+  code_eu115Times,
+  code_eu115Codes
+};
+const uint16_t code_eu116Times[] PROGMEM = {
+  3, 9,
+  3, 31,
+  3, 42,
+  3, 10957,
+};
+const uint8_t code_eu116Codes[] PROGMEM = {
+  0x80,
+  0x01,
+  0x00,
+  0x2E,
+  0x00,
+  0x04,
+  0x00,
+  0x80,
+};
+const struct IrCode code_eu116Code PROGMEM = {
+  0,              // Non-pulsed code
+  29,		// # of pairs
+  2,		// # of bits per index
+  code_eu116Times,
+  code_eu116Codes
+};
+const uint16_t code_eu117Times[] PROGMEM = {
+  49, 53,
+  49, 262,
+  49, 264,
+  49, 8030,
+  100, 103,
+};
+const uint8_t code_eu117Codes[] PROGMEM = {
+  0x22,
+  0x00,
+  0x1A,
+  0x10,
+  0x00,
+  0x40,
+};
+const struct IrCode code_eu117Code PROGMEM = {
+  freq_to_timerval(31250),
+  14,		// # of pairs
+  3,		// # of bits per index
+  code_eu117Times,
+  code_eu117Codes
+};
+const uint16_t code_eu118Times[] PROGMEM = {
+  44, 815,
+  45, 528,
+  45, 815,
+  45, 4713,
+};
+const uint8_t code_eu118Codes[] PROGMEM = {
+  0x2A,
+  0x9A,
+  0x9B,
+  0xAA,
+  0x9A,
+  0x9A,
+};
+const struct IrCode code_eu118Code PROGMEM = {
+  freq_to_timerval(34483),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu118Times,
+  code_eu118Codes
+};
+
+const uint16_t code_eu119Times[] PROGMEM = {
+  14, 491,
+  14, 743,
+  14, 5430,
+};
+const uint8_t code_eu119Codes[] PROGMEM = {
+  0x44,
+  0x44,
+  0x02,
+  0x44,
+  0x44,
+  0x01,
+};
+const struct IrCode code_eu119Code PROGMEM = {
+  freq_to_timerval(38462),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu119Times,
+  code_eu119Codes
+};
+
+
+const uint16_t code_eu120Times[] PROGMEM = {
+  19, 78,
+  21, 27,
+  21, 77,
+  21, 3785,
+  22, 0,
+};
+const uint8_t code_eu120Codes[] PROGMEM = {
+  0x09,
+  0x24,
+  0x92,
+  0x49,
+  0x12,
+  0x4A,
+  0x24,
+  0x92,
+  0x49,
+  0x24,
+  0x92,
+  0x49,
+  0x24,
+  0x94,
+  0x89,
+  0x69,
+  0x24,
+  0x92,
+  0x49,
+  0x22,
+  0x49,
+  0x44,
+  0x92,
+  0x49,
+  0x24,
+  0x92,
+  0x49,
+  0x24,
+  0x92,
+  0x91,
+  0x30,
+};
+const struct IrCode code_eu120Code PROGMEM = {
+  freq_to_timerval(38462),
+  82,		// # of pairs
+  3,		// # of bits per index
+  code_eu120Times,
+  code_eu120Codes
+};
+
+/* Duplicate timing table, same as eu051 !
+ const uint16_t code_eu121Times[] PROGMEM = {
+ 	84, 88,
+ 	84, 261,
+ 	84, 3360,
+ 	347, 347,
+ 	347, 348,
+ };
+ */
+const uint8_t code_eu121Codes[] PROGMEM = {
+  0x64,
+  0x00,
+  0x09,
+  0x24,
+  0x00,
+  0x09,
+  0x24,
+  0x00,
+  0x09,
+  0x2A,
+  0x10,
+  0x00,
+  0x24,
+  0x90,
+  0x00,
+  0x24,
+  0x90,
+  0x00,
+  0x24,
+  0x90,
+};
+const struct IrCode code_eu121Code PROGMEM = {
+  freq_to_timerval(38462),
+  52,		// # of pairs
+  3,		// # of bits per index
+  code_eu051Times,
+  code_eu121Codes
+};
+
+/* Duplicate timing table, same as eu120 !
+ const uint16_t code_eu122Times[] PROGMEM = {
+ 	19, 78,
+ 	21, 27,
+ 	21, 77,
+ 	21, 3785,
+ 	22, 0,
+ };
+ */
+const uint8_t code_eu122Codes[] PROGMEM = {
+  0x04,
+  0xA4,
+  0x92,
+  0x49,
+  0x22,
+  0x49,
+  0x48,
+  0x92,
+  0x49,
+  0x24,
+  0x92,
+  0x49,
+  0x24,
+  0x94,
+  0x89,
+  0x68,
+  0x94,
+  0x92,
+  0x49,
+  0x24,
+  0x49,
+  0x29,
+  0x12,
+  0x49,
+  0x24,
+  0x92,
+  0x49,
+  0x24,
+  0x92,
+  0x91,
+  0x30,
+};
+const struct IrCode code_eu122Code PROGMEM = {
+  freq_to_timerval(38462),
+  82,		// # of pairs
+  3,		// # of bits per index
+  code_eu120Times,
+  code_eu122Codes
+};
+const uint16_t code_eu123Times[] PROGMEM = {
+  13, 490,
+  13, 741,
+  13, 742,
+  13, 5443,
+};
+const uint8_t code_eu123Codes[] PROGMEM = {
+  0x6A,
+  0xA0,
+  0x0B,
+  0xAA,
+  0xA0,
+  0x09,
+};
+const struct IrCode code_eu123Code PROGMEM = {
+  freq_to_timerval(40000),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu123Times,
+  code_eu123Codes
+};
+const uint16_t code_eu124Times[] PROGMEM = {
+  50, 54,
+  50, 158,
+  50, 407,
+  50, 2153,
+  843, 407,
+};
+const uint8_t code_eu124Codes[] PROGMEM = {
+  0x80,
+  0x10,
+  0x40,
+  0x08,
+  0x92,
+  0x48,
+  0x01,
+  0xC0,
+  0x08,
+  0x20,
+  0x04,
+  0x49,
+  0x24,
+  0x00,
+  0x00,
+};
+const struct IrCode code_eu124Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_eu124Times,
+  code_eu124Codes
+};
+const uint16_t code_eu125Times[] PROGMEM = {
+  55, 56,
+  55, 168,
+  55, 3929,
+  56, 0,
+  882, 454,
+  884, 452,
+};
+const uint8_t code_eu125Codes[] PROGMEM = {
+  0x84,
+  0x80,
+  0x00,
+  0x20,
+  0x82,
+  0x49,
+  0x00,
+  0x02,
+  0x00,
+  0x04,
+  0x90,
+  0x49,
+  0x2A,
+  0x92,
+  0x00,
+  0x00,
+  0x82,
+  0x09,
+  0x24,
+  0x00,
+  0x08,
+  0x00,
+  0x12,
+  0x41,
+  0x24,
+  0xB0,
+};
+const struct IrCode code_eu125Code PROGMEM = {
+  freq_to_timerval(38462),
+  68,		// # of pairs
+  3,		// # of bits per index
+  code_eu125Times,
+  code_eu125Codes
+};
+
+/* Duplicate timing table, same as na004 !
+ const uint16_t code_eu126Times[] PROGMEM = {
+ 	55, 57,
+ 	55, 170,
+ 	55, 3949,
+ 	55, 9623,
+ 	56, 0,
+ 	898, 453,
+ 	900, 226,
+ };
+ */
+const uint8_t code_eu126Codes[] PROGMEM = {
+  0xA0,
+  0x00,
+  0x00,
+  0x04,
+  0x92,
+  0x49,
+  0x20,
+  0x00,
+  0x00,
+  0x04,
+  0x92,
+  0x49,
+  0x2B,
+  0x3D,
+  0x00,
+};
+const struct IrCode code_eu126Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na004Times,
+  code_eu126Codes
+};
+
+/* Duplicate timing table, same as eu087 !
+ const uint16_t code_eu127Times[] PROGMEM = {
+ 	14, 491,
+ 	14, 743,
+ 	14, 5126,
+ };
+ */
+const uint8_t code_eu127Codes[] PROGMEM = {
+  0x44,
+  0x40,
+  0x56,
+  0x44,
+  0x40,
+  0x55,
+};
+const struct IrCode code_eu127Code PROGMEM = {
+  freq_to_timerval(38462),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu087Times,
+  code_eu127Codes
+};
+const uint16_t code_eu128Times[] PROGMEM = {
+  152, 471,
+  154, 156,
+  154, 469,
+  154, 782,
+  154, 2947,
+};
+const uint8_t code_eu128Codes[] PROGMEM = {
+  0x05,
+  0xC4,
+  0x59,
+};
+const struct IrCode code_eu128Code PROGMEM = {
+  freq_to_timerval(41667),
+  8,		// # of pairs
+  3,		// # of bits per index
+  code_eu128Times,
+  code_eu128Codes
+};
+const uint16_t code_eu129Times[] PROGMEM = {
+  50, 50,
+  50, 99,
+  50, 251,
+  50, 252,
+  50, 1449,
+  50, 11014,
+  102, 49,
+  102, 98,
+};
+const uint8_t code_eu129Codes[] PROGMEM = {
+  0x47,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x8C,
+  0x8C,
+  0x40,
+  0x03,
+  0xF1,
+  0xEB,
+  0x23,
+  0x10,
+  0x00,
+  0xFC,
+  0x74,
+};
+const struct IrCode code_eu129Code PROGMEM = {
+  freq_to_timerval(38462),
+  45,		// # of pairs
+  3,		// # of bits per index
+  code_eu129Times,
+  code_eu129Codes
+};
+
+/* Duplicate timing table, same as eu129 !
+ const uint16_t code_eu130Times[] PROGMEM = {
+ 	50, 50,
+ 	50, 99,
+ 	50, 251,
+ 	50, 252,
+ 	50, 1449,
+ 	50, 11014,
+ 	102, 49,
+ 	102, 98,
+ };
+ */
+const uint8_t code_eu130Codes[] PROGMEM = {
+  0x47,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x8C,
+  0x8C,
+  0x40,
+  0x03,
+  0xE3,
+  0xEB,
+  0x23,
+  0x10,
+  0x00,
+  0xF8,
+  0xF4,
+};
+const struct IrCode code_eu130Code PROGMEM = {
+  freq_to_timerval(38462),
+  45,		// # of pairs
+  3,		// # of bits per index
+  code_eu129Times,
+  code_eu130Codes
+};
+const uint16_t code_eu131Times[] PROGMEM = {
+  14, 491,
+  14, 743,
+  14, 4170,
+};
+const uint8_t code_eu131Codes[] PROGMEM = {
+  0x55,
+  0x55,
+  0x42,
+  0x55,
+  0x55,
+  0x41,
+};
+const struct IrCode code_eu131Code PROGMEM = {
+  freq_to_timerval(38462),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu131Times,
+  code_eu131Codes
+};
+
+/* Duplicate timing table, same as eu069 !
+ const uint16_t code_eu132Times[] PROGMEM = {
+ 	4, 499,
+ 	4, 750,
+ 	4, 4999,
+ };
+ */
+const uint8_t code_eu132Codes[] PROGMEM = {
+  0x05,
+  0x50,
+  0x06,
+  0x05,
+  0x50,
+  0x04,
+};
+const struct IrCode code_eu132Code PROGMEM = {
+  0,              // Non-pulsed code
+  23,		// # of pairs
+  2,		// # of bits per index
+  code_eu069Times,
+  code_eu132Codes
+};
+
+/* Duplicate timing table, same as eu071 !
+ const uint16_t code_eu133Times[] PROGMEM = {
+ 	14, 491,
+ 	14, 743,
+ 	14, 4422,
+ };
+ */
+const uint8_t code_eu133Codes[] PROGMEM = {
+  0x55,
+  0x54,
+  0x12,
+  0x55,
+  0x54,
+  0x11,
+};
+const struct IrCode code_eu133Code PROGMEM = {
+  freq_to_timerval(38462),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu071Times,
+  code_eu133Codes
+};
+const uint16_t code_eu134Times[] PROGMEM = {
+  13, 490,
+  13, 741,
+  13, 742,
+  13, 5939,
+};
+const uint8_t code_eu134Codes[] PROGMEM = {
+  0x40,
+  0x0A,
+  0x83,
+  0x80,
+  0x0A,
+  0x81,
+};
+const struct IrCode code_eu134Code PROGMEM = {
+  freq_to_timerval(40000),
+  24,		// # of pairs
+  2,		// # of bits per index
+  code_eu134Times,
+  code_eu134Codes
+};
+const uint16_t code_eu135Times[] PROGMEM = {
+  6, 566,
+  6, 851,
+  6, 5188,
+};
+const uint8_t code_eu135Codes[] PROGMEM = {
+  0x54,
+  0x45,
+  0x46,
+  0x54,
+  0x45,
+  0x44,
+};
+const struct IrCode code_eu135Code PROGMEM = {
+  0,              // Non-pulsed code
+  23,		// # of pairs
+  2,		// # of bits per index
+  code_eu135Times,
+  code_eu135Codes
+};
+
+/* Duplicate timing table, same as na004 !
+ const uint16_t code_eu136Times[] PROGMEM = {
+ 	55, 57,
+ 	55, 170,
+ 	55, 3949,
+ 	55, 9623,
+ 	56, 0,
+ 	898, 453,
+ 	900, 226,
+ };
+ */
+const uint8_t code_eu136Codes[] PROGMEM = {
+  0xA0,
+  0x00,
+  0x00,
+  0x04,
+  0x92,
+  0x49,
+  0x24,
+  0x00,
+  0x00,
+  0x00,
+  0x92,
+  0x49,
+  0x2B,
+  0x3D,
+  0x00,
+};
+const struct IrCode code_eu136Code PROGMEM = {
+  freq_to_timerval(38462),
+  38,		// # of pairs
+  3,		// # of bits per index
+  code_na004Times,
+  code_eu136Codes
+};
+const uint16_t code_eu137Times[] PROGMEM = {
+  86, 91,
+  87, 90,
+  87, 180,
+  87, 8868,
+  88, 0,
+  174, 90,
+};
+const uint8_t code_eu137Codes[] PROGMEM = {
+  0x14,
+  0x95,
+  0x4A,
+  0x35,
+  0x9A,
+  0x4A,
+  0xA5,
+  0x1B,
+  0x00,
+};
+const struct IrCode code_eu137Code PROGMEM = {
+  freq_to_timerval(35714),
+  22,		// # of pairs
+  3,		// # of bits per index
+  code_eu137Times,
+  code_eu137Codes
+};
+const uint16_t code_eu138Times[] PROGMEM = {
+  4, 1036,
+  4, 1507,
+  4, 3005,
+};
+const uint8_t code_eu138Codes[] PROGMEM = {
+  0x05,
+  0x60,
+  0x54,
+};
+const struct IrCode code_eu138Code PROGMEM = {
+  0,              // Non-pulsed code
+  11,		// # of pairs
+  2,		// # of bits per index
+  code_eu138Times,
+  code_eu138Codes
+};
+
+const uint16_t code_eu139Times[] PROGMEM = {
+  0, 0,
+  14, 141,
+  14, 452,
+  14, 607,
+  14, 6310,
+};
+const uint8_t code_eu139Codes[] PROGMEM = {
+  0x64,
+  0x92,
+  0x4A,
+  0x24,
+  0x92,
+  0xE3,
+  0x24,
+  0x92,
+  0x51,
+  0x24,
+  0x96,
+  0x00,
+};
+const struct IrCode code_eu139Code PROGMEM = {
+  0,              // Non-pulsed code
+  30,		// # of pairs
+  3,		// # of bits per index
+  code_eu139Times,
+  code_eu139Codes
+};
+
+
+////////////////////////////////////////////////////////////////
+
+
+const struct IrCode *NApowerCodes[] PROGMEM = {
+  &code_na000Code,
+  &code_na001Code,
+  &code_na002Code,
+  &code_na003Code,
+  &code_na004Code,
+  &code_na005Code,
+  &code_na006Code,
+  &code_na007Code,
+  &code_na008Code,
+  &code_na009Code,
+  &code_na010Code,
+  &code_na011Code,
+  &code_na012Code,
+  &code_na013Code,
+  &code_na014Code,
+  &code_na015Code,
+  &code_na016Code,
+  &code_na017Code,
+  &code_na018Code,
+  &code_na019Code,
+  &code_na020Code,
+  &code_na021Code,
+  &code_na022Code,
+  &code_na023Code,
+  &code_na024Code,
+  &code_na025Code,
+  &code_na026Code,
+  &code_na027Code,
+  &code_na028Code,
+  &code_na029Code,
+  &code_na030Code,
+  &code_na031Code,
+  &code_na032Code,
+  &code_na033Code,
+  &code_na034Code,
+  &code_na035Code,
+  &code_na036Code,
+  &code_na037Code,
+  &code_na038Code,
+  &code_na039Code,
+  &code_na040Code,
+  &code_na041Code,
+  &code_na042Code,
+  &code_na043Code,
+  &code_na044Code,
+  &code_na045Code,
+  &code_na046Code,
+  &code_na047Code,
+  &code_na048Code,
+  &code_na049Code,
+  &code_na050Code,
+  &code_na051Code,
+  &code_na052Code,
+  &code_na053Code,
+  &code_na054Code,
+  &code_na055Code,
+  &code_na056Code,
+  &code_na057Code,
+  &code_na058Code,
+  &code_na059Code,
+  &code_na060Code,
+  &code_na061Code,
+  &code_na062Code,
+  &code_na063Code,
+  &code_na064Code,
+  &code_na065Code,
+  &code_na066Code,
+  &code_na067Code,
+  &code_na068Code,
+  &code_na069Code,
+  &code_na070Code,
+  &code_na071Code,
+  &code_na072Code,
+  &code_na073Code,
+  &code_na074Code,
+  &code_na075Code,
+  &code_na076Code,
+  &code_na077Code,
+  &code_na078Code,
+  &code_na079Code,
+  &code_na080Code,
+  &code_na081Code,
+  &code_na082Code,
+  &code_na083Code,
+  &code_na084Code,
+  &code_na085Code,
+  &code_na086Code,
+  &code_na087Code,
+  &code_na088Code,
+  &code_na089Code,
+  &code_na090Code,
+  &code_na091Code,
+  &code_na092Code,
+  &code_na093Code,
+  &code_na094Code,
+  &code_na095Code,
+  &code_na096Code,
+  &code_na097Code,
+  &code_na098Code,
+  &code_na099Code,
+  &code_na100Code,
+  &code_na101Code,
+  &code_na102Code,
+  &code_na103Code,
+  &code_na104Code,
+  &code_na105Code,
+  &code_na106Code,
+  &code_na107Code,
+  &code_na108Code,
+  &code_na109Code,
+  &code_na110Code,
+  &code_na111Code,
+  &code_na112Code,
+  &code_na113Code,
+  &code_na114Code,
+  &code_na115Code,
+  &code_na116Code,
+  &code_na117Code,
+  &code_na118Code,
+  &code_na119Code,
+  &code_na120Code,
+  &code_na121Code,
+  &code_na122Code,
+  &code_na123Code,
+  &code_na124Code,
+  &code_na125Code,
+  &code_na126Code,
+  &code_na127Code,
+  &code_na128Code,
+  &code_na129Code,
+  &code_na130Code,
+  &code_na131Code,
+  &code_na132Code,
+  &code_na133Code,
+  &code_na134Code,
+  &code_na135Code,
+  &code_na136Code,
+};
+
+const struct IrCode *EUpowerCodes[] PROGMEM = {
+  &code_eu000Code,
+  &code_eu001Code,
+  &code_eu002Code,
+  &code_na000Code, // same as &code_eu003Code
+  &code_eu004Code,
+  &code_eu005Code,
+  &code_eu006Code,
+  &code_eu007Code,
+  &code_eu008Code,
+  &code_na005Code, // same as &code_eu009Code
+  &code_na004Code, // same as &code_eu010Code
+  &code_eu011Code,
+  &code_eu012Code,
+  &code_eu013Code,
+  &code_na021Code, // same as &code_eu014Code
+  &code_eu015Code,
+  &code_eu016Code,
+  &code_eu017Code,
+  &code_eu018Code,
+  &code_eu019Code,
+  &code_eu020Code,
+  &code_eu021Code,
+  &code_eu022Code,
+  &code_na022Code, // same as &code_eu023Code
+  &code_eu024Code,
+  &code_eu025Code,
+  &code_eu026Code,
+  &code_eu027Code,
+  &code_eu028Code,
+  &code_eu029Code,
+  &code_eu030Code,
+  &code_eu031Code,
+  &code_eu032Code,
+  &code_eu033Code,
+  &code_eu034Code,
+  //&code_eu035Code, same as eu009
+  &code_eu036Code,
+  &code_eu037Code,
+  &code_eu038Code,
+  &code_eu039Code,
+  &code_eu040Code,
+  &code_eu041Code,
+  &code_eu042Code,
+  &code_eu043Code,
+  &code_eu044Code,
+  &code_eu045Code,
+  &code_eu046Code,
+  &code_eu047Code,
+  &code_eu048Code,
+  &code_eu049Code,
+  &code_eu050Code,
+  &code_eu051Code,
+  &code_eu052Code,
+  &code_eu053Code,
+  &code_eu054Code,
+  &code_eu055Code,
+  &code_eu056Code,
+  //&code_eu057Code, same as eu008
+  &code_eu058Code,
+  &code_eu059Code,
+  &code_eu060Code,
+  &code_eu061Code,
+  &code_eu062Code,
+  &code_eu063Code,
+  &code_eu064Code,
+  &code_eu065Code,
+  &code_eu066Code,
+  &code_eu067Code,
+  &code_eu068Code,
+  &code_eu069Code,
+  &code_eu070Code,
+  &code_eu071Code,
+  &code_eu072Code,
+  &code_eu073Code,
+  &code_eu074Code,
+  &code_eu075Code,
+  &code_eu076Code,
+  &code_eu077Code,
+  &code_eu078Code,
+  &code_eu079Code,
+  &code_eu080Code,
+  &code_eu081Code,
+  &code_eu082Code,
+  &code_eu083Code,
+  &code_eu084Code,
+  &code_eu085Code,
+  &code_eu086Code,
+  &code_eu087Code,
+  &code_eu088Code,
+  &code_eu089Code,
+  &code_eu090Code,
+  &code_eu091Code,
+  &code_eu092Code,
+  &code_eu093Code,
+  &code_eu094Code,
+  &code_eu095Code,
+  &code_eu096Code,
+  &code_eu097Code,
+  &code_eu098Code,
+  &code_eu099Code,
+  &code_eu100Code,
+  &code_eu101Code,
+  &code_eu102Code,
+  &code_eu103Code,
+  &code_eu104Code,
+  &code_eu105Code,
+  &code_eu106Code,
+  &code_eu107Code,
+  &code_eu108Code,
+  &code_eu109Code,
+  &code_eu110Code,
+  &code_eu111Code,
+  &code_eu112Code,
+  &code_eu113Code,
+  &code_eu114Code,
+  &code_eu115Code,
+  &code_eu116Code,
+  &code_eu117Code,
+  &code_eu118Code,
+  &code_eu119Code,
+  &code_eu120Code,
+  &code_eu121Code,
+  &code_eu122Code,
+  &code_eu123Code,
+  &code_eu124Code,
+  &code_eu125Code,
+  &code_eu126Code,
+  &code_eu127Code,
+  &code_eu128Code,
+  &code_eu129Code,
+  &code_eu130Code,
+  &code_eu131Code,
+  &code_eu132Code,
+  &code_eu133Code,
+  &code_eu134Code,
+  &code_eu135Code,
+  &code_eu136Code,
+  &code_eu137Code,
+  &code_eu138Code,
+  &code_eu139Code,
+};
+
+uint8_t num_NAcodes = NUM_ELEM(NApowerCodes);
+uint8_t num_EUcodes = NUM_ELEM(EUpowerCodes);
diff --git a/TVB/main.h b/TVB/main.h
new file mode 100644
index 0000000..9c1f84f
--- /dev/null
+++ b/TVB/main.h
@@ -0,0 +1,45 @@
+#include <avr/pgmspace.h>
+
+
+// The TV-B-Gone for Arduino can use
+//   either the EU or the NA database of POWER CODES
+// EU is for Europe, Middle East, Australia, New Zealand, and some countries in Africa and South America
+// NA is for North America, Asia, and the rest of the world not covered by EU
+
+// Two regions!
+#define NA 1
+#define EU 0
+
+// What pins do what
+#define DBG 12
+#define LED 13
+#define IRLED 3
+#define TRIGGER 2
+#define REGIONSWITCH 5
+
+// Lets us calculate the size of the NA/EU databases
+#define NUM_ELEM(x) (sizeof (x) / sizeof (*(x)));
+
+// set define to 0 to turn off debug output
+#define DEBUG 0
+#define DEBUGP(x) if (DEBUG == 1) { x ; }
+
+// Shortcut to insert single, non-optimized-out nop
+#define NOP __asm__ __volatile__ ("nop")
+
+// Tweak this if neccessary to change timing
+#define DELAY_CNT 25
+
+// Makes the codes more readable. the OCRA is actually
+// programmed in terms of 'periods' not 'freqs' - that
+// is, the inverse!
+#define freq_to_timerval(x) (F_CPU / 8 / x - 1)
+
+// The structure of compressed code entries
+struct IrCode {
+  uint8_t timer_val;
+  uint8_t numpairs;
+  uint8_t bitcompression;
+  uint16_t const *times;
+  uint8_t const*codes;
+};
diff --git a/libraries/readme.txt b/libraries/readme.txt
new file mode 100644
index 0000000..a8f1390
--- /dev/null
+++ b/libraries/readme.txt
@@ -0,0 +1 @@
+For information on installing libraries, see: http://arduino.cc/en/Guide/Libraries