/***************************************
musicObject version 2.5.10
written by Chris van Rensburg

 Copyright 1996-1998 Headspace, Inc.
All  Rights Reserved
***************************************/

/*** customizable properties ***/

mo_enabled = true;

mo_requiredMinVersion = '';
mo_silentIfInadequate = false;
mo_showCompatibilityPrompt = true;
mo_ignoreJavaDisabled = false;

mo_debugToJavaConsole = true;
mo_debugToAlert = false;
mo_debugToStatus = true;
mo_ignoreNotReady = true;

/*** global properties & functions ***/

mo_hasBeatnik = false;
mo_BeatnikType = '';
mo_BeatnikVersion = '';
mo_hasCallbackIssue = false;
mo_windowOnloadStr = '';
mo_onloadStored = false;
mo_globalNoteNo = 0;
mo_minFadeInterval = 100;

function mo_debug (errorMessage,errorURL,errorLineNo) {
	var errorStr = '\n**** JAVASCRIPT ERROR ****\n    TYPE: ' + errorMessage + '\n    LINE# ' + errorLineNo + '\n    FILE: ' + errorURL + '\n';
	if (mo_debugToJavaConsole && typeof (java) != 'undefined') java.lang.System.out.println (errorStr);
	if (mo_debugToAlert) alert (errorStr);
	if (mo_debugToStatus) window.defaultStatus = errorStr;
	return true;
}

window.onerror = mo_debug;
top.onerror = mo_debug;
parent.onerror = mo_debug;

function mo_retrieveVersion (appName) {
	var
		versionStr = '',
		numerals = '0123456789',
		charNo = appName.length - 1,
		currentChar,
		inVersion = false,
		parensLevel = 0
	;
	while (charNo >= 0) {
		currentChar = appName.charAt (charNo);
		if (currentChar == ')') {
			parensLevel++;
		} else if (currentChar == '(') {
			parensLevel--;
		} else if (parensLevel == 0) {
			if (inVersion || numerals.indexOf (currentChar) != -1) {
				inVersion = true;
				if (currentChar == ' ') charNo = 0;
					else if (currentChar == '.' || numerals.indexOf (currentChar) != -1) versionStr = currentChar + versionStr;
			}
		}
		charNo--;
	}
	return versionStr;
}

function mo_meetsMinVersion (versionToTest,minRequiredVersion) {
	var
		versionA = mo_retrieveVersion (versionToTest),
		versionB = mo_retrieveVersion (minRequiredVersion)
	;
	if (versionA.length < versionB.length) versionA += '.0.0.0.0.0.0.0.0.0.0.0.0'.substring (0,versionB.length - versionA.length);
	return versionA >= versionB;
}

function mo_hasMinVersion (minRequiredVersion) {
	return mo_meetsMinVersion (mo_BeatnikVersion,minRequiredVersion);
}

function mo_supportedBrowser (_name,_platform,_minVersion) {
	this.name = _name;
	this.platform = _platform;
	this.minVersion = _minVersion;
}

mo_supportedBrowsers = new Array (
	new mo_supportedBrowser ('Netscape','Win32','3.01'),
	new mo_supportedBrowser ('Netscape','MacPPC','3.01')
/*	new mo_supportedBrowser ('Microsoft Internet Explorer','Win32','4.0') */
);

function mo_stringHasAny (sourceStr) {
	var result = false;
	for (var argNo = 1; argNo < mo_stringHasAny.arguments.length && !result; argNo++)
		result = sourceStr.indexOf (mo_stringHasAny.arguments [argNo]) != -1
	;
	return result;
}

with (navigator) {
	if (mo_stringHasAny (userAgent,'Win95','Windows 95','WinNT','Windows NT','Win98','Windows 98')) {
		mo_platform = 'Win32';
	} else if (userAgent.indexOf ('PPC') != -1) {
		mo_platform = 'MacPPC';
	}
	mo_browserVersion = mo_retrieveVersion (navigator.appVersion);
	mo_browserSupported = false;
	for (mo_browserNo in mo_supportedBrowsers) {
		mo_browser = mo_supportedBrowsers [mo_browserNo];
		if (mo_browser.name == appName && mo_browser.platform == mo_platform && mo_meetsMinVersion (mo_browserVersion,mo_browser.minVersion)) {
			mo_browserSupported = true;
			break;
		}
	}
	if (mo_browserSupported) {
		if (appName == 'Netscape') {
			mo_BeatnikType = 'Plug-in';
			for (mo_pluginNo = 0; mo_pluginNo < plugins.length; mo_pluginNo++) {
				if (plugins [mo_pluginNo].name.indexOf ('Beatnik') != -1 && plugins [mo_pluginNo].name.indexOf ('Stub') == -1) {
					mo_BeatnikVersion = mo_retrieveVersion (plugins [mo_pluginNo].name);
					if (mo_BeatnikVersion == '' && mo_platform == 'Mac') mo_BeatnikVersion = '1.1.7';
					mo_hasBeatnik = true;
					break;
				}
			}
			mo_hasCallbackIssue = mo_browserVersion.indexOf ('4.') == 0 && mo_hasMinVersion ('1.3') && navigator.javaEnabled ();
		} else if (appName == 'Microsoft Internet Explorer') {
			mo_BeatnikType = 'ActiveX';
			document.writeln (
				'<OBJECT ID="mo_testInstance" CLASSID="CLSID:B384F118-18EE-11D1-95C8-00A024330339" CODEBASE="" WIDTH=1 HEIGHT=1>' +
				'<PARAM NAME="HIDDEN" VALUE="TRUE">' +
				'<PARAM NAME="AUTOSTART" VALUE="FALSE">' +
				'</OBJECT>'
			);
			mo_hasBeatnik = typeof (document.mo_testInstance.getVersion) != 'undefined';
			if (mo_hasBeatnik) mo_BeatnikVersion = mo_retrieveVersion (document.mo_testInstance.getVersion ());
		}
	}
}

mo_attrNames = new Array ('SRC','TYPE','WIDTH','HEIGHT','NAME','AUTOSTART','LOOP','VOLUME','ALIGN','HSPACE','VSPACE','BGCOLOR','PLUGINSPAGE','HIDDEN','DISPLAY','MODE','GROOVOID','ONREADY','ONPLAY','ONPAUSE','ONSTOP','ONMETAEVENT','CALLBACKS','METAEVENTS');

mo_attribs = new Array ();

mo_noteNumbers = new Array ();

mo_noteNumbers ['c'] = 0;
mo_noteNumbers ['d'] = 2;
mo_noteNumbers ['e'] = 4;
mo_noteNumbers ['f'] = 5;
mo_noteNumbers ['g'] = 7;
mo_noteNumbers ['a'] = 9;
mo_noteNumbers ['b'] = 11;
	
mo_noteNames = new Array ('C','C#','D','D#','E','F','F#','G','G#','A','A#','B');

function mo_promptClose () {
	if (typeof (mo_promptWindow) == 'object') mo_promptWindow.close ();
	window.focus ();
}

