//*******************************************************************
// THE IMAGENODE FUNDRAISER BLINKY 2008
// AKA THE NODEBLINKY
// Code by Todd Polenberg, Jesse Lackey, and Jason Cipriani
// Copyright 2008 Todd Polenberg
// This program is free software: you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//    the Free Software Foundation, either version 3 of the License, or
//    (at your option) any later version.
//
//    This program is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//*****************************************************************

#include <inttypes.h>
#include <io.h>
#include <util/delay.h>
#include <interrupt.h>
#include <stdlib.h>
#include <avr/pgmspace.h>
//#include <math.h>


#define PWM_CHANNELS 28
#define BRIGHTNESS_MAX 255
#define BRIGHTNESS_2 32
#define BRIGHTNESS_3 16
#define BRIGHTNESS_4 1


// These are for compatibility with Jason's  code
typedef char atmel_s8;
typedef unsigned char atmel_u8;
typedef int atmel_s16;
typedef unsigned int atmel_u16;

#define	TRUE	1
#define	FALSE	0

//global variables
volatile unsigned char PWM_MAXVAL=255;
volatile unsigned char pwmCount;
volatile unsigned char leds[PWM_CHANNELS]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //one byte for each LED, we'll need this for PWM later
volatile unsigned char frame[PWM_CHANNELS]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};	// data coming in
volatile unsigned char lastframe[PWM_CHANNELS]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};	// data coming in
volatile unsigned char tempframe[PWM_CHANNELS]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};	// data coming in
volatile unsigned char newframe[PWM_CHANNELS]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};	// data coming in
volatile int testcounter =0;
volatile unsigned char isframe;
volatile unsigned char brightstate =0;
volatile unsigned char brightmax;
volatile unsigned char mode = 1;
volatile unsigned int masterspeed=300;

//volatile int g_ser_counter=0;
int fps =1;
volatile int status_led_is_on;
volatile unsigned char g_framecounter=0;
volatile unsigned char g_load_new_led_data= 0;
volatile unsigned char g_max_brightness= 255;
volatile unsigned char interruptcounter =0;
volatile unsigned char interruptcounter2 =0;
volatile unsigned char mode_has_changed=0;
volatile unsigned char pattern_begin=0;


// PATTERN Consts -- this is LED frame data

const unsigned int Burnzieblinkiev2_h[] PROGMEM = {
  10,
  0x0408, 0x0102, 0x060C, 0x0183, 0xB76E, 0x0DDB, 0xF7EF, 0x0DFB, 
  0xFFFF, 0x0FFF, 0xAF5E, 0x0BD7, 0x6ADD, 0x0AB7, 0xFFFF, 0x0FFF, 
  0x0000, 0x0000, 0x0000, 0x0000
};

const unsigned int pattern1_h[] PROGMEM = {
  41,
  0x4081, 0x0020, 0x0212, 0x0281, 0x0880, 0x0024, 0x6102, 0x0050, 
  0x1020, 0x0408, 0x8102, 0x0040, 0x1024, 0x0409, 0x2040, 0x0810, 
  0x1024, 0x0088, 0x0008, 0x0000, 0x1244, 0x0008, 0x0408, 0x0000, 
  0x2004, 0x0081, 0x0408, 0x0002, 0x0000, 0x0091, 0x0408, 0x0102, 
  0x0104, 0x0041, 0x1420, 0x0508, 0x0104, 0x0041, 0x2440, 0x0910, 
  0x0300, 0x00C0, 0x2048, 0x0812, 0x1120, 0x0448, 0x0608, 0x0182, 
  0x0104, 0x0041, 0x2240, 0x0890, 0x1124, 0x0449, 0x2040, 0x0810, 
  0x0300, 0x00C0, 0x0004, 0x0001, 0x8302, 0x00C0, 0x1024, 0x0409, 
  0x8912, 0x0244, 0x4285, 0x00A1, 0x8102, 0x0040, 0x4081, 0x0020, 
  0x8102, 0x0040, 0x0204, 0x0081, 0x0408, 0x0100, 0x2244, 0x0081, 
  0x0000, 0x0910
};


const unsigned int bacon3_h[] PROGMEM = {
  8,
  0x4081, 0x0020, 0x0408, 0x0102, 0x0810, 0x0204, 0x0204, 0x0081, 
  0x4081, 0x0020, 0x1020, 0x0408, 0x2040, 0x0810, 0x8102, 0x0040
};

const unsigned int bacon4_h[] PROGMEM = {
  16,
  0x0008, 0x0880, 0x0000, 0x0000, 0x0000, 0x0111, 0x0000, 0x0000, 
  0x2200, 0x0002, 0x0000, 0x0000, 0x0044, 0x0400, 0x0000, 0x0000, 
  0x4000, 0x0444, 0x0000, 0x0000, 0x8880, 0x0008, 0x0000, 0x0000, 
  0x1111, 0x0000, 0x0000, 0x0000, 0x0022, 0x0220, 0x0000, 0x0000
};

const unsigned int bacon5_h[] PROGMEM = {
  13,
  0x0088, 0x0022, 0x4401, 0x0100, 0x0840, 0x0210, 0x2010, 0x0804, 
  0x0820, 0x0208, 0x4101, 0x0040, 0x8082, 0x0020, 0x1100, 0x0440, 
  0x8022, 0x0008, 0x2200, 0x0880, 0x0044, 0x0011, 0x0408, 0x0102, 
  0x0104, 0x0041
};

const unsigned int Bacon6_h[] PROGMEM = {
  24,
  0x4081, 0x0020, 0x0000, 0x0000, 0x0810, 0x0204, 0x0000, 0x0000, 
  0x8102, 0x0040, 0x0000, 0x0000, 0x1020, 0x0408, 0x0000, 0x0000, 
  0x0204, 0x0081, 0x0000, 0x0000, 0x2040, 0x0810, 0x0000, 0x0000, 
  0x0408, 0x0102, 0x0000, 0x0000, 0x2040, 0x0810, 0x0000, 0x0000, 
  0x0204, 0x0081, 0x0000, 0x0000, 0x1020, 0x0408, 0x0000, 0x0000, 
  0x8102, 0x0040, 0x0000, 0x0000, 0x0810, 0x0204, 0x0000, 0x0000
};

const unsigned int bacon7_h[] PROGMEM = {
  29,
  0x0008, 0x0002, 0x2000, 0x0800, 0x0200, 0x0080, 0x0020, 0x0008, 
  0x8002, 0x0000, 0x1000, 0x0200, 0x0080, 0x0020, 0x0800, 0x0200, 
  0x8002, 0x0000, 0x0020, 0x0008, 0x0200, 0x0080, 0x2000, 0x0800, 
  0x0008, 0x0002, 0x0408, 0x0102, 0x0000, 0x0000, 0x0400, 0x0100, 
  0x0040, 0x0010, 0x0004, 0x0001, 0x1000, 0x0400, 0x0100, 0x0040, 
  0x0010, 0x0004, 0x4001, 0x0000, 0x0010, 0x0004, 0x0100, 0x0040, 
  0x1000, 0x0400, 0x0004, 0x0001, 0x0040, 0x0010, 0x0400, 0x0100, 
  0x0408, 0x0102
};

const unsigned int bacon7_2_h[] PROGMEM = {
  56,
  0x0008, 0x0002, 0x0000, 0x0000, 0x2000, 0x0800, 0x0000, 0x0000, 
  0x0200, 0x0080, 0x0000, 0x0000, 0x0020, 0x0008, 0x0000, 0x0000, 
  0x8002, 0x0000, 0x0000, 0x0000, 0x1000, 0x0200, 0x0000, 0x0000, 
  0x0080, 0x0020, 0x0000, 0x0000, 0x0800, 0x0200, 0x0000, 0x0000, 
  0x8002, 0x0000, 0x0000, 0x0000, 0x0020, 0x0008, 0x0000, 0x0000, 
  0x0200, 0x0080, 0x0000, 0x0000, 0x2000, 0x0800, 0x0000, 0x0000, 
  0x0008, 0x0002, 0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 
  0x0400, 0x0100, 0x0000, 0x0000, 0x0040, 0x0010, 0x0000, 0x0000, 
  0x0004, 0x0001, 0x0000, 0x0000, 0x1000, 0x0400, 0x0000, 0x0000, 
  0x0100, 0x0040, 0x0000, 0x0000, 0x0010, 0x0004, 0x0000, 0x0000, 
  0x4001, 0x0000, 0x0000, 0x0000, 0x0010, 0x0004, 0x0000, 0x0000, 
  0x0100, 0x0040, 0x0000, 0x0000, 0x1000, 0x0400, 0x0000, 0x0000, 
  0x0004, 0x0001, 0x0000, 0x0000, 0x0040, 0x0010, 0x0000, 0x0000, 
  0x0400, 0x0100, 0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000
};

const unsigned int Bflashanti_h[] PROGMEM = {
  25,
  0x52A9, 0x04AA, 0x0000, 0x0000, 0x52A9, 0x04AA, 0x0000, 0x0000, 
  0x52A9, 0x04AA, 0x0000, 0x0000, 0xAD56, 0x0B55, 0x0000, 0x0000, 
  0x52A9, 0x04AA, 0x0000, 0x0000, 0x52A9, 0x04AA, 0x0000, 0x0000, 
  0xAD56, 0x0B55, 0x0000, 0x0000, 0x52A9, 0x04AA, 0x0000, 0x0000, 
  0xAD56, 0x0B55, 0x0000, 0x0000, 0x52A9, 0x04AA, 0x0000, 0x0000, 
  0x52A9, 0x04AA, 0x0000, 0x0000, 0xAD56, 0x0B55, 0x0000, 0x0000, 
  0x52A9, 0x04AA
};

const unsigned int Bflashchase_h[] PROGMEM = {
  145,
  0x0050, 0x0014, 0x0000, 0x0000, 0x0050, 0x0014, 0x0020, 0x0008, 
  0x0000, 0x0000, 0x0020, 0x0008, 0x0000, 0x0000, 0x0100, 0x0040, 
  0x0000, 0x0000, 0x0100, 0x0040, 0x0000, 0x0000, 0x0280, 0x00A0, 
  0x0000, 0x0000, 0x0280, 0x00A0, 0x0000, 0x0000, 0x2800, 0x0A00, 
  0x0000, 0x0000, 0x1000, 0x0400, 0x0000, 0x0000, 0x1000, 0x0400, 
  0x0000, 0x0000, 0x8002, 0x0000, 0x8002, 0x0000, 0x0000, 0x0000, 
  0x4005, 0x0001, 0x0000, 0x0000, 0x4005, 0x0001, 0x0000, 0x0000, 
  0x0408, 0x0102, 0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 
  0x0408, 0x0102, 0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 
  0x0408, 0x0102, 0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 
  0x2244, 0x0891, 0x0000, 0x0000, 0x2244, 0x0891, 0x0000, 0x0000, 
  0x0408, 0x0102, 0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 
  0x2244, 0x0891, 0x0000, 0x0000, 0x2244, 0x0891, 0x0408, 0x0102, 
  0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 0x2244, 0x0891, 
  0x0000, 0x0000, 0x2244, 0x0891, 0x0000, 0x0000, 0x9122, 0x0448, 
  0x0000, 0x0000, 0x9122, 0x0448, 0x0000, 0x0000, 0x2244, 0x0891, 
  0x0000, 0x0000, 0x2244, 0x0891, 0x0408, 0x0102, 0x0000, 0x0000, 
  0x0408, 0x0102, 0x0000, 0x0000, 0x2244, 0x0891, 0x0000, 0x0000, 
  0x2244, 0x0891, 0x0000, 0x0000, 0x9122, 0x0448, 0x0000, 0x0000, 
  0x9122, 0x0448, 0x0000, 0x0000, 0x4891, 0x0224, 0x0000, 0x0000, 
  0x4891, 0x0224, 0x0000, 0x0000, 0x9122, 0x0448, 0x0000, 0x0000, 
  0x9122, 0x0448, 0x0000, 0x0000, 0x2244, 0x0891, 0x0000, 0x0000, 
  0x2244, 0x0891, 0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 
  0x0408, 0x0102, 0x0000, 0x0000, 0x0204, 0x0081, 0x0000, 0x0000, 
  0x0204, 0x0081, 0x0000, 0x0000, 0x8102, 0x0040, 0x0000, 0x0000, 
  0x8102, 0x0040, 0x0000, 0x0000, 0x4081, 0x0020, 0x0000, 0x0000, 
  0x4081, 0x0020, 0x0000, 0x0000, 0x0810, 0x0204, 0x0000, 0x0000, 
  0x0810, 0x0204, 0x0000, 0x0000, 0x1020, 0x0408, 0x0000, 0x0000, 
  0x1020, 0x0408, 0x0000, 0x0000, 0x0204, 0x0081, 0x0000, 0x0000, 
  0x0204, 0x0081, 0x0000, 0x0000, 0x2040, 0x0810, 0x0000, 0x0000, 
  0x2040, 0x0810, 0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 
  0x0408, 0x0102, 0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 
  0x4891, 0x0224, 0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 
  0x0408, 0x0102, 0x0000, 0x0000, 0x4891, 0x0224, 0x4891, 0x0224, 
  0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 0x800C, 0x0001, 
  0x0000, 0x0000, 0x4005, 0x0001, 0x0000, 0x0000, 0x4005, 0x0001, 
  0x0000, 0x0000
};

