function LPD8RK() {}
LPD8RK.debug=false;

//set defaults - don't change these
LPD8RK.oldHotcueBank=0;//storage for the last active hotcue bank - used for bank indicator lights
LPD8RK.LEDinterval=300;//interval in milliseconds for LED update
LPD8RK.hotcueClear=false;//if true, hitting hotcue button clears it.
LPD8RK.loopbuttonDown=false;//if true, special loop functions with knob modifiers are enabled.
LPD8RK.looplen=0x40;//default position of looplength dial - active when loop buttons are held down
LPD8RK.looptype="beatloop";//default looptype - beatloop if <64, beatlooproll otherwise
LPD8RK.loopmove=0.0125;//default loop move distance in seconds
LPD8RK.doreloop=true;//don't change this
LPD8RK.beatjumpstep=1;//default beat jump step in beats
LPD8RK.vol=new Array();//array of volumes to return to after mute - don't change
LPD8RK.hotcueBank=1;//default hotcue bank to show on PAD setting, adjustable by knob


//array of valid LED addresses
LPD8RK.validLEDS = new Array();
LPD8RK.validLEDS[0x90]={0x2b : true,0x27 : true,0x2a : true,0x26 : true,0x29 : true,0x25 : true,0x28 : true,0x24 : true};
LPD8RK.validLEDS[0x91]={0x2c : true,0x27 : true,0x2e : true,0x2a : true,0x26 : true,0x24 : true,0x25 : true,0x23 : true};
LPD8RK.validLEDS[0x92]={0x48 : true,0x41 : true,0x47 : true,0x40 : true,0x45 : true,0x3e : true,0x43 : true,0x3c : true};
LPD8RK.validLEDS[0x93]={0x30 : true,0x29 : true,0x2f : true,0x28 : true,0x2d : true,0x26 : true,0x2b : true,0x24 : true};
LPD8RK.validLEDS[0xb0]={0x01 : true,0x09 : true,0x04 : true,0x08 : true,0x03 : true,0x06 : true,0x03 : true,0x05 : true};
LPD8RK.validLEDS[0xb1]={0x01 : true,0x09 : true,0x04 : true,0x08 : true,0x03 : true,0x06 : true,0x03 : true,0x05 : true};
LPD8RK.validLEDS[0xb2]={0x01 : true,0x09 : true,0x04 : true,0x08 : true,0x03 : true,0x06 : true,0x03 : true,0x05 : true};
LPD8RK.validLEDS[0xb3]={0x01 : true,0x09 : true,0x04 : true,0x08 : true,0x03 : true,0x06 : true,0x03 : true,0x05 : true};


//map hotcue pads and leds
LPD8RK.hotcues = new Array();
//preset 1 (group, cuenum, status, ctrl)
//initialize
LPD8RK.hotcues["902b"] = new Array();
LPD8RK.hotcues["9027"] = new Array();
LPD8RK.hotcues["902a"] = new Array();
LPD8RK.hotcues["9026"] = new Array();
LPD8RK.hotcues["9029"] = new Array();
LPD8RK.hotcues["9025"] = new Array();
//bank 1
LPD8RK.hotcues["902b"][1] = new Array("[Channel1]", "1", 0x90, 0x2b);
LPD8RK.hotcues["9027"][1] = new Array("[Channel1]", "2", 0x90, 0x27);
LPD8RK.hotcues["902a"][1] = new Array("[Channel1]", "3", 0x90, 0x2a);
LPD8RK.hotcues["9026"][1] = new Array("[Channel1]", "4", 0x90, 0x26);
LPD8RK.hotcues["9029"][1] = new Array("[Channel1]", "5", 0x90, 0x29);
LPD8RK.hotcues["9025"][1] = new Array("[Channel1]", "6", 0x90, 0x25);
//bank 2
LPD8RK.hotcues["902b"][2] = new Array("[Channel1]", "7", 0x90, 0x2b);
LPD8RK.hotcues["9027"][2] = new Array("[Channel1]", "8", 0x90, 0x27);
LPD8RK.hotcues["902a"][2] = new Array("[Channel1]", "9", 0x90, 0x2a);
LPD8RK.hotcues["9026"][2] = new Array("[Channel1]", "10", 0x90, 0x26);
LPD8RK.hotcues["9029"][2] = new Array("[Channel1]", "11", 0x90, 0x29);
LPD8RK.hotcues["9025"][2] = new Array("[Channel1]", "12", 0x90, 0x25);
//bank 3
LPD8RK.hotcues["902b"][3] = new Array("[Channel1]", "13", 0x90, 0x2b);
LPD8RK.hotcues["9027"][3] = new Array("[Channel1]", "14", 0x90, 0x27);
LPD8RK.hotcues["902a"][3] = new Array("[Channel1]", "15", 0x90, 0x2a);
LPD8RK.hotcues["9026"][3] = new Array("[Channel1]", "16", 0x90, 0x26);
LPD8RK.hotcues["9029"][3] = new Array("[Channel1]", "17", 0x90, 0x29);
LPD8RK.hotcues["9025"][3] = new Array("[Channel1]", "18", 0x90, 0x25);
//bank 4
LPD8RK.hotcues["902b"][4] = new Array("[Channel1]", "19", 0x90, 0x2b);
LPD8RK.hotcues["9027"][4] = new Array("[Channel1]", "20", 0x90, 0x27);
LPD8RK.hotcues["902a"][4] = new Array("[Channel1]", "21", 0x90, 0x2a);
LPD8RK.hotcues["9026"][4] = new Array("[Channel1]", "22", 0x90, 0x26);
LPD8RK.hotcues["9029"][4] = new Array("[Channel1]", "23", 0x90, 0x29);
LPD8RK.hotcues["9025"][4] = new Array("[Channel1]", "24", 0x90, 0x25);
//bank 5
LPD8RK.hotcues["902b"][5] = new Array("[Channel1]", "25", 0x90, 0x2b);
LPD8RK.hotcues["9027"][5] = new Array("[Channel1]", "26", 0x90, 0x27);
LPD8RK.hotcues["902a"][5] = new Array("[Channel1]", "27", 0x90, 0x2a);
LPD8RK.hotcues["9026"][5] = new Array("[Channel1]", "28", 0x90, 0x26);
LPD8RK.hotcues["9029"][5] = new Array("[Channel1]", "29", 0x90, 0x29);
LPD8RK.hotcues["9025"][5] = new Array("[Channel1]", "30", 0x90, 0x25);