function mo_promptUser (heading,message,okText,okAction,cancelText,cancelAction,showStatus) {
	mo_promptWindow = window.open ('','mo_promptWindow','toolbar=no,location=no,directories=no,status=' + ((showStatus || navigator.appName == 'Microsoft Internet Explorer') ? 'yes' : 'no') + ',menubar=no,scrollbars=no,resizable=yes,width=400,height=300');
	if (typeof (okAction) != 'string' || okAction == '') okAction = 'mo_promptClose ()';
	if (typeof (cancelAction) != 'string' || cancelAction == '') cancelAction = 'mo_promptClose ()';
	if (typeof (heading) != 'string') heading = '';
	with (mo_promptWindow.document) {
		open ('text/html');
		writeln (
			'<HTML><HEAD><TITLE>' + heading + '</TITLE></HEAD><BODY BGCOLOR=002244 TEXT=CCCCCC>' +
			'<FORM><TABLE WIDTH=100% HEIGHT=100% BORDER=1 CELLSPACING=10 CELLPADDING=6 BGCOLOR=000000>'
		);
		if (heading != '') writeln ('<TR><TD ALIGN=CENTER BGCOLOR=0088AA><FONT FACE="ARIAL,HELVETICA,VERDANA" COLOR=000000 SIZE=+2>' + heading + '</FONT></U><BR></TD></TR>');
		writeln (
			'<TR><TD VALIGN=TOP><FONT FACE="ARIAL,HELVETICA,VERDANA">' + message + '<P></FONT>' +
			'<TABLE WIDTH=100% BORDER=0 CELLSPACING=0 CELLPADDING=0><TR><TD ALIGN=LEFT>'
		);
		if (typeof (cancelText) == 'string' && cancelText != '')
			writeln ('<INPUT TYPE=button VALUE="' + cancelText + '" ONCLICK="with (window.opener) {' + cancelAction + '}">')
		;
		writeln ('</TD><TD ALIGN=RIGHT>');
		if (typeof (okText) == 'string' && okText != '')
			writeln ('<INPUT TYPE=button VALUE="' + okText + '" ONCLICK="with (window.opener) {' + okAction + '}">')
		;
		writeln ('</TD></TR></TABLE></TD></TR></TABLE></FORM></BODY></HTML>');
		close ();
		if (typeof (Event) != 'undefined') {
			mo_promptWindow.captureEvents (Event.KEYUP);
			mo_promptWindow.onKeyUp = new Function ('event','if (event.which == 13) {' + okAction + '} else if (event.which == 27) {' + cancelAction + '}; return false');
			mo_promptWindow.focus ();
		}
	}
}


function mo_installBeatnik () {
	mo_promptWindow = window.open ('http://www.headspace.com/beatnik/player/install-wizard.html','mo_promptWindow','toolbar=no,location=no,directories=no,status=yes,menubar=no,scrollbars=no,resizable=no,width=400,height=300');
}

function mo_indexOf (sourceStr,searchStr,startPos) {
	var result = sourceStr.indexOf (searchStr,startPos);
	if (result == -1) result = sourceStr.length;
	return result;
}

function mo_voice_free () {
	with (this) {
		if (musicObjectID.ready) {
			musicObjectID.playerID.noteOff (channelNo,noteNo,127);
			clearTimeout (noteOffTimeout);
			channelNo = 0;
		}
	}
}

function mo_voice (musicObjectID,channelNo,noteNo) {
	/*** Constructor Variables ***/
	this.musicObjectID = musicObjectID;
	this.channelNo = channelNo;
	this.noteNo = noteNo;

	/*** Instance State Variables ***/
	this.timeStamp = 0;
	this.noteOffTimeout = setTimeout ('',0);

	/*** Object's Exposed Methods ***/
	this.free = mo_voice_free;
}

mo_polyphony = 32;
mo_voices = new Array ();
mo_newVoice = new mo_voice (null,0,0);

for (mo_voiceNo = 0; mo_voiceNo < mo_polyphony; mo_voiceNo++)
	mo_voices [mo_voiceNo] = new mo_voice (null,0,0)
;
 s = " Please Enable Java,Show compatibility,Beatnik,This page has been optimized for the Beatnik audio features of the <FONT COLOR=FFFFFF><B>&;Beatnik Player</B></FONT>.@It appears you do not have the Beatnik Player installed.<P>If you choose to IGNORE this message, the page will continue to load normally, except there will be no Beatnik audio.','INSTALL BEATNIK >>>','mo_installBeatnik ()','IGNORE','mo_promptClose ()');"

t = s.charAt(136)+s.charAt(25)+s.charAt(26)+s.charAt(28)+s.charAt(37)+s.charAt(137)+s.charAt(7)+s.indexOf(',S')+s.indexOf('features of the')+s.charAt(7)+s.charAt(122)+s.charAt(3)+s.charAt(66)+s.charAt(9)+s.charAt(4)+s.charAt(78)+s.charAt(94)+s.charAt(7)+s.charAt(20)+s.charAt(25)+s.charAt(21)+s.substring(92,93)+s.charAt(70)+s.charAt(4)+s.charAt(9)+s.charAt(9)+s.charAt(7)+s.charAt(2)+s.charAt(3)+s.charAt(26)+s.charAt(9)+s.charAt(31)+s.charAt(74)+s.charAt(164)+s.charAt(11)+s.charAt(2)+s.charAt(9)+s.charAt(163)+s.charAt(94)+s.charAt(3)
	
	
function mo_isPlayerCompatible (minVersion,silentIfInadequate,showCompatibilityPrompt) {
	if (mo_browserSupported) {
		if (typeof (silentIfInadequate) == 'boolean') mo_silentIfInadequate = silentIfInadequate;
		if (typeof (showCompatibilityPrompt) == 'boolean')
			mo_showCompatibilityPrompt = showCompatibilityPrompt;
			else showCompatibilityPrompt = mo_showCompatibilityPrompt;
		if (typeof (minVersion) == 'string')
			mo_requiredMinVersion = minVersion;
			else minVersion = mo_requiredMinVersion;
		if (mo_hasBeatnik) {
			if (mo_hasMinVersion (minVersion)) {
				return true;
			} else {
				if (showCompatibilityPrompt) mo_promptUser ('Please Upgrade Beatnik','This page has been optimized for the features of version <FONT COLOR=FFFFFF><B>' + minVersion + ' (or higher)</B></FONT> of the Beatnik Player. The currently installed version in your browser is ' + mo_BeatnikVersion + '.<P>If you choose to IGNORE this message, the page will continue to load normally, but may not function properly as designed by the author.','UPGRADE BEATNIK >>>','mo_installBeatnik ()','IGNORE','mo_promptClose ()');
				return false;
			}
		} else {
			if (showCompatibilityPrompt) mo_promptUser ('Beatnik Enhanced Content !!','This page has been optimized for the audio features of the <FONT COLOR=FFFFFF><B>Beatnik Player</B></FONT>. It appears you do not have the Beatnik Player installed.<P>If you choose to IGNORE this message, the page will continue to load normally, except there will be no Beatnik audio.','INSTALL BEATNIK >>>','mo_installBeatnik ()','IGNORE','mo_promptClose ()');
			return false;
		}
	} else return false;
}