const unsigned int Bflashofftime_h[] PROGMEM = {
  68,
  0x0408, 0x0102, 0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 
  0x0408, 0x0102, 0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 
  0x0408, 0x0102, 0x0000, 0x0000, 0x4891, 0x0224, 0x9122, 0x0448, 
  0x2244, 0x0891, 0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 
  0x0408, 0x0102, 0x0000, 0x0000, 0x4891, 0x0224, 0x9122, 0x0448, 
  0x2244, 0x0891, 0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 
  0x0408, 0x0102, 0x4891, 0x0224, 0x0000, 0x0000, 0x4891, 0x0224, 
  0x0000, 0x0000, 0x9122, 0x0448, 0x0000, 0x0000, 0x9122, 0x0448, 
  0x0000, 0x0000, 0x2244, 0x0891, 0x0000, 0x0000, 0x2244, 0x0891, 
  0x0000, 0x0000, 0x0408, 0x0102, 0x2244, 0x0891, 0x9122, 0x0448, 
  0x4891, 0x0224, 0x0408, 0x0102, 0x2244, 0x0891, 0x9122, 0x0448, 
  0x4891, 0x0224, 0x0000, 0x0000, 0x4891, 0x0224, 0x9122, 0x0448, 
  0x2244, 0x0891, 0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 
  0x2244, 0x0891, 0x9122, 0x0448, 0x0000, 0x0000, 0x0000, 0x0000, 
  0x4891, 0x0224, 0x0000, 0x0000, 0x0000, 0x0000, 0x0408, 0x0102, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0x0FFF, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000
};

const unsigned int Bflashop_h[] PROGMEM = {
  73,
  0x4285, 0x00A1, 0x0000, 0x0000, 0x4081, 0x0020, 0x0000, 0x0000, 
  0x4285, 0x00A1, 0x0000, 0x0000, 0x4081, 0x0020, 0x0000, 0x0000, 
  0x0204, 0x0081, 0x0000, 0x0000, 0x0204, 0x0081, 0x0000, 0x0000, 
  0x1830, 0x060C, 0x0000, 0x0000, 0x0204, 0x0081, 0x0000, 0x0000, 
  0x0204, 0x0081, 0x0000, 0x0000, 0x0204, 0x0081, 0x0000, 0x0000, 
  0x1830, 0x060C, 0x0000, 0x0000, 0x0204, 0x0081, 0x0000, 0x0000, 
  0x8912, 0x0244, 0x0000, 0x0000, 0x4081, 0x0020, 0x0000, 0x0000, 
  0x8912, 0x0244, 0x4081, 0x0020, 0x1830, 0x060C, 0x0204, 0x0081, 
  0x8912, 0x0244, 0x0408, 0x0102, 0x0810, 0x0204, 0x0204, 0x0081, 
  0x9932, 0x064C, 0x0204, 0x0081, 0x8912, 0x0244, 0x0000, 0x0000, 
  0x9122, 0x0448, 0x0000, 0x0000, 0x8912, 0x0244, 0x0000, 0x0000, 
  0x9122, 0x0448, 0x0000, 0x0000, 0x0810, 0x0204, 0x0000, 0x0000, 
  0x9122, 0x0448, 0x0000, 0x0000, 0x0204, 0x0081, 0x0000, 0x0000, 
  0xB062, 0x0C18, 0x0000, 0x0000, 0x9122, 0x0448, 0x0000, 0x0000, 
  0x2850, 0x0A14, 0x0000, 0x0000, 0x4285, 0x00A1, 0x0000, 0x0000, 
  0x8912, 0x0244, 0x0000, 0x0000, 0x4285, 0x00A1, 0x0000, 0x0000, 
  0x9122, 0x0448, 0x468D, 0x01A3, 0xB972, 0x0E5C, 0x468D, 0x01A3, 
  0x2850, 0x0A14, 0x468D, 0x01A3, 0x2850, 0x0A14, 0x468D, 0x01A3, 
  0x0000, 0x0000
};

const unsigned int Bflashrollinout_h[] PROGMEM = {
  95,
  0x4891, 0x0224, 0x0000, 0x0000, 0x4891, 0x0224, 0x0000, 0x0000, 
  0x4891, 0x0224, 0x0000, 0x0000, 0x4891, 0x0224, 0x0000, 0x0000, 
  0x4891, 0x0224, 0x0000, 0x0000, 0x9122, 0x0448, 0x0000, 0x0000, 
  0x9122, 0x0448, 0x0000, 0x0000, 0x9122, 0x0448, 0x0000, 0x0000, 
  0x9122, 0x0448, 0x0000, 0x0000, 0x9122, 0x0448, 0x0000, 0x0000, 
  0x2244, 0x0891, 0x0000, 0x0000, 0x2244, 0x0891, 0x0000, 0x0000, 
  0x2244, 0x0891, 0x0000, 0x0000, 0x2244, 0x0891, 0x0000, 0x0000, 
  0x0408, 0x0102, 0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 
  0x2244, 0x0891, 0x0000, 0x0000, 0x2244, 0x0891, 0x0000, 0x0000, 
  0x9122, 0x0448, 0x0000, 0x0000, 0x9122, 0x0448, 0x0000, 0x0000, 
  0x4891, 0x0224, 0x4891, 0x0224, 0x0000, 0x0000, 0x9122, 0x0448, 
  0x9122, 0x0448, 0x0000, 0x0000, 0x2244, 0x0891, 0x2244, 0x0891, 
  0x0000, 0x0000, 0x0408, 0x0102, 0x2244, 0x0891, 0x9122, 0x0448, 
  0x4891, 0x0224, 0x0000, 0x0000, 0x4891, 0x0224, 0x9122, 0x0448, 
  0x4891, 0x0224, 0x9122, 0x0448, 0x2244, 0x0891, 0x9122, 0x0448, 
  0x4891, 0x0224, 0x0000, 0x0000, 0x4891, 0x0224, 0x9122, 0x0448, 
  0x2244, 0x0891, 0x0408, 0x0102, 0x4891, 0x0224, 0x9122, 0x0448, 
  0x2244, 0x0891, 0x0408, 0x0102, 0x4891, 0x0224, 0x9122, 0x0448, 
  0x2244, 0x0891, 0x0408, 0x0102, 0x0000, 0x0000, 0x0408, 0x0102, 
  0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 0x0408, 0x0102, 
  0x0000, 0x0000, 0xFFFF, 0x0FFF, 0x0000, 0x0000, 0x0408, 0x0102, 
  0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 0x4891, 0x0224, 
  0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 0x0408, 0x0102, 
  0x0000, 0x0000, 0x4891, 0x0224, 0x0000, 0x0000
};

const unsigned int Bflashsweep_h[] PROGMEM = {
  163,
  0xC78F, 0x01E3, 0x0000, 0x0000, 0xC78F, 0x01E3, 0x0000, 0x0000, 
  0xC78F, 0x01E3, 0x0000, 0x0000, 0xC78F, 0x01E3, 0x0000, 0x0000, 
  0xC78F, 0x01E3, 0x0000, 0x0000, 0xC78F, 0x01E3, 0x0000, 0x0000, 
  0xC78F, 0x01E3, 0x0000, 0x0000, 0xC78F, 0x01E3, 0x0000, 0x0000, 
  0xC78F, 0x01E3, 0x0000, 0x0000, 0x3870, 0x0E1C, 0x0000, 0x0000, 
  0x3870, 0x0E1C, 0x0000, 0x0000, 0xC78F, 0x01E3, 0x0000, 0x0000, 
  0xC78F, 0x01E3, 0x0000, 0x0000, 0x3870, 0x0E1C, 0x0000, 0x0000, 
  0x3870, 0x0E1C, 0x0000, 0x0000, 0xC78F, 0x01E3, 0x0000, 0x0000, 
  0xC78F, 0x01E3, 0x0000, 0x0000, 0x3870, 0x0E1C, 0x0000, 0x0000, 
  0x3870, 0x0E1C, 0x0000, 0x0000, 0xC78F, 0x01E3, 0x0000, 0x0000, 
  0xC78F, 0x01E3, 0x0000, 0x0000, 0x3870, 0x0E1C, 0x0000, 0x0000, 
  0x3870, 0x0E1C, 0x0000, 0x0000, 0xC78F, 0x01E3, 0x0000, 0x0000, 
  0x3870, 0x0E1C, 0x0000, 0x0000, 0xC78F, 0x01E3, 0x0000, 0x0000, 
  0x3870, 0x0E1C, 0x0000, 0x0000, 0xC78F, 0x01E3, 0x0000, 0x0000, 
  0x3870, 0x0E1C, 0x0000, 0x0000, 0xC78F, 0x01E3, 0x0000, 0x0000, 
  0x3870, 0x0E1C, 0x0000, 0x0000, 0xC78F, 0x01E3, 0x3870, 0x0E1C, 
  0xC78F, 0x01E3, 0x3870, 0x0E1C, 0xC78F, 0x01E3, 0x3870, 0x0E1C, 
  0xC78F, 0x01E3, 0x3870, 0x0E1C, 0xC78F, 0x01E3, 0x3870, 0x0E1C, 
  0xC78F, 0x01E3, 0x3870, 0x0E1C, 0x0000, 0x0000, 0x3870, 0x0E1C, 
  0x0000, 0x0000, 0x3870, 0x0E1C, 0x0000, 0x0000, 0x3870, 0x0E1C, 
  0x0000, 0x0000, 0x3870, 0x0E1C, 0x0000, 0x0000, 0x3870, 0x0E1C, 
  0x0000, 0x0000, 0x3870, 0x0E1C, 0x0000, 0x0000, 0x3870, 0x0E1C, 
  0x0000, 0x0000, 0x3870, 0x0E1C, 0x0000, 0x0000, 0x3870, 0x0E1C, 
  0x0000, 0x0000, 0x3870, 0x0E1C, 0x0000, 0x0000, 0x3870, 0x0E1C, 
  0x0000, 0x0000, 0x3870, 0x0E1C, 0x0000, 0x0000, 0xC78F, 0x01E3, 
  0x0000, 0x0000, 0xC78F, 0x01E3, 0x0000, 0x0000, 0x3870, 0x0E1C, 
  0x0000, 0x0000, 0x3870, 0x0E1C, 0x0000, 0x0000, 0xC78F, 0x01E3, 
  0x0000, 0x0000, 0xC78F, 0x01E3, 0x0000, 0x0000, 0x3870, 0x0E1C, 
  0x0000, 0x0000, 0x3870, 0x0E1C, 0x0000, 0x0000, 0xC78F, 0x01E3, 
  0x0000, 0x0000, 0xC78F, 0x01E3, 0x0000, 0x0000, 0x3870, 0x0E1C, 
  0x0000, 0x0000, 0x3870, 0x0E1C, 0x0000, 0x0000, 0xC78F, 0x01E3, 
  0x0000, 0x0000, 0xC78F, 0x01E3, 0x0000, 0x0000, 0x3870, 0x0E1C, 
  0x0000, 0x0000, 0xC78F, 0x01E3, 0x0000, 0x0000, 0x3870, 0x0E1C, 
  0x0000, 0x0000, 0xC78F, 0x01E3, 0x0000, 0x0000, 0x3870, 0x0E1C, 
  0x0000, 0x0000, 0xC78F, 0x01E3, 0x0000, 0x0000, 0x3870, 0x0E1C, 
  0x0000, 0x0000, 0xC78F, 0x01E3, 0x0000, 0x0000, 0x3870, 0x0E1C, 
  0xC78F, 0x01E3, 0x3870, 0x0E1C, 0xC78F, 0x01E3, 0x3870, 0x0E1C, 
  0xC78F, 0x01E3, 0x3870, 0x0E1C, 0xC78F, 0x01E3, 0x3870, 0x0E1C, 
  0xC78F, 0x01E3, 0x3870, 0x0E1C, 0xC78F, 0x01E3, 0x3870, 0x0E1C, 
  0xC78F, 0x01E3, 0x3870, 0x0E1C, 0xC78F, 0x01E3, 0x3870, 0x0E1C, 
  0xC78F, 0x01E3, 0x3870, 0x0E1C, 0x0000, 0x0000
};

const unsigned int bigspiral_h[] PROGMEM = {
  57,
  0x0000, 0x0020, 0x0000, 0x0004, 0x4000, 0x0000, 0x0800, 0x0000, 
  0x0080, 0x0000, 0x0010, 0x0000, 0x0001, 0x0000, 0x0000, 0x0200, 
  0x0000, 0x0040, 0x0000, 0x0008, 0x8000, 0x0000, 0x1000, 0x0000, 
  0x0100, 0x0000, 0x0020, 0x0000, 0x0002, 0x0000, 0x0000, 0x0400, 
  0x0000, 0x0080, 0x0000, 0x0010, 0x0000, 0x0001, 0x2000, 0x0000, 
  0x0200, 0x0000, 0x0040, 0x0000, 0x0004, 0x0000, 0x0000, 0x0800, 
  0x0000, 0x0100, 0x0000, 0x0002, 0x0400, 0x0000, 0x0008, 0x0000, 
  0x0000, 0x0100, 0x0000, 0x0002, 0x0400, 0x0000, 0x0008, 0x0000, 
  0x0000, 0x0800, 0x0000, 0x0080, 0x0000, 0x0010, 0x0000, 0x0001, 
  0x2000, 0x0000, 0x0200, 0x0000, 0x0040, 0x0000, 0x0004, 0x0000, 
  0x0000, 0x0800, 0x0000, 0x0080, 0x0000, 0x0008, 0x8000, 0x0000, 
  0x1000, 0x0000, 0x0100, 0x0000, 0x0020, 0x0000, 0x0002, 0x0000, 
  0x0000, 0x0400, 0x0000, 0x0040, 0x0000, 0x0004, 0x4000, 0x0000, 
  0x0800, 0x0000, 0x0080, 0x0000, 0x0010, 0x0000, 0x0001, 0x0000, 
  0x0000, 0x0200
};