//##################
//preset 2 (group, cuenum, status, ctrl)
//initialize
LPD8RK.hotcues["912c"] = new Array();
LPD8RK.hotcues["9127"] = new Array();
LPD8RK.hotcues["912e"] = new Array();
LPD8RK.hotcues["912a"] = new Array();
LPD8RK.hotcues["9126"] = new Array();
LPD8RK.hotcues["9124"] = new Array();
//bank 1
LPD8RK.hotcues["912c"][1] = new Array("[Channel2]", "1", 0x91, 0x2c);
LPD8RK.hotcues["9127"][1] = new Array("[Channel2]", "2", 0x91, 0x27);
LPD8RK.hotcues["912e"][1] = new Array("[Channel2]", "3", 0x91, 0x2e);
LPD8RK.hotcues["912a"][1] = new Array("[Channel2]", "4", 0x91, 0x2a);
LPD8RK.hotcues["9126"][1] = new Array("[Channel2]", "5", 0x91, 0x26);
LPD8RK.hotcues["9124"][1] = new Array("[Channel2]", "6", 0x91, 0x24);
//bank 2
LPD8RK.hotcues["912c"][2] = new Array("[Channel2]", "7", 0x91, 0x2c);
LPD8RK.hotcues["9127"][2] = new Array("[Channel2]", "8", 0x91, 0x27);
LPD8RK.hotcues["912e"][2] = new Array("[Channel2]", "9", 0x91, 0x2e);
LPD8RK.hotcues["912a"][2] = new Array("[Channel2]", "10", 0x91, 0x2a);
LPD8RK.hotcues["9126"][2] = new Array("[Channel2]", "11", 0x91, 0x26);
LPD8RK.hotcues["9124"][2] = new Array("[Channel2]", "12", 0x91, 0x24);
//bank 3
LPD8RK.hotcues["912c"][3] = new Array("[Channel2]", "13", 0x91, 0x2c);
LPD8RK.hotcues["9127"][3] = new Array("[Channel2]", "14", 0x91, 0x27);
LPD8RK.hotcues["912e"][3] = new Array("[Channel2]", "15", 0x91, 0x2e);
LPD8RK.hotcues["912a"][3] = new Array("[Channel2]", "16", 0x91, 0x2a);
LPD8RK.hotcues["9126"][3] = new Array("[Channel2]", "17", 0x91, 0x26);
LPD8RK.hotcues["9124"][3] = new Array("[Channel2]", "18", 0x91, 0x24);
//bank 4
LPD8RK.hotcues["912c"][4] = new Array("[Channel2]", "19", 0x91, 0x2c);
LPD8RK.hotcues["9127"][4] = new Array("[Channel2]", "20", 0x91, 0x27);
LPD8RK.hotcues["912e"][4] = new Array("[Channel2]", "21", 0x91, 0x2e);
LPD8RK.hotcues["912a"][4] = new Array("[Channel2]", "22", 0x91, 0x2a);
LPD8RK.hotcues["9126"][4] = new Array("[Channel2]", "23", 0x91, 0x26);
LPD8RK.hotcues["9124"][4] = new Array("[Channel2]", "24", 0x91, 0x24);
//bank 5
LPD8RK.hotcues["912c"][5] = new Array("[Channel2]", "25", 0x91, 0x2c);
LPD8RK.hotcues["9127"][5] = new Array("[Channel2]", "26", 0x91, 0x27);
LPD8RK.hotcues["912e"][5] = new Array("[Channel2]", "27", 0x91, 0x2e);
LPD8RK.hotcues["912a"][5] = new Array("[Channel2]", "28", 0x91, 0x2a);
LPD8RK.hotcues["9126"][5] = new Array("[Channel2]", "29", 0x91, 0x26);
LPD8RK.hotcues["9124"][5] = new Array("[Channel2]", "30", 0x91, 0x24);