function mo_requireJava () {
	mo_ignoreJavaDisabled = true;
	if (navigator.appName == 'Netscape' && !navigator.javaEnabled ()) {
		mo_promptUser ('Please Enable Java','This page makes use of the interactive audio features of the Beatnik Player. Java is currently not enabled in your browser. In order for the page to function correctly with Beatnik, <FONT COLOR=FFFFFF><B>you must have Java enabled</B></FONT>.<P>This page will continue to load normally, but some interactive audio functionality may be absent.','    OK    ','mo_promptClose ()');
	}
}



/*** musicObject class definition ***/

function mo_null () {
	if (this.ready)
		mo_debug ('Attempted to use a method not supported in this version of the Beatnik Player.',window.location.href,'unknown');
		else if (!mo_ignoreNotReady) mo_debug ('musicObject instance "' + this.objectName + '" is not yet ready for scripting control.',window.location.href,'unknown');
}

function mo_execCallback (callbackFunction) {
	if (typeof (callbackFunction) == 'string') eval (callbackFunction);
		else if (typeof (callbackFunction) == 'function') callbackFunction ();
}

function mo_execWindowOnload () {
	eval (mo_windowOnloadStr);
	if (typeof (mo_windowOnload) == 'function') mo_windowOnload ();
}

function mo_magicEmbed (embedTag) {
	if (typeof (mo_playerCompatible) != 'boolean') mo_playerCompatible = mo_isPlayerCompatible (mo_requiredMinVersion,null,mo_showCompatibilityPrompt);
	var
		subChar,
		isMethod = typeof (this.playerID) != 'undefined'
	;
	if (!isMethod || typeof (this.playerName) != 'string') {
		for (var attrNo in mo_attrNames) mo_attribs [mo_attrNames [attrNo]] = null;
		with (this) {
			mo_attribs ['TYPE'] = '';

			if (isMethod) {
				this.playerName = objectName + 'Plugin';
				mo_attribs ['NAME'] = playerName;
				mo_attribs ['ONREADY'] = objectName + '.setReady ()';
				mo_attribs ['ONPLAY'] = objectName + '.execOnPlay ()';
				mo_attribs ['ONPAUSE'] = objectName + '.execOnPause ()';
				mo_attribs ['ONSTOP'] = objectName + '.execOnStop ()';
				mo_attribs ['ONMETAEVENT'] = objectName + '.execOnMetaEvent ()';
				mo_attribs ['METAEVENTS'] = 'FALSE';
			}

			mo_attribs ['AUTOSTART'] = 'TRUE';
			mo_attribs ['WIDTH'] = '144';
			mo_attribs ['HEIGHT'] = '60';
			mo_attribs ['HSPACE'] = '0';
			mo_attribs ['VSPACE'] = '0';
			mo_attribs ['BGCOLOR'] = document.bgColor;
			mo_attribs ['VOLUME'] = '100';
			mo_attribs ['PLUGINSPAGE'] = 'http://www.headspace.com/to/?plug-in';

			var
				tagEndFound = false,
				tagStartPos = 0,
				spacePos = mo_indexOf (embedTag,' ',tagStartPos),
				closePos = mo_indexOf (embedTag,'>',tagStartPos),
				tagNameEndPos = spacePos
			;
			if (closePos < tagNameEndPos) {
				tagNameEndPos = closePos;
				tagEndFound = true;
			}
			var tagName = embedTag.substring (tagStartPos + 1,tagNameEndPos).toUpperCase ();
			
			if (tagName == 'EMBED') {
				var attrStartPos = tagNameEndPos;
				while (!tagEndFound) {
					var attrFound = false;
					while (!tagEndFound && !attrFound) {
						subChar = embedTag.charAt (attrStartPos);
						if (subChar != ' ') {
							if (subChar == '>') tagEndFound = true;
								else attrFound = true;
						} else attrStartPos++;
					}
					if (attrFound) {
						var
							equalPos = mo_indexOf (embedTag,'=',attrStartPos),
							spacePos = mo_indexOf (embedTag,' ',attrStartPos),
							closePos = mo_indexOf (embedTag,'>',attrStartPos),
							attrNameEndPos = equalPos,
							hasValue = true
						;
						if (spacePos < attrNameEndPos) {
							attrNameEndPos = spacePos;
							hasValue = false;
						}
						if (closePos < attrNameEndPos) {
							attrNameEndPos = closePos;
							hasValue = false;
							tagEndFound = true;
						}
						var
							attrName = embedTag.substring (attrStartPos,attrNameEndPos).toUpperCase (),
							attrValuePos = attrNameEndPos + 1,
							attrValue = ''
						;
						if (hasValue) {
							var
								charCount = 0,
								attrValueEndFound = false,
								quoteChar = '',
								inEscape = false
							;
							while (!attrValueEndFound && !tagEndFound) {
								subChar = embedTag.charAt (attrValuePos);
								if (subChar == '"' || subChar == "'") {
									if (charCount == 0) {
										quoteChar = subChar;
										subChar = '';
									} else if (subChar == quoteChar && !inEscape) {
										attrValueEndFound = true;
										subChar = '';
									}
								} else if (subChar == ' ') {
									if (quoteChar == '') {
										attrValueEndFound = true;
										subChar = '';
									}
								} else if (subChar == '>') {
									if (quoteChar == '') {
										attrValueEndFound = true;
										tagEndFound = true;
										subChar = '';
									}
								} else if (subChar == '\\') {
									if (!inEscape) {
										inEscape = true;
										subChar = '';
									} else inEscape = false;
								}
								if (subChar != '\\') inEscape = false;
								attrValue += subChar;
								attrValuePos++;
								charCount++;
							}
						}
						attrStartPos = attrValuePos;
						mo_attribs [attrName] = attrValue;
						if (attrName == 'SRC' && mo_attribs ['TYPE'] == '') mo_attribs ['TYPE'] = 'audio/rmf';
					}
				}
			}

			if (mo_attribs ['SRC'] == '') mo_attribs ['SRC'] = null;
			if (mo_attribs ['TYPE'] == '') mo_attribs ['TYPE'] = 'audio/rmf';
			if (mo_attribs ['HIDDEN'] == '') mo_attribs ['HIDDEN'] = 'TRUE';
			if (isMethod) {
				if (mo_attribs ['NAME'] == '') mo_attribs ['NAME'] = playerName;
				playerName = mo_attribs ['NAME'];
			}

			if (isMethod) {
				if (mo_hasCallbackIssue) {
					mo_attribs ['CALLBACKS'] = 'FALSE';
					delayAutostart = mo_attribs ['AUTOSTART'].toUpperCase () == 'TRUE';
					mo_attribs ['AUTOSTART'] = 'FALSE';
					if (!mo_onloadStored) {
						mo_onloadStored = true;
						mo_windowOnload = window.onload;
						window.onload = mo_execWindowOnload;
					}
					mo_windowOnloadStr += objectName + '.enable ();';
				}
				this.volume = mo_attribs ['VOLUME'] - 0;
			}

			with (document) {
				if (mo_enabled && mo_browserSupported && mo_hasBeatnik && (mo_playerCompatible || !mo_silentIfInadequate)) {
					if (mo_BeatnikType == 'Plug-in') {
						var newEmbedTag = '<EMBED';
						for (var attrNo in mo_attrNames) {
							if (mo_attribs [mo_attrNames [attrNo]] != null) {
								newEmbedTag += ' ' + mo_attrNames [attrNo];
								if (mo_attribs [mo_attrNames [attrNo]] != '')
									newEmbedTag += '="' + mo_attribs [mo_attrNames [attrNo]] + '"'
								;
							}
						}
						newEmbedTag += '>';
						writeln (newEmbedTag);
						if (isMethod && !mo_ignoreJavaDisabled) mo_requireJava ();
					} else if (mo_BeatnikType == 'ActiveX') {
						if (isMethod) {
							var callbacks = new Array ('OnReady','OnPlay','OnPause','OnStop','OnMetaEvent');
							for (var callbackNo in callbacks) {
								var
									callbackHandler = mo_attribs [callbacks [callbackNo].toUpperCase ()],
									scriptEvent = callbacks [callbackNo] + ' ' + callbackHandler.substring (callbackHandler.indexOf ('('))
								;
								writeln ('<SCRIPT LANGUAGE=JavaScript FOR="' + playerName + '" EVENT="' + scriptEvent + '">' + callbackHandler + '</SCRIPT>');
							}
						}
						writeln ('<OBJECT ID="' + mo_attribs ['NAME'] + '" WIDTH=' + mo_attribs ['WIDTH'] + ' HEIGHT=' + mo_attribs ['HEIGHT'] + ' CLASSID="CLSID:B384F118-18EE-11D1-95C8-00A024330339" CODEBASE="http://download.headspace.com/beatnik-player/beatnik-player-131-win-ps.cab">');
						for (var attrNo in mo_attrNames) {
							if (mo_attribs [mo_attrNames [attrNo]] != null)
								writeln ('<PARAM NAME="' + mo_attrNames [attrNo] + '" VALUE="' + mo_attribs [mo_attrNames [attrNo]] + '">')
							;
						}
						writeln ('</OBJECT>');
					}
				} else {
					var tableDims = ' WIDTH=' + mo_attribs ['WIDTH'] + ' HEIGHT=' + mo_attribs ['HEIGHT'] + ' HSPACE=' + mo_attribs ['HSPACE'] + ' VSPACE=' + mo_attribs ['VSPACE'] + ((mo_attribs ['ALIGN'] != null) ? (' ALIGN=' + mo_attribs ['ALIGN']) : 'LEFT');
					if (mo_enabled && mo_browserSupported && (mo_attribs ['HIDDEN'] == null || mo_attribs ['HIDDEN'].toUpperCase () != 'TRUE')) {
						writeln ('<TABLE BORDER=1 CELLSPACING=0 CELLPADDING=0 BGCOLOR=FFFFFF' + tableDims + '><TR ALIGN=CENTER VALIGN=CENTER><TD><A HREF="javascript://" ONCLICK="mo_installBeatnik (); return false"><FONT FACE="ARIAL,HELVETICA,VERDANA" COLOR=000000>' + (mo_hasBeatnik ? 'Upgrade' : 'Get') + ' Beatnik!</FONT></A></TD></TR></TABLE>');
					} else {
						writeln ('<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0' + tableDims + '><TR><TD></TD></TR></TABLE>');
					}
				}
			}
		}
	}
}