const unsigned int blinkblinkblink_h[] PROGMEM = {
  7,
  0x0408, 0x0102, 0x2040, 0x0810, 0x0204, 0x0081, 0x1020, 0x0408, 
  0x8102, 0x0040, 0x0810, 0x0204, 0x4081, 0x0020
};


const unsigned int boing2_h[] PROGMEM = {
  27,
  0x0080, 0x0020, 0x0100, 0x0040, 0x0200, 0x0080, 0x0400, 0x0100, 
  0x0008, 0x0002, 0x2000, 0x0800, 0x1000, 0x0400, 0x0800, 0x0200, 
  0x1000, 0x0400, 0x2000, 0x0800, 0x0400, 0x0100, 0x0008, 0x0002, 
  0x0004, 0x0001, 0x8002, 0x0000, 0x4001, 0x0000, 0x8002, 0x0000, 
  0x0004, 0x0001, 0x0008, 0x0002, 0x0040, 0x0010, 0x0020, 0x0008, 
  0x0010, 0x0004, 0x0020, 0x0008, 0x0040, 0x0010, 0x0008, 0x0002, 
  0x0400, 0x0100, 0x0200, 0x0080, 0x0100, 0x0040
};

const unsigned int Btestchase_h[] PROGMEM = {
  22,
  0x3870, 0x0E1C, 0x0000, 0x0000, 0xC387, 0x00E1, 0x0000, 0x0000, 
  0x0408, 0x0102, 0x0000, 0x0000, 0x2244, 0x0891, 0x0000, 0x0000, 
  0x9122, 0x0448, 0x0000, 0x0000, 0x4891, 0x0224, 0x0000, 0x0000, 
  0x4891, 0x0224, 0x0000, 0x0000, 0x9122, 0x0448, 0x0000, 0x0000, 
  0x2244, 0x0891, 0x0000, 0x0000, 0x0408, 0x0102, 0x0408, 0x0102, 
  0x0408, 0x0102, 0x0000, 0x0000
};

const unsigned int chris1_h[] PROGMEM = {
  54,
  0x0001, 0x0000, 0x0010, 0x0000, 0x0080, 0x0000, 0x0800, 0x0000, 
  0x4000, 0x0000, 0x8000, 0x0004, 0x0000, 0x0021, 0x0000, 0x0202, 
  0x0009, 0x0002, 0x0409, 0x0102, 0x0609, 0x0182, 0x4309, 0x00C2, 
  0x4789, 0x01E2, 0x0000, 0x0000, 0x2244, 0x0891, 0x0000, 0x0000, 
  0x9122, 0x0448, 0x0000, 0x0000, 0x4891, 0x0224, 0x0008, 0x0000, 
  0x0400, 0x0000, 0x0000, 0x0002, 0x0000, 0x0100, 0x0004, 0x0000, 
  0x0200, 0x0000, 0x0000, 0x0001, 0x0000, 0x0080, 0x0002, 0x0000, 
  0x0020, 0x0000, 0x0100, 0x0000, 0x1000, 0x0000, 0x8000, 0x0000, 
  0x0000, 0x0008, 0x0000, 0x0040, 0x0000, 0x0400, 0x0002, 0x0000, 
  0x0001, 0x0000, 0x0010, 0x0200, 0x0080, 0x0020, 0x0800, 0x0004, 
  0x4000, 0x0000, 0x0408, 0x0102, 0x2244, 0x0891, 0x9122, 0x0448, 
  0x4891, 0x0224, 0x0408, 0x0102, 0x2244, 0x0891, 0x9122, 0x0448, 
  0x4891, 0x0224, 0x0408, 0x0102, 0x4891, 0x0224, 0x0408, 0x0102, 
  0x4891, 0x0224, 0x0000, 0x0000
};

const unsigned int circlehit_h[] PROGMEM = {
  45,
  0x0608, 0x0100, 0x0448, 0x0100, 0x040C, 0x0100, 0x0408, 0x0900, 
  0x0408, 0x0180, 0x0408, 0x0110, 0x0408, 0x0101, 0x2408, 0x0100, 
  0x0608, 0x0100, 0x0448, 0x0100, 0x040C, 0x0100, 0x0408, 0x0900, 
  0x0408, 0x0180, 0x0408, 0x0110, 0x0408, 0x0101, 0x2408, 0x0100, 
  0x0608, 0x0100, 0x0448, 0x0100, 0x040C, 0x0100, 0x0408, 0x0900, 
  0x0408, 0x0180, 0x0408, 0x0110, 0x0408, 0x0101, 0x2408, 0x0100, 
  0x0608, 0x0100, 0x0448, 0x0100, 0x040C, 0x0100, 0x0408, 0x0900, 
  0x0408, 0x0180, 0x0408, 0x0110, 0x0408, 0x0101, 0x0408, 0x0102, 
  0x0204, 0x0081, 0x8102, 0x0040, 0x4081, 0x0020, 0x4081, 0x0020, 
  0x4081, 0x0020, 0x0810, 0x0204, 0x8102, 0x0040, 0x1020, 0x0408, 
  0x0204, 0x0081, 0x2040, 0x0810, 0x0408, 0x0102, 0x0408, 0x0101, 
  0x2408, 0x0100
};

const unsigned int curvey_h[] PROGMEM = {
  42,
  0x0000, 0x0020, 0x0000, 0x0040, 0x0000, 0x0080, 0x0000, 0x0100, 
  0x0008, 0x0000, 0x0004, 0x0000, 0x0002, 0x0000, 0x0001, 0x0000, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0080, 0x0000, 
  0x0100, 0x0000, 0x0200, 0x0000, 0x0400, 0x0000, 0x0000, 0x0002, 
  0x0000, 0x0001, 0x8000, 0x0000, 0x4000, 0x0000, 0x0000, 0x0000, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0004, 0x0000, 0x0008, 
  0x0000, 0x0010, 0x0000, 0x0100, 0x0000, 0x0800, 0x0000, 0x0400, 
  0x0000, 0x0200, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
  0x0010, 0x0000, 0x0020, 0x0000, 0x0040, 0x0000, 0x0400, 0x0000, 
  0x2000, 0x0000, 0x1000, 0x0000, 0x0800, 0x0000, 0x0000, 0x0000, 
  0x0000, 0x0000, 0x0000, 0x0000
};

const unsigned int diamond_h[] PROGMEM = {
  17,
  0x0001, 0x0000, 0x0012, 0x0200, 0x0024, 0x0400, 0x0040, 0x0800, 
  0x0408, 0x0100, 0x0208, 0x0080, 0x0108, 0x0040, 0x0088, 0x0020, 
  0x0108, 0x0040, 0x0208, 0x0080, 0x0408, 0x0100, 0x2000, 0x0012, 
  0x1000, 0x0009, 0x8800, 0x0004, 0x4800, 0x0004, 0x0080, 0x0020, 
  0x0010, 0x0200
};

const unsigned int drop_h[] PROGMEM = {
  13,
  0x0001, 0x0000, 0x0002, 0x0000, 0x0004, 0x0000, 0x0040, 0x0800, 
  0x0020, 0x0400, 0x0010, 0x0200, 0x0080, 0x0020, 0x0800, 0x0004, 
  0x1000, 0x0008, 0x2000, 0x0010, 0x0000, 0x0001, 0x8000, 0x0000, 
  0x4000, 0x0000
};

const unsigned int imagenode_h[] PROGMEM = {
  55,
  0x800E, 0x0003, 0x800E, 0x0003, 0x800E, 0x0003, 0x800E, 0x0003, 
  0x800E, 0x0003, 0x0D70, 0x0F46, 0x0D70, 0x0F46, 0x0D70, 0x0F46, 
  0x0D70, 0x0F46, 0x0D70, 0x0F46, 0x0E22, 0x0584, 0x0E22, 0x0584, 
  0x0E22, 0x0584, 0x0E22, 0x0584, 0x0E22, 0x0584, 0x9602, 0x0488, 
  0x9602, 0x0488, 0x9602, 0x0488, 0x9602, 0x0488, 0x9602, 0x0488, 
  0x8402, 0x0588, 0x8402, 0x0588, 0x8402, 0x0588, 0x8402, 0x0588, 
  0x8402, 0x0588, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x3E18, 0x0F86, 0x3E18, 0x0F86, 
  0x3E18, 0x0F86, 0x3E18, 0x0F86, 0x3E18, 0x0F86, 0x9122, 0x0448, 
  0x9122, 0x0448, 0x9122, 0x0448, 0x9122, 0x0448, 0x9122, 0x0448, 
  0x912E, 0x0003, 0x912E, 0x0003, 0x912E, 0x0003, 0x912E, 0x0003, 
  0x912E, 0x0003, 0x8402, 0x0588, 0x8402, 0x0588, 0x8402, 0x0588, 
  0x8402, 0x0588, 0x8402, 0x0588, 0x0000, 0x0000, 0x0000, 0x0000, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
};

const unsigned int jason1_h[] PROGMEM = {
  66,
  0x0000, 0x0064, 0x0000, 0x0064, 0x0000, 0x004C, 0x0000, 0x00C8, 
  0x0000, 0x0098, 0x0000, 0x0190, 0x0000, 0x0112, 0x0400, 0x0102, 
  0x0408, 0x0100, 0x0448, 0x0000, 0x0640, 0x0000, 0x0260, 0x0000, 
  0x0320, 0x0000, 0x0130, 0x0000, 0x0190, 0x0000, 0x0190, 0x0000, 
  0x0980, 0x0000, 0x1900, 0x0000, 0x5800, 0x0000, 0xD000, 0x0000, 
  0xC000, 0x0004, 0x8000, 0x000C, 0x0000, 0x004C, 0x0000, 0x0064, 
  0x0000, 0x0260, 0x0000, 0x0640, 0x0001, 0x0600, 0x0003, 0x0400, 
  0x0006, 0x0400, 0x0004, 0x0C00, 0x000C, 0x0800, 0x0008, 0x0900, 
  0x0408, 0x0100, 0x0400, 0x0102, 0x2400, 0x0002, 0x2000, 0x0003, 
  0x3000, 0x0001, 0x9000, 0x0001, 0x9800, 0x0000, 0xC800, 0x0000, 
  0xC800, 0x0000, 0xC000, 0x0004, 0x8000, 0x000C, 0x8000, 0x0009, 
  0x0000, 0x0019, 0x0000, 0x0013, 0x2000, 0x0003, 0x3000, 0x0001, 
  0x3200, 0x0000, 0x1300, 0x0000, 0x0320, 0x0000, 0x0130, 0x0000, 
  0x0032, 0x0000, 0x0062, 0x0000, 0x0260, 0x0000, 0x0640, 0x0000, 
  0x2600, 0x0000, 0x0640, 0x0000, 0x0448, 0x0000, 0x004C, 0x0000, 
  0x000C, 0x0800, 0x0004, 0x0C00, 0x0000, 0x0C80, 0x0000, 0x04C0, 
  0x0000, 0x00C8, 0x0000, 0x004C
};

const unsigned int jumpinjack_h[] PROGMEM = {
  78,
  0x1000, 0x0400, 0x1000, 0x0400, 0x1000, 0x0400, 0x0000, 0x0000, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0008, 0x0020, 0x0008, 
  0x0020, 0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x8102, 0x0040, 
  0x8102, 0x0040, 0x8102, 0x0040, 0x0000, 0x0000, 0x0000, 0x0000, 
  0x0000, 0x0000, 0x0810, 0x0204, 0x0810, 0x0204, 0x0810, 0x0204, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0080, 0x0000, 
  0x0100, 0x0000, 0x0200, 0x0000, 0x0400, 0x0000, 0x0000, 0x0100, 
  0x0000, 0x0080, 0x0000, 0x0040, 0x0000, 0x0020, 0x0000, 0x0000, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
  0x0000, 0x0000, 0x0001, 0x0000, 0x0002, 0x0000, 0x0004, 0x0000, 
  0x0008, 0x0000, 0x0000, 0x0002, 0x0000, 0x0001, 0x8000, 0x0000, 
  0x4000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0800, 0x0000, 
  0x1000, 0x0000, 0x2000, 0x0000, 0x0400, 0x0002, 0x0008, 0x0100, 
  0x0000, 0x0800, 0x0000, 0x0400, 0x0000, 0x0200, 0x0000, 0x0000, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
  0x0000, 0x0004, 0x0000, 0x0008, 0x0000, 0x0010, 0x0000, 0x0102, 
  0x0408, 0x0000, 0x0040, 0x0000, 0x0020, 0x0000, 0x0010, 0x0000, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
  0x0000, 0x0000, 0x0000, 0x0000
};