//##################
//preset 3 (group, cuenum, status, ctrl)
//initialize
LPD8RK.hotcues["9248"] = new Array();
LPD8RK.hotcues["9241"] = new Array();
LPD8RK.hotcues["9247"] = new Array();
LPD8RK.hotcues["9240"] = new Array();
LPD8RK.hotcues["9245"] = new Array();
LPD8RK.hotcues["923e"] = new Array();
//bank 1
LPD8RK.hotcues["9248"][1] = new Array("[Sampler1]", "1", 0x92, 0x48);
LPD8RK.hotcues["9241"][1] = new Array("[Sampler1]", "2", 0x92, 0x41);
LPD8RK.hotcues["9247"][1] = new Array("[Sampler1]", "3", 0x92, 0x47);
LPD8RK.hotcues["9240"][1] = new Array("[Sampler1]", "4", 0x92, 0x40);
LPD8RK.hotcues["9245"][1] = new Array("[Sampler1]", "5", 0x92, 0x45);
LPD8RK.hotcues["923e"][1] = new Array("[Sampler1]", "6", 0x92, 0x3e);
//bank 2
LPD8RK.hotcues["9248"][2] = new Array("[Sampler1]", "7", 0x92, 0x48);
LPD8RK.hotcues["9241"][2] = new Array("[Sampler1]", "8", 0x92, 0x41);
LPD8RK.hotcues["9247"][2] = new Array("[Sampler1]", "9", 0x92, 0x47);
LPD8RK.hotcues["9240"][2] = new Array("[Sampler1]", "10", 0x92, 0x40);
LPD8RK.hotcues["9245"][2] = new Array("[Sampler1]", "11", 0x92, 0x45);
LPD8RK.hotcues["923e"][2] = new Array("[Sampler1]", "12", 0x92, 0x3e);
//bank 3
LPD8RK.hotcues["9248"][3] = new Array("[Sampler1]", "13", 0x92, 0x48);
LPD8RK.hotcues["9241"][3] = new Array("[Sampler1]", "14", 0x92, 0x41);
LPD8RK.hotcues["9247"][3] = new Array("[Sampler1]", "15", 0x92, 0x47);
LPD8RK.hotcues["9240"][3] = new Array("[Sampler1]", "16", 0x92, 0x40);
LPD8RK.hotcues["9245"][3] = new Array("[Sampler1]", "17", 0x92, 0x45);
LPD8RK.hotcues["923e"][3] = new Array("[Sampler1]", "18", 0x92, 0x3e);
//bank 4
LPD8RK.hotcues["9248"][4] = new Array("[Sampler1]", "19", 0x92, 0x48);
LPD8RK.hotcues["9241"][4] = new Array("[Sampler1]", "20", 0x92, 0x41);
LPD8RK.hotcues["9247"][4] = new Array("[Sampler1]", "21", 0x92, 0x47);
LPD8RK.hotcues["9240"][4] = new Array("[Sampler1]", "22", 0x92, 0x40);
LPD8RK.hotcues["9245"][4] = new Array("[Sampler1]", "23", 0x92, 0x45);
LPD8RK.hotcues["923e"][4] = new Array("[Sampler1]", "24", 0x92, 0x3e);
//bank 5
LPD8RK.hotcues["9248"][5] = new Array("[Sampler1]", "25", 0x92, 0x48);
LPD8RK.hotcues["9241"][5] = new Array("[Sampler1]", "26", 0x92, 0x41);
LPD8RK.hotcues["9247"][5] = new Array("[Sampler1]", "27", 0x92, 0x47);
LPD8RK.hotcues["9240"][5] = new Array("[Sampler1]", "28", 0x92, 0x40);
LPD8RK.hotcues["9245"][5] = new Array("[Sampler1]", "29", 0x92, 0x45);
LPD8RK.hotcues["923e"][5] = new Array("[Sampler1]", "30", 0x92, 0x3e);

