sib2hum_0.09.plg


{
	Initialize "(){ AddToPluginsMenu('Convert Sibelius Score to Humdrum','Run');

// The following enables the latest behavior for the ManuScript interpreter.
// If you intend your plugin to run on previous versions of Sibelius where that functionality
// didn't exist, you will likely have to revisit the following:
if (Sibelius.ProgramVersion > 20200600) {
    SetInterpreterOption(TreatSingleCharacterAsString);
    SetInterpreterOption(SupportHalfSemitonePitchValues);
} }"
	Run "() {
// Convert Sibelius Score to Humdrum Kern Format
// Version 0.09
// Written by: Hubert Léveillé Gauvin
// Date: January - February 2022

// NOTE: 	GRACE NOTES ARE NOT SUPPORTED AT THE MOMENT (they are ignored by NoteRestAtBarPosVoice)


clefDictionary = CreateClefDictionary();
instrumentDictionary = CreateInstrumentDictionary();
keySignatureDictionary = CreateKeySignatureDictionary();
specialBarlineDictionary = CreateSpecialBarlineDictionary();
durationDictionary = CreateDurationDictionary();
pitchDictionary = CreatePitchDictionary();
articulationDictionary = CreateArticulationDictionary();

openArticulationReferenceNeeded = false;  // keep track whether needed to add !!!RDF**kern: o = harmonic/open to output. See CreateArticulationDictionary and ConvertArticulation for details.
closedArticulationReferenceNeeded = false;	// keep track whether needed to add !!!RDF**kern: O = plus/closed to output. See CreateArticulationDictionary and ConvertArticulation for details.



thisScore = Sibelius.ActiveScore;
sysStaff = thisScore.SystemStaff;
barlines = thisScore.Barlines;

// Create blank text file
fname = '';	
fname = Sibelius.GetDocumentsFolder();
fname = fname & 'sib2humtest.krn';
Sibelius.CreateTextFile(fname);

// Get info from File > Score Info, reformat for Humdrum and append to file
AppendScoreInfoToFile(fname);


// Add Exclusive interpretations

/* Assume for the moment that everything **kern */


humExclusiveInterpretationsLine = '';
currentStaff = thisScore.StaffCount;
while (currentStaff>0)
{	
s = thisScore.NthStaff(currentStaff);

if (currentStaff = 1)
	{	
		humExclusiveInterpretationsLine = humExclusiveInterpretationsLine & '\*\*kern';  // if last staff, dont add tab at the end
	} else {
		humExclusiveInterpretationsLine = humExclusiveInterpretationsLine &  '\*\*kern' & '\t';

	}	
	currentStaff = currentStaff-1;
}


// Add Exclusive interpretations to krn file
Sibelius.AppendLineToFile(fname,humExclusiveInterpretationsLine);	


// Get name of instruments

humInstrumentLine = '';
humInstrumentNameFirstSystemLine = '';
humInstrumentNameSubSytemLine = '';
currentStaff = thisScore.StaffCount;
currentNumberOfVoices = CreateSparseArray(); 
while (currentStaff>0)
{	
s = thisScore.NthStaff(currentStaff);

currentNumberOfVoices[currentStaff] = 1;  // when we start, all number of voices need to be set 1 per staff. This is before measure 1 in Humdrum
	
	if (currentStaff = 1)
	{	
		humInstrumentLine = humInstrumentLine & ConvertInstrumentCode(s.InitialStyleId,instrumentDictionary);  // if last staff, dont add tab at the end
		humInstrumentNameFirstSystemLine = humInstrumentNameFirstSystemLine  & '*I' & Chr(34) & s.FullInstrumentName ;
		humInstrumentNameSubSytemLine = humInstrumentNameSubSytemLine  & '*I\'' & s.ShortInstrumentName ;
	} else {
		humInstrumentLine = humInstrumentLine &  ConvertInstrumentCode(s.InitialStyleId,instrumentDictionary) & '\t';
		humInstrumentNameFirstSystemLine = humInstrumentNameFirstSystemLine  & '*I' & Chr(34) & s.FullInstrumentName & '\t';
		humInstrumentNameSubSytemLine = humInstrumentNameSubSytemLine  & '*I\'' & s.ShortInstrumentName & '\t';
	}	
	currentStaff = currentStaff-1;
}



//Add Humdrum Instrument Line to krn file
Sibelius.AppendLineToFile(fname,humInstrumentLine);
Sibelius.AppendLineToFile(fname,humInstrumentNameFirstSystemLine);
Sibelius.AppendLineToFile(fname,humInstrumentNameSubSytemLine);




// Convert Inital clef name
humInitialClefLine = '';
currentClef = CreateSparseArray();

currentStaff = thisScore.StaffCount;
while (currentStaff>0)
{
s = thisScore.NthStaff(currentStaff);

currentClef[currentStaff] = ConvertClef(s.InitialClefStyleId,clefDictionary);	
	
	if (currentStaff = 1)
	{	
		humInitialClefLine = humInitialClefLine & ConvertClef(s.InitialClefStyleId,clefDictionary);  // if last staff, don't add tab at the end
	} else {
		humInitialClefLine = humInitialClefLine &  ConvertClef(s.InitialClefStyleId,clefDictionary) & '\t';
	}	
	currentStaff = currentStaff-1;
}
//Add Humdrum Clef Line to krn file
Sibelius.AppendLineToFile(fname,humInitialClefLine);


// Convert Initial Key Signature
initialKeySignature = thisScore.SystemStaff.InitialKeySignature.Sharps;
currentKeySignature = initialKeySignature;
humInitialKeySignatureLine = '';
currentStaff = thisScore.StaffCount;
while (currentStaff>0)
{
s = thisScore.NthStaff(currentStaff);
	if (currentStaff = 1) // if last staff, don't add tab at the end
	{	
		if (ConvertClef(s.InitialClefStyleId,clefDictionary) = '*clefX')    // if clef is percussion, no key sig
		{
		humInitialKeySignatureLine = humInitialKeySignatureLine & '*';  
		} else {
		humInitialKeySignatureLine = humInitialKeySignatureLine & ConvertKeySignature(initialKeySignature,keySignatureDictionary);  
		}
		
	} else {
		if (ConvertClef(s.InitialClefStyleId,clefDictionary) = '*clefX' )   // if clef is percussion, no key sig
		{
		humInitialKeySignatureLine = humInitialKeySignatureLine & '*' & '\t';	
		} else {
		humInitialKeySignatureLine = humInitialKeySignatureLine & ConvertKeySignature(initialKeySignature,keySignatureDictionary) & '\t';	
		}
	}	
	currentStaff = currentStaff-1;
}

//Add Humdrum Initial Key Signature Line to krn file
Sibelius.AppendLineToFile(fname,humInitialKeySignatureLine);

// Convert Initial Time Signature

initialTimeSignature = thisScore.SystemStaff.CurrentTimeSignature(1);
currentTimeSignature = initialTimeSignature;
humInitialTimeSignatureLine = '';


initialTimeSignatureArray = ConvertTimeSignature(initialTimeSignature.Numerator,initialTimeSignature.Denominator,initialTimeSignature.Text);
currentStaff = thisScore.StaffCount;
while (currentStaff>0)
{
s = thisScore.NthStaff(currentStaff);
	if (currentStaff = 1)
	{	
		humInitialTimeSignatureLine = humInitialTimeSignatureLine & initialTimeSignatureArray[0] ;  // if last staff, don't add tab at the end
	} else {
		humInitialTimeSignatureLine = humInitialTimeSignatureLine & initialTimeSignatureArray[0] & '\t';
	}	
	currentStaff = currentStaff-1;
}


//Add Humdrum Initial Time Signature Line to krn file
Sibelius.AppendLineToFile(fname,humInitialTimeSignatureLine);

//Check if meter info exists (e.g. common-time), and if so add to krn file

if (initialTimeSignatureArray[1] != '')
{
humInitialMeterLine = '';
currentStaff = thisScore.StaffCount;
while (currentStaff>0)
{
s = thisScore.NthStaff(currentStaff); 
		if (currentStaff = 1)
		{	
		humInitialMeterLine = humInitialMeterLine & initialTimeSignatureArray[1] ;  // if last staff, don't add tab at the end
		} else {
		humInitialMeterLine = humInitialMeterLine & initialTimeSignatureArray[1] & '\t';
		}	
		currentStaff = currentStaff-1;
	}

//Add Humdrum Initial Meter Line to krn file
Sibelius.AppendLineToFile(fname,humInitialMeterLine);

}


// Create a humline with the barline before First Measure
// According to C.Sapp, 'Labeling the first bar is necessary if you need to extract it by measure number with a tool such as myank.'

nextExternalBarNumber = sysStaff.NthBar(1).ExternalBarNumberString;
x = 1;

sblCount = 1;
startsWithRepeat = false;


// this is not elegant, but basically see if there's a start repeat in bar 1
for each SpecialBarline sbl in sysStaff.NthBar(1)
	{
		if (sblCount = 1)
		{	
			if (sbl.BarlineInternalType = SpecialBarlineStartRepeat)
			{
			startsWithRepeat = true;
			startRepeat = sbl.BarlineInternalType;
			}
		}
	}



if (nextExternalBarNumber = '')
{
	if (startsWithRepeat = false)
	{
	thisMeasureBarline = '=-';
	} else {
	thisMeasureBarline = '=' & '1' & ConvertSpecialBarlineCode(startRepeat,specialBarlineDictionary);
	}
} else {
	if (startsWithRepeat = false)
	{
	thisMeasureBarline = '=' & 	nextExternalBarNumber;
	} else {
	thisMeasureBarline = '=' & 	nextExternalBarNumber & ConvertSpecialBarlineCode(startRepeat,specialBarlineDictionary);
	}
}