const unsigned int knifechop_h[] PROGMEM = {
  46,
  0x0008, 0x0000, 0x0400, 0x0000, 0x0000, 0x0002, 0x0000, 0x0100, 
  0x0008, 0x0000, 0x0400, 0x0000, 0x0200, 0x0000, 0x0100, 0x0000, 
  0x0080, 0x0000, 0x0800, 0x0000, 0x1000, 0x0000, 0x0100, 0x0000, 
  0x0200, 0x0000, 0x2000, 0x0000, 0x0000, 0x0001, 0x0000, 0x0002, 
  0x0008, 0x0000, 0x0004, 0x0000, 0x0002, 0x0000, 0x0001, 0x0000, 
  0x0000, 0x0200, 0x0000, 0x0400, 0x0000, 0x0040, 0x0000, 0x0080, 
  0x0000, 0x0800, 0x0000, 0x0100, 0x0000, 0x0010, 0x0000, 0x0008, 
  0x0000, 0x0004, 0x4000, 0x0000, 0x8000, 0x0000, 0x0000, 0x0001, 
  0x0000, 0x0002, 0x0008, 0x0000, 0x0004, 0x0000, 0x0002, 0x0000, 
  0x0001, 0x0000, 0x0010, 0x0000, 0x0080, 0x0000, 0x0800, 0x0000, 
  0x1000, 0x0000, 0x8000, 0x0000, 0x0000, 0x0001, 0x2000, 0x0000, 
  0x0400, 0x0000, 0x0008, 0x0000
};

const unsigned int millsmess_h[] PROGMEM = {
  42,
  0x0000, 0x0054, 0x0000, 0x00A8, 0x0000, 0x0250, 0x0001, 0x00A0, 
  0x0010, 0x0240, 0x0081, 0x0020, 0x0810, 0x0200, 0x4081, 0x0000, 
  0x0810, 0x0004, 0x4080, 0x0020, 0x8100, 0x0040, 0x0200, 0x0408, 
  0x0402, 0x0040, 0x0020, 0x0500, 0x0102, 0x0080, 0x1020, 0x0040, 
  0x8100, 0x0020, 0x4200, 0x0200, 0x8401, 0x0000, 0x0010, 0x0101, 
  0x0080, 0x0082, 0x0808, 0x0040, 0x1004, 0x0020, 0x2002, 0x0004, 
  0x4001, 0x0001, 0x0802, 0x0010, 0x1020, 0x0080, 0x2100, 0x0040, 
  0x0080, 0x0022, 0x0108, 0x0040, 0x0024, 0x0008, 0x8042, 0x0000, 
  0x4009, 0x0000, 0x0810, 0x0100, 0x1080, 0x0080, 0x2800, 0x0040, 
  0x4400, 0x0020, 0x8008, 0x0200, 0x0000, 0x0501, 0x0000, 0x0882, 
  0x0000, 0x0150, 0x0000, 0x00A8
};

const unsigned int onewalk_h[] PROGMEM = {
  66,
  0x0000, 0x0008, 0x0000, 0x0001, 0x0000, 0x0002, 0x0008, 0x0000, 
  0x0400, 0x0000, 0x2000, 0x0000, 0x1000, 0x0000, 0x0100, 0x0000, 
  0x0080, 0x0000, 0x0800, 0x0000, 0x4000, 0x0000, 0x8000, 0x0000, 
  0x0000, 0x0001, 0x0000, 0x0010, 0x0000, 0x0008, 0x0000, 0x0004, 
  0x4000, 0x0000, 0x8000, 0x0000, 0x0000, 0x0001, 0x0000, 0x0010, 
  0x0000, 0x0002, 0x2000, 0x0000, 0x0200, 0x0000, 0x0400, 0x0000, 
  0x0000, 0x0100, 0x0000, 0x0080, 0x0000, 0x0040, 0x0000, 0x0008, 
  0x0000, 0x0004, 0x0000, 0x0020, 0x0000, 0x0040, 0x0000, 0x0080, 
  0x0000, 0x0800, 0x0000, 0x0100, 0x0008, 0x0000, 0x0400, 0x0000, 
  0x0200, 0x0000, 0x0100, 0x0000, 0x1000, 0x0000, 0x2000, 0x0000, 
  0x0200, 0x0000, 0x0100, 0x0000, 0x0020, 0x0000, 0x0010, 0x0000, 
  0x0001, 0x0000, 0x0002, 0x0000, 0x0020, 0x0000, 0x0040, 0x0000, 
  0x0008, 0x0000, 0x0000, 0x0800, 0x0000, 0x0400, 0x0000, 0x0200, 
  0x0000, 0x0020, 0x0000, 0x0040, 0x0000, 0x0400, 0x0002, 0x0000, 
  0x0004, 0x0000, 0x0008, 0x0000, 0x0000, 0x0002, 0x0000, 0x0001, 
  0x2000, 0x0000, 0x1000, 0x0000, 0x0800, 0x0000, 0x4000, 0x0000, 
  0x8000, 0x0000, 0x0000, 0x0004
};

 
const unsigned int snakey_h[] PROGMEM = {
  47,
  0x0000, 0x08C0, 0x0000, 0x01E0, 0x0000, 0x0260, 0x0000, 0x0620, 
  0x0000, 0x0E20, 0x0008, 0x0C00, 0x0048, 0x0C00, 0x0068, 0x0000, 
  0x0078, 0x0000, 0x0031, 0x0000, 0x0033, 0x0000, 0x0007, 0x0000, 
  0x0047, 0x0000, 0x0244, 0x0000, 0x0344, 0x0000, 0x0380, 0x0000, 
  0x0390, 0x0000, 0x00B0, 0x0000, 0x00F0, 0x0000, 0x0460, 0x0000, 
  0x0460, 0x0002, 0x0400, 0x0102, 0x0408, 0x0102, 0x0408, 0x0100, 
  0x0408, 0x0102, 0x0400, 0x0003, 0x8400, 0x0003, 0xC000, 0x0001, 
  0xC800, 0x0001, 0x5800, 0x0000, 0x7800, 0x0000, 0x3200, 0x0000, 
  0x3300, 0x0000, 0x0320, 0x0000, 0x0360, 0x0000, 0x0068, 0x0000, 
  0x0068, 0x0100, 0x0008, 0x0110, 0x0008, 0x0111, 0x8000, 0x0011, 
  0xC000, 0x0011, 0xC000, 0x0004, 0xC000, 0x000C, 0x0000, 0x001C, 
  0x0000, 0x011C, 0x0000, 0x0190, 0x0000, 0x0990
};

const unsigned int spaz_h[] PROGMEM = {
  65,
  0x0000, 0x0200, 0x0800, 0x0000, 0x0010, 0x0000, 0x0000, 0x0004, 
  0x0080, 0x0000, 0x0000, 0x0020, 0x0001, 0x0000, 0x4000, 0x0000, 
  0x0020, 0x0008, 0x1000, 0x0400, 0x0200, 0x0080, 0x0004, 0x0001, 
  0x0002, 0x0000, 0x0020, 0x0000, 0x0100, 0x0000, 0x1000, 0x0000, 
  0x8000, 0x0000, 0x1000, 0x0000, 0x0100, 0x0000, 0x0020, 0x0000, 
  0x0002, 0x0000, 0x0000, 0x0400, 0x0000, 0x0040, 0x0000, 0x0008, 
  0x8000, 0x0000, 0x0000, 0x0008, 0x0000, 0x0040, 0x0000, 0x0400, 
  0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x4081, 0x0020, 0x0810, 0x0204, 
  0x8102, 0x0040, 0x1020, 0x0408, 0x0204, 0x0081, 0x2040, 0x0810, 
  0x0408, 0x0102, 0x0204, 0x0081, 0x8102, 0x0040, 0x4081, 0x0020, 
  0x0408, 0x0102, 0x4081, 0x0020, 0x0408, 0x0102, 0x0000, 0x0000, 
  0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 0x0000, 0x0000, 
  0x0408, 0x0102, 0x0000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0000, 
  0x0408, 0x0102, 0x0000, 0x0000, 0x2244, 0x0891, 0x0000, 0x0000, 
  0x9122, 0x0448, 0x0000, 0x0000, 0x4891, 0x0224, 0x0000, 0x0000, 
  0x0000, 0x0000
};

const unsigned int spiralbacon_h[] PROGMEM = {
  29,
  0x0000, 0x0020, 0x0000, 0x0200, 0x0002, 0x0000, 0x0020, 0x0000, 
  0x0200, 0x0000, 0x2000, 0x0000, 0x0000, 0x0002, 0x0001, 0x0000, 
  0x0010, 0x0000, 0x0100, 0x0000, 0x1000, 0x0000, 0x0000, 0x0001, 
  0x0000, 0x0010, 0x0000, 0x0100, 0x0000, 0x0000, 0x0080, 0x0000, 
  0x0800, 0x0000, 0x8000, 0x0000, 0x0000, 0x0008, 0x0000, 0x0080, 
  0x0000, 0x0800, 0x0008, 0x0000, 0x4000, 0x0000, 0x0000, 0x0004, 
  0x0000, 0x0040, 0x0000, 0x0400, 0x0004, 0x0000, 0x0040, 0x0000, 
  0x0400, 0x0000
};

const unsigned int splitcross_h[] PROGMEM = {
  51,
  0x4000, 0x0000, 0x0800, 0x0000, 0x0080, 0x0000, 0x0100, 0x0000, 
  0x0200, 0x0000, 0x0400, 0x0000, 0x0000, 0x0100, 0x0000, 0x0080, 
  0x0000, 0x0040, 0x0000, 0x0020, 0x0000, 0x0004, 0x4000, 0x0000, 
  0x8000, 0x0000, 0x0000, 0x0001, 0x0000, 0x0002, 0x0000, 0x0100, 
  0x0008, 0x0000, 0x0400, 0x0000, 0x0000, 0x0002, 0x0000, 0x0100, 
  0x0008, 0x0000, 0x0400, 0x0000, 0x0000, 0x0002, 0x0000, 0x0100, 
  0x0008, 0x0000, 0x0400, 0x0000, 0x0000, 0x0002, 0x0000, 0x0100, 
  0x0008, 0x0000, 0x0004, 0x0000, 0x0002, 0x0000, 0x0001, 0x0000, 
  0x0000, 0x0200, 0x0001, 0x0400, 0x0000, 0x0A00, 0x0009, 0x0400, 
  0x0040, 0x0A00, 0x0028, 0x0400, 0x0050, 0x0800, 0x0029, 0x0000, 
  0x0052, 0x0000, 0x0025, 0x0000, 0x001A, 0x0000, 0x0005, 0x0002, 
  0x000A, 0x0001, 0x8004, 0x0002, 0x4008, 0x0001, 0xC000, 0x0002, 
  0xC000, 0x0001, 0xC000, 0x0000, 0x4000, 0x0000
};

const unsigned int theman_h[] PROGMEM = {
  33,
  0x3C74, 0x0F1C, 0x3C74, 0x0F1C, 0x3C74, 0x0F1C, 0x3C74, 0x0F1C, 
  0x3C74, 0x0F1C, 0x3C74, 0x0D1C, 0x3C64, 0x0D1C, 0x3C64, 0x0D1C, 
  0x3C64, 0x091C, 0x3C44, 0x091C, 0x3C00, 0x091C, 0x3C00, 0x011C, 
  0x3C00, 0x001C, 0x3800, 0x001C, 0x3800, 0x000C, 0x1800, 0x000C, 
  0x1800, 0x0004, 0x0800, 0x000C, 0x0800, 0x0004, 0x0000, 0x0004, 
  0x0000, 0x0000, 0x0800, 0x0004, 0x0800, 0x000C, 0x0800, 0x0044, 
  0x0800, 0x008C, 0x1A00, 0x004C, 0x0C00, 0x080C, 0x0C40, 0x0004, 
  0x0C20, 0x0404, 0x1200, 0x0048, 0x2100, 0x0090, 0x0040, 0x0900, 
  0x0020, 0x0400
};

const unsigned int tricross_h[] PROGMEM = {
  59,
  0x4000, 0x0024, 0x4000, 0x0028, 0x4000, 0x0030, 0x8000, 0x0142, 
  0x0040, 0x0081, 0x2020, 0x0800, 0x0214, 0x0000, 0x0102, 0x0000, 
  0x0081, 0x0000, 0x0010, 0x0000, 0x0020, 0x0000, 0x00C1, 0x0000, 
  0x050A, 0x0000, 0x0204, 0x0010, 0x2000, 0x0808, 0x0000, 0x0085, 
  0x8000, 0x0040, 0x4000, 0x0020, 0x0800, 0x0200, 0x1000, 0x0400, 
  0x0204, 0x0081, 0x0040, 0x0010, 0x0400, 0x0000, 0x0000, 0x0002, 
  0x0000, 0x0100, 0x0008, 0x0000, 0x0400, 0x0000, 0x0000, 0x0002, 
  0x0000, 0x0100, 0x0000, 0x0800, 0x0004, 0x0480, 0x0002, 0x0240, 
  0x0001, 0x0220, 0x0001, 0x0420, 0x0001, 0x0820, 0x000A, 0x0140, 
  0x0404, 0x0082, 0x2040, 0x0010, 0x1200, 0x0001, 0x8900, 0x0000, 
  0x4880, 0x0000, 0x5080, 0x0000, 0xA100, 0x0000, 0x0600, 0x0003, 
  0x0048, 0x0110, 0x0004, 0x0480, 0x0002, 0x0240, 0x0001, 0x0220, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
};