//##################
//preset 4 (group, cuenum, status, ctrl)
//initialize
LPD8RK.hotcues["9330"] = new Array();
LPD8RK.hotcues["9329"] = new Array();
LPD8RK.hotcues["932f"] = new Array();
LPD8RK.hotcues["9328"] = new Array();
LPD8RK.hotcues["932d"] = new Array();
LPD8RK.hotcues["9326"] = new Array();
//bank 1
LPD8RK.hotcues["9330"][1] = new Array("[Sampler2]", "1", 0x93, 0x30);
LPD8RK.hotcues["9329"][1] = new Array("[Sampler2]", "2", 0x93, 0x29);
LPD8RK.hotcues["932f"][1] = new Array("[Sampler2]", "3", 0x93, 0x2f);
LPD8RK.hotcues["9328"][1] = new Array("[Sampler2]", "4", 0x93, 0x28);
LPD8RK.hotcues["932d"][1] = new Array("[Sampler2]", "5", 0x93, 0x2d);
LPD8RK.hotcues["9326"][1] = new Array("[Sampler2]", "6", 0x93, 0x26);
//bank 2
LPD8RK.hotcues["9330"][2] = new Array("[Sampler2]", "7", 0x93, 0x30);
LPD8RK.hotcues["9329"][2] = new Array("[Sampler2]", "8", 0x93, 0x29);
LPD8RK.hotcues["932f"][2] = new Array("[Sampler2]", "9", 0x93, 0x2f);
LPD8RK.hotcues["9328"][2] = new Array("[Sampler2]", "10", 0x93, 0x28);
LPD8RK.hotcues["932d"][2] = new Array("[Sampler2]", "11", 0x93, 0x2d);
LPD8RK.hotcues["9326"][2] = new Array("[Sampler2]", "12", 0x93, 0x26);
//bank 3
LPD8RK.hotcues["9330"][3] = new Array("[Sampler2]", "13", 0x93, 0x30);
LPD8RK.hotcues["9329"][3] = new Array("[Sampler2]", "14", 0x93, 0x29);
LPD8RK.hotcues["932f"][3] = new Array("[Sampler2]", "15", 0x93, 0x2f);
LPD8RK.hotcues["9328"][3] = new Array("[Sampler2]", "16", 0x93, 0x28);
LPD8RK.hotcues["932d"][3] = new Array("[Sampler2]", "17", 0x93, 0x2d);
LPD8RK.hotcues["9326"][3] = new Array("[Sampler2]", "18", 0x93, 0x26);
//bank 4
LPD8RK.hotcues["9330"][4] = new Array("[Sampler2]", "19", 0x93, 0x30);
LPD8RK.hotcues["9329"][4] = new Array("[Sampler2]", "20", 0x93, 0x29);
LPD8RK.hotcues["932f"][4] = new Array("[Sampler2]", "21", 0x93, 0x2f);
LPD8RK.hotcues["9328"][4] = new Array("[Sampler2]", "22", 0x93, 0x28);
LPD8RK.hotcues["932d"][4] = new Array("[Sampler2]", "23", 0x93, 0x2d);
LPD8RK.hotcues["9326"][4] = new Array("[Sampler2]", "24", 0x93, 0x26);
//bank 5
LPD8RK.hotcues["9330"][5] = new Array("[Sampler2]", "25", 0x93, 0x30);
LPD8RK.hotcues["9329"][5] = new Array("[Sampler2]", "26", 0x93, 0x29);
LPD8RK.hotcues["932f"][5] = new Array("[Sampler2]", "27", 0x93, 0x2f);
LPD8RK.hotcues["9328"][5] = new Array("[Sampler2]", "28", 0x93, 0x28);
LPD8RK.hotcues["932d"][5] = new Array("[Sampler2]", "29", 0x93, 0x2d);
LPD8RK.hotcues["9326"][5] = new Array("[Sampler2]", "30", 0x93, 0x26);




//map hotcue loop and leds
LPD8RK.loops = new Array();
//preset 1 (group, beatloop_len, status, ctrl)
LPD8RK.loops["b09"] = new Array("[Channel1]", "1", 0xB0, 0x09);
LPD8RK.loops["b04"] = new Array("[Channel1]", "2", 0xB0, 0x04);
LPD8RK.loops["b08"] = new Array("[Channel1]", "4", 0xB0, 0x08);
LPD8RK.loops["b03"] = new Array("[Channel1]", "8", 0xB0, 0x03);

//preset 2 (group, beatloop_len, status, ctrl)
LPD8RK.loops["b19"] = new Array("[Channel2]", "1", 0xB1, 0x09);
LPD8RK.loops["b14"] = new Array("[Channel2]", "2", 0xB1, 0x04);
LPD8RK.loops["b18"] = new Array("[Channel2]", "4", 0xB1, 0x08);
LPD8RK.loops["b13"] = new Array("[Channel2]", "8", 0xB1, 0x03);

//preset 3 (group, beatloop_len, status, ctrl)
LPD8RK.loops["b29"] = new Array("[Sampler1]", "1", 0xB2, 0x09);
LPD8RK.loops["b24"] = new Array("[Sampler1]", "2", 0xB2, 0x04);
LPD8RK.loops["b28"] = new Array("[Sampler1]", "4", 0xB2, 0x08);
LPD8RK.loops["b23"] = new Array("[Sampler1]", "8", 0xB2, 0x03);