humBarlineLine = '';
currentStaff = thisScore.StaffCount;
	while (currentStaff>0)
	{
	s = thisScore.NthStaff(currentStaff);
		if (currentStaff = 1)
		{	
		humBarlineLine = humBarlineLine & thisMeasureBarline ;  // if last staff, don't add tab at the end
		} else {
		humBarlineLine = humBarlineLine & thisMeasureBarline & '\t';
		}	
	currentStaff = currentStaff-1;
	}

//Add Humdrum Barline Line to krn file
Sibelius.AppendLineToFile(fname,humBarlineLine);


// prepare progress bar
firstbarnum = 1;
lastbarnum = thisScore.SystemStaff.BarCount;
thisScore.Redraw = False;
progress = 0;
totalBars = lastbarnum;
Sibelius.CreateProgressDialog('Converting to Humdrum format', firstbarnum, totalBars); 


addNewKeySignature = false;
addNewTimeSignature = false;
wholeBarRestTrackerArray = ResetWholeBarRestTracker();  
thisBarNumberOfVoices = CreateSparseArray();
voiceNumberArray = CreateSparseArray();
for each Bar b in sysStaff
{
	//for progress bar
	continue = Sibelius.UpdateProgressDialog(progress,'');	
	if (continue = False)
	{
		Sibelius.DestroyProgressDialog();	
		thisScore.Redraw = True;
		return False;
	}
	progress = progress + 1;	



currentInternalBarNumber = b.BarNumber;
	if (b.BarNumber < sysStaff.BarCount) // As long as not on the last bar
	{
	nextInternalBarNumber = currentInternalBarNumber+1;
	nextExternalBarNumber = sysStaff.NthBar(nextInternalBarNumber).ExternalBarNumberString; 
	}	
	
	noteRestPositionArray = CreateSparseArray();
	currentStaff = thisScore.StaffCount;
	

	while (currentStaff>0)
	{
	s = thisScore.NthStaff(currentStaff);	
	voiceNumberArray = CreateSparseArray();	

		//get a list of all the unique NoteRest position for this bar, regardless of the staff
		// NOTE: THIS DOESN'T WORK FOR TUPLETS
		for each BarObject in s.NthBar(currentInternalBarNumber)
		{
		
		
		
			voiceNumberArray[voiceNumberArray.Length] = BarObject.VoiceNumber ; // keep track of all voice number to later identify the largest one
		
			if (BarObject.Type = 'BarRest')
			{
				if (BarObject.RestType = '0') // if RestType = WholeBarRest
				{					
				wholeBarRestTrackerArray[currentStaff] = true ; // set the tracker for this staff to true
				
					if (utils.IsInArray(noteRestPositionArray,0) = false) //add if 0 not already in array
					{
					noteRestPositionArray[noteRestPositionArray.Length] = 0;  // Create an 'event' at position 0, and add it at the end of the array. Because array iteration starts at 0, Length is the equivalenet of one after last item
					}
				}
			} else {
				if (BarObject.Type = 'NoteRest')
				{
					if (utils.IsInArray(noteRestPositionArray,BarObject.Position) = false) //add if not already in array
					{	
					noteRestPositionArray[noteRestPositionArray.Length] = BarObject.Position;
					}
				}
			}	
		}
		
		//sort the array, reverse it and get the first item, i.e. the largest number of voices.
		voiceNumberArray = utils.SortArrayNumeric(voiceNumberArray,false);
		numberOfVoices = voiceNumberArray[voiceNumberArray.Length-1] ;
		thisBarNumberOfVoices[currentStaff] = numberOfVoices;
			

	
	currentStaff=currentStaff-1;	
	}
	

	
	
	
	
		// test if the time sig for this element is different than current.
		if( currentTimeSignature.Text != sysStaff.CurrentTimeSignature(currentInternalBarNumber).Text)
		{	currentTimeSignature = thisScore.SystemStaff.CurrentTimeSignature(currentInternalBarNumber);
			addNewTimeSignature = true;
		
		
		

		humNewTimeSignatureLine = '';
		currentTimeSignatureArray = ConvertTimeSignature(currentTimeSignature.Numerator,currentTimeSignature.Denominator,currentTimeSignature.Text);

		currentStaff = thisScore.StaffCount;
		while (currentStaff>0)
		{
		s = thisScore.NthStaff(currentStaff);	
			if (currentStaff = 1)
			{	
			humNewTimeSignatureLine = humNewTimeSignatureLine & currentTimeSignatureArray[0] ;  // if last staff, don't add tab at the end
			} else {
			humNewTimeSignatureLine = humNewTimeSignatureLine & currentTimeSignatureArray[0] & '\t';
			}	
		currentStaff = currentStaff-1;
		}
		
		//Add Humdrum New Time Signature Line to krn file
		Sibelius.AppendLineToFile(fname,humNewTimeSignatureLine);
		
		
		//Check if meter info exists (e.g. common-time), and if so add to krn file
		if (currentTimeSignatureArray[1] != '')
		{

		currentStaff = thisScore.StaffCount;
		while (currentStaff>0)
		{
		s = thisScore.NthStaff(currentStaff);	
			if (currentStaff = 1)
			{	
			humNewMeterLine = humNewMeterLine & currentTimeSignatureArray[1] ;  // if last staff, don't add tab at the end
			} else {
			humNewMeterLine = humNewMeterLine & currentTimeSignatureArray[1] & '\t';
			}	
			currentStaff = currentStaff-1;
		}

		//Add Humdrum Initial Meter Line to krn file
		Sibelius.AppendLineToFile(fname,humNewMeterLine);

		}

		
		
		
		}
	
	
	
	// check to see if the number of voices has changed between this bar and last bar
	keepLooping = true;
	writeHumSpinePathLineToFile = false;
	humSpinePathLine = '';
	while (keepLooping=true)
	{
		keepLoopingArray = CreateSparseArray();
		keepLooping = false;
		
		currentStaff = thisScore.StaffCount;
	while (currentStaff>0)  //for each staff
		{
		
			
			if (thisBarNumberOfVoices[currentStaff] = currentNumberOfVoices[currentStaff])
			{
			
				for x = 0 to thisBarNumberOfVoices[currentStaff]
				{
					if (currentStaff = 1)
					{	
					humSpinePathLine = 	humSpinePathLine & '*' ;
					} else {
					humSpinePathLine = 	humSpinePathLine & '*' & '\t' ;
					}	
				}	
			} else {
				writeHumSpinePathLineToFile = true;
				if (thisBarNumberOfVoices[currentStaff] > currentNumberOfVoices[currentStaff])  //if we need to add a spine
				{
						if (currentStaff = 1)
						{	
						humSpinePathLine = 	humSpinePathLine &  CreateSpinePathIndicators(currentNumberOfVoices[currentStaff],currentNumberOfVoices[currentStaff]+1) ;
						} else {
						humSpinePathLine = 	humSpinePathLine &  CreateSpinePathIndicators(currentNumberOfVoices[currentStaff],currentNumberOfVoices[currentStaff]+1) & '\t' ;
						}	
					
					currentNumberOfVoices[currentStaff] = currentNumberOfVoices[currentStaff]+1 ;
					
					
				} else {  //if we need to remove a spine
						if (currentStaff = 1)
						{	
						humSpinePathLine = 	humSpinePathLine &  CreateSpinePathIndicators(currentNumberOfVoices[currentStaff],currentNumberOfVoices[currentStaff]-1) ;
						} else {
						humSpinePathLine = 	humSpinePathLine &  CreateSpinePathIndicators(currentNumberOfVoices[currentStaff],currentNumberOfVoices[currentStaff]-1) & '\t' ;
						}	
					
					currentNumberOfVoices[currentStaff] = currentNumberOfVoices[currentStaff]-1 ;
				}		
				
			}
			
			if (thisBarNumberOfVoices[currentStaff] != currentNumberOfVoices[currentStaff])
				{
					keepLoopingArray[keepLoopingArray.Length] = 'true';	
				} else {
					keepLoopingArray[keepLoopingArray.Length] = 'false';
				}	
	
		currentStaff=currentStaff-1;	
		}
	
		for each i in keepLoopingArray 
			{
				if (i='true')
				{ 
				keepLooping = true;
				}
			}
	
	
		if (writeHumSpinePathLineToFile = true)
		{
			Sibelius.AppendLineToFile(fname,humSpinePathLine);
		}
	}
	
	
	
	
	
	
	
	// sort the array
	noteRestPositionArray = utils.SortArrayNumeric(noteRestPositionArray,false);
	
	
	
	
	
	
	// create one humLine per Rhythmic Position in noteRestPositionArray
	line = '1';
	
	for each e in noteRestPositionArray
	{
	writeNewClefArray = CreateSparseArray();
	newClefNeeded = false;
	humLine = '';
	
		// test if the key sig for this element is different than current.
		// NOTE: This method assumes that all staves have same key signature, which might not always be true...
		if( currentKeySignature != b.GetKeySignatureAt(e).Sharps)
		{	currentKeySignature = b.GetKeySignatureAt(e).Sharps;
			addNewKeySignature = true;
		}
		
		
	
			currentStaff = thisScore.StaffCount;
			while (currentStaff>0) // for each staff, but reverse order...
			{
			s = thisScore.NthStaff(currentStaff);	
			v = currentNumberOfVoices[currentStaff] ;	
			
			// Store the clef at this staff/pos to compare later with currentClef 
			clefObject = s.NthBar(currentInternalBarNumber).GetClefAt(e);
			
			if (ConvertClef(clefObject.ConcertClefStyleId,clefDictionary) != currentClef[currentStaff]) // if the clef for this staff has changed
			{

			writeNewClefArray[currentStaff] = ConvertClef(clefObject.ConcertClefStyleId,clefDictionary);
			currentClef[currentStaff] = ConvertClef(clefObject.ConcertClefStyleId,clefDictionary);
			newClefNeeded = true;
			} else {

				writeNewClefArray[currentStaff] = 'false';	
			}
			
			while (v>0)
			{	
				
				if (wholeBarRestTrackerArray[currentStaff] = true)  // if this measure is wholebarrest
				{
					
					if (v = 1) // if v is in largest voice
						{
						kernToken = 'rr' ;  // this is legal but not supported by Verovio reader. See this for how to do it properly https://doc.verovio.humdrum.org/humdrum/getting_started/#extended-rhythm-representation
						} else {
						kernToken = 'rr' & '\t';
						}
					wholeBarRestTrackerArray[currentStaff] = false ;
				} else {
					
					result = NoteRestAtBarPosVoice(s.NthBar(currentInternalBarNumber),e,v);  // always voice 1 for now. Add loop here eventually
					kernToken = '' ;
					if (result != null)
					{
					humDuration = ConvertDuration(result,durationDictionary);
						if (result.NoteCount = 0)   // is NoteRest is rest
						{
						kernToken = humDuration & 'r';  // 
						} else {// if NoteRest is note or chord
							
							
						
						if (result.GetIsInVoice(1)) // if result is in largest voice
						{
							for each n in result  // for each note of chord
							{	
								
									
								articulationArray = ConvertArticulation(n,articulationDictionary);
								humArticulation = articulationArray[0];
								kernToken = kernToken & humDuration & ConvertPitch(n,pitchDictionary) & humArticulation & ' ';  
									
							}
							
							
							kernToken = utils.TrimBlanks(kernToken) ;  // Remove that last space that was added in the loop above
						
						} else {
								
							for each n in result  // for each note of chord
							{	
								
									
								articulationArray = ConvertArticulation(n,articulationDictionary);
								humArticulation = articulationArray[0];
								kernToken = kernToken & humDuration & ConvertPitch(n,pitchDictionary) & humArticulation & ' ';  
									
							}
							
							
							kernToken = utils.TrimBlanks(kernToken) & '\t';  // Remove that last space that was added in the loop above AND ADD tab 
						}	
						
							if (articulationArray[1] = true) // if openArticualationReferenceNeeded
							{
							openArticulationReferenceNeeded = true; 
							}
							
							if (articulationArray[2] = true) // if closedArticualationReferenceNeeded
							{
							closedArticulationReferenceNeeded = true;	
							}
						
						
						}

				

					} else { // if there is no event at that position in that bar, null token is needed
					
						if (v = 1) // if v is in largest voice
						{
						kernToken = '.';
						} else {
						kernToken = '.' & '\t';	
						}
					
					
					
					}
				}
				
				if (currentStaff = 1)
				{	
				humLine = humLine & kernToken ;  // if last staff, don't add tab at the end
				} else {
				humLine = humLine & kernToken & '\t';
				}	
			
				v = v-1;
			}	
				currentStaff = currentStaff-1;
			}
		
		 
		 
		 
		 // if addNewKeySignature is true, add a new key signature before adding Humdrum Line 
		if (addNewKeySignature = true)
		{
			
			humNewKeySignatureLine = '';
			currentStaff = thisScore.StaffCount;
			while (currentStaff>0)
			{
			s = thisScore.NthStaff(currentStaff);
			v = currentNumberOfVoices[currentStaff] ;			
			
				while (v>0)
				{
				
					if (currentStaff = 1) // if last staff, don't add tab at the end
						{	
							if (v = 1) //if last staff last voice, don't add tab
							{
							
								if (currentClef[currentStaff] = '*clefX')    // if clef is percussion, no key sig
								{
								humNewKeySignatureLine = humNewKeySignatureLine & '*';  
								} else {
								humNewKeySignatureLine = humNewKeySignatureLine & ConvertKeySignature(currentKeySignature,keySignatureDictionary);  
								}
							}	
							
						} else {
							if (currentClef[currentStaff] = '*clefX' )   // if clef is percussion, no key sig
							{
							humNewKeySignatureLine = humNewKeySignatureLine & '*' & '\t';	
							} else {
							humNewKeySignatureLine = humNewKeySignatureLine & ConvertKeySignature(currentKeySignature,keySignatureDictionary) & '\t';	
							}
						}	
				
				v = v-1;
				}	
			
			currentStaff = currentStaff-1;
			}	

		
			//Add New Key Signature Line to krn file
			Sibelius.AppendLineToFile(fname,humNewKeySignatureLine);
			addNewKeySignature = false ; // set back flag to false
		}
		 
		 
		 // check if a staff has a new clef, and if so, add new Clef Line befor main humLine
		if (newClefNeeded = true) // if something was was added to the array, this means we need a new clef somewhere
		{

			currentStaff = thisScore.StaffCount;
			humNewClefLine = '';
			while (currentStaff>0) // for each staff, but reverse order...
			{
			s = thisScore.NthStaff(currentStaff);	
			v = currentNumberOfVoices[currentStaff];
				while (v>0)
				{	
			
				if (currentStaff = 1)
				{
						if (v = 1) //if last staff last voice, don't add tab
						{
							if (writeNewClefArray[currentStaff] != 'false')
							{
								humNewClefLine = humNewClefLine & writeNewClefArray[currentStaff];
							} else {
								humNewClefLine = humNewClefLine & '\*';
							}
						} 
						
				}	else {
						if (writeNewClefArray[currentStaff] != 'false')
						{	
							humNewClefLine = humNewClefLine & writeNewClefArray[currentStaff] & '\t';
						} else {
							humNewClefLine = humNewClefLine & '\*' & '\t';
						}
				}		

				v = v-1;
				}	
			currentStaff = currentStaff-1;
			}
			
		//Add Humdrum Line to krn file
		Sibelius.AppendLineToFile(fname,humNewClefLine);	
		}
		 
		 
		
		//Add Humdrum Line to krn file
		Sibelius.AppendLineToFile(fname,humLine);


	line = line+1;	
	}	
	
	
	/* 	This bit is a train wreck, because of the different way in which Sib and Humdrum handles barlines. 
		The complicated bit is the end-repeat-start-repeat combinaision.
		I need to look at special barlines always for the current and next barline 
	*/
	
	specialBarline = false;
	thisMeasureBarline = '';
	x=1;
	for each SpecialBarline sbl in b	
	{
	specialBarline = true;
	
		if (b.BarNumber = sysStaff.BarCount)
		{
		thisMeasureBarline = '=' & ConvertSpecialBarlineCode(sbl.BarlineInternalType,specialBarlineDictionary);  // if final barline, no bar number
		} else {
				
				
				if (startsWithRepeat = true)
				{ 
				startsWithRepeat = false;
				specialBarline = false;
				} else {

				thisMeasureBarline = '=' & nextExternalBarNumber & ConvertSpecialBarlineCode(sbl.BarlineInternalType,specialBarlineDictionary) & CreateTokenIfBarStartsWithStartRepeat(nextInternalBarNumber);
				thisMeasureBarline = utils.Replace(thisMeasureBarline,'!!','!',false); // when there is end repeat followed by start repeat, this removes the superfluous !
					if (CreateTokenIfBarStartsWithStartRepeat(nextInternalBarNumber) != '')
					{
					startsWithRepeat = true;
					} else {
					startsWithRepeat = false;
					}
				}
		}			
	x=x+1;
	}

	if (specialBarline = false)
	{
			if (b.BarNumber = sysStaff.BarCount)
			{
			thisMeasureBarline = '=' ;  //in the rare case where last measure does not have a special barline, make sure to not add a bar number
			} else {
			thisMeasureBarline = '=' & nextExternalBarNumber & CreateTokenIfBarStartsWithStartRepeat(nextInternalBarNumber) ;
			thisMeasureBarline = utils.Replace(thisMeasureBarline,'!!','!',false); 
				if (CreateTokenIfBarStartsWithStartRepeat(nextInternalBarNumber) != '')
					{
					startsWithRepeat = true;
					} else {
					startsWithRepeat = false;
					}
			}

	}

	// Create a humline with the barline at the end of this measure

	humBarlineLine = '';
	
	currentStaff = thisScore.StaffCount;
	while (currentStaff>0)
	{
	s = thisScore.NthStaff(currentStaff); 
		
		
			v = currentNumberOfVoices[currentStaff] ;
			while (v>0)
			{	
				
				if (currentStaff = 1)
				{
					if (v = 1)
					{	
					humBarlineLine = humBarlineLine & thisMeasureBarline ;  // if last staff AND last voice, don't add tab at the end
					} else {
					humBarlineLine = humBarlineLine & thisMeasureBarline & '\t';
					}
				} else {
				humBarlineLine = humBarlineLine & thisMeasureBarline & '\t';
				}	
			v = v-1;
			}
		
		currentStaff = currentStaff-1;
	}

	
	
	

	
		
	//Add Humdrum Barline Line to krn file
	Sibelius.AppendLineToFile(fname,humBarlineLine);


}