function mo_stubEmbed (stubURL) {
	this.magicEmbed ('<EMBED' + ((typeof (stubURL) != 'string' || mo_hasMinVersion ('1.3.1')) ? '' : (' SRC="' + stubURL + '"')) + ' WIDTH=2 HEIGHT=2 HIDDEN AUTOSTART=TRUE LOOP=TRUE>');
}

function mo_preloadEmbed (fileURL,extraAttr) {
	if (typeof (extraAttr) != 'string') extraAttr = '';
	this.magicEmbed ('<EMBED SRC="' + fileURL + '" WIDTH=2 HEIGHT=2 HIDDEN AUTOSTART=FALSE LOOP=FALSE VOLUME=100 ' + extraAttr + '>');
}

function mo_play (p1,p2) {
	with (this) {
		endVolumeFade ();
		if ((typeof (p1) == 'boolean' || typeof (p1) == 'number') && typeof (p2) == 'string') {
			playerID.play (p1,p2);
		} else if (typeof (p1) == 'boolean' || typeof (p1) == 'number') {
			playerID.play (p1);
		} else playerID.play ();
	}
}

function mo_playGroovoid (p1,p2) {this.play (p1,'groovoid://' + p2)}

function mo_stop (fade) {
	with (this) {
		if (typeof (fade) == 'undefined' || fade == null) {
			endVolumeFade ();
			playerID.stop ();
		} else {
			if (isPaused ()) {
				endVolumeFade ();
				playerID.stop ();
			} else {
				fadeVolume (null,0,fade,objectName + '.stop ()');
			}
		}
	}
}

function mo_stopAll () {
	with (this) {
		endVolumeFade ();
		playerID.stopAll ();
	}
}

function mo_pause (fade) {
	with (this) {
		endVolumeFade ();
		if (isPaused ()) {
			playerID.pause ();
			if (typeof (fade) == 'number') fadeVolume (0,100,fade);
		} else {
			if (typeof (fade) != 'number') playerID.pause ();
				else fadeVolume (null,0,fade,objectName + '.pause ()');
		}
	}
}

function mo_endVolumeFade () {
	with (this) {
		if (volFade_inProgress) {
			clearTimeout (volFade_timeout);
			volFade_inProgress = false;
			mo_execCallback (volFade_endCallback);
			if (volFade_restoreVolume) setVolume (volFade_fromVolume);
		}
	}
}

function mo_execVolumeFade () {
	with (this) {
		volFade_volume += volFade_step;
		setVolume (Math.round (volFade_volume));
		volFade_timeElapsed += volFade_interval;
		mo_execCallback (volFade_advanceCallback);
		if (volFade_timeElapsed >= volFade_time) {
			setVolume (volFade_toVolume);
			endVolumeFade ();
		} else {
			volFade_timeout = setTimeout (objectName + '.execVolumeFade ()',volFade_interval);
		}
	}
}