//preset 4 (group, beatloop_len, status, ctrl)
LPD8RK.loops["b39"] = new Array("[Sampler2]", "1", 0xB3, 0x09);
LPD8RK.loops["b34"] = new Array("[Sampler2]", "2", 0xB3, 0x04);
LPD8RK.loops["b38"] = new Array("[Sampler2]", "4", 0xB3, 0x08);
LPD8RK.loops["b33"] = new Array("[Sampler2]", "8", 0xB3, 0x03);



LPD8RK.init = function (id, debug) { // called when the device is opened & set up
	if (LPD8RK.debug){print("###init##############")};
	//soft takeovers
	engine.softTakeover("[Master]","crossfader",true);
	engine.softTakeover("[Channel1]","volume",true);
	engine.softTakeover("[Channel1]","rate",true);
	engine.softTakeover("[Channel2]","volume",true);
	engine.softTakeover("[Channel2]","rate",true);
	engine.softTakeover("[Sampler1]","volume",true);
	engine.softTakeover("[Sampler1]","rate",true);
	engine.softTakeover("[Sampler2]","volume",true);
	engine.softTakeover("[Sampler2]","rate",true);
	
	//set LED timer
	LPD8RK.ledTimer = engine.beginTimer(LPD8RK.LEDinterval, "LPD8RK.setLeds()");
};

LPD8RK.shutdown = function () {
	engine.stopTimer(LPD8RK.ledTimer);
};

LPD8RK.resetLEDTimer = function () {
	engine.stopTimer(LPD8RK.ledTimer);
	LPD8RK.setLeds()
	LPD8RK.ledTimer = engine.beginTimer(LPD8RK.LEDinterval, "LPD8RK.setLeds()");
};

LPD8RK.setLeds = function () {
	//runs repeatedly on a timer set in init()
	//has to run on a timer because you apparently can only set LEDs on the current prog selection on the LPD8
	//ie: leds on a PAD or CC other than the one you're currently using can't be set.
	//and no midi messages are sent when you change a PROG or pad.  No way of telling MIXXX which LEDs are currently active
	//so, this runs 4x a second to make sure LEDs are updated.  Kludge, but so it goes.

	//hotcues
	for (var id in LPD8RK.hotcues){
		for (var bank in LPD8RK.hotcues[id]){
			//iterate through hotcues for current bank, set hotcue leds
			var status = LPD8RK.hotcues[id][LPD8RK.hotcueBank][2];
			var ctrl = LPD8RK.hotcues[id][LPD8RK.hotcueBank][3];
			var state = engine.getValue(LPD8RK.hotcues[id][LPD8RK.hotcueBank][0], "hotcue_"+LPD8RK.hotcues[id][LPD8RK.hotcueBank][1]+"_enabled");

			//if (LPD8RK.debug){print("midi.sendShortMsg("+status+", "+ctrl+", "+state+")")};
			
			LPD8RK.lightLED(status, ctrl, state);
			};
		};
	
	//loops
	for (var id in LPD8RK.loops){
		//iterate through hotcues, set hotcue leds
		var status = LPD8RK.loops[id][2];
		var ctrl = LPD8RK.loops[id][3];
		var state = engine.getValue(LPD8RK.loops[id][0], "beatloop_"+LPD8RK.loops[id][1]+"_enabled");

		//if (LPD8RK.debug){print("midi.sendShortMsg("+status+", "+ctrl+", "+state+")")};
	
		LPD8RK.lightLED(status, ctrl, state);
		};
	
	//reloop buttons
	LPD8RK.lightLED(0xb0, 0x01, engine.getValue("[Channel1]", "loop_enabled"));	
	LPD8RK.lightLED(0xb1, 0x01, engine.getValue("[Channel2]", "loop_enabled"));	
	LPD8RK.lightLED(0xb2, 0x01, engine.getValue("[Sampler1]", "loop_enabled"));	
	LPD8RK.lightLED(0xb3, 0x01, engine.getValue("[Sampler2]", "loop_enabled"));	
	};

LPD8RK.lightLED = function (status, ctrl, state){
	//function to check for valid LED lighting messages - LPD8 seems to go into a weird nonresponsive mode when some unknown code is sent to it
	//don't know what the messed code is, but this function checks for valid LED addresses.  Hopefully this will prevent problems.
	if (LPD8RK.validLEDS[status][ctrl] !== true){
		print("######## INVALID STATUS ########");
		return false;
		} else {
		if (state > 0 || state === true){state=1;}//make sure state is valid
		midi.sendShortMsg(status, ctrl, state);
		}
	};	
	