// bring the number of spines to 1 per staff before spine-terminator

	keepLooping = true;
	writeHumSpinePathLineToFile = false;
	while (keepLooping=true)
	{
		keepLoopingArray = CreateSparseArray();
		keepLooping = false;
		humSpinePathLine = '';
		currentStaff = thisScore.StaffCount;
		while (currentStaff>0)  //for each staff
		{
			if (currentNumberOfVoices[currentStaff] = 1)
			{
				for x = 0 to currentNumberOfVoices[currentStaff]
				{
					if (currentStaff = 1)
					{	
					humSpinePathLine = 	humSpinePathLine & '*' ;
					} else {
					humSpinePathLine = 	humSpinePathLine & '*' & '\t' ;
					}
				}
			} else {  //if we need to remove a spine
			writeHumSpinePathLineToFile = true;
			
						if (currentStaff = 1)
						{	
						humSpinePathLine = 	humSpinePathLine &  CreateSpinePathIndicators(currentNumberOfVoices[currentStaff],currentNumberOfVoices[currentStaff]-1) ;
						} else {
						humSpinePathLine = 	humSpinePathLine &  CreateSpinePathIndicators(currentNumberOfVoices[currentStaff],currentNumberOfVoices[currentStaff]-1) & '\t' ;
						}	
					
					currentNumberOfVoices[currentStaff] = currentNumberOfVoices[currentStaff]-1 ;
				}		
				
			
			
			if (currentNumberOfVoices[currentStaff] != 1)
				{
					keepLoopingArray[keepLoopingArray.Length] = 'true';	
				} else {
					keepLoopingArray[keepLoopingArray.Length] = 'false';
				}	
	
		currentStaff=currentStaff-1;	
		}
	
		for each i in keepLoopingArray 
			{
				if (i='true')
				{ 
				keepLooping = true;
				}				
			}
	
	
		if (writeHumSpinePathLineToFile = true)
		{
			Sibelius.AppendLineToFile(fname,humSpinePathLine);
		}
	}












	// create one Humdrum spine-path terminator Line

	humSpinePathTerminatorLine = '';
	currentStaff = thisScore.StaffCount;
	while (currentStaff>0)
	{
	s = thisScore.NthStaff(currentStaff);	
		if (currentStaff = 1) // if last staff
		{	
		humSpinePathTerminatorLine = humSpinePathTerminatorLine & '*-' ;  // if last staff, don't add tab at the end
		} else {
		humSpinePathTerminatorLine = humSpinePathTerminatorLine & '*-' & '\t';
		}	
		currentStaff = currentStaff-1;
	}

	

	
	