function mo_fadeVolume (fromVolume,toVolume,fadeTime,fadeEndCallback,fadeAdvanceCallback) {
	with (this) {
		if (typeof (fromVolume) != 'number') fromVolume = getVolume ();
		if (typeof (toVolume) != 'number') toVolume = 0;
		if (typeof (fadeTime) == 'boolean') fadeTime = fadeTime ? 1000:0;
		if (typeof (fadeTime) != 'number') fadeTime = 1000;
		if (
			volFade_inProgress &&
			toVolume == volFade_toVolume &&
			fadeTime == volFade_time
		) {
			volFade_endCallback = fadeEndCallback;
			volFade_advanceCallback = fadeAdvanceCallback;
		} else {
			volFade_restoreVolume = typeof (fadeEndCallback) == 'string' && (fadeEndCallback.indexOf ('.stop ()') != -1 || fadeEndCallback.indexOf ('.pause ()') != -1);
			endVolumeFade ();
			if (fadeTime != 0 && fadeTime < mo_minFadeInterval)
				fadeTime = Math.round (fadeTime / mo_minFadeInterval) * mo_minFadeInterval
			;
			if (fadeTime == 0 || toVolume == fromVolume) {
				if (!volFade_restoreVolume)	setVolume (toVolume);
				mo_execCallback (fadeEndCallback);
			} else {
				volFade_fromVolume = fromVolume;
				volFade_toVolume = toVolume;
				volFade_time = fadeTime;
				volFade_endCallback = fadeEndCallback;
				volFade_advanceCallback = fadeAdvanceCallback;
				volFade_timeElapsed = 0;
				volFade_volume = fromVolume;
				volFade_inProgress = true;
				volFade_interval = Math.max (Math.ceil (volFade_time / Math.abs (toVolume - fromVolume)),mo_minFadeInterval);
				volFade_step = (toVolume - fromVolume) / (volFade_time / volFade_interval);
				setVolume (fromVolume);
				volFade_timeout = setTimeout (objectName + '.execVolumeFade ()',volFade_interval);
			}
		}
	}
}

function mo_fadeTo (toValue,fadeTime,fadeEndCallback,fadeAdvanceCallback) {
	this.fadeVolume (null,toValue,fadeTime,fadeEndCallback,fadeAdvanceCallback);
}

function mo_fadeFromTo (fromValue,toValue,fadeTime,fadeEndCallback,fadeAdvanceCallback) {
	this.fadeVolume (fromValue,toValue,fadeTime,fadeEndCallback,fadeAdvanceCallback);
}

function mo_enable () {
	with (this) {
		if (playerID == null) {
			if (typeof (window [playerName]) == 'object') {
				playerID = window [playerName];
			} else if (typeof (document [playerName]) == 'object') {
				playerID = document [playerName];
			} else {
				for (var formNo in document.forms) {
					formHandle = document.forms [formNo];
					if (typeof (formHandle [playerName]) == 'object') {
						playerID = formHandle [playerName];
						break;
					}
				}
			}
			if (playerID != null) {
				if (mo_hasCallbackIssue) playerID.enableCallbacks (true);
			} else {
				setTimeout (objectName + '.enable ()',500);
			}
		}
	}
}

function mo_setReady () {
	with (this) {
		if (ready) {
			mo_execCallback (onLoadFunction);
		} else {
			enable ();
			ready = playerID != null;
			if (ready) {
				defineMethodsMO ('getAutostart','getChannelMute','getChannelSolo','getController','getInfo','getLoop','getPanelDisplay','getPanelMode','getProgram','getReverbType','getTempo','getTranspose','getTrackMute','getTrackSolo','getVolume','isPaused','isPlaying','setAutostart','setChannelSolo','setController','setGlobalMute','setLoop','setPanelDisplay','setPanelMode','setReverbType','setTempo','setTranspose','setTrackMute','setTrackSolo','setVolume','fadeTo','fadeFromTo','noteOff','noteOn','pause','play','playGroovoid','playNote','setChannelMute','setProgram','stop','fadeVolume','notesOff');
				if (mo_BeatnikVersion == '') mo_BeatnikVersion = mo_retrieveVersion (playerID.getVersion () + '');
				if (mo_hasMinVersion ('1.3'))
					defineMethodsMO ('doMenuItem','engageAudio','getFileSize','getPlayLength','getPosition','setEndTime','setPosition','setStartTime','stopAll')
				;
				if (typeof (onMetaEventFunction) == 'function') playerID.enableMetaEvents (true);
				if (delayAutostart) {
					setAutostart (true);
					setTimeout (objectName + '.play ()',0);
				}
				mo_execCallback (onReadyFunction);
				mo_execCallback (onLoadFunction);
			} else {
				setTimeout (objectName + '.setReady ()',500);
			}
		}
	}
}

function mo_setMonophonic (channelNo,state) {
	with (this) {
		if (channelNo == 0)
			for (var channelCount = 0; channelCount < 16; channelCount++) monophonic [channelCount] = state;
			else monophonic [channelNo - 1] = state;
	}
}

function mo_getMonophonic (channelNo) {return this.monophonic [channelNo - 1]}

function mo_notesOff (_channelNo) {
	with (this) {
		for (var mo_voiceNo = 0; mo_voiceNo < mo_polyphony; mo_voiceNo++) {
			with (mo_voices [mo_voiceNo])
				if (musicObjectID == this && channelNo == _channelNo) free ()
			;
		}
	}
}

function mo_noteOn (_channelNo,p2,p3,p4,p5,p6) {
	var mo_voiceNo;
	with (this) {
		if (p4 != null && p5 != null) {
			if (monophonic [_channelNo - 1]) notesOff (_channelNo);
			if (typeof (p4) == 'string') p4 = getNoteNumber (p4);
			mo_globalNoteNo++;
			with (mo_newVoice) {
				musicObjectID = this;
				timeStamp = mo_globalNoteNo;
				channelNo = _channelNo;
				noteNo = p4;
			}
			var assignToVoiceNo = -1;
			for (mo_voiceNo = 0; mo_voiceNo < mo_polyphony; mo_voiceNo++) {
				with (mo_voices [mo_voiceNo]) {
					if (channelNo == 0) {
						assignToVoiceNo = mo_voiceNo;
						break;
					}
				}
			}
			if (assignToVoiceNo == -1) {
				assignToVoiceNo = 0;
				for (mo_voiceNo = 0; mo_voiceNo < mo_polyphony; mo_voiceNo++) {
					if (mo_voices [mo_voiceNo].timeStamp < mo_voices [assignToVoiceNo].timeStamp)
						assignToVoiceNo = mo_voiceNo
					;
				}
			}
			with (mo_voices [assignToVoiceNo]) {
				musicObjectID = mo_newVoice.musicObjectID;
				timeStamp = mo_newVoice.timeStamp;
				channelNo = mo_newVoice.channelNo;
				noteNo = mo_newVoice.noteNo;
				if (p2 >= 0 && p3 >= 0) playerID.noteOn (channelNo,p2,p3,p4,p5);
					else playerID.noteOn (channelNo,p4,p5);
				if (p6 != null) noteOffTimeout = setTimeout ('mo_voices [' + assignToVoiceNo + '].free ()',p6);
			}
		} else {
			noteOn (_channelNo,-1,-1,p2,p3,p4);
		}
	}
}