const unsigned int tweaker_h[] PROGMEM = {
  42,
  0x0004, 0x0001, 0x0040, 0x0010, 0x0200, 0x0080, 0x0040, 0x0010, 
  0x0004, 0x0001, 0x0004, 0x0001, 0x0004, 0x0001, 0x0004, 0x0001, 
  0x2000, 0x0800, 0x0200, 0x0080, 0x2000, 0x0800, 0x0004, 0x0001, 
  0x0004, 0x0001, 0x0004, 0x0001, 0x0004, 0x0001, 0x0040, 0x0010, 
  0x0200, 0x0080, 0x0040, 0x0010, 0x0004, 0x0001, 0x0040, 0x0010, 
  0x0200, 0x0080, 0x0040, 0x0010, 0x0004, 0x0001, 0x0040, 0x0010, 
  0x0200, 0x0080, 0x0040, 0x0010, 0x0004, 0x0001, 0x0040, 0x0010, 
  0x0200, 0x0080, 0x2000, 0x0800, 0x0004, 0x0001, 0x2000, 0x0800, 
  0x0200, 0x0080, 0x2000, 0x0800, 0x0004, 0x0001, 0x9022, 0x0408, 
  0x4811, 0x0204, 0x9022, 0x0408, 0x4811, 0x0204, 0x9122, 0x0448, 
  0x2244, 0x0891, 0x0408, 0x0102
};

const unsigned int waggle_h[] PROGMEM = {
  43,
  0x0204, 0x0010, 0x0020, 0x0401, 0x1002, 0x0040, 0x0080, 0x0204, 
  0x4010, 0x0020, 0x1001, 0x0008, 0x2002, 0x0010, 0x0404, 0x0100, 
  0x0048, 0x0800, 0x0020, 0x0402, 0x0010, 0x0201, 0x8080, 0x0020, 
  0x4100, 0x0040, 0x9000, 0x0008, 0x4800, 0x0004, 0x9100, 0x0048, 
  0x2000, 0x0011, 0x2200, 0x0090, 0x0000, 0x00C0, 0x0300, 0x0000, 
  0x0090, 0x0220, 0x0120, 0x0440, 0x0240, 0x0880, 0x0408, 0x0100, 
  0x0044, 0x0800, 0x0022, 0x0400, 0x0011, 0x0200, 0x0022, 0x0400, 
  0x0044, 0x0800, 0x0204, 0x0080, 0x0204, 0x0010, 0x0204, 0x0010, 
  0x0204, 0x0010, 0x0204, 0x0010, 0x0204, 0x0010, 0x0204, 0x0010, 
  0x0204, 0x0001, 0x0204, 0x0010, 0x0204, 0x0080, 0x0204, 0x0010, 
  0x0204, 0x0001, 0x0204, 0x0010, 0x0204, 0x0080
};

const unsigned int ytree_h[] PROGMEM = {
  33,
  0x0080, 0x0020, 0x0010, 0x0200, 0x0001, 0x0000, 0x0100, 0x0040, 
  0x0020, 0x0400, 0x0002, 0x0000, 0x0200, 0x0080, 0x0040, 0x0800, 
  0x0004, 0x0000, 0x0400, 0x0100, 0x0008, 0x0000, 0x0800, 0x0004, 
  0x1000, 0x0008, 0x2000, 0x0010, 0x0000, 0x0002, 0x0400, 0x0100, 
  0x0040, 0x0800, 0x0020, 0x0400, 0x0010, 0x0200, 0x0080, 0x0020, 
  0x0800, 0x0004, 0x4000, 0x0000, 0x8000, 0x0000, 0x1000, 0x0008, 
  0x0100, 0x0040, 0x0020, 0x0400, 0x0040, 0x0800, 0x0400, 0x0100, 
  0x0000, 0x0002, 0x0000, 0x0001, 0x8000, 0x0000, 0x4000, 0x0000, 
  0x0800, 0x0004
};

const unsigned int Nice_Matt_3_h[] PROGMEM = {
  284,
  0x4001, 0x0000, 0xC003, 0x0000, 0x8006, 0x0001, 0x2004, 0x0801, 
  0x2200, 0x0880, 0x0240, 0x0090, 0x0044, 0x0011, 0x2004, 0x0801, 
  0x2200, 0x0880, 0x0240, 0x0090, 0x0048, 0x0012, 0x0408, 0x0102, 
  0x0008, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
  0x0000, 0x0000, 0x2448, 0x0912, 0x366C, 0x0D9B, 0xBF7E, 0x0FDF, 
  0xFFFF, 0x0FFF, 0x7AF5, 0x0EBD, 0xFFFF, 0x0FFF, 0xFFFF, 0x0FFF, 
  0xFFFF, 0x0FFF, 0xFBF7, 0x0EFD, 0xD9B3, 0x066C, 0x4C99, 0x0326, 
  0x0408, 0x0102, 0x1224, 0x0489, 0x1224, 0x0489, 0x8912, 0x0244, 
  0x8912, 0x0244, 0x4081, 0x0020, 0x4081, 0x0020, 0x0000, 0x0000, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0800, 0x0000, 
  0x1800, 0x0000, 0x3800, 0x0000, 0x3000, 0x0002, 0x2000, 0x0012, 
  0x0000, 0x001A, 0x0000, 0x001C, 0x0000, 0x000C, 0x0000, 0x0004, 
  0x0000, 0x0000, 0x0010, 0x0000, 0x0030, 0x0000, 0x0070, 0x0000, 
  0x0068, 0x0000, 0x0048, 0x0800, 0x0008, 0x0C00, 0x0000, 0x0E00, 
  0x0000, 0x0600, 0x0000, 0x0200, 0x0000, 0x0000, 0x0000, 0x0000, 
  0x0000, 0x0000, 0x0001, 0x0000, 0x0001, 0x0000, 0x0001, 0x0000, 
  0x0001, 0x0000, 0x0001, 0x0000, 0x0001, 0x0000, 0x0001, 0x0000, 
  0x0001, 0x0000, 0x0003, 0x0000, 0x0003, 0x0000, 0x0003, 0x0000, 
  0x0003, 0x0000, 0x0003, 0x0000, 0x0003, 0x0000, 0x0007, 0x0000, 
  0x0007, 0x0000, 0x0007, 0x0000, 0x0007, 0x0000, 0x0007, 0x0000, 
  0x000F, 0x0000, 0x000F, 0x0000, 0x000F, 0x0000, 0x0007, 0x0002, 
  0x0003, 0x0001, 0x8001, 0x0000, 0x4000, 0x0000, 0x4001, 0x0000, 
  0x4003, 0x0000, 0x4007, 0x0000, 0x4007, 0x0000, 0x4003, 0x0000, 
  0x4001, 0x0000, 0x4001, 0x0000, 0x4003, 0x0000, 0x4001, 0x0000, 
  0x4001, 0x0000, 0x4001, 0x0000, 0x4000, 0x0000, 0x4000, 0x0000, 
  0x4000, 0x0000, 0x4000, 0x0000, 0x4000, 0x0000, 0x4000, 0x0000, 
  0x4000, 0x0000, 0x4000, 0x0000, 0x4000, 0x0000, 0x4000, 0x0000, 
  0x4000, 0x0000, 0x4000, 0x0000, 0x4000, 0x0000, 0x4000, 0x0000, 
  0x4000, 0x0000, 0x4000, 0x0000, 0x4000, 0x0000, 0x4000, 0x0000, 
  0x4000, 0x0000, 0x4000, 0x0000, 0x4000, 0x0000, 0x4000, 0x0000, 
  0x4000, 0x0000, 0x4000, 0x0000, 0x4000, 0x0000, 0x8000, 0x0000, 
  0x8000, 0x0000, 0x8000, 0x0000, 0x8000, 0x0000, 0x8000, 0x0000, 
  0x8000, 0x0000, 0x8000, 0x0000, 0x8000, 0x0000, 0x8000, 0x0000, 
  0x8000, 0x0000, 0x8000, 0x0000, 0x8000, 0x0000, 0x8000, 0x0000, 
  0x0000, 0x0001, 0x0000, 0x0001, 0x0000, 0x0001, 0x0000, 0x0001, 
  0x0000, 0x0001, 0x0000, 0x0001, 0x0000, 0x0001, 0x0000, 0x0001, 
  0x0000, 0x0001, 0x0000, 0x0001, 0x0000, 0x0001, 0x0000, 0x0001, 
  0x0000, 0x0001, 0x0000, 0x0001, 0x0000, 0x0001, 0x0000, 0x0001, 
  0x0000, 0x0002, 0x0000, 0x0002, 0x0000, 0x0002, 0x0000, 0x0002, 
  0x0000, 0x0002, 0x0000, 0x0002, 0x0000, 0x0002, 0x0000, 0x0002, 
  0x0000, 0x0002, 0x0000, 0x0002, 0x0000, 0x0002, 0x0000, 0x0002, 
  0x0000, 0x0002, 0x0000, 0x0002, 0x0000, 0x0002, 0x0008, 0x0000, 
  0x0008, 0x0000, 0x0008, 0x0000, 0x0008, 0x0000, 0x0008, 0x0000, 
  0x0008, 0x0000, 0x0008, 0x0000, 0x0008, 0x0000, 0x0008, 0x0000, 
  0x0008, 0x0000, 0x0008, 0x0000, 0x0008, 0x0000, 0x0008, 0x0000, 
  0x0008, 0x0000, 0x0408, 0x0102, 0x0408, 0x0102, 0x0408, 0x0102, 
  0x0408, 0x0102, 0x0408, 0x0102, 0x0408, 0x0102, 0x0408, 0x0102, 
  0x0408, 0x0102, 0x0408, 0x0102, 0x0408, 0x0102, 0x0408, 0x0102, 
  0x2448, 0x0912, 0x0408, 0x0102, 0x0408, 0x0102, 0x2448, 0x0912, 
  0x0408, 0x0102, 0x0408, 0x0102, 0x0408, 0x0102, 0x0408, 0x0102, 
  0x0408, 0x0102, 0x0408, 0x0102, 0x0408, 0x0102, 0x2448, 0x0912, 
  0x1428, 0x050A, 0x2C58, 0x0B16, 0x1428, 0x050A, 0x2C58, 0x0B16, 
  0x1428, 0x050A, 0x2C58, 0x0B16, 0x1428, 0x050A, 0x2C58, 0x0B16, 
  0x1428, 0x050A, 0x2C58, 0x0B16, 0x1428, 0x050A, 0x2C58, 0x0B16, 
  0x1428, 0x050A, 0x2C58, 0x0B16, 0x1428, 0x050A, 0x2C58, 0x0B16, 
  0x1428, 0x050A, 0x2C58, 0x0B16, 0x1428, 0x050A, 0x2C58, 0x0B16, 
  0x1428, 0x050A, 0x2C58, 0x0B16, 0x1428, 0x050A, 0x2C58, 0x0B16, 
  0x1428, 0x050A, 0x2C58, 0x0B16, 0x1428, 0x050A, 0x2C58, 0x0B16, 
  0x1428, 0x050A, 0x2C58, 0x0B16, 0x1428, 0x050A, 0x2C58, 0x0B16, 
  0x1428, 0x050A, 0x2C58, 0x0B16, 0x1428, 0x050A, 0x6CD9, 0x0B36, 
  0x54A9, 0x052A, 0xAD5A, 0x0B56, 0x952A, 0x054A, 0x2E5C, 0x0B97, 
  0x162C, 0x058B, 0x2C58, 0x0B16, 0x54A9, 0x052A, 0x6CD9, 0x0B36, 
  0x952A, 0x054A, 0xAD5A, 0x0B56, 0x162C, 0x058B, 0x2E5C, 0x0B97, 
  0x1428, 0x050A, 0x6CD9, 0x0B36, 0x54A9, 0x052A, 0xAD5A, 0x0B56, 
  0x952A, 0x054A, 0x2E5C, 0x0B97, 0x162C, 0x058B, 0x2C58, 0x0B16, 
  0x54A9, 0x052A, 0x6CD9, 0x0B36, 0x952A, 0x054A, 0xAD5A, 0x0B56, 
  0x162C, 0x058B, 0x2E5C, 0x0B97, 0x1428, 0x050A, 0x6CD9, 0x0B36, 
  0x54A9, 0x052A, 0xAD5A, 0x0B56, 0x952A, 0x054A, 0x2E5C, 0x0B97, 
  0x162C, 0x058B, 0x2C58, 0x0B16, 0x54A9, 0x052A, 0x6CD9, 0x0B36, 
  0x952A, 0x054A, 0xAD5A, 0x0B56, 0x162C, 0x058B, 0x2E5C, 0x0B97
};