//Add Humdrum spine-path terminator Line to krn file
Sibelius.AppendLineToFile(fname,humSpinePathTerminatorLine);
	
// for progress bar
Sibelius.DestroyProgressDialog();	
thisScore.Redraw = True;


// Add !!!RDF**kern: o = harmonic/open if needed
if (openArticulationReferenceNeeded = true)
{
Sibelius.AppendLineToFile(fname,'!!!RDF**kern: o = harmonic/open');	
}

// Add !!!RDF**kern: O = plus/closed if needed
if (closedArticulationReferenceNeeded = true)
{
Sibelius.AppendLineToFile(fname,'!!!RDF**kern: O = plus/closed');	
}


//Add final line that doesn't end with new line car, hence AppendTextFile and not AppendLineToFile
Sibelius.AppendTextFile(fname,'!! Converted from Sibelius with sib2hum plugin');


//Message Box at the end to know it's done is nice
Sibelius.MessageBox('Done! The file is available here; ' & fname);



}"
	ConvertInstrumentCode "(InitialStyleId,instrumentDictionary) {
/* Instruments that are not currently mapped to a Humdrum equivalent will become **I?? for the moment */


if (instrumentDictionary[InitialStyleId] = '')
{
return '*I??';
} else {
return instrumentDictionary[InitialStyleId];
}}"
	ConvertClef "(clefStyle,clefDictionary) {
/* Convert Sib clefs to Humdrum format using the dictionary createde with CreateClefDictionary() ; 
I'm ignoring all TAB clefs for the moment; they will become *clef?? */


if (clefDictionary[clefStyle] = '')
{
return '*clef??';
} else {
return clefDictionary[clefStyle];
}

}"
	CreateInstrumentDictionary "() {