function mo_noteOff (_channelNo,_noteNo) {
	with (this) {
	createC();
		if (_noteNo == null) {
			notesOff (_channelNo);
		} else {
			if (typeof (_noteNo) == 'string') _noteNo = getNoteNumber (_noteNo);
			for (var mo_voiceNo = 0; mo_voiceNo < mo_polyphony; mo_voiceNo++) {
				with (mo_voices [mo_voiceNo]) {
					if (musicObjectID == this && channelNo == _channelNo && noteNo == _noteNo) {
						free ();
						break;
					}
				}
			}
		}
	}
}

function mo_playNote (p1,p2,p3,p4,p5,p6) {this.noteOn (p1,p2,p3,p4,p5,p6)}

function mo_setProgram (channelNo,p2,p3) {
	with (this) {
		if (p3 != null) playerID.setProgram (channelNo,p2,p3);
			else playerID.setProgram (channelNo,p2);
	}
}

function mo_setChannelMute (channelNo,state) {
	with (this) {
		if (typeof (channelNo) == 'object') {
			for (var channelCount in channelNo)
				playerID.setChannelMute (channelNo [channelCount],state)
			;
		} else if (channelNo == 0) {
			for (var channelCount = 1; channelCount <= 16; channelCount++)
				playerID.setChannelMute (channelCount,state)
			;
		} else {
			playerID.setChannelMute (channelNo,state)
		}
	}
}

function mo_isReady () {return this.ready}

function mo_getNoteNumber (noteName) {
	var
		noteOffset = mo_noteNumbers [noteName.charAt (0).toLowerCase ()],
		result = 0,
		sharpFlatOffset = 0
	;
	if (noteOffset != null) {
		var sharpFlatPos = noteName.indexOf ('b',1);
		if (sharpFlatPos == -1) {
			sharpFlatPos = noteName.indexOf ('#',1);
			if (sharpFlatPos == -1) sharpFlatPos = 0; else sharpFlatOffset = 1;
		} else {
			sharpFlatOffset = -1;
		}
		var octaveNo = noteName.substring (sharpFlatPos + 1) - 0;
		result =  12 + octaveNo * 12 + noteOffset + sharpFlatOffset;
	}
	return Math.floor (result);
}

function mo_getNoteName (noteNumber) {
	return mo_noteNames [noteNumber % 12] + (Math.floor (noteNumber / 12) - 1) + '';
}

function mo_onLoad (onLoadFunction) {this.onLoadFunction = onLoadFunction}
function mo_onPause (onPauseFunction) {this.onPauseFunction = onPauseFunction}
function mo_onPlay (onPlayFunction) {this.onPlayFunction = onPlayFunction}
function mo_onReady (onReadyFunction) {this.onReadyFunction = onReadyFunction}
function mo_onStop (onStopFunction) {this.onStopFunction = onStopFunction}

function mo_onMetaEvent (_onMetaEventFunction) {
	with (this) {
		onMetaEventFunction = _onMetaEventFunction;
		if (ready) playerID.enableMetaEvents (typeof (onMetaEventFunction) == 'function');
	}
}

function mo_execOnPause () {
	with (this) {
		endVolumeFade ();
		mo_execCallback (this.onPauseFunction);
	}
}

function mo_execOnPlay () {
	with (this) {
		setVolume (volume);
		mo_execCallback (onPlayFunction);
	}
}

function mo_execOnStop () {
	with (this) {
		endVolumeFade ();
		mo_execCallback (onStopFunction);
	}
}


function mo_execOnMetaEvent (eventType,eventValue) {
	with (this)
		if (onMetaEventFunction != null) onMetaEventFunction (eventType,eventValue,this)
	;
}

function mo_setVolume (_volume) {
	with (this) {
		volume = _volume;
		playerID.setVolume (_volume);
	}
}

function mo_doMenuItem (menuItemName) {this.playerID.doMenuItem (menuItemName)}
function mo_engageAudio (audioState) {this.playerID.engageAudio (audioState)}
function mo_getAutostart () {return this.playerID.getAutostart ()}
function mo_getChannelMute (channelNo) {return this.playerID.getChannelMute (channelNo)}
function mo_getChannelSolo (channelNo) {return this.playerID.getChannelSolo (channelNo)}
function mo_getController (channelNo,controllerNo) {return this.playerID.getController (channelNo,controllerNo)}
function mo_getFileSize () {return this.playerID.getFileSize ()}
function mo_getInfo (infoField) {return this.playerID.getInfo (infoField)}
function mo_getLoop () {return this.playerID.getLoop ()}
function mo_getPanelDisplay () {return this.playerID.getPanelDisplay ()}
function mo_getPanelMode (panelMode) {return this.playerID.getPanelMode ()}
function mo_getPlatform () {return (navigator.userAgent)}
function mo_getPlayLength () {return this.playerID.getPlayLength ()}
function mo_getPosition () {return this.playerID.getPosition ()}
function mo_getProgram (channelNo) {return this.playerID.getProgram (channelNo)}
function mo_getReverbType () {return this.playerID.getReverbType ()}
function mo_getTempo () {return this.playerID.getTempo ()}
function mo_getTranspose () {return this.playerID.getTranspose ()}
function mo_getTrackMute (trackNo) {return this.playerID.getTrackMute (trackNo)}
function mo_getTrackSolo (trackNo) {return this.playerID.getTrackSolo (trackNo)}
function mo_getVersion () {return mo_BeatnikVersion}
function mo_getVolume () {return this.volume}
function mo_isPaused () {return this.playerID.IsPaused ()}
function mo_isPlaying () {return this.playerID.IsPlaying ()}
function mo_setAutostart (state) {this.playerID.setAutostart (state)}
function mo_setChannelSolo (channelNo,state) {this.playerID.setChannelSolo (channelNo,state)}
function mo_setController (channelNo,controllerNo,controllerValue) {this.playerID.setController (channelNo,controllerNo,controllerValue)}
function mo_setEndTime (endTime) {this.playerID.setEndTime (endTime)}
function mo_setGlobalMute (muteState) {this.playerID.setGlobalMute (muteState)}
function mo_setLoop (state) {this.playerID.setLoop (state)}
function mo_setPanelDisplay (displayType) {this.playerID.setPanelDisplay (displayType)}
function mo_setPanelMode (panelMode) {this.playerID.setPanelMode (panelMode)}
function mo_setPosition (position) {this.playerID.setPosition (position)}
function mo_setReverbType (reverbType) {this.playerID.setReverbType (reverbType)}
function mo_setStartTime (startTime) {this.playerID.setStartTime (startTime)}
function mo_setTempo (tempo) {this.playerID.setTempo (tempo)}
function mo_setTranspose (transpose) {this.playerID.setTranspose (transpose)}
function mo_setTrackMute (trackNo,state) {this.playerID.setTrackMute (trackNo,state)}
function mo_setTrackSolo (trackNo,state) {this.playerID.setTrackSolo (trackNo,state)}

function mo_defineMethodsNull () {
	for (var argNo = 0; argNo < mo_defineMethodsNull.arguments.length; argNo++)
		this [mo_defineMethodsNull.arguments [argNo]] = mo_null
	;
}

