/*
* ATTINY861_20PU_LED_MATRIX.c
*
* Created: 1/25/2014 4:24:47 PM
* Author: The Hammer
*/
#include <avr/io.h>
// 74HC595 PWM and key variables
int row = 0, column = 0;
int esc = 0, escBC[3]={0, 20, 0}, escBPC[3]={0, 0, 20}, escGfade[2]={49, 0}, escG[3]={0, 0, 0}, escBfade[2]={49, 0}, escB[3]={0, 0, 0}, escRfade[2]={49, 0}, escR[3]={0, 0, 0};
int tilda = 0, tildaBC[3]={0, 20, 0}, tildaBPC[3]={0, 0, 20}, tildaGfade[2]={49, 0}, tildaG[3]={0, 0, 0}, tildaBfade[2]={49, 0}, tildaB[3]={0, 0, 0}, tildaRfade[2]={49, 0}, tildaR[3]={0, 0, 0};
int tab = 0, tabBC[3]={0, 20, 0}, tabBPC[3]={0, 0, 20}, tabGfade[2]={49, 0}, tabG[3]={0, 0, 0}, tabBfade[2]={49, 0}, tabB[3]={0, 0, 0}, tabRfade[2]={49, 0}, tabR[3]={0, 0, 0};
int caps = 0, capsBC[3]={0, 20, 0}, capsBPC[3]={0, 0, 20}, capsGfade[2]={49, 0}, capsG[3]={0, 0, 0}, capsBfade[2]={49, 0}, capsB[3]={0, 0, 0}, capsRfade[2]={49, 0}, capsR[3]={0, 0, 0};
int lshift = 0, lshiftBC[3]={0, 20, 0}, lshiftBPC[3]={0, 0, 20}, lshiftGfade[2]={49, 0}, lshiftG[3]={0, 0, 0}, lshiftBfade[2]={49, 0}, lshiftB[3]={0, 0, 0}, lshiftRfade[2]={49, 0}, lshiftR[3]={0, 0, 0};
int lctrl = 0, lctrlBC[3]={0, 20, 0}, lctrlBPC[3]={0, 0, 20}, lctrlGfade[2]={49, 0}, lctrlG[3]={0, 0, 0}, lctrlBfade[2]={49, 0}, lctrlB[3]={0, 0, 0}, lctrlRfade[2]={49, 0}, lctrlR[3]={0, 0, 0};
int f1 = 0, f1BC[3]={0, 20, 0}, f1BPC[3]={0, 0, 20}, f1Gfade[2]={49, 0}, f1G[3]={0, 0, 0}, f1Bfade[2]={49, 0}, f1B[3]={0, 0, 0}, f1Rfade[2]={49, 0}, f1R[3]={0, 0, 0};
int one = 0, oneBC[3]={0, 20, 0}, oneBPC[3]={0, 0, 20}, oneGfade[2]={49, 0}, oneG[3]={0, 0, 0}, oneBfade[2]={49, 0}, oneB[3]={0, 0, 0}, oneRfade[2]={49, 0}, oneR[3]={0, 0, 0};
int q = 0, qBC[3]={0, 20, 0}, qBPC[3]={0, 0, 20}, qGfade[2]={49, 0}, qG[3]={0, 0, 0}, qBfade[2]={49, 0}, qB[3]={0, 0, 0}, qRfade[2]={49, 0}, qR[3]={0, 0, 0};
int a = 0, aBC[3]={0, 20, 0}, aBPC[3]={0, 0, 20}, aGfade[2]={49, 0}, aG[3]={0, 0, 0}, aBfade[2]={49, 0}, aB[3]={0, 0, 0}, aRfade[2]={49, 0}, aR[3]={0, 0, 0};
int z = 0, zBC[3]={0, 20, 0}, zBPC[3]={0, 0, 20}, zGfade[2]={49, 0}, zG[3]={0, 0, 0}, zBfade[2]={49, 0}, zB[3]={0, 0, 0}, zRfade[2]={49, 0}, zR[3]={0, 0, 0};
int lspecial = 0, lspecialBC[3]={0, 20, 0}, lspecialBPC[3]={0, 0, 20}, lspecialGfade[2]={49, 0}, lspecialG[3]={0, 0, 0}, lspecialBfade[2]={49, 0}, lspecialB[3]={0, 0, 0}, lspecialRfade[2]={49, 0}, lspecialR[3]={0, 0, 0};
int f2 = 0, f2BC[3]={0, 20, 0}, f2BPC[3]={0, 0, 20}, f2Gfade[2]={49, 0}, f2G[3]={0, 0, 0}, f2Bfade[2]={49, 0}, f2B[3]={0, 0, 0}, f2Rfade[2]={49, 0}, f2R[3]={0, 0, 0};
int two = 0, twoBC[3]={0, 20, 0}, twoBPC[3]={0, 0, 20}, twoGfade[2]={49, 0}, twoG[3]={0, 0, 0}, twoBfade[2]={49, 0}, twoB[3]={0, 0, 0}, twoRfade[2]={49, 0}, twoR[3]={0, 0, 0};
int w = 0, wBC[3]={0, 20, 0}, wBPC[3]={0, 0, 20}, wGfade[2]={49, 0}, wG[3]={0, 0, 0}, wBfade[2]={49, 0}, wB[3]={0, 0, 0}, wRfade[2]={49, 0}, wR[3]={0, 0, 0};
int s = 0, sBC[3]={0, 20, 0}, sBPC[3]={0, 0, 20}, sGfade[2]={49, 0}, sG[3]={0, 0, 0}, sBfade[2]={49, 0}, sB[3]={0, 0, 0}, sRfade[2]={49, 0}, sR[3]={0, 0, 0};
int x = 0, xBC[3]={0, 20, 0}, xBPC[3]={0, 0, 20}, xGfade[2]={49, 0}, xG[3]={0, 0, 0}, xBfade[2]={49, 0}, xB[3]={0, 0, 0}, xRfade[2]={49, 0}, xR[3]={0, 0, 0};
int lalt = 0, laltBC[3]={0, 20, 0}, laltBPC[3]={0, 0, 20}, laltGfade[2]={49, 0}, laltG[3]={0, 0, 0}, laltBfade[2]={49, 0}, laltB[3]={0, 0, 0}, laltRfade[2]={49, 0}, laltR[3]={0, 0, 0};
int f3 = 0, f3BC[3]={0, 20, 0}, f3BPC[3]={0, 0, 20}, f3Gfade[2]={49, 0}, f3G[3]={0, 0, 0}, f3Bfade[2]={49, 0}, f3B[3]={0, 0, 0}, f3Rfade[2]={49, 0}, f3R[3]={0, 0, 0};
int three = 0, threeBC[3]={0, 20, 0}, threeBPC[3]={0, 0, 20}, threeGfade[2]={49, 0}, threeG[3]={0, 0, 0}, threeBfade[2]={49, 0}, threeB[3]={0, 0, 0}, threeRfade[2]={49, 0}, threeR[3]={0, 0, 0};
int e = 0, eBC[3]={0, 20, 0}, eBPC[3]={0, 0, 20}, eGfade[2]={49, 0}, eG[3]={0, 0, 0}, eBfade[2]={49, 0}, eB[3]={0, 0, 0}, eRfade[2]={49, 0}, eR[3]={0, 0, 0};
int d = 0, dBC[3]={0, 20, 0}, dBPC[3]={0, 0, 20}, dGfade[2]={49, 0}, dG[3]={0, 0, 0}, dBfade[2]={49, 0}, dB[3]={0, 0, 0}, dRfade[2]={49, 0}, dR[3]={0, 0, 0};
int c = 0, cBC[3]={0, 20, 0}, cBPC[3]={0, 0, 20}, cGfade[2]={49, 0}, cG[3]={0, 0, 0}, cBfade[2]={49, 0}, cB[3]={0, 0, 0}, cRfade[2]={49, 0}, cR[3]={0, 0, 0};
int v = 0, vBC[3]={0, 20, 0}, vBPC[3]={0, 0, 20}, vGfade[2]={49, 0}, vG[3]={0, 0, 0}, vBfade[2]={49, 0}, vB[3]={0, 0, 0}, vRfade[2]={49, 0}, vR[3]={0, 0, 0};
int f4 = 0, f4BC[3]={0, 20, 0}, f4BPC[3]={0, 0, 20}, f4Gfade[2]={49, 0}, f4G[3]={0, 0, 0}, f4Bfade[2]={49, 0}, f4B[3]={0, 0, 0}, f4Rfade[2]={49, 0}, f4R[3]={0, 0, 0};
int four = 0, fourBC[3]={0, 20, 0}, fourBPC[3]={0, 0, 20}, fourGfade[2]={49, 0}, fourG[3]={0, 0, 0}, fourBfade[2]={49, 0}, fourB[3]={0, 0, 0}, fourRfade[2]={49, 0}, fourR[3]={0, 0, 0};
int r = 0, rBC[3]={0, 20, 0}, rBPC[3]={0, 0, 20}, rGfade[2]={49, 0}, rG[3]={0, 0, 0}, rBfade[2]={49, 0}, rB[3]={0, 0, 0}, rRfade[2]={49, 0}, rR[3]={0, 0, 0};
int f = 0, fBC[3]={0, 20, 0}, fBPC[3]={0, 0, 20}, fGfade[2]={49, 0}, fG[3]={0, 0, 0}, fBfade[2]={49, 0}, fB[3]={0, 0, 0}, fRfade[2]={49, 0}, fR[3]={0, 0, 0};
int b = 0, bBC[3]={0, 20, 0}, bBPC[3]={0, 0, 20}, bGfade[2]={49, 0}, bG[3]={0, 0, 0}, bBfade[2]={49, 0}, bB[3]={0, 0, 0}, bRfade[2]={49, 0}, bR[3]={0, 0, 0};
int space = 0, spaceBC[3]={0, 20, 0}, spaceBPC[3]={0, 0, 20}, spaceGfade[2]={49, 0}, spaceG[3]={0, 0, 0}, spaceBfade[2]={49, 0}, spaceB[3]={0, 0, 0}, spaceRfade[2]={49, 0}, spaceR[3]={0, 0, 0};
int five = 0, fiveBC[3]={0, 20, 0}, fiveBPC[3]={0, 0, 20}, fiveGfade[2]={49, 0}, fiveG[3]={0, 0, 0}, fiveBfade[2]={49, 0}, fiveB[3]={0, 0, 0}, fiveRfade[2]={49, 0}, fiveR[3]={0, 0, 0};
int six = 0, sixBC[3]={0, 20, 0}, sixBPC[3]={0, 0, 20}, sixGfade[2]={49, 0}, sixG[3]={0, 0, 0}, sixBfade[2]={49, 0}, sixB[3]={0, 0, 0}, sixRfade[2]={49, 0}, sixR[3]={0, 0, 0};
int y = 0, yBC[3]={0, 20, 0}, yBPC[3]={0, 0, 20}, yGfade[2]={49, 0}, yG[3]={0, 0, 0}, yBfade[2]={49, 0}, yB[3]={0, 0, 0}, yRfade[2]={49, 0}, yR[3]={0, 0, 0};
int t = 0, tBC[3]={0, 20, 0}, tBPC[3]={0, 0, 20}, tGfade[2]={49, 0}, tG[3]={0, 0, 0}, tBfade[2]={49, 0}, tB[3]={0, 0, 0}, tRfade[2]={49, 0}, tR[3]={0, 0, 0};
int h = 0, hBC[3]={0, 20, 0}, hBPC[3]={0, 0, 20}, hGfade[2]={49, 0}, hG[3]={0, 0, 0}, hBfade[2]={49, 0}, hB[3]={0, 0, 0}, hRfade[2]={49, 0}, hR[3]={0, 0, 0};
int g = 0, gBC[3]={0, 20, 0}, gBPC[3]={0, 0, 20}, gGfade[2]={49, 0}, gG[3]={0, 0, 0}, gBfade[2]={49, 0}, gB[3]={0, 0, 0}, gRfade[2]={49, 0}, gR[3]={0, 0, 0};
int f5 = 0, f5BC[3]={0, 20, 0}, f5BPC[3]={0, 0, 20}, f5Gfade[2]={49, 0}, f5G[3]={0, 0, 0}, f5Bfade[2]={49, 0}, f5B[3]={0, 0, 0}, f5Rfade[2]={49, 0}, f5R[3]={0, 0, 0};
int seven = 0, sevenBC[3]={0, 20, 0}, sevenBPC[3]={0, 0, 20}, sevenGfade[2]={49, 0}, sevenG[3]={0, 0, 0}, sevenBfade[2]={49, 0}, sevenB[3]={0, 0, 0}, sevenRfade[2]={49, 0}, sevenR[3]={0, 0, 0};
int u = 0, uBC[3]={0, 20, 0}, uBPC[3]={0, 0, 20}, uGfade[2]={49, 0}, uG[3]={0, 0, 0}, uBfade[2]={49, 0}, uB[3]={0, 0, 0}, uRfade[2]={49, 0}, uR[3]={0, 0, 0};
int i = 0, iBC[3]={0, 20, 0}, iBPC[3]={0, 0, 20}, iGfade[2]={49, 0}, iG[3]={0, 0, 0}, iBfade[2]={49, 0}, iB[3]={0, 0, 0}, iRfade[2]={49, 0}, iR[3]={0, 0, 0};
int j = 0, jBC[3]={0, 20, 0}, jBPC[3]={0, 0, 20}, jGfade[2]={49, 0}, jG[3]={0, 0, 0}, jBfade[2]={49, 0}, jB[3]={0, 0, 0}, jRfade[2]={49, 0}, jR[3]={0, 0, 0};
int n = 0, nBC[3]={0, 20, 0}, nBPC[3]={0, 0, 20}, nGfade[2]={49, 0}, nG[3]={0, 0, 0}, nBfade[2]={49, 0}, nB[3]={0, 0, 0}, nRfade[2]={49, 0}, nR[3]={0, 0, 0};
int f6 = 0, f6BC[3]={0, 20, 0}, f6BPC[3]={0, 0, 20}, f6Gfade[2]={49, 0}, f6G[3]={0, 0, 0}, f6Bfade[2]={49, 0}, f6B[3]={0, 0, 0}, f6Rfade[2]={49, 0}, f6R[3]={0, 0, 0};
int eight = 0, eightBC[3]={0, 20, 0}, eightBPC[3]={0, 0, 20}, eightGfade[2]={49, 0}, eightG[3]={0, 0, 0}, eightBfade[2]={49, 0}, eightB[3]={0, 0, 0}, eightRfade[2]={49, 0}, eightR[3]={0, 0, 0};
int nine = 0, nineBC[3]={0, 20, 0}, nineBPC[3]={0, 0, 20}, nineGfade[2]={49, 0}, nineG[3]={0, 0, 0}, nineBfade[2]={49, 0}, nineB[3]={0, 0, 0}, nineRfade[2]={49, 0}, nineR[3]={0, 0, 0};
int o = 0, oBC[3]={0, 20, 0}, oBPC[3]={0, 0, 20}, oGfade[2]={49, 0}, oG[3]={0, 0, 0}, oBfade[2]={49, 0}, oB[3]={0, 0, 0}, oRfade[2]={49, 0}, oR[3]={0, 0, 0};
int k = 0, kBC[3]={0, 20, 0}, kBPC[3]={0, 0, 20}, kGfade[2]={49, 0}, kG[3]={0, 0, 0}, kBfade[2]={49, 0}, kB[3]={0, 0, 0}, kRfade[2]={49, 0}, kR[3]={0, 0, 0};
int m = 0, mBC[3]={0, 20, 0}, mBPC[3]={0, 0, 20}, mGfade[2]={49, 0}, mG[3]={0, 0, 0}, mBfade[2]={49, 0}, mB[3]={0, 0, 0}, mRfade[2]={49, 0}, mR[3]={0, 0, 0};
int f7 = 0, f7BC[3]={0, 20, 0}, f7BPC[3]={0, 0, 20}, f7Gfade[2]={49, 0}, f7G[3]={0, 0, 0}, f7Bfade[2]={49, 0}, f7B[3]={0, 0, 0}, f7Rfade[2]={49, 0}, f7R[3]={0, 0, 0};
int zero = 0, zeroBC[3]={0, 20, 0}, zeroBPC[3]={0, 0, 20}, zeroGfade[2]={49, 0}, zeroG[3]={0, 0, 0}, zeroBfade[2]={49, 0}, zeroB[3]={0, 0, 0}, zeroRfade[2]={49, 0}, zeroR[3]={0, 0, 0};
int p = 0, pBC[3]={0, 20, 0}, pBPC[3]={0, 0, 20}, pGfade[2]={49, 0}, pG[3]={0, 0, 0}, pBfade[2]={49, 0}, pB[3]={0, 0, 0}, pRfade[2]={49, 0}, pR[3]={0, 0, 0};
int l = 0, lBC[3]={0, 20, 0}, lBPC[3]={0, 0, 20}, lGfade[2]={49, 0}, lG[3]={0, 0, 0}, lBfade[2]={49, 0}, lB[3]={0, 0, 0}, lRfade[2]={49, 0}, lR[3]={0, 0, 0};
int comma = 0, commaBC[3]={0, 20, 0}, commaBPC[3]={0, 0, 20}, commaGfade[2]={49, 0}, commaG[3]={0, 0, 0}, commaBfade[2]={49, 0}, commaB[3]={0, 0, 0}, commaRfade[2]={49, 0}, commaR[3]={0, 0, 0};
int ralt = 0, raltBC[3]={0, 20, 0}, raltBPC[3]={0, 0, 20}, raltGfade[2]={49, 0}, raltG[3]={0, 0, 0}, raltBfade[2]={49, 0}, raltB[3]={0, 0, 0}, raltRfade[2]={49, 0}, raltR[3]={0, 0, 0};
int f8 = 0, f8BC[3]={0, 20, 0}, f8BPC[3]={0, 0, 20}, f8Gfade[2]={49, 0}, f8G[3]={0, 0, 0}, f8Bfade[2]={49, 0}, f8B[3]={0, 0, 0}, f8Rfade[2]={49, 0}, f8R[3]={0, 0, 0};
int minus = 0, minusBC[3]={0, 20, 0}, minusBPC[3]={0, 0, 20}, minusGfade[2]={49, 0}, minusG[3]={0, 0, 0}, minusBfade[2]={49, 0}, minusB[3]={0, 0, 0}, minusRfade[2]={49, 0}, minusR[3]={0, 0, 0};
int lsqbracket = 0, lsqbracketBC[3]={0, 20, 0}, lsqbracketBPC[3]={0, 0, 20}, lsqbracketGfade[2]={49, 0}, lsqbracketG[3]={0, 0, 0}, lsqbracketBfade[2]={49, 0}, lsqbracketB[3]={0, 0, 0}, lsqbracketRfade[2]={49, 0}, lsqbracketR[3]={0, 0, 0};
int semicolon = 0, semicolonBC[3]={0, 20, 0}, semicolonBPC[3]={0, 0, 20}, semicolonGfade[2]={49, 0}, semicolonG[3]={0, 0, 0}, semicolonBfade[2]={49, 0}, semicolonB[3]={0, 0, 0}, semicolonRfade[2]={49, 0}, semicolonR[3]={0, 0, 0};
int period = 0, periodBC[3]={0, 20, 0}, periodBPC[3]={0, 0, 20}, periodGfade[2]={49, 0}, periodG[3]={0, 0, 0}, periodBfade[2]={49, 0}, periodB[3]={0, 0, 0}, periodRfade[2]={49, 0}, periodR[3]={0, 0, 0};
int rspecial = 0, rspecialBC[3]={0, 20, 0}, rspecialBPC[3]={0, 0, 20}, rspecialGfade[2]={49, 0}, rspecialG[3]={0, 0, 0}, rspecialBfade[2]={49, 0}, rspecialB[3]={0, 0, 0}, rspecialRfade[2]={49, 0}, rspecialR[3]={0, 0, 0};
int f9 = 0, f9BC[3]={0, 20, 0}, f9BPC[3]={0, 0, 20}, f9Gfade[2]={49, 0}, f9G[3]={0, 0, 0}, f9Bfade[2]={49, 0}, f9B[3]={0, 0, 0}, f9Rfade[2]={49, 0}, f9R[3]={0, 0, 0};
int equals = 0, equalsBC[3]={0, 20, 0}, equalsBPC[3]={0, 0, 20}, equalsGfade[2]={49, 0}, equalsG[3]={0, 0, 0}, equalsBfade[2]={49, 0}, equalsB[3]={0, 0, 0}, equalsRfade[2]={49, 0}, equalsR[3]={0, 0, 0};
int rsqbracket = 0, rsqbracketBC[3]={0, 20, 0}, rsqbracketBPC[3]={0, 0, 20}, rsqbracketGfade[2]={49, 0}, rsqbracketG[3]={0, 0, 0}, rsqbracketBfade[2]={49, 0}, rsqbracketB[3]={0, 0, 0}, rsqbracketRfade[2]={49, 0}, rsqbracketR[3]={0, 0, 0};
int apostrophe = 0, apostropheBC[3]={0, 20, 0}, apostropheBPC[3]={0, 0, 20}, apostropheGfade[2]={49, 0}, apostropheG[3]={0, 0, 0}, apostropheBfade[2]={49, 0}, apostropheB[3]={0, 0, 0}, apostropheRfade[2]={49, 0}, apostropheR[3]={0, 0, 0};
int fslash = 0, fslashBC[3]={0, 20, 0}, fslashBPC[3]={0, 0, 20}, fslashGfade[2]={49, 0}, fslashG[3]={0, 0, 0}, fslashBfade[2]={49, 0}, fslashB[3]={0, 0, 0}, fslashRfade[2]={49, 0}, fslashR[3]={0, 0, 0};
int menu = 0, menuBC[3]={0, 20, 0}, menuBPC[3]={0, 0, 20}, menuGfade[2]={49, 0}, menuG[3]={0, 0, 0}, menuBfade[2]={49, 0}, menuB[3]={0, 0, 0}, menuRfade[2]={49, 0}, menuR[3]={0, 0, 0};
int f10 = 0, f10BC[3]={0, 20, 0}, f10BPC[3]={0, 0, 20}, f10Gfade[2]={49, 0}, f10G[3]={0, 0, 0}, f10Bfade[2]={49, 0}, f10B[3]={0, 0, 0}, f10Rfade[2]={49, 0}, f10R[3]={0, 0, 0};
int backspace = 0, backspaceBC[3]={0, 20, 0}, backspaceBPC[3]={0, 0, 20}, backspaceGfade[2]={49, 0}, backspaceG[3]={0, 0, 0}, backspaceBfade[2]={49, 0}, backspaceB[3]={0, 0, 0}, backspaceRfade[2]={49, 0}, backspaceR[3]={0, 0, 0};
int bslash = 0, bslashBC[3]={0, 20, 0}, bslashBPC[3]={0, 0, 20}, bslashGfade[2]={49, 0}, bslashG[3]={0, 0, 0}, bslashBfade[2]={49, 0}, bslashB[3]={0, 0, 0}, bslashRfade[2]={49, 0}, bslashR[3]={0, 0, 0};
int enter = 0, enterBC[3]={0, 20, 0}, enterBPC[3]={0, 0, 20}, enterGfade[2]={49, 0}, enterG[3]={0, 0, 0}, enterBfade[2]={49, 0}, enterB[3]={0, 0, 0}, enterRfade[2]={49, 0}, enterR[3]={0, 0, 0};
int rshift = 0, rshiftBC[3]={0, 20, 0}, rshiftBPC[3]={0, 0, 20}, rshiftGfade[2]={49, 0}, rshiftG[3]={0, 0, 0}, rshiftBfade[2]={49, 0}, rshiftB[3]={0, 0, 0}, rshiftRfade[2]={49, 0}, rshiftR[3]={0, 0, 0};
int rctrl = 0, rctrlBC[3]={0, 20, 0}, rctrlBPC[3]={0, 0, 20}, rctrlGfade[2]={49, 0}, rctrlG[3]={0, 0, 0}, rctrlBfade[2]={49, 0}, rctrlB[3]={0, 0, 0}, rctrlRfade[2]={49, 0}, rctrlR[3]={0, 0, 0};
int f11 = 0, f11BC[3]={0, 20, 0}, f11BPC[3]={0, 0, 20}, f11Gfade[2]={49, 0}, f11G[3]={0, 0, 0}, f11Bfade[2]={49, 0}, f11B[3]={0, 0, 0}, f11Rfade[2]={49, 0}, f11R[3]={0, 0, 0};
int f12 = 0, f12BC[3]={0, 20, 0}, f12BPC[3]={0, 0, 20}, f12Gfade[2]={49, 0}, f12G[3]={0, 0, 0}, f12Bfade[2]={49, 0}, f12B[3]={0, 0, 0}, f12Rfade[2]={49, 0}, f12R[3]={0, 0, 0};
int up = 0, upBC[3]={0, 20, 0}, upBPC[3]={0, 0, 20}, upGfade[2]={49, 0}, upG[3]={0, 0, 0}, upBfade[2]={49, 0}, upB[3]={0, 0, 0}, upRfade[2]={49, 0}, upR[3]={0, 0, 0};
int down = 0, downBC[3]={0, 20, 0}, downBPC[3]={0, 0, 20}, downGfade[2]={49, 0}, downG[3]={0, 0, 0}, downBfade[2]={49, 0}, downB[3]={0, 0, 0}, downRfade[2]={49, 0}, downR[3]={0, 0, 0};
int right = 0, rightBC[3]={0, 20, 0}, rightBPC[3]={0, 0, 20}, rightGfade[2]={49, 0}, rightG[3]={0, 0, 0}, rightBfade[2]={49, 0}, rightB[3]={0, 0, 0}, rightRfade[2]={49, 0}, rightR[3]={0, 0, 0};
int left = 0, leftBC[3]={0, 20, 0}, leftBPC[3]={0, 0, 20}, leftGfade[2]={49, 0}, leftG[3]={0, 0, 0}, leftBfade[2]={49, 0}, leftB[3]={0, 0, 0}, leftRfade[2]={49, 0}, leftR[3]={0, 0, 0};
int insert = 0, insertBC[3]={0, 20, 0}, insertBPC[3]={0, 0, 20}, insertGfade[2]={49, 0}, insertG[3]={0, 0, 0}, insertBfade[2]={49, 0}, insertB[3]={0, 0, 0}, insertRfade[2]={49, 0}, insertR[3]={0, 0, 0};
int home = 0, homeBC[3]={0, 20, 0}, homeBPC[3]={0, 0, 20}, homeGfade[2]={49, 0}, homeG[3]={0, 0, 0}, homeBfade[2]={49, 0}, homeB[3]={0, 0, 0}, homeRfade[2]={49, 0}, homeR[3]={0, 0, 0};
int pageup = 0, pageupBC[3]={0, 20, 0}, pageupBPC[3]={0, 0, 20}, pageupGfade[2]={49, 0}, pageupG[3]={0, 0, 0}, pageupBfade[2]={49, 0}, pageupB[3]={0, 0, 0}, pageupRfade[2]={49, 0}, pageupR[3]={0, 0, 0};
int dlt = 0, dltBC[3]={0, 20, 0}, dltBPC[3]={0, 0, 20}, dltGfade[2]={49, 0}, dltG[3]={0, 0, 0}, dltBfade[2]={49, 0}, dltB[3]={0, 0, 0}, dltRfade[2]={49, 0}, dltR[3]={0, 0, 0};
int end = 0, endBC[3]={0, 20, 0}, endBPC[3]={0, 0, 20}, endGfade[2]={49, 0}, endG[3]={0, 0, 0}, endBfade[2]={49, 0}, endB[3]={0, 0, 0}, endRfade[2]={49, 0}, endR[3]={0, 0, 0};
int pagedown = 0, pagedownBC[3]={0, 20, 0}, pagedownBPC[3]={0, 0, 20}, pagedownGfade[2]={49, 0}, pagedownG[3]={0, 0, 0}, pagedownBfade[2]={49, 0}, pagedownB[3]={0, 0, 0}, pagedownRfade[2]={49, 0}, pagedownR[3]={0, 0, 0};
int macro = 0, macroS = 0, macroS1BC[3]={20, 0, 0},macroS2BC[3]={20, 20, 20}, macroBC[3]={0, 20, 0}, macroBPC[3]={0, 0, 20}, macroGfade[2]={49, 0}, macroG[3]={0, 0, 0}, macroBfade[2]={49, 0}, macroB[3]={0, 0, 0}, macroRfade[2]={49, 0}, macroR[3]={0, 0, 0}, macroFKBPCV[39]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int numlock = 0, numlockBC[3]={0, 20, 0}, numlockBPC[3]={0, 0, 20}, numlockGfade[2]={49, 0}, numlockG[3]={0, 0, 0}, numlockBfade[2]={49, 0}, numlockB[3]={0, 0, 0}, numlockRfade[2]={49, 0}, numlockR[3]={0, 0, 0};
int num7 = 0, num7BC[3]={0, 20, 0}, num7BPC[3]={0, 0, 20}, num7Gfade[2]={49, 0}, num7G[3]={0, 0, 0}, num7Bfade[2]={49, 0}, num7B[3]={0, 0, 0}, num7Rfade[2]={49, 0}, num7R[3]={0, 0, 0};
int num4 = 0, num4BC[3]={0, 20, 0}, num4BPC[3]={0, 0, 20}, num4Gfade[2]={49, 0}, num4G[3]={0, 0, 0}, num4Bfade[2]={49, 0}, num4B[3]={0, 0, 0}, num4Rfade[2]={49, 0}, num4R[3]={0, 0, 0};
int num1 = 0, num1BC[3]={0, 20, 0}, num1BPC[3]={0, 0, 20}, num1Gfade[2]={49, 0}, num1G[3]={0, 0, 0}, num1Bfade[2]={49, 0}, num1B[3]={0, 0, 0}, num1Rfade[2]={49, 0}, num1R[3]={0, 0, 0};
int num0 = 0, num0BC[3]={0, 20, 0}, num0BPC[3]={0, 0, 20}, num0Gfade[2]={49, 0}, num0G[3]={0, 0, 0}, num0Bfade[2]={49, 0}, num0B[3]={0, 0, 0}, num0Rfade[2]={49, 0}, num0R[3]={0, 0, 0};
int bright = 0, brightBC[3]={0, 20, 0}, brightBPC[3]={0, 0, 20}, brightGfade[2]={49, 0}, brightG[3]={0, 0, 0}, brightBfade[2]={49, 0}, brightB[3]={0, 0, 0}, brightRfade[2]={49, 0}, brightR[3]={0, 0, 0};
int numfslash = 0, numfslashBC[3]={0, 20, 0}, numfslashBPC[3]={0, 0, 20}, numfslashGfade[2]={49, 0}, numfslashG[3]={0, 0, 0}, numfslashBfade[2]={49, 0}, numfslashB[3]={0, 0, 0}, numfslashRfade[2]={49, 0}, numfslashR[3]={0, 0, 0};
int num8 = 0, num8BC[3]={0, 20, 0}, num8BPC[3]={0, 0, 20}, num8Gfade[2]={49, 0}, num8G[3]={0, 0, 0}, num8Bfade[2]={49, 0}, num8B[3]={0, 0, 0}, num8Rfade[2]={49, 0}, num8R[3]={0, 0, 0};
int num5 = 0, num5BC[3]={0, 20, 0}, num5BPC[3]={0, 0, 20}, num5Gfade[2]={49, 0}, num5G[3]={0, 0, 0}, num5Bfade[2]={49, 0}, num5B[3]={0, 0, 0}, num5Rfade[2]={49, 0}, num5R[3]={0, 0, 0};
int num2 = 0, num2BC[3]={0, 20, 0}, num2BPC[3]={0, 0, 20}, num2Gfade[2]={49, 0}, num2G[3]={0, 0, 0}, num2Bfade[2]={49, 0}, num2B[3]={0, 0, 0}, num2Rfade[2]={49, 0}, num2R[3]={0, 0, 0};
int numperiod = 0, numperiodBC[3]={0, 20, 0}, numperiodBPC[3]={0, 0, 20}, numperiodGfade[2]={49, 0}, numperiodG[3]={0, 0, 0}, numperiodBfade[2]={49, 0}, numperiodB[3]={0, 0, 0}, numperiodRfade[2]={49, 0}, numperiodR[3]={0, 0, 0};
int mute = 0, muteBC[3]={0, 20, 0}, muteBPC[3]={0, 0, 20}, muteGfade[2]={49, 0}, muteG[3]={0, 0, 0}, muteBfade[2]={49, 0}, muteB[3]={0, 0, 0}, muteRfade[2]={49, 0}, muteR[3]={0, 0, 0};
int asterisk = 0, asteriskBC[3]={0, 20, 0}, asteriskBPC[3]={0, 0, 20}, asteriskGfade[2]={49, 0}, asteriskG[3]={0, 0, 0}, asteriskBfade[2]={49, 0}, asteriskB[3]={0, 0, 0}, asteriskRfade[2]={49, 0}, asteriskR[3]={0, 0, 0};
int num9 = 0, num9BC[3]={0, 20, 0}, num9BPC[3]={0, 0, 20}, num9Gfade[2]={49, 0}, num9G[3]={0, 0, 0}, num9Bfade[2]={49, 0}, num9B[3]={0, 0, 0}, num9Rfade[2]={49, 0}, num9R[3]={0, 0, 0};
int num6 = 0, num6BC[3]={0, 20, 0}, num6BPC[3]={0, 0, 20}, num6Gfade[2]={49, 0}, num6G[3]={0, 0, 0}, num6Bfade[2]={49, 0}, num6B[3]={0, 0, 0}, num6Rfade[2]={49, 0}, num6R[3]={0, 0, 0};
int num3 = 0, num3BC[3]={0, 20, 0}, num3BPC[3]={0, 0, 20}, num3Gfade[2]={49, 0}, num3G[3]={0, 0, 0}, num3Bfade[2]={49, 0}, num3B[3]={0, 0, 0}, num3Rfade[2]={49, 0}, num3R[3]={0, 0, 0};
int numenter = 0, numenterBC[3]={0, 20, 0}, numenterBPC[3]={0, 0, 20}, numenterGfade[2]={49, 0}, numenterG[3]={0, 0, 0}, numenterBfade[2]={49, 0}, numenterB[3]={0, 0, 0}, numenterRfade[2]={49, 0}, numenterR[3]={0, 0, 0};
int prtscrn = 0, prtscrnBC[3]={0, 20, 0}, prtscrnBPC[3]={0, 0, 20}, prtscrnGfade[2]={49, 0}, prtscrnG[3]={0, 0, 0}, prtscrnBfade[2]={49, 0}, prtscrnB[3]={0, 0, 0}, prtscrnRfade[2]={49, 0}, prtscrnR[3]={0, 0, 0};
int scrolllock = 0, scrolllockBC[3]={0, 20, 0}, scrolllockBPC[3]={0, 0, 20}, scrolllockGfade[2]={49, 0}, scrolllockG[3]={0, 0, 0}, scrolllockBfade[2]={49, 0}, scrolllockB[3]={0, 0, 0}, scrolllockRfade[2]={49, 0}, scrolllockR[3]={0, 0, 0};
int pause = 0, pauseBC[3]={0, 20, 0}, pauseBPC[3]={0, 0, 20}, pauseGfade[2]={49, 0}, pauseG[3]={0, 0, 0}, pauseBfade[2]={49, 0}, pauseB[3]={0, 0, 0}, pauseRfade[2]={49, 0}, pauseR[3]={0, 0, 0};
int numminus = 0, numminusBC[3]={0, 20, 0}, numminusBPC[3]={0, 0, 20}, numminusGfade[2]={49, 0}, numminusG[3]={0, 0, 0}, numminusBfade[2]={49, 0}, numminusB[3]={0, 0, 0}, numminusRfade[2]={49, 0}, numminusR[3]={0, 0, 0};
int plus = 0, plusBC[3]={0, 20, 0}, plusBPC[3]={0, 0, 20}, plusGfade[2]={49, 0}, plusG[3]={0, 0, 0}, plusBfade[2]={49, 0}, plusB[3]={0, 0, 0}, plusRfade[2]={49, 0}, plusR[3]={0, 0, 0};
void sh_cp(int cdata);
void st_cp();
int fader_state(int key, int keyBC, int keyBPC, int* keyCfadestep, int* keyCfadetime, int* keyCtime, int* keyCstate, int* keyCdcs);
void sh_cp(int cdata) //input rdata and cdata states into the 74HC595 chips, if cdata is 1 make cdata state high then low
{
if (cdata == 0) //if cdata is 0 pulse clock pin
{
PORTA |= (1<<PA2); //set clock pin high
PORTA &= ~(1<<PA2); //set clock pin low
} //end if (cdata == 0)
else
{
PORTA |= (1<<PA1); //set cdata pin high
PORTA |= (1<<PA2); //set clock pin high
PORTA &= ~(1<<PA2); //set clock pin low
PORTA &= ~(1<<PA1); //set cdata pin high
}
} //end sh_cp() function
void st_cp() //latch all 74HC595 states
{
PORTA |= (1<<PA3); //set latch pin high
PORTA &= ~(1<<PA3); //set latch pin low
} //end st_cp() function
int fader_state(int key, int keyBC, int keyBPC, int* keyCfadestep, int* keyCfadetime, int* keyCtime, int* keyCstate, int* keyCdcs) //key fader and LED color function
{
if (key==1) //if key is pressed
{
if (keyBPC > 0) //if keyButtonPressColor is on
{
*keyCtime = keyBPC; //reset fader and key duty cycle to beginning state of keyButtonPressColor
*keyCstate = 1;
*keyCdcs = 0;
*keyCfadestep = 1;
} //end if (keyBPC > 0)
else
{
*keyCtime = 20; //reset fader to off state and reset key duty cycle
*keyCstate = 0;
*keyCdcs = 0;
*keyCfadestep = 49;
} //end else
} //end if (key==1)
else
{
if (*keyCdcs==2) //if LED has completed duty cycle
{
if (*keyCfadestep < 49) //if fader timer has not run out
{
if (keyBPC < keyBC) //if keyButtonPressColor is smaller than keyButtonColor
{
*keyCfadetime = keyBC - keyBPC; //math to figure out time on in duty cycle
*keyCfadetime /= 49;
*keyCfadetime *= *keyCfadestep;
*keyCfadetime = keyBC - *keyCfadetime;
*keyCtime = *keyCfadetime;
} //end if (keyBPC < keyBC)
else if (keyBPC > keyBC) //if keyButtonPressColor is bigger than keyButtonColor
{
*keyCfadetime = keyBPC - keyBC; //math to figure out time on in duty cycle
*keyCfadetime /= 49;
*keyCfadetime *= *keyCfadestep;
*keyCtime = *keyCfadetime;
} //end else if (keyBPC > keyBC)
else
{
*keyCtime = keyBC; //if keyButtonPressColor and keyButtonColor are the same put keyButtonColor in effect
*keyCstate = 1;
*keyCfadestep = 48;
} //end else
++*keyCfadestep;
} //end if (*keyCfadestep < 49)
else
{
if (keyBC > 0) //if keyButtonColor is on
{
*keyCtime = keyBC; //make keyColortime state of keyButtonColor and keyCstate 1
*keyCstate = 1;
} //end if (keyBC > 0)
else
{
*keyCtime = 20; //make keyColortime full duty cycle and keyCstate to 0
*keyCstate = 0;
} //end else
} //end else
*keyCdcs = 0; //make keyCdutycyclestate 0 to start new duty cycle
} //end if (*keyCdcs==2)
else if (*keyCdcs==1 && *keyCtime==0) //if LED is done with first stage of duty cycle
{
if (*keyCfadestep < 49) //if keyColorfadestep is below 49
*keyCtime = 20 - *keyCfadetime; //math for time left until end of duty cycle
else
*keyCtime = 20 - keyBC; //math for time left until end of duty cycle
*keyCstate = 0;//make key finish second stage of duty cycle off
}
else if (*keyCdcs==0 && *keyCtime==0) //if LED is ready to begin first duty cycle
{
if (keyBC > 0) //if keyButtonColor is on
{
*keyCtime = keyBC; //make keyColortime state of keyButtonColor and keyCstate 1
*keyCstate = 1;
} //end if (keyBC > 0)
else
{
*keyCtime = 20; //make keyColortime full duty cycle and keyCstate to 0
*keyCstate = 0;
} //end else
} //end else if (*keyCdcs==0 && *keyCtime==0)
} //end else
if (*keyCstate==1) //if keyColorstate is 1
{
PORTA |= (1<<PA0); //rdata on
--*keyCtime; //increment keyColortime
if (*keyCtime==0||*keyCtime==19) //if keyColortime is 0 or 19
{
++*keyCdcs; //increment keyColordutycyclestate
} //end if (*keyCtime==0||*keyCtime==19)
} //if (*keyCstate==1)
else
{
PORTA &= ~(1<<PA0); //rdata off
--*keyCtime; //increment keyColortime
if (*keyCtime==0||*keyCtime==19) //if keyColortime is 0 or 19
{
++*keyCdcs; //increment keyColordutycyclestate
} //end if (*keyCtime==0||*keyCtime==19)
} //else
} //end fader_state() function
int main(void)
{
DDRA = (1<<PA0)|(1<<PA1)|(1<<PA2)|(1<<PA3);
PORTA = (0<<PA0)|(0<<PA1)|(0<<PA2)|(0<<PA3);
while(1)
{
if (row==0)
{
PORTA |= (1<<0);
esc = PINA0;
tilda = PINA1;
tab = PINA2;
caps = PINA3;
lshift = PINA4;
lctrl = PINA5;
f1 = PINA6;
one = PINA7;
q = PINA8;
a = PINA9;
PORTA &= ~(1<<0);
row++;
}
else if (row==1)
{
PORTA |= (1<<1);
z = PINA0;
lspecial = PINA1;
f2 = PINA2;
two = PINA3;
w = PINA4;
s = PINA5;
x = PINA6;
lalt = PINA7;
f3 = PINA8;
three = PINA9;
PORTA &= ~(1<<1);
row++;
}
else if (row==2)
{
PORTA |= (1<<2);
e = PINA0;
d = PINA1;
c = PINA2;
v = PINA3;
f4 = PINA4;
four = PINA5;
r = PINA6;
f = PINA7;
b = PINA8;
space = PINA9;
PORTA &= ~(1<<2);
row++;
}
else if (row==3)
{
PORTA |= (1<<3);
five = PINA0;
six = PINA1;
y = PINA2;
t = PINA3;
h = PINA4;
g = PINA5;
f5 = PINA6;
seven = PINA7;
u = PINA8;
i = PINA9;
PORTA &= ~(1<<3);
row++;
}
else if (row==4)
{
PORTA |= (1<<4);
j = PINA0;
n = PINA1;
f6 = PINA2;
eight = PINA3;
nine = PINA4;
o = PINA5;
k = PINA6;
m = PINA7;
f7 = PINA8;
zero = PINA9;
PORTA &= ~(1<<4);
row++;
}
else if (row==5)
{
PORTA |= (1<<5);
p = PINA0;
l = PINA1;
comma = PINA2;
ralt = PINA3;
f8 = PINA4;
minus = PINA5;
lsqbracket = PINA6;
semicolon = PINA7;
period = PINA8;
rspecial = PINA9;
PORTA &= ~(1<<5);
row++;
}
else if (row==6)
{
PORTA |= (1<<6);
f9 = PINA0;
equals = PINA1;
rsqbracket = PINA2;
apostrophe = PINA3;
fslash = PINA4;
menu = PINA5;
f10 = PINA6;
backspace = PINA7;
bslash = PINA8;
enter = PINA9;
PORTA &= ~(1<<6);
row++;
}
else if (row==7)
{
PORTA |= (1<<7);
rshift = PINA0;
rctrl = PINA1;
f11 = PINA2;
f12 = PINA3;
up = PINA4;
down = PINA5;
right = PINA6;
left = PINA7;
insert = PINA8;
home = PINA9;
PORTA &= ~(1<<7);
row++;
}
else if (row==8)
{
PORTA |= (1<<8);
pageup = PINA0;
dlt = PINA1;
end = PINA2;
pagedown = PINA3;
macro = PINA4;
numlock = PINA5;
num7 = PINA6;
num4 = PINA7;
num1 = PINA8;
num0 = PINA9;
PORTA &= ~(1<<8);
row++;
}
else if (row==9)
{
PORTA |= (1<<9);
bright = PINA0;
numfslash = PINA1;
num8 = PINA2;
num5 = PINA3;
num2 = PINA4;
numperiod = PINA5;
mute = PINA6;
asterisk = PINA7;
num9 = PINA8;
num6 = PINA9;
PORTA &= ~(1<<9);
row++;
}
else if (row==10)
{
PORTA |= (1<<10);
num3 = PINA0;
numenter = PINA1;
prtscrn = PINA2;
scrolllock = PINA3;
pause = PINA4;
numminus = PINA5;
plus = PINA6;
PORTA &= ~(1<<10);
row = 0;
}
if (column==0)
{
fader_state(esc, escBC[0], escBPC[0], &escGfade[0], &escGfade[1], &escG[0], &escG[1], &escG[2]); //the fader state function sets the rdata pin for this clock cycle
sh_cp(1); //the sh_cp function sets the state of cdata low if sent 0, and high if 1 as well as setting the clock pin
fader_state(esc, escBC[1], escBPC[1], &escBfade[0], &escBfade[1], &escB[0], &escB[1], &escB[2]);
sh_cp(0);
fader_state(esc, escBC[2], escBPC[2], &escRfade[0], &escRfade[1], &escR[0], &escR[1], &escR[2]);
sh_cp(0);
fader_state(tilda, tildaBC[0], tildaBPC[0], &tildaGfade[0], &tildaGfade[1], &tildaG[0], &tildaG[1], &tildaG[2]);
sh_cp(0);
fader_state(tilda, tildaBC[1], tildaBPC[1], &tildaBfade[0], &tildaBfade[1], &tildaB[0], &tildaB[1], &tildaB[2]);
sh_cp(0);
fader_state(tilda, tildaBC[2], tildaBPC[2], &tildaRfade[0], &tildaRfade[1], &tildaR[0], &tildaR[1], &tildaR[2]);
sh_cp(0);
fader_state(tab, tabBC[0], tabBPC[0], &tabGfade[0], &tabGfade[1], &tabG[0], &tabG[1], &tabG[2]);
sh_cp(0);
fader_state(tab, tabBC[1], tabBPC[1], &tabBfade[0], &tabBfade[1], &tabB[0], &tabB[1], &tabB[2]);
sh_cp(0);
fader_state(tab, tabBC[2], tabBPC[2], &tabRfade[0], &tabRfade[1], &tabR[0], &tabR[1], &tabR[2]);
sh_cp(0);
fader_state(caps, capsBC[0], capsBPC[0], &capsGfade[0], &capsGfade[1], &capsG[0], &capsG[1], &capsG[2]);
sh_cp(0);
fader_state(caps, capsBC[1], capsBPC[1], &capsBfade[0], &capsBfade[1], &capsB[0], &capsB[1], &capsB[2]);
sh_cp(0);
fader_state(caps, capsBC[2], capsBPC[2], &capsRfade[0], &capsRfade[1], &capsR[0], &capsR[1], &capsR[2]);
sh_cp(0);
fader_state(lshift, lshiftBC[0], lshiftBPC[0], &lshiftGfade[0], &lshiftGfade[1], &lshiftG[0], &lshiftG[1], &lshiftG[2]);
sh_cp(0);
fader_state(lshift, lshiftBC[1], lshiftBPC[1], &lshiftBfade[0], &lshiftBfade[1], &lshiftB[0], &lshiftB[1], &lshiftB[2]);
sh_cp(0);
fader_state(lshift, lshiftBC[2], lshiftBPC[2], &lshiftRfade[0], &lshiftRfade[1], &lshiftR[0], &lshiftR[1], &lshiftR[2]);
sh_cp(0);
fader_state(lctrl, lctrlBC[0], lctrlBPC[0], &lctrlGfade[0], &lctrlGfade[1], &lctrlG[0], &lctrlG[1], &lctrlG[2]);
sh_cp(0);
fader_state(lctrl, lctrlBC[1], lctrlBPC[1], &lctrlBfade[0], &lctrlBfade[1], &lctrlB[0], &lctrlB[1], &lctrlB[2]);
sh_cp(0);
fader_state(lctrl, lctrlBC[2], lctrlBPC[2], &lctrlRfade[0], &lctrlRfade[1], &lctrlR[0], &lctrlR[1], &lctrlR[2]);
sh_cp(0);
st_cp();
column++;
} //end else if (column==0)
else if (column==1)
{
fader_state(f1, f1BC[0], f1BPC[0], &f1Gfade[0], &f1Gfade[1], &f1G[0], &f1G[1], &f1G[2]);
sh_cp(0);
fader_state(f1, f1BC[1], f1BPC[1], &f1Bfade[0], &f1Bfade[1], &f1B[0], &f1B[1], &f1B[2]);
sh_cp(1);
fader_state(f1, f1BC[2], f1BPC[2], &f1Rfade[0], &f1Rfade[1], &f1R[0], &f1R[1], &f1R[2]);
sh_cp(0);
fader_state(one, oneBC[0], oneBPC[0], &oneGfade[0], &oneGfade[1], &oneG[0], &oneG[1], &oneG[2]);
sh_cp(0);
fader_state(one, oneBC[1], oneBPC[1], &oneBfade[0], &oneBfade[1], &oneB[0], &oneB[1], &oneB[2]);
sh_cp(0);
fader_state(one, oneBC[2], oneBPC[2], &oneRfade[0], &oneRfade[1], &oneR[0], &oneR[1], &oneR[2]);
sh_cp(0);
fader_state(q, qBC[0], qBPC[0], &qGfade[0], &qGfade[1], &qG[0], &qG[1], &qG[2]);
sh_cp(0);
fader_state(q, qBC[1], qBPC[1], &qBfade[0], &qBfade[1], &qB[0], &qB[1], &qB[2]);
sh_cp(0);
fader_state(q, qBC[2], qBPC[2], &qRfade[0], &qRfade[1], &qR[0], &qR[1], &qR[2]);
sh_cp(0);
fader_state(a, aBC[0], aBPC[0], &aGfade[0], &aGfade[1], &aG[0], &aG[1], &aG[2]);
sh_cp(0);
fader_state(a, aBC[1], aBPC[1], &aBfade[0], &aBfade[1], &aB[0], &aB[1], &aB[2]);
sh_cp(0);
fader_state(a, aBC[2], aBPC[2], &aRfade[0], &aRfade[1], &aR[0], &aR[1], &aR[2]);
sh_cp(0);
fader_state(z, zBC[0], zBPC[0], &zGfade[0], &zGfade[1], &zG[0], &zG[1], &zG[2]);
sh_cp(0);
fader_state(z, zBC[1], zBPC[1], &zBfade[0], &zBfade[1], &zB[0], &zB[1], &zB[2]);
sh_cp(0);
fader_state(z, zBC[2], zBPC[2], &zRfade[0], &zRfade[1], &zR[0], &zR[1], &zR[2]);
sh_cp(0);
fader_state(lspecial, lspecialBC[0], lspecialBPC[0], &lspecialGfade[0], &lspecialGfade[1], &lspecialG[0], &lspecialG[1], &lspecialG[2]);
sh_cp(0);
fader_state(lspecial, lspecialBC[1], lspecialBPC[1], &lspecialBfade[0], &lspecialBfade[1], &lspecialB[0], &lspecialB[1], &lspecialB[2]);
sh_cp(0);
fader_state(lspecial, lspecialBC[2], lspecialBPC[2], &lspecialRfade[0], &lspecialRfade[1], &lspecialR[0], &lspecialR[1], &lspecialR[2]);
sh_cp(0);
st_cp();
column++;
} //end else if (column==1)
else if (column==2)
{
fader_state(f2, f2BC[0], f2BPC[0], &f2Gfade[0], &f2Gfade[1], &f2G[0], &f2G[1], &f2G[2]);
sh_cp(0);
fader_state(f2, f2BC[1], f2BPC[1], &f2Bfade[0], &f2Bfade[1], &f2B[0], &f2B[1], &f2B[2]);
sh_cp(0);
fader_state(f2, f2BC[2], f2BPC[2], &f2Rfade[0], &f2Rfade[1], &f2R[0], &f2R[1], &f2R[2]);
sh_cp(1);
fader_state(two, twoBC[0], twoBPC[0], &twoGfade[0], &twoGfade[1], &twoG[0], &twoG[1], &twoG[2]);
sh_cp(0);
fader_state(two, twoBC[1], twoBPC[1], &twoBfade[0], &twoBfade[1], &twoB[0], &twoB[1], &twoB[2]);
sh_cp(0);
fader_state(two, twoBC[2], twoBPC[2], &twoRfade[0], &twoRfade[1], &twoR[0], &twoR[1], &twoR[2]);
sh_cp(0);
fader_state(w, wBC[0], wBPC[0], &wGfade[0], &wGfade[1], &wG[0], &wG[1], &wG[2]);
sh_cp(0);
fader_state(w, wBC[1], wBPC[1], &wBfade[0], &wBfade[1], &wB[0], &wB[1], &wB[2]);
sh_cp(0);
fader_state(w, wBC[2], wBPC[2], &wRfade[0], &wRfade[1], &wR[0], &wR[1], &wR[2]);
sh_cp(0);
fader_state(s, sBC[0], sBPC[0], &sGfade[0], &sGfade[1], &sG[0], &sG[1], &sG[2]);
sh_cp(0);
fader_state(s, sBC[1], sBPC[1], &sBfade[0], &sBfade[1], &sB[0], &sB[1], &sB[2]);
sh_cp(0);
fader_state(s, sBC[2], sBPC[2], &sRfade[0], &sRfade[1], &sR[0], &sR[1], &sR[2]);
sh_cp(0);
fader_state(x, xBC[0], xBPC[0], &xGfade[0], &xGfade[1], &xG[0], &xG[1], &xG[2]);
sh_cp(0);
fader_state(x, xBC[1], xBPC[1], &xBfade[0], &xBfade[1], &xB[0], &xB[1], &xB[2]);
sh_cp(0);
fader_state(x, xBC[2], xBPC[2], &xRfade[0], &xRfade[1], &xR[0], &xR[1], &xR[2]);
sh_cp(0);
fader_state(lalt, laltBC[0], laltBPC[0], &laltGfade[0], &laltGfade[1], &laltG[0], &laltG[1], &laltG[2]);
sh_cp(0);
fader_state(lalt, laltBC[1], laltBPC[1], &laltBfade[0], &laltBfade[1], &laltB[0], &laltB[1], &laltB[2]);
sh_cp(0);
fader_state(lalt, laltBC[2], laltBPC[2], &laltRfade[0], &laltRfade[1], &laltR[0], &laltR[1], &laltR[2]);
sh_cp(0);
st_cp();
column++;
} //end else if (column==2)
else if (column==3)
{
fader_state(f3, f3BC[0], f3BPC[0], &f3Gfade[0], &f3Gfade[1], &f3G[0], &f3G[1], &f3G[2]);
sh_cp(0);
fader_state(f3, f3BC[1], f3BPC[1], &f3Bfade[0], &f3Bfade[1], &f3B[0], &f3B[1], &f3B[2]);
sh_cp(0);
fader_state(f3, f3BC[2], f3BPC[2], &f3Rfade[0], &f3Rfade[1], &f3R[0], &f3R[1], &f3R[2]);
sh_cp(0);
fader_state(three, threeBC[0], threeBPC[0], &threeGfade[0], &threeGfade[1], &threeG[0], &threeG[1], &threeG[2]);
sh_cp(1);
fader_state(three, threeBC[1], threeBPC[1], &threeBfade[0], &threeBfade[1], &threeB[0], &threeB[1], &threeB[2]);
sh_cp(0);
fader_state(three, threeBC[2], threeBPC[2], &threeRfade[0], &threeRfade[1], &threeR[0], &threeR[1], &threeR[2]);
sh_cp(0);
fader_state(e, eBC[0], eBPC[0], &eGfade[0], &eGfade[1], &eG[0], &eG[1], &eG[2]);
sh_cp(0);
fader_state(e, eBC[1], eBPC[1], &eBfade[0], &eBfade[1], &eB[0], &eB[1], &eB[2]);
sh_cp(0);
fader_state(e, eBC[2], eBPC[2], &eRfade[0], &eRfade[1], &eR[0], &eR[1], &eR[2]);
sh_cp(0);
fader_state(d, dBC[0], dBPC[0], &dGfade[0], &dGfade[1], &dG[0], &dG[1], &dG[2]);
sh_cp(0);
fader_state(d, dBC[1], dBPC[1], &dBfade[0], &dBfade[1], &dB[0], &dB[1], &dB[2]);
sh_cp(0);
fader_state(d, dBC[2], dBPC[2], &dRfade[0], &dRfade[1], &dR[0], &dR[1], &dR[2]);
sh_cp(0);
fader_state(c, cBC[0], cBPC[0], &cGfade[0], &cGfade[1], &cG[0], &cG[1], &cG[2]);
sh_cp(0);
fader_state(c, cBC[1], cBPC[1], &cBfade[0], &cBfade[1], &cB[0], &cB[1], &cB[2]);
sh_cp(0);
fader_state(c, cBC[2], cBPC[2], &cRfade[0], &cRfade[1], &cR[0], &cR[1], &cR[2]);
sh_cp(0);
fader_state(v, vBC[0], vBPC[0], &vGfade[0], &vGfade[1], &vG[0], &vG[1], &vG[2]);
sh_cp(0);
fader_state(v, vBC[1], vBPC[1], &vBfade[0], &vBfade[1], &vB[0], &vB[1], &vB[2]);
sh_cp(0);
fader_state(v, vBC[2], vBPC[2], &vRfade[0], &vRfade[1], &vR[0], &vR[1], &vR[2]);
sh_cp(0);
st_cp();
column++;
} //end else if (column==3)
else if (column==4)
{
fader_state(f, fBC[0], fBPC[0], &fGfade[0], &fGfade[1], &fG[0], &fG[1], &fG[2]);
sh_cp(0);
fader_state(f, fBC[1], fBPC[1], &fBfade[0], &fBfade[1], &fB[0], &fB[1], &fB[2]);
sh_cp(0);
fader_state(f, fBC[2], fBPC[2], &fRfade[0], &fRfade[1], &fR[0], &fR[1], &fR[2]);
sh_cp(0);
fader_state(four, fourBC[0], fourBPC[0], &fourGfade[0], &fourGfade[1], &fourG[0], &fourG[1], &fourG[2]);
sh_cp(0);
fader_state(four, fourBC[1], fourBPC[1], &fourBfade[0], &fourBfade[1], &fourB[0], &fourB[1], &fourB[2]);
sh_cp(1);
fader_state(four, fourBC[2], fourBPC[2], &fourRfade[0], &fourRfade[1], &fourR[0], &fourR[1], &fourR[2]);
sh_cp(0);
fader_state(r, rBC[0], rBPC[0], &rGfade[0], &rGfade[1], &rG[0], &rG[1], &rG[2]);
sh_cp(0);
fader_state(r, rBC[1], rBPC[1], &rBfade[0], &rBfade[1], &rB[0], &rB[1], &rB[2]);
sh_cp(0);
fader_state(r, rBC[2], rBPC[2], &rRfade[0], &rRfade[1], &rR[0], &rR[1], &rR[2]);
sh_cp(0);
fader_state(f, fBC[0], fBPC[0], &fGfade[0], &fGfade[1], &fG[0], &fG[1], &fG[2]);
sh_cp(0);
fader_state(f, fBC[1], fBPC[1], &fBfade[0], &fBfade[1], &fB[0], &fB[1], &fB[2]);
sh_cp(0);
fader_state(f, fBC[2], fBPC[2], &fRfade[0], &fRfade[1], &fR[0], &fR[1], &fR[2]);
sh_cp(0);
fader_state(b, bBC[0], bBPC[0], &bGfade[0], &bGfade[1], &bG[0], &bG[1], &bG[2]);
sh_cp(0);
fader_state(b, bBC[1], bBPC[1], &bBfade[0], &bBfade[1], &bB[0], &bB[1], &bB[2]);
sh_cp(0);
fader_state(b, bBC[2], bBPC[2], &bRfade[0], &bRfade[1], &bR[0], &bR[1], &bR[2]);
sh_cp(0);
fader_state(space, spaceBC[0], spaceBPC[0], &spaceGfade[0], &spaceGfade[1], &spaceG[0], &spaceG[1], &spaceG[2]);
sh_cp(0);
fader_state(space, spaceBC[1], spaceBPC[1], &spaceBfade[0], &spaceBfade[1], &spaceB[0], &spaceB[1], &spaceB[2]);
sh_cp(0);
fader_state(space, spaceBC[2], spaceBPC[2], &spaceRfade[0], &spaceRfade[1], &spaceR[0], &spaceR[1], &spaceR[2]);
sh_cp(0);
st_cp();
column++;
} //end else if (column==4)
else if (column==5)
{
fader_state(five, fiveBC[0], fiveBPC[0], &fiveGfade[0], &fiveGfade[1], &fiveG[0], &fiveG[1], &fiveG[2]);
sh_cp(0);
fader_state(five, fiveBC[1], fiveBPC[1], &fiveBfade[0], &fiveBfade[1], &fiveB[0], &fiveB[1], &fiveB[2]);
sh_cp(0);
fader_state(five, fiveBC[2], fiveBPC[2], &fiveRfade[0], &fiveRfade[1], &fiveR[0], &fiveR[1], &fiveR[2]);
sh_cp(0);
fader_state(six, sixBC[0], sixBPC[0], &sixGfade[0], &sixGfade[1], &sixG[0], &sixG[1], &sixG[2]);
sh_cp(0);
fader_state(six, sixBC[1], sixBPC[1], &sixBfade[0], &sixBfade[1], &sixB[0], &sixB[1], &sixB[2]);
sh_cp(0);
fader_state(six, sixBC[2], sixBPC[2], &sixRfade[0], &sixRfade[1], &sixR[0], &sixR[1], &sixR[2]);
sh_cp(1);
fader_state(t, tBC[0], tBPC[0], &tGfade[0], &tGfade[1], &tG[0], &tG[1], &tG[2]);
sh_cp(0);
fader_state(t, tBC[1], tBPC[1], &tBfade[0], &tBfade[1], &tB[0], &tB[1], &tB[2]);
sh_cp(0);
fader_state(t, tBC[2], tBPC[2], &tRfade[0], &tRfade[1], &tR[0], &tR[1], &tR[2]);
sh_cp(0);
fader_state(y, yBC[0], yBPC[0], &yGfade[0], &yGfade[1], &yG[0], &yG[1], &yG[2]);
sh_cp(0);
fader_state(y, yBC[1], yBPC[1], &yBfade[0], &yBfade[1], &yB[0], &yB[1], &yB[2]);
sh_cp(0);
fader_state(y, yBC[2], yBPC[2], &yRfade[0], &yRfade[1], &yR[0], &yR[1], &yR[2]);
sh_cp(0);
fader_state(g, gBC[0], gBPC[0], &gGfade[0], &gGfade[1], &gG[0], &gG[1], &gG[2]);
sh_cp(0);
fader_state(g, gBC[1], gBPC[1], &gBfade[0], &gBfade[1], &gB[0], &gB[1], &gB[2]);
sh_cp(0);
fader_state(g, gBC[2], gBPC[2], &gRfade[0], &gRfade[1], &gR[0], &gR[1], &gR[2]);
sh_cp(0);
fader_state(h, hBC[0], hBPC[0], &hGfade[0], &hGfade[1], &hG[0], &hG[1], &hG[2]);
sh_cp(0);
fader_state(h, hBC[1], hBPC[1], &hBfade[0], &hBfade[1], &hB[0], &hB[1], &hB[2]);
sh_cp(0);
fader_state(h, hBC[2], hBPC[2], &hRfade[0], &hRfade[1], &hR[0], &hR[1], &hR[2]);
sh_cp(0);
st_cp();
column++;
} //end else if (column==5)
else if (column==6)
{
fader_state(f, fBC[0], fBPC[0], &fGfade[0], &fGfade[1], &fG[0], &fG[1], &fG[2]);
sh_cp(0);
fader_state(f, fBC[1], fBPC[1], &fBfade[0], &fBfade[1], &fB[0], &fB[1], &fB[2]);
sh_cp(0);
fader_state(f, fBC[2], fBPC[2], &fRfade[0], &fRfade[1], &fR[0], &fR[1], &fR[2]);
sh_cp(0);
fader_state(seven, sevenBC[0], sevenBPC[0], &sevenGfade[0], &sevenGfade[1], &sevenG[0], &sevenG[1], &sevenG[2]);
sh_cp(0);
fader_state(seven, sevenBC[1], sevenBPC[1], &sevenBfade[0], &sevenBfade[1], &sevenB[0], &sevenB[1], &sevenB[2]);
sh_cp(0);
fader_state(seven, sevenBC[2], sevenBPC[2], &sevenRfade[0], &sevenRfade[1], &sevenR[0], &sevenR[1], &sevenR[2]);
sh_cp(0);
fader_state(u, uBC[0], uBPC[0], &uGfade[0], &uGfade[1], &uG[0], &uG[1], &uG[2]);
sh_cp(1);
fader_state(u, uBC[1], uBPC[1], &uBfade[0], &uBfade[1], &uB[0], &uB[1], &uB[2]);
sh_cp(0);
fader_state(u, uBC[2], uBPC[2], &uRfade[0], &uRfade[1], &uR[0], &uR[1], &uR[2]);
sh_cp(0);
fader_state(i, iBC[0], iBPC[0], &iGfade[0], &iGfade[1], &iG[0], &iG[1], &iG[2]);
sh_cp(0);
fader_state(i, iBC[1], iBPC[1], &iBfade[0], &iBfade[1], &iB[0], &iB[1], &iB[2]);
sh_cp(0);
fader_state(i, iBC[2], iBPC[2], &iRfade[0], &iRfade[1], &iR[0], &iR[1], &iR[2]);
sh_cp(0);
fader_state(j, jBC[0], jBPC[0], &jGfade[0], &jGfade[1], &jG[0], &jG[1], &jG[2]);
sh_cp(0);
fader_state(j, jBC[1], jBPC[1], &jBfade[0], &jBfade[1], &jB[0], &jB[1], &jB[2]);
sh_cp(0);
fader_state(j, jBC[2], jBPC[2], &jRfade[0], &jRfade[1], &jR[0], &jR[1], &jR[2]);
sh_cp(0);
fader_state(n, nBC[0], nBPC[0], &nGfade[0], &nGfade[1], &nG[0], &nG[1], &nG[2]);
sh_cp(0);
fader_state(n, nBC[1], nBPC[1], &nBfade[0], &nBfade[1], &nB[0], &nB[1], &nB[2]);
sh_cp(0);
fader_state(n, nBC[2], nBPC[2], &nRfade[0], &nRfade[1], &nR[0], &nR[1], &nR[2]);
sh_cp(0);
st_cp();
column++;
} //end else if (column==6)
else if (column==7)
{
fader_state(f6, f6BC[0], f6BPC[0], &f6Gfade[0], &f6Gfade[1], &f6G[0], &f6G[1], &f6G[2]);
sh_cp(0);
fader_state(f6, f6BC[1], f6BPC[1], &f6Bfade[0], &f6Bfade[1], &f6B[0], &f6B[1], &f6B[2]);
sh_cp(0);
fader_state(f6, f6BC[2], f6BPC[2], &f6Rfade[0], &f6Rfade[1], &f6R[0], &f6R[1], &f6R[2]);
sh_cp(0);
fader_state(eight, eightBC[0], eightBPC[0], &eightGfade[0], &eightGfade[1], &eightG[0], &eightG[1], &eightG[2]);
sh_cp(0);
fader_state(eight, eightBC[1], eightBPC[1], &eightBfade[0], &eightBfade[1], &eightB[0], &eightB[1], &eightB[2]);
sh_cp(0);
fader_state(eight, eightBC[2], eightBPC[2], &eightRfade[0], &eightRfade[1], &eightR[0], &eightR[1], &eightR[2]);
sh_cp(0);
fader_state(nine, nineBC[0], nineBPC[0], &nineGfade[0], &nineGfade[1], &nineG[0], &nineG[1], &nineG[2]);
sh_cp(0);
fader_state(nine, nineBC[1], nineBPC[1], &nineBfade[0], &nineBfade[1], &nineB[0], &nineB[1], &nineB[2]);
sh_cp(1);
fader_state(nine, nineBC[2], nineBPC[2], &nineRfade[0], &nineRfade[1], &nineR[0], &nineR[1], &nineR[2]);
sh_cp(0);
fader_state(o, oBC[0], oBPC[0], &oGfade[0], &oGfade[1], &oG[0], &oG[1], &oG[2]);
sh_cp(0);
fader_state(o, oBC[1], oBPC[1], &oBfade[0], &oBfade[1], &oB[0], &oB[1], &oB[2]);
sh_cp(0);
fader_state(o, oBC[2], oBPC[2], &oRfade[0], &oRfade[1], &oR[0], &oR[1], &oR[2]);
sh_cp(0);
fader_state(k, kBC[0], kBPC[0], &kGfade[0], &kGfade[1], &kG[0], &kG[1], &kG[2]);
sh_cp(0);
fader_state(k, kBC[1], kBPC[1], &kBfade[0], &kBfade[1], &kB[0], &kB[1], &kB[2]);
sh_cp(0);
fader_state(k, kBC[2], kBPC[2], &kRfade[0], &kRfade[1], &kR[0], &kR[1], &kR[2]);
sh_cp(0);
fader_state(m, mBC[0], mBPC[0], &mGfade[0], &mGfade[1], &mG[0], &mG[1], &mG[2]);
sh_cp(0);
fader_state(m, mBC[1], mBPC[1], &mBfade[0], &mBfade[1], &mB[0], &mB[1], &mB[2]);
sh_cp(0);
fader_state(m, mBC[2], mBPC[2], &mRfade[0], &mRfade[1], &mR[0], &mR[1], &mR[2]);
sh_cp(0);
st_cp();
column++;
} //end else if (column==7)
else if (column==8)
{
fader_state(f7, f7BC[0], f7BPC[0], &f7Gfade[0], &f7Gfade[1], &f7G[0], &f7G[1], &f7G[2]);
sh_cp(0);
fader_state(f7, f7BC[1], f7BPC[1], &f7Bfade[0], &f7Bfade[1], &f7B[0], &f7B[1], &f7B[2]);
sh_cp(0);
fader_state(f7, f7BC[2], f7BPC[2], &f7Rfade[0], &f7Rfade[1], &f7R[0], &f7R[1], &f7R[2]);
sh_cp(0);
fader_state(zero, zeroBC[0], zeroBPC[0], &zeroGfade[0], &zeroGfade[1], &zeroG[0], &zeroG[1], &zeroG[2]);
sh_cp(0);
fader_state(zero, zeroBC[1], zeroBPC[1], &zeroBfade[0], &zeroBfade[1], &zeroB[0], &zeroB[1], &zeroB[2]);
sh_cp(0);
fader_state(zero, zeroBC[2], zeroBPC[2], &zeroRfade[0], &zeroRfade[1], &zeroR[0], &zeroR[1], &zeroR[2]);
sh_cp(0);
fader_state(p, pBC[0], pBPC[0], &pGfade[0], &pGfade[1], &pG[0], &pG[1], &pG[2]);
sh_cp(0);
fader_state(p, pBC[1], pBPC[1], &pBfade[0], &pBfade[1], &pB[0], &pB[1], &pB[2]);
sh_cp(0);
fader_state(p, pBC[2], pBPC[2], &pRfade[0], &pRfade[1], &pR[0], &pR[1], &pR[2]);
sh_cp(1);
fader_state(l, lBC[0], lBPC[0], &lGfade[0], &lGfade[1], &lG[0], &lG[1], &lG[2]);
sh_cp(0);
fader_state(l, lBC[1], lBPC[1], &lBfade[0], &lBfade[1], &lB[0], &lB[1], &lB[2]);
sh_cp(0);
fader_state(l, lBC[2], lBPC[2], &lRfade[0], &lRfade[1], &lR[0], &lR[1], &lR[2]);
sh_cp(0);
fader_state(comma, commaBC[0], commaBPC[0], &commaGfade[0], &commaGfade[1], &commaG[0], &commaG[1], &commaG[2]);
sh_cp(0);
fader_state(comma, commaBC[1], commaBPC[1], &commaBfade[0], &commaBfade[1], &commaB[0], &commaB[1], &commaB[2]);
sh_cp(0);
fader_state(comma, commaBC[2], commaBPC[2], &commaRfade[0], &commaRfade[1], &commaR[0], &commaR[1], &commaR[2]);
sh_cp(0);
fader_state(ralt, raltBC[0], raltBPC[0], &raltGfade[0], &raltGfade[1], &raltG[0], &raltG[1], &raltG[2]);
sh_cp(0);
fader_state(ralt, raltBC[1], raltBPC[1], &raltBfade[0], &raltBfade[1], &raltB[0], &raltB[1], &raltB[2]);
sh_cp(0);
fader_state(ralt, raltBC[2], raltBPC[2], &raltRfade[0], &raltRfade[1], &raltR[0], &raltR[1], &raltR[2]);
sh_cp(0);
st_cp();
column++;
} //end else if (column==8)
else if (column==9)
{
fader_state(f8, f8BC[0], f8BPC[0], &f8Gfade[0], &f8Gfade[1], &f8G[0], &f8G[1], &f8G[2]);
sh_cp(0);
fader_state(f8, f8BC[1], f8BPC[1], &f8Bfade[0], &f8Bfade[1], &f8B[0], &f8B[1], &f8B[2]);
sh_cp(0);
fader_state(f8, f8BC[2], f8BPC[2], &f8Rfade[0], &f8Rfade[1], &f8R[0], &f8R[1], &f8R[2]);
sh_cp(0);
fader_state(minus, minusBC[0], minusBPC[0], &minusGfade[0], &minusGfade[1], &minusG[0], &minusG[1], &minusG[2]);
sh_cp(0);
fader_state(minus, minusBC[1], minusBPC[1], &minusBfade[0], &minusBfade[1], &minusB[0], &minusB[1], &minusB[2]);
sh_cp(0);
fader_state(minus, minusBC[2], minusBPC[2], &minusRfade[0], &minusRfade[1], &minusR[0], &minusR[1], &minusR[2]);
sh_cp(0);
fader_state(lsqbracket, lsqbracketBC[0], lsqbracketBPC[0], &lsqbracketGfade[0], &lsqbracketGfade[1], &lsqbracketG[0], &lsqbracketG[1], &lsqbracketG[2]);
sh_cp(0);
fader_state(lsqbracket, lsqbracketBC[1], lsqbracketBPC[1], &lsqbracketBfade[0], &lsqbracketBfade[1], &lsqbracketB[0], &lsqbracketB[1], &lsqbracketB[2]);
sh_cp(0);
fader_state(lsqbracket, lsqbracketBC[2], lsqbracketBPC[2], &lsqbracketRfade[0], &lsqbracketRfade[1], &lsqbracketR[0], &lsqbracketR[1], &lsqbracketR[2]);
sh_cp(0);
fader_state(semicolon, semicolonBC[0], semicolonBPC[0], &semicolonGfade[0], &semicolonGfade[1], &semicolonG[0], &semicolonG[1], &semicolonG[2]);
sh_cp(1);
fader_state(semicolon, semicolonBC[1], semicolonBPC[1], &semicolonBfade[0], &semicolonBfade[1], &semicolonB[0], &semicolonB[1], &semicolonB[2]);
sh_cp(0);
fader_state(semicolon, semicolonBC[2], semicolonBPC[2], &semicolonRfade[0], &semicolonRfade[1], &semicolonR[0], &semicolonR[1], &semicolonR[2]);
sh_cp(0);
fader_state(period, periodBC[0], periodBPC[0], &periodGfade[0], &periodGfade[1], &periodG[0], &periodG[1], &periodG[2]);
sh_cp(0);
fader_state(period, periodBC[1], periodBPC[1], &periodBfade[0], &periodBfade[1], &periodB[0], &periodB[1], &periodB[2]);
sh_cp(0);
fader_state(period, periodBC[2], periodBPC[2], &periodRfade[0], &periodRfade[1], &periodR[0], &periodR[1], &periodR[2]);
sh_cp(0);
fader_state(rspecial, rspecialBC[0], rspecialBPC[0], &rspecialGfade[0], &rspecialGfade[1], &rspecialG[0], &rspecialG[1], &rspecialG[2]);
sh_cp(0);
fader_state(rspecial, rspecialBC[1], rspecialBPC[1], &rspecialBfade[0], &rspecialBfade[1], &rspecialB[0], &rspecialB[1], &rspecialB[2]);
sh_cp(0);
fader_state(rspecial, rspecialBC[2], rspecialBPC[2], &rspecialRfade[0], &rspecialRfade[1], &rspecialR[0], &rspecialR[1], &rspecialR[2]);
sh_cp(0);
st_cp();
column++;
} //end else if (column==9)
else if (column==10)
{
fader_state(f9, f9BC[0], f9BPC[0], &f9Gfade[0], &f9Gfade[1], &f9G[0], &f9G[1], &f9G[2]);
sh_cp(0);
fader_state(f9, f9BC[1], f9BPC[1], &f9Bfade[0], &f9Bfade[1], &f9B[0], &f9B[1], &f9B[2]);
sh_cp(0);
fader_state(f9, f9BC[2], f9BPC[2], &f9Rfade[0], &f9Rfade[1], &f9R[0], &f9R[1], &f9R[2]);
sh_cp(0);
fader_state(equals, equalsBC[0], equalsBPC[0], &equalsGfade[0], &equalsGfade[1], &equalsG[0], &equalsG[1], &equalsG[2]);
sh_cp(0);
fader_state(equals, equalsBC[1], equalsBPC[1], &equalsBfade[0], &equalsBfade[1], &equalsB[0], &equalsB[1], &equalsB[2]);
sh_cp(0);
fader_state(equals, equalsBC[2], equalsBPC[2], &equalsRfade[0], &equalsRfade[1], &equalsR[0], &equalsR[1], &equalsR[2]);
sh_cp(0);
fader_state(rsqbracket, rsqbracketBC[0], rsqbracketBPC[0], &rsqbracketGfade[0], &rsqbracketGfade[1], &rsqbracketG[0], &rsqbracketG[1], &rsqbracketG[2]);
sh_cp(0);
fader_state(rsqbracket, rsqbracketBC[1], rsqbracketBPC[1], &rsqbracketBfade[0], &rsqbracketBfade[1], &rsqbracketB[0], &rsqbracketB[1], &rsqbracketB[2]);
sh_cp(0);
fader_state(rsqbracket, rsqbracketBC[2], rsqbracketBPC[2], &rsqbracketRfade[0], &rsqbracketRfade[1], &rsqbracketR[0], &rsqbracketR[1], &rsqbracketR[2]);
sh_cp(0);
fader_state(apostrophe, apostropheBC[0], apostropheBPC[0], &apostropheGfade[0], &apostropheGfade[1], &apostropheG[0], &apostropheG[1], &apostropheG[2]);
sh_cp(0);
fader_state(apostrophe, apostropheBC[1], apostropheBPC[1], &apostropheBfade[0], &apostropheBfade[1], &apostropheB[0], &apostropheB[1], &apostropheB[2]);
sh_cp(1);
fader_state(apostrophe, apostropheBC[2], apostropheBPC[2], &apostropheRfade[0], &apostropheRfade[1], &apostropheR[0], &apostropheR[1], &apostropheR[2]);
sh_cp(0);
fader_state(fslash, fslashBC[0], fslashBPC[0], &fslashGfade[0], &fslashGfade[1], &fslashG[0], &fslashG[1], &fslashG[2]);
sh_cp(0);
fader_state(fslash, fslashBC[1], fslashBPC[1], &fslashBfade[0], &fslashBfade[1], &fslashB[0], &fslashB[1], &fslashB[2]);
sh_cp(0);
fader_state(fslash, fslashBC[2], fslashBPC[2], &fslashRfade[0], &fslashRfade[1], &fslashR[0], &fslashR[1], &fslashR[2]);
sh_cp(0);
fader_state(menu, menuBC[0], menuBPC[0], &menuGfade[0], &menuGfade[1], &menuG[0], &menuG[1], &menuG[2]);
sh_cp(0);
fader_state(menu, menuBC[1], menuBPC[1], &menuBfade[0], &menuBfade[1], &menuB[0], &menuB[1], &menuB[2]);
sh_cp(0);
fader_state(menu, menuBC[2], menuBPC[2], &menuRfade[0], &menuRfade[1], &menuR[0], &menuR[1], &menuR[2]);
sh_cp(0);
st_cp();
column++;
} //end else if (column==10)
else if (column==11)
{
fader_state(f10, f10BC[0], f10BPC[0], &f10Gfade[0], &f10Gfade[1], &f10G[0], &f10G[1], &f10G[2]);
sh_cp(0);
fader_state(f10, f10BC[1], f10BPC[1], &f10Bfade[0], &f10Bfade[1], &f10B[0], &f10B[1], &f10B[2]);
sh_cp(0);
fader_state(f10, f10BC[2], f10BPC[2], &f10Rfade[0], &f10Rfade[1], &f10R[0], &f10R[1], &f10R[2]);
sh_cp(0);
fader_state(backspace, backspaceBC[0], backspaceBPC[0], &backspaceGfade[0], &backspaceGfade[1], &backspaceG[0], &backspaceG[1], &backspaceG[2]);
sh_cp(0);
fader_state(backspace, backspaceBC[1], backspaceBPC[1], &backspaceBfade[0], &backspaceBfade[1], &backspaceB[0], &backspaceB[1], &backspaceB[2]);
sh_cp(0);
fader_state(backspace, backspaceBC[2], backspaceBPC[2], &backspaceRfade[0], &backspaceRfade[1], &backspaceR[0], &backspaceR[1], &backspaceR[2]);
sh_cp(0);
fader_state(bslash, bslashBC[0], bslashBPC[0], &bslashGfade[0], &bslashGfade[1], &bslashG[0], &bslashG[1], &bslashG[2]);
sh_cp(0);
fader_state(bslash, bslashBC[1], bslashBPC[1], &bslashBfade[0], &bslashBfade[1], &bslashB[0], &bslashB[1], &bslashB[2]);
sh_cp(0);
fader_state(bslash, bslashBC[2], bslashBPC[2], &bslashRfade[0], &bslashRfade[1], &bslashR[0], &bslashR[1], &bslashR[2]);
sh_cp(0);
fader_state(enter, enterBC[0], enterBPC[0], &enterGfade[0], &enterGfade[1], &enterG[0], &enterG[1], &enterG[2]);
sh_cp(0);
fader_state(enter, enterBC[1], enterBPC[1], &enterBfade[0], &enterBfade[1], &enterB[0], &enterB[1], &enterB[2]);
sh_cp(0);
fader_state(enter, enterBC[2], enterBPC[2], &enterRfade[0], &enterRfade[1], &enterR[0], &enterR[1], &enterR[2]);
sh_cp(1);
fader_state(rshift, rshiftBC[0], rshiftBPC[0], &rshiftGfade[0], &rshiftGfade[1], &rshiftG[0], &rshiftG[1], &rshiftG[2]);
sh_cp(0);
fader_state(rshift, rshiftBC[1], rshiftBPC[1], &rshiftBfade[0], &rshiftBfade[1], &rshiftB[0], &rshiftB[1], &rshiftB[2]);
sh_cp(0);
fader_state(rshift, rshiftBC[2], rshiftBPC[2], &rshiftRfade[0], &rshiftRfade[1], &rshiftR[0], &rshiftR[1], &rshiftR[2]);
sh_cp(0);
fader_state(rctrl, rctrlBC[0], rctrlBPC[0], &rctrlGfade[0], &rctrlGfade[1], &rctrlG[0], &rctrlG[1], &rctrlG[2]);
sh_cp(0);
fader_state(rctrl, rctrlBC[1], rctrlBPC[1], &rctrlBfade[0], &rctrlBfade[1], &rctrlB[0], &rctrlB[1], &rctrlB[2]);
sh_cp(0);
fader_state(rctrl, rctrlBC[2], rctrlBPC[2], &rctrlRfade[0], &rctrlRfade[1], &rctrlR[0], &rctrlR[1], &rctrlR[2]);
sh_cp(0);
st_cp();
column++;
} //end else if (column==11)
else if (column==12)
{
fader_state(f11, f11BC[0], f11BPC[0], &f11Gfade[0], &f11Gfade[1], &f11G[0], &f11G[1], &f11G[2]);
sh_cp(0);
fader_state(f11, f11BC[1], f11BPC[1], &f11Bfade[0], &f11Bfade[1], &f11B[0], &f11B[1], &f11B[2]);
sh_cp(0);
fader_state(f11, f11BC[2], f11BPC[2], &f11Rfade[0], &f11Rfade[1], &f11R[0], &f11R[1], &f11R[2]);
sh_cp(0);
fader_state(f12, f12BC[0], f12BPC[0], &f12Gfade[0], &f12Gfade[1], &f12G[0], &f12G[1], &f12G[2]);
sh_cp(0);
fader_state(f12, f12BC[1], f12BPC[1], &f12Bfade[0], &f12Bfade[1], &f12B[0], &f12B[1], &f12B[2]);
sh_cp(0);
fader_state(f12, f12BC[2], f12BPC[2], &f12Rfade[0], &f12Rfade[1], &f12R[0], &f12R[1], &f12R[2]);
sh_cp(0);
fader_state(left, leftBC[0], leftBPC[0], &leftGfade[0], &leftGfade[1], &leftG[0], &leftG[1], &leftG[2]);
sh_cp(0);
fader_state(left, leftBC[1], leftBPC[1], &leftBfade[0], &leftBfade[1], &leftB[0], &leftB[1], &leftB[2]);
sh_cp(0);
fader_state(left, leftBC[2], leftBPC[2], &leftRfade[0], &leftRfade[1], &leftR[0], &leftR[1], &leftR[2]);
sh_cp(0);
fader_state(up, upBC[0], upBPC[0], &upGfade[0], &upGfade[1], &upG[0], &upG[1], &upG[2]);
sh_cp(0);
fader_state(up, upBC[1], upBPC[1], &upBfade[0], &upBfade[1], &upB[0], &upB[1], &upB[2]);
sh_cp(0);
fader_state(up, upBC[2], upBPC[2], &upRfade[0], &upRfade[1], &upR[0], &upR[1], &upR[2]);
sh_cp(0);
fader_state(down, downBC[0], downBPC[0], &downGfade[0], &downGfade[1], &downG[0], &downG[1], &downG[2]);
sh_cp(1);
fader_state(down, downBC[1], downBPC[1], &downBfade[0], &downBfade[1], &downB[0], &downB[1], &downB[2]);
sh_cp(0);
fader_state(down, downBC[2], downBPC[2], &downRfade[0], &downRfade[1], &downR[0], &downR[1], &downR[2]);
sh_cp(0);
fader_state(right, rightBC[0], rightBPC[0], &rightGfade[0], &rightGfade[1], &rightG[0], &rightG[1], &rightG[2]);
sh_cp(0);
fader_state(right, rightBC[1], rightBPC[1], &rightBfade[0], &rightBfade[1], &rightB[0], &rightB[1], &rightB[2]);
sh_cp(0);
fader_state(right, rightBC[2], rightBPC[2], &rightRfade[0], &rightRfade[1], &rightR[0], &rightR[1], &rightR[2]);
sh_cp(0);
st_cp();
column++;
} //end else if (column==12)
else if (column==13)
{
fader_state(insert, insertBC[0], insertBPC[0], &insertGfade[0], &insertGfade[1], &insertG[0], &insertG[1], &insertG[2]);
sh_cp(0);
fader_state(insert, insertBC[1], insertBPC[1], &insertBfade[0], &insertBfade[1], &insertB[0], &insertB[1], &insertB[2]);
sh_cp(0);
fader_state(insert, insertBC[2], insertBPC[2], &insertRfade[0], &insertRfade[1], &insertR[0], &insertR[1], &insertR[2]);
sh_cp(0);
fader_state(dlt, dltBC[0], dltBPC[0], &dltGfade[0], &dltGfade[1], &dltG[0], &dltG[1], &dltG[2]);
sh_cp(0);
fader_state(dlt, dltBC[1], dltBPC[1], &dltBfade[0], &dltBfade[1], &dltB[0], &dltB[1], &dltB[2]);
sh_cp(0);
fader_state(dlt, dltBC[2], dltBPC[2], &dltRfade[0], &dltRfade[1], &dltR[0], &dltR[1], &dltR[2]);
sh_cp(0);
fader_state(home, homeBC[0], homeBPC[0], &homeGfade[0], &homeGfade[1], &homeG[0], &homeG[1], &homeG[2]);
sh_cp(0);
fader_state(home, homeBC[1], homeBPC[1], &homeBfade[0], &homeBfade[1], &homeB[0], &homeB[1], &homeB[2]);
sh_cp(0);
fader_state(home, homeBC[2], homeBPC[2], &homeRfade[0], &homeRfade[1], &homeR[0], &homeR[1], &homeR[2]);
sh_cp(0);
fader_state(end, endBC[0], endBPC[0], &endGfade[0], &endGfade[1], &endG[0], &endG[1], &endG[2]);
sh_cp(0);
fader_state(end, endBC[1], endBPC[1], &endBfade[0], &endBfade[1], &endB[0], &endB[1], &endB[2]);
sh_cp(0);
fader_state(end, endBC[2], endBPC[2], &endRfade[0], &endRfade[1], &endR[0], &endR[1], &endR[2]);
sh_cp(0);
fader_state(pageup, pageupBC[0], pageupBPC[0], &pageupGfade[0], &pageupGfade[1], &pageupG[0], &pageupG[1], &pageupG[2]);
sh_cp(0);
fader_state(pageup, pageupBC[1], pageupBPC[1], &pageupBfade[0], &pageupBfade[1], &pageupB[0], &pageupB[1], &pageupB[2]);
sh_cp(1);
fader_state(pageup, pageupBC[2], pageupBPC[2], &pageupRfade[0], &pageupRfade[1], &pageupR[0], &pageupR[1], &pageupR[2]);
sh_cp(0);
fader_state(pagedown, pagedownBC[0], pagedownBPC[0], &pagedownGfade[0], &pagedownGfade[1], &pagedownG[0], &pagedownG[1], &pagedownG[2]);
sh_cp(0);
fader_state(pagedown, pagedownBC[1], pagedownBPC[1], &pagedownBfade[0], &pagedownBfade[1], &pagedownB[0], &pagedownB[1], &pagedownB[2]);
sh_cp(0);
fader_state(pagedown, pagedownBC[2], pagedownBPC[2], &pagedownRfade[0], &pagedownRfade[1], &pagedownR[0], &pagedownR[1], &pagedownR[2]);
sh_cp(0);
st_cp();
column++;
} //end else if (column==13)
if (macro == 1) //if macro key is pressed
{
++macroS; //incriment macroState
if (macroS==1) //if macroState is 1
{
macroFKBPCV[0] = f1BPC[0]; //store f1-f12+macro ButtonPressColor in macroFunctionButtonPressColorValue
macroFKBPCV[1] = f1BPC[1];
macroFKBPCV[2] = f1BPC[2];
macroFKBPCV[3] = f2BPC[0];
macroFKBPCV[4] = f2BPC[1];
macroFKBPCV[5] = f2BPC[2];
macroFKBPCV[6] = f3BPC[0];
macroFKBPCV[7] = f3BPC[1];
macroFKBPCV[8] = f3BPC[2];
macroFKBPCV[9] = f4BPC[0];
macroFKBPCV[10] = f4BPC[1];
macroFKBPCV[11] = f4BPC[2];
macroFKBPCV[12] = f5BPC[0];
macroFKBPCV[13] = f5BPC[1];
macroFKBPCV[14] = f5BPC[2];
macroFKBPCV[15] = f6BPC[0];
macroFKBPCV[16] = f6BPC[1];
macroFKBPCV[17] = f6BPC[2];
macroFKBPCV[18] = f7BPC[0];
macroFKBPCV[19] = f7BPC[1];
macroFKBPCV[20] = f7BPC[2];
macroFKBPCV[21] = f8BPC[0];
macroFKBPCV[22] = f8BPC[1];
macroFKBPCV[23] = f8BPC[2];
macroFKBPCV[24] = f9BPC[0];
macroFKBPCV[25] = f9BPC[1];
macroFKBPCV[26] = f9BPC[2];
macroFKBPCV[27] = f10BPC[0];
macroFKBPCV[28] = f10BPC[1];
macroFKBPCV[29] = f10BPC[2];
macroFKBPCV[30] = f11BPC[0];
macroFKBPCV[31] = f11BPC[1];
macroFKBPCV[32] = f11BPC[2];
macroFKBPCV[33] = f12BPC[0];
macroFKBPCV[34] = f12BPC[1];
macroFKBPCV[35] = f12BPC[2];
macroFKBPCV[36] = macroBPC[0];
macroFKBPCV[37] = macroBPC[1];
macroFKBPCV[38] = macroBPC[2];
f1BPC[0] = f1BC[0]; //set f1-f12+macro ButtonPressColor to f1-f12+macro ButtonColor
f1BPC[1] = f1BC[1];
f1BPC[2] = f1BC[2];
f2BPC[0] = f2BC[0];
f2BPC[1] = f2BC[1];
f2BPC[2] = f2BC[2];
f3BPC[0] = f3BC[0];
f3BPC[1] = f3BC[1];
f3BPC[2] = f3BC[2];
f4BPC[0] = f4BC[0];
f4BPC[1] = f4BC[1];
f4BPC[2] = f4BC[2];
f5BPC[0] = f5BC[0];
f5BPC[1] = f5BC[1];
f5BPC[2] = f5BC[2];
f6BPC[0] = f6BC[0];
f6BPC[1] = f6BC[1];
f6BPC[2] = f6BC[2];
f7BPC[0] = f7BC[0];
f7BPC[1] = f7BC[1];
f7BPC[2] = f7BC[2];
f8BPC[0] = f8BC[0];
f8BPC[1] = f8BC[1];
f8BPC[2] = f8BC[2];
f9BPC[0] = f9BC[0];
f9BPC[1] = f9BC[1];
f9BPC[2] = f9BC[2];
f10BPC[0] = f10BC[0];
f10BPC[1] = f10BC[1];
f10BPC[2] = f10BC[2];
f11BPC[0] = f11BC[0];
f11BPC[1] = f11BC[1];
f11BPC[2] = f11BC[2];
f12BPC[0] = f12BC[0];
f12BPC[1] = f12BC[1];
f12BPC[2] = f12BC[2];
macroBPC[0] = macroBC[0];
macroBPC[1] = macroBC[1];
macroBPC[2] = macroBC[2];
f1BC[0] = macroS1BC[0]; //set f1-f12+macro ButtonColor to macroState1ButtonColor
f1BC[1] = macroS1BC[1];
f1BC[2] = macroS1BC[2];
f2BC[0] = macroS1BC[0];
f2BC[1] = macroS1BC[1];
f2BC[2] = macroS1BC[2];
f3BC[0] = macroS1BC[0];
f3BC[1] = macroS1BC[1];
f3BC[2] = macroS1BC[2];
f4BC[0] = macroS1BC[0];
f4BC[1] = macroS1BC[1];
f4BC[2] = macroS1BC[2];
f5BC[0] = macroS1BC[0];
f5BC[1] = macroS1BC[1];
f5BC[2] = macroS1BC[2];
f6BC[0] = macroS1BC[0];
f6BC[1] = macroS1BC[1];
f6BC[2] = macroS1BC[2];
f7BC[0] = macroS1BC[0];
f7BC[1] = macroS1BC[1];
f7BC[2] = macroS1BC[2];
f8BC[0] = macroS1BC[0];
f8BC[1] = macroS1BC[1];
f8BC[2] = macroS1BC[2];
f9BC[0] = macroS1BC[0];
f9BC[1] = macroS1BC[1];
f9BC[2] = macroS1BC[2];
f10BC[0] = macroS1BC[0];
f10BC[1] = macroS1BC[1];
f10BC[2] = macroS1BC[2];
f11BC[0] = macroS1BC[0];
f11BC[1] = macroS1BC[1];
f11BC[2] = macroS1BC[2];
f12BC[0] = macroS1BC[0];
f12BC[1] = macroS1BC[1];
f12BC[2] = macroS1BC[2];
macroBC[0] = macroS1BC[0];
macroBC[1] = macroS1BC[1];
macroBC[2] = macroS1BC[2];
} //end if(macroS==1)
else if (macroS==2) //if macroState is 2
{
f1BC[0] = macroS2BC[0]; //set f1-f12+macro ButtonColor to macroState2ButtonColor
f1BC[1] = macroS2BC[1];
f1BC[2] = macroS2BC[2];
f2BC[0] = macroS2BC[0];
f2BC[1] = macroS2BC[1];
f2BC[2] = macroS2BC[2];
f3BC[0] = macroS2BC[0];
f3BC[1] = macroS2BC[1];
f3BC[2] = macroS2BC[2];
f4BC[0] = macroS2BC[0];
f4BC[1] = macroS2BC[1];
f4BC[2] = macroS2BC[2];
f5BC[0] = macroS2BC[0];
f5BC[1] = macroS2BC[1];
f5BC[2] = macroS2BC[2];
f6BC[0] = macroS2BC[0];
f6BC[1] = macroS2BC[1];
f6BC[2] = macroS2BC[2];
f7BC[0] = macroS2BC[0];
f7BC[1] = macroS2BC[1];
f7BC[2] = macroS2BC[2];
f8BC[0] = macroS2BC[0];
f8BC[1] = macroS2BC[1];
f8BC[2] = macroS2BC[2];
f9BC[0] = macroS2BC[0];
f9BC[1] = macroS2BC[1];
f9BC[2] = macroS2BC[2];
f10BC[0] = macroS2BC[0];
f10BC[1] = macroS2BC[1];
f10BC[2] = macroS2BC[2];
f11BC[0] = macroS2BC[0];
f11BC[1] = macroS2BC[1];
f11BC[2] = macroS2BC[2];
f12BC[0] = macroS2BC[0];
f12BC[1] = macroS2BC[1];
f12BC[2] = macroS2BC[2];
macroBC[0] = macroS2BC[0];
macroBC[1] = macroS2BC[1];
macroBC[2] = macroS2BC[2];
} //end if(macroS==2)
else
{
f1BC[0] = f1BPC[0]; //set f1-f12+macro ButtonColor to f1-f12+macro ButtonPressColor
f1BC[1] = f1BPC[1];
f1BC[2] = f1BPC[2];
f2BC[0] = f2BPC[0];
f2BC[1] = f2BPC[1];
f2BC[2] = f2BPC[2];
f3BC[0] = f3BPC[0];
f3BC[1] = f3BPC[1];
f3BC[2] = f3BPC[2];
f4BC[0] = f4BPC[0];
f4BC[1] = f4BPC[1];
f4BC[2] = f4BPC[2];
f5BC[0] = f5BPC[0];
f5BC[1] = f5BPC[1];
f5BC[2] = f5BPC[2];
f6BC[0] = f6BPC[0];
f6BC[1] = f6BPC[1];
f6BC[2] = f6BPC[2];
f7BC[0] = f7BPC[0];
f7BC[1] = f7BPC[1];
f7BC[2] = f7BPC[2];
f8BC[0] = f8BPC[0];
f8BC[1] = f8BPC[1];
f8BC[2] = f8BPC[2];
f9BC[0] = f9BPC[0];
f9BC[1] = f9BPC[1];
f9BC[2] = f9BPC[2];
f10BC[0] = f10BPC[0];
f10BC[1] = f10BPC[1];
f10BC[2] = f10BPC[2];
f11BC[0] = f11BPC[0];
f11BC[1] = f11BPC[1];
f11BC[2] = f11BPC[2];
f12BC[0] = f12BPC[0];
f12BC[1] = f12BPC[1];
f12BC[2] = f12BPC[2];
macroBC[0] = macroBPC[0];
macroBC[1] = macroBPC[1];
macroBC[2] = macroBPC[2];
f1BPC[0] = macroFKBPCV[0]; //set f1-f12+macro ButtonPressColor to macroFunctionKeyPressColorValue
f1BPC[1] = macroFKBPCV[1];
f1BPC[2] = macroFKBPCV[2];
f2BPC[0] = macroFKBPCV[3];
f2BPC[1] = macroFKBPCV[4];
f2BPC[2] = macroFKBPCV[5];
f3BPC[0] = macroFKBPCV[6];
f3BPC[1] = macroFKBPCV[7];
f3BPC[2] = macroFKBPCV[8];
f4BPC[0] = macroFKBPCV[9];
f4BPC[1] = macroFKBPCV[10];
f4BPC[2] = macroFKBPCV[11];
f5BPC[0] = macroFKBPCV[12];
f5BPC[1] = macroFKBPCV[13];
f5BPC[2] = macroFKBPCV[14];
f6BPC[0] = macroFKBPCV[15];
f6BPC[1] = macroFKBPCV[16];
f6BPC[2] = macroFKBPCV[17];
f7BPC[0] = macroFKBPCV[18];
f7BPC[1] = macroFKBPCV[19];
f7BPC[2] = macroFKBPCV[20];
f8BPC[0] = macroFKBPCV[21];
f8BPC[1] = macroFKBPCV[22];
f8BPC[2] = macroFKBPCV[23];
f9BPC[0] = macroFKBPCV[24];
f9BPC[1] = macroFKBPCV[25];
f9BPC[2] = macroFKBPCV[26];
f10BPC[0] = macroFKBPCV[27];
f10BPC[1] = macroFKBPCV[28];
f10BPC[2] = macroFKBPCV[29];
f11BPC[0] = macroFKBPCV[30];
f11BPC[1] = macroFKBPCV[31];
f11BPC[2] = macroFKBPCV[32];
f12BPC[0] = macroFKBPCV[33];
f12BPC[1] = macroFKBPCV[34];
f12BPC[2] = macroFKBPCV[35];
macroBPC[0] = macroFKBPCV[36];
macroBPC[1] = macroFKBPCV[37];
macroBPC[2] = macroFKBPCV[38];
macroS = 0;
} //end else
} //end if(macro==1)
else if (column==14)
{
fader_state(macro, macroBC[0], macroBPC[0], ¯oGfade[0], ¯oGfade[1], ¯oG[0], ¯oG[1], ¯oG[2]);
sh_cp(0);
fader_state(macro, macroBC[1], macroBPC[1], ¯oBfade[0], ¯oBfade[1], ¯oB[0], ¯oB[1], ¯oB[2]);
sh_cp(0);
fader_state(macro, macroBC[2], macroBPC[2], ¯oRfade[0], ¯oRfade[1], ¯oR[0], ¯oR[1], ¯oR[2]);
sh_cp(0);
fader_state(numlock, numlockBC[0], numlockBPC[0], &numlockGfade[0], &numlockGfade[1], &numlockG[0], &numlockG[1], &numlockG[2]);
sh_cp(0);
fader_state(numlock, numlockBC[1], numlockBPC[1], &numlockBfade[0], &numlockBfade[1], &numlockB[0], &numlockB[1], &numlockB[2]);
sh_cp(0);
fader_state(numlock, numlockBC[2], numlockBPC[2], &numlockRfade[0], &numlockRfade[1], &numlockR[0], &numlockR[1], &numlockR[2]);
sh_cp(0);
fader_state(num7, num7BC[0], num7BPC[0], &num7Gfade[0], &num7Gfade[1], &num7G[0], &num7G[1], &num7G[2]);
sh_cp(0);
fader_state(num7, num7BC[1], num7BPC[1], &num7Bfade[0], &num7Bfade[1], &num7B[0], &num7B[1], &num7B[2]);
sh_cp(0);
fader_state(num7, num7BC[2], num7BPC[2], &num7Rfade[0], &num7Rfade[1], &num7R[0], &num7R[1], &num7R[2]);
sh_cp(0);
fader_state(num4, num4BC[0], num4BPC[0], &num4Gfade[0], &num4Gfade[1], &num4G[0], &num4G[1], &num4G[2]);
sh_cp(0);
fader_state(num4, num4BC[1], num4BPC[1], &num4Bfade[0], &num4Bfade[1], &num4B[0], &num4B[1], &num4B[2]);
sh_cp(0);
fader_state(num4, num4BC[2], num4BPC[2], &num4Rfade[0], &num4Rfade[1], &num4R[0], &num4R[1], &num4R[2]);
sh_cp(0);
fader_state(num1, num1BC[0], num1BPC[0], &num1Gfade[0], &num1Gfade[1], &num1G[0], &num1G[1], &num1G[2]);
sh_cp(0);
fader_state(num1, num1BC[1], num1BPC[1], &num1Bfade[0], &num1Bfade[1], &num1B[0], &num1B[1], &num1B[2]);
sh_cp(0);
fader_state(num1, num1BC[2], num1BPC[2], &num1Rfade[0], &num1Rfade[1], &num1R[0], &num1R[1], &num1R[2]);
sh_cp(1);
fader_state(num0, num0BC[0], num0BPC[0], &num0Gfade[0], &num0Gfade[1], &num0G[0], &num0G[1], &num0G[2]);
sh_cp(0);
fader_state(num0, num0BC[1], num0BPC[1], &num0Bfade[0], &num0Bfade[1], &num0B[0], &num0B[1], &num0B[2]);
sh_cp(0);
fader_state(num0, num0BC[2], num0BPC[2], &num0Rfade[0], &num0Rfade[1], &num0R[0], &num0R[1], &num0R[2]);
sh_cp(0);
st_cp();
column++;
} //end else if (column==14)
else if (column==15)
{
fader_state(bright, brightBC[0], brightBPC[0], &brightGfade[0], &brightGfade[1], &brightG[0], &brightG[1], &brightG[2]);
sh_cp(0);
fader_state(bright, brightBC[1], brightBPC[1], &brightBfade[0], &brightBfade[1], &brightB[0], &brightB[1], &brightB[2]);
sh_cp(0);
fader_state(bright, brightBC[2], brightBPC[2], &brightRfade[0], &brightRfade[1], &brightR[0], &brightR[1], &brightR[2]);
sh_cp(0);
fader_state(numfslash, numfslashBC[0], numfslashBPC[0], &numfslashGfade[0], &numfslashGfade[1], &numfslashG[0], &numfslashG[1], &numfslashG[2]);
sh_cp(0);
fader_state(numfslash, numfslashBC[1], numfslashBPC[1], &numfslashBfade[0], &numfslashBfade[1], &numfslashB[0], &numfslashB[1], &numfslashB[2]);
sh_cp(0);
fader_state(numfslash, numfslashBC[2], numfslashBPC[2], &numfslashRfade[0], &numfslashRfade[1], &numfslashR[0], &numfslashR[1], &numfslashR[2]);
sh_cp(0);
fader_state(num8, num8BC[0], num8BPC[0], &num8Gfade[0], &num8Gfade[1], &num8G[0], &num8G[1], &num8G[2]);
sh_cp(0);
fader_state(num8, num8BC[1], num8BPC[1], &num8Bfade[0], &num8Bfade[1], &num8B[0], &num8B[1], &num8B[2]);
sh_cp(0);
fader_state(num8, num8BC[2], num8BPC[2], &num8Rfade[0], &num8Rfade[1], &num8R[0], &num8R[1], &num8R[2]);
sh_cp(0);
fader_state(num5, num5BC[0], num5BPC[0], &num5Gfade[0], &num5Gfade[1], &num5G[0], &num5G[1], &num5G[2]);
sh_cp(0);
fader_state(num5, num5BC[1], num5BPC[1], &num5Bfade[0], &num5Bfade[1], &num5B[0], &num5B[1], &num5B[2]);
sh_cp(0);
fader_state(num5, num5BC[2], num5BPC[2], &num5Rfade[0], &num5Rfade[1], &num5R[0], &num5R[1], &num5R[2]);
sh_cp(0);
fader_state(num2, num2BC[0], num2BPC[0], &num2Gfade[0], &num2Gfade[1], &num2G[0], &num2G[1], &num2G[2]);
sh_cp(0);
fader_state(num2, num2BC[1], num2BPC[1], &num2Bfade[0], &num2Bfade[1], &num2B[0], &num2B[1], &num2B[2]);
sh_cp(0);
fader_state(num2, num2BC[2], num2BPC[2], &num2Rfade[0], &num2Rfade[1], &num2R[0], &num2R[1], &num2R[2]);
sh_cp(0);
fader_state(numperiod, numperiodBC[0], numperiodBPC[0], &numperiodGfade[0], &numperiodGfade[1], &numperiodG[0], &numperiodG[1], &numperiodG[2]);
sh_cp(1);
fader_state(numperiod, numperiodBC[1], numperiodBPC[1], &numperiodBfade[0], &numperiodBfade[1], &numperiodB[0], &numperiodB[1], &numperiodB[2]);
sh_cp(0);
fader_state(numperiod, numperiodBC[2], numperiodBPC[2], &numperiodRfade[0], &numperiodRfade[1], &numperiodR[0], &numperiodR[1], &numperiodR[2]);
sh_cp(0);
st_cp();
column++;
} //end else if (column==15)
else if (column==16)
{
fader_state(mute, muteBC[0], muteBPC[0], &muteGfade[0], &muteGfade[1], &muteG[0], &muteG[1], &muteG[2]);
sh_cp(0);
fader_state(mute, muteBC[1], muteBPC[1], &muteBfade[0], &muteBfade[1], &muteB[0], &muteB[1], &muteB[2]);
sh_cp(0);
fader_state(mute, muteBC[2], muteBPC[2], &muteRfade[0], &muteRfade[1], &muteR[0], &muteR[1], &muteR[2]);
sh_cp(0);
fader_state(asterisk, asteriskBC[0], asteriskBPC[0], &asteriskGfade[0], &asteriskGfade[1], &asteriskG[0], &asteriskG[1], &asteriskG[2]);
sh_cp(0);
fader_state(asterisk, asteriskBC[1], asteriskBPC[1], &asteriskBfade[0], &asteriskBfade[1], &asteriskB[0], &asteriskB[1], &asteriskB[2]);
sh_cp(0);
fader_state(asterisk, asteriskBC[2], asteriskBPC[2], &asteriskRfade[0], &asteriskRfade[1], &asteriskR[0], &asteriskR[1], &asteriskR[2]);
sh_cp(0);
fader_state(num9, num9BC[0], num9BPC[0], &num9Gfade[0], &num9Gfade[1], &num9G[0], &num9G[1], &num9G[2]);
sh_cp(0);
fader_state(num9, num9BC[1], num9BPC[1], &num9Bfade[0], &num9Bfade[1], &num9B[0], &num9B[1], &num9B[2]);
sh_cp(0);
fader_state(num9, num9BC[2], num9BPC[2], &num9Rfade[0], &num9Rfade[1], &num9R[0], &num9R[1], &num9R[2]);
sh_cp(0);
fader_state(num6, num6BC[0], num6BPC[0], &num6Gfade[0], &num6Gfade[1], &num6G[0], &num6G[1], &num6G[2]);
sh_cp(0);
fader_state(num6, num6BC[1], num6BPC[1], &num6Bfade[0], &num6Bfade[1], &num6B[0], &num6B[1], &num6B[2]);
sh_cp(0);
fader_state(num6, num6BC[2], num6BPC[2], &num6Rfade[0], &num6Rfade[1], &num6R[0], &num6R[1], &num6R[2]);
sh_cp(0);
fader_state(num3, num3BC[0], num3BPC[0], &num3Gfade[0], &num3Gfade[1], &num3G[0], &num3G[1], &num3G[2]);
sh_cp(0);
fader_state(num3, num3BC[1], num3BPC[1], &num3Bfade[0], &num3Bfade[1], &num3B[0], &num3B[1], &num3B[2]);
sh_cp(0);
fader_state(num3, num3BC[2], num3BPC[2], &num3Rfade[0], &num3Rfade[1], &num3R[0], &num3R[1], &num3R[2]);
sh_cp(0);
fader_state(numenter, numenterBC[0], numenterBPC[0], &numenterGfade[0], &numenterGfade[1], &numenterG[0], &numenterG[1], &numenterG[2]);
sh_cp(0);
fader_state(numenter, numenterBC[1], numenterBPC[1], &numenterBfade[0], &numenterBfade[1], &numenterB[0], &numenterB[1], &numenterB[2]);
sh_cp(1);
fader_state(numenter, numenterBC[2], numenterBPC[2], &numenterRfade[0], &numenterRfade[1], &numenterR[0], &numenterR[1], &numenterR[2]);
sh_cp(0);
st_cp();
column++;
} //end else if (column==16)
else if (column==17)
{
fader_state(prtscrn, prtscrnBC[0], prtscrnBPC[0], &prtscrnGfade[0], &prtscrnGfade[1], &prtscrnG[0], &prtscrnG[1], &prtscrnG[2]);
sh_cp(0);
fader_state(prtscrn, prtscrnBC[1], prtscrnBPC[1], &prtscrnBfade[0], &prtscrnBfade[1], &prtscrnB[0], &prtscrnB[1], &prtscrnB[2]);
sh_cp(0);
fader_state(prtscrn, prtscrnBC[2], prtscrnBPC[2], &prtscrnRfade[0], &prtscrnRfade[1], &prtscrnR[0], &prtscrnR[1], &prtscrnR[2]);
sh_cp(0);
fader_state(scrolllock, scrolllockBC[0], scrolllockBPC[0], &scrolllockGfade[0], &scrolllockGfade[1], &scrolllockG[0], &scrolllockG[1], &scrolllockG[2]);
sh_cp(0);
fader_state(scrolllock, scrolllockBC[1], scrolllockBPC[1], &scrolllockBfade[0], &scrolllockBfade[1], &scrolllockB[0], &scrolllockB[1], &scrolllockB[2]);
sh_cp(0);
fader_state(scrolllock, scrolllockBC[2], scrolllockBPC[2], &scrolllockRfade[0], &scrolllockRfade[1], &scrolllockR[0], &scrolllockR[1], &scrolllockR[2]);
sh_cp(0);
fader_state(pause, pauseBC[0], pauseBPC[0], &pauseGfade[0], &pauseGfade[1], &pauseG[0], &pauseG[1], &pauseG[2]);
sh_cp(0);
fader_state(pause, pauseBC[1], pauseBPC[1], &pauseBfade[0], &pauseBfade[1], &pauseB[0], &pauseB[1], &pauseB[2]);
sh_cp(0);
fader_state(pause, pauseBC[2], pauseBPC[2], &pauseRfade[0], &pauseRfade[1], &pauseR[0], &pauseR[1], &pauseR[2]);
sh_cp(0);
fader_state(numminus, numminusBC[0], numminusBPC[0], &numminusGfade[0], &numminusGfade[1], &numminusG[0], &numminusG[1], &numminusG[2]);
sh_cp(0);
fader_state(numminus, numminusBC[1], numminusBPC[1], &numminusBfade[0], &numminusBfade[1], &numminusB[0], &numminusB[1], &numminusB[2]);
sh_cp(0);
fader_state(numminus, numminusBC[2], numminusBPC[2], &numminusRfade[0], &numminusRfade[1], &numminusR[0], &numminusR[1], &numminusR[2]);
sh_cp(0);
fader_state(plus, plusBC[0], plusBPC[0], &plusGfade[0], &plusGfade[1], &plusG[0], &plusG[1], &plusG[2]);
sh_cp(0);
fader_state(plus, plusBC[1], plusBPC[1], &plusBfade[0], &plusBfade[1], &plusB[0], &plusB[1], &plusB[2]);
sh_cp(0);
fader_state(plus, plusBC[2], plusBPC[2], &plusRfade[0], &plusRfade[1], &plusR[0], &plusR[1], &plusR[2]);
sh_cp(0);
PORTA &= ~(1<<PA0); //sets rdata to low since there are no more keys to fill up the remainder of the 18 LED slots and the remainder of the 24 total 74HC595 pins low
sh_cp(0);
sh_cp(0);
sh_cp(1);
sh_cp(0);
sh_cp(0);
sh_cp(0);
sh_cp(0);
sh_cp(0);
sh_cp(0);
st_cp();
column = 0; //restart at the beginning of column loop
} //end else if (column==17)
} //end while(1)
} //end main