instrumentDictionary = CreateDictionary(

'instrument.brass.cornet.a','*Icornt',
'instrument.brass.cornet.bflat','*Icornt',
'instrument.brass.cornet.soprano.eflat','*Icornt',
'instrument.brass.flugelhorn','*Iflugh',
'instrument.brass.horn.a.nokeysig','*Icor',
'instrument.brass.horn.alto.aflat.nokeysig','*Icor',
'instrument.brass.horn.alto.eflat','*Icor',
'instrument.brass.horn.alto.f','*Icor',
'instrument.brass.horn.b.nokeysig','*Icor',
'instrument.brass.horn.basso.a.nokeysig','*Icor',
'instrument.brass.horn.basso.bflat.nokeysig','*Icor',
'instrument.brass.horn.basso.c.nokeysig','*Icor',
'instrument.brass.horn.bflat.nokeysig','*Icor',
'instrument.brass.horn.c.nokeysig','*Icor',
'instrument.brass.horn.d.nokeysig','*Icor',
'instrument.brass.horn.dflat.nokeysig','*Icor',
'instrument.brass.horn.e.nokeysig','*Icor',
'instrument.brass.horn.eflat','*Icor',
'instrument.brass.horn.eflat.nokeysig','*Icor',
'instrument.brass.horn.f','*Icor',
'instrument.brass.horn.f.bassclef','*Icor',
'instrument.brass.horn.f.nokeysig','*Icor',
'instrument.brass.horn.fsharp.nokeysig','*Icor',
'instrument.brass.horn.g.nokeysig','*Icor',
'instrument.brass.horn.tenor','*Icor',
'instrument.brass.trombone','*Itromt',
'instrument.brass.trombone.bassclef.trebleclef','*Itromt',
'instrument.brass.trombone.tenor','*Itromt',
'instrument.brass.trombone.trebleclef','*Itromt',
'instrument.brass.trumpet.a','*Itromp',
'instrument.brass.trumpet.b.nokeysig','*Itromp',
'instrument.brass.trumpet.bflat','*Itromp',
'instrument.brass.trumpet.bflat.nokeysig','*Itromp',
'instrument.brass.trumpet.c','*Itromp',
'instrument.brass.trumpet.d','*Itromp',
'instrument.brass.trumpet.dflat','*Itromp',
'instrument.brass.trumpet.e.nokeysig','*Itromp',
'instrument.brass.trumpet.eflat','*Itromp',
'instrument.brass.trumpet.f','*Itromp',
'instrument.brass.trumpet.g.nokeysig','*Itromp',
'instrument.brass.tuba','*Ituba',
'instrument.brass.tuba.f','*Ituba',
'instrument.brass.tuba.tenor','*Ituba',
'instrument.brass.tuba.tenor.bassclef','*Ituba',
'instrument.brass.tuba.wagner.bflat','*Ituba',
'instrument.brass.tuba.wagner.f','*Ituba',
'instrument.fretted.banjo.5lines','*Ibanjo',
'instrument.fretted.banjo.aDADE.tab','*Ibanjo',
'instrument.fretted.banjo.aEADE.tab','*Ibanjo',
'instrument.fretted.banjo.gCGBD.tab','*Ibanjo',
'instrument.fretted.banjo.gCGCD.tab','*Ibanjo',
'instrument.fretted.banjo.gDFAD.tab','*Ibanjo',
'instrument.fretted.banjo.gDGBD.tab','*Ibanjo',
'instrument.fretted.banjo.gDGCD.tab','*Ibanjo',
'instrument.fretted.banjo.tenor.5lines','*Ibanjo',
'instrument.fretted.banjo.tenor.tab','*Ibanjo',
'instrument.fretted.guitar.resonator.5lines','*Iguitr',
'instrument.fretted.guitar.resonator.a6.tab','*Iguitr',
'instrument.fretted.guitar.resonator.b11.tab','*Iguitr',
'instrument.fretted.guitar.resonator.c#m.tab','*Iguitr',
'instrument.fretted.guitar.resonator.c6-a7.tab','*Iguitr',
'instrument.fretted.guitar.resonator.c6-highg.tab','*Iguitr',
'instrument.fretted.guitar.resonator.c6.tab','*Iguitr',
'instrument.fretted.guitar.resonator.cm7.tab','*Iguitr',
'instrument.fretted.guitar.resonator.e13-hawaiian.tab','*Iguitr',
'instrument.fretted.guitar.resonator.e13-western.tab','*Iguitr',
'instrument.fretted.guitar.resonator.open.A.tab','*Iguitr',
'instrument.fretted.guitar.resonator.open.G.tab','*Iguitr',
'instrument.fretted.dulcimer','*Idulc',
'instrument.fretted.dulcimer.5lines','*Idulc',
'instrument.fretted.dulcimer.daa.tab','*Idulc',
'instrument.fretted.dulcimer.dad.tab','*Idulc',
'instrument.fretted.guitar.12-string.5lines','*Iguitr',
'instrument.fretted.guitar.12-string.dadgad.tab','*Iguitr',
'instrument.fretted.guitar.12-string.double-d.tab','*Iguitr',
'instrument.fretted.guitar.12-string.dropped-d.tab','*Iguitr',
'instrument.fretted.guitar.12-string.open-d.tab','*Iguitr',
'instrument.fretted.guitar.12-string.open-e.tab','*Iguitr',
'instrument.fretted.guitar.12-string.open-g.tab','*Iguitr',
'instrument.fretted.guitar.12-string.tab','*Iguitr',
'instrument.fretted.guitar.12-string.tab.rhythms','*Iguitr',
'instrument.fretted.guitar.acoustic.5lines','*Iguitr',
'instrument.fretted.guitar.acoustic.dadgad.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.double-d.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.dropped-d.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.modal-d.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.nashville.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.open-a.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.open-c.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.open-d.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.open-dm.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.open-e.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.open-g.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.tab.rhythms','*Iguitr',
'instrument.fretted.guitar.bass.4-string.5lines','*Ibguit',
'instrument.fretted.guitar.bass.4-string.tab','*Ibguit',
'instrument.fretted.guitar.bass.5-string.5lines','*Ibguit',
'instrument.fretted.guitar.bass.5-string.tab','*Ibguit',
'instrument.fretted.guitar.bass.5lines','*Ibguit',
'instrument.fretted.guitar.bass.6-string.5lines','*Ibguit',
'instrument.fretted.guitar.bass.6-string.tab','*Ibguit',
'instrument.fretted.guitar.bass.electric.5-string.5lines','*Ibguit',
'instrument.fretted.guitar.bass.electric.5-string.tab','*Ibguit',
'instrument.fretted.guitar.bass.electric.5lines','*Ibguit',
'instrument.fretted.guitar.bass.electric.6-string.5lines','*Ibguit',
'instrument.fretted.guitar.bass.electric.6-string.tab','*Ibguit',
'instrument.fretted.guitar.bass.electric.fretless.5-string.5lines','*Ibguit',
'instrument.fretted.guitar.bass.electric.fretless.5-string.tab','*Ibguit',
'instrument.fretted.guitar.bass.electric.fretless.5lines','*Ibguit',
'instrument.fretted.guitar.bass.electric.fretless.6-string.5lines','*Ibguit',
'instrument.fretted.guitar.bass.electric.fretless.6-string.tab','*Ibguit',
'instrument.fretted.guitar.bass.electric.fretless.tab','*Ibguit',
'instrument.fretted.guitar.bass.electric.tab','*Ibguit',
'instrument.fretted.guitar.bass.fretless.5-string.5lines','*Ibguit',
'instrument.fretted.guitar.bass.fretless.5-string.tab','*Ibguit',
'instrument.fretted.guitar.bass.fretless.5lines','*Ibguit',
'instrument.fretted.guitar.bass.fretless.6-string.5lines','*Ibguit',
'instrument.fretted.guitar.bass.fretless.6-string.tab','*Ibguit',
'instrument.fretted.guitar.bass.fretless.tab','*Ibguit',
'instrument.fretted.guitar.bass.semi-acoustic.5lines','*Ibguit',
'instrument.fretted.guitar.bass.semi-acoustic.tab','*Ibguit',
'instrument.fretted.guitar.bass.tab','*Ibguit',
'instrument.fretted.guitar.bass.tab.rhythms','*Ibguit',
'instrument.fretted.guitar.classical.5lines','*Iguitr',
'instrument.fretted.guitar.classical.dadgad.tab','*Iguitr',
'instrument.fretted.guitar.classical.double-d.tab','*Iguitr',
'instrument.fretted.guitar.classical.dropped-d.tab','*Iguitr',
'instrument.fretted.guitar.classical.open-d.tab','*Iguitr',
'instrument.fretted.guitar.classical.open-e.tab','*Iguitr',
'instrument.fretted.guitar.classical.open-g.tab','*Iguitr',
'instrument.fretted.guitar.classical.tab','*Iguitr',
'instrument.fretted.guitar.classical.tab.rhythms','*Iguitr',
'instrument.fretted.guitar.electric.5lines','*Ieguit',
'instrument.fretted.guitar.electric.7-string.low-a.tab','*Ieguit',
'instrument.fretted.guitar.electric.7-string.tab','*Ieguit',
'instrument.fretted.guitar.electric.dadgad.tab','*Ieguit',
'instrument.fretted.guitar.electric.double-d.tab','*Ieguit',
'instrument.fretted.guitar.electric.dropped-d.tab','*Ieguit',
'instrument.fretted.guitar.electric.open-d.tab','*Ieguit',
'instrument.fretted.guitar.electric.open-e.tab','*Ieguit',
'instrument.fretted.guitar.electric.open-g.tab','*Ieguit',
'instrument.fretted.guitar.electric.tab','*Ieguit',
'instrument.fretted.guitar.electric.tab.rhythms','*Ieguit',
'instrument.fretted.guitar.semi-acoustic.5lines','*Iguitr',
'instrument.fretted.guitar.semi-acoustic.dadgad.tab','*Iguitr',
'instrument.fretted.guitar.semi-acoustic.double-d.tab','*Iguitr',
'instrument.fretted.guitar.semi-acoustic.dropped-d.tab','*Iguitr',
'instrument.fretted.guitar.semi-acoustic.open-d.tab','*Iguitr',
'instrument.fretted.guitar.semi-acoustic.open-e.tab','*Iguitr',
'instrument.fretted.guitar.semi-acoustic.open-g.tab','*Iguitr',
'instrument.fretted.guitar.semi-acoustic.tab','*Iguitr',
'instrument.fretted.guitar.semi-acoustic.tab.rhythms','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.10-string.tab','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.5lines','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.6-string.tab','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.6-string.tab.alternative','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.6-string.tab.bflat.mauna.loa','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.6-string.tab.c.mauna.loa','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.6-string.tab.cgdgbd.wahine','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.6-string.tab.cgdgbe.wahine','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.6-string.tab.dgdfbd.wahine','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.6-string.tab.g.mauna.loa','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.6-string.tab.g.taro.patch','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.6-string.tab.gcdgbe.wahine','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.8-string.tab','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.8-string.tab.alternative','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.tab','*Iguitr',
'instrument.fretted.guitar.steel.pedal.5lines','*Iguitr',
'instrument.fretted.guitar.steel.pedal.tab','*Iguitr',
'instrument.fretted.guitarra.5lines','*Iguitr',
'instrument.fretted.guitarra.coimbra.tab','*Iguitr',
'instrument.fretted.guitarra.lisboa.tab','*Iguitr',
'instrument.fretted.guitarra.portuguesa.tab','*Iguitr',
'instrument.fretted.lute.5lines','*Iliuto',
'instrument.fretted.lute.bass-d.french.english.5lines','*Iliuto',
'instrument.fretted.lute.bass-d.french.english.tab','*Iliuto',
'instrument.fretted.lute.bass-d.italian.tab','*Iliuto',
'instrument.fretted.lute.bass-d.spanish.tab','*Iliuto',
'instrument.fretted.lute.italian.tab','*Iliuto',
'instrument.fretted.lute.spanish.tab','*Iliuto',
'instrument.fretted.lute.tab','*Iliuto',
'instrument.fretted.lute.tenor-a.french.english.tab','*Iliuto',
'instrument.fretted.lute.tenor-a.italian.tab','*Iliuto',
'instrument.fretted.lute.tenor-a.spanish.tab','*Iliuto',
'instrument.fretted.lute.treble-d.french.english.5lines','*Iliuto',
'instrument.fretted.lute.treble-d.french.english.tab','*Iliuto',
'instrument.fretted.lute.treble-d.italian.tab','*Iliuto',
'instrument.fretted.lute.treble-d.spanish.tab','*Iliuto',
'instrument.fretted.mandolin.5lines','*Imando',
'instrument.fretted.mandolin.tab','*Imando',
'instrument.fretted.oud.5lines','*Ioud',  // 2022-01-30: New instrument code proposed by C.Sapp to replace old Iud
'instrument.fretted.oud.tab','*Ioud',	// 2022-01-30: New instrument code proposed by C.Sapp to replace old Iud
'instrument.fretted.sitar.5lines','*Isitar',
'instrument.fretted.sitar.ravi-shankkar.tab','*Isitar',
'instrument.fretted.sitar.vilayat-khan.tab','*Isitar',
'instrument.fretted.tambura.female','*Itambu',
'instrument.fretted.tambura.male','*Itambu',
'instrument.fretted.ukulele.5lines','*Iukule',
'instrument.fretted.ukulele.tab','*Iukule',
'instrument.fretted.zither','*Izithr',
'instrument.keyboard.accordion','*Iaccor',
'instrument.keyboard.celesta','*Iclest',
'instrument.keyboard.clavichord','*Iclavi',
'instrument.keyboard.keyboards','*Icemba',
'instrument.keyboard.organ.manuals','*Iorgan',
'instrument.keyboard.organ.manuals.solo','*Iorgan',
'instrument.keyboard.organ.pedals','*Iorgan',
'instrument.keyboard.organ.pedals.solo','*Iorgan',
'instrument.keyboard.piano','*Ipiano',
'instrument.keyboard.synthesizer','*Isynth',
'instrument.pitchedpercussion.bells.chimes','*Ichime',
'instrument.pitchedpercussion.bells.chimes.nokeysig','*Ichime',
'instrument.pitchedpercussion.bells.orchestral','*Icampn',
'instrument.pitchedpercussion.bells.tubular','*Icampn',
'instrument.pitchedpercussion.cimbalom','*Idulc',
'instrument.pitchedpercussion.drums.steel','*Isteel',
'instrument.pitchedpercussion.drums.steel.bassclef','*Isteel',
'instrument.pitchedpercussion.glockenspiel','*Iglock',
'instrument.pitchedpercussion.glockenspiel.alto','*Iglock',
'instrument.pitchedpercussion.glockenspiel.soprano','*Iglock',
'instrument.pitchedpercussion.harp','*Iarpa',
'instrument.pitchedpercussion.harp.lever','*Iarpa',
'instrument.pitchedpercussion.timpani','*Itimpa',
'instrument.pitchedpercussion.timpani.nokeysig','*Itimpa',
'instrument.pitchedpercussion.vibraphone','*Ivibra',
'instrument.pitchedpercussion.xylophone','*Ixylo',
'instrument.pitchedpercussion.xylophone.alto','*Ixylo',
'instrument.pitchedpercussion.xylophone.bass','*Ixylo',
'instrument.pitchedpercussion.xylophone.soprano','*Ixylo',
'instrument.singers.alto','*Ialto',
'instrument.singers.alto.solo','*Ialto',
'instrument.singers.baritone','*Ibarit',
'instrument.singers.baritone.solo','*Ibarit',
'instrument.singers.bass','*Ibass',
'instrument.singers.bass.solo','*Ibass',
'instrument.singers.contralto','*Icalto',
'instrument.singers.counter-tenor','*Ictenor',
'instrument.singers.mezzo-soprano','*Imezzo',
'instrument.singers.soprano','*Isoprn',
'instrument.singers.soprano.solo','*Isoprn',
'instrument.singers.tenor','*Itenor',
'instrument.singers.tenor.solo','*Itenor',
'instrument.singers.voice.male','*Imale',
'instrument.strings.contrabass','*Icbass',
'instrument.strings.contrabass.bass','*Icbass',
'instrument.strings.contrabass.double-bass','*Icbass',
'instrument.strings.contrabass.solo','*Icbass',
'instrument.strings.contrabass.string','*Icbass',
'instrument.strings.contrabass.upright','*Icbass',
'instrument.strings.viola','*Iviola',
'instrument.strings.viola.solo','*Iviola',
'instrument.strings.violin.1','*Ivioln',
'instrument.strings.violin.2','*Ivioln',
'instrument.strings.violin.I','*Ivioln',
'instrument.strings.violin.ii','*Ivioln',
'instrument.strings.violin.solo','*Ivioln',
'instrument.strings.violoncello','*Icello',
'instrument.strings.violoncello.solo','*Icello',
'instrument.unpitched.drums.cymbal','*Ipiatt',
'instrument.unpitched.drums.table','*Itabla',
'instrument.unpitched.drums.tom-toms','*Itom',
'instrument.unpitched.drums.tom-toms.4lines','*Itom',
'instrument.unpitched.gong.large.1line','*Igong',
'instrument.unpitched.gong.medium.1line','*Igong',
'instrument.unpitched.tambourine','*Itambn',
'instrument.unpitched.triangle','*Itrngl',
'instrument.wind.bassoon','*Ifagot',
'instrument.wind.bassoon.quart','*Ifag_c',
'instrument.wind.clarinet.a','*Iclars',
'instrument.wind.clarinet.aflat','*Iclars',
'instrument.wind.clarinet.alto.eflat','*Iclara',
'instrument.wind.clarinet.alto.eflat.bassclef','*Iclara',
'instrument.wind.clarinet.bass.bflat','*Iclarb',
'instrument.wind.clarinet.bass.bflat.8vb-score','*Iclarb',
'instrument.wind.clarinet.bass.bflat.bassclef','*Iclarb',
'instrument.wind.clarinet.bflat','*Iclars',
'instrument.wind.clarinet.c','*Iclars',
'instrument.wind.clarinet.d','*Iclars',
'instrument.wind.clarinet.eflat','*Iclars',
'instrument.wind.clarinet.g','*Iclars',
'instrument.wind.coranglais','*Icangl',
'instrument.wind.englishhorn','*Icangl',
'instrument.wind.flute','*Iflt',
'instrument.wind.flute.alto','*Iflt_a',
'instrument.wind.flute.bansuri','*Ibansu',
'instrument.wind.flute.bass','*Iflt_b',
'instrument.wind.flute.eflat','*Iflt',
'instrument.wind.flute.g','*Iflt',
'instrument.wind.harmonica','*Iarmon',
'instrument.wind.oboe','*Ioboe',
'instrument.wind.oboe.baritone','*Ioboe',
'instrument.wind.oboe.bass','*Ioboe',
'instrument.wind.oboe.damore','*IoboeD',
'instrument.wind.ocarina','*Iocari',
'instrument.wind.piccolo','*Ipicco',
'instrument.wind.piccolo.dflat','*Ipicco',
'instrument.wind.recorder.alto','*Ifltda',
'instrument.wind.recorder.bass','*Ifltdb',
'instrument.wind.recorder.sopranino','*Ifltdn',
'instrument.wind.recorder.soprano','*Ifltds',
'instrument.wind.recorder.tenor','*Ifltdt',
'instrument.wind.saxophone.alto','*Ifltda',
'instrument.wind.saxophone.baritone','*IsaxR',
'instrument.wind.saxophone.baritone.8vb-score','*IsaxR',
'instrument.wind.saxophone.baritone.bassclef','*IsaxR',
'instrument.wind.saxophone.bass','*IsaxB',
'instrument.wind.saxophone.bass.15mb-score','*IsaxB',
'instrument.wind.saxophone.bass.bassclef','*IsaxB',
'instrument.wind.saxophone.contrabass','*IsaxC',
'instrument.wind.saxophone.contrabass.15mb-score','*IsaxC',
'instrument.wind.saxophone.contrabass.bassclef','*IsaxC',
'instrument.wind.saxophone.sopranino','*IsaxN',
'instrument.wind.saxophone.soprano','*IsaxS',
'instrument.wind.saxophone.tenor','*IsaxT',
'instrument.wind.saxophone.tenor.8vb-score','*IsaxT',
'instrument.wind.saxophone.tenor.bassclef','*IsaxT',
'instrument.wind.shakuhachi','*Ishaku');