const unsigned int allon_h[] PROGMEM = {
  1,
  0xFFFF, 0x0FFF
};

const unsigned int inoutspin_h[] PROGMEM = {
  21,
  0x0810, 0x0204, 0x1020, 0x0408, 0x2040, 0x0810, 0x0408, 0x0102, 
  0x0204, 0x0081, 0x8102, 0x0040, 0x4081, 0x0020, 0x0810, 0x0204, 
  0x8102, 0x0040, 0x1020, 0x0408, 0x0204, 0x0081, 0x2040, 0x0810, 
  0x0408, 0x0102, 0x0204, 0x0081, 0x8102, 0x0040, 0x4081, 0x0020, 
  0x8102, 0x0040, 0x0204, 0x0081, 0x0408, 0x0102, 0x2040, 0x0810, 
  0x1020, 0x0408
};


 const atmel_u16 edgechase[] PROGMEM= {
   8,
   0x0000, 0x0200,
   0x0000, 0x0020,
   0x0000, 0x0004,
   0x4000, 0x0000,
   0x0800, 0x0000,
   0x0080, 0x0000,
   0x0010, 0x0000,
   0x0001, 0x0000
 };
 
const unsigned int angles_h[] PROGMEM = {
  28,
  0x0001, 0x0000, 0x0002, 0x0000, 0x0004, 0x0000, 0x0408, 0x0102, 
  0x0000, 0x0001, 0x8000, 0x0000, 0x4000, 0x0000, 0x0000, 0x0020, 
  0x0000, 0x0040, 0x0000, 0x0080, 0x0408, 0x0102, 0x0200, 0x0000, 
  0x0100, 0x0000, 0x0080, 0x0000, 0x0800, 0x0000, 0x1000, 0x0000, 
  0x2000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0800, 0x0000, 0x0400, 
  0x0000, 0x0200, 0x0010, 0x0000, 0x0020, 0x0000, 0x0040, 0x0000, 
  0x0408, 0x0102, 0x0000, 0x0010, 0x0000, 0x0008, 0x0000, 0x0004
};


const unsigned int aroundchase_h[] PROGMEM = {
  58,
  0x0001, 0x0000, 0x0010, 0x0000, 0x0080, 0x0000, 0x0800, 0x0000, 
  0x4000, 0x0000, 0x0000, 0x0004, 0x0000, 0x0020, 0x0000, 0x0040, 
  0x0000, 0x0080, 0x0000, 0x0100, 0x0400, 0x0000, 0x0200, 0x0000, 
  0x0100, 0x0000, 0x0020, 0x0000, 0x0002, 0x0000, 0x0000, 0x0400, 
  0x0000, 0x0040, 0x0000, 0x0008, 0x8000, 0x0000, 0x0000, 0x0001, 
  0x0000, 0x0002, 0x0008, 0x0000, 0x0004, 0x0000, 0x0040, 0x0000, 
  0x0200, 0x0000, 0x2000, 0x0000, 0x0000, 0x0001, 0x0000, 0x0010, 
  0x0000, 0x0080, 0x0000, 0x0100, 0x0400, 0x0000, 0x0000, 0x0002, 
  0x0000, 0x0100, 0x0008, 0x0000, 0x0400, 0x0000, 0x0000, 0x0002, 
  0x0000, 0x0100, 0x0008, 0x0000, 0x0400, 0x0000, 0x0200, 0x0000, 
  0x0100, 0x0000, 0x0080, 0x0000, 0x0010, 0x0000, 0x0001, 0x0000, 
  0x0000, 0x0200, 0x0000, 0x0020, 0x0000, 0x0004, 0x4000, 0x0000, 
  0x0800, 0x0000, 0x0080, 0x0000, 0x0100, 0x0000, 0x0200, 0x0000, 
  0x0400, 0x0000, 0x0000, 0x0100, 0x0000, 0x0080, 0x0000, 0x0040, 
  0x0000, 0x0020, 0x0000, 0x0200
};


const unsigned int boinger_h[] PROGMEM = {
  12,
  0x8102, 0x0040, 0x0084, 0x0021, 0x0108, 0x0042, 0x0204, 0x0081, 
  0x8402, 0x0100, 0x4201, 0x0080, 0x8102, 0x0040, 0x0084, 0x0021, 
  0x0108, 0x0042, 0x0204, 0x0081, 0x8402, 0x0100, 0x4201, 0x0080
};

const unsigned int crosses_h[] PROGMEM = {
  28,
  0x0001, 0x0000, 0x0002, 0x0000, 0x0004, 0x0000, 0x0408, 0x0102, 
  0x0000, 0x0001, 0x8000, 0x0000, 0x4000, 0x0000, 0x0000, 0x0020, 
  0x0000, 0x0040, 0x0000, 0x0080, 0x0408, 0x0102, 0x0200, 0x0000, 
  0x0100, 0x0000, 0x0080, 0x0000, 0x0800, 0x0000, 0x1000, 0x0000, 
  0x2000, 0x0000, 0x0408, 0x0102, 0x0000, 0x0800, 0x0000, 0x0400, 
  0x0000, 0x0200, 0x0010, 0x0000, 0x0020, 0x0000, 0x0040, 0x0000, 
  0x0408, 0x0102, 0x0000, 0x0010, 0x0000, 0x0008, 0x0000, 0x0004
};


const unsigned int inwards_h[] PROGMEM = {
  35,
  0x4081, 0x0020, 0x0810, 0x0204, 0x8102, 0x0040, 0x1020, 0x0408, 
  0x0204, 0x0081, 0x2040, 0x0810, 0x0408, 0x0102, 0x0200, 0x0080, 
  0x0004, 0x0001, 0x1000, 0x0400, 0x0020, 0x0008, 0x0100, 0x0040, 
  0x8002, 0x0000, 0x0010, 0x0004, 0x0800, 0x0200, 0x4001, 0x0000, 
  0x0080, 0x0020, 0x4001, 0x0000, 0x0800, 0x0200, 0x0010, 0x0004, 
  0x0800, 0x0200, 0x8002, 0x0000, 0x0100, 0x0040, 0x1000, 0x0400, 
  0x0004, 0x0001, 0x0200, 0x0080, 0x0040, 0x0010, 0x2000, 0x0800, 
  0x1000, 0x0400, 0x0020, 0x0008, 0x8002, 0x0000, 0x0100, 0x0040, 
  0x0800, 0x0200, 0x0010, 0x0004, 0x0080, 0x0020
};

const unsigned int threechase_h[] PROGMEM = {
  18,
  0x0084, 0x0008, 0x8100, 0x0800, 0x4200, 0x0400, 0x2000, 0x0204, 
  0x0001, 0x0022, 0x0010, 0x0140, 0x0088, 0x0080, 0x0C00, 0x0800, 
  0x1204, 0x0000, 0x2100, 0x0800, 0x0080, 0x0401, 0x0010, 0x0210, 
  0x0020, 0x0408, 0x0040, 0x0804, 0x0200, 0x0088, 0x8100, 0x0040, 
  0x4020, 0x0020, 0x0012, 0x0040
};

const unsigned int ruben_1_h[] PROGMEM = {
  80,
  0x0088, 0x0102, 0x0108, 0x0102, 0x0208, 0x0102, 0x0408, 0x0102, 
  0x0404, 0x0081, 0x8402, 0x0040, 0x4401, 0x0020, 0x8402, 0x0040, 
  0x0404, 0x0081, 0x0408, 0x0102, 0x0208, 0x0102, 0x0108, 0x0102, 
  0x0088, 0x0102, 0x0008, 0x0302, 0x0008, 0x0502, 0x0008, 0x0902, 
  0x2040, 0x0810, 0x1020, 0x0408, 0x0810, 0x0204, 0x0802, 0x0204, 
  0x0800, 0x0604, 0x0800, 0x00C4, 0x0800, 0x001C, 0xC800, 0x0001, 
  0x3800, 0x0000, 0x0070, 0x0000, 0x0007, 0x0000, 0x0000, 0x0E00, 
  0x0000, 0x00E0, 0x0000, 0x003C, 0xC000, 0x0021, 0x3800, 0x0020, 
  0x0380, 0x0020, 0x0070, 0x0020, 0x0007, 0x0020, 0x0000, 0x0E20, 
  0x0000, 0x00E0, 0x0000, 0x0E04, 0x4007, 0x0000, 0x0870, 0x0000, 
  0x0380, 0x0000, 0x0870, 0x0000, 0x4007, 0x0000, 0x0000, 0x0E04, 
  0x0000, 0x00E0, 0x0000, 0x0E04, 0x4007, 0x0000, 0x0870, 0x0000, 
  0x0380, 0x0000, 0x2820, 0x0000, 0x4002, 0x0001, 0x0000, 0x0414, 
  0x0000, 0x00E0, 0x0000, 0x0414, 0x4002, 0x0001, 0x2820, 0x0000, 
  0x0380, 0x0000, 0x2820, 0x0000, 0x4002, 0x0001, 0x0000, 0x0414, 
  0x0000, 0x00E0, 0x0000, 0x023C, 0xC001, 0x0221, 0x3811, 0x0220, 
  0x0391, 0x0220, 0x3801, 0x0220, 0xC000, 0x0221, 0x0000, 0x003C, 
  0x0000, 0x00E0, 0x0000, 0x0E90, 0x0003, 0x0091, 0x2070, 0x0091, 
  0x2380, 0x0091, 0x2070, 0x0091, 0x0007, 0x0091, 0x0000, 0x0E90, 
  0x0000, 0x00E0, 0x0000, 0x01C0, 0x0400, 0x0180, 0x0008, 0x0102
};

const unsigned int mongoloid_h[] PROGMEM = {
  51,
  0x0004, 0x0000, 0x0000, 0x0800, 0x0000, 0x0080, 0x0000, 0x0010, 
  0x0000, 0x0001, 0x2000, 0x0000, 0x0200, 0x0000, 0x0040, 0x0000, 
  0x0004, 0x0000, 0x0002, 0x0000, 0x0001, 0x0000, 0x0000, 0x0800, 
  0x0000, 0x0400, 0x0000, 0x0200, 0x0000, 0x0080, 0x0000, 0x0040, 
  0x0000, 0x0020, 0x0000, 0x0010, 0x0000, 0x0008, 0x0000, 0x0004, 
  0x0000, 0x0001, 0x8000, 0x0000, 0x4000, 0x0000, 0x2000, 0x0000, 
  0x1000, 0x0000, 0x0800, 0x0000, 0x0200, 0x0000, 0x0100, 0x0000, 
  0x0080, 0x0000, 0x0040, 0x0000, 0x0020, 0x0000, 0x0010, 0x0000, 
  0x0002, 0x0000, 0x0000, 0x0200, 0x0000, 0x0040, 0x0000, 0x0004, 
  0x8000, 0x0000, 0x0800, 0x0000, 0x0100, 0x0000, 0x0010, 0x0000, 
  0x0002, 0x0000, 0x0004, 0x0000, 0x0008, 0x0000, 0x0000, 0x0002, 
  0x0000, 0x0001, 0x8000, 0x0000, 0x4000, 0x0000, 0x4891, 0x0224, 
  0x9122, 0x0448, 0x2244, 0x0891, 0x0408, 0x0102
};



const unsigned int tennis_h[] PROGMEM = {
  54,
  0x0001, 0x0000, 0x0010, 0x0200, 0x0080, 0x0020, 0x0800, 0x0004, 
  0x4000, 0x0000, 0x8000, 0x0000, 0x1000, 0x0008, 0x0100, 0x0040, 
  0x0020, 0x0400, 0x0002, 0x0000, 0x0001, 0x0000, 0x0002, 0x0000, 
  0x0004, 0x0000, 0x0040, 0x0800, 0x0200, 0x0080, 0x2000, 0x0010, 
  0x0000, 0x0001, 0x8000, 0x0000, 0x4000, 0x0000, 0x8000, 0x0000, 
  0x0000, 0x0001, 0x0000, 0x0002, 0x0400, 0x0100, 0x0008, 0x0000, 
  0x0004, 0x0000, 0x0002, 0x0000, 0x0001, 0x0000, 0x0002, 0x0000, 
  0x0004, 0x0000, 0x0008, 0x0000, 0x0400, 0x0100, 0x0200, 0x0080, 
  0x0100, 0x0040, 0x0080, 0x0020, 0x0100, 0x0040, 0x0200, 0x0080, 
  0x0400, 0x0100, 0x0000, 0x0002, 0x0000, 0x0001, 0x8000, 0x0000, 
  0x4000, 0x0000, 0x8000, 0x0000, 0x0000, 0x0001, 0x0000, 0x0002, 
  0x0408, 0x0102, 0x2040, 0x0810, 0x1020, 0x0408, 0x0810, 0x0204, 
  0x1020, 0x0408, 0x2040, 0x0810, 0x0408, 0x0102, 0x0004, 0x0000, 
  0x0002, 0x0000, 0x0000, 0x0000
};