LPD8RK.clear = function (){//enables hotcue clearing
	if (LPD8RK.debug){print("###hotcueclear##############")};
	LPD8RK.hotcueClear=true;
	};

LPD8RK.noclear = function (){//disables hotcue clearing
	LPD8RK.hotcueClear=false;
	};

LPD8RK.hotcueButton = function (channel, control, value, status, group) {
	//weird status bug workaround
	if (channel==0 && status != 0x90){status = 0x90};
	if (channel==1 && status != 0x91){status = 0x91};
	if (channel==2 && status != 0x92){status = 0x92};
	if (channel==3 && status != 0x93){status = 0x93};

	if (LPD8RK.debug){print("###hotcueButton##############")};
	if (LPD8RK.debug){print("status:"+status)};
	if (LPD8RK.debug){print("channel:"+channel)};
	if (LPD8RK.debug){print("control:"+control)};
	if (LPD8RK.debug){print("hotcuebank:"+LPD8RK.hotcueBank)};
	if (LPD8RK.debug){print("phrase:#"+status.toString(16).toLowerCase()+control.toString(16).toLowerCase()+"#")};
	//activate or clear depending on whether clear button is pressed
	var thecue = LPD8RK.hotcues[status.toString(16).toLowerCase()+control.toString(16).toLowerCase()][LPD8RK.hotcueBank];
	if (LPD8RK.hotcueClear){
		engine.setValue(thecue[0], "hotcue_"+thecue[1]+"_clear", 1);
		engine.setValue(thecue[0], "hotcue_"+thecue[1]+"_clear", 0);
		if (LPD8RK.debug){print("cleared")};
		} else {
		engine.setValue(thecue[0], "hotcue_"+thecue[1]+"_activate", 1);
		engine.setValue(thecue[0], "hotcue_"+thecue[1]+"_activate", 0);
		if (LPD8RK.debug){print("###"+status.toString(16).toLowerCase()+control.toString(16).toLowerCase()+"--activated")};
		};

	};

LPD8RK.loopButton = function (channel, control, value, status, group) {
	if (LPD8RK.debug){print(LPD8RK.looplen+"len");}
	if (LPD8RK.debug){print(LPD8RK.looptype+"type");}
	//activate beatloop
	var theloop = LPD8RK.loops[status.toString(16).toLowerCase()+control.toString(16).toLowerCase()];
	if (value>0){//button was pressed
		LPD8RK.loopbuttonDown=true;
		engine.setValue(group, LPD8RK.looptype+"_"+theloop[1]+"_activate", 1);
		} else {//button was released
		LPD8RK.loopbuttonDown=false;
		};

	};

LPD8RK.reloopButton = function (channel, control, value, status, group) {
	if (LPD8RK.debug){print(LPD8RK.looplen+"len");}
	if (LPD8RK.debug){print(LPD8RK.looptype+"type");}
	
	if (value>0){//button was pressed
		engine.stopTimer(LPD8RK.reloopTimer);
		LPD8RK.loopbuttonDown=true;
		LPD8RK.doreloop=true;
		LPD8RK.reloopTimer = engine.beginTimer(500, "LPD8RK.disablereloop()", true);
		} else {//button was released
		LPD8RK.loopbuttonDown=false;
		if (LPD8RK.doreloop===true) {engine.setValue(group, "reloop_exit", 1);};
		LPD8RK.doreloop=true;
		engine.stopTimer(LPD8RK.reloopTimer);
		};

	};

LPD8RK.disablereloop = function () {
	//timed function - fires half a second after pressing reloop.  Don't do the reloop if you hold down the button (so you can move the loop without exiting)
	LPD8RK.doreloop=false;
	};

LPD8RK.looptypeDial = function (channel, control, value, status, group) {
	//activates variable length type depending on dial position
	//beatlooproll only works in 1.11 or above - script is a placeholder, knob used to select hotcue bank for now
	//if(value>63){LPD8RK.looptype="beatlooproll";}else{LPD8RK.looptype="beatloop";}
	//if (LPD8RK.debug){print(LPD8RK.looptype);}
	};

LPD8RK.resetOldBank = function () {
	//clears stored old hotcue bank
	LPD8RK.oldHotcueBank=0;
	};