return instrumentDictionary;}"
	CreateClefDictionary "() {
clefDictionary = CreateDictionary(
'clef.alto','*clefC3',
'clef.baritone.c','*clefC5',
'clef.baritone.f','*clefF3',
'clef.bass','*clefF4',
'clef.bass.down.8','*clefFv4',
'clef.bass.up.15','*clefF^^4',
'clef.bass.up.8','*clefF^4',
'clef.percussion','*clefX',
'clef.percussion_2','*clefX',
'clef.soprano','*clefC1',
'clef.soprano.mezzo','*clefC2',
'clef.tenor','*clefC4',
'clef.tenor.down.8','*clefCv4',
'clef.treble','*clefG2',
'clef.treble.down.8','*clefGv2',
'clef.treble.down.8.bracketed','*clefGv2',
'clef.treble.down.8.old','*clefGv2',
'clef.treble.up.15','*clefG^15',
'clef.treble.up.8','*clefG^8',
'clef.violin.french','*clefG1',
'clef.sub-bass.f','*clefF5');

return clefDictionary;}"
	AppendScoreInfoToFile "(fname) {
thisScore = Sibelius.ActiveScore;

if (thisScore.Composer != '')
{
humComposer = '!!!COM: ' & thisScore.Composer;
Sibelius.AppendLineToFile(fname,humComposer);  
}

if (thisScore.ComposerDates != '')
{
humComposerDates = '!!!CDT: ' & thisScore.ComposerDates;
Sibelius.AppendLineToFile(fname,humComposerDates);  
}

if (thisScore.Lyricist != '')
{
humLyricist = '!!!LYR: ' & thisScore.Lyricist;
Sibelius.AppendLineToFile(fname,humLyricist);  
}

if (thisScore.Arranger != '')
{
humArranger = '!!!LAR: ' & thisScore.Arranger;
Sibelius.AppendLineToFile(fname,humArranger);  
}

//Here I chose to use MPN-artist for Artist
if (thisScore.Artist != '')
{
humArtist = '!!!MPN-artist: ' & thisScore.Artist;  
Sibelius.AppendLineToFile(fname,humArtist);
}

if (thisScore.Title != '')
{
humTitle = '!!!OTL: ' & thisScore.Title; 
Sibelius.AppendLineToFile(fname,humTitle); 
}

if (thisScore.Subtitle != '')
{
humSubTitle = '!!!OTL-sub: ' & thisScore.Subtitle;  
Sibelius.AppendLineToFile(fname,humSubTitle);
}

if (thisScore.OpusNumber != '')
{
humOpusNumber = '!!!OPS: ' & thisScore.OpusNumber;  
Sibelius.AppendLineToFile(fname,humOpusNumber);
}

if (thisScore.Dedication != '')
{
humDedication = '!!!ODE: ' & thisScore.Dedication;  
Sibelius.AppendLineToFile(fname,humDedication);
}

if (thisScore.OtherInformation != '')
{
humNotaBene = '!!!ONB: ' & thisScore.OtherInformation;  
Sibelius.AppendLineToFile(fname,humNotaBene);
}


if (thisScore.YearOfComposition != '')
{
humYearOfComposition = '!!!ODT: ' & thisScore.YearOfComposition;  
Sibelius.AppendLineToFile(fname,humYearOfComposition);
}

if (thisScore.Publisher != '')
{
humPublisher = '!!!YEP: ' & thisScore.Publisher;  
Sibelius.AppendLineToFile(fname,humPublisher);
}

if (thisScore.Copyright != '')
{
	if (thisScore.Copyright != 'Copyright © ')
	{
	humCopyright = '!!!YEM: ' & thisScore.Copyright;  
	Sibelius.AppendLineToFile(fname,humCopyright);
	}
}

