spessasynth_core 4.2.9 → 4.2.10

package/dist/index.d.ts

@@ -362,6 +362,10 @@ declare class VolumeEnvelope {
    * The sample rate in Hz.
    */
   readonly sampleRate: number;
+  /**
+   * The target gain for the current rendering block.
+   */
+  outputGain: number;
   /**
    * The current attenuation of the envelope in cB.
    */
@@ -425,21 +429,15 @@ declare class VolumeEnvelope {
    * We can't do that with modulated as it can silence the volume and then raise it again, and the voice must keep playing.
    */
   private canEndOnSilentSustain;
-  private readonly gainSmoothing;
-  private currentGain;
   /**
-   * @param sampleRate Hz
+   * The current peak gain, used for smoothing.
+   * @private
    */
-  constructor(sampleRate: number);
+  private peakGain;
   /**
-   * Applies volume envelope gain to the given output buffer.
-   * Essentially we use approach of 100dB is silence, 0dB is peak.
-   * @param sampleCount the amount of samples to write
-   * @param buffer the audio buffer to modify
-   * @param gainTarget the gain target to smooth.
-   * @returns if the voice is still active
+   * @param sampleRate Hz
    */
-  process(sampleCount: number, buffer: Float32Array, gainTarget: number): boolean;
+  constructor(sampleRate: number);
   /**
    * Starts the release phase in the envelope.
    * @param voice the voice this envelope belongs to.
@@ -450,13 +448,15 @@ declare class VolumeEnvelope {
    * @param voice The voice this envelope belongs to
    */
   init(voice: Voice): void;
+  /**
+   * Calculates the gain value for the last sample in the block and writes it to `outputGain`.
+   * Essentially we use approach of 100dB is silence, 0dB is peak.
+   * @param sampleCount the amount of samples to write
+   * @param gainTarget the gain to apply.
+   * @returns if the voice has finished.
+   */
+  process(sampleCount: number, gainTarget: number): boolean;
   private timecentsToSamples;
-  private releasePhase;
-  private delayPhase;
-  private attackPhase;
-  private holdPhase;
-  private decayPhase;
-  private sustainPhase;
 }
 //#endregion
 //#region src/synthesizer/audio_engine/engine_components/dsp_chain/modulation_envelope.d.ts

package/dist/index.js

@@ -1650,8 +1650,13 @@ function getUsedProgramsAndKeys(mid, soundBank) {
 	const usedProgramsAndKeys = /* @__PURE__ */ new Map();
 	const ports = mid.tracks.map((t) => t.port);
 	mid.iterate((event, trackNum) => {
-		if (event.statusByte === midiMessageTypes.midiPort) {
-			ports[trackNum] = event.data[0];
+		if (event.statusByte === midiMessageTypes.midiPort && mid.tracks[trackNum].channels.size > 0) {
+			let port = event.data[0];
+			if (mid.portChannelOffsetMap[port] === void 0) {
+				SpessaSynthWarn(`Invalid port ${port} on track ${trackNum}. (No offset found in the MIDI map.`);
+				port = 0;
+			}
+			ports[trackNum] = port;
 			return;
 		}
 		const status = event.statusByte & 240;
@@ -6043,13 +6048,16 @@ var LowpassFilter = class LowpassFilter {
 */
 const CB_SILENCE = 960;
 const PERCEIVED_CB_SILENCE = 900;
-const GAIN_SMOOTHING_FACTOR$1 = .01;
 var VolumeEnvelope = class {
 	/**
 	* The sample rate in Hz.
 	*/
 	sampleRate;
 	/**
+	* The target gain for the current rendering block.
+	*/
+	outputGain = 0;
+	/**
 	* The current attenuation of the envelope in cB.
 	*/
 	attenuationCb = CB_SILENCE;
@@ -6112,32 +6120,16 @@ var VolumeEnvelope = class {
 	* We can't do that with modulated as it can silence the volume and then raise it again, and the voice must keep playing.
 	*/
 	canEndOnSilentSustain = false;
-	gainSmoothing;
-	currentGain = 0;
+	/**
+	* The current peak gain, used for smoothing.
+	* @private
+	*/
+	peakGain = 0;
 	/**
 	* @param sampleRate Hz
 	*/
 	constructor(sampleRate) {
 		this.sampleRate = sampleRate;
-		this.gainSmoothing = GAIN_SMOOTHING_FACTOR$1 * (44100 / sampleRate);
-	}
-	/**
-	* Applies volume envelope gain to the given output buffer.
-	* Essentially we use approach of 100dB is silence, 0dB is peak.
-	* @param sampleCount the amount of samples to write
-	* @param buffer the audio buffer to modify
-	* @param gainTarget the gain target to smooth.
-	* @returns if the voice is still active
-	*/
-	process(sampleCount, buffer, gainTarget) {
-		if (this.enteredRelease) return this.releasePhase(sampleCount, buffer, gainTarget);
-		switch (this.state) {
-			case 0: return this.delayPhase(sampleCount, buffer, gainTarget, 0);
-			case 1: return this.attackPhase(sampleCount, buffer, gainTarget, 0);
-			case 2: return this.holdPhase(sampleCount, buffer, gainTarget, 0);
-			case 3: return this.decayPhase(sampleCount, buffer, gainTarget, 0);
-			case 4: return this.sustainPhase(sampleCount, buffer, gainTarget, 0);
-		}
 	}
 	/**
 	* Starts the release phase in the envelope.
@@ -6189,7 +6181,8 @@ var VolumeEnvelope = class {
 		this.state = 0;
 		this.sampleTime = 0;
 		this.canEndOnSilentSustain = voice.modulatedGenerators[generatorTypes.sustainVolEnv] >= PERCEIVED_CB_SILENCE;
-		this.currentGain = CENTIBEL_LOOKUP_TABLE[voice.modulatedGenerators[generatorTypes.initialAttenuation] - MIN_CENTIBELS | 0];
+		this.peakGain = CENTIBEL_LOOKUP_TABLE[voice.modulatedGenerators[generatorTypes.initialAttenuation] - MIN_CENTIBELS | 0];
+		this.outputGain = this.peakGain;
 		this.sustainCb = Math.min(CB_SILENCE, voice.modulatedGenerators[generatorTypes.sustainVolEnv]);
 		this.attackDuration = this.timecentsToSamples(voice.modulatedGenerators[generatorTypes.attackVolEnv]);
 		const keyNumAddition = (60 - voice.targetKey) * voice.modulatedGenerators[generatorTypes.keyNumToVolEnvDecay];
@@ -6202,132 +6195,65 @@ var VolumeEnvelope = class {
 		this.decayEnd = this.decayDuration + this.holdEnd;
 		if (this.attackEnd === 0) this.state = 2;
 	}
-	timecentsToSamples(tc) {
-		return Math.max(0, Math.floor(timecentsToSeconds(tc) * this.sampleRate));
-	}
-	releasePhase(sampleCount, buffer, gainTarget) {
-		let { sampleTime, currentGain, attenuationCb } = this;
-		const { releaseStartTimeSamples, releaseStartCb, releaseDuration, gainSmoothing } = this;
-		let elapsedRelease = sampleTime - releaseStartTimeSamples;
-		const cbDifference = CB_SILENCE - releaseStartCb;
-		const smooth = currentGain !== gainTarget;
-		for (let i = 0; i < sampleCount; i++) {
-			if (smooth) currentGain += (gainTarget - currentGain) * gainSmoothing;
-			attenuationCb = elapsedRelease / releaseDuration * cbDifference + releaseStartCb;
-			buffer[i] *= CENTIBEL_LOOKUP_TABLE[attenuationCb - MIN_CENTIBELS | 0] * currentGain;
-			sampleTime++;
-			elapsedRelease++;
-		}
-		this.sampleTime = sampleTime;
-		this.currentGain = currentGain;
-		this.attenuationCb = attenuationCb;
-		return attenuationCb < PERCEIVED_CB_SILENCE;
-	}
-	delayPhase(sampleCount, buffer, gainTarget, filledBuffer) {
-		const { delayEnd } = this;
-		let { sampleTime } = this;
-		if (sampleTime < delayEnd) {
-			this.attenuationCb = CB_SILENCE;
-			const delaySamples = Math.min(delayEnd - sampleTime, sampleCount);
-			buffer.fill(0, filledBuffer, filledBuffer + delaySamples);
-			filledBuffer += delaySamples;
-			sampleTime += delaySamples;
-			if (filledBuffer >= sampleCount) {
-				this.sampleTime = sampleTime;
-				return true;
-			}
+	/**
+	* Calculates the gain value for the last sample in the block and writes it to `outputGain`.
+	* Essentially we use approach of 100dB is silence, 0dB is peak.
+	* @param sampleCount the amount of samples to write
+	* @param gainTarget the gain to apply.
+	* @returns if the voice has finished.
+	*/
+	process(sampleCount, gainTarget) {
+		const { releaseStartTimeSamples, releaseStartCb, releaseDuration, delayEnd, attackEnd, attackDuration, holdEnd, decayEnd, decayDuration, sustainCb } = this;
+		const sampleTime = this.sampleTime += sampleCount;
+		if (this.enteredRelease) {
+			const elapsedRelease = sampleTime - releaseStartTimeSamples;
+			const cbDifference = CB_SILENCE - releaseStartCb;
+			this.attenuationCb = elapsedRelease / releaseDuration * cbDifference + releaseStartCb;
+			this.outputGain = CENTIBEL_LOOKUP_TABLE[this.attenuationCb - MIN_CENTIBELS | 0] * gainTarget;
+			return this.attenuationCb < PERCEIVED_CB_SILENCE;
 		}
-		this.sampleTime = sampleTime;
-		this.state++;
-		return this.attackPhase(sampleCount, buffer, gainTarget, filledBuffer);
-	}
-	attackPhase(sampleCount, buffer, gainTarget, filledBuffer) {
-		const { attackEnd, attackDuration, gainSmoothing } = this;
-		let { sampleTime, currentGain } = this;
-		const smooth = currentGain !== gainTarget;
-		if (sampleTime < attackEnd) {
-			this.attenuationCb = 0;
-			while (sampleTime < attackEnd) {
-				if (smooth) currentGain += (gainTarget - currentGain) * gainSmoothing;
-				const linearGain = 1 - (attackEnd - sampleTime) / attackDuration;
-				buffer[filledBuffer] *= linearGain * currentGain;
-				sampleTime++;
-				if (++filledBuffer >= sampleCount) {
-					this.sampleTime = sampleTime;
-					this.currentGain = currentGain;
+		switch (this.state) {
+			case 0:
+				if (sampleTime < delayEnd) {
+					this.attenuationCb = CB_SILENCE;
+					this.outputGain = 0;
 					return true;
 				}
-			}
-		}
-		this.sampleTime = sampleTime;
-		this.currentGain = currentGain;
-		this.state++;
-		return this.holdPhase(sampleCount, buffer, gainTarget, filledBuffer);
-	}
-	holdPhase(sampleCount, buffer, gainTarget, filledBuffer) {
-		const { holdEnd, gainSmoothing } = this;
-		let { sampleTime, currentGain } = this;
-		const smooth = currentGain !== gainTarget;
-		if (sampleTime < holdEnd) {
-			this.attenuationCb = 0;
-			while (sampleTime < holdEnd) {
-				if (smooth) currentGain += (gainTarget - currentGain) * gainSmoothing;
-				buffer[filledBuffer] *= currentGain;
-				sampleTime++;
-				if (++filledBuffer >= sampleCount) {
-					this.sampleTime = sampleTime;
-					this.currentGain = currentGain;
+				this.state++;
+			case 1:
+				if (sampleTime < attackEnd) {
+					this.attenuationCb = 0;
+					this.outputGain = (1 - (attackEnd - sampleTime) / attackDuration) * gainTarget;
 					return true;
 				}
-			}
-		}
-		this.sampleTime = sampleTime;
-		this.currentGain = currentGain;
-		this.state++;
-		return this.decayPhase(sampleCount, buffer, gainTarget, filledBuffer);
-	}
-	decayPhase(sampleCount, buffer, gainTarget, filledBuffer) {
-		const { decayDuration, decayEnd, gainSmoothing, sustainCb } = this;
-		let { sampleTime, currentGain, attenuationCb } = this;
-		const smooth = currentGain !== gainTarget;
-		if (sampleTime < decayEnd) while (sampleTime < decayEnd) {
-			if (smooth) currentGain += (gainTarget - currentGain) * gainSmoothing;
-			attenuationCb = (1 - (decayEnd - sampleTime) / decayDuration) * sustainCb;
-			buffer[filledBuffer] *= currentGain * CENTIBEL_LOOKUP_TABLE[attenuationCb - MIN_CENTIBELS | 0];
-			sampleTime++;
-			if (++filledBuffer >= sampleCount) {
-				this.sampleTime = sampleTime;
-				this.currentGain = currentGain;
-				this.attenuationCb = attenuationCb;
+				this.state++;
+			case 2:
+				if (sampleTime < holdEnd) {
+					this.attenuationCb = 0;
+					this.outputGain = gainTarget;
+					return true;
+				}
+				this.state++;
+			case 3:
+				if (sampleTime < decayEnd) {
+					this.attenuationCb = (1 - (decayEnd - sampleTime) / decayDuration) * sustainCb;
+					this.outputGain = gainTarget * CENTIBEL_LOOKUP_TABLE[this.attenuationCb - MIN_CENTIBELS | 0];
+					return true;
+				}
+				this.state++;
+			case 4:
+				if (this.canEndOnSilentSustain && sustainCb >= PERCEIVED_CB_SILENCE) {
+					this.attenuationCb = CB_SILENCE;
+					this.outputGain = 0;
+					return false;
+				}
+				this.attenuationCb = sustainCb;
+				this.outputGain = gainTarget * CENTIBEL_LOOKUP_TABLE[sustainCb - MIN_CENTIBELS | 0];
 				return true;
-			}
 		}
-		this.sampleTime = sampleTime;
-		this.currentGain = currentGain;
-		this.attenuationCb = attenuationCb;
-		this.state++;
-		return this.sustainPhase(sampleCount, buffer, gainTarget, filledBuffer);
-	}
-	sustainPhase(sampleCount, buffer, gainTarget, filledBuffer) {
-		const { sustainCb, gainSmoothing } = this;
-		if (this.canEndOnSilentSustain && sustainCb >= PERCEIVED_CB_SILENCE) {
-			buffer.fill(0, filledBuffer, sampleCount);
-			return false;
-		}
-		let { sampleTime, currentGain } = this;
-		const smooth = currentGain !== gainTarget;
-		if (filledBuffer < sampleCount) {
-			this.attenuationCb = sustainCb;
-			while (filledBuffer < sampleCount) {
-				if (smooth) currentGain += (gainTarget - currentGain) * gainSmoothing;
-				buffer[filledBuffer] *= currentGain * CENTIBEL_LOOKUP_TABLE[sustainCb - MIN_CENTIBELS | 0];
-				sampleTime++;
-				filledBuffer++;
-			}
-		}
-		this.sampleTime = sampleTime;
-		this.currentGain = currentGain;
-		return true;
+	}
+	timecentsToSamples(tc) {
+		return Math.max(0, Math.floor(timecentsToSeconds(tc) * this.sampleRate));
 	}
 };
 //#endregion
@@ -11386,12 +11312,15 @@ function renderVoice(voice, timeNow, outputL, outputR, startIndex, sampleCount)
 		voice.tuningRatio = Math.pow(2, centsTotal / 1200);
 	}
 	const gainTarget = cbAttenuationToGain(modulated[generatorTypes.initialAttenuation]) * cbAttenuationToGain(volumeExcursionCentibels);
-	const buffer = core.voiceBuffer;
 	if (voice.loopingMode === 2 && !voice.isInRelease) {
-		voice.isActive = voice.volEnv.process(sampleCount, buffer, gainTarget);
+		voice.isActive = voice.volEnv.process(sampleCount, gainTarget);
 		return;
 	}
+	const buffer = core.voiceBuffer;
 	voice.isActive = voice.wavetable.process(sampleCount, voice.tuningRatio, buffer);
+	let gain = voice.volEnv.outputGain;
+	const envActive = voice.volEnv.process(sampleCount, gainTarget);
+	const gainInc = (voice.volEnv.outputGain - gain) / sampleCount;
 	{
 		const f = voice.filter;
 		const initialFc = modulated[generatorTypes.initialFilterFc];
@@ -11402,8 +11331,13 @@ function renderVoice(voice, timeNow, outputL, outputR, startIndex, sampleCount)
 		}
 		const targetCutoff = f.currentInitialFc + lowpassExcursion;
 		const modulatedResonance = modulated[generatorTypes.initialFilterQ];
-		if (f.currentInitialFc > 13499 && targetCutoff > 13499 && modulatedResonance === 0) f.currentInitialFc = 13500;
-		else {
+		if (f.currentInitialFc > 13499 && targetCutoff > 13499 && modulatedResonance === 0) {
+			f.currentInitialFc = 13500;
+			for (let i = 0; i < sampleCount; i++) {
+				buffer[i] *= gain;
+				gain += gainInc;
+			}
+		} else {
 			if (Math.abs(f.lastTargetCutoff - targetCutoff) > 1 || f.resonanceCb !== modulatedResonance) {
 				f.lastTargetCutoff = targetCutoff;
 				f.resonanceCb = modulatedResonance;
@@ -11418,7 +11352,8 @@ function renderVoice(voice, timeNow, outputL, outputR, startIndex, sampleCount)
 				x1 = input;
 				y2 = y1;
 				y1 = filtered;
-				buffer[i] = filtered;
+				buffer[i] = filtered * gain;
+				gain += gainInc;
 			}
 			f.x1 = x1;
 			f.x2 = x2;
@@ -11426,7 +11361,6 @@ function renderVoice(voice, timeNow, outputL, outputR, startIndex, sampleCount)
 			f.y2 = y2;
 		}
 	}
-	const envActive = voice.volEnv.process(sampleCount, buffer, gainTarget);
 	voice.isActive = voice.isActive && envActive;
 	let pan;
 	if (voice.overridePan) pan = voice.overridePan;
@@ -11434,10 +11368,10 @@ function renderVoice(voice, timeNow, outputL, outputR, startIndex, sampleCount)
 		voice.currentPan += (modulated[generatorTypes.pan] - voice.currentPan) * core.panSmoothingFactor;
 		pan = voice.currentPan;
 	}
-	const gain = core.masterParameters.masterGain * core.midiVolume * voiceGain;
+	const outputGain = core.masterParameters.masterGain * core.midiVolume * voiceGain;
 	const index = pan + 500 | 0;
-	const gainLeft = panTableLeft$1[index] * gain * core.panLeft;
-	const gainRight = panTableRight$1[index] * gain * core.panRight;
+	const gainLeft = panTableLeft$1[index] * outputGain * core.panLeft;
+	const gainRight = panTableRight$1[index] * outputGain * core.panRight;
 	if (this.insertionEnabled) {
 		const insertionL = core.insertionInputL;
 		const insertionR = core.insertionInputR;
@@ -11457,20 +11391,20 @@ function renderVoice(voice, timeNow, outputL, outputR, startIndex, sampleCount)
 	if (!core.enableEffects) return;
 	const reverbSend = modulated[generatorTypes.reverbEffectsSend] * voice.reverbSend;
 	if (reverbSend > 0) {
-		const reverbGain = core.masterParameters.reverbGain * gain * (reverbSend / 1e3);
+		const reverbGain = core.masterParameters.reverbGain * outputGain * (reverbSend / 1e3);
 		const reverb = core.reverbInput;
 		for (let i = 0; i < sampleCount; i++) reverb[i] += reverbGain * buffer[i];
 	}
 	const chorusSend = modulated[generatorTypes.chorusEffectsSend] * voice.chorusSend;
 	if (chorusSend > 0) {
-		const chorusGain = core.masterParameters.chorusGain * (chorusSend / 1e3) * gain;
+		const chorusGain = core.masterParameters.chorusGain * (chorusSend / 1e3) * outputGain;
 		const chorus = core.chorusInput;
 		for (let i = 0; i < sampleCount; i++) chorus[i] += chorusGain * buffer[i];
 	}
 	if (core.delayActive) {
 		const delaySend = this.midiControllers[midiControllers.variationDepth] * voice.delaySend;
 		if (delaySend > 0) {
-			const delayGain = gain * core.masterParameters.delayGain * ((delaySend >> 7) / 127);
+			const delayGain = outputGain * core.masterParameters.delayGain * ((delaySend >> 7) / 127);
 			const delay = core.delayInput;
 			for (let i = 0; i < sampleCount; i++) delay[i] += delayGain * buffer[i];
 		}
@@ -11542,7 +11476,7 @@ function dataEntryCoarse(dataCoarse) {
 			switch (paramCoarse) {
 				default:
 					if (dataCoarse === 64) return;
-					SpessaSynthInfo(`%cUnrecognized NRPN for %c${this.channel}%c: %c(0x${paramFine.toString(16).toUpperCase()} 0x${paramFine.toString(16).toUpperCase()})%c data value: %c${dataCoarse}`, consoleColors.warn, consoleColors.recognized, consoleColors.warn, consoleColors.unrecognized, consoleColors.warn, consoleColors.value);
+					SpessaSynthInfo(`%cUnrecognized NRPN for %c${this.channel}%c: %c(0x${paramCoarse.toString(16).toUpperCase()} 0x${paramFine.toString(16).toUpperCase()})%c data value: %c${dataCoarse}`, consoleColors.warn, consoleColors.recognized, consoleColors.warn, consoleColors.unrecognized, consoleColors.warn, consoleColors.value);
 					break;
 				case nonRegisteredMSB.partParameter: {
 					const paramLock = this.synthCore.masterParameters.nprnParamLock;
@@ -11821,9 +11755,12 @@ function dataEntryFine(dataValue) {
 	switch (this.dataEntryState) {
 		default: break;
 		case dataEntryStates.RPCoarse:
-		case dataEntryStates.RPFine:
-			switch (this.midiControllers[midiControllers.registeredParameterMSB] | this.midiControllers[midiControllers.registeredParameterLSB] >> 7) {
-				default: break;
+		case dataEntryStates.RPFine: {
+			const rpnValue = this.midiControllers[midiControllers.registeredParameterMSB] | this.midiControllers[midiControllers.registeredParameterLSB] >> 7;
+			switch (rpnValue) {
+				default:
+					SpessaSynthInfo(`%cUnrecognized RPN LSB for %c${this.channel}%c: %c(0x${rpnValue.toString(16)})%c data value: %c${dataValue}`, consoleColors.warn, consoleColors.recognized, consoleColors.warn, consoleColors.unrecognized, consoleColors.warn, consoleColors.value);
+					break;
 				case registeredParameterTypes.pitchWheelRange: {
 					if (dataValue === 0) break;
 					this.midiControllers[128 + modulatorSources.pitchWheelRange] |= dataValue;
@@ -11846,16 +11783,17 @@ function dataEntryFine(dataValue) {
 					break;
 			}
 			break;
+		}
 		case dataEntryStates.NRPFine: {
-			const NRPNCoarse = this.midiControllers[midiControllers.nonRegisteredParameterMSB] >> 7;
-			const NRPNFine = this.midiControllers[midiControllers.nonRegisteredParameterLSB] >> 7;
-			if (NRPNCoarse === nonRegisteredMSB.SF2) return;
-			switch (NRPNCoarse) {
+			const paramCoarse = this.midiControllers[midiControllers.nonRegisteredParameterMSB] >> 7;
+			const paramFine = this.midiControllers[midiControllers.nonRegisteredParameterLSB] >> 7;
+			if (paramCoarse === nonRegisteredMSB.SF2 || paramCoarse >= nonRegisteredMSB.drumPitch && paramFine <= nonRegisteredMSB.drumDelay || paramCoarse === nonRegisteredMSB.partParameter) return;
+			switch (paramCoarse) {
 				default:
-					SpessaSynthInfo(`%cUnrecognized NRPN LSB for %c${this.channel}%c: %c(0x${NRPNFine.toString(16).toUpperCase()} 0x${NRPNFine.toString(16).toUpperCase()})%c data value: %c${dataValue}`, consoleColors.warn, consoleColors.recognized, consoleColors.warn, consoleColors.unrecognized, consoleColors.warn, consoleColors.value);
+					SpessaSynthInfo(`%cUnrecognized NRPN LSB for %c${this.channel}%c: %c(0x${paramCoarse.toString(16).toUpperCase()} 0x${paramFine.toString(16).toUpperCase()})%c data value: %c${dataValue}`, consoleColors.warn, consoleColors.recognized, consoleColors.warn, consoleColors.unrecognized, consoleColors.warn, consoleColors.value);
 					break;
 				case nonRegisteredMSB.awe32:
-					handleAWE32NRPN.call(this, NRPNFine, dataValue, this.midiControllers[midiControllers.dataEntryMSB] >> 7);
+					handleAWE32NRPN.call(this, paramFine, dataValue, this.midiControllers[midiControllers.dataEntryMSB] >> 7);
 					break;
 			}
 		}