LPD8RK.hotcueBankDial = function (channel, control, value, status, group) {
	//sets which hotcue bank to display (separate this out on dedicated controller)
	
	//pause LED resets, so bank indicator lights will be visible
	engine.stopTimer(LPD8RK.ledTimer);

	//select hotcue bank
	if (value>=0 && value <=12){LPD8RK.hotcueBank=1;};
	if (value>12 && value <=46){LPD8RK.hotcueBank=2;};
	if (value>46 && value <=80){LPD8RK.hotcueBank=3;};
	if (value>80 && value <=114){LPD8RK.hotcueBank=4;};
	if (value>114 && value <=128){LPD8RK.hotcueBank=5;};

	//light up indicator light
	if (LPD8RK.oldHotcueBank != LPD8RK.hotcueBank){//check if the bank's changed.  If it has, change the LEDs - LPD8RK.oldHotcueBank != LPD8RK.hotcueBank
		for (var id in LPD8RK.hotcues){
			for (var bank in LPD8RK.hotcues[id][1]){
				var status = LPD8RK.hotcues[id][1][2];
				var ctrl = LPD8RK.hotcues[id][1][3];
				//find bank number indicator light
				if (LPD8RK.hotcues[id][1][1]==LPD8RK.hotcueBank){
					var state = 1;
					}else{
					var state = 0;
					};

				LPD8RK.lightLED(status, ctrl, state);
				};
			};
		};
	//record last hotcue bank
	LPD8RK.oldHotcueBank=LPD8RK.hotcueBank;
	//set timer to clear old bank number after 500 msec, so bank indicator light will light up
	engine.stopTimer(LPD8RK.oldbanktimer);
	LPD8RK.oldbanktimer = engine.beginTimer(500, "LPD8RK.resetOldBank()", true);	

	//set timer to restart LED updates in 500 msec
	engine.stopTimer(LPD8RK.LEDPauseTimer);
	LPD8RK.LEDPauseTimer = engine.beginTimer(LPD8RK.LEDinterval, "LPD8RK.resetLEDTimer()", true);	
	};

LPD8RK.looplenDial = function (channel, control, value, status, group) {
	//activates variable length loop depending on dial position
	LPD8RK.looplen=value;

	if (LPD8RK.loopbuttonDown !== true){return false;}//exit if no loop button down 
	else if (LPD8RK.looplen<=0x12){engine.setValue(group, LPD8RK.looptype+"_0.0625_activate", .0625);return true;} else 
	if (LPD8RK.looplen<=0x25){engine.setValue(group, LPD8RK.looptype+"_0.125_activate", .125);return true;} else 
	if (LPD8RK.looplen<=0x37){engine.setValue(group, LPD8RK.looptype+"_0.25_activate", .25);return true;} else 
	if (LPD8RK.looplen<=0x49){engine.setValue(group, LPD8RK.looptype+"_0.5_activate", .5);return true;} else 
	if (LPD8RK.looplen<=0x5b){engine.setValue(group, LPD8RK.looptype+"_1_activate", 1);return true;} else 
	if (LPD8RK.looplen<=0x6d){engine.setValue(group, LPD8RK.looptype+"_2_activate", 2);return true;} else 
	if (LPD8RK.looplen<=0x70){engine.setValue(group, LPD8RK.looptype+"_4_activate", 4);return true;} else	
	if (LPD8RK.looplen<=0x7f){engine.setValue(group, LPD8RK.looptype+"_8_activate", 8);return true;};	
	};

LPD8RK.loopminus = function (channel, control, value, status, group) {
	//shrinks loop or moves loop back
	if (LPD8RK.loopbuttonDown !== true){engine.setValue(group, "loop_halve", 1);engine.setValue(group, "loop_halve", 0); return false;}//shrink loop if no loop button down 
	else if (engine.getValue(group, "loop_start_position")>=0 && engine.getValue(group, "loop_end_position")>=0 ){
		//move loop
		var interval =	LPD8RK.loopmove*engine.getValue(group, "track_samples")/engine.getValue(group, "duration");
		var start = engine.getValue(group, "loop_start_position");
		var end = engine.getValue(group, "loop_end_position");
		engine.setValue(group, "loop_start_position", start-interval);
		engine.setValue(group, "loop_end_position", end-interval);
		return true;
		};
	};

LPD8RK.loopplus = function (channel, control, value, status, group) {
	//grows loop or moves loop forward
	if (LPD8RK.loopbuttonDown !== true){engine.setValue(group, "loop_double", 1); engine.setValue(group, "loop_double", 0); return false;}//shrink loop if no loop button down 
	else if (engine.getValue(group, "loop_start_position")>=0 && engine.getValue(group, "loop_end_position")>=0 ){
		//move loop
		var interval =	LPD8RK.loopmove*engine.getValue(group, "track_samples")/engine.getValue(group, "duration");
		var start = engine.getValue(group, "loop_start_position");
		var end = engine.getValue(group, "loop_end_position");
		engine.setValue(group, "loop_start_position", start+interval);
		engine.setValue(group, "loop_end_position", end+interval);
		return true;
		};
	};