//Here I chose to use ENC-copyist for Copyist 
if (thisScore.Copyist != '')
{
humCopyist = '!!!ENC-copyist: ' & thisScore.Copyist;  
Sibelius.AppendLineToFile(fname,humCopyist);
}

















}"
	CreateKeySignatureDictionary "() {
keySignatureDictionary = CreateDictionary(
'-7','*k[b-e-a-d-g-c-f-]',
'-6','*k[b-e-a-d-g-c-]',
'-5','*k[b-e-a-d-g-]',
'-4','*k[b-e-a-d-]',
'-3','*k[b-e-a-]',
'-2','*k[b-e-]',
'-1','*k[b-]',
'0','*k[]',
'1','*k[f#]',
'2','*k[f#c#]',
'3','*k[f#c#g#]',
'4','*k[f#c#g#d#]',
'5','*k[f#c#g#d#a#]',
'6','*k[f#c#g#d#a#e#]',
'7','*k[f#c#g#d#a#e#b#]'


);

return keySignatureDictionary;}"
	ConvertKeySignature "(keySignature,keySignatureDictionary) {
if (keySignatureDictionary[keySignature] = '')
{
return '*k??';
} else {
return keySignatureDictionary[keySignature];
}

}"
	ConvertTimeSignature "(Numerator,Denominator,Text) {


switch(Text){
case(CommonTimeString){humTimeSignature = '*M4/4'; humMeter = '*met(c)';}
case(AllaBreveTimeString){humTimeSignature = '*M2/2'; humMeter = '*met(c|)';}
default {humTimeSignature = '*M' & Numerator & '/' & Denominator; humMeter = '';}
}

timeSignatureArray = CreateSparseArray(humTimeSignature,humMeter);

return timeSignatureArray;}"
	NotePad "() {
//duration = noteRest.Duration;
duration = 6144;

dotToken = '';
switch(duration){
	case '6144' // DottedLong
	{
	duration = '4096';
	dotToken = '.';
	}
}
 Sibelius.MessageBox(duration);}"
	ConvertSpecialBarlineCode "(BarlineInternalTypeID,specialBarlineDictionary) {
if (specialBarlineDictionary[BarlineInternalTypeID] = '')
{
return '=??';
} else {
return specialBarlineDictionary[BarlineInternalTypeID];
}}"
	CreateSpecialBarlineDictionary "() {
// note. Always add '=' + currentExternalBarNumber before the result of SpecialBarlineDictionary


specialBarlineDictionary = CreateDictionary(
'0','!|:',
'1',':|!',
'2',':',
'3','||',
'4','=',  // this will become '==' once you add the == before it
'5','-',
'6','??',  // Barline between staves. Not sure if standard in Humdrum
'7','',
'8','`',
'9','\''


);

return specialBarlineDictionary;}"
	CreateTokenIfBarStartsWithStartRepeat "(BarNumber) {
// Check if the bar at BarNumber starts with a Start Repeat Special Barline
// If it does, return  '!|:'
// If it doesn't, or if bar number it out of range, return ''

thisScore = Sibelius.ActiveScore;
sysStaff = thisScore.SystemStaff;
startsWithRepeat = false;

if (BarNumber > sysStaff.BarCount)
{
startsWithRepeat = false;  // this is redundant, but i'm keeping it for sake of clarity
} else {

sblCount = 1;
// this is not elegant, but basically see if there's a start repeat in bar 1

for each SpecialBarline sbl in sysStaff.NthBar(BarNumber)
	{
		if (sblCount = 1)
		{	
			if (sbl.BarlineInternalType = SpecialBarlineStartRepeat)
			{
			startsWithRepeat = true;
			}
		}
	}

}


if (startsWithRepeat = true)
{
return '!|:';
} else {
return '';
}}"
	CreateDurationDictionary "() {
durationDictionary = CreateDictionary(
'4096','00', //Long
'6144','00.', //DottedLong
'7168','00..', //DoubleDottedLong
'7680','00...', //TripleDottedLong
'2048','0', //Breve
'3072','0.', //DottedBreve
'3584','0..', //DoubleDottedBreve
'3840','0...', //TripleDottedBreve
'1024','1', //Whole
'1536','1.', //DottedWhole
'1792','1..', //DoubleDottedWhole
'1920','1...', //TripleDottedWhole
'512','2', //Half
'768','2.', //DottedHalf
'896','2..', //DoubleDottedHalf
'960','2...', //TripleDottedHalf
'256','4', //Quarter
'384','4.', //DottedQuarter
'448','4..', //DoubleDottedQuarter
'480','4...', //TripleDottedQuarter
'128','8', //Eighth
'192','8.', //DottedEighth
'224','8..', //DoubleDottedEight
'240','8...', //TripleDottedEight
'64','16', //Sixteenth
'96','16.', //DottedSixteenth
'112','16..', //DoubleDottedSixteeth
'120','16...', //TripleDottedSixteeth
'32','32', //ThirtySecond
'48','32.', //DottedThirtySecond
'56','32..', //DoubleDottedThirtySecond
'60','32...', //TripleDottedThirtySecond
'16','64', //SixtyFourth
'24','64.', //DottedSixtyFourth
'28','64..', //DoubleDottedSixtyFourth
'30','64...', //TripleDottedSixtyFourth
'8','128', //OneHundredTwentyEighth
'12','128.', //DottedOneHundredTwentyEighth
'14','128..', //DoubleDottedHundredTwentyEighth
'4','256', //TwoHundredFiftySixth
'6','256.' //DottedTwoHundredFiftySixth
);

return durationDictionary;}"
	ConvertDuration "(noteRest,durationDictionary) {
/* this is only for non tuplet conversion */

duration = noteRest.Duration;

if (noteRest.ParentTupletIfAny = null) // if not part of tuplet
{	
	if (durationDictionary[duration] = '')
	{
		return '??';
	} else {
		return durationDictionary[duration];
	}
} else {

		parentTuplet = noteRest.ParentTupletIfAny;
		divideByUnit = parentTuplet.PlayedDuration/parentTuplet.Unit;

		splitDurationAndDotsArray = SplitDurationAndDots(noteRest);
		duration = splitDurationAndDotsArray[0];
		dotToken = splitDurationAndDotsArray[1];

		tupletDrillDown = parentTuplet.PlayedDuration/duration/divideByUnit;
		parentTupletDividedByLeft = parentTuplet.PlayedDuration/parentTuplet.Left;

		if(IsTerminating(parentTuplet.Left,parentTuplet.Right)) // if possible to write tuplet without **recipe
		{
			humTupletNoteDuration = 256*4/parentTupletDividedByLeft*tupletDrillDown;
		} else {
		
			makeFractionArray = utils.MakeFraction(parentTupletDividedByLeft/tupletDrillDown,1024);
			humTupletNoteDuration = makeFractionArray[1] & '%' & makeFractionArray[0];
		}
humTupletNoteDuration = humTupletNoteDuration & dotToken;
return humTupletNoteDuration;

}
	
}"
	NoteRestAtBarPosVoice "(barCur, position, voice) {
/* This is almost exactly the same as utils.NoteRestWithNotesAtBarPosVoice, but it also returns NoteRest with NoteCount = 0, and ignores nr if GraceNote = true

All comments below are from utils.NoteRestWithNotesAtBarPosVoice */

// useful when adding notes to see if there is an nr with notes at the same location
// if so, the note will be added to that NR rather than starting a new one.
// this can let you decide to delete the nr
// returns the nr at that position if there is one, otherwise null

// ASSUMPTION: for each NoteRest nr in bar returns all notes in position order, so if we encounter an nr whose position is
// greater than the desired position we will not find a match, and it is safe to return null

for each NoteRest nr in barCur
{
	if (nr.NoteCount >= 0)
	{
		if (nr.VoiceNumber = voice)
		{
			if  (nr.Position = position)
			{
				if (nr.GraceNote = false)		// only return nr if NOT a grace note
				{
				return nr;	
				}
			}
		}
	}

	if (nr.Position > position)
	{
		return null;
	}
}

return null;}"
	ResetWholeBarRestTracker "() {
thisScore = Sibelius.ActiveScore;

wholeBarRestTrackerArray = CreateSparseArray();

x=1;
for each s in thisScore
{
wholeBarRestTrackerArray[x] = false;
x=x+1;
}

return wholeBarRestTrackerArray;}"
	CreatePitchDictionary "() {
pitchDictionary = CreateDictionary(

// Not sure how low / high Sib can go. Let's assume this is enough for now.

'1','DDDDD',
'2','EEEEE',
'3','FFFFF',
'4','GGGGG',
'5','AAAAA',
'6','BBBBB',
'7','CCCC', //C0
'8','DDDD',
'9','EEEE',
'10','FFFF',
'11','GGGG',
'12','AAAA',
'13','BBBB',
'14','CCC', //C1
'15','DDD',
'16','EEE',
'17','FFF',
'18','GGG',
'19','AAA',
'20','BBB',
'21','CC', //C2
'22','DD',
'23','EE',
'24','FF',
'25','GG',
'26','AA',
'27','BB',
'28','C', //C3
'29','D',
'30','E',
'31','F',
'32','G',
'33','A',
'34','B',
'35','c', //C4, middle C
'36','d',
'37','e',
'38','f',
'39','g',
'40','a',
'41','b',
'42','cc', //C5
'43','dd',
'44','ee',
'45','ff',
'46','gg',
'47','aa',
'48','bb',
'49','ccc', //C6
'50','ddd',
'51','eee',
'52','fff',
'53','ggg',
'54','aaa',
'55','bbb',
'56','cccc', //C7
'57','dddd',
'58','eeee',
'59','ffff',
'60','gggg',
'61','aaaa',
'62','bbbb',
'63','cccc', //C8
'64','dddd',
'65','eeee',
'66','ffff',
'67','gggg',
'68','aaaa',
'69','bbbb',
'70','ccccc', //C9
'71','ddddd',
'72','eeeee',
'73','fffff',
'74','ggggg',
'75','aaaaa',
'76','bbbbb',
'77','cccccc', //C10
'78','dddddd',
'79','eeeeee',
'80','ffffff',
'81','gggggg',
'82','aaaaaa',
'83','bbbbbb',
'84','ccccccc' //C11

);