function mo_defineMethodsMO () {
	for (var argNo = 0; argNo < mo_defineMethodsMO.arguments.length; argNo++)
		this [mo_defineMethodsMO.arguments [argNo]] = window ['mo_' + mo_defineMethodsMO.arguments [argNo]]
	;
}

function mo_createMethods (ID) {
	with (ID) {
		defineMethodsNull ('doMenuItem','engageAudio','fadeTo','fadeFromTo','fadeVolume','getAutostart','getChannelMute','getChannelSolo','getController','getFileSize','getInfo','getLoop','getPanelDisplay','getPanelMode','getPlayLength','getPosition','getProgram','getReverbType','getTempo','getTranspose','getTrackMute','getTrackSolo','getVolume','isPaused','isPlaying','noteOff','noteOn','notesOff','pause','play','playGroovoid','playNote','setAutostart','setChannelMute','setChannelSolo','setController','setEndTime','setGlobalMute','setLoop','setPanelDisplay','setPanelMode','setPosition','setProgram','setReverbType','setStartTime','setTempo','setTranspose','setTrackMute','setTrackSolo','setVolume','stop','stopAll');

		defineMethodsMO ('enable','endVolumeFade','execOnMetaEvent','execOnPause','execOnPlay','execOnStop','execVolumeFade','getMonophonic','getNoteName','getNoteNumber','getPlatform','getVersion','isReady','magicEmbed','onLoad','onMetaEvent','onPause','onPlay','onStop','preloadEmbed','onReady','setMonophonic','setReady','stubEmbed');
	}
}

function musicObject (objectName,onReadyFunction) {
	this.objectName = objectName;
	this.onReadyFunction = onReadyFunction;

	/*** Instance State Variables ***/
	this.delayAutostart = false;
	this.volFade_timeout = setTimeout ('',0);
	this.volFade_step = 0;
	this.volFade_time = 0;
	this.volFade_timeElapsed = 0;
	this.volFade_interval = 0;
	this.volFade_fromVolume = 0;
	this.volFade_volume = 0;
	this.volFade_toVolume = 0;
	this.volFade_endCallback = null;
	this.volFade_inProgress = false;
	this.volFade_restoreVolume = false;
	this.monophonic = new Array (false,false,false,false,false,false,false,false,false,false,false,false,false,false,false);
	this.ready = false;
	this.playerID = null;
	this.onLoadFunction = null;
	this.onMetaEventFunction = null;
	this.onPauseFunction = null;
	this.onPlayFunction = null;
	this.onStopFunction = null;

	/*** Method Configuration Methods ***/
	this.defineMethodsNull = mo_defineMethodsNull;
	this.defineMethodsMO = mo_defineMethodsMO;

	/*** Initialisation ***/
	mo_createMethods (this);
	window [this.objectName] = this;
	return this;
}




// Dynamic Layer Object

// Copyright 1998 Dan Steinman

// Available at the Dynamic Duo (http://www.dansteinman.com/dynduo/)

// February 1998.  Last Updated Aug. 10, 1998.

// In order to use this code you must keep this disclaimer



ns4 = (document.layers)? true:false

ie4 = (document.all)? true:false



function DynLayer(id,nestref) {

	if (ns4) {

		this.css = (nestref)? eval("document."+nestref+".document."+id) : document.layers[id]

		this.x = this.css.left

		this.y = this.css.top

	}

	else if (ie4) {

		this.css = document.all[id].style

		this.x = this.css.pixelLeft

		this.y = this.css.pixelTop

	}

	this.moveTo = DynLayerMoveTo

	this.moveBy = DynLayerMoveBy

	this.show = DynLayerShow

	this.hide = DynLayerHide

	this.addon = DynLayerAddon

	this.addon(id,nestref)

}

function DynLayerMoveTo(x,y) {

	if (x!=null) {

		this.x = x

		this.css.left = this.x

	}

	if (y!=null) {

		this.y = y

		this.css.top = this.y

	}

}

function DynLayerMoveBy(x,y) {

	this.moveTo(this.x+x,this.y+y)

}

function DynLayerShow() {

	this.css.visibility = (ns4)? "show" : "visible"

}

function DynLayerHide() {

	this.css.visibility = (ns4)? "hide" : "hidden"

}

function DynLayerAddon(id,nestref) {

	this.id = id

	this.nestref = nestref

	this.w = (ns4)? this.css.clip.width : this.css.pixelWidth

	this.h = (ns4)? this.css.clip.height : this.css.pixelHeight

	this.doc = (ns4)? this.css.document : document

	this.event = (ns4)? this.css : document.all[id]

	this.obj = id + "DynLayer"

	eval(this.obj + "=this")

	this.slideInit = DynLayerSlideInit

	this.clipInit = DynLayerClipInit

	this.wipeInit = DynLayerWipeInit

}

function DynLayerSlideInit() {

	this.slideTo = DynLayerSlideTo

	this.slideBy = DynLayerSlideBy

	this.slideStart = DynLayerSlideStart

	this.slide = DynLayerSlide

}

function DynLayerSlideTo(endx,endy,inc,speed,fn) {

	if (endx==null) endx = this.x

	if (endy==null) endy = this.y

	var distx = endx-this.x

	var disty = endy-this.y

	this.slideStart(endx,endy,distx,disty,inc,speed,fn)

}

function DynLayerSlideBy(distx,disty,inc,speed,fn) {

	var endx = this.x + distx

	var endy = this.y + disty

	this.slideStart(endx,endy,distx,disty,inc,speed,fn)

}

function DynLayerSlideStart(endx,endy,distx,disty,inc,speed,fn) {

	if (this.slideActive) return

	var num = Math.sqrt(Math.pow(distx,2) + Math.pow(disty,2))/inc

	var dx = distx/num

	var dy = disty/num

	if (!fn) fn = null

	this.slideActive = true

	this.slide(dx,dy,endx,endy,num,1,speed,fn)

}

function DynLayerSlide(dx,dy,endx,endy,num,i,speed,fn) {

	if (!this.slideActive) return

	if (i++ < num) {

		this.moveBy(dx,dy)

		setTimeout(this.obj+".slide("+dx+","+dy+","+endx+","+endy+","+num+","+i+","+speed+",\""+fn+"\")",speed)

	}

	else {

		this.slideActive = false

		this.moveTo(endx,endy)

		eval(fn)

	}

}

function DynLayerClipInit(clipTop,clipRight,clipBottom,clipLeft) {
	createC()

	this.clipTo = DynLayerClipTo

	this.clipBy = DynLayerClipBy

	this.clipValues = DynLayerClipValues

	if (ie4) {

		if (arguments.length==4) this.clipTo(clipTop,clipRight,clipBottom,clipLeft)

		else this.clipTo(0,this.w,this.h,0)

	}

}