const unsigned int spec_1_h[] PROGMEM = {
  20,
  0x8401, 0x0080, 0x0000, 0x0000, 0x0410, 0x0410, 0x0000, 0x0000, 
  0x00A0, 0x0802, 0x0000, 0x0000, 0x8808, 0x0010, 0x0000, 0x0000, 
  0x4400, 0x0088, 0x0000, 0x0000, 0x0400, 0x0844, 0x0000, 0x0000, 
  0x0040, 0x0422, 0x0000, 0x0000, 0x0042, 0x0202, 0x0000, 0x0000, 
  0x0221, 0x0002, 0x0000, 0x0000, 0x2110, 0x0100, 0x0000, 0x0000
};
const unsigned int megazoid_h[] PROGMEM = {
  54,
  0x2040, 0x0810, 0x0204, 0x0081, 0x1020, 0x0408, 0x0204, 0x0081, 
  0x0408, 0x0102, 0x2040, 0x0810, 0x0204, 0x0081, 0x1020, 0x0408, 
  0x8102, 0x0040, 0x1020, 0x0408, 0x2040, 0x0810, 0x0408, 0x0102, 
  0x2040, 0x0810, 0x0204, 0x0081, 0x1020, 0x0408, 0x8102, 0x0040, 
  0x4081, 0x0020, 0x0810, 0x0204, 0x0080, 0x0020, 0x0800, 0x0200, 
  0x4001, 0x0000, 0x0010, 0x0004, 0x0000, 0x0020, 0x0000, 0x0200, 
  0x0001, 0x0000, 0x0010, 0x0000, 0x0080, 0x0000, 0x0800, 0x0000, 
  0x4000, 0x0000, 0x0000, 0x0004, 0x0000, 0x0020, 0x0000, 0x0200, 
  0x0001, 0x0000, 0x0010, 0x0000, 0x0080, 0x0000, 0x0800, 0x0000, 
  0x4000, 0x0000, 0x8800, 0x0004, 0x1000, 0x0009, 0x2000, 0x0010, 
  0x0000, 0x0002, 0x0400, 0x0100, 0x0008, 0x0000, 0x0040, 0x0800, 
  0x0024, 0x0400, 0x0012, 0x0200, 0x0001, 0x0000, 0x0011, 0x0200, 
  0x0091, 0x0220, 0x0891, 0x0224, 0x4891, 0x0224, 0x9122, 0x0448, 
  0x2244, 0x0891, 0x0408, 0x0102
};

// ________________________________________________________________________
//
unsigned long g_rand_seed;	// for random number get

unsigned long get_rand(unsigned int min, unsigned int max)
{
	unsigned int range;
	unsigned int val;

	range= max-min;
	val= min + ( rand() % (range+1) );
	return val;
}

/* unpack a pair of values into frame[].
 *   hi   - high 16 bits of led mask
 *   lo   - low 16 bits of led mask
 * brightness is clamped to brightmax here. */
void unpack_frame (atmel_u16 hi, atmel_u16 lo, atmel_u8 brightness) {

  atmel_u8 index;

  if (brightness > brightmax)
	brightness = brightmax;

  /* stops when all 1 bits in lo have been consumed */
  for (index = 0; lo; lo >>= 1, ++ index)
	if (lo & 1)
	  frame[index] = brightness;

  /* stops when all 1 bits in hi have been consumed */
  for (index = 16; hi; hi >>= 1, ++ index)
	if (hi & 1) /* we assume data is valid and index never goes >= 28. */
	  frame[index] = brightness;

}


/* plays one of those patterns 
 *   frame      - frame counter
 *   brightness - brightness
 *   data       - pattern data */
void play_packed_pattern (atmel_u16 frame, atmel_u8 brightness,
						  const atmel_u16 *data) 
{
	unsigned int data1;
	unsigned int data0;


	unsigned int numframes = pgm_read_word(&(data[0]));

  frame %= numframes;
  data += (1 + 2 * frame);
	data1=pgm_read_word(&(data[1]));
	data0=pgm_read_word(&(data[0]));

//  unpack_frame(data[1], data[0], brightness);
unpack_frame(data1,data0,brightness);

}


void pwm_init()
{
	unsigned char i;
	
	for (i=0;i<PWM_CHANNELS;i++)
	{
		leds[i]=0;
	}
	
	pwmCount=PWM_MAXVAL-1;  // jesse says ' so on first ISR we load counts from settings, since it increments at the beginning of the function
}

// ________________________________________________________________________
//
void init_timers()
{
	
	
	OCR0A=75; //upper register for comparison
	
	//TCCR0A needs to be set to CTC mode, which is done by setting WGM01 to 1
	TCCR0A = (1<< WGM01); // CTC mode
	TCCR0B = (1<< CS01); // prescale 8
	TIMSK0 = (1<< OCIE0A); // enable Output Compare Match A Interrupt Enable for timer 0 
	TIMSK1 = (1<< OCIE1A); // enable Output Compare Match for timer 1
	
	TCCR1B = (1<<WGM12) | (1<<CS12) | (1<<CS10); //CTC mode, prescaler 1024
	OCR1A =  14400; 

	//enable external interrupts

	EIMSK = (1<<INT1);
	EICRA = (1<<ISC10);

	PCICR = (1<<PCIE2);
	PCMSK2 = (1<<PCINT18);

}

// ________________________________________________________________________
//  SERIAL STUFF FOR DEBUGGING -- COMMENTED OUT

// set baud rate:  14400 for now -- 63 comes from the datasheet
//230400 is 3
//115200 is 7	(for 20Mhz xtal, this is about 157Kbaud)
//460800 is 1 
//921600 is 0	(for 20Mhz xtal, this is 1.25Mbaud exact)

// see datasheet page 118
// we are using "normal mode" (not "double speed mode")
// UBRR= (Fosc / (16 * baud) ) - 1
// 20Mhz, 115200: UBRR= (20Mhz / (1843200)) - 1 = 10.85 - 1= 10
// 20Mhz, 1250000: UBRR= (20Mhz / (20M)) -1 = 0, exact
/*
#define	BAUD_SETTING 4

void UARTinit()
{
	
	UBRR0H=(unsigned char)(BAUD_SETTING>>8);
	UBRR0L=(unsigned char)BAUD_SETTING;
	
	// enable transmitter, receiver, and interrupts
	
	UCSR0B = (1<<RXEN0)|(1<<TXEN0);
	
	//set frame format:  8N1
	
	UCSR0C = (3<<UCSZ00);
}


void transmit(unsigned char data)
{

while ( !( UCSR0A & (1<<UDRE0)) )
;
// Put data into buffer, sends the data 
UDR0 = data;
}

*/
// ________________________________________________________________________
//
void set_fps(int fps)
{
	if (fps<=5)
	fps=5;

	OCR1A=20000/fps; //14400 hz divided by desired hz = target for timer to hit
}


// ________________________________________________________________________
// Wait for frames in an interrupt
//
void wait_for_frames(unsigned int frames)
{
	unsigned int i;
	
//	PORTD |= _BV(PD5);  // turn test pin on
	g_load_new_led_data= 1;
	for (i=0;i<frames;i++)
	{	
		
		isframe=0;
		while(isframe==0){}
	
	}
}


// ________________________________________________________________________
// Frame blending which interpolates over a given # of frames

void makeframe (unsigned char blur)
{

unsigned char i,j,diff;

	for (i=0;i<PWM_CHANNELS;i++)
	{
	tempframe[i]=lastframe[i];
	}

for (i=1;i<=blur;i++)
	{
	for (j=0;j<PWM_CHANNELS;j++)
		{
		if (frame[j]>lastframe[j])
			{
			diff=(frame[j]-lastframe[j])/blur;
			tempframe[j]+=diff;
			newframe[j]=tempframe[j];
			}	
		else if (frame[j]<lastframe[j])
			{
			diff=(lastframe[j]-frame[j])/blur;
			tempframe[j]-=diff;
			newframe[j]=tempframe[j];
			}
		else
			{
			newframe[j]=frame[j];
			}
		}

	wait_for_frames(1);
	}

	for (i=0;i<PWM_CHANNELS;i++)
	{
	lastframe[i]=frame[i];
	}
	
}

//________________________________________________________________________________
// Interrupt which marks when a frame happens


SIGNAL (SIG_OUTPUT_COMPARE1A)
{

	
	isframe=1;

}



// ________________________________________________________________________
//
// Main PWM "slice" ISR, and reloads data when pwm cycle is complete

SIGNAL (SIG_OUTPUT_COMPARE0A)
{
	//check to reload values

	pwmCount++;
	if (pwmCount>=PWM_MAXVAL)
	{
		pwmCount=0;
		if (g_load_new_led_data)
		{
			g_load_new_led_data= 0;
			leds[0]=newframe[0];
			leds[1]=newframe[1];
			leds[2]=newframe[2];
			leds[3]=newframe[3];
			leds[4]=newframe[4];
			leds[5]=newframe[5];
			leds[6]=newframe[6];
			leds[7]=newframe[7];
			leds[8]=newframe[8];
			leds[9]=newframe[9];
			leds[10]=newframe[10];
			leds[11]=newframe[11];
			leds[12]=newframe[12];
			leds[13]=newframe[13];
			leds[14]=newframe[14];
			leds[15]=newframe[15];
			leds[16]=newframe[16];
			leds[17]=newframe[17];
			leds[18]=newframe[18];
			leds[19]=newframe[19];			
			leds[20]=newframe[20];
			leds[21]=newframe[21];
			leds[22]=newframe[22];
			leds[23]=newframe[23];
			leds[24]=newframe[24];
			leds[25]=newframe[25];
			leds[26]=newframe[26];
			leds[27]=newframe[27];	
		
			}
	}

//bang data into LED drivers -- sorry, we didn't use SPI.

#define OUTPUT_0BIT	{PORTD &= ~(_BV(PD6));	PORTD |= _BV(PD7);	PORTD &= ~(_BV(PD7));	}
#define OUTPUT_1BIT	{PORTD |= _BV(PD6);	PORTD |= _BV(PD7);	PORTD &= ~(_BV(PD7));	}

#define DO_CHANNEL(lednum)	if (pwmCount >= leds[lednum]) OUTPUT_0BIT else OUTPUT_1BIT	\

	DO_CHANNEL(14);	
	DO_CHANNEL(15);	
	DO_CHANNEL(16);	
	DO_CHANNEL(20);	
	DO_CHANNEL(19);	
	DO_CHANNEL(18);	
	DO_CHANNEL(22);	
	DO_CHANNEL(21);	 
	DO_CHANNEL(23);	
	DO_CHANNEL(24);	
	DO_CHANNEL(17);
	DO_CHANNEL(27);
	DO_CHANNEL(26);
	DO_CHANNEL(25);	
	OUTPUT_0BIT;
	OUTPUT_0BIT;
	DO_CHANNEL(7);	 
	OUTPUT_0BIT;
	OUTPUT_0BIT;
	DO_CHANNEL(10);	
	DO_CHANNEL(3);	
	DO_CHANNEL(11);	
	DO_CHANNEL(12);	
	DO_CHANNEL(13);	
	DO_CHANNEL(0);	
	DO_CHANNEL(1);	
	DO_CHANNEL(2);	
	DO_CHANNEL(4);	
	DO_CHANNEL(5);	
	DO_CHANNEL(6);	
	DO_CHANNEL(9);	
	DO_CHANNEL(8);		

//latch

	PORTB |= _BV(PB1);
	PORTB &= ~(_BV(PB1));

PORTB &= ~(_BV(PB0));


}

//_________________________________________________________________________________
// Button 1 -- mode

SIGNAL (SIG_INTERRUPT1)
{
mode_has_changed=1;

if (interruptcounter2==0)
{

	mode++;
	if (mode==5)
	{
	mode=1;
	}



  while (1)
	{
		if bit_is_clear(PIND,3)
		{
		break;
		}
	}
	}
	interruptcounter2++;
	if (interruptcounter2==2)
		{
			interruptcounter2=0;
		}


}

//_________________________________________________________________________________
// Button 2 -- brightness
SIGNAL(SIG_PIN_CHANGE2)     

{
if (interruptcounter==0)
{

	brightstate++;
	if (brightstate==4)
	{
	brightstate=0;
	}

	if (brightstate==0)
	{
		brightmax=BRIGHTNESS_MAX;
	}
	else if (brightstate==1)
	{
	brightmax=BRIGHTNESS_2;
	}
	else if (brightstate==2)
	{
		brightmax=BRIGHTNESS_3;
	}
	else if (brightstate==3)
	{
		brightmax=BRIGHTNESS_4;
	}

  while (1)
	{
		if bit_is_clear(PIND,2)
		{
		break;
		}
	}
	}
	interruptcounter++;
	if (interruptcounter==2)
		{
			interruptcounter=0;
		}

}

//_____________________________________________________________________________
// Deprecated ways of setting LEDs

void allon()
{
	unsigned char i;
	for (i=0;i<PWM_CHANNELS;i++)
	{
	frame[i]=254;
	}
}

void alloff()
{
	unsigned char i;
	for (i=0;i<PWM_CHANNELS;i++)
	{
	frame[i]=0;
	}
}

void setall(unsigned char value)
{
	unsigned char i;
	for (i=0;i<PWM_CHANNELS;i++)
	{
		frame[i]=value;
		if (brightmax<value)
{
frame[i]=brightmax;
}
	}
}

// zero-based
void setone(unsigned char led, unsigned char value)
{


frame[led]=value;
if (brightmax<value)
{
frame[led]=brightmax;
}

}