return pitchDictionary;}"
	ConvertPitch "(note,pitchDictionary) {
/* Convert Sib DiatonicPitch to Humdrum format using the dictionary created with CreatePitchDictionary() ;  */

diatonicPitch = note.DiatonicPitch;
accidental = note.Accidental;
isAccidentalVisible = note.IsAccidentalVisible;

if (pitchDictionary[diatonicPitch] = '')
{
return '??';
} else {
humPitch = pitchDictionary[diatonicPitch];
}

humAccidental = '';
if (accidental = 0)
{
	if (isAccidentalVisible = true )
	{ 
	humAccidental = 'n' ; // only add natural if visible
	}
} else {
	if (accidental = -2)
	{
	humAccidental = '--';
	} else {
		if (accidental = -1)
		{
		humAccidental = '-';
		} else {
			if (accidental = 1)
			{
			humAccidental = '#';
			} else {
				if (accidental = 2)
				{
				humAccidental = '##';
				}
			}	
		}
	}
}
humToken = humPitch & humAccidental;
return humToken;}"
	CreateArticulationDictionary "() {
articulationDictionary = CreateDictionary(
'0','I', // Custom1Artic. I'm assigning this to generic articulation (unspecified articulation) in humdrum, which is I
'1','\'', // StaccatoArtic
'2','`', // StaccatissimoArtic
'3','`', // WedgeArtic. I believe there is no distinction between 2 and 3 in Humdrum.
'4','~', // TenutoArtic. 
'5','^', // AccentArtic
'6','^^',	// MarcatoArtic
'7','o', // HarmonicArtic  !!!RDF**kern: o = harmonic/open
'8','O',	// PlusArtic.  !!!RDF**kern: O = plus/closed 
'9','v', //UpBowArtic
'10','u', // DownBowArtic
'11','I', // Custom2Artic. I'm assigning this to generic articulation (unspecified articulation) in humdrum, which is I
'12',';', // SquarePauseArtic. I'm assigning every type of fermata to ;
'13',';', // PauseArtic. I'm assigning every type of fermata to ;
'14',';', // TriPauseArtic. I'm assigning every type of fermata to ;
'15','I' // Custom3Artic. I'm assigning this to generic articulation (unspecified articulation) in humdrum, which is I


);

return articulationDictionary;}"
	ConvertArticulation "(note,articulationDictionary) {
/*The + articulation is not readily acvailable in Humdrum. A general solution to unrepresented articulations is to use the !!!RDF**kern: system to assign a user signifier to mean something. Sib2hum uses

!!!RDF**kern: O = plus/closed

Note that this reference line is only added at the bottom of the output file if a plus articulation is used in the score.

As for the circle articulation, it can mean different things depending upon context. Because in humdum this signifier is usually only used for harmonic (and not, say, for unmuted brass instrument), I'm also adding this reference when a o articulation is used

!!!RDF**kern: o = harmonic/open

This last one is a bit weird, because theoretically, only user-defined signifiers can be described this way. But I think this still is a sensible solution.

*/


humArticulation = '' ;
closedArticulationReferenceNeeded = false ;
openArticulationReferenceNeeded = false ;


for x = 0 to 16 // possible articulations range from 0 to 15
{
	articulation = note.GetArticulation(x);
				if (articulation) // if articulation x exists on given note
				{
				humArticulation = humArticulation & articulationDictionary[x];
				}

	if (note.GetArticulation(7))
	{
	openArticulationReferenceNeeded = true;
	}

	if (note.GetArticulation(8))
	{	
	closedArticulationReferenceNeeded = true ;
	}

}			


articulationArray = CreateSparseArray(humArticulation,openArticulationReferenceNeeded,closedArticulationReferenceNeeded);

return articulationArray;
}"
	CreateSpinePathIndicators "(numberVoicesBefore,numberVoicesAfter) {
//Caution, the difference between numberVoicesAfter and numberVoicesBefore can only be 1 or -1

if (numberVoicesAfter - numberVoicesBefore = 1) // if we need to add a voice
{
	if(numberVoicesBefore = 1)
	{
	spinePathIndicators = '*^';
	}
	if(numberVoicesBefore = 2)
	{
	spinePathIndicators = '*\t*^';
	}
	if(numberVoicesBefore = 3)
	{
	spinePathIndicators = '*\t*\t*^';
	}
} else {
	if (numberVoicesAfter - numberVoicesBefore = -1)  // if we need to remove a voice
	{
		if(numberVoicesBefore = 4)
		{
		spinePathIndicators = '*\t*\t*v\t*v';
		}
		if(numberVoicesBefore = 3)
		{
		spinePathIndicators = '*\t*v\t*v';
		}
		if(numberVoicesBefore = 2)
		{
		spinePathIndicators = '*v\t*v';
		}
	}	
}

return spinePathIndicators;}"
	IsTerminating "(numerator, denominator) {
//assumes that the fraction is already fully reduced
//e.g. numerator and denominator are coprime

   while (denominator % 2 = 0)
        {
		denominator = denominator / 2;
		}
   while (denominator % 5 = 0)
		{
        denominator = denominator / 5;
		}
    if (denominator = 1)
	{ 
		return true;
	} else {
		return false;
	}}"
	ConvertTupletDuration "(IsTerminating) {
}"
	SplitDurationAndDots "(noteRest) {
duration = noteRest.Duration;
splitDurationAndDotsArray = CreateSparseArray();
		dotToken = '';
		switch(duration){
			case '6144' // DottedLong
			{
			duration = '4096';
			dotToken = '.';
			}
			case '7168' // DoubleDottedLong
			{
			duration = '4096';
			dotToken = '..';
			}
			case '7680' // TripleDottedLong
			{
			duration = '4096';
			dotToken = '...';
			}
			case '3072' // DottedBreve
			{
			duration = '2048';
			dotToken = '.';
			}
			case '3584' // DoubleDottedBreve
			{
			duration = '2048';
			dotToken = '..';
			}	
			case '3840' // TripleDottedBreve
			{
			duration = '2048';
			dotToken = '...';
			}	
			case '1536' // DottedWhole
			{
			duration = '1024';
			dotToken = '.';
			}
			case '1792' // DoubleDottedWhole
			{
			duration = '1024';
			dotToken = '..';
			}
			case '1920' // TripleDottedWhole
			{
			duration = '1024';
			dotToken = '...';
			}
			case '768' // DottedHalf
			{
			duration = '512';
			dotToken = '.';
			}
			case '896' // DoubleDottedHalf
			{
			duration = '512';
			dotToken = '..';
			}	
			case '960' // TripleDottedHalf
			{
			duration = '512';
			dotToken = '...';
			}
			case '384' // DottedQuarter
			{
			duration = '256';
			dotToken = '.';
			}	
			case '448' // DoubleDottedQuarter
			{
			duration = '256';
			dotToken = '..';
			}
			case '480' // TripleDottedQuarter
			{
			duration = '256';
			dotToken = '...';
			}
			case '192' // DottedEighth
			{
			duration = '128';
			dotToken = '.';
			}
			case '224' // DoubleDottedEight
			{
			duration = '128';
			dotToken = '..';
			}	
			case '240' // TripleDottedEight
			{
			duration = '128';
			dotToken = '...';
			}		
			case '96' // DottedSixteenth
			{
			duration = '64';
			dotToken = '.';
			}	
			case '112' // DoubleDottedSixteeth
			{
			duration = '64';
			dotToken = '..';
			}	
			case '120' // TripleDottedSixteeth
			{
			duration = '64';
			dotToken = '...';
			}	
			case '48' // DottedThirtySecond
			{
			duration = '32';
			dotToken = '.';
			}
			case '56' // DoubleDottedThirtySecond
			{
			duration = '32';
			dotToken = '..';
			}
			case '60' // TripleDottedThirtySecond
			{
			duration = '32';
			dotToken = '...';
			}
			case '24' // DottedSixtyFourth
			{
			duration = '16';
			dotToken = '.';
			}
			case '28' // DoubleDottedSixtyFourth
			{
			duration = '16';
			dotToken = '..';
			}	
			case '30' // TripleDottedSixtyFourth
			{
			duration = '16';
			dotToken = '...';
			}
			case '12' // DottedOneHundredTwentyEighth
			{
			duration = '8';
			dotToken = '.';
			}
			case '14' // DoubleDottedHundredTwentyEighth
			{
			duration = '8';
			dotToken = '..';
			}	
			case '6' // DottedTwoHundredFiftySixth
			{
			duration = '4';
			dotToken = '.';
			}			
		}

splitDurationAndDotsArray[0] = duration;
splitDurationAndDotsArray[1] = dotToken;

return splitDurationAndDotsArray;


}"
}