LPD8RK.beatjump = function (channel, control, value, status, group) {
	//jumps back certain number of beats depending on knob modifier
	var curpos = engine.getValue(group, "playposition")*engine.getValue(group, "track_samples");
	var numbeats = LPD8RK.beatjumpstep;
	var backseconds = numbeats*(1/(engine.getValue(group, "bpm")/60));
	var backsamples = backseconds*engine.getValue(group, "track_samples")/engine.getValue(group, "duration");
	var newpos = curpos-(backsamples+engine.getValue("Master", "latency"));
	
	if (LPD8RK.debug){print("backseconds: "+backseconds);}
	if (LPD8RK.debug){print("backsamples: "+backsamples);}
	if (LPD8RK.debug){print("curpos: "+curpos);}
	if (LPD8RK.debug){print("newpos: "+newpos);}
	if (LPD8RK.debug){print("numbeats: "+numbeats);}
	
	engine.setValue(group, "playposition", newpos/engine.getValue(group, "track_samples"));
	};

LPD8RK.beatjumpDial = function (channel, control, value, status, group) {
	//activates variable length loop depending on dial position
	if(value>=0 && value <=127){
		if (value<=1){LPD8RK.beatjumpstep=.25; return true;} else 
		if (value<=31){LPD8RK.beatjumpstep=.5; return true;} else 	
		if (value<=63){LPD8RK.beatjumpstep=1; return true;} else 	
		if (value<=94){LPD8RK.beatjumpstep=2; return true;} else 	
		if (value<=125){LPD8RK.beatjumpstep=4; return true;} else 	
		if (value<=127){LPD8RK.beatjumpstep=8; return true;};
		};	
	};

LPD8RK.mute = function (group) {
	//toggles mute, then returns to previous volume
	storedvol=LPD8RK.vol[group];
	curvol=engine.getValue(group, "volume");
	engine.softTakeover(group,"volume",false);
	if (curvol==0){//is muted.  unmute.
		engine.setValue(group, "volume", storedvol);
		}else{//is not muted.  mute.
		engine.setValue(group, "volume", 0);
		LPD8RK.vol[group]=curvol;
		};
	engine.softTakeover(group,"volume",true);
	
	if (LPD8RK.debug){print("MUTE");}
	};

LPD8RK.progChng = function (channel, control, value, status, group) {
	if (LPD8RK.debug){print("###PROG CHANGE###");}
	//workaround because prog chng buttons don't seem to like to work unless they're linked to scripts
	if (control==0x07){LPD8RK.toggleplay(group, engine.getValue(group, "play")); return true;} else 
	if (control==0x03){engine.setValue(group, "cue_default", true); engine.setValue(group, "cue_default", false); return true;} else 
	if (control==0x06){engine.setValue(group, "beatsync", true); engine.setValue(group, "beatsync", false); return true;} else 
	if (control==0x02){LPD8RK.togglepfl(group, engine.getValue(group, "pfl")); return true;} else 
	if (control==0x05){LPD8RK.togglereverse(group, engine.getValue(group, "reverse")); return true;} else 
	if (control==0x04){LPD8RK.toggleback(group, engine.getValue(group, "back")); return true;} else 
	if (control==0x00){LPD8RK.togglefwd(group, engine.getValue(group, "fwd")); return true;}
	if (control==0x01){LPD8RK.mute(group); return true;}
	};

LPD8RK.toggleplay = function (group, state) {
	if (state==true){engine.setValue(group, "reverse",0);engine.setValue(group, "play", false);} else {engine.setValue(group, "reverse",0);engine.setValue(group, "play", true);};
	};

LPD8RK.togglepfl = function (group, state) {
	if (state==true){engine.setValue(group, "pfl", false);} else {engine.setValue(group, "pfl", true);};
	};

LPD8RK.togglereverse = function (group, state) {
	if (state==true){engine.setValue(group, "reverse", false);} else {engine.setValue(group, "reverse", true);};	
	};

LPD8RK.toggleback = function (group, state) {
	if (state==true){engine.setValue(group, "back", false);} else {engine.setValue(group, "back", true);};	
	};

LPD8RK.togglefwd = function (group, state) {
	if (state==true){engine.setValue(group, "fwd", false);} else {engine.setValue(group, "fwd", true);};	
	};

LPD8RK.softXfade = function (channel, control, value, status, group) {
	engine.setValue(group, "crossfader", (value/64)-1);
	};

LPD8RK.softVolume = function (channel, control, value, status, group) {
	engine.setValue(group, "volume", (value/127));
	};

LPD8RK.softRate = function (channel, control, value, status, group) {
	engine.setValue(group, "rate", (value/64)-1);
	};


LPD8RK.test = function (channel, control, value, status, group) {
	print("channel: "+channel);
	print("control: "+control.toString(16));
	print("value: "+value);
	print("status: "+status);
	print("group: "+group);
	print("test: ##"+status.toString(16)+control.toString(16)+"##");
	print("loopbuttondown: ##"+LPD8RK.loopbuttonDown+"##");
	print("LPD8RK.looplen: ##"+LPD8RK.looplen+"##");
	print("LPD8RK.looplen.tostring: ##"+LPD8RK.looplen.toString(16)+"##");
	print("LPD8RK.looptype: ##"+LPD8RK.looptype+"##");
	print("test: ##"+2+"##");
	};