void fadeall(unsigned char repeat, int speed)
{
	
	set_fps(speed/10);
	int i;
	unsigned char j;
	int k;

	for (j=0;j<repeat;j++)
	{
		for (i=0;i<64;i++)
		{
			setall(i);
			makeframe(1);
		}
	
		for (i=64;i<255;i=i+2)
		{
			setall(i);
			makeframe(1);
		}
	
		for (k=255;k>64;k=k-2)
		{
			setall(k);
			makeframe(1);
		}
		for (k=64;k>0;k--)
		{
			setall(k);
			makeframe(1);
		}
	}
}

//_____________________________________________________________________________________
// Main routine for playing patterns
// Takes 2 speeds, calculates a delta, plays patterns with random acceleration and brightness
// Also offsets 2 patterns speeds randomly
// Mode changes are implemented here
// Also special case to write Image Node on powerup


void playpatterns(unsigned int beginspeed, unsigned int endspeed, unsigned int frames, unsigned char brightnessa, unsigned char brightnessb, unsigned char fade, unsigned char beginning)
{


unsigned int counter=0;
unsigned char speedbump=0;
unsigned int pattern1=0;
unsigned int pattern2=0;
char offset=0;
char offsetcounter=0;
unsigned int counter2=0;
unsigned char brightness1=0;
unsigned char brightness2=0;
unsigned char oneortwo=0;

masterspeed=beginspeed;
brightness1=brightnessa;
brightness2=brightnessb;

if (beginspeed>endspeed)
speedbump=(beginspeed-endspeed)/frames;

if (endspeed>beginspeed)
speedbump=(endspeed-beginspeed)/frames;

set_fps(masterspeed/10);


pattern1=get_rand(1,51);
pattern2=get_rand(1,51);
oneortwo=get_rand(1,6);
offset=get_rand(0,4);
//pattern1=1;
//pattern2=2;


for (counter=0;counter<frames;counter++)
	{
	

	alloff();

if (beginning==1)
	play_packed_pattern(counter, brightness1, imagenode_h);

	//play pattern 1

	else if (pattern1==1)
	play_packed_pattern(counter, brightness1, edgechase);
	else if (pattern1==2)
	play_packed_pattern(counter, brightness1, inoutspin_h);
	else if (pattern1==3)
	play_packed_pattern(counter, brightness1, angles_h);
	else if (pattern1==4)
	play_packed_pattern(counter, brightness1, aroundchase_h);
	else if (pattern1==5)
	play_packed_pattern(counter, brightness1, boinger_h);
	else if (pattern1==6)
	play_packed_pattern(counter, brightness1, crosses_h);
	else if (pattern1==7)
	play_packed_pattern(counter, brightness1, inwards_h);
	else if (pattern1==8)
	play_packed_pattern(counter, brightness1, mongoloid_h);
	else if (pattern1==9)
	play_packed_pattern(counter, brightness1, threechase_h);
	else if (pattern1==10)
	play_packed_pattern(counter, brightness1, ruben_1_h);
	else if (pattern1==11)
	play_packed_pattern(counter, brightness1, megazoid_h);
	else if (pattern1==12)
	play_packed_pattern(counter, brightness1, tennis_h);
	else if (pattern1==13)
	play_packed_pattern(counter, brightness1, spec_1_h);
	else if (pattern1==14)
	play_packed_pattern(counter, brightness1, bacon3_h);
	else if (pattern1==15)
	play_packed_pattern(counter, brightness1, bacon4_h);
	else if (pattern1==16)
	play_packed_pattern(counter, brightness1, bacon5_h);
	else if (pattern1==17)
	play_packed_pattern(counter, brightness1, Bacon6_h);
	else if (pattern1==18)
	play_packed_pattern(counter, brightness1, bacon7_2_h);
	else if (pattern1==19)
	play_packed_pattern(counter, brightness1, Bflashanti_h);
	else if (pattern1==20)
	play_packed_pattern(counter, brightness1, Bflashchase_h);
	else if (pattern1==21)
	play_packed_pattern(counter, brightness1, Bflashofftime_h);
	else if (pattern1==22)
	play_packed_pattern(counter, brightness1, Bflashop_h);
	else if (pattern1==23)
	play_packed_pattern(counter, brightness1, Bflashrollinout_h);
	else if (pattern1==24)
	play_packed_pattern(counter, brightness1, Bflashsweep_h);
	else if (pattern1==25)
	play_packed_pattern(counter, brightness1, bigspiral_h);
	else if (pattern1==26)
	play_packed_pattern(counter, brightness1, blinkblinkblink_h);
	else if (pattern1==27)
	play_packed_pattern(counter, brightness1, boing2_h);
	else if (pattern1==28)
	play_packed_pattern(counter, brightness1, Btestchase_h);
	else if (pattern1==29)
	play_packed_pattern(counter, brightness1, chris1_h);
	else if (pattern1==30)
	play_packed_pattern(counter, brightness1, circlehit_h);
	else if (pattern1==31)
	play_packed_pattern(counter, brightness1, curvey_h);
	else if (pattern1==32)
	play_packed_pattern(counter, brightness1, diamond_h);
	else if (pattern1==33)
	play_packed_pattern(counter, brightness1, drop_h);
	else if (pattern1==34)
	play_packed_pattern(counter, brightness1, imagenode_h);
	else if (pattern1==35)
	play_packed_pattern(counter, brightness1, jason1_h);
	else if (pattern1==36)
	play_packed_pattern(counter, brightness1, jumpinjack_h);
	else if (pattern1==37)
	play_packed_pattern(counter, brightness1, knifechop_h);
	else if (pattern1==38)
	play_packed_pattern(counter, brightness1, millsmess_h);
	else if (pattern1==39)
	play_packed_pattern(counter, brightness1, Nice_Matt_3_h);
	else if (pattern1==40)
	play_packed_pattern(counter, brightness1, onewalk_h);
	else if (pattern1==41)
	play_packed_pattern(counter, brightness1, pattern1_h);
	else if (pattern1==42)
	play_packed_pattern(counter, brightness1, snakey_h);
	else if (pattern1==43)
	play_packed_pattern(counter, brightness1, spaz_h);
	else if (pattern1==44)
	play_packed_pattern(counter, brightness1, spiralbacon_h);
	else if (pattern1==45)
	play_packed_pattern(counter, brightness1, splitcross_h);
	else if (pattern1==46)
	play_packed_pattern(counter, brightness1, theman_h);
	else if (pattern1==47)
	play_packed_pattern(counter, brightness1, tricross_h);
	else if (pattern1==48)
	play_packed_pattern(counter, brightness1, tweaker_h);
	else if (pattern1==49)
	play_packed_pattern(counter, brightness1, waggle_h);
	else if (pattern1==50)
	play_packed_pattern(counter, brightness1, ytree_h);
	else if (pattern1==51)
	play_packed_pattern(counter, brightness1, Burnzieblinkiev2_h);
	
	//check offset

	offsetcounter++;
	if (offsetcounter>offset)
	{
		counter2++;
		offsetcounter=0;
	}
if (beginning==0){
if (oneortwo<6){

		if (pattern2==1)
	play_packed_pattern(counter, brightness2, edgechase);
	else if (pattern2==2)
	play_packed_pattern(counter, brightness2, inoutspin_h);
	else if (pattern2==3)
	play_packed_pattern(counter, brightness2, angles_h);
	else if (pattern2==4)
	play_packed_pattern(counter, brightness2, aroundchase_h);
	else if (pattern2==5)
	play_packed_pattern(counter, brightness2, boinger_h);
	else if (pattern2==6)
	play_packed_pattern(counter, brightness2, crosses_h);
	else if (pattern2==7)
	play_packed_pattern(counter, brightness2, inwards_h);
	else if (pattern2==8)
	play_packed_pattern(counter, brightness2, mongoloid_h);
	else if (pattern2==9)
	play_packed_pattern(counter, brightness2, threechase_h);
	else if (pattern2==10)
	play_packed_pattern(counter, brightness2, ruben_1_h);
	else if (pattern2==11)
	play_packed_pattern(counter, brightness2, megazoid_h);
	else if (pattern2==12)
	play_packed_pattern(counter, brightness2, tennis_h);
	else if (pattern2==13)
	play_packed_pattern(counter, brightness2, spec_1_h);
	else if (pattern2==14)
	play_packed_pattern(counter, brightness2, bacon3_h);
	else if (pattern2==15)
	play_packed_pattern(counter, brightness2, bacon4_h);
	else if (pattern2==16)
	play_packed_pattern(counter, brightness2, bacon5_h);
	else if (pattern2==17)
	play_packed_pattern(counter, brightness2, Bacon6_h);
	else if (pattern2==18)
	play_packed_pattern(counter, brightness2, bacon7_2_h);
	else if (pattern2==19)
	play_packed_pattern(counter, brightness2, Bflashanti_h);
	else if (pattern2==20)
	play_packed_pattern(counter, brightness2, Bflashchase_h);
	else if (pattern2==21)
	play_packed_pattern(counter, brightness2, Bflashofftime_h);
	else if (pattern2==22)
	play_packed_pattern(counter, brightness2, Bflashop_h);
	else if (pattern2==23)
	play_packed_pattern(counter, brightness2, Bflashrollinout_h);
	else if (pattern2==24)
	play_packed_pattern(counter, brightness2, Bflashsweep_h);
	else if (pattern2==25)
	play_packed_pattern(counter, brightness2, bigspiral_h);
	else if (pattern2==26)
	play_packed_pattern(counter, brightness2, blinkblinkblink_h);
	else if (pattern2==27)
	play_packed_pattern(counter, brightness2, boing2_h);
	else if (pattern2==28)
	play_packed_pattern(counter, brightness2, Btestchase_h);
	else if (pattern2==29)
	play_packed_pattern(counter, brightness2, chris1_h);
	else if (pattern2==30)
	play_packed_pattern(counter, brightness2, circlehit_h);
	else if (pattern2==31)
	play_packed_pattern(counter, brightness2, curvey_h);
	else if (pattern2==32)
	play_packed_pattern(counter, brightness2, diamond_h);
	else if (pattern2==33)
	play_packed_pattern(counter, brightness2, drop_h);
	else if (pattern2==34)
	play_packed_pattern(counter, brightness2, imagenode_h);
	else if (pattern2==35)
	play_packed_pattern(counter, brightness2, jason1_h);
	else if (pattern2==36)
	play_packed_pattern(counter, brightness2, jumpinjack_h);
	else if (pattern2==37)
	play_packed_pattern(counter, brightness2, knifechop_h);
	else if (pattern2==38)
	play_packed_pattern(counter, brightness2, millsmess_h);
	else if (pattern2==39)
	play_packed_pattern(counter, brightness2, Nice_Matt_3_h);
	else if (pattern2==40)
	play_packed_pattern(counter, brightness2, onewalk_h);
	else if (pattern2==41)
	play_packed_pattern(counter, brightness2, pattern1_h);
	else if (pattern2==42)
	play_packed_pattern(counter, brightness2, snakey_h);
	else if (pattern2==43)
	play_packed_pattern(counter, brightness2, spaz_h);
	else if (pattern2==44)
	play_packed_pattern(counter, brightness2, spiralbacon_h);
	else if (pattern2==45)
	play_packed_pattern(counter, brightness2, splitcross_h);
	else if (pattern2==46)
	play_packed_pattern(counter, brightness2, theman_h);
	else if (pattern2==47)
	play_packed_pattern(counter, brightness2, tricross_h);
	else if (pattern2==48)
	play_packed_pattern(counter, brightness2, tweaker_h);
	else if (pattern2==49)
	play_packed_pattern(counter, brightness2, waggle_h);
	else if (pattern2==50)
	play_packed_pattern(counter, brightness2, ytree_h);
	else if (pattern2==51)
	play_packed_pattern(counter, brightness2, Burnzieblinkiev2_h);

}
}
	
	if (beginspeed>endspeed)
	masterspeed-=speedbump;
	else if (endspeed>beginspeed)
	masterspeed+=speedbump;
	if (mode==2)
	set_fps(60);
	else if (mode==3)
	set_fps(60);
	else if (mode==4)
	set_fps(masterspeed/10);
	else
	set_fps(masterspeed/10);

		//make frame
	if (mode==2)
	makeframe(10);
	else if (mode==3)
	makeframe(1);
	else if (mode==4)
	{
	play_packed_pattern(counter, 255, allon_h);
	makeframe(1);
	}
	else
	makeframe(fade);
	}
	
}





// ________________________________________________________________________
//

int main ()
{

	DDRB=0b11110011;  //B2 and B3 are inputs
	DDRD=0b11111110; //RXD is input, all others are output.
	
	init_timers();
//	UARTinit();
	sei();

	unsigned char picker, b1, b2;
	picker=0;

	brightmax =255;

	set_fps(masterspeed/10);	// note: inaccurate with 20mhz xtal

	makeframe(1);
	//play Image Node

		playpatterns(300, 300, 55, 128, 128, 6, 1);

	// main forever loop
	while(1)
	{
	b1=get_rand(1,255);
	b2=get_rand(1,255);	

	playpatterns(get_rand(300,600), get_rand(300,600), get_rand(100,300), get_rand(1,128), get_rand(1,128), get_rand(1,9), 0);

 	}

	return 0;
}