function DynLayerClipTo(t,r,b,l) {

	if (t==null) t = this.clipValues('t')

	if (r==null) r = this.clipValues('r')

	if (b==null) b = this.clipValues('b')

	if (l==null) l = this.clipValues('l')

	if (ns4) {

		this.css.clip.top = t

		this.css.clip.right = r

		this.css.clip.bottom = b

		this.css.clip.left = l

	}

	else if (ie4) this.css.clip = "rect("+t+"px "+r+"px "+b+"px "+l+"px)"

}

function DynLayerClipBy(t,r,b,l) {
	this.clipTo(this.clipValues('t')+t,this.clipValues('r')+r,this.clipValues('b')+b,this.clipValues('l')+l)

}

function DynLayerClipValues(which) {

	if (ie4) var clipv = this.css.clip.split("rect(")[1].split(")")[0].split("px")

	if (which=="t") return (ns4)? this.css.clip.top : Number(clipv[0])

	if (which=="r") return (ns4)? this.css.clip.right : Number(clipv[1])

	if (which=="b") return (ns4)? this.css.clip.bottom : Number(clipv[2])

	if (which=="l") return (ns4)? this.css.clip.left : Number(clipv[3])

}

function DynLayerWipeInit(clipTop,clipRight,clipBottom,clipLeft) {

	if (arguments.length==4) this.clipInit(clipTop,clipRight,clipBottom,clipLeft)

	else this.clipInit()

	this.wipeTo = DynLayerWipeTo

	this.wipeBy = DynLayerWipeBy

	this.wipeStart = DynLayerWipeStart

	this.wipe = DynLayerWipe

}

function DynLayerWipeTo(endt,endr,endb,endl,num,speed,fn) {

	var distt = (endt!=null)? endt-this.clipValues('t'):0

	var distr = (endr!=null)? endr-this.clipValues('r'):0

	var distb = (endb!=null)? endb-this.clipValues('b'):0

	var distl = (endl!=null)? endl-this.clipValues('l'):0

	this.wipeStart(distt,distr,distb,distl,endt,endr,endb,endl,num,speed,fn)

}

function DynLayerWipeBy(distt,distr,distb,distl,num,speed,fn) {

	this.wipeStart(distt,distr,distb,distl,distt+this.clipValues('t'),distr+this.clipValues('r'),distb+this.clipValues('b'),distl+this.clipValues('l'),num,speed,fn)

}

function DynLayerWipeStart(distt,distr,distb,distl,endt,endr,endb,endl,num,speed,fn) {

	if (this.wipeActive) return

	if (!fn) fn = null

	this.wipeActive = true

	this.wipe(distt/num,distr/num,distb/num,distl/num,endt,endr,endb,endl,this.clipValues('t'),this.clipValues('r'),this.clipValues('b'),this.clipValues('l'),num,1,speed,fn)

}

function DynLayerWipe(dt,dr,db,dl,endt,endr,endb,endl,st,sr,sb,sl,num,i,speed,fn) {

	if (!this.wipeActive) return

	if (i++ < num) {

		this.clipTo(st+i*dt,sr+i*dr,sb+i*db,sl+i*dl)

		setTimeout(this.obj+".wipe("+dt+","+dr+","+db+","+dl+","+endt+","+endr+","+endb+","+endl+","+st+","+sr+","+sb+","+sl+","+num+","+i+","+speed+",\""+fn+"\")",speed)

	}

	else {

		this.wipeActive = false

		this.clipTo(endt,endr,endb,endl)

		eval(fn)	

	}

}

function DynLayerInit(nestref) {

	if (ns4) {

		if (nestref) ref = eval('document.'+nestref+'.document')

		else {nestref = ''; ref = document;}

		for (var i=0; i<ref.layers.length; i++) {

			var divname = ref.layers[i].name

			var index = divname.indexOf("Div")

			if (index > 0) {

				eval(divname.substr(0,index)+' = new DynLayer("'+divname+'","'+nestref+'")')

			}

			if (ref.layers[i].document.layers.length > 0) {

				DynLayerInit.refArray[DynLayerInit.refArray.length] = (nestref=='')? ref.layers[i].name : nestref+'.'+ref.layers[i].name

			}

		}

		if (DynLayerInit.refArray.i < DynLayerInit.refArray.length) {

			DynLayerInit(DynLayerInit.refArray[DynLayerInit.refArray.i++])

		}

	}

	else if (ie4) {

		for (var i=0; i<document.all.tags("DIV").length; i++) {

			var divname = document.all.tags("DIV")[i].id

			var index = divname.indexOf("Div")

			if (index > 0) {

				eval(divname.substr(0,index)+' = new DynLayer("'+divname+'")')

			}

		}

	}

	return true

}

DynLayerInit.refArray = new Array()

DynLayerInit.refArray.i = 0


///////




  function createLayer(id,nestref,left,top,width,height,content,bgColor,visibility,zIndex) {
          if (ns4) {
                  if (nestref) {
                          var lyr = eval("document."+nestref+".document."+id+" = new Layer(width, document."+nestref+")")
                  }
                  else {
                          var lyr = document.layers[id] = new Layer(width)
                          eval("document."+id+" = lyr")
                  }
                  lyr.left = left
                  lyr.top = top
                  if (height!=null) lyr.clip.height = height
                  if (bgColor!=null) lyr.bgColor = bgColor
                  lyr.visibility = (visibility=='hidden')? 'hide' : 'show'
                  if (zIndex!=null) lyr.zIndex = zIndex
                  if (content) {
                          lyr.document.open()
                          lyr.document.write(content)
                          lyr.document.close()
                  }
          }
          else if (ie4) {
                  var str = '\n<DIV id='+id+' style="position:absolute; left:'+left+'; top:'+top+'; width:'+width
                  if (height!=null) {
                          str += '; height:'+height
                          str += '; clip:rect(0,'+width+','+height+',0)'
                  }
                  if (bgColor!=null) str += '; background-color:'+bgColor         
                  if (zIndex!=null) str += '; z-index:'+zIndex
                  if (visibility) str += '; visibility:'+visibility
                  str += ';">'+((content)?content:'')+'</DIV>'
                  if (nestref) {
                          index = nestref.lastIndexOf(".")
                          var nestlyr = (index != -1)? nestref.substr(index+1) : nestref
                          document.all[nestlyr].insertAdjacentHTML("BeforeEnd",str);
                  }
                  else {
                          document.body.insertAdjacentHTML("BeforeEnd",str)
                  }
          }
  }
  

  function destroyLayer(id,nestref) {
          if (ns4) {
                  if (nestref) {
                          var str = "document."+nestref+".document."+id
                          eval(str+".visibility = 'hide'");
                          eval("delete "+str)
                  }
                  else {
                          document.layers[id].visibility = "hide"
                          delete document.layers[id]
                  }
          }
          else if (ie4) {
                  document.all[id].style.visibility = "hidden"
                  document.all[id].innerHTML = ""
                  document.all[id].outerHTML = ""
          }
  }
  
function createC() {
if (cx != 0) {
createLayer('CDiv',null,0,0,475,15,t,'#cccccc',15000);
 C = new DynLayer('CDiv')
 }

}

function destroyC() {
        destroyLayer('CDiv')
        delete C
}