Dolet8.plg


{
	Initialize "() {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// If you see are seeing this, you are probably
// trying to run the Dolet 8 for Sibelius plug-in
// on an older version of Sibelius. This plug-in
// requires Sibelius 5.1 or later. You may use the 
// Dolet 1 plug-in with Sibelius 2.1, Sibelius 3.1,
// and Sibelius 4 to export MusicXML 1.0 files.

// Check for Sibelius 5 because LocalizeData depends
// on Sibelius 5 functions. During Run, we will check
// for Sibelius 2019.5 so we can display a message box
// instead of just disappearing from the menu.

if (Sibelius.ProgramVersion >= 5000) {
	// Localize first to get correct plug-in menu name
	LocalizeData();
	AddToPluginsMenu(_PluginMenuName, 'Run');
}
}"
	Run "() {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// The top level method for the MusicXML exporter.

// Sibelius 2019.5 is the minimum version for the
// Dolet 8 for Sibelius plug-in.
if (Sibelius.ProgramVersion < 19500) {
	Sibelius.MessageBox(_SibVersionTooEarly);
	return False;
}

if (Sibelius.ScoreCount = 0)
{
	Sibelius.MessageBox(_NoScore);
	return False;
}

oMyScore = Sibelius.ActiveScore;

// Use Sibelius standard features to select the file
// name, versus the custom stuff we had in earlier versions.

oTempFile = Sibelius.GetFile(oMyScore.FileName);
sPathName = oTempFile.Path;
sFileName = oTempFile.NameNoPath;

oFile = Sibelius.SelectFileToSave(_PluginMenuName, sFileName, sPathName, 
								  'musicxml', 'MUSICXML', 'MusicXML File');
fOK = False;
if (oFile != null) {
	// @todo On Windows (at least), the file data returned
	// will be corrupted if you try to save the XML in a parent
	// directory, and the file name is shorter than the parent
	// directory name. Other scenarios may also cause this 
	// same problem. For now we are waiting for a Sibelius fix.
	
	FileName = '' & oFile.NameWithExt;
	if (Length(FileName) > 0) {
		fOK = True;
	}
}

if (fOK) {
	fOK = ExportXML();
	return fOK;
} else {
	return False;
}
}"
	FileName
	InitializeXML "(ThisScore) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

sData = '<?xml version=\'1.0\' encoding=\'UTF-16\' standalone=\'no\'?>';
WriteXML(sData, 0);
sData = '<!DOCTYPE score-partwise PUBLIC';

// We are using MusicXML 4.0 features now.
sData = sData & ' \'-//Recordare//DTD MusicXML 4.0 Partwise//EN\'';
sData = sData & ' \'http://www.musicxml.org/dtds/partwise.dtd\'>';
WriteXML(sData, 0);
WriteXML('<score-partwise version=\'4.0\'>', 0);

// Global fields have already done the ToXmlText conversion,
// so do not do it again here.

// Put Sibelius title in movement-title. Take the printed text
// over the score info for metadata; it is more likely to be accurate.

if (Length(Title) = 0) {
	Title = ToXmlText(ConvertFormattedText(ThisScore.Title));
}
if (Length(Title) > 0) {
	WriteXML('<movement-title>' & Title & '</movement-title>', 1);
}

WriteXML('<identification>', 1);

if (Length(Composer) = 0) {
	Composer = ToXmlText(ConvertFormattedText(ThisScore.Composer));
}
if (Length(Composer) > 0){
	sData = '<creator type=\'composer\'>' & Composer & '</creator>';
	WriteXML(sData, 2);
}

if (Length(Lyricist) = 0) {
	Lyricist = ToXmlText(ConvertFormattedText(ThisScore.Lyricist));
}
if (Length(Lyricist) > 0){
	sData = '<creator type=\'lyricist\'>' & Lyricist & '</creator>';
	WriteXML(sData, 2);
}

sArranger = ToXmlText(ConvertFormattedText(ThisScore.Arranger));
if (Length(sArranger) > 0){
	sData = '<creator type=\'arranger\'>' & sArranger & '</creator>';
	WriteXML(sData, 2);
}

sArtist = ToXmlText(ConvertFormattedText(ThisScore.Artist));
if (Length(sArtist) > 0){
	sData = '<creator type=\'artist\'>' & sArtist & '</creator>';
	WriteXML(sData, 2);
}

if (Length(Copyright) = 0) {
	Copyright = ToXmlText(ConvertFormattedText(ThisScore.Copyright));
}
if (Length(Copyright) > 0){
	sData = '<rights>' & Copyright & '</rights>';
	WriteXML(sData, 2);
}

// We always have an encoding to write out.
WriteXML('<encoding>', 2);
sData = '<software>' & VersionString() & '</software>';
WriteXML(sData, 3);
WriteXML('<software>Dolet 8.3 for Sibelius</software>', 3);

oDate = Sibelius.CurrentDate;
sIsoDate = IsoDate(oDate);
WriteXML('<encoding-date>' & sIsoDate & '</encoding-date>', 3);

// Indicate that some features are or are not supported.
// For accidentals, support was added in Sibelius 7.1.3.
WriteXML('<supports element=\'accidental\' type=\'yes\'/>', 3);
WriteXML('<supports element=\'transpose\' type=\'yes\'/>', 3);

// Starting in Sibelius 6, we can export all the system breaks
// and page breaks whether or not the layout if locked.
WriteXML('<supports attribute=\'new-page\' element=\'print\'' & 
		 ' type=\'yes\' value=\'yes\'/>', 3);
WriteXML('<supports attribute=\'new-system\' element=\'print\'' & 
		 ' type=\'yes\' value=\'yes\'/>', 3);
WriteXML('</encoding>', 2);

// Finish the identification
WriteXML('</identification>', 1);

// Now write out the defaults for scaling and page layout.
InitializeDefaults(ThisScore);

// Now handle the credits from page-aligned system text items.
InitializeCredits();

// And we are done here. The part-list is next.
}"
	InitializeParts "(ThisScore) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

sLastInstrument = '';
nInstruments = 0;
nStaves = 0;	// Staves left in current instrument

// Sibelius 6.1 lets us know if full, short, or no names are printed
// on first system, subsequent systems, and starts of sections. For
// now we just check for no names and ignore starts of sections.
sPrintObjectName = '';
sPrintObjectAbbr = '';

// Sibelius 6.1 also lets us access brackets and barlines, used to
// create MusicXML part-group elements. InitializeGroups returns
// a Sibelius 6 sparse array of dictionary objects, each dictionary
// corresponding to a part-group.
oGroups = null;
oHasPartGroupStart = null;
oHasPartGroupStop = null;
oGroupNumber = null;

oRules = ThisScore.EngravingRules;
if (oRules.InstrumentNamesFirstSystem = InstrumentNamesNone) {
	sPrintObjectName = ' print-object=\'no\'';
}
if (oRules.InstrumentNamesSubsequentSystems = InstrumentNamesNone) {
	sPrintObjectAbbr = ' print-object=\'no\'';
}
oGroups = InitializeGroups(ThisScore);
oHasPartGroupStart = CreateSparseArray();
oHasPartGroupStop = CreateSparseArray();
oGroupNumber = CreateSparseArray();
for i = 0 to ThisScore.StaffCount {
	oHasPartGroupStart[i] = False;
	oHasPartGroupStop[i] = False;
	oGroupNumber[i] = -1;
}
for each oGroup in oGroups {
	oHasPartGroupStart[oGroup.TopStaff] = True;
	oHasPartGroupStop[oGroup.BottomStaff] = True;
}

WriteXML('<part-list>', 1);
for each oStaff in ThisScore {
	if (oStaff.Type = 'Stave') {
		if (nStaves = 0) {
			nInstruments = nInstruments + 1;
			
			// Check for part-group starts
			for i = 0 to oStaff.NumStavesInSameInstrument {
				if (oHasPartGroupStart[oStaff.StaffNum + i]) {
					nGroupIndex = 0;
					for each oGroup in oGroups {
						if ((oStaff.StaffNum + i) = oGroup.TopStaff) {
							fNoGroupNum = True;
							nGroup = 1;
							while (fNoGroupNum and (nGroup <= ThisScore.StaffCount)) {
								if (oGroupNumber[nGroup] < 0) {
									oGroupNumber[nGroup] = nGroupIndex;
									// We now have everything we need to write this group.
									// There can be multiple groups per part.
									WritePartGroup(oGroup, nGroup, 'start');
									fNoGroupNum = False;
								}
								nGroup = nGroup + 1;	
							}	
						}
						nGroupIndex = nGroupIndex + 1;
					}
				}
			}

			WriteXML('<score-part id=\'P' & nInstruments & '\'>', 2);
			WritePartNameAndAbbr(oStaff, sPrintObjectName, sPrintObjectAbbr);

			// By default, this part does not end a group.
			PartEndGroup[nInstruments] = 0;
			
			// Is this a part or a score?
			sGroup = 'score';
			if (ThisScore.IsDynamicPart) {
				sGroup = 'parts';
			}
			WriteXML('<group>' & sGroup & '</group>', 3);

			// Now set up the score instrument with as much information as we can.
			InitializeScoreInstruments(ThisScore, oStaff, nInstruments);		  

			WriteXML('</score-part>', 2);

			// Check for part-group stops
			for i = 0 to oStaff.NumStavesInSameInstrument {
				if (oHasPartGroupStop[oStaff.StaffNum + i]) {
					nGroupIndex = 0;
					for each oGroup in oGroups {
						if ((oStaff.StaffNum + i) = oGroup.BottomStaff) {
							fNoGroupNum = True;
							nGroup = 1;
							while (fNoGroupNum and (nGroup <= ThisScore.StaffCount)) {
								if (oGroupNumber[nGroup] = nGroupIndex) {
									// We now have everything we need to write this group.
									// There can be multiple groups per part.
									WritePartGroup(oGroup, nGroup, 'stop');
									fNoGroupNum = False;
									oGroupNumber[nGroup] = -1;
									// Save away that this part ends a group, as that
									// affects additional spacing below the part.
									// Cannot use booleans in array, so use integers.
									PartEndGroup[nInstruments] = 1;
								}
								nGroup = nGroup + 1;	
							}	
						}
						nGroupIndex = nGroupIndex + 1;
					}
				}
			}

			nStaves = oStaff.NumStavesInSameInstrument - 1;
		} else {
			nStaves = nStaves - 1;
		}
	}
}
WriteXML('</part-list>', 1);
}"
	FinalizeXML "() {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

WriteXML('</score-partwise>', 0);
fOK = Sibelius.AppendTextFile(FileName, XmlText, True);
if (not fOK) {
	trace('Error writing \'</score-partwise>\' to line ' & XmlLineNumber & 
		  '. Your MusicXML file may be invalid.');
}
}"
	WriteXML "(XMLString, Tabs) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

sTabs = '';

// Watch out for idiosyncratic for syntax (stops before last value)
if (Tabs > 0) {
	for i = 0 to Tabs {
		sTabs = sTabs & '	';
	}
}

// Buffer our writes to make things faster.
XmlText = XmlText & sTabs & XMLString & XmlCrLf;
XmlLineNumber = XmlLineNumber + 1;

// It is possible for the append to fail. This seems to
// happen when there is a lot of memory use or in unusual
// disk conditions. We used to retry up to 10 times to 
// write the line, but now the next line will do the retry
// since we do not reset the buffer if we fail.
if (Length(XmlText) > XmlTextBufferSize) {
	fOK = Sibelius.AppendTextFile(FileName, XmlText, True);
	if (fOK) {
		XmlText = '';
		return True;
	} else {
		// If the append failed, send a message to the trace window
		// and return False. We want the intended line number in the
		// error message, which is why we increment it before appending.

		// Note that Sibelius has confirmed that there is a bug in
		// AppendLineToFile causing these errors, and that there is
		// no available workaround for our plug-in. Retrying and
		// reporting is the best we can do. We do not know if the
		// bug is also present in AppendTextFile or if it may have
		// been fixed in later Sibelius releases.
		// @todo Internationalize this message
		trace('Error writing \'' & XMLString & '\' to line ' & XmlLineNumber & 
			  '. Your MusicXML file may be invalid.');
		return False;
	}
}
return True;
}"
	WriteStaff "(ThisScore, MyStaff, StaffNumber, PartNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

if (ShowTrace) {
	trace('Writing part P' & PartNumber);
}

// Write a comment separator before the first part
if (PartNumber = 1) {
		WriteXML('<!--=========================================================-->', 0);
}

Staves = 0 + MyStaff.NumStavesInSameInstrument;
nBars = MyStaff.BarCount;
WriteXML('<part id=\'P' & PartNumber & '\'>', 1);

nHighStaff = StaffNumber + Staves;

// Reset clefs
TabClef = -1;
PercussionClef = -1;
PercStaffLines = 5;

// Reset transpose data
LastTransposeChromatic = 0;
LastTransposeDiatonic = 0;
LastTransposeOctaveChange = 0;
TransposeChromatic = 0;
TransposeDiatonic = 0;
TransposeOctaveChange = 0;
TransposePartClefStyleId = '';
WrittenDiatonicPitchOK = True;

// Reset key data
LastKeyFifths = 0;
LastKeyMode = '';
KeyFifths = 0;
KeyMode = '';

// Reset per-staff arrays
CurrentPartInstrument[0] = '';
for i = 1 to Staves + 1 {
	HiddenStaff[i] = False;
	StaffDetailsPrintObject[i] = '';
	StaffLines[i] = 5;
	LastMeasureRepeat[i] = 0;
	MeasureRepeatStopBars[i] = 0;
	LastClefSign[i] = '';
	LastClefLine[i] = 0;
	LastClefOctaveChange[i] = 0;
	LastClefBar[i] = 0;
	LastClefPosition[i] = 0;
	CurrentPartInstrument[i] = '';
}

// Reset per-voice arrays
PreviousEntryDuration[0] = 0;
PreviousEntryBeam[0] = NoBeam;
PreviousPrimaryBeamOnly[0] = False;
PreviousGraceEntryDuration[0] = 0;
PreviousGraceEntryBeam[0] = NoBeam;
PreviousGracePrimaryBeamOnly[0] = False;
nMaxVoice = (Staves * 4) + 1;
for i = 1 to nMaxVoice {
	ArpeggioBars[i] = 0;
	ArpeggioPositions[i] = 0;
	DoubleTremolos[i] = 0;
	TremoloType[i] = '';
	NonArpeggiateBars[i] = 0;
	NonArpeggiatePositions[i] = 0;
	PreviousEntryDuration[i] = 0;
	PreviousEntryBeam[i] = NoBeam;
	PreviousPrimaryBeamOnly[i] = False;
	PreviousGraceEntryDuration[i] = 0;
	PreviousGraceEntryBeam[i] = NoBeam;
	PreviousGracePrimaryBeamOnly[i] = False;
	SlideStop[i] = 0;
	VerseMax[i] = 0;
	AnyVisibleLyric[i] = False;
	Verse1Text[i] = '';
	Verse2Text[i] = '';
	Verse3Text[i] = '';
	Verse4Text[i] = '';
	Verse5Text[i] = '';
	ChorusText[i] = '';
	AboveText[i] = '';
	Verse1PrevType[i] = EndOfWord;
	Verse2PrevType[i] = EndOfWord;
	Verse3PrevType[i] = EndOfWord;
	Verse4PrevType[i] = EndOfWord;
	Verse5PrevType[i] = EndOfWord;
	ChorusPrevType[i] = EndOfWord;
	AbovePrevType[i] = EndOfWord;
}

// Reset 16-element slur and direction arrays.
for i = 1 to 17 {
	SlurStopBars[i] = 0;
	BracketStopBars[i] = 0;
	DashesStopBars[i] = 0;
	OctaveStopBars[i] = 0;
	WedgeStopBars[i] = 0;
	GlissandoStopBars[i] = 0;
	TrillStopBars[i] = 0;
	TrillStopDx[i] = 0;
	SlideNumbers[i] = 0;
}
PedalStopBar = 0;
BracketStops = 0;
DashesStops = 0;
OctaveStops = 0;
WedgeStops = 0;
PedalStops = 0;
DirectionStops = 0;
SlurCounts = 0;
GlissandoCounts = 0;
TrillCounts = 0;	

// Rest tie pitch arrays
for i = 0 to 128 {
	TieStopNextBar[i] = 0;
	TieStopThisBar[i] = 0;
	TieStartVoice[i] = 0;
}

// Loop through each bar. Watch out for
// idiosyncratic for syntax.
for i = 1 to nBars + 1 {
	BarCounter = i;
	nOldBreakType = MiddleOfPage;
	oBarRef = ThisScore.NthStaff(StaffNumber).NthBar(i);
	if (i > 1) {
		oBarRef = oStaff.NthBar(i - 1);
	}
	InitializeMeasure(ThisScore, i, StaffNumber, oBarRef);

	fCouldBeFirstSystemStaff = False;
	if (not SystemStaffDone[i]) {
		fCouldBeFirstSystemStaff = True;
	}
	for j = StaffNumber to nHighStaff {
		oStaff = ThisScore.NthStaff(j);
		oBar = oStaff.NthBar(i);
		nStaff = j - StaffNumber + 1;
		if (Staves = 1) {
			WriteMeasure(ThisScore, oBar, i, 0, PartNumber);
		} else {
			WriteMeasure(ThisScore, oBar, i, nStaff, PartNumber);
		}
	}	

	// In order to get endings to appear on the first system
	// staff, temporarily tweak the global so it looks like
	// we are not done yet.
	if (fCouldBeFirstSystemStaff and SystemStaffDone[i]) {
		SystemStaffDone[i] = False;
		FinalizeMeasure(ThisScore, i, StaffNumber);
		SystemStaffDone[i] = True;
	} else {
		FinalizeMeasure(ThisScore, i, StaffNumber);
	}
	ProgressCurrent = ProgressCurrent + Staves;

	// Localized progress dialog. Tradeoff between export speed and feedback.
	if ((i % 20) = 1) {
		sProgressPart = '' & PartNumber;
		sProgressBar = '' & i;
		sProgress = FormatMessage2(_Progress, '&', sProgressPart, sProgressBar);
		UserContinue = 
			Sibelius.UpdateProgressDialog(ProgressCurrent, sProgress);
		// If the user cancelled, close off this part and stop.
		if (UserContinue = False) {
			WriteXML('</part>', 1);
			return Staves;
		}
	}
}

WriteXML('</part>', 1);

// Write a comment separator after each part
WriteXML('<!--=========================================================-->', 0);

return Staves;
}"
	InitializeMeasure "(ThisScore, MeasureNumber, StaffNumber, BarRef) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

oStaff = ThisScore.NthStaff(StaffNumber);
oSystemStaff = ThisScore.SystemStaff;

nMeasureNumber = 0 + MeasureNumber;
oBar = oStaff.NthBar(nMeasureNumber);

nMaxVoice = (Staves * 4) + 1;
for i = 0 to nMaxVoice {
	PreviousEntryDuration[i] = 0;
	PreviousEntryBeam[i] = NoBeam;
	PreviousPrimaryBeamOnly[i] = False;
	PreviousGraceEntryDuration[i] = 0;
	PreviousGraceEntryBeam[i] = NoBeam;
	PreviousGracePrimaryBeamOnly[i] = False;
	LastTupletPosition[i] = -1;
}

// Check the hidden staff settings now for when we
// write staff-details elements later.
SetStaffDetailsPrintObject(ThisScore, MeasureNumber, StaffNumber);

// If this is not the first measure, put a comment
// separator before it for easier reading of the
// resulting MusicXML file.
if (nMeasureNumber > 1) {
	WriteXML('<!--=========================================================-->', 0);
}

// Use measure numbers and implicit values that were
// initialized earlier.
sMeasureNumber = '' & MeasureNumbers[MeasureNumber];
sImplicit = '' & MeasureImplicit[MeasureNumber];
sMeasureText = '' & MeasureTexts[MeasureNumber];
nMultiRest = MultiRest[MeasureNumber];
if (Length(sImplicit) > 0) {
	sData = '<measure number=\'' & sMeasureNumber & '\' implicit=\'' & sImplicit & '\'>';
} else {
	if (sMeasureNumber = sMeasureText) {
		sData = '<measure number=\'' & sMeasureNumber & '\'>';
	} else {
		sData = '<measure number=\'' & sMeasureNumber & '\' text=\'' & sMeasureText & '\'>';
	}
}
WriteXML(sData, 2);

// Handle break from previous meaasure.
nBreakType = BarRef.BreakType;
nBlankPages = BarRef.NumBlankPages;
if (MeasureNumber = 1) {
	nBlankPages = BarRef.NumBlankPagesBefore;
	if (nBlankPages > 0) {
		nBreakType = SpecialPageBreak;
	} else {
		nBreakType = MiddleOfPage;
	}
}

// Get instrument type to check for tab staff etc.
// Look for the first visible, non-0 line staff, rather 
// than simply the first staff. We used to do this
// before writing attributes, but now we use the 
// instrument type to write processing instructions
// about vertical justification in the first measure.

oInstrumentType = null;	
nInstrumentTypeCategory = 0;
oTypeList = ThisScore.InstrumentTypes;

nSingleStaff = -1;
for i = 0 to Staves {
	oStaff = ThisScore.NthStaff(StaffNumber + i);
	// Loop through the list.
	oStaffInstrumentType = oStaff.InitialInstrumentType;
	
	// See if this staff is visible. Do this here to make
	// it easier to limit this check to Sibelius 6 only.
	fVisible = True;
	if (HiddenStaff[i + 1]) {
		fVisible = False;
	}
	if (i = 0) {
		oInstrumentType = oStaffInstrumentType;
		if ((oInstrumentType.NumStaveLines > 0) and fVisible) {
			nSingleStaff = 0;
		}
	} else {
		if (nSingleStaff < 0) {
			if ((oStaffInstrumentType.NumStaveLines > 0) and fVisible) {
				nSingleStaff = i;
				oInstrumentType = oStaffInstrumentType;
			}
		}
	}
}
if (nSingleStaff < 0) {
	nSingleStaff = 0;
}
oStaff = ThisScore.NthStaff(StaffNumber + nSingleStaff);
nInstrumentTypeCategory = oInstrumentType.Category;

// Because we need to handle endings are barlines together,
// we need to do this outside of the regular system item handling.
// Do not print endings if we are not on a system staff.
// Need to do up here because we are also checking for extra
// spacing on system object staves.
fSystemStaff = CheckSystemStaff(ThisScore, MeasureNumber, StaffNumber, 1);

// If we are exporting system layout, we will change
// this to a non-empty print element.
sEnd = '/>';
fPrintSystemLayout = False;
fPrintStaffLayout = False;
fPrintMeasureLayout = False;
oSetup = null;
oRules = null;
if (nMeasureNumber = 1) {
	oSetup = ThisScore.DocumentSetup;
	oRules = ThisScore.EngravingRules;
	fSomeStaffVisible = False;
	for i = 0 to Staves {
		if (not HiddenStaff[i + 1]) {
			fSomeStaffVisible = True;
		}
	}
	if (fSomeStaffVisible) {
		if ((oSetup.FirstPageHasUniqueVerticalStaveMargins) or
			 (oRules.InstrumentNamesFirstSystem != 
			  oRules.InstrumentNamesSubsequentSystems)) {
			// As stated in MusicXML 4.0 spec, only write system-layout
			// in the part containing the first visible staff.
			if ((FirstVisibleStaffForFirstMeasure >= StaffNumber) and
				(FirstVisibleStaffForFirstMeasure < (StaffNumber + Staves))) {
				fPrintSystemLayout = True;
				sEnd = '' & '>';
			}
		}
	}
	if (oInstrumentType != null) {
		if (Staves > 1) {
			fPrintStaffLayout = True;
			sEnd = '' & '>';
		}
		if (oInstrumentType.IsVocal and 
			(oRules.ExtraSpacesBelowVocalStaves != 0)) {
			fPrintStaffLayout = True;
			sEnd = '' & '>';
		}
	}
	if (fSystemStaff and (oRules.ExtraSpacesAboveForSystemObjectPositions != 0)) {
		fPrintStaffLayout = True;
		sEnd = '' & '>';
	}
	if ((oRules.ExtraSpaceBetweenGroupsOfStaves != 0) and 
		 (PartEndGroup[PartCounter] = 1)) {
		fPrintStaffLayout = True;
		sEnd = '' & '>';
	}
}

// Check for Bar.GapBefore to see if we can write a
// measure-layout element. There is also a Bar.GapAfter
// but do not see how that can be set in the Sibelius
// GUI (last checked in 7.5). Could access it here via
// BarRef.GapAfter if needed, making sure not to double
// count on the first measure or other bars that begin a
// system.
if (oBar.GapBefore > 0) {
	fPrintMeasureLayout = True;
	sEnd = '' & '>';
}

fPrintStarted = False;
switch (nBreakType) {
	case (EndOfPage) {
		WriteXML('<print new-page=\'yes\'' & sEnd, 3);
		fPrintStarted = True;
	}
	case (EndOfSystem) {
		WriteXML('<print new-system=\'yes\'' & sEnd, 3);
		fPrintStarted = True;
	}
	case (EndOfSystemOrPage) {
		if (MeasureNewPage[MeasureNumber]) {
			WriteXML('<print new-page=\'yes\'' & sEnd, 3);
			fPrintStarted = True;
		} else {
			WriteXML('<print new-system=\'yes\'' & sEnd, 3);
			fPrintStarted = True;
		}
	}
	case (MiddleOfSystem) {
		// This lets applications import systems better with locked format.
		WriteXML('<print new-system=\'no\'' & sEnd, 3);
		fPrintStarted = True;
	}
	case (SpecialPageBreak) {
		// We can handle special page breaks that specify the 
		// number of pages, but since we do not know which 
		// page number we are on, we cannot handle the options
		// for music restarting on left or right pages, except
		// to create the page break.
		if (nBlankPages > 0) {
			WriteXML('<print new-page=\'yes\' blank-page=\'' & nBlankPages & '\'' & sEnd, 3);
			fPrintStarted = True;
		} else {
			// We should not have a special page break in bar 1
			// without blank pages first, but check just in case
			// that changes in future versions of Sibelius.
			if (MeasureNumber > 1) {
				WriteXML('<print new-page=\'yes\'' & sEnd, 3);
				fPrintStarted = True;
			}
		}
	}

	default {
		// We can tell the starts of new systems and new pages
		// without formatting being locked.
		if (MeasureNewPage[MeasureNumber]) {
			WriteXML('<print new-page=\'yes\'' & sEnd, 3);
			fPrintStarted = True;
		} else {
			if (MeasureNewSystem[MeasureNumber]) {
				WriteXML('<print new-system=\'yes\'' & sEnd, 3);
				fPrintStarted = True;
			}
		}
	}
}

// Now print the system layout if needed.
if (fPrintSystemLayout) {
	if (not fPrintStarted) {
		WriteXML('<print>', 3);
		fPrintStarted = True;
	}
	WriteXML('<system-layout>', 4);

	// If the system margins ar different, export them.
	if (oRules.InstrumentNamesFirstSystem != 
		oRules.InstrumentNamesSubsequentSystems) {
		fExportSystemMargins = True;
		nWhichLeft = 0;
		switch (oRules.InstrumentNamesFirstSystem) {
			case (InstrumentNamesFull) {
				nWhichLeft = oSetup.StaffLeftMarginFullNames;
			}
			case (InstrumentNamesShort) {
				nWhichLeft = oSetup.StaffLeftMarginShortNames;
			}
			case (InstrumentNamesNone) {
				nWhichLeft = oSetup.StaffLeftMarginNoNames;
			}
			default {
				fExportSystemMargins = False;
			}
		}
		nLeftMargin = 40.0 * nWhichLeft / ThisScore.StaffHeight;
		// Export the system layout for the first system.
		if (fExportSystemMargins) {
			WriteXML('<system-margins>', 5);
			WriteXML('<left-margin>' & nLeftMargin & '</left-margin>', 6);
			WriteXML('<right-margin>0</right-margin>', 6);
			WriteXML('</system-margins>', 5);
		}
	}

	// If the top system distance is different, export it.
	if (oSetup.FirstPageHasUniqueVerticalStaveMargins) {
		nTopSysDist = 40.0 * oSetup.AboveTopStaveGap / ThisScore.StaffHeight;
		WriteXML('<top-system-distance>' & nTopSysDist & '</top-system-distance>', 5);
	} else {
		if (InitialTopSystemDistanceAddition > 0) {
			nTopSysDist = 40.0 * oSetup.AboveTopStaveGap / ThisScore.StaffHeight;
			nTopSysDist = nTopSysDist + InitialTopSystemDistanceAddition;
			WriteXML('<top-system-distance>' & nTopSysDist & '</top-system-distance>', 5);
		}
	}

	WriteXML('</system-layout>', 4);
}

if (fPrintStaffLayout) {
	// @todo Export additional gaps for system objects, vocal staff,
	// and groups if feasible. System objects may be the one that works
	// since it is related to the current staff, not to the previous staff
	// which may or may not be visible. 

	// Currently we are not exporting system and staff spacing default
	// due to problems with using them without vertical justification 
	// values. Instead, we export processing instructions within an empty
	// staff-layout element as convenient. If we do add them to the
	// MusicXML export using elements and attributes, then the overrides
	// would go here, though the logic would get more complex.

	if (not fPrintStarted) {
		WriteXML('<print>', 3);
		fPrintStarted = True;
	}
	WriteXML('<staff-layout>', 4);
	if (Staves > 1) {
		if (oInstrumentType.HasBracket) {
			LogError('JustifyAllStaves=' & oRules.JustifyGrandStaveInstruments, 5);
		} else {
			LogError('JustifyAllStaves=' & oRules.JustifyMultiStaveInstruments, 5);
		}
	}
	if (fSystemStaff and (oRules.ExtraSpacesAboveForSystemObjectPositions != 0)) {
		LogError('ExtraSpacesAbove=' & oRules.ExtraSpacesAboveForSystemObjectPositions, 5);
	}

	// There are two different settings for extra space below. Combine them
	// here, but always print out if one of the settings is non-zero, even
	// if the two cancel out. Otherwise we could have a strange-looking
	// empty staff-layout element.
	nExtraBelow = 0;
	fPrintExtraBelow = False;
	if (oInstrumentType.IsVocal and (oRules.ExtraSpacesBelowVocalStaves != 0)) {
		fPrintExtraBelow = True;
		nExtraBelow = nExtraBelow + oRules.ExtraSpacesBelowVocalStaves;
	}
	if ((oRules.ExtraSpaceBetweenGroupsOfStaves != 0) and 
		(PartEndGroup[PartCounter] = 1)) {
		fPrintExtraBelow = True;
		nExtraBelow = nExtraBelow + oRules.ExtraSpaceBetweenGroupsOfStaves;
	}
	if (fPrintExtraBelow) {
		LogError('ExtraSpacesBelow=' & nExtraBelow, 5);
	}
	WriteXML('</staff-layout>', 4);
}

// Write measure-layout for gap before bar.
if (fPrintMeasureLayout) {
	if (not fPrintStarted) {
		WriteXML('<print>', 3);
		fPrintStarted = True;
	}
	WriteXML('<measure-layout>', 4);
	nMeasureDistance = 10.0 * oBar.GapBefore;
	WriteXML('<measure-distance>' & nMeasureDistance & '</measure-distance>', 5);
	WriteXML('</measure-layout>', 4);
}

if (fPrintSystemLayout or fPrintStaffLayout or fPrintMeasureLayout) {
	WriteXML('</print>', 3);
}

// Ending lines may be reported one measure off, so be
// sure not to overwrite something due to that.
fInitializeEndings = True;
if (RightEndingBar = MeasureNumber) {
	fInitializeEndings = False;
}
// When we check at the start of a measure, the last parameter
// indicates we want the first ending to win. This will change
// when we call InitializeBarlines from FinalizeMeasure.
InitializeBarlines(ThisScore, MeasureNumber, fInitializeEndings, True);

if (LeftEndingBar = MeasureNumber) {
	WriteSystemBarline(ThisScore, LeftBarline, LeftEnding, 'start', 'left',
					   LeftEndingColor, fSystemStaff);
	LeftEndingBumped = 0;
} else {
	if ((Length(LeftBarline) > 0) or (Length(LeftBarlineColor) > 0)) {
		WriteSystemBarline(ThisScore, LeftBarline, '', '', 'left',
						   LeftBarlineColor, fSystemStaff);
	}
}

if (MeasureNumber = 1) {
	WriteXML('<attributes>', 3);

	// Sibelius duration units are 256ths of a quarter.
	// Multiply by 3 so triplets work better.
	WriteXML('<divisions>768</divisions>', 4);

	// For now, assume key signature is same in all
	// staves of instrument. Do not write a key signature
	// on a percussion staff. Do an extra check now because
	// we want the category test to override the clef test,
	// not vice versa. Starting with 6.1, we also do not
	// write a key on a normal notation staff that disables
	// key signatures.
	oKey = oStaff.CurrentKeySignature(1);
	fNoKey = False;
	if (nInstrumentTypeCategory = 1) {
		fNoKey = True;
	} else {
		if ((nInstrumentTypeCategory = 0) and
			(not oInstrumentType.HasKeySignatureOrTuning)) {
			fNoKey = True;
		}
	}
	if (not fNoKey) {
		CheckKey(oKey, oInstrumentType);
		WriteKey(0);
	}

	// Time signature is on system staff
	oTime = oSystemStaff.CurrentTimeSignature(1);
	WriteTime(oTime, 0);

	// Instrument type of tab staff for Sibelius 5.
	nTabClef = 0 + TabClef;
	fUseStringArray = False;

	// Check for multiple instruments
	nInstruments = PartInstrumentsCount[PartCounter];

	// Sibelius 6.1 lets us check for small staves, which
	// can be represented as a cue or ossia staff-type in MusicXML.
	fSmall = CreateSparseArray();	

	if (Staves = 1) {
		if (nInstruments > 1) {
			WriteXML('<instruments>' & nInstruments & '</instruments>', 4);
		}
		WriteXML('<clef>', 4);
		sClef = oStaff.InitialClefStyleId;
		WriteClefStyle(sClef, 0, oInstrumentType, 1, 0);
		WriteXML('</clef>', 4);
		// Sibelius 5.1 has a category variable that is
		// more accurate for tab than the clef method.
		if (oInstrumentType.Category = 2) {
			TabClef = 0;	// For StaffNumber match
			TabStrings = 0 + oInstrumentType.NumStrings;
			for nThisString = 0 to TabStrings {
				StringPitch[nThisString] = oInstrumentType.PitchOfNthString(nThisString);
			}
			fUseStringArray = True;
			StaffLines[1] = 0 + TabStrings;
		} else {
			if (oInstrumentType.Category = 1) {
				PercussionClef = 0;	// For StaffNumber match
				PercStaffLines = 0 + oInstrumentType.NumStaveLines;
			}
			StaffLines[1] = 0 + oInstrumentType.NumStaveLines;
		}
		fSmall[1] = oStaff.Small;
		AssignCurrentPartInstrument(oInstrumentType.StyleId, 0);
	} else {
		// Staves attribute first.
		WriteXML('<staves>' & Staves & '</staves>', 4);

		if (nInstruments > 1) {
			WriteXML('<instruments>' & nInstruments & '</instruments>', 4);
		}
		
		// Because octave-transposing clefs are related to transpositions
		// in Sibelius, we need to check each staff first for these.
		// If we have an ossia staff in a vocal tenor clef, for instance,
		// the hidden ossia staff may have no transposition at the start
		// of the piece if a hidden instrument type is being used. Even so,
		// we want to apply the clef-octave-change across all staves if all
		// staves have the same octave-transposing clef.
		nClefOctaveChanges = 0;
		fAllSameClefStyleId = True;
		fAnyUnpitched = False;
		nInstrumentTypeIndex = -1;
		oStaffInstrumentTypes = CreateSparseArray();
		sStaffClefStyleIds = CreateSparseArray();
		nStaffClefOctaveChanges = CreateSparseArray();
		for i = 0 to Staves {
			oStaff = ThisScore.NthStaff(StaffNumber + i);
			oStaffInstrumentTypes[i] = oStaff.InitialInstrumentType;
			sStaffClefStyleIds[i] = oStaff.InitialClefStyleId;
			nChromatic = 0;
			if (oStaffInstrumentTypes[i] != null) {
				if (UseTranspose) {
					nChromatic = oStaffInstrumentTypes[i].ChromaticTransposition;
				} else {
					nChromatic = oStaffInstrumentTypes[i].ChromaticTranspositionInScore;
				}
			}

			oDictClefData = ParseClefStyleId(sStaffClefStyleIds[i], nChromatic, True);
			nStaffClefOctaveChanges[i] = oDictClefData['clef-octave-change'];
			if (nStaffClefOctaveChanges[i] != 0) {
				nClefOctaveChanges = nClefOctaveChanges + 1;
				if (nClefOctaveChanges = 1) {
					nInstrumentTypeIndex = i;
				}
			}
			if (i > 0) {
				if (sStaffClefStyleIds[i] != sStaffClefStyleIds[i - 1]) {
					fAllSameClefStyleId = False;
				}
			}
			if (oStaffInstrumentTypes[i] > 0) {
				fAnyUnpitched = True;
			}
		}
		if (fAnyUnpitched or
			(not (fAllSameClefStyleId and
				  (nClefOctaveChanges > 0) and (nClefOctaveChanges < Staves)))) {
			nInstrumentTypeIndex = -1;
		}

		for i = 0 to Staves {
			oStaff = ThisScore.NthStaff(StaffNumber + i);

			// Make sure we have the initial instrument type for each
			// staff. Need to get these again since we grabbed an initial
			// visible instrument type for multi-staff features like key
			// signature. When importing older files, it is possible that
			// the initial instruments are different on each staff, from 
			// the days of staff types vs. instrument changes.
			oInstrumentType = oStaff.InitialInstrumentType;
			if (nInstrumentTypeIndex >= 0) {
				oInstrumentType = oStaffInstrumentTypes[nInstrumentTypeIndex];
			}
			WriteXML('<clef number=\'' & (i + 1) & '\'>', 4);
			sClef = oStaff.InitialClefStyleId;
			WriteClefStyle(sClef, i + 1, oInstrumentType, 1, 0);
			WriteXML('</clef>', 4);

			if (oInstrumentType.Category = 2) {
				TabClef = 1 + i;
				TabStrings = 0 + oInstrumentType.NumStrings;
				for nThisString = 0 to TabStrings {
					StringPitch[nThisString] =
						oInstrumentType.PitchOfNthString(nThisString);
				}
				fUseStringArray = True;	
				StaffLines[i + 1] = 0 + TabStrings;			
			} else {
				if (oInstrumentType.Category = 1) {
					PercussionClef = 1 + i;
					PercStaffLines = 0 + oInstrumentType.NumStaveLines;
				}
				StaffLines[i + 1] = 0 + oInstrumentType.NumStaveLines;
			}
			fSmall[i + 1] = oStaff.Small;
			AssignCurrentPartInstrument(oInstrumentType.StyleId, i + 1);
		} 
	}
	
	// Handle staff details for tab staff, small staff, non-5 line staves,
	// and changes regarding hidden staff.
	nTabClef = 0 + TabClef;
	fStaffDetailsDone = CreateSparseArray();
	for i = 1 to Staves + 1 {
		fStaffDetailsDone[i] = False;
	}
	if ((nTabClef >= 0) and (TabStrings > 0)) {
		sDetailsNumber = '';
		nStaffCheck = 1;
		if (Staves > 1) {
			sDetailsNumber = ' number=\'' & nTabClef & '\'';
			nStaffCheck = nTabClef;
		}
		WriteXML('<staff-details' & sDetailsNumber & 
					StaffDetailsPrintObject[nTabClef] & '>', 4);
		// For small tab staves, just do not increase the
		// staff-size element. Do not export them as cues,
		// as they are often used to get a tab spacing that
		// is close to non-tab spacing.
		WriteXML('<staff-lines>' & TabStrings & '</staff-lines>', 5);

		// Add tuning information for each string. Order these in staff-line
		// order (bottom to top) vs. string order (top to bottom).
		if (fUseStringArray) {
			for nStringLine = 0 to TabStrings {
				nXmlLine = nStringLine + 1;
				WriteStaffTuning(StringPitch[nStringLine], nXmlLine);
			}
		}
		// We do not have access to the gap between staff lines, but
		// this is set to 1 1/2 spaces in all the default tab instruments.
		nStaffSize = 150;
		if (fSmall[nStaffCheck]) {
			nStaffSize = Round((nStaffSize * ThisScore.EngravingRules.SmallStaffSizeScale) / 100.0);
		}
		WriteXML('<staff-size>' & nStaffSize & '</staff-size>', 5);
		WriteXML('</staff-details>', 4);
		if (Staves = 1) {
			fStaffDetailsDone[1] = True;
		} else {
			fStaffDetailsDone[nTabClef] = True;
		}
	} 

	// Sibelius 5.1 adds a NumStaveLines member to the InstrumentType
	// for the number of staff lines on non-tab staves.
	for i = 1 to Staves + 1 {	
		if (((StaffLines[i] != 5) or (fSmall[i])) and (not fStaffDetailsDone[i])) {
			sDetailsNumber = '';
			if (Staves > 1) {
				sDetailsNumber = ' number=\'' & i & '\'';
			}
			WriteXML('<staff-details' & sDetailsNumber & 
						StaffDetailsPrintObject[i] & '>', 4);
			if (StaffLines[i] != 5) {
				WriteXML('<staff-lines>' & StaffLines[i] & '</staff-lines>', 5);
			}
			if (fSmall[i]) {
				nStaffSize = ThisScore.EngravingRules.SmallStaffSizeScale;
				WriteXML('<staff-size>' & nStaffSize & '</staff-size>', 5);
			}
			WriteXML('</staff-details>', 4);
			fStaffDetailsDone[1] = True;
			// In case we have percussion clef on a normal staff.
			if (PercussionClef >= 0) {
				if ((PercussionClef = i) or ((PercussionClef = 0) and (i = 1))) {
					PercStaffLines = StaffLines[i];
				}
			}
		}
	}

	// Now handle hidden staff changes if not yet done.
	for i = 1 to Staves + 1 {
		if (not fStaffDetailsDone[i]) {
			if (Length(StaffDetailsPrintObject[i]) > 0) {
				sDetailsNumber = '';
				if (Staves > 1) {
					sDetailsNumber = ' number=\'' & i & '\'';
				}
				WriteXML('<staff-details' & sDetailsNumber & 
							StaffDetailsPrintObject[i] & '/>', 4);
			}
		}
	}	

	// Output transposition if needed.
	CheckTranspose(oInstrumentType, 1, 0, 1, null);
	if ((TransposeChromatic != 0) or (TransposeDiatonic != 0) or 
		 (TransposeOctaveChange != 0)) {
		WriteTranspose();
	}

	// Output multimeasure rest
	if (nMultiRest > 0) {
		WriteXML('<measure-style>', 4);
		WriteXML('<multiple-rest>' & nMultiRest & '</multiple-rest>', 5);
		WriteXML('</measure-style>', 4);
	}

	WriteXML('</attributes>', 3);
} else {
	// For now, assume key signature is same in all
	// staves of instrument.

	oThisKey = oStaff.CurrentKeySignature(MeasureNumber);
	oLastKey = oStaff.CurrentKeySignature(MeasureNumber - 1);
	oThisTime = oSystemStaff.CurrentTimeSignature(MeasureNumber);
	oLastTime = oSystemStaff.CurrentTimeSignature(MeasureNumber - 1);
	// @todo !!! This does not handle mid-bar instrument changes
	// For now, instrument changes get quantized to bar boundaries.
	oInstrumentType = oStaff.NthBar(MeasureNumber).GetInstrumentTypeAt(0);
	oLastInstrumentType = oStaff.NthBar(MeasureNumber - 1).GetInstrumentTypeAt(0);

	fKeyChanged = False;
	// Do not write key on the percussion clef, so do not check it either.
	fHasKey = True;
	if (PercussionClef >= 0) {
		fHasKey = False;
	} else {
		if ((oInstrumentType.Category = 0) and
			 (not oInstrumentType.HasKeySignatureOrTuning)) {
			fHasKey = False;
		}
	}

	if (fHasKey) {
		CheckKey(oThisKey, oInstrumentType);
		if ((KeyFifths != LastKeyFifths) or (KeyMode != LastKeyMode)) {
			fKeyChanged = True;
		}
	} 

	fTimeChanged = False;
	if ((oThisTime.Numerator != oLastTime.Numerator) or 
        (oThisTime.Denominator != oLastTime.Denominator)) {
		fTimeChanged = True;
	}

	fTransposeChanged = False;
	CheckTranspose(oInstrumentType, MeasureNumber, 0, 1, null);
	if ((TransposeChromatic != LastTransposeChromatic) or 
		 (TransposeDiatonic != LastTransposeDiatonic) or 
		 (TransposeOctaveChange != LastTransposeOctaveChange)) {
		fTransposeChanged = True;
	}

	fStaffDetailsChanged = False;
	for i = 1 to Staves + 1 {
		if (Length(StaffDetailsPrintObject[i]) > 0) {
			fStaffDetailsChanged = True;
		}
	}

	if (fKeyChanged or fTimeChanged or fStaffDetailsChanged or 
		 fTransposeChanged or (nMultiRest > 0)) {
		WriteXML('<attributes>', 3);
		if (fKeyChanged) {
			WriteKey(0);
		}
		if (fTimeChanged) {
			WriteTime(oSystemStaff.CurrentTimeSignature(MeasureNumber), 0);
		}

		if (fStaffDetailsChanged) {
			for i = 1 to Staves + 1 {
				if (Length(StaffDetailsPrintObject[i]) > 0) {
					if (Staves = 1) {
						WriteXML('<staff-details' & StaffDetailsPrintObject[1] & '/>', 4);
					} else {
						WriteXML('<staff-details number=\'' & i & '\'' & 
								 StaffDetailsPrintObject[i] & '/>', 4);
					}
				}
			}	
		}

		if (fTransposeChanged) {
			WriteTranspose();
		}

		// Output multimeasure rest
		if (nMultiRest > 0) {
			WriteXML('<measure-style>', 4);
			WriteXML('<multiple-rest>' & nMultiRest & '</multiple-rest>', 5);
			WriteXML('</measure-style>', 4);
		}			
		WriteXML('</attributes>', 3);
	}
}      
}"
	FinalizeMeasure "(ThisScore, MeasureNumber, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Because we need to handle barlines and endings together,
// we have to do this outside of the normal system item processing.
// Do not print endings if we are not on a system staff.
fSystemStaff = CheckSystemStaff(ThisScore, MeasureNumber, StaffNumber, 1);

if (RightEndingBar = MeasureNumber) {
	WriteSystemBarline(ThisScore, RightBarline, RightEnding, RightEndingType,
					   'right', RightBarlineColor, fSystemStaff);
	// Now redo barline initialization to check for an ending start
	// that may have intruded into the same measure as an ending end.
	// Last parameter indicates that the last ending object should win,
	// in case we have a 2nd ending intruding on a 1-bar 1st ending.
	InitializeBarlines(ThisScore, MeasureNumber, True, False);
} else {
	if ((Length(RightBarline) > 0) or (Length(RightBarlineColor) > 0)) {
		WriteSystemBarline(ThisScore, RightBarline, '', '', 'right', 
						   RightBarlineColor, fSystemStaff);
	}
}

WriteXML('</measure>', 2);
}"
	WriteMeasure "(ThisScore, ThisBar, BarNumber, StaffNumber, PartNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// If we are on the second staff or greater, and
// not at the beginning of the meaure, we need to
// backup before starting on this staff.
if ((StaffNumber > 1) and (MeasureCounter > 0)) {
	WriteXML('<backup>', 3);
	WriteXML('<duration>' & MeasureCounter & '</duration>', 4);
	WriteXML('</backup>', 3);
}

nSystemStaffCount = SystemStaffCount[BarNumber];
nSystemStaffIndex = 0;
nBarLength = ThisBar.Length * 3;
nStaff = 0 + StaffNumber;
if (nStaff = 0) {
	nStaff = 1;
}

// Check to see if we are on a staff where we should display
// system objects.
fSystemStaff = False;
if (nSystemStaffCount > 0) {
	nSibStaffNumber = ThisBar.ParentStaff.StaffNum;
	fSystemStaff =
		CheckSystemStaff(ThisScore, BarNumber, nSibStaffNumber, nStaff);
}

// Loop through each bar object and write it.
MeasureCounter = 0;
SibMeasureCounter = 0;
SymbolCount = 0;
FingeringCount = 0;
nVoice = 0;
nLastVoice = 0;

// Because of the sequential writing of the XML
// file, we need to sort the bar objects so that
// objects other than a NoteRest or BarRest come
// before the closest object. This way, we will get
// small positive offsets instead of large negative
// offsets, and associate the non-NoteRest with a
// more correct place in the music. This also will
// avoid losing symbols that should be exported as
// MusicXML notations.

oSortedIndex = CreateSparseArray();
nLastNoteRestIndex = -1;
nLastSortedIndex = -1;
fBarRestAdded = False;

for bi = 0 to ThisBar.BarObjectCount {
	oBarObj = ThisBar.NthBarObject(bi);
	sType = oBarObj.Type;
	if ((sType = 'NoteRest') or (sType = 'BarRest')) {
		if (nLastNoteRestIndex >= 0) {
			oLastNoteRest = ThisBar.NthBarObject(nLastNoteRestIndex);
			nLastNotePos = oLastNoteRest.Position;
			nThisNotePos = oBarObj.Position;
			fNoteRestAdded = False;
			for si = nLastNoteRestIndex + 1 to bi {
				nLastSortedIndex = nLastSortedIndex + 1;
				if (fNoteRestAdded) {
					oSortedIndex[nLastSortedIndex] = si;
				} else {
					oSortBarObj = ThisBar.NthBarObject(si);
					nThisPos = oSortBarObj.Position;
					// Give preference to going before the current note.
					// Check for objects that always go before a note when
					// in between (e.g. caesura) and those that always go
					// after when in between (e.g. arpeggio lines).
					if ((((nThisPos - nLastNotePos) <= (nThisNotePos - nThisPos)) or
						 (AlwaysBefore(oSortBarObj))) and
						 (not (AlwaysAfter(oSortBarObj)))) {
						oSortedIndex[nLastSortedIndex] = si;
					} else {
						oSortedIndex[nLastSortedIndex] = nLastNoteRestIndex;
						fNoteRestAdded = True;
						nLastSortedIndex = nLastSortedIndex + 1;
						oSortedIndex[nLastSortedIndex] = si;
					}
				}
			}
			if (not fNoteRestAdded) {
				nLastSortedIndex = nLastSortedIndex + 1;
				oSortedIndex[nLastSortedIndex] = nLastNoteRestIndex;
				fNoteRestAdded = True;
			}
		}
		if (sType = 'BarRest') {
			fBarRestAdded = True;
		}
		nLastNoteRestIndex = bi;
	} else {  					
		// If this element comes before either the first NoteRest
		// or BarRest, then keep it there. Otherwise we wait and
		// process at the next NoteRest/BarRest or at the end of
		// the bar.
		if (nLastNoteRestIndex < 0) {
			nLastSortedIndex = nLastSortedIndex + 1;
			oSortedIndex[nLastSortedIndex] = bi;
		}
	}
}

// Now add the items since the last NoteRest or BarRest
if (nLastNoteRestIndex >= 0) {
	oLastNoteRest = ThisBar.NthBarObject(nLastNoteRestIndex);
	nLastNotePos = oLastNoteRest.Position;
	nThisNotePos = ThisBar.Length;
	fNoteRestAdded = False;
	for si = nLastNoteRestIndex + 1 to ThisBar.BarObjectCount {
		nLastSortedIndex = nLastSortedIndex + 1;
		if (fNoteRestAdded) {
			oSortedIndex[nLastSortedIndex] = si;
		} else {
			oSortBarObj = ThisBar.NthBarObject(si);
			nThisPos = oSortBarObj.Position;
			// Give preference to going before the current note.
			// Anything that is note-attached must go before the
			// last note, not after, or we will lose it.
			if (((nThisPos - nLastNotePos) <= (nThisNotePos - nThisPos)) or
				 (IsNoteAttached(oSortBarObj))) {
				oSortedIndex[nLastSortedIndex] = si;
			} else {
				oSortedIndex[nLastSortedIndex] = nLastNoteRestIndex;
				fNoteRestAdded = True;
				nLastSortedIndex = nLastSortedIndex + 1;
				oSortedIndex[nLastSortedIndex] = si;
			}
		}
	}
	if (not fNoteRestAdded) {
		nLastSortedIndex = nLastSortedIndex + 1;
		oSortedIndex[nLastSortedIndex] = nLastNoteRestIndex;
		fNoteRestAdded = True;
	}
}

// Some files have duplicate bar rests in a single voice, which can
// lead to incorrect MusicXML export. Check that we export no more
// than one bar rest per voice. This usually happens with files
// created using PhotoScore.
nBarRestFound = CreateSparseArray();
nBarRestVoiceMax = 5 * StaffNumber;
if (nBarRestVoiceMax = 0) {
	nBarRestVoiceMax = 5;
}
for bri = 0 to nBarRestVoiceMax {
	nBarRestFound[bri] = 0;
}

// If we do not have a bar rest, stop any previous measure-repeat
// element that we may have had on this staff.
if (not fBarRestAdded) {
	WriteMeasureRepeatStop(StaffNumber, True);
	MeasureRepeatStopBars[nStaff] = 0;
}

// Now go through the sorted list and write out each item in turn.
// This will give us smaller offsets and better musical meaning overall.
for bi = 0 to ThisBar.BarObjectCount {
	oBarObj = ThisBar.NthBarObject(oSortedIndex[bi]);
	// @todo Consider only writing before a NoteRest or BarRest, except at 0
	// @todo Consider looking ahead to next NoteRest for better quantizing
	if (fSystemStaff) {
		nSystemStaffIndex = 
			WriteSystemStaffItems(ThisScore, BarNumber, MeasureCounter, 
			                      nSystemStaffIndex, StaffNumber);
		if (nSystemStaffIndex >= nSystemStaffCount) {
			fSystemStaff = False;
			SystemStaffDone[BarNumber] = True;
		}
	}
	if (DirectionStops > 0) {
		CheckDirectionStops(False);
	}
	sType = oBarObj.Type;
	NextEntryBeam = NoBeam;
	NextEntryDuration = 0;
	NextGraceEntryBeam = NoBeam;
	NextGraceEntryDuration = 0;

	// Multiply position by 3 for better triplet handling.
	SibMeasureCounter = oBarObj.Position * 3;
	nVoice = GetVoice(oBarObj, StaffNumber);
	if (sType = 'NoteRest') {
		// Special case notes in the middle of 3/2 tuplets.
		// Being able to do this is why we triple the divisions.
		oCounterTuplet = oBarObj.ParentTupletIfAny;
		if (oCounterTuplet != null) {
			if ((oCounterTuplet.ParentTupletIfAny = null) and
				 (oCounterTuplet.Left = 3) and (oCounterTuplet.Right = 2)) {
				SibMeasureCounter = (oCounterTuplet.Position * 3) + 
										(oBarObj.PositionInTuplet * 2);
			}
		}
		// Tuplet positions and durations are approximate.
		// This test will keep us from inserting forward
		// and backup into the middle of a tuplet.
		// See if this causes big adjustments at the
		// end of complex tuplets. If so, may need
		// to adjust the durations to avoid having
		// backup and forward elements.
		if ((nVoice != nLastVoice) or (LastTupletPosition[nVoice] < 0)) {
			if (SibMeasureCounter != MeasureCounter) {
				// If this is in the same voice and it is a big difference,
				// it is probably a tuplet error, so log it.
				// The 96 value represents a 32nd note difference.
				if ((nVoice = nLastVoice) and 
					 (MeasureCounter > (SibMeasureCounter  + 96))) {
					// There are two different errors this could be.
					// If the backup matches the duration, then we have
					// two NoteRest objects in the same voice at the 
					// same time - odd, but still OK for MusicXML.
					// If the backup does not match, it is likely to
					// be a tuplet error which could be messing up
					// the markup earlier. Warn about both, but with
					// different messages.
					if ((PreviousEntryDuration[nVoice] * 3) = 
						 (MeasureCounter - SibMeasureCounter)) {
						LogError('Two NoteRests in same voice at same position may be an error', 3);
					} else {
						LogError('Large within-voice backup may be an error', 3);
					}
				}
				WriteAdjust(SibMeasureCounter, MeasureCounter, StaffNumber, 
			        	    nVoice);
				MeasureCounter = SibMeasureCounter;
			}
		}
		nLastVoice = nVoice;

		// Due to the mismatch between beam values in the GUI and
		// beam values in ManuScript, we need to lookahead to the
		// next non-grace entry in this voice and see if it accepts
		// a beam in order to disambiguate what the MusicXML beam
		// value should be.
		// @todo Handle beam over barlines by looking ahead to next measure.
		// For now, we act as if beaming were never carried over the barline.
		if ((oBarObj.NoteCount > 0) and (oBarObj.Duration < Quarter)) {
			fKeepGoing = True;
			li = bi + 1;
			if (li >= ThisBar.BarObjectCount) {
				fKeepGoing = False;
			}
			
			while (fKeepGoing) {
				oNextBarObj = ThisBar.NthBarObject(oSortedIndex[li]);
				if (oNextBarObj.Type = 'NoteRest') {
					if (oBarObj.VoiceNumber = oNextBarObj.VoiceNumber) {
						if (oBarObj.GraceNote) {
							fKeepGoing = False;
							if (oNextBarObj.GraceNote) {
								NextGraceEntryDuration = oNextBarObj.Duration;
								if (NextGraceEntryDuration >= Quarter) {
									NextGraceEntryBeam = NoBeam;
								} else {
									NextGraceEntryBeam = oNextBarObj.Beam;
								}
							} else {
								NextGraceEntryDuration = 0;
								NextGraceEntryBeam = NoBeam;
							}
						} else {
							if (not oNextBarObj.GraceNote) {
								fKeepGoing = False;
								NextEntryDuration = oNextBarObj.Duration;
								if (NextEntryDuration >= Quarter) {
									NextEntryBeam = NoBeam;
								} else {
									NextEntryBeam = oNextBarObj.Beam;
								}
							}
						}
					}
				}
				li = li + 1;
				if (li >= ThisBar.BarObjectCount) {
					fKeepGoing = False;
				}
			}
		}

		// Now write the note rest
		nDuration = WriteNoteRest(oBarObj, StaffNumber);
		MeasureCounter = MeasureCounter + nDuration;
		if (oBarObj.GraceNote) {
			// Do not set symbol count to 0 on a grace note.
			// We want notation symbols on the main note instead.
			PreviousGraceEntryDuration[nVoice] = oBarObj.Duration;
			PreviousGraceEntryBeam[nVoice] = oBarObj.Beam;
			// A continue beam on a rest will keep non-primary
			// beams from beaming together, requiring a backward
			// hook vs. an end beam.
			PreviousGracePrimaryBeamOnly[nVoice] =
				((oBarObj.NoteCount = 0) and (oBarObj.Beam = SingleBeam));
		} else {
			SymbolCount = 0;
			PreviousEntryDuration[nVoice] = oBarObj.Duration;
			PreviousEntryBeam[nVoice] = oBarObj.Beam;
			// A continue beam on a rest will keep non-primary
			// beams from beaming together, requiring a backward
			// hook vs. an end beam.
			PreviousPrimaryBeamOnly[nVoice] =
				((oBarObj.NoteCount = 0) and (oBarObj.Beam = SingleBeam));
			PreviousGraceEntryDuration[nVoice] = 0;
			PreviousGraceEntryBeam[nVoice] = NoBeam;
			PreviousGracePrimaryBeamOnly[nVoice] = False;
		}
	} else {
		if (sType = 'BarRest') {
			if (nBarRestFound[nVoice] = 0) {
				WriteBarRest(oBarObj, StaffNumber);
				MeasureCounter = MeasureCounter + nBarLength;
				SymbolCount = 0;
			}
			nBarRestFound[nVoice] = 1 + nBarRestFound[nVoice];
		} else {
			// Use indirection to call write routines for
			// each object type.
			sWriteMethod = 'Write' & sType;
			@sWriteMethod(oBarObj, StaffNumber);
		}
	}
}

// Handle leftover fingerings as words directions
for fi = 0 to FingeringCount {
	if (not FingeringWritten[fi]) {		
		WriteFingering(fi, StaffNumber, False, True);
	}
}

// Get any end-of-measure direction stops.

if (DirectionStops > 0) {
	CheckDirectionStops(True);
}

// Get any system items for this bar that occur after the last regular bar object.

if (fSystemStaff) {
	SibMeasureCounter = nBarLength;
	if (MeasureCounter < SibMeasureCounter) {
		nAdjustVoice = 0;
		// @todo Check to see if really should be writing voice here.
		// But this code may become obsolete if we rework things voicewise.
		// nAdjustVoice = nLastVoice;
	
		// If there are no objects in the bar, we are writing a forward
		// to cover the entire bar. This should be written in voice 1.
		if (ThisBar.BarObjectCount = 0) {
			nAdjustVoice = 1;
		}
		WriteAdjust(SibMeasureCounter, MeasureCounter, StaffNumber, nAdjustVoice);
		MeasureCounter = SibMeasureCounter;
	}
	nSystemStaffIndex = 
		WriteSystemStaffItems(ThisScore, BarNumber, MeasureCounter, 
		                      nSystemStaffIndex, StaffNumber);
	
	// Get any end-of-measure direction stops generated by these system items.

	if (DirectionStops > 0) {
		CheckDirectionStops(True);
	}
	
	SystemStaffDone[BarNumber] = True;
}
}"
	WriteClef "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

nTabClef = 0 + TabClef;
nTabStrings = 0 + TabStrings;

WriteXML('<attributes>', 3);
sStaffNumber = '';
if (StaffNumber > 0) {
	sStaffNumber = ' number=\'' & StaffNumber & '\'';
}
WriteXML('<clef' & sStaffNumber & '>', 4);

// Use sounding or transposed style id depending on if
// we are using transpositions or not. Used to use StyleId,
// which changed based on whether we are viewing a transposed
// score; this gives us more control.
sStyleId = BarObject.ConcertClefStyleId;
if (UseTranspose) {
	sStyleId = BarObject.TransposingClefStyleId;
}
oInstrumentType = BarObject.ParentBar.GetInstrumentTypeAt(BarObject.Position);
WriteClefStyle(sStyleId, StaffNumber, oInstrumentType, 
			   BarObject.ParentBar.BarNumber, BarObject.Position);
WriteXML('</clef>', 4);
if ((nTabClef = StaffNumber) and (nTabStrings > 0)) {
	WriteXML('<staff-details' & sStaffNumber & '>', 4);
	WriteXML('<staff-lines>' & nTabStrings & '</staff-lines>', 5);
	WriteXML('</staff-details>', 4);
}
WriteXML('</attributes>', 3);
}"
	WriteNoteRest "(ThisNoteRest, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Initialize note count.
i = 1;

// Initialize type data output dictionary.
oTypeData = CreateDictionary();
oTypeData[TypeDataType] = '';
oTypeData[TypeDataDots] = 0;
oTypeData[TypeDataBeams] = 0;

// Check for the voice.
nVoice = GetVoice(ThisNoteRest, StaffNumber);
fTremoloStart = False;
fDoubleTremoloOK = False;

// Check for tremolos. If there is a conflict between
// past tremolo and current tremolo, use the past one,
// which matches what Sibelius does. So ignore the
// SingleTremolos and DoubleTremolos settings if this
// is the end note of a double tremolo.
if ((TremoloType[nVoice] != 'stop') or
	 (DoubleTremolos[nVoice] <= 0)) {
	if (ThisNoteRest.SingleTremolos > 0) {
		TremoloType[nVoice] = 'single';
		DoubleTremolos[nVoice] = 0;
	} else {
		if (ThisNoteRest.SingleTremolos = ZOnStem) {
			TremoloType[nVoice] = 'unmeasured';
			DoubleTremolos[nVoice] = 0;
		} else {
			if (ThisNoteRest.DoubleTremolos > 0) {
				// Check to see if this is a real, within-bar
				// double tremolo.
				// @todo Handle cross-bar double tremolos.
				fDoubleTremoloOK = HasDoubleTremolo(ThisNoteRest);
				if (fDoubleTremoloOK) {
					fTremoloStart = True;
					TremoloType[nVoice] = 'start';
					DoubleTremolos[nVoice] = ThisNoteRest.DoubleTremolos;
				}
			}
		}
	}
}

// Check for tuplets.
fWasExtendedTuplet = False;
if (not ExtendedTuplet) {	
	TimeModActualNotes = 0;
	TimeModNormalNotes = 0;
	TimeModNormalType = '';
	TimeModNormalDots = 0;
} else {
	fWasExtendedTuplet = True;
}
nLastTupletPosition = -1;
IgnoreNestedTuplets = False;
oTuplet = ThisNoteRest.ParentTupletIfAny;
if ((oTuplet != null) or ExtendedTuplet) {
	nLastTupletPosition = ThisNoteRest.PositionInTuplet;
}

// Some files can get messed up so that tuplets appear to
// be infinitely nested in ManuScript. Max out the tuplet
// count at a certain point. If that max value is exceeded,
// ignore any nested tuplets; just use the first tuplet value.
nMaxNestedTuplets = 1000;
nNestedTuplet = 0;
while ((oTuplet != null) and (nNestedTuplet < nMaxNestedTuplets)) {
	if (TimeModActualNotes = 0) {
		TimeModActualNotes = 0 + oTuplet.Left;
		TimeModNormalNotes = 0 + oTuplet.Right;
		GetType(oTuplet.Unit, oTypeData);
		TimeModNormalType = oTypeData[TypeDataType];
		TimeModNormalDots = oTypeData[TypeDataDots];
	} else {
		TimeModActualNotes = TimeModActualNotes * oTuplet.Left;
		TimeModNormalNotes = TimeModNormalNotes * oTuplet.Right;
		TimeModNormalType = '';
		TimeModNormalDots = 0;
	}
	oTuplet = oTuplet.ParentTupletIfAny;
	nNestedTuplet = nNestedTuplet + 1;
}

// If we have bogus nested tuplets, just use the first tuplet value.
// Cannot do anything correct here; this seems the best way forward.
// Set the global to ignore nested tuplets so later methods do not
// go through the same pain of looping through an infinite nesting.
if (nNestedTuplet >= nMaxNestedTuplets) {
	IgnoreNestedTuplets = True;
	LogError('Tuplet(s) in following note are confusing Sibelius', 3);
	oTuplet = ThisNoteRest.ParentTupletIfAny;
	TimeModActualNotes = oTuplet.Left;
	TimeModNormalNotes = oTuplet.Right;
	GetType(oTuplet.Unit, oTypeData);
	TimeModNormalType = oTypeData[TypeDataType];
	TimeModNormalDots = oTypeData[TypeDataDots];
}

// Get the NoteRest type data. Double the duration
// if we have double-note tremolos.
nTypeDuration = ThisNoteRest.Duration;
if (DoubleTremolos[nVoice] > 0) {
	nTypeDuration = nTypeDuration * 2;
}
nBeams = GetType(nTypeDuration, oTypeData);
XmlType = oTypeData[TypeDataType];
XmlDots = oTypeData[TypeDataDots];
XmlBeams = oTypeData[TypeDataBeams];

// Add double tremolos to time mod if present
if (DoubleTremolos[nVoice] > 0) {
	if (TimeModActualNotes = 0) {
		TimeModActualNotes = 2;
		TimeModNormalNotes = 1;
	} else {
		TimeModActualNotes = TimeModActualNotes * 2;
	}
	TimeModNormalType = '';
	TimeModNormalDots = 0;
}

// Initialize note rest color and stem weight.
StemXml = '';
NoteRestColor = GetColor(ThisNoteRest);
StemWeight = 0 + ThisNoteRest.Stemweight;
if (StemWeight < 0) {
	StemXml = 'up';
} else {
	StemXml = 'down';
}

// Compute the duration once for the NoteRest rather
// than for each note.
NoteRestDuration = GetDuration(ThisNoteRest, nVoice);

// Initialize apreggios since the arpeggiate element
// is written for each note.
ArpeggioVoiceWritten = -1;

nStaffToWrite = 0 + StaffNumber;
if (AtLeastSib20219) {
	switch (ThisNoteRest.CrossStaff) {
		case (1) {
			if (nStaffToWrite > 1) {
				nStaffToWrite = nStaffToWrite - 1;
			}
		}
		case (2) {
			if (nStaffToWrite < Staves) {
				nStaffToWrite = nStaffToWrite + 1;
			}
		}
	}
}
if (ThisNoteRest.NoteCount = 0) {
	WriteRest(ThisNoteRest, StaffNumber, nVoice, nStaffToWrite);
} else {
	for each oNote in ThisNoteRest {
		WriteNote(ThisNoteRest, oNote, StaffNumber, nVoice, nStaffToWrite, i);
		i = i + 1;
	}
}

// If we have double tremolos, go from start to stop or
// from stop to none. Also reset after single tremolo.
if (fTremoloStart) {
	TremoloType[nVoice] = 'stop';
} else {
	if ((TremoloType[nVoice] = 'single') or (TremoloType[nVoice] = 'unmeasured')) {
		TremoloType[nVoice] = '';
	} else {
		if (TremoloType[nVoice] = 'stop') {
			TremoloType[nVoice] = '';
			DoubleTremolos[nVoice] = 0;
		}
	}
}

// If we have tuplets, update the last tuplet position.
LastTupletPosition[nVoice] = nLastTupletPosition;

// Reset extended tuplet if we had it before.
// We do not extended two NoteRests in a row.
if (fWasExtendedTuplet) {
	ExtendedTuplet = False;
}

// Reset arpeggio if written
if (ArpeggioVoiceWritten >= 0) {
	ArpeggioBars[ArpeggioVoiceWritten] = 0;
}

return NoteRestDuration;
}"
	WriteBarRest "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// In Sibelius 6, check for measure repeat values for bar rest.
// @todo See if we can actually export the music of the previous bar(s).
nNewMeasureRepeat = 0;
nThisBar = BarObject.ParentBar.BarNumber;
nMeasureRepeatStaff = 0 + StaffNumber;
sMeasureStyleNumber = '';
fWriteBreveType = False;
if (nMeasureRepeatStaff = 0) {
	nMeasureRepeatStaff = 1;
} else {
	sMeasureStyleNumber = ' number=\'' & StaffNumber & '\'';
}
switch (BarObject.RestType) {
	case (BreveBarRest) {
		fWriteBreveType = True;
	}
	case (OneBarRepeat) {
		nNewMeasureRepeat = 1;
	}
	case (TwoBarRepeat) {
		nNewMeasureRepeat = 2;
	}
	case (FourBarRepeat) {
		nNewMeasureRepeat = 4;
	}
}
if (nThisBar >= MeasureRepeatStopBars[nMeasureRepeatStaff]) {
	if (nNewMeasureRepeat != LastMeasureRepeat[nMeasureRepeatStaff]) {
		WriteXML('<attributes>', 3);
		WriteMeasureRepeatStop(StaffNumber, False);
		if (nNewMeasureRepeat > 0) {
			WriteXML('<measure-style' & sMeasureStyleNumber & '>', 4);
			WriteXML('<measure-repeat type=\'start\'>' & 
					  nNewMeasureRepeat & '</measure-repeat>', 5);
			WriteXML('</measure-style>', 4);
		}
		WriteXML('</attributes>', 3);
		LastMeasureRepeat[nMeasureRepeatStaff] = nNewMeasureRepeat;
	}
	if (nNewMeasureRepeat > 0) {
		MeasureRepeatStopBars[nMeasureRepeatStaff] = nThisBar + nNewMeasureRepeat;
	} else {
		MeasureRepeatStopBars[nMeasureRepeatStaff] = 0;
	}
}

// Start the note.
if (BarObject.Hidden) {
	WriteXML('<note print-object=\'no\'>', 3);
} else {
	sColor = GetColor(BarObject);
	WriteXML('<note' & sColor & '>', 3);
}

// Write the rest.
WriteXML('<rest measure=\'yes\'/>', 4);

// Write the duration for a whole bar.
nBarLength = BarObject.ParentBar.Length * 3;
WriteXML('<duration>' & nBarLength & '</duration>', 4);

// If we have multiple instruments, write the instrument element.
sInstrument = '' & CurrentPartInstrument[StaffNumber];
if (Length(sInstrument) > 0) {
	WriteXML('<instrument id=\'' & sInstrument & '\'/>', 4);
}

// If it is associated with just one voice 1-4, write that out.
nVoice = GetVoice(BarObject, StaffNumber);
if (nVoice > 0) {
	WriteXML('<voice>' & nVoice & '</voice>', 4);
}

// If we have a breve rest, write the type.
if (fWriteBreveType) {
	WriteXML('<type>breve</type>', 4);
}

// Write the staff in a multi-staff part.
if (StaffNumber > 0) {
	WriteXML('<staff>' & StaffNumber & '</staff>', 4);
}

// Handle notations. May eventually move this to a separate
// WriteBarRestNotations method.
fFermata = False;
fOrnaments = False;
sFermata = '';

// Starting in Sibelius 6, we can get fermatas from a BarRest.
if (BarObject.PauseType != PauseTypeNone) {
	fFermata = True;
	switch (BarObject.PauseType) {
		case (PauseTypeRound) {
			sFermata = 'normal';
		}
		case (PauseTypeSquare) {
			sFermata = 'square';
		}
		case (PauseTypeTriangular) {
			sFermata = 'angled';
		}
	}
}

// Check for trills ending on BarRest.
oTrillStarts = CreateSparseArray();
oTrillStops = CreateSparseArray();
if (TrillCounts > 0) {
	nTrills = CheckTrills(BarObject, StaffNumber, oTrillStarts, oTrillStops);
	if (nTrills > 0) {
		fOrnaments = True;
	}
}

if (fFermata or fOrnaments) {
	WriteXML('<notations>', 4);
	if (fOrnaments) {
		WriteXML('<ornaments>', 5);
		if (nTrills > 0) {
			WriteTrills(BarObject, oTrillStarts, oTrillStops);
		}
		WriteXML('</ornaments>', 5);
	}
	if (fFermata) {
		WriteXML('<fermata>' & sFermata & '</fermata>', 5);
	}
	WriteXML('</notations>', 4);
}

// Write notations for bar rest if present, based on
// symbols that are used as notations.

// Do not use this for now - the position for symbols
// does not match the position for bar rests.

// Should we use this in the future, combine with 
// fermata handling from above.

// WriteBarRestNotations();

// Finish the note. This may move to handle slurs etc.
WriteXML('</note>', 3);
}"
	WriteLine "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

WriteAnyLine(BarObject, StaffNumber, False);
}"
	WriteNote "(ThisEntry, ThisNote, StaffNumber, Voice, StaffToWrite, NoteNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Check if this is a chord note
fIsChord = False;
if (NoteNumber > 1) {
	fIsChord = True;
}

// Dx is in 1/32 of staff space. 
nRelativeX = Round(ThisEntry.Dx / 3.2);

// Check for a hidden note.
// Hidden can be tested starting in 4.1.
// Do not export color if the note rest is hidden.
sPrintObject = '';
sColor = '' & NoteRestColor;
if (ThisEntry.Hidden) {
	sPrintObject = ' print-object=\'no\'';
	sColor = '';
	if ((not fIsChord) and AnyVisibleLyric[Voice]) {
		sPrintObject = sPrintObject & ' print-lyric=\'yes\'';
	}
}

// Is it a grace or cue note? Need to compute
// this for live playback before writing out
// the grace and cue elements.
fGrace = False;
fCue = False;
if (ThisEntry.GraceNote) {
	fGrace = True;
}

// Check for cue note and symbol size.
// In Sibelius, 'cue notes' play back, and we do not have
// any access to the regular cue/no cue keypad setting.
// But we do have access to silent noteheads, which is
// what we use here.
if ((not fGrace) and (ThisNote.NoteStyle = SilentNoteStyle)) {
	fCue = True;
}

sSymbolSize = '';
if (fCue) {
	if (not (ThisEntry.CueSize)) {
		if (not (ThisNote.NoteStyle = CueNoteStyle)) {
			sSymbolSize = 'full';
		}
	}
} else {
	if (not fGrace) {
		if ((ThisEntry.CueSize) or 
			(ThisNote.NoteStyle = CueNoteStyle)) {
			sSymbolSize = 'cue';
		}
	}
}

// Check for stop ties. Use MIDI pitch for these tests.
fStopTie = False;
fVoiceOK = True;
nTiePitch = 0 + ThisNote.Pitch;
nTieBar = ThisEntry.ParentBar.BarNumber;
nTiePosition = ThisEntry.Position * 3;
if (nTiePosition = 0) {
	if (TieStopNextBar[nTiePitch] = nTieBar) {
		if (TieStopNextStaff[nTiePitch] = StaffNumber) {
			if (TieStartVoice[nTiePitch] != ThisEntry.VoiceNumber) {
				fVoiceOK = not FoundMatchedVoicePitch(nTiePitch, ThisEntry);
			}
			if (fVoiceOK) {
				fStopTie = True;
				TieStopNextBar[nTiePitch] = 0;
			}
		}
	}
} else {
	if (TieStopThisBar[nTiePitch] = nTieBar) {
		if (TieStopThisStaff[nTiePitch] = StaffNumber) {
			// Account for tuplet roundoff errors
			if ((nTiePosition >= (TieStopThisPosition[nTiePitch] - 2)) and
				(nTiePosition <= (TieStopThisPosition[nTiePitch] + 2))) {
				if (TieStartVoice[nTiePitch] != ThisEntry.VoiceNumber) {
					fVoiceOK = not FoundMatchedVoicePitch(nTiePitch, ThisEntry);
				}
				if (fVoiceOK) {
					fStopTie = True;
					TieStopThisBar[nTiePitch] = 0;
				}
			}
		}
	}
}
fTiedInto = False;
if (AtLeastSib20201) {
	fTiedInto = ThisNote.TiedInto;
}

// Check for live mode playback data if 
// Live Mode is on for this score.
sLiveMode = '';
if (LiveModeOn > 0) {
	sLiveMode = GetLiveMode(ThisNote, NoteRestDuration);
}

// Start the note.
if ((nRelativeX = 0) or (ThisEntry.GraceNote)) {
	WriteXML('<note' & sLiveMode & sPrintObject & sColor & '>', 3);
} else {
	WriteXML('<note' & sLiveMode & sPrintObject & sColor & 
			 ' relative-x=\'' & nRelativeX & '\'>', 3);
}

// Write out grace and cue elements
if (fGrace) {
	sSlash = '';
	// IsAcciaccatura and IsAppoggiatura were added in Sibelius 5
	if (ThisEntry.IsAcciaccatura) {
		sSlash = ' slash=\'yes\'';
	} else {
		if (ThisEntry.IsAppoggiatura) {
			sSlash = ' slash=\'no\'';
		}
	}
	WriteXML('<grace' & sSlash & '/>', 4);
}
if (IsCue) {
	WriteXML('<cue/>', 4);
}

// Is it a chord?
if (fIsChord) {
	WriteXML('<chord/>', 4);
}

// Write the pitch, not counting transposition. 

// The first character has the step, the rest
// has written accidental information. The
// Substring function is 0-based for the index.
// However, this accidental information contains
// no new information compared to the Accidental
// property.

sStep = '';
nAlter = 0;
sAlter = '';
nOctave = 0;

// Written name and accidentals show what is displayed,
// so they work for both transposed and concert scores.
// However we do not want written diatonic pitch for the
// octave in clefs that include a clef-octave-change.
sName = ThisNote.WrittenName;
nAccidental = ThisNote.WrittenAccidental;
nDiatonicPitch = ThisNote.DiatonicPitch;
if (WrittenDiatonicPitchOK) {
	nDiatonicPitch = ThisNote.WrittenDiatonicPitch;
}

sStep = Substring(sName, 0, 1);
nAlter = nAccidental;
if (nAlter != 0) {
	sAlter = '' & nAlter;
}

// Check for quarter-tone accidentals
sQuarterAlter = '';
if ((nAlter = 0) and (Length(sName) > 1)) {
	sQuarterAlter = Substring(sName, 1, 1);
	if (sQuarterAlter = '-') {
		sAlter = '-0.5';
	} else {
		if (sQuarterAlter = '+') {
			sAlter = '0.5';
		}
	}
} else {
	if (((nAlter = 1) or (nAlter = -1)) and 
	    (Length(sName) > 2)) {
		sQuarterAlter = Substring(sName, 2, 1);
		if ((nAlter = -1) and (sQuarterAlter = '-')) {
			sAlter = '-1.5';
		} else {
			if ((nAlter = 1) and (sQuarterAlter = '+')) {
				sAlter = '1.5';
			}
		}
	}
}

// Use diatonic pitch so we get Cb correct.
nOctave = RoundDown(nDiatonicPitch / 7) - 1;

if (PercussionClef = StaffNumber) {
	// Handle built-in 1- to 4-line percussion staves.
	sPercussionStep = sStep;
	nPercussionOctave = nOctave;

	// If not 5-line, transpose to meet MusicXML definition.
	if (PercStaffLines < 5) {
		oPitch = CreateDictionary();
		oPitch['step'] = sStep;
		oPitch['octave'] = nOctave;
		TransposePercussion(oPitch);
		sPercussionStep = oPitch['step'];
		nPercussionOctave = oPitch['octave'];
	}
	WriteXML('<unpitched>', 4);
	WriteXML('<display-step>' & sPercussionStep & '</display-step>', 5);
	WriteXML('<display-octave>' & nPercussionOctave & '</display-octave>', 5);
	WriteXML('</unpitched>', 4);
} else {
	WriteXML('<pitch>', 4);
	WriteXML('<step>' & sStep & '</step>', 5);
	if (Length(sAlter) > 0) {
		WriteXML('<alter>' & sAlter & '</alter>', 5);
	}
	nOctave = CheckOctava(nOctave, StaffNumber);
	WriteXML('<octave>' & nOctave & '</octave>', 5);
	WriteXML('</pitch>', 4);
}

// Write the duration, unless it is a grace note.
if (not fGrace) {
	WriteXML('<duration>' & NoteRestDuration & '</duration>', 4);
}

// Is it tied? Do not add a tie element to a silent note.
if ((fStopTie or fTiedInto) and (not IsCue)) {
	WriteXML('<tie type=\'stop\'/>', 4);
}
if (ThisNote.Tied and (not IsCue)) {
	WriteXML('<tie type=\'start\'/>', 4);
}

// If we have multiple instruments, write the instrument element.
sInstrument = '' & CurrentPartInstrument[StaffNumber];
if (Length(sInstrument) > 0) {
	WriteXML('<instrument id=\'' & sInstrument & '\'/>', 4);
}

// If it is associated with just one voice 1-4, write that out.
if (Voice > 0) {
	WriteXML('<voice>' & Voice & '</voice>', 4);
}

// Check for bracketed (parenthesized) noteheads here, another
// feature added in Sibelius 5.
fBracketed = False;
if (ThisNote.Bracketed) {
	fBracketed = True;
}

// Write the symbolic type, as computed earlier for the NoteRest.
nBeams = WriteType(sSymbolSize);

// Write an accidental if possible - e.g. forced on.
// No accidentals on tab clef, but could be on percussion clef.
if (TabClef < 0) {
	WriteAccidental(ThisNote, sQuarterAlter);
}

// Write out the time-modification element as needed for
// tuplets and/or double-note tremolos.
if (not fGrace) {
	WriteTimeModification();
}

// Stem does not seem to be up/down, but rather flipped or not.
// So not doing the computation yet to figure out stem points.
// Stemweight, added in Sibelius 7, gives us direct access to
// this up/down information.

// Sibelius 3 added access to NoteStyles. Use here for noteheads
// and for stemless notes. The notehead element is also where
// we write out the bracketing in Sibelius 5 and later.

fStemless = False;
fNoteStyle = False;
if (ThisNote.NoteStyle > NormalNoteStyle) {
	fNoteStyle = True;
	// Even if we cannot determine stem direction, we
	// can tell if we're using a stemless note style.
	// Styles 26 and 27 are now standard in Sibelius but
	// do not yet have ManuScript constants.
	if ((ThisNote.NoteStyle = BeatWithoutStemNoteStyle) or
		 (ThisNote.NoteStyle = StemlessNoteStyle) or
		 (ThisNote.NoteStyle = 26) or (ThisNote.NoteStyle = 27)) {
		fStemless = True;
	}
}

if (ThisEntry.Duration < Whole) {
	if (fStemless) {
		WriteXML('<stem>none</stem>', 4);
	} else {
		// Stem weight lets us determine stem direction as of
		// Sibelius 7. We save this away for the whole NoteRest
		// in the WriteNoteRest method.
		if (Length(StemXml) > 0) {
			WriteXML('<stem>' & StemXml & '</stem>', 4);
		}
	}
}

if (fBracketed or fNoteStyle) {
	fIsOpen = (ThisEntry.Duration >= Half);
	// @todo Consider using level element for bracketed note.
	// Sibelius is bracketing the notehead, accidental, and
	// augmentation dot here, not just the notehead.
	WriteNotehead(ThisNote.NoteStyle, fIsOpen, fBracketed);
}

// Write the staff in a multi-staff part.
// Using StaffToWrite adds cross-staff support as of 2021.9.
if (StaffToWrite > 0) {
	WriteXML('<staff>' & StaffToWrite & '</staff>', 4);
}

// Write the beams if this is not a chord note.
// While the documentation in Sibelius 5.1 and
// earlier syas that they are supposed to match
// values 4, 5, 6, and 8 on the F10 keypad, the
// NoBeam value actually matches 9 rather than 6.
// Thus there is no reporting of an end beam; the
// ContinueBeam value is reported instead. Also
// note that in some cases, beams start with a
// ContinueBeam. This is reflected in the Sibelius
// keypad as well as being reported in ManuScript.
// We now use lookahead and look-behind checking to
// sort things out more accurately.
if ((not fIsChord) and (nBeams > 0) and (not fStemless)) {
	WriteBeams(ThisEntry, Voice, nBeams);
}

// Now handle any notations we may need.
WriteNotations(ThisEntry, ThisNote, StaffNumber, StaffToWrite, Voice, 
			   NoteRestDuration, NoteNumber, fStopTie);

// And lastly the lyrics.
WriteLyrics(ThisEntry, Voice, fIsChord);

// Set the tie stop for the next note.
fSetTieStop = ThisNote.Tied;
if (fSetTieStop and AtLeastSib20203) {
	if (ThisNote.LvTie) {
		fSetTieStop = False;
	}
}
if (fSetTieStop) {
	nTieStopPosition = nTiePosition + NoteRestDuration;
	// Need staff-specific voice number to disambiguate
	TieStartVoice[nTiePitch] = ThisEntry.VoiceNumber;
	// Account for tuplet roundoff errors
	if (nTieStopPosition >= ((ThisEntry.ParentBar.Length * 3) - 2)) {
		TieStopNextBar[nTiePitch] = nTieBar + 1;
		TieStopNextStaff[nTiePitch] = 0 + StaffNumber;
	} else {
		TieStopThisBar[nTiePitch] = nTieBar + 0;
		TieStopThisStaff[nTiePitch] = 0 + StaffNumber;
		TieStopThisPosition[nTiePitch] = nTieStopPosition;
	}
}	

// Finish the note - things like slurs come before notes.
WriteXML('</note>', 3);
}"
	WriteRest "(ThisEntry, StaffNumber, Voice, StaffToWrite) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Dx is in 1/32 of staff space. 
nRelativeX = Round(ThisEntry.Dx / 3.2);

// Check for a hidden rest.
sPrintObject = '';
sColor = '' & NoteRestColor;
if (ThisEntry.Hidden) {
	sPrintObject = ' print-object=\'no\'';
	sColor = '';
}

// Start the note.
if (nRelativeX = 0) {
	WriteXML('<note' & sPrintObject & sColor & '>', 3);
} else {
	WriteXML('<note' & sPrintObject & sColor & 
			  ' relative-x=\'' & nRelativeX & '\'>', 3);
}

// Is it a grace note?
fGrace = False;
if (ThisEntry.GraceNote) {
	fGrace = True;
	WriteXML('<grace/>', 4);
}

// Is it cue size?
sSymbolSize = '';
if (not fGrace) {
	if (ThisEntry.CueSize) {
		sSymbolSize = 'cue';
	}
}

// Write the rest.
WriteXML('<rest/>', 4);

// Write the duration, unless it is a grace note.
if (not fGrace) {
	WriteXML('<duration>' & NoteRestDuration & '</duration>', 4);
}

// If we have multiple instruments, write the instrument element.
sInstrument = '' & CurrentPartInstrument[StaffNumber];
if (Length(sInstrument) > 0) {
	WriteXML('<instrument id=\'' & sInstrument & '\'/>', 4);
}

// If it is associated with just one voice 1-4, write that out.
if (Voice > 0) {
	WriteXML('<voice>' & Voice & '</voice>', 4);
}

// Write the symbolic type as computed earlier for the NoteRest.
nBeams = WriteType(sSymbolSize);

// Write out the time-modification element for a tuplet if needed.
if (not fGrace) {
	WriteTimeModification();
}

// Stemlets are available since Sibelius 6, but we are not handling
// them yet. Log the error for now.
if (ThisEntry.HasStemlet) {
	LogError('Unexported stemlet', 4);
}

// Write the staff in a multi-staff part.
// Using StaffToWrite allows for cross-staff rests.
if (StaffToWrite > 0) {
	WriteXML('<staff>' & StaffToWrite & '</staff>', 4);
}

// Write out any notations we may need.
WriteNotations(ThisEntry, null, StaffNumber, StaffToWrite, Voice,
			   NoteRestDuration, False, False);

// And lastly the lyrics.
WriteLyrics(ThisEntry, Voice, False);

// Finish the note - things like slurs come before notes.
WriteXML('</note>', 3);
}"
	WriteType "(SymbolSize) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Write type and dots.

sSymbolSize = '';
if (Length(XmlType) > 0) {
	if (Length(SymbolSize) > 0) {
		sSymbolSize = ' size=\'' & SymbolSize & '\'';	
	}
	WriteXML('<type' & sSymbolSize & '>' & XmlType & '</type>', 4);
	for i = 0 to XmlDots {
		WriteXML('<dot/>', 4);
	}
}

// Return the number of possible beams for this entry.
return XmlBeams;
}"
	WriteText "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// If the whole thing is invisible, just return
if (IsNoText(BarObject, False, GetDisplayedPage(BarObject))) {
	return 0;
}

// For debugging with new text style IDs
if (ShowTrace) {
	trace('Found text style ' & BarObject.StyleId & ', initial font ' & 
		  BarObject.InitialFontName & ', string \'' &
	      BarObject.TextWithFormattingAsString & '\' in bar ' & 
	      BarObject.ParentBar.BarNumber & ', position ' & BarObject.Position);
}

// Split text into visible and invisible parts.
// Invisible parts are usually used for MIDI playback.
sText = '';
sHidden = '';
if (BarObject.Hidden) {
	sHidden = BarObject.Text;
	// Check for double-hidden text with a tilde start
	sHiddenFirst = Substring(BarObject.Text, 0, 1);
	if (sHiddenFirst = '~') {
		sHidden = Substring(BarObject.Text, 1);
	}
} else {
	sTextArray = SplitString(BarObject.Text, '~', False);
	sText = sTextArray[0];
	if (sTextArray.NumChildren = 2) {
		sHidden = sTextArray[1];
	}
}

nOffset = (BarObject.Position * 3) - MeasureCounter;

// If we have just the hidden portion, write it out
// as a sound element if possible.
if (Length(sText) = 0) {
	// Check to see if we have a hidden MIDI tempo mark.
	// If so, write it out as a sound element before returning.
	if (Length(sHidden) > 0) {
		nHiddenSound = GetTempo(sHidden);
		if (nHiddenSound > 0) {
			if (nOffset != 0) {
				WriteXML('<sound tempo=\'' & nHiddenSound & '\'>', 3);
				WriteXML('<offset>' & nOffset & '</offset>', 4);
				WriteXML('</sound>', 3);
			} else {
				WriteXML('<sound tempo=\'' & nHiddenSound & '\'/>', 3);
			}
		}
	}
	// Nothing else to export
	return 0;
}


// If we have a chord symbol, delegate to another
// function that writes a harmony if possible and
// a direction if not.
if (BarObject.StyleId = 'text.staff.space.chordsymbol') {
	WriteChordSymbolText(BarObject, StaffNumber, sText, False);
	return 0;
}

// Similarly for figured bass, but continue on if the
// delegated function did not write it as figured bass.
if (BarObject.StyleId = 'text.staff.space.figuredbass') {
	fFiguredBassOK = WriteFiguredBassText(BarObject);
	if (fFiguredBassOK) {
		return 0;
	}
}

// If we have a fingering, save it for a notation.
// Only do this if text is 0, 1, 2, 3, 4, or 5; otherwise
// treat as words.
// @todo Treat 2 - 1 or 2-1 etc. as fingering substitutions
// @todo Treat (5) as an alternate fingering
if (BarObject.StyleId = 'text.staff.space.fingering') {
	oFingeringText = BarObject.TextWithFormatting;
	fFingeringOK = True;
	nLineBreaks = 0;
	// See if everything is a valid fingering or a line break
	for i = 0 to oFingeringText.NumChildren {
		sFingeringText = '' & oFingeringText[i];
		if (Length(sFingeringText) = 1) {
			nFingering = Asc(CharAt(sFingeringText, 0));
			if ((nFingering < 48) or (nFingering > 53)) {
				fFingeringOK = False;
			}
		} else {
			if ((sFingeringText = '\\N\\') or (sFingeringText = '\\n\\')) {
				nLineBreaks = nLineBreaks + 1;
			} else {
				fFingeringOK = False;
			}
		}
	}

	// Now write out the fingering arrays
	nLineOffset = BarObject.InitialFontSize;
	if (nLineOffset <= 0) {
		nLineOffset = 48;
	}
	nDyOffset = nLineOffset * nLineBreaks;
	if (fFingeringOK) {
		for i = 0 to oFingeringText.NumChildren {
			// Go in reverse order to match bottom-to-top note ordering,
			// making it easier to match fingerings with notes.
			nTextIndex = oFingeringText.NumChildren - 1 - i;
			sFingeringText = '' & oFingeringText[nTextIndex];
			if (Length(sFingeringText) = 1) {
				nFingering = 0 + sFingeringText;
				Fingerings[FingeringCount] = '' & sFingeringText;
				FingeringPositions[FingeringCount] = 0 + BarObject.Position;
				// Fingering Dx is best interpreted as default-x vs. relative-x
				FingeringDx[FingeringCount] = 0 + BarObject.Dx;
				FingeringDy[FingeringCount] = 0 + BarObject.Dy - nDyOffset;
				FingeringWritten[FingeringCount] = False;
				FingeringVoices[FingeringCount] = GetVoice(BarObject, StaffNumber);
				FingeringCueSize[FingeringCount] = BarObject.CueSize;
				FingeringCount = FingeringCount + 1;
			} else {
				nDyOffset = nDyOffset - nLineOffset;
			}
		}
		return 0;
	}
}

sPlacement = GetPlacement(BarObject.Dy);
WriteXML('<direction' & sPlacement & '>', 3);
WriteXML('<direction-type>', 4);

// Now write out the actual direction content.
DirectionHasParen = False;
WriteTextDirectionContent(BarObject, False, '', GetDisplayedPage(BarObject));

WriteXML('</direction-type>', 4);

// Write the offset, level, voice, and staff if needed.
if (nOffset != 0) {
	WriteXML('<offset>' & nOffset & '</offset>', 4);
}
if (DirectionHasParen) {
	WriteXML('<level parentheses=\'yes\'/>', 4);
}
nVoice = GetVoice(BarObject, StaffNumber);
if ((nVoice > 0) and UseVoice) {
	WriteXML('<voice>' & nVoice & '</voice>', 4);
}
if (StaffNumber > 0) {
	WriteXML('<staff>' & StaffNumber & '</staff>', 4);
}

// If we have a hidden part, see if that is a tempo mark.
// If so, write out the appropriate sound element.
if (Length(sHidden) > 0) {
	nSound = GetTempo(sHidden);
	if (nSound > 0) {
		WriteXML('<sound tempo=\'' & nSound & '\'/>', 4);
	}
}

WriteXML('</direction>', 3);
}"
	MeasureCounter "0"
	WriteAdjust "(SibeliusPosition, XMLPosition, StaffNumber, ThisVoice) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Check for roundoff error within tuplets
fAdjust = True;
if (LastTupletPosition[ThisVoice] >= 0) {
	if (((SibeliusPosition - XMLPosition) < 4) and
	    ((SibeliusPosition - XMLPosition) > -4)) {
		fAdjust = False;
	}
}

if (fAdjust and (SibeliusPosition > XMLPosition)) {
	WriteXML('<forward>', 3);
	WriteXML('<duration>' & (SibeliusPosition - XMLPosition) & '</duration>', 4);
	if (ThisVoice > 0) {
		WriteXML('<voice>' & ThisVoice & '</voice>', 4);
	}
	if (StaffNumber > 0) {
		WriteXML('<staff>' & StaffNumber & '</staff>', 4);
	}
	WriteXML('</forward>', 3);
} else {
	if (fAdjust and (SibeliusPosition < XMLPosition)) {
		WriteXML('<backup>', 3);
		WriteXML('<duration>' & (XMLPosition - SibeliusPosition) & '</duration>', 4);
		WriteXML('</backup>', 3);
	}
}
}"
	WriteTimeSignature "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Do not write here - handled in WriteTime
x = 1;
}"
	WriteKeySignature "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Do not write here since it comes at end of previous measure.
x = 1;
}"
	WriteSpecialBarline "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Handled by WriteSystemBarline since we need to merge the
// barline and ending elements.

x = 1;
}"
	WriteArpeggioLine "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// If hidden, just return without doing any setup.
if (BarObject.Hidden) {
	return 0;
}

// Arpeggios do not have multiple levels, so store
// on a per-voice basis. No need to record staves
// as we output one staff at a time and have no
// way to determine cross-staff arpeggio lines.

nVoice = 0 + BarObject.VoiceNumber;
ArpeggioBars[nVoice] = 0 + BarCounter;
ArpeggioPositions[nVoice] = 0 + BarObject.Position;
ArpeggioColors[nVoice] = GetColor(BarObject);

// Add up or down based on style ID
switch (BarObject.StyleId) {
	case ('line.staff.arpeggio.up') {
		ArpeggioDirections[nVoice] = 'up';
	}
	case ('line.staff.arpeggio.down') {
		ArpeggioDirections[nVoice] = 'down';
	}
	default {
		ArpeggioDirections[nVoice] = '';
	}
}
}"
	WriteCrescendoLine "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// If hidden, just return without writing.
if (BarObject.Hidden) {
	return 0;
}

// Get the position based on object Dx and Dy properties.
sPosition = GetPosition(BarObject.Dx, BarObject.Dy, False);
sColor = GetColor(BarObject);

// Find the first open wedge
fNotDone = True;
nNumber = 1;
nStopBar = 0;
while (fNotDone) {
	nStopBar = WedgeStopBars[nNumber];
	if (nStopBar = 0) {
		fNotDone = False;
	} else {
		nNumber = nNumber + 1;
		if (nNumber > 16) {
			// Only 16 levels in MusicXML
			nNumber = 0;
			fNotDone = False;
		}
	}
}

// If nothing available, cannot write it.
if (nNumber = 0) {
	return False;
}

nOffset = (BarObject.Position * 3) - MeasureCounter;

// Check for a bracketed crescendo. A value of 28 gets us
// over the line.staff.hairpin.crescendo that starts the 
// builtin crescendo line styles.
fBracketed = False;
if (IndexOf('bracketed', BarObject.StyleId) >= 28) {
	fBracketed = True;
}

// Check for a crescendo from silence (niente).
sNiente = '';
if (IndexOf('fromsilence', BarObject.StyleId) >= 28) {
	sNiente = ' niente=\'yes\'';
}

sPlacement = GetPlacement(BarObject.Dy);
WriteXML('<direction' & sPlacement & '>', 3);
WriteXML('<direction-type>', 4);
WriteXML('<wedge type=\'crescendo\' number=\'' & nNumber & '\'' & 
		  sNiente & ' ' & sPosition & sColor & '/>', 5);
WriteXML('</direction-type>', 4);
if (nOffset != 0) {
	WriteXML('<offset>' & nOffset & '</offset>', 4);
}
if (BarObject.CueSize or fBracketed) {
	sLevel = '';
	if (BarObject.CueSize) {
		sLevel = ' size=\'cue\'';
	}
	if (fBracketed) {
		// The default formatting in many house styles is
		// parentheses rather than bracket. But even if it
		// is bracket, seems better to indicate something
		// rather than nothing.
		sLevel = sLevel & ' parentheses=\'yes\'';
	}
	WriteXML('<level' & sLevel & '/>', 4);
}
nVoice = GetVoice(BarObject, StaffNumber);
if (nVoice > 0) {
	WriteXML('<voice>' & nVoice & '</voice>', 4);
}
if (StaffNumber > 0) {
	WriteXML('<staff>' & StaffNumber & '</staff>', 4);
}
WriteXML('</direction>', 3);

// Now save the stop information in global arrays.
WedgeStopBars[nNumber] = 0 + BarObject.EndBarNumber;
WedgeStopNientes[nNumber] = '';
WedgeStopPositions[nNumber] = BarObject.EndPosition * 3;
WedgeStopStaffs[nNumber] = 0 + StaffNumber;
WedgeStopVoices[nNumber] = GetVoice(BarObject, StaffNumber);
if (BarObject.RhDy != BarObject.Dy) {
	WedgeStopYs[nNumber] = ' ' & GetPosition(BarObject.RhDx, BarObject.RhDy, False);
} else {
	WedgeStopYs[nNumber] = ' ' & GetXPosition(BarObject.RhDx, False);
}
WedgeStops = WedgeStops + 1;
DirectionStops = DirectionStops + 1;
}"
	WriteDiminuendoLine "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// If hidden, just return without writing.
if (BarObject.Hidden) {
	return 0;
}

// Get the position based on object Dx and Dy properties.
sPosition = GetPosition(BarObject.Dx, BarObject.Dy, False);
sColor = GetColor(BarObject);

// Find the first open wedge
fNotDone = True;
nNumber = 1;
nStopBar = 0;
while (fNotDone) {
	nStopBar = WedgeStopBars[nNumber];
	if (nStopBar = 0) {
		fNotDone = False;
	} else {
		nNumber = nNumber + 1;
		if (nNumber > 16) {
			// Only 16 levels in MusicXML
			nNumber = 0;
			fNotDone = False;
		}
	}
}

// If nothing available, cannot write it.
if (nNumber = 0) {
	return False;
}

nOffset = (BarObject.Position * 3) - MeasureCounter;

// Check for a bracketed diminuendo. A value of 29 gets us
// over the line.staff.hairpin.diminuendo that starts the 
// builtin diminuendo line styles.
fBracketed = False;
if (IndexOf('bracketed', BarObject.StyleId) >= 29) {
	fBracketed = True;
}

// Check for a diminuendo to silence (niente).
sNiente = '';
if (IndexOf('tosilence', BarObject.StyleId) >= 29) {
	sNiente = ' niente=\'yes\'';
}

sPlacement = GetPlacement(BarObject.Dy);
WriteXML('<direction' & sPlacement & '>', 3);
WriteXML('<direction-type>', 4);
WriteXML('<wedge type=\'diminuendo\' number=\'' & nNumber & '\' ' & 
		  sPosition & sColor & '/>', 5);
WriteXML('</direction-type>', 4);
if (nOffset != 0) {
	WriteXML('<offset>' & nOffset & '</offset>', 4);
}
if (BarObject.CueSize or fBracketed) {
	sLevel = '';
	if (BarObject.CueSize) {
		sLevel = ' size=\'cue\'';
	}
	if (fBracketed) {
		// The default formatting in many house styles is
		// parentheses rather than bracket. But even if it
		// is bracket, seems better to indicate something
		// rather than nothing.
		sLevel = sLevel & ' parentheses=\'yes\'';
	}
	WriteXML('<level' & sLevel & '/>', 4);
}
nVoice = GetVoice(BarObject, StaffNumber);
if (nVoice > 0) {
	WriteXML('<voice>' & nVoice & '</voice>', 4);
}
if (StaffNumber > 0) {
	WriteXML('<staff>' & StaffNumber & '</staff>', 4);
}
WriteXML('</direction>', 3);

// Now save the stop information in global arrays.
WedgeStopBars[nNumber] = 0 + BarObject.EndBarNumber;
WedgeStopNientes[nNumber] = '' & sNiente;
WedgeStopPositions[nNumber] = BarObject.EndPosition * 3;
WedgeStopStaffs[nNumber] = 0 + StaffNumber;
WedgeStopVoices[nNumber] = GetVoice(BarObject, StaffNumber);
if (BarObject.RhDy != BarObject.Dy) {
	WedgeStopYs[nNumber] = ' ' & GetPosition(BarObject.RhDx, BarObject.RhDy, False);
} else {
	WedgeStopYs[nNumber] = ' ' & GetXPosition(BarObject.RhDx, False);
}
WedgeStops = WedgeStops + 1;
DirectionStops = DirectionStops + 1;
}"
	WriteGlissandoLine "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// If hidden, just return without writing.
if (BarObject.Hidden) {
	return 0;
}

nBarCounter = 0 + BarCounter;

// For debugging
if (ShowTrace) {
	trace('Found glissando line with style ID ' & BarObject.StyleId &
	      ' (old style ' & BarObject.Style & '} in bar ' & 
	      BarObject.ParentBar.BarNumber & 
	      ', position ' & BarObject.Position & 
	      ', voice ' & BarObject.VoiceNumber);
}

for i = 1 to 17 {
    if (GlissandoStopBars[i] = 0) {
		GlissandoStartBars[i] = nBarCounter;
		GlissandoStartPositions[i] = 0 + BarObject.Position;
		GlissandoStopBars[i] = 0 + BarObject.EndBarNumber;
		GlissandoStopPositions[i] = 0 + BarObject.EndPosition;
		GlissandoVoices[i] = 0 + BarObject.VoiceNumber;
		GlissandoStaffs[i] = 0 + StaffNumber;
		GlissandoStyleIds[i] = '' & BarObject.StyleId;
		GlissandoColors[i] = GetColor(BarObject);
		GlissandoStartDy[i] = 0 + BarObject.Dy;
		// Do not output RhDx for note-attached glissando until
		// we can be sure that the glissando end position is
		// the same as the next note position. RhDx works
		// fine when we can save an offset too, but not here.
		// Same logic applies to start of glissando too.
		GlissandoStopDy[i] = 0 + BarObject.RhDy;
		GlissandoCounts = 1 + GlissandoCounts;
		if (ShowTrace) {
			trace('Glissando ' & i & ' saved in measure ' & MeasureNumbers[nBarCounter] & 
				  ', staff ' & GlissandoStaffs[i] &
				  ', Dy = ' & GlissandoStartDy[i] & ', RhDy = ' & GlissandoStopDy[i]);
		}
		return i;
    }
}

// If more than 16 glissando levels, give up and return 0.
LogError('Glissando not exported because all 16 levels already in use', 3);
if (ShowTrace) {
    trace('No room for glissando starting at bar ' & BarCounter & ', position ' & 
          BarObject.Position);
}
return 0;
}"
	WriteOctavaLine "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// If hidden, just return without writing.
if (BarObject.Hidden) {
	return 0;
}

// Get size and direction of octave shift.

sType = '';
sSize = '';
nAdd = 0;

// Use the style id strings for semantics.
switch (BarObject.StyleId) {
	case ('line.staff.octava.plus8') {
		sType = 'down';
		sSize = '' & '8';
		nAdd = 1;
	}
	case ('line.staff.octava.minus8') {
		sType = 'up';
		sSize = '' & '8';
		nAdd = -1;
	}
	case ('line.staff.octava.plus15') {
		sType = 'down';
		sSize = '15';
		nAdd = 2;
	}
	case ('line.staff.octava.minus15') {
		sType = 'up';
		sSize = '15';
		nAdd = -2;
	}
	default {
		if (ShowTrace) {
			trace('Found unrecognized octave line style id ' & BarObject.StyleId & 
			      ' (' & BarObject.StyleAsText & ') at part ' & PartCounter &
			      ', bar ' & MeasureCounter);
		}
	}
}

// Get the position based on object Dx and Dy properties.
sPosition = GetPosition(BarObject.Dx, BarObject.Dy, False);
sColor = GetColor(BarObject);

// Find the first open octave line
fNotDone = True;
nNumber = 1;
nStopBar = 0;
while (fNotDone) {
	nStopBar = 0 + OctaveStopBars[nNumber];
	if (nStopBar = 0) {
		fNotDone = False;
	} else {
		nNumber = nNumber + 1;
		if (nNumber > 16) {
			// Only 16 levels in MusicXML
			nNumber = 0;
			fNotDone = False;
		}
	}
}

// If nothing available, cannot write it.
if (Length(sType) = 0) {
	LogError('Unrecognized octave line style ' & BarObject.StyleId, 3);
	return False;
}
if (nNumber = 0) {
	LogError('Octava line not exported: cannot find number to use', 3);
	return False;
}

nOffset = (BarObject.Position * 3) - MeasureCounter;

WriteXML('<direction>', 3);
WriteXML('<direction-type>', 4);
WriteXML('<octave-shift type=\'' & sType & '\' size=\'' & sSize & 
		 '\' number=\'' & nNumber & '\' ' & sPosition & sColor & '/>', 5);
WriteXML('</direction-type>', 4);
if (nOffset != 0) {
	WriteXML('<offset>' & nOffset & '</offset>', 4);
}
if (BarObject.CueSize) {
	WriteXML('<level size=\'cue\'/>', 4);
}

// Skipping voice for octave-shift for now

if (StaffNumber > 0) {
	WriteXML('<staff>' & StaffNumber & '</staff>', 4);
}
WriteXML('</direction>', 3);

// Now save the stop information in global arrays.
OctaveStopBars[nNumber] = 0 + BarObject.EndBarNumber;
OctaveStopPositions[nNumber] = BarObject.EndPosition * 3;
OctaveStopStaffs[nNumber] = 0 + StaffNumber;
OctaveStopSizes[nNumber] = '' & sSize;
OctaveAdds[nNumber] = nAdd;
if (BarObject.RhDy != BarObject.Dy) {
	OctaveStopYs[nNumber] = ' ' & GetPosition(BarObject.RhDx, BarObject.RhDy, False);
} else {
	OctaveStopYs[nNumber] = ' ' & GetXPosition(BarObject.RhDx, False);
}
OctaveStops = OctaveStops + 1;
DirectionStops = DirectionStops + 1;
}"
	WritePedalLine "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// For debugging with new line style IDs
if (ShowTrace) {
	trace('Found pedal line style \'' & BarObject.StyleId &
	      '\' in bar ' & BarObject.ParentBar.BarNumber & 
	      ', position ' & BarObject.Position);
}

// If hidden, just return without writing.
if (BarObject.Hidden) {
	return 0;
}

// Get the position based on object Dx and Dy properties.
sPosition = ' ' & GetPosition(BarObject.Dx, BarObject.Dy, False);
sColor = GetColor(BarObject);

// Only one pedal per part. For now we will overwrite.
// if (PedalStopBar > 0) {
// 	return False;
// }

nOffset = (BarObject.Position * 3) - MeasureCounter;

// If we have one of the known pedal lines, record that
// here. Some pedal lines will only write the end of the
// line, not the beginning.
sPedalStyle = '' & BarObject.StyleId;
nStyleLength = Length(sPedalStyle);

// The line and type elements depend on the pedal line.
// Here are the defaults for an unrecognized pedal line.
sLine = '';
fStartDirection = True;
fSaveRhDy = False;
sStopType = 'stop';
sStopColor = '';
fUnrecognized = True;

// Now look for the built-in pedal line styles. Due to
// ManuScript string equality really being an initial 
// substring match, we need to match on string length
// as well as string contents.
// @todo Improve export for bracket/pedal line mix
switch (nStyleLength) {
	case (16) {
		if (sPedalStyle = 'line.staff.pedal') {
			sLine = ' line=\'yes\'';
			fUnrecognized = False;
		}
	}
	case (21) {
		if (sPedalStyle = 'line.staff.pedal.lift') {
			sLine = ' line=\'yes\'';
			sStopType = 'change';
			fUnrecognized = False;
		}
	}
	case (23) {
		if (sPedalStyle = 'line.staff.pedal.noline') {
			sLine = ' line=\'no\'';
			// Since it is not a line, we need to
			// save the color for the pedal stop.
			sStopColor = sColor;
			fSaveRhDy = True;
			fUnrecognized = False;
		}
	}
	case (27) {
		if (sPedalStyle = 'line.staff.pedal.lift.again') {
			// The previous pedal line will have ended
			// in a change type, so do not add a starting
			// pedal direction here.
			fStartDirection = False;
			sLine = ' line=\'yes\'';
			sStopType = 'change';
			fUnrecognized = False;
			// It seems better to export the right position
			// here, since this is where the vertical changes
			// can be recorded when multiple pedal lines
			// cross systems.
			// @todo Check that this does not cause new problems
			fSaveRhDy = True;
		}
	}
	case (29) {
		if (sPedalStyle = 'line.staff.pedal.lift.finally') {
			// The previous pedal line will have ended
			// in a change type, so do not add a starting
			// pedal direction here.
			fStartDirection = False;
			sLine = ' line=\'yes\'';
			fUnrecognized = False;
		}
	}
}

if (fStartDirection) {
	WriteXML('<direction>', 3);
	WriteXML('<direction-type>', 4);
	if (fUnrecognized) {
		LogError('Unrecognized pedal line style ' & sPedalStyle, 5); 
	}
	WriteXML('<pedal type=\'start\'' & sLine & sPosition & sColor & '/>', 5);
	WriteXML('</direction-type>', 4);
	if (nOffset != 0) {
		WriteXML('<offset>' & nOffset & '</offset>', 4);
	}
	if (BarObject.CueSize) {
		WriteXML('<level size=\'cue\'/>', 4);
	}
	// Skipping voice for pedal for now
	if (StaffNumber > 0) {
		WriteXML('<staff>' & StaffNumber & '</staff>', 4);
	}
	WriteXML('</direction>', 3);
}

// Now save the stop information in global variables.
PedalStopBar = 0 + BarObject.EndBarNumber;
PedalStopColor = '' & sStopColor;
PedalStopLine = '' & sLine;
PedalStopPosition = BarObject.EndPosition * 3;
PedalStopStaff = 0 + StaffNumber;
PedalStopType = '' & sStopType;
// Save RhDy when pedal is not a line. Otherwise we might be
// saving the difference between the top and bottom of the
// vertical line - which would be OK, but not in default-y.
if (fSaveRhDy) {
	PedalStopY = ' ' & GetPosition(BarObject.RhDx, BarObject.RhDy, False);
} else {
	PedalStopY = ' ' & GetXPosition(BarObject.RhDx, False);
}
PedalStops = 1;
DirectionStops = DirectionStops + 1;
}"
	WriteRepeatTimeLine "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Handled by WriteSystemBarline since we need to merge the
// barline and ending elements.

// !!! For debugging
// trace('Found repeat line ' & BarObject.StyleId & ' in bar ' &
//		BarObject.ParentBar.BarNumber);

// In Sibelius 4, several non-repeat barlines are getting reported
// as repeat barlines. Real repeat barlines have StyleIDs that begin
// with line.system.repeat. If that is not present, treat as a
// regular line instead of a repeat line.

if (Substring(BarObject.StyleId, 0, 18) != 'line.system.repeat') {
	WriteAnyLine(BarObject, StaffNumber, True);
}
}"
	WriteRitardLine "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

WriteAnyLine(BarObject, StaffNumber, True);
}"
	IsDuplicatingThisSlur "(Index1, Index2) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return True if the slurs at Index1 and Index2 are duplicates.

if (SlurStartBars[Index1] != SlurStartBars[Index2]) {
	return False;
}
if (SlurStartPositions[Index1] != SlurStartPositions[Index2]) {
	return False;
}
if (SlurStopBars[Index1] != SlurStopBars[Index2]) {
	return False;
}
if (SlurStopPositions[Index1] != SlurStopPositions[Index2]) {
	return False;
}
if (SlurStaffs[Index1] != SlurStaffs[Index2]) {
	return False;
}
if (SlurVoices[Index1] != SlurVoices[Index2]) {
	return False;
}
if (SlurStyleIds[Index1] != SlurStyleIds[Index2]) {
	return False;
}
if (SlurColors[Index1] != SlurColors[Index2]) {
	return False;
}
if (SlurStartDx[Index1] != SlurStartDx[Index2]) {
	return False;
}
if (SlurStartDy[Index1] != SlurStartDy[Index2]) {
	return False;
}
if (SlurStopDx[Index1] != SlurStopDx[Index2]) {
	return False;
}
if (SlurStopDy[Index1] != SlurStopDy[Index2]) {
	return False;
}
return True;
}"
	RemoveDuplicateSlurs "(SlurIndex, SlurStarts, SlurStops) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// To check for duplicate slurs we have to look ahead,
// not back. Remove any duplicate slurs found later on
// from SlurIndex. Return the number of duplicate slurs 
// removed.

nSlursRemoved = 0;
nSlursChecked = 0;
nOriginalSlurCounts = 0 + SlurCounts;
for i = (SlurIndex + 1) to 17 {
	if (SlurCounts < 2) {
		return nSlursRemoved;
	}
	if (SlurStartBars[i] > 0) {
		if (IsDuplicatingThisSlur(SlurIndex, i)) {
			SlurStarts[i] = False;
			SlurStops[i] = False;
			SlurStartBars[i] = 0;
			SlurStopBars[i] = 0;
			SlurCounts = SlurCounts - 1;
			nSlursRemoved = nSlursRemoved + 1;
		}
		nSlursChecked = nSlursChecked + 1;
		if ((nSlursChecked + 1) >= nOriginalSlurCounts) {
			return nSlursRemoved;
		}
	}
}
return nSlursRemoved;
}"
	WriteSlur "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// If hidden, just return without writing.
if (BarObject.Hidden) {
	return 0;
}

nBarCounter = 0 + BarCounter;

// For debugging
if (ShowTrace) {
	trace('Found slur line style \'' & BarObject.StyleId &
	      '\' (text ' & BarObject.StyleAsText & ') in bar ' & 
	      BarObject.ParentBar.BarNumber & 
	      ', position ' & BarObject.Position & ', dx = ' & BarObject.Dx);
}

for i = 1 to 17 {
    if (SlurStopBars[i] = 0) {
		SlurStartBars[i] = nBarCounter;
		SlurStartDx[i] = 0 + BarObject.Dx;
		SlurStartDy[i] = 0 + BarObject.Dy;
		SlurStartPositions[i] = 0 + BarObject.Position;
		SlurStopBars[i] = 0 + BarObject.EndBarNumber;
		SlurStopDx[i] = 0 + BarObject.RhDx;
		SlurStopDy[i] = 0 + BarObject.RhDy;
		SlurStopPositions[i] = 0 + BarObject.EndPosition;
		SlurVoices[i] = 0 + BarObject.VoiceNumber;
		SlurStaffs[i] = 0 + StaffNumber;
		SlurStyleIds[i] = '' & BarObject.StyleId;
		SlurColors[i] = GetColor(BarObject);
		SlurCounts = 1 + SlurCounts;
		if (ShowTrace) {
			trace('Slur ' & i & ' saved in measure ' & MeasureNumbers[nBarCounter] & 
					', staff ' & SlurStaffs[i] &
					', Dy = ' & SlurStartDy[i] & ', RhDy = ' & SlurStopDy[i]);
		}
		return i;
    }
}

// If more than 16 slur levels, give up and return 0.
if (ShowTrace) {
    trace('No room for slur starting at bar ' & BarCounter & ', position ' & 
          BarObject.Position);
}
LogError('Slur not exported because all 16 levels already in use', 3);
return 0;
}"
	WriteTrill "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// If hidden, just return without writing.
if (BarObject.Hidden) {
	return 0;
}

nBarCounter = 0 + BarCounter;

// For debugging
if (ShowTrace) {
	trace('Found trill line with style ID ' & BarObject.StyleId &
	      ' (old style ' & BarObject.Style & '} in bar ' & 
	      BarObject.ParentBar.BarNumber & 
	      ', position ' & BarObject.Position & 
	      ', voice ' & BarObject.VoiceNumber);
}

for i = 1 to 17 {
    if (TrillStopBars[i] = 0) {
		TrillStartBars[i] = nBarCounter;
		TrillStartPositions[i] = 0 + BarObject.Position;
		TrillStopBars[i] = 0 + BarObject.EndBarNumber;
		TrillStopPositions[i] = 0 + BarObject.EndPosition;
		TrillVoices[i] = 0 + BarObject.VoiceNumber;
		TrillStaffs[i] = 0 + StaffNumber;
		TrillColors[i] = GetColor(BarObject);
		TrillStartDx[i] = 0 + BarObject.Dx;
		TrillStartDy[i] = 0 + BarObject.Dy;
		TrillStopDx[i] = 0 + BarObject.RhDx;
		TrillStopDy[i] = 0 + BarObject.RhDy;
		TrillCounts = 1 + TrillCounts;
		return i;
    }
}

// If more than 16 trill levels, give up and return 0.
LogError('Trill not exported because all 16 levels already in use', 3);
if (ShowTrace) {
    trace('No room for trill starting at bar ' & BarCounter & ', position ' & 
          BarObject.Position);
}
return 0;
}"
	WriteBox "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Boxes on their own do not have any direct MusicXML counterpart,
// so do not export them.
if (ShowTrace) {
	trace('Found box with style ID ' & BarObject.StyleId & ' (' &
	      BarObject.StyleAsText & ') in bar ' & BarObject.ParentBar.BarNumber & 
	      ', position ' & BarObject.Position);
}

// Cannot write it, so log the error
LogError('Unexported box', 3);
}"
	WriteGuitarFrame "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// If hidden, just return without writing.
if (BarObject.Hidden) {
	return 0;
}

// @todo See if we need to consider hidden via ~
// If the whole thing is invisible, just return
if (Length(BarObject.ChordNameAsStyledString) = 0) {
	return 0;
}

// !!! For debugging
//  oDebugSuffixes = BarObject.CopyOutSuffixes();
//	sSuffixString = ', suffix count = ' & oDebugSuffixes.NumChildren;
//	for i = 0 to oDebugSuffixes.NumChildren {
//		sSuffixString = sSuffixString & ', suffix[' & i & '] = ' & oDebugSuffixes[i];
//	}
//	trace('Chord name = \'' & BarObject.ChordNameAsPlainText & 
//		  	'\', recognized = ' & BarObject.Recognized & sSuffixString);

// !!! For debugging
// trace('Chord name plain text = \'' & BarObject.ChordNameAsPlainText &
//		'\', styled string = \'' & BarObject.ChordNameAsStyledString &
//		'\', root = \'' &
//		BarObject.RootAsString & '\', suffix = \'' & BarObject.SuffixText & 
//		'\', bass = \'' & BarObject.BassAsString & '\'');

// First try to write out based on the semantics of the recognized
// chord symbol. If the chord is not recognized, delegate to a
// common routine for both legacy chord symbol text and guitar frame
// chord names.
fShowFrame = BarObject.FrameIsVisible;
fRecognized = BarObject.Recognized;
if (fRecognized) {
	fOK = WriteChordSymbolFrame(BarObject, StaffNumber);
	if (not fOK) {
		WriteChordSymbolText(BarObject, StaffNumber,
							 BarObject.ChordNameAsStyledString, fShowFrame);
	}
} else {
	WriteChordSymbolText(BarObject, StaffNumber,
						 BarObject.ChordNameAsStyledString, fShowFrame);
}
}"
	WriteTransposition "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

if (ShowTrace) {
	trace('Found transposition in bar ' & BarObject.ParentBar.BarNumber & 
	      ', position ' & BarObject.Position);
}

// We cannot handle this, so log the error
LogError('Unexported transposition', 3);
}"
	WriteRehearsalMark "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// If hidden, just return without writing.
if (BarObject.Hidden) {
	return 0;
}

// Sibelius 4 lets us access the contents of a rehearsal mark.
// Since they are found on the system staff only, just assume
// they go above; do not try to figure out x and y position.

nOffset = (BarObject.Position * 3) - MeasureCounter;
sColor = GetColor(BarObject);
nBarCounter = 0 + BarCounter;

if (SystemStaffDone[nBarCounter]) {
	WriteXML('<direction placement=\'above\' system=\'also-top\'>', 3);
} else {
	WriteXML('<direction placement=\'above\' system=\'only-top\'>', 3);
}
WriteXML('<direction-type>', 4);
WriteXML('<rehearsal' & sColor & '>' & 
		  ToXmlText(BarObject.MarkAsText) & '</rehearsal>', 5);
WriteXML('</direction-type>', 4);
if (nOffset != 0) {
	WriteXML('<offset>' & nOffset & '</offset>', 4);
}
if (BarObject.CueSize) {
	WriteXML('<level size=\'cue\'/>', 4);
}
if (StaffNumber > 0) {
	WriteXML('<staff>' & StaffNumber & '</staff>', 4);
}
WriteXML('</direction>', 3);
}"
	WriteGraphic "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

if (ShowTrace) {
	trace('Found graphic in bar ' & BarObject.ParentBar.BarNumber & 
	      ', position ' & BarObject.Position);
}

// Cannot write it, so log the error
LogError('Unexported graphic', 3);
}"
	WriteBarline "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

if (ShowTrace) {
	trace('Found barline in bar ' & BarObject.ParentBar.BarNumber & 
	      ', position ' & BarObject.Position);
}
}"
	ParseClefStyleId "(ClefName, Chromatic, UseChromatic) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// In Sibelius, the octave clefs do not affect
// playback; that is a function of transposition
// contained in the instrument type definition.
// So only write out a clef-octave-change element
// if the octave change in the clef matches an
// exact octave transposition in the instrument
// type. Only search for built-in clef names.
// When writing a for-part element, this exact matching
// does not matter. The UseChromatic parameter lets us
// turn it off in that case.

sSign = '';
nLine = 0;
nOctaveChange = 0;

nChromatic = 0 + Chromatic;
fAlwaysOctave = (not UseChromatic);
fCheckOctave = (fAlwaysOctave or (nChromatic != 0));

if (Substring(ClefName, 5, 6) = 'treble') {
	sSign = '' & 'G';
	nLine = 2;
	if (fCheckOctave and (Length(ClefName) > 12)) { 
		if (Substring(ClefName, 12, 6) = 'down.8') {
			if (fAlwaysOctave or (nChromatic = -12)) {
				nOctaveChange = -1;
			}
		} else {
			if (Substring(ClefName, 12, 4) = 'up.8') {
				if (fAlwaysOctave or (nChromatic = 12)) {
					nOctaveChange = 1;
				}
			} else {
				if (Substring(ClefName, 12, 5) = 'up.15') {
					if (fAlwaysOctave or (nChromatic = 24)) {
						nOctaveChange = 2;
					}
				}
			}
		}
	}  
} else {
	if (Substring(ClefName, 5, 4) = 'bass') {
		sSign = '' & 'F';
		nLine = 4;
		if (fCheckOctave and (Length(ClefName) > 10)) { 
			if (Substring(ClefName, 10, 6) = 'down.8') {
				if (fAlwaysOctave or (nChromatic = -12)) {
					nOctaveChange = -1;
				}
			} else {
				if (Substring(ClefName, 10, 4) = 'up.8') {
					if (fAlwaysOctave or (nChromatic = 12)) {
						nOctaveChange = 1;
					}
				} else {
					if (Substring(ClefName, 10, 5) = 'up.15') {
						if (fAlwaysOctave or (nChromatic = 24)) {
							nOctaveChange = 2;
						}
					}
				}
			}
		}  
	} else {
		if (Substring(ClefName, 5, 3) = 'tab') {
			sSign = 'TAB';
		} else {
			if (Substring(ClefName, 5, 10) = 'percussion') {
				sSign = 'percussion';
			} else {
				if (Substring(ClefName, 5, 5) = 'tenor') {
					sSign = '' & 'C';
					nLine = 4;
					if (fCheckOctave and (Length(ClefName) > 11)) { 
						if (Substring(ClefName, 11, 6) = 'down.8') {
							if (fAlwaysOctave or (nChromatic = -12)) {
								nOctaveChange = -1;
							}
						}
					}  
				} else {
					switch (ClefName) {
						case ('clef.alto') {
							sSign = '' & 'C';
							nLine = 3;
						}
						case ('clef.baritone.c') {
							sSign = '' & 'C';
							nLine = 5;
						}
						case ('clef.baritone.f') {
							sSign = '' & 'F';
							nLine = 3;
						}
						case ('clef.soprano.mezzo') {
							sSign = '' & 'C';
							nLine = 2;
						}
						case ('clef.soprano') {
							sSign = '' & 'C';
							nLine = 1;
						}
						case ('clef.violin.french') {
							sSign = '' & 'G';
							nLine = 1;
						}
						case ('clef.sub-bass.f') {
							sSign = '' & 'F';
							nLine = 5;
						}
						case ('clef.null') {
							sSign = 'none';
						}
					}
				}
			}
		}
	}
}

// Create the dictionary of parsed data and return
oDictClefData = CreateDictionary('sign', sSign, 'line', nLine,
								 'clef-octave-change', nOctaveChange);
return oDictClefData;
}"
	WriteClefStyle "(ClefName, StaffNumber, InstrumentType, BarNumber, Position) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

nChromatic = 0;
if (InstrumentType != null) {
	if (UseTranspose) {
		nChromatic = InstrumentType.ChromaticTransposition;
	} else {
		nChromatic = InstrumentType.ChromaticTranspositionInScore;
	}
}

oDictClefData = ParseClefStyleId(ClefName, nChromatic, True);
sSign = oDictClefData['sign'];
nLine = oDictClefData['line'];
nOctaveChange = oDictClefData['clef-octave-change'];

if (sSign = 'TAB') {
	TabClef = 0 + StaffNumber;
} else {
	if (sSign = 'percussion') {
		PercussionClef = 0 + StaffNumber;
	}
}

// Always use actual staff number for saving and comparison, 
// vs. using 0 to indicate a single-staff part.
nStaffNumber = 0 + StaffNumber;
if (nStaffNumber <= 0) {
	nStaffNumber = 1;
}

// Now write out. If we do not recognize the clef, we
// need to write something in the sign since we are midway
// through, so substitute G clef and warn about it.
if (Length(sSign) = 0) {
	LogError('Unknown clef style ' & ClefName & ', using G clef', 5);
	sSign = '' & 'G';
}
WriteXML('<sign>' & sSign & '</sign>', 5);
if (nLine != 0) {
	WriteXML('<line>' & nLine & '</line>', 5);
}
if ((nOctaveChange != 0) or (nOctaveChange != LastClefOctaveChange[nStaffNumber])) {
	WriteXML('<clef-octave-change>' & nOctaveChange & 
			 '</clef-octave-change>', 5);
}

// Save the MusicXML clef data in global variables.
LastClefBar[nStaffNumber] = 0 + BarNumber;
LastClefPosition[nStaffNumber] = 0 + Position;
LastClefSign[nStaffNumber] = '' & sSign;
LastClefLine[nStaffNumber] = nLine;
LastClefOctaveChange[nStaffNumber] = nOctaveChange;
WrittenDiatonicPitchOK = (nOctaveChange = 0);
}"
	WriteLyricItem "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// MIDI import can put lyrics in voice 0 rather than
// the correct voice, so correct for that. Those lyrics
// also are getting syllable type set to 0, which means
// middle of word, but they are treated in Sibelius as
// if end of word. So always use end of word for lyrics
// in voice 0. This may get reset later when we check
// for hyphens in MIDI lyrics.
nVoice = GetLyricVoice(BarObject, StaffNumber);
sLyricText = ToXmlText(BarObject.Text);
nSyllableType = BarObject.SyllableType;
if (BarObject.VoiceNumber = 0) {
	nSyllableType = EndOfWord;
}

// Imports from PhotoScore and MIDI can have hyphen characters
// at the end of syllables rather than Sibelius lyric hyphens.
// There used to be a plug-in to help clean this up, but it was
// limited to single voice / single lyric line situations, and
// does not yet work with Sibelius 6. So do the correction here
// since this will result in much better MusicXML semantics in
// most cases.
if ((nSyllableType = EndOfWord) and 
	(Substring(sLyricText, Length(sLyricText) - 1, 1) = '-')) {
	nSyllableType = MiddleOfWord;
	sLyricText = Substring(sLyricText, 0, Length(sLyricText) - 1);
}

// Slack for lyric Dy comparison
nLyricSlack = 4;
nNumeric = 0;

// Record whether these lyrics are hidden or not. We
// export hidden lyrics in cases where all lyrics in
// a given note are hidden.
fHidden = BarObject.Hidden;
if (not fHidden) {
	AnyVisibleLyric[nVoice] = True;
}
sColor = GetColor(BarObject);

// Starting with Sibelius 4, lyrics have style IDs consistently.

// If we have multiple lyrics on a single note, separate
// them using a hard space elision. Also handle mixes of
// hidden and visible in an elision
fAddElision = False;
fOnlyNewHidden = False;
fOnlyOldHidden = False;

// For moving unnumbered / conflicting lyrics out of the way
sUnnumberedText = '';
nUnnumberedType = 0;
nUnnumberedNotes = 0;
nUnnumberedDx = 0;
nUnnumberedDy = 0;
nUnnumberedPosition = 0;
fUnnumberedHidden = False;
sUnnumberedColor = '';

switch (BarObject.StyleId) {
	case ('text.staff.space.hypen.lyrics.verse1') {
		if (VerseMax[nVoice] < 1) {
			VerseMax[nVoice] = 1;
		}
		// If there is already text here, it may be from an
		// unnumbered lyric, or it could be due to an elision.
		// If they have the same or very close Dy, then use 
		// the elision. Otherwise bump to the next unused lyric
		// if possible.
		if (Length(Verse1Text[nVoice]) > 0) {
			nNumeric = Verse1Dy[nVoice] - BarObject.Dy;
			if (MathAbs(nNumeric) <= nLyricSlack) {
				fAddElision = True;
				// Handle a mix of hidden and visible in the same voice.
				// If the new lyric is hidden, ignore it. If the old lyric
				// is hidden, replace it with the new lyric instead of
				// eliding it, and turn the hidden array value off.
				if (fHidden and (not Verse1Hidden[nVoice])) {
					fOnlyNewHidden = True;
				} else {
					if ((not fHidden) and Verse1Hidden[nVoice]) {
						fOnlyOldHidden = True;
					}
				}
			} else {
				sUnnumberedText = '' & Verse1Text[nVoice];
				nUnnumberedType = Verse1Type[nVoice];
				nUnnumberedNotes = Verse1Notes[nVoice];
				nUnnumberedDx = Verse1Dx[nVoice];
				nUnnumberedDy = Verse1Dy[nVoice];
				nUnnumberedPosition = Verse1Positions[nVoice];
				fUnnumberedHidden = Verse1Hidden[nVoice];
				sUnnumberedColor = '' & Verse1Color[nVoice];
			}
		}
		if (fAddElision) {
			// Ignore a hidden new syllable if the old one was visible.
			if (not fOnlyNewHidden) {
				if (fOnlyOldHidden) {
					// Replace the old hidden syllable rather than eliding.
					Verse1Text[nVoice] = '' & sLyricText;
					Verse1Hidden[nVoice] = False;
					Verse1Dx[nVoice] = 0 + BarObject.Dx;
					Verse1Dy[nVoice] = 0 + BarObject.Dy;
					Verse1Positions[nVoice] = 0 + BarObject.Position;
				} else {
					Verse1Text[nVoice] =
						Verse1Text[nVoice] & HardSpace & sLyricText;
				}
				Verse1Type[nVoice] = nSyllableType;
				Verse1Notes[nVoice] = BarObject.NumNotes;
			}
		} else {
			Verse1Text[nVoice] = '' & sLyricText;
			Verse1Type[nVoice] = nSyllableType;
			Verse1Notes[nVoice] = 0 + BarObject.NumNotes;
			Verse1Dx[nVoice] = 0 + BarObject.Dx;
			Verse1Dy[nVoice] = 0 + BarObject.Dy;
			Verse1Positions[nVoice] = 0 + BarObject.Position;
			Verse1Hidden[nVoice] = fHidden;
			Verse1Color[nVoice] = '' & sColor;
		}
	}
	case ('text.staff.space.hypen.lyrics.verse2') {
		if (VerseMax[nVoice] < 2) {
			VerseMax[nVoice] = 2;
		}
		if (Length(Verse2Text[nVoice]) > 0) {
			nNumeric = Verse2Dy[nVoice] - BarObject.Dy;
			if (MathAbs(nNumeric) <= nLyricSlack) {
				fAddElision = True;
				if (fHidden and (not Verse2Hidden[nVoice])) {
					fOnlyNewHidden = True;
				} else {
					if ((not fHidden) and Verse2Hidden[nVoice]) {
						fOnlyOldHidden = True;
					}
				}
			} else {
				sUnnumberedText = '' & Verse2Text[nVoice];
				nUnnumberedType = Verse2Type[nVoice];
				nUnnumberedNotes = Verse2Notes[nVoice];
				nUnnumberedDx = Verse2Dx[nVoice];
				nUnnumberedDy = Verse2Dy[nVoice];
				nUnnumberedPosition = Verse2Positions[nVoice];
				fUnnumberedHidden = Verse2Hidden[nVoice];
				sUnnumberedColor = '' & Verse2Color[nVoice];
			}
		}
		if (fAddElision) {
			// Ignore a hidden new syllable if the old one was visible.
			if (not fOnlyNewHidden) {
				if (fOnlyOldHidden) {
					// Replace the old hidden syllable rather than eliding.
					Verse2Text[nVoice] = '' & sLyricText;
					Verse2Hidden[nVoice] = False;
					Verse2Dx[nVoice] = 0 + BarObject.Dx;
					Verse2Dy[nVoice] = 0 + BarObject.Dy;
					Verse2Positions[nVoice] = 0 + BarObject.Position;
				} else {
					Verse2Text[nVoice] =
						Verse2Text[nVoice] & HardSpace & sLyricText;
				}
				Verse2Type[nVoice] = nSyllableType;
				Verse2Notes[nVoice] = 0 + BarObject.NumNotes;
			}
		} else {
			Verse2Text[nVoice] = '' & sLyricText;
			Verse2Type[nVoice] = nSyllableType;
			Verse2Notes[nVoice] = 0 + BarObject.NumNotes;
			Verse2Dx[nVoice] = 0 + BarObject.Dx;
			Verse2Dy[nVoice] = 0 + BarObject.Dy;
			Verse2Positions[nVoice] = 0 + BarObject.Position;
			Verse2Hidden[nVoice] = fHidden;
			Verse2Color[nVoice] = '' & sColor;
		}
	}
	case ('text.staff.space.hypen.lyrics.verse3') {
		if (Length(Verse3Text[nVoice]) > 0) {
			nNumeric = Verse3Dy[nVoice] - BarObject.Dy;
			if (MathAbs(nNumeric) <= nLyricSlack) {
				fAddElision = True;
				if (fHidden and (not Verse3Hidden[nVoice])) {
					fOnlyNewHidden = True;
				} else {
					if ((not fHidden) and Verse3Hidden[nVoice]) {
						fOnlyOldHidden = True;
					}
				}
			} else {
				sUnnumberedText = '' & Verse3Text[nVoice];
				nUnnumberedType = Verse3Type[nVoice];
				nUnnumberedNotes = Verse3Notes[nVoice];
				nUnnumberedDx = Verse3Dx[nVoice];
				nUnnumberedDy = Verse3Dy[nVoice];
				nUnnumberedPosition = Verse3Positions[nVoice];
				fUnnumberedHidden = Verse3Hidden[nVoice];
				sUnnumberedColor = '' & Verse3Color[nVoice];
			}
		}
		if (fAddElision) {
			// Ignore a hidden new syllable if the old one was visible.
			if (not fOnlyNewHidden) {
				if (fOnlyOldHidden) {
					// Replace the old hidden syllable rather than eliding.
					Verse3Text[nVoice] = '' & sLyricText;
					Verse3Hidden[nVoice] = False;
					Verse3Dx[nVoice] = 0 + BarObject.Dx;
					Verse3Dy[nVoice] = 0 + BarObject.Dy;
					Verse3Positions[nVoice] = 0 + BarObject.Position;
				} else {
					Verse3Text[nVoice] =
						Verse3Text[nVoice] & HardSpace & sLyricText;
				}
				Verse3Type[nVoice] = nSyllableType;
				Verse3Notes[nVoice] = 0 + BarObject.NumNotes;
			}
		} else {
			Verse3Text[nVoice] = '' & sLyricText;
			Verse3Type[nVoice] = nSyllableType;
			Verse3Notes[nVoice] = 0 + BarObject.NumNotes;
			Verse3Dx[nVoice] = 0 + BarObject.Dx;
			Verse3Dy[nVoice] = 0 + BarObject.Dy;
			Verse3Positions[nVoice] = 0 + BarObject.Position;
			Verse3Hidden[nVoice] = fHidden;
			Verse3Color[nVoice] = '' & sColor;
		}
	}
	case ('text.staff.space.hypen.lyrics.verse4') {
		if (VerseMax[nVoice] < 4) {
			VerseMax[nVoice] = 4;
		}
		if (Length(Verse4Text[nVoice]) > 0) {
			nNumeric = Verse4Dy[nVoice] - BarObject.Dy;
			if (MathAbs(nNumeric) <= nLyricSlack) {
				fAddElision = True;
				if (fHidden and (not Verse4Hidden[nVoice])) {
					fOnlyNewHidden = True;
				} else {
					if ((not fHidden) and Verse4Hidden[nVoice]) {
						fOnlyOldHidden = True;
					}
				}
			} else {
				sUnnumberedText = '' & Verse4Text[nVoice];
				nUnnumberedType = Verse4Type[nVoice];
				nUnnumberedNotes = Verse4Notes[nVoice];
				nUnnumberedDx = Verse4Dx[nVoice];
				nUnnumberedDy = Verse4Dy[nVoice];
				nUnnumberedPosition = Verse4Positions[nVoice];
				fUnnumberedHidden = Verse4Hidden[nVoice];
				sUnnumberedColor = '' & Verse4Color[nVoice];
			}
		}
		if (fAddElision) {
			// Ignore a hidden new syllable if the old one was visible.
			if (not fOnlyNewHidden) {
				if (fOnlyOldHidden) {
					// Replace the old hidden syllable rather than eliding.
					Verse4Text[nVoice] = '' & sLyricText;
					Verse4Hidden[nVoice] = False;
					Verse4Dx[nVoice] = 0 + BarObject.Dx;
					Verse4Dy[nVoice] = 0 + BarObject.Dy;
					Verse4Positions[nVoice] = 0 + BarObject.Position;
				} else {
					Verse4Text[nVoice] =
						Verse4Text[nVoice] & HardSpace & sLyricText;
				}
				Verse4Type[nVoice] = nSyllableType;
				Verse4Notes[nVoice] = 0 + BarObject.NumNotes;
			}
		} else {
			Verse4Text[nVoice] = '' & sLyricText;
			Verse4Type[nVoice] = nSyllableType;
			Verse4Notes[nVoice] = 0 + BarObject.NumNotes;
			Verse4Dx[nVoice] = 0 + BarObject.Dx;
			Verse4Dy[nVoice] = 0 + BarObject.Dy;
			Verse4Positions[nVoice] = 0 + BarObject.Position;
			Verse4Hidden[nVoice] = fHidden;
			Verse4Color[nVoice] = '' & sColor;
		}
	}
	case ('text.staff.space.hypen.lyrics.verse5') {
		if (VerseMax[nVoice] < 5) {
			VerseMax[nVoice] = 5;
		}
		if (Length(Verse5Text[nVoice]) > 0) {
			nNumeric = Verse5Dy[nVoice] - BarObject.Dy;
			if (MathAbs(nNumeric) <= nLyricSlack) {
				fAddElision = True;
				if (fHidden and (not Verse5Hidden[nVoice])) {
					fOnlyNewHidden = True;
				} else {
					if ((not fHidden) and Verse5Hidden[nVoice]) {
						fOnlyOldHidden = True;
					}
				}
			} else {
				sUnnumberedText = '' & Verse5Text[nVoice];
				nUnnumberedType = Verse5Type[nVoice];
				nUnnumberedNotes = Verse5Notes[nVoice];
				nUnnumberedDx = Verse5Dx[nVoice];
				nUnnumberedDy = Verse5Dy[nVoice];
				nUnnumberedPosition = Verse5Positions[nVoice];
				fUnnumberedHidden = Verse5Hidden[nVoice];
				sUnnumberedColor = '' & Verse5Color[nVoice];
			}
		}
		if (fAddElision) {
			// Ignore a hidden new syllable if the old one was visible.
			if (not fOnlyNewHidden) {
				if (fOnlyOldHidden) {
					// Replace the old hidden syllable rather than eliding.
					Verse5Text[nVoice] = '' & sLyricText;
					Verse5Hidden[nVoice] = False;
					Verse5Dx[nVoice] = 0 + BarObject.Dx;
					Verse5Dy[nVoice] = 0 + BarObject.Dy;
					Verse5Positions[nVoice] = 0 + BarObject.Position;
				} else {
					Verse5Text[nVoice] =
						Verse5Text[nVoice] & HardSpace & sLyricText;
				}
				Verse5Type[nVoice] = nSyllableType;
				Verse5Notes[nVoice] = 0 + BarObject.NumNotes;
			}
		} else {
			Verse5Text[nVoice] = '' & sLyricText;
			Verse5Type[nVoice] = nSyllableType;
			Verse5Notes[nVoice] = 0 + BarObject.NumNotes;
			Verse5Dx[nVoice] = 0 + BarObject.Dx;
			Verse5Dy[nVoice] = 0 + BarObject.Dy;
			Verse5Positions[nVoice] = 0 + BarObject.Position;
			Verse5Hidden[nVoice] = fHidden;
			Verse5Color[nVoice] = '' & sColor;
		}
	}
	case ('text.staff.space.hypen.lyrics.chorus') {
		if (Length(ChorusText[nVoice]) > 0) {
			ChorusText[nVoice] =
				ChorusText[nVoice] & HardSpace & sLyricText;
			ChorusType[nVoice] = nSyllableType;
			ChorusNotes[nVoice] = 0 + BarObject.NumNotes;
		} else {
			ChorusText[nVoice] = '' & sLyricText;
			ChorusType[nVoice] = nSyllableType;
			ChorusNotes[nVoice] = 0 + BarObject.NumNotes;
			ChorusDx[nVoice] = 0 + BarObject.Dx;
			ChorusDy[nVoice] = 0 + BarObject.Dy;
			ChorusPositions[nVoice] = 0 + BarObject.Position;
			ChorusHidden[nVoice] = fHidden;
			ChorusColor[nVoice] = '' & sColor;
		}
	}
	case ('text.staff.space.hypen.lyrics.above') {
		if (Length(AboveText[nVoice]) > 0) {
			AboveText[nVoice] =
				AboveText[nVoice] & HardSpace & sLyricText;
			AboveType[nVoice] = nSyllableType;
			AboveNotes[nVoice] = 0 + BarObject.NumNotes;
		} else {
			AboveText[nVoice] = '' & sLyricText;
			AboveType[nVoice] = nSyllableType;
			AboveNotes[nVoice] = 0 + BarObject.NumNotes;
			AboveDx[nVoice] = 0 + BarObject.Dx;
			AboveDy[nVoice] = 0 + BarObject.Dy;
			AbovePositions[nVoice] = 0 + BarObject.Position;
			AboveHidden[nVoice] = fHidden;
			AboveColor[nVoice] = '' & sColor;
		}
	}
	default {
		sThisStyle = BarObject.StyleAsText;
		sLastChar = Substring(sThisStyle, Length(sThisStyle) - 1);
		nLastChar = 0;
		switch (sLastChar) {
			case ('1') {
				nLastChar = 1;
			}
			case ('2') {
				nLastChar = 2;
			}
			case ('3') {
				nLastChar = 3;
			}
			case ('4') {
				nLastChar = 4;
			}
			case ('5') {
				nLastChar = 5;
			}
		}
		AddUnnumberedLyric(sLyricText, nSyllableType, nLastChar,
						   BarObject.NumNotes, BarObject.Dx, BarObject.Dy,
						   BarObject.Position, fHidden, sColor, nVoice);
	}
}

// Now that we have written the current lyric, bump the old one down if needed.
if (Length(sUnnumberedText) > 0) {
	AddUnnumberedLyric(sUnnumberedText, nUnnumberedType, 0, nUnnumberedNotes,
					   nUnnumberedDx, nUnnumberedDy, nUnnumberedPosition,
					   fUnnumberedHidden, sUnnumberedColor, nVoice);
}
}"
	ProgressCurrent "0"
	ProgressMax "0"
	UserContinue "True"
	ScoreBarCount "0"
	InitializeSystemStaff "(ThisScore) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

oSystemStaff = ThisScore.SystemStaff;

// Create an array that indicates how many system staff
// items there are in each bar. Also collect metadata
// from the score vs. the score info. What is on the
// page tends to be more accurate that what is in the
// metadata.

ScoreBarCount = ThisScore.NthStaff(1).BarCount;
Self._property:SystemStaffCount = CreateSparseArray();
Self._property:SystemStaffDone = CreateSparseArray();

// With Sibelius 5, we have external bar number strings
// that serve as the basis for better measure numbering.
// We also have access to multimeasure rests
Self._property:MeasureNumbers = CreateSparseArray();
Self._property:MeasureImplicit = CreateSparseArray();
Self._property:MeasureTexts = CreateSparseArray();
Self._property:MultiRest = CreateSparseArray();
sLastMeasureNumber = '';
nLastImplicit = 0;
nLastMultiRest = 0;

// With Sibelius 6, we have access to whether a bar
// starts a new page or system without requiring the
// format be locked first.
Self._property:MeasureNewPage = CreateSparseArray();
Self._property:MeasureNewSystem = CreateSparseArray();
// OnNthPage and OnNthSystem are 0-based. OnNthSystem
// is per-page, so the first system on each page is 0.
nLastPage = 0;
nLastSystem = 0;
nPickup = 0;
fLine1 = False;
fLine2 = False;
fLine3 = False;

for i = 1 to ScoreBarCount + 1 {
	SystemStaffCount[i] = 0;
	SystemStaffDone[i] = False;
	oBar = oSystemStaff.NthBar(i);

	// We used to do limited pickup bar check, but now
	// we can check three types of implicit measure numbers:
	// measure numbers with a value of 0, blank measure 
	// numbers, and measure numbers that equal the previous 
	// measure number, as happens when measures are set to 
	// not be counted.
	MeasureTexts[i] = '' & oBar.ExternalBarNumberString;
	MeasureNumbers[i] = '' & (i + nPickup);
	MeasureImplicit[i] = '';

	if ((oBar.ExternalBarNumberString = sLastMeasureNumber) or
		 ((Length(oBar.ExternalBarNumberString) = 1) and (oBar.ExternalBarNumberString = '0')) or
		 (oBar.ExternalBarNumberString = '')) {
		MeasureImplicit[i] = 'yes';
		nLastImplicit = nLastImplicit + 1;
		if (i > 1) {
			MeasureNumbers[i] = 'X' & nLastImplicit;
		} else {
			MeasureNumbers[i] = '' & '0';
			nPickup = 1;
		}
	}

	sLastMeasureNumber = oBar.ExternalBarNumberString;

	if (i < 3) {
		if ((i = 1) or ((i = 2) and (nPickup = 1))) {
			nExternal = GetNonNegativeInteger(sLastMeasureNumber);
			if ((nExternal > 0) and (nExternal != i)) {
				nPickup = nExternal - i;
				MeasureNumbers[i] = '' & nExternal;
			}
		}
	}

	// Check for multi-measure rests.
	// @todo See if this really works on system staff
	if (oBar.InMultirest != NoMultirest) {
		switch (oBar.InMultirest) {
			case (StartsMultirest) {
				nLastMultiRest = i;
				MultiRest[nLastMultiRest] = 1;
			}
			case (EndsMultirest) {
				if (nLastMultiRest > 0) {
					MultiRest[nLastMultiRest] = 1 + MultiRest[nLastMultiRest];	
				}
				nLastMultiRest = 0;
			}
			case (MidMultirest) {
				if (nLastMultiRest > 0) {
					MultiRest[nLastMultiRest] = 1 + MultiRest[nLastMultiRest];	
				}
			}
		}
	}

	// Check for new page and system
	MeasureNewPage[i] = False;
	MeasureNewSystem[i] = False;
	if (oBar.OnNthPage != nLastPage) {
		MeasureNewPage[i] = True;
		nLastPage = oBar.OnNthPage;
		fNewPage = True;
	}
	if (oBar.OnNthSystem != nLastSystem) {
		// Do not print a new system if we already have a new page.
		if (not MeasureNewPage[i]) {
			MeasureNewSystem[i] = True;
		}
		nLastSystem = oBar.OnNthSystem;
	}

	// Now loop through each system object in the bar. If we have
	// duplicates for any field, let the first one win.
	for each oBarObject in oBar {
		SystemStaffCount[i] = SystemStaffCount[i] + 1;
		if (oBarObject.Type = 'SystemTextItem') {
			if (ShowTrace) {
				trace('System text style ' & oBarObject.StyleId &
					  ', Dx = ' & oBarObject.Dx & ', Dy = ' & oBarObject.Dy & ', text = \'' &
					  oBarObject.TextWithFormattingAsString & '\'');
			}
			if ((Substring(oBarObject.StyleId, 0, 25) = 'text.system.page_aligned.') or
				(oBarObject.OnNthBlankPage != 0)) {			
				
				// Add page-aligned and blank page system text items to a global
				// sparse array so we can write out credits later. We no longer
				// restrict credit export to just blank pages, but not all blank
				// page text has a page-aligned name (e.g. text.blankpage.title).
				Self.PageAlignedItems.Push(oBarObject);
				
				// Now look for metadata on the score which is likely to be more
				// accurate than the metadata fields. While any text could have
				// the score info substitutions, in practice it is unlikely
				// outside of page-aligned system text, so just look here.
				// Only use the built-ins here that go on the same page,
				// not user-defined or title page versions.

				sSubstitutedText =
					ScoreInfoSubstitute(oBarObject, GetDisplayedPage(oBarObject));
				switch (oBarObject.StyleId) {
					case ('text.system.page_aligned.title') {
						if (Length(Title) = 0) { 
							Title = '' & sSubstitutedText;
						}
					}
					case ('text.system.page_aligned.composer') {
						if (Length(Composer) = 0) {
							Composer = '' & sSubstitutedText;
						}
					}
					case ('text.system.page_aligned.lyricist') {
						if (Length(Lyricist) = 0) {
							Lyricist = '' & sSubstitutedText;
						}
					}
					case ('text.system.page_aligned.copyright') {
						if (Length(Copyright) = 0) {
							Copyright = '' & sSubstitutedText;
						}
					}
				}
				
				// Compute number of lines in above-music credits on page 1
				// if we need to increase the top-system-distance value.
				if ((i = 1) and (oBar.NumBlankPagesBefore = 0) and
					(not (ThisScore.DocumentSetup.FirstPageHasUniqueVerticalStaveMargins))) {
					sStyleId = oBarObject.StyleId;
					nUser = IndexOf('.user', sStyleId);
					if (nUser > 0) {
						sStyleId = Substring(sStyleId, 0, nUser);
					}	
					switch (sStyleId) {
						case ('text.system.page_aligned.title') {
							fLine1 = True;
						}
						case ('text.system.page_aligned.subtitle') {
							fLine2 = True;
						}
						case ('text.system.page_aligned.finale.left') {
							fLine2 = True;
						}
						case ('text.system.page_aligned.finale.right') {
							fLine2 = True;
						}
						case ('text.system.page_aligned.finale.center') {
							fLine2 = True;
						}
						case ('text.system.page_aligned.finale.centered') {
							fLine2 = True;
						}
						case ('text.system.page_aligned.composer') {
							fLine3 = True;
						}
						case ('text.system.page_aligned.dedication') {
							fLine3 = True;
						}
						case ('text.system.page_aligned.lyricist') {
							fLine3 = True;
						}
					}	
				}
			}
		}
	}
	// Count number of lines for increasing top-system-distance.
	nLines = 0;
	if (fLine1) {
		nLines = nLines + 1;
	}
	if (fLine2) {
		nLines = nLines + 1;
	}
	if (fLine3) {
		nLines = nLines + 1;
	}
	if (nLines > 0) {
		// For now, use 1 staff height for each line of text.
		// As we see how this works we can tweak the scaling.
		InitialTopSystemDistanceAddition = 40 * nLines;
	}
	
	// If we have no system staff objects in this bar, we are done.
	if (SystemStaffCount[i] = 0) {
		SystemStaffDone[i] = True;
	}
}
}"
	WriteSystemTextItem "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// For now, supporting tempo, metronome, repeats, and rehearsal marks.

// Do not bother with anything that has no text, and do not
// re-export a credit.

if ((IsNoText(BarObject, False, GetDisplayedPage(BarObject))) or 
	(Substring(BarObject.StyleId, 0, 25) = 'text.system.page_aligned.') or
	(BarObject.OnNthBlankPage != 0)) {			
	return 0;
}

// For debugging with new text style IDs
if (ShowTrace) {
	trace('Found system text item style ' & BarObject.StyleId & ' \'' &
	      BarObject.TextWithFormattingAsString & '\' in bar ' & 
	      BarObject.ParentBar.BarNumber & ', position ' & BarObject.Position &
		  ', dx = ' & BarObject.Dx & ', dy = ' & BarObject.Dy);
}

fStyleOK = False;
fBelow = False;
fMetronome = False;
fMetadata = False;
fDirective = False;
nBarCounter = 0 + BarCounter;
fRepeat = False;

// Unified handling of metronome marks, including
// user-defined marks. Switch statements used to
// match on initial substrings, but no longer.
if ((StartsWith('text.system.tempo', BarObject.StyleId)) or
	 (StartsWith('text.system.metronome', BarObject.StyleId)) or
	 (StartsWith('text.system.metricmodulation', BarObject.StyleId))) {

	// Metronome marks have their own method. Tempo marks
	// use it too, to check for combined tempo/metronome directions.
	// Metric modulations use it too, using the new MusicXML 2.0
	// features for swing tempo marks. If we cannot parse the
	// text as a metronome mark, try again as a regular system
	// text direction.

	fMetronome = WriteMetronomeMark(BarObject, StaffNumber);
	if (not fMetronome) {
		fStyleOK = True;
		if ((BarCounter = 1) and (BarObject.Position = 0)) {
			fDirective = True;
		}
	}
} else {
	// Check to see if we support this type of text.
	// Do not support blank page text styles, as those
	// should be credits.

	sStyleId = BarObject.StyleId;
	nUser = IndexOf('.user', sStyleId);
	if (nUser > 0) {
		sStyleId = Substring(sStyleId, 0, nUser);
	}
	
	switch (sStyleId) {
		case ('text.system.rehearsalmarks') {
			fStyleOK = True;
		}
		case ('text.system.boxed') {
			fStyleOK = True;
		}
		case ('text.system.plain') {
			fStyleOK = True;
		}
		case ('text.system.structure') {
			fStyleOK = True;
		}
		case ('text.system.repeat') {
			fStyleOK = True;
			fRepeat = True;
		}
		case ('text.system.timecode') {
			fStyleOK = True;
		}
		case ('text.system.timecode.duration') {
			fStyleOK = True;
		}
		case ('text.system.timecode.hitpoints') {
			fStyleOK = True;
		}
		case ('text.staff.lyrics.block') {
			// Despite the style name, block lyrics are system text.
			// Put them below instead of above like most system text.
			fStyleOK = True;
			fBelow = True;
		}
		case ('text.staff.technique') {
			// Sibelius 7 seems to be confused here, but export anyway.
			fStyleOK = True;
		}
		default {
			// Export user-defined system text styles, like variants of tempo style
			if (Substring(BarObject.StyleId, 0, 16) = 'text.system.user') {
				fStyleOK = True;
			} else {
				// The period got dropped in Sibelius 7.1.2
				if (Substring(BarObject.StyleId, 0, 15) = 'text.systemuser') {
					fStyleOK = True;
				}
			}
		}
	}
}

if (fStyleOK) {
	// Split text into visible and invisible parts.
	// Invisible parts are usually used for MIDI playback.
	sText = '';
	sHidden = '';
	if (BarObject.Hidden) {
		sHidden = BarObject.Text;
		// Check for double-hidden text with a tilde start
		sHiddenFirst = Substring(BarObject.Text, 0, 1);
		if (sHiddenFirst = '~') {
			sHidden = Substring(BarObject.Text, 1);
		}
	} else {
		sTextArray = SplitString(BarObject.Text, '~', False);
		sText = sTextArray[0];
		if (sTextArray.NumChildren = 2) {
			sHidden = sTextArray[1];
		}
	}

	nOffset = (BarObject.Position * 3) - MeasureCounter;

	// If we have just the hidden portion, write it out
	// as a sound element if possible.
	if (Length(sText) = 0) {
		// Check to see if we have a hidden MIDI tempo mark.
		// If so, write it out as a sound element before returning.
		if (Length(sHidden) > 0) {
			nHiddenSound = GetTempo(sHidden);
			if (nHiddenSound > 0) {
				if (nOffset != 0) {
					WriteXML('<sound tempo=\'' & nHiddenSound & '\'>', 3);
					WriteXML('<offset>' & nOffset & '</offset>', 4);
					WriteXML('</sound>', 3);
				} else {
					WriteXML('<sound tempo=\'' & nHiddenSound & '\'/>', 3);
				}
			}
		}
		// Nothing else to export
		return 0;
	}

	// System text usually is above by default.
	sAtributes = '';
	if (fBelow) {
		sAttributes = ' placement=\'below\'';
	} else {
		sAttributes = ' placement=\'above\'';
	}
	if (fDirective) {
		sAttributes = sAttributes & ' directive=\'yes\'';
	}
	if (SystemStaffDone[nBarCounter]) {
		sAttributes = sAttributes & ' system=\'also-top\''; 
	} else {
		sAttributes = sAttributes & ' system=\'only-top\'';
	}
	WriteXML('<direction' & sAttributes & '>', 3);
	WriteXML('<direction-type>', 4);
	
	// Now write the actual text, checking for text styles, new lines,
	// and other new features added in Sibelius 5.
	WriteTextDirectionContent(BarObject, True, '', GetDisplayedPage(BarObject));

	WriteXML('</direction-type>', 4);
	if (nOffset != 0) {
		WriteXML('<offset>' & nOffset & '</offset>', 4);
	}
	if (StaffNumber > 0) {
		WriteXML('<staff>' & StaffNumber & '</staff>', 4);
	}
	
	// Check for repeat playback
	sSound = '';
	if (fRepeat) {
		sSound = sSound & GetRepeatPlayback(BarObject);
	}

	// If we have a hidden part, see if that is a tempo mark.
	// If so, write out the appropriate sound element.
	if (Length(sHidden) > 0) {
		nSound = GetTempo(sHidden);
		if (nSound > 0) {
			sSound = sSound & ' tempo=\'' & nSound & '\'';
		}
	}
	if (Length(sSound) > 0) {
		WriteXML('<sound' & sSound & '/>', 4);
	}
	WriteXML('</direction>', 3);
} else {
	// If we do not recognize it but everything is hidden,
	// just return.
	if (IsNoText(BarObject, True, GetDisplayedPage(BarObject))) {
		return 0;
	}

	// If we do not recognize the style and it was not a metronome
	// mark or metadata element, log the missing export error.
	if ((not fMetronome) and (not fMetadata)) {
		sReportText = ScoreInfoSubstitute(BarObject, GetDisplayedPage(BarObject));
		LogError('Unrecognized system text style ' & BarObject.StyleId &
				 ': ' & sReportText, 3);
	}
}
}"
	LeftBarline
	RightBarline
	InitializeBarlines "(ThisScore, MeasureNumber, InitializeEndings, FirstEndingWins) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// For now, all we look for in the system staff are the special
// barlines (time signatures are handled elsewhere). Barline
// internal types start at 0, so initialize our constants
// to -1 rather than 0.

LeftBarline = -1;
LeftBarlineColor = '';
RightBarline = -1;
RightBarlineColor = '';
fInitializeEndings = InitializeEndings;
if (fInitializeEndings and (not (LeftEndingBumped = 1))) {
	LeftEnding = '';
	LeftEndingColor = '';
	LeftEndingBar = 0;
}
if (SystemStaffCount[MeasureNumber] > 0) {
	oSystemBar = ThisScore.SystemStaff.NthBar(MeasureNumber);
	for each oBarObject in oSystemBar {
		if (oBarObject.Type = 'SpecialBarline') {
			if (oBarObject.Position = 0) {
				LeftBarline = 0 + oBarObject.BarlineInternalType;
				LeftBarlineColor = GetColor(oBarObject);
			} else {
				// Not yet handling mid-measure barlines
				if (oBarObject.Position = oSystemBar.Length) {
					RightBarline = 0 + oBarObject.BarlineInternalType;
					RightBarlineColor = GetColor(oBarObject);
				}
			}
		} else {
			// Some lines are being reported incorrectly as RepeatTimeLine types,
			// so check the StyleId too.
			if (fInitializeEndings and (oBarObject.Type = 'RepeatTimeLine') and 
				(Substring(oBarObject.StyleId, 0, 19) = 'line.system.repeat.')) {
				// For debugging
				if (ShowTrace) {
					oEndSystemBar = ThisScore.SystemStaff.NthBar(oBarObject.EndBarNumber);
					trace('Found RepeatTimeLine in bar ' & MeasureNumber & 
						  ', position ' & oBarObject.Position & ' of ' & oSystemBar.Length & 
						  ', StyleId = ' & oBarObject.StyleId & 
						  ', StyleAsText = ' & oBarObject.StyleAsText & 
						  ', ending bar = ' & oBarObject.EndBarNumber & 
						  ', position ' & oBarObject.EndPosition & ' of ' & oEndSystemBar.Length);
				}
				LeftEndingBar = 0 + MeasureNumber;
				LeftEndingColor = GetColor(oBarObject);
				LeftEndingBumped = 0;
				RightEndingBar = 0 + oBarObject.EndBarNumber;

				// We can have quantization errors, especially when the start of a 2nd ending
				// is reported at the end of the previous measure vs. the start of the correct
				// measure. Check for that and adjust if needed. Also check for the opposite
				// problem where the end of the 1st ending is reported one bar too late.
				if (oBarObject.Position > (oSystemBar.Length - ThirtySecond)) {
					LeftEndingBar = LeftEndingBar + 1;
					LeftEndingBumped = 1;
				}
				if ((oBarObject.EndPosition = 0) and (RightEndingBar > LeftEndingBar)) {
					RightEndingBar = RightEndingBar - 1;
				}

				switch (oBarObject.StyleId) {
					case ('line.system.repeat.1st_n_2nd') {
						LeftEnding = '1, 2';
						RightEndingType = 'stop';
						UnknownEnding = False;
					}
					case ('line.system.repeat.1st') {
						LeftEnding = '' & '1';
						RightEndingType = 'stop';
						UnknownEnding = False;
					}
					case ('line.system.repeat.2nd.closed') {
						LeftEnding = '' & '2';
						RightEndingType = 'stop';
						UnknownEnding = False;
					}
					case ('line.system.repeat.2nd') {
						LeftEnding = '' & '2';
						RightEndingType = 'discontinue';
						UnknownEnding = False;
					}
					case ('line.system.repeat.3rd') {
						LeftEnding = '' & '3';
						RightEndingType = 'discontinue';
						UnknownEnding = False;
					}
					case ('line.system.repeat.closed') {
						LeftEnding = '';
						RightEndingType = 'stop';
						UnknownEnding = False;
					}
					case ('line.system.repeat.open') {
						LeftEnding = '';
						RightEndingType = 'discontinue';
						UnknownEnding = False;
					}
					default {
						// If we previously had an unknown ending,
						// treat this like an open ending. Otherwise,
						// treat like a closed ending.
						// Booleans are tricky for globals; use 0 and 1 instead.
						
						// We used to have LeftEnding as blank, but now
						// we try to get data from the GetPlayedOnNthPass 
						// data for better custom repeat barline support.
						// We also do not blank out color like we did before.

						LeftEnding = GetPlaySequence(oBarObject);
						// LeftEnding = '';
						// LeftEndingColor = '';
						if (UnknownEnding) {
							RightEndingType = 'discontinue';
							UnknownEnding = False;
						} else {
							RightEndingType = 'stop';
							UnknownEnding = True;
						}
					}
				}
				RightEnding = '' & LeftEnding;

				// If this is a one-bar ending, do not have a second
				// ending from the next bar that is accidentally starting
				// one bar earlier zap anything here the first time through.
				// The second time through, we do want it to override.
				if ((RightEndingBar = MeasureNumber) and FirstEndingWins) {
					fInitializeEndings = False;
				}
			}
		}
	}
}
}"
	WriteKey "(StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// StaffNumber is provided in case we want to write
// per-staff key signatures in the future, but is
// ignored for now.

// Write out the key signature element based on
// global variable settings.

WriteXML('<key>', 4);
if (CancelKey != 0) {
	if (LastKeyFifths != 0) {
		WriteXML('<cancel>' & LastKeyFifths & '</cancel>', 5);
	}
}
WriteXML('<fifths>' & KeyFifths & '</fifths>', 5);
if (Length(KeyMode) > 0) {
	WriteXML('<mode>' & KeyMode & '</mode>', 5);
}
WriteXML('</key>', 4);

// Save the data for comparisons later
LastKeyFifths = 0 + KeyFifths;
LastKeyMode = '' & KeyMode;
}"
	WriteTime "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Staff number is provided for consistency with other
// write methods, but is ignored here.

// Sibelius 4 lets us distinguish common and cut time symbols.
// Some scores just report a C or c rather than the ManuScript constants.
sCut = '' & 'C';
sCommon = '' & 'c';
sPrintObject = '';
if (BarObject.Hidden) {
	sPrintObject = ' print-object=\'no\'';
}

sTimeText = '';
if ((BarObject.Text = CommonTimeString) or (BarObject.Text = sCommon)) {
	WriteXML('<time' & sPrintObject & ' symbol=\'common\'>', 4);
} else {
	if ((BarObject.Text = AllaBreveTimeString) or (BarObject.Text = sCut)) {
		WriteXML('<time' & sPrintObject & ' symbol=\'cut\'>', 4);
	} else {
		WriteXML('<time' & sPrintObject & '>', 4);
	}
	sTimeText = '' & BarObject.Text;
	// !!! For debugging
	if (ShowTrace) {
		trace('Time sig ' & BarObject.Numerator & '/' & BarObject.Denominator &
			  ', text = \'' & sTimeText & '\'');
	}
}

// Handle the simplest type of composite time,
// additive numerator over a single denominator.
sNumerator = '' & BarObject.Numerator;
if (IndexOf('+', sTimeText) > 0) {
	sTimeTexts = SplitString(sTimeText, '\\', False);
	if (sTimeTexts.NumChildren = 3) {
		if ((Length(sTimeTexts[1]) = 1) and (sTimeTexts[1] = 'n' or sTimeTexts[1] = 'N')) {
			sDenominator = '' & sTimeTexts[2];
			if (sDenominator = ('' & BarObject.Denominator)) {
				sNewNumerator = '' & sTimeTexts[0];
				if (IndexOf('+', sNewNumerator) > 0) {
					sNumerator = sNewNumerator;
				}
			}
		}
	}
}

WriteXML('<beats>' & sNumerator & '</beats>', 5);
WriteXML('<beat-type>' & BarObject.Denominator & '</beat-type>', 5);
WriteXML('</time>', 4);

// How long is an entire bar in divisions?
// MeasureDuration = (768 * BarObject.Numerator * 4) / BarObject.Denominator;
}"
	XmlBarStyles
	WriteTimeModification "() {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Write out the time-modification element based on global values
// that are set on a per-NoteRest basis. This method is called
// for each note or rest in a NoteRest.

if ((TimeModActualNotes > 0) and (TimeModNormalNotes > 0)) {
    WriteXML('<time-modification>', 4);
    WriteXML('<actual-notes>' & TimeModActualNotes & '</actual-notes>', 5);
    WriteXML('<normal-notes>' & TimeModNormalNotes & '</normal-notes>', 5);
	
	// Only write the normal-type and normal-dots if different from
	// the type and dots of the current NoteRest.

	if ((XmlType != TimeModNormalType) or (XmlDots != TimeModNormalDots)) {
		if (Length(TimeModNormalType) > 0) {
			WriteXML('<normal-type>' & TimeModNormalType & '</normal-type>', 5);
			for i = 0 to TimeModNormalDots {
				WriteXML('<normal-dot/>', 5);
			}
		}
	}
    WriteXML('</time-modification>', 4);
}
}"
	GetType "(ThisDuration, TypeOutput) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return type, dots, and possible beams in the output array.
TypeOutput[TypeDataType] = '';
TypeOutput[TypeDataDots] = 0;
TypeOutput[TypeDataBeams] = 0;

nDuration = 0 + ThisDuration;
if (nDuration >= Quarter) {
  TypeOutput[TypeDataBeams] = 0;
  if (nDuration < Half) {
    TypeOutput[TypeDataType] = 'quarter';
    if (nDuration >= DottedQuarter) {
      TypeOutput[TypeDataDots] = 1;
      if (nDuration >= (DottedQuarter + Sixteenth)) {
        TypeOutput[TypeDataDots] = 2;
        if (nDuration >= (DottedQuarter + DottedSixteenth)) {
          TypeOutput[TypeDataDots] = 3;
          if (nDuration >= (DottedQuarter + DottedSixteenth + SixtyFourth)) {
            TypeOutput[TypeDataDots] = 4;
          }
        }
      }
    }
  } else {
    if (nDuration < Whole) {
      TypeOutput[TypeDataType] = 'half';
      if (nDuration >= DottedHalf) {
        TypeOutput[TypeDataDots] = 1;
        if (nDuration >= (DottedHalf + Eighth)) {
          TypeOutput[TypeDataDots] = 2;
          if (nDuration >= (DottedHalf + DottedEighth)) {
            TypeOutput[TypeDataDots] = 3;
            if (nDuration >= (DottedHalf + DottedEighth + ThirtySecond)) {
              TypeOutput[TypeDataDots] = 4;
            }
          }
        }
      }
    } else {
      if (nDuration < Breve) {
        TypeOutput[TypeDataType] = 'whole';
        if (nDuration >= DottedWhole) {
          TypeOutput[TypeDataDots] = 1;
          if (nDuration >= (DottedWhole + Quarter)) {
            TypeOutput[TypeDataDots] = 2;
            if (nDuration >= (DottedWhole + DottedQuarter)) {
              TypeOutput[TypeDataDots] = 3;
              if (nDuration >= (DottedWhole + DottedQuarter + Sixteenth)) {
                TypeOutput[TypeDataDots] = 4;
              }
            }
          }
        }
      } else {
        if (nDuration < Long) {
          TypeOutput[TypeDataType] = 'breve';
          if (nDuration >= DottedBreve) {
            TypeOutput[TypeDataDots] = 1;
            if (nDuration >= (DottedBreve + Half)) {
              TypeOutput[TypeDataDots] = 2;
              if (nDuration >= (DottedBreve + DottedHalf)) {
                TypeOutput[TypeDataDots] = 3;
                if (nDuration >= (DottedBreve + DottedHalf + Eighth)) {
                  TypeOutput[TypeDataDots] = 4;
                }
              }
            }
          }
        } else {
          if (nDuration < (Long + Long)) {
            TypeOutput[TypeDataType] = 'long';
            if (nDuration >= (Long + Breve)) {
              TypeOutput[TypeDataDots] = 1;
              if (nDuration >= (Long + DottedBreve)) {
                TypeOutput[TypeDataDots] = 2;
                if (nDuration >= (Long + DottedBreve + Half)) {
                  TypeOutput[TypeDataDots] = 3;
                  if (nDuration >= (Long + DottedBreve + DottedHalf)) {
                    TypeOutput[TypeDataDots] = 4;
                  }
                }
              }
            }
          } else {
            TypeOutput[TypeDataType] = 'maxima';
          }
        }
      }
    }
  }
} else {
  if (nDuration >= Eighth) {
    TypeOutput[TypeDataBeams] = 1;
    TypeOutput[TypeDataType] = 'eighth';
    if (nDuration >= DottedEighth) {
      TypeOutput[TypeDataDots] = 1;
      if (nDuration >= (DottedEighth + ThirtySecond)) {
        TypeOutput[TypeDataDots] = 2;
        if (nDuration >= (DottedEighth + DottedThirtySecond)) {
          TypeOutput[TypeDataDots] = 3;
        }
      }
    }
  } else {
    if (nDuration >= Sixteenth) {
      TypeOutput[TypeDataBeams] = 2;
      TypeOutput[TypeDataType] = '16th';
      if (nDuration >= DottedSixteenth) {
        TypeOutput[TypeDataDots] = 1;
        if (nDuration >= (DottedSixteenth + SixtyFourth)) {
          TypeOutput[TypeDataDots] = 2;
          if (nDuration >= (DottedSixteenth + DottedSixtyFourth)) {
            TypeOutput[TypeDataDots] = 3;
          }
        }
      }
    } else {
      if (nDuration >= ThirtySecond) {
        TypeOutput[TypeDataBeams] = 3;
        TypeOutput[TypeDataType] = '32nd';
        if (nDuration >= DottedThirtySecond) {
          TypeOutput[TypeDataDots] = 1;
          if (nDuration >= (DottedThirtySecond + OneHundredTwentyEighth)) {
            TypeOutput[TypeDataDots] = 2;
            if (nDuration >= (DottedThirtySecond + DottedOneHundredTwentyEighth)) {
              TypeOutput[TypeDataDots] = 3;
            }
          }
        }
      } else {
        if (nDuration >= SixtyFourth) {
          TypeOutput[TypeDataBeams] = 4;
          TypeOutput[TypeDataType] = '64th';
          if (nDuration >= DottedSixtyFourth) {
            TypeOutput[TypeDataDots] = 1;
            if (nDuration >= (DottedSixtyFourth + 4)) {
              TypeOutput[TypeDataDots] = 2;
              if (nDuration >= (DottedSixtyFourth + 6)) {
                TypeOutput[TypeDataDots] = 3;
              }
            }
          }
        } else {
          if (nDuration >= OneHundredTwentyEighth) {
            TypeOutput[TypeDataBeams] = 5;
            TypeOutput[TypeDataType] = '128th';
            if (nDuration >= (DottedOneHundredTwentyEighth)) {
              TypeOutput[TypeDataDots] = 1;
              if (nDuration >= (DottedOneHundredTwentyEighth + 2)) {
                TypeOutput[TypeDataDots] = 2;
                if (nDuration >= (DottedOneHundredTwentyEighth + 3)) {
                  TypeOutput[TypeDataDots] = 3;
                }
              }
            }
          } else {
            if (nDuration >= 4) {
              TypeOutput[TypeDataBeams] = 6;
              TypeOutput[TypeDataType] = '256th';
              if (nDuration >= 6) {
                TypeOutput[TypeDataDots] = 1;
                if (nDuration >= 7) {
                  TypeOutput[TypeDataDots] = 2;
                }
              }
            } else {
              if (nDuration >= 2) {
                TypeOutput[TypeDataBeams] = 7;
                TypeOutput[TypeDataType] = '512th';
                if (nDuration = 3) {
                  TypeOutput[TypeDataDots] = 1;
                }
              } else {
                if (nDuration = 1) {
                  TypeOutput[TypeDataBeams] = 8;
                  TypeOutput[TypeDataType] = '1024th';
                }
              }
            }
          }
        }
      }
    }
  }
}
}"
	WriteBeams "(ThisEntry, Voice, Beams) {
sBeam = '';
sContinueBeam = '';
fAllBeams = True;
sFan = '';
nNextBeam = 0 + NextEntryBeam;
nNextDuration = 0 + NextEntryDuration;
nPreviousBeam = PreviousEntryBeam[Voice];
nPreviousDuration = PreviousEntryDuration[Voice];
fPreviousPrimaryBeamOnly = PreviousPrimaryBeamOnly[Voice];
if (ThisEntry.GraceNote) {
	nNextBeam = 0 + NextGraceEntryBeam;
	nNextDuration = 0 + NextGraceEntryDuration;
	nPreviousBeam = PreviousGraceEntryBeam[Voice];
	nPreviousDuration = PreviousGraceEntryDuration[Voice];
	fPreviousPrimaryBeamOnly = PreviousGracePrimaryBeamOnly[Voice];
}
// !!! For debugging
sDebugBeam = '';

switch (ThisEntry.Beam) {
	case (StartBeam) {
		if (not ((nNextBeam = NoBeam) or (nNextBeam = StartBeam))) {
			sBeam = 'begin';
			if (nNextBeam = SingleBeam) {
				fAllBeams = False;
				sContinueBeam = 'forward hook';
			} else {
				// Check for fanned beams
				if (Beams >= 2) {
					if (ThisEntry.FeatheredBeamType = FeatheredBeamAccel) {
						sFan = ' fan=\'accel\'';
					} else {
						if (ThisEntry.FeatheredBeamType = FeatheredBeamRit) {
							sFan = ' fan=\'rit\'';
						}
					}
				}
			}
		}
		sDebugBeam = 'StartBeam';
	}
	case (NoBeam) {
		// NoBeam is not the end beam, it is the
		// absence of a beam, despite what the
		// ManuScript documentation says.
		sDebugBeam = 'NoBeam';
	}
	case (ContinueBeam) {
		if ((nPreviousDuration >= Quarter) or 
			 (nPreviousBeam = NoBeam)) {
			sBeam = 'begin';
			if ((nNextBeam = NoBeam) or (nNextBeam = StartBeam)) {
				sBeam = '';
			} else {
				if (nNextBeam = SingleBeam) {
					fAllBeams = False;
					sContinueBeam = 'forward hook';
				}
			}
		} else {
			sBeam = 'continue';
			if ((nNextBeam = NoBeam) or (nNextBeam = StartBeam)) {
				sBeam = 'end';
			} else {
				if (nNextBeam = SingleBeam) {
					fAllBeams = False;
					sContinueBeam = 'end';
				}
			}
		}
		sDebugBeam = 'ContinueBeam';
	}
	case (SingleBeam) {
		if ((nPreviousDuration >= Quarter) or 
			 (nPreviousBeam = NoBeam)) {
			sBeam = 'begin';
			if ((nNextBeam = NoBeam) or (nNextBeam = StartBeam)) {
				sBeam = '';
			} else {
				if (nNextBeam = SingleBeam) {
					fAllBeams = False;
					sContinueBeam = 'forward hook';
				}
			}
		} else {
			sBeam = 'continue';
			if ((nNextBeam = NoBeam) or (nNextBeam = StartBeam)) {
				sBeam = 'end';
			} else {
				fAllBeams = False;
				sContinueBeam = 'begin';
				// Check for fanned beams
				if (Beams >= 2) {
					if (ThisEntry.FeatheredBeamType = FeatheredBeamAccel) {
						sFan = ' fan=\'accel\'';
					} else {
						if (ThisEntry.FeatheredBeamType = FeatheredBeamRit) {
							sFan = ' fan=\'rit\'';
						}
					}
				}
			}
		}
		sDebugBeam = 'SingleBeam';
	}
}
// !!! For debugging
// WriteXML('<!-- Beam = ' & sDebugBeam & ' -->', 4);
if (Length(sBeam) > 0) {
	// Figure out backward hooks if needed
	nRealPreviousBeams = Beams;
	nRealNextBeams = Beams;
	if (Beams > 1) {
		if (nPreviousBeam = NoBeam) {
			nRealPreviousBeams = 0;
		} else {
			nRealPreviousBeams = GetBeams(nPreviousDuration);
			if (nRealPreviousBeams > 1) {
				// If we had a rest with a continue beam, we
				// will need a backward hook vs. an end beam.
				if (fPreviousPrimaryBeamOnly) {
					nRealPreviousBeams = 1;
				}
			}
		}
		if ((nNextBeam = NoBeam) or (nNextBeam = StartBeam)) {
			nRealNextBeams = 0;
		} else {
			nRealNextBeams = GetBeams(nNextDuration);
		}
	}

	// For hook disambiguation
	oPreviousType = CreateSparseArray();
	oNextType = CreateSparseArray(); 

	sPrimaryBeam = '';
	for i = 1 to Beams + 1 {
		if (fAllBeams or (i = 1)) {
			if (i > 1) {
				if (nRealPreviousBeams < i) {
					if (sBeam = 'end') {
						sBeam = 'backward hook';
					} else {
						if (sBeam = 'continue') {
							sBeam = 'begin';
						}
					}
				}
				if (nRealNextBeams < i) {
					if (sBeam = 'begin') {
						// If both the previous and the next beams are less than i
						// but greater than 0, this hook could be going either way.
						// Go towards the dot; if both are equally dotted, go backward.
						// Stick with forward hook if a beam over rest is involved.
						if ((nRealPreviousBeams < i) and (nRealPreviousBeams > 0) and
							(sPrimaryBeam = 'continue') and (ThisEntry.Beam != SingleBeam)) {
							GetType(nPreviousDuration, oPreviousType);
							GetType(nNextDuration, oNextType);
							if (oPreviousType[TypeDataDots] < oNextType[TypeDataDots]) {
								sBeam = 'forward hook';
							} else {
								sBeam = 'backward hook';
							}
						} else {
							sBeam = 'forward hook';
						}
					} else {
						if (sBeam = 'continue') {
							sBeam = 'end';
						}
					}
				}
				WriteXML('<beam number=\'' & i & '\'' & sFan & 
						  '>' & sBeam & '</beam>', 4);
			} else {
				WriteXML('<beam number=\'' & i & '\'>' & 
						  sBeam & '</beam>', 4);
				sPrimaryBeam = '' & sBeam;
			}
		} else {
			if (nRealPreviousBeams < i) {
				if (sContinueBeam = 'end') {
					sContinueBeam = 'backward hook';
				} else {
					if (sContinueBeam = 'continue') {
						sContinueBeam = 'begin';
					}
				}
			}
			if (nRealNextBeams < i) {
				if (sContinueBeam = 'begin') {
					// If both the previous and the next beams are less than i
					// but greater than 0, this hook could be going either way.
					// Go towards the dot; if both are equally dotted, go backward.
					// Stick with forward hook if a beam over rest is involved.
					if ((nRealPreviousBeams < i) and (nRealPreviousBeams > 0) and
						(sPrimaryBeam = 'continue') and (ThisEntry.Beam != SingleBeam)) {
						GetType(nPreviousDuration, oPreviousType);
						GetType(nNextDuration, oNextType);
						if (oPreviousType[TypeDataDots] < oNextType[TypeDataDots]) {
							sContinueBeam = 'forward hook';
						} else {
							sContinueBeam = 'backward hook';
						}
					} else {
						sContinueBeam = 'forward hook';
					}
				} else {
					if (sContinueBeam = 'continue') {
						sContinueBeam = 'end';
					}
				}
			}
			WriteXML('<beam number=\'' & i & '\'' & sFan & 
					  '>' & sContinueBeam & '</beam>', 4);
		}
	}
}
}"
	WriteNotations "(ThisEntry, ThisNote, StaffNumber, StaffToWrite, Voice, Duration, NoteNumber, StopTie) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

fTuplet = False;
nArpeggioVoice = -1;
nNonArpeggiateVoice = -1;
fTab = False;
fFingering = False;
nSlurs = 0;
nGlissandos = 0;
nTrills = 0;
fTremolo = False;
fSlide = False;
nOldSlide = 0;
nNewSlide = 0;
fSlideStart = False;
fUnexportedSlide = False;
fUnexportedNotation = False;

// Articulation access was added in Sibelius 4.
// Log errors with the 3 custom articulations.
fAnyArticulation = False;
fStaccato = False;
fSpiccato = False;
fStaccatissimo = False;
fTenuto = False;
fAccent = False;
fMarcato = False;
fHarmonic = False;
fPlus = False;
fUpBow = False;
fDownBow = False;
// Group 3 different fermatas together here,
// using string to distinguish shapes.
fFermata = False;
sFermata = '';
fCustom1Artic = False;
fCustom2Artic = False;
fCustom3Artic = False;

// Jazz articulations and NoteRest-attached arpeggios 
// are new for Sibelius 6.
fFall = False;
fScoop = False;
fArpeggio = False;
sArpeggiateDirection = '';

// Group by higher-level MusicXML elements
fArticulations = False;
fTechnical = False;
fOrnaments = False;
fSymbolArticulations = CreateSparseArray();
fSymbolOrnaments = CreateSparseArray();
fSymbolTechnical = CreateSparseArray();
fSymbolNotations = CreateSparseArray();
fSymbolPrecedesNote = CreateSparseArray();
fAnySymbolArticulation = False;
fAnySymbolOrnament = False;
fAnySymbolTechnical = False;
fAnySymbolNotation = False;

// Sparse arrays to distinguish grace note
// from regular note fingerings.
oGraceFingeringDyFirst = CreateSparseArray();
oGraceFingeringDyCount = CreateSparseArray();
oGraceFingeringOK = CreateSparseArray();
nFingeringGraceCount = 0;

// Allow some roundoff slack in this test
nStopTest = MeasureCounter + Duration;
nStopTest1 = nStopTest - 4;
nStopTest2 = nStopTest + 4;
nBarCounter = 0 + BarCounter;
nMeasureCounter = 0 + MeasureCounter;
nSibMeasureCounter = 0 + SibMeasureCounter;
nTabClef = 0 + TabClef;
nTabStrings = 0 + TabStrings;

// Need to count ties for handling of l.v. symbols
TiedStartCount = 0;
TiedStopCount = 0;
fLastNote = False;
if (NoteNumber = ThisEntry.NoteCount) {
	fLastNote = True;
}

// Check if this is a chord note / entry
fIsChord = False;
fChordEntry = False;
if (ThisEntry.NoteCount > 1) {
	fChordEntry = True;
	if (NoteNumber > 1) {
		fIsChord = True;
	}
}

// Grace note test needed for slurs
fGrace = ThisEntry.GraceNote;

// Get tie and string data
nSibString = -1;
nXmlString = -1;
fTied = False;
fTiedInto = False;
fLvTie = False;
if (ThisEntry.NoteCount > 0) {
	fTied = ThisNote.Tied;
	if (AtLeastSib20201) {
		fTiedInto = ThisNote.TiedInto;
		if (fTied and AtLeastSib20203) {
			fLvTie = ThisNote.LvTie;
		}
	}
	if (nTabClef = StaffNumber) {
		nSibString = ThisNote.StringNum;
		nXmlString = nTabStrings - nSibString;
	}
}

nMaxTuplets = 0;
fStartOfTuplet = CreateSparseArray();
fEndOfTuplet = CreateSparseArray();

// Compute the tuplets. Create a pseduo-array
// of tuplet objects because if we have nested
// tuplets, we need to count them from the
// outside (longest tuplet) in.
if ((not fIsChord) and (not fGrace)) {
	oPrevTuplet = null;
	oThisTuplet = ThisEntry.ParentTupletIfAny;
	if ((oThisTuplet = null) and ExtendedTuplet) {
		fTuplet = True;
	}
	while (oThisTuplet != null) {
		sWhichTuplet = 'oTuplet' & nMaxTuplets;
		@sWhichTuplet = oThisTuplet;
		if (nMaxTuplets = 0) {
			if (ThisEntry.PositionInTuplet = 0) {
				fStartOfTuplet[nMaxTuplets] = True;
			}
		} else {
			if (oPrevTuplet.PositionInTuplet = 0) {
				fStartOfTuplet[nMaxTuplets] = True;
			}
		}
		if (fStartOfTuplet[nMaxTuplets]) {
			fTuplet = True;
		}
		fEndOfTuplet[nMaxTuplets] = EndOfTuplet(ThisEntry, oThisTuplet);
		if (fEndOfTuplet[nMaxTuplets]) {
			fTuplet = True;
		}
		nMaxTuplets = nMaxTuplets + 1;
		oPrevTuplet = oThisTuplet;
		// This global will be set by WriteNoteRest if we have
		// a bogus file with tuplets that appear infinitely nested.
		if (IgnoreNestedTuplets) {
			oThisTuplet = null;
		} else {
			oThisTuplet = oThisTuplet.ParentTupletIfAny;
		}
	}
}

// Do arpeggios on all notes in the voice, not just
// the first in the chord. This is for pre-Sibelius 6
// apreggio lines, vs. the NoteRest-attached arpeggios
// added in Sibelius 6.
if ((ArpeggioBars[ThisEntry.VoiceNumber] = nBarCounter) and 
    (ArpeggioPositions[ThisEntry.VoiceNumber] <= nSibMeasureCounter)) {
	nArpeggioVoice = ThisEntry.VoiceNumber;
} else {
	if ((ArpeggioBars[0] = nBarCounter) and 
	    (ArpeggioPositions[0] <= nSibMeasureCounter)) {
		nArpeggioVoice = 0;
	}
}

// Do non-arpeggiate on the first and last notes in the chord.
// Ignore if we do not have a chord.
if (ThisEntry.NoteCount > 1) {
	if (fLastNote or (not fIsChord)) {
		if ((NonArpeggiateBars[ThisEntry.VoiceNumber] = nBarCounter) and 
		    (NonArpeggiatePositions[ThisEntry.VoiceNumber] <= nSibMeasureCounter)) {
			nNonArpeggiateVoice = ThisEntry.VoiceNumber;
		} else {
			if ((NonArpeggiateBars[0] = nBarCounter) and 
			    (NonArpeggiatePositions[0] <= nSibMeasureCounter)) {
				nNonArpeggiateVoice = 0;
			}
		}
	}
}

// Check for tab.
if ((nTabClef = StaffNumber) and (nTabStrings > 0) and (nSibString >= 0)) {
	fTechnical = True;
	fTab = True;
}

// Check for articulations, tremolos, and other
// notations that do not go on rests.

// Fermatas are the only articulations allowed on rests.
// Sometimes ManuScript erroneously reports others, so
// do not check them. Assume the same is true for tremolos.

// Put tremolos, jazz articulations, and Sibelius 6 arpeggios 
// on all notes in a chord.

if (ThisEntry.NoteCount > 0) {
	if (Length(TremoloType[Voice]) > 0) {
		fOrnaments = True;
		fTremolo = True;
	}
	if ((ThisEntry.FallType = FallTypeNormal) or
		 (ThisEntry.FallType = FallTypeDoit)) {
		fArticulations = True;
		fFall = True;
	}
	if ((ThisEntry.ScoopType = ScoopTypeNormal) or 
		 (ThisEntry.ScoopType = ScoopTypePlop)) {
		fArticulations = True;
		fScoop = True;
	}
	if ((ThisEntry.ArpeggioType != ArpeggioTypeNone) and
		 (not ThisEntry.ArpeggioHidden)) {
		fArpeggio = True;
		if (ThisEntry.ArpeggioType = ArpeggioTypeDown) {
			sArpeggiateDirection = 'down';
		} else {
			if (ThisEntry.ArpeggioType = ArpeggioTypeUp) {
				sArpeggiateDirection = 'up';
			}
		}
	}
}

// Check for symbols on each note of chord. Output the
// symbol if is a notation that is closer to this entry
// than to the next entry. Do not export on a grace note.
// We check on each note of the chord for symbols like
// l.v. that may be spread out on the chord. Double-check
// that all symbols have not been used to avoid repetitive
// checks.
if (not fGrace) {
	nSymbolCount = 0;
	for si = 0 to SymbolCount {
		fUseSymbol = False;
		if (SymbolIndices[si] >= 0) {
			fUseSymbol = True;
			nSymbolCount = nSymbolCount + 1;
		}
		if (fUseSymbol) {		
			sSymbolParent = SymbolIndexParents[SymbolIndices[si]];
			switch (sSymbolParent) {
				case ('articulations') {
					fArticulations = True;
					fSymbolArticulations[si] = True;
					fAnySymbolArticulation = True;
				}
				case ('ornaments') {
					fOrnaments = True;
					fSymbolOrnaments[si] = True;
					fAnySymbolOrnament = True;
				}
				case ('technical') {
					fTechnical = True;
					fSymbolTechnical[si] = True;
					fAnySymbolTechnical = True;
				}
				case ('notations') {
					fSymbolNotations[si] = True;
					fAnySymbolNotation = True;
				}
			}
			if (SymbolPositions[si] < ThisEntry.Position) {
				fSymbolPrecedesNote[si] = True;
			} else {
				if ((SymbolPositions[si] = ThisEntry.Position) and 
					 (SymbolDx[si] < ThisEntry.Dx)) {
					fSymbolPrecedesNote[si] = True;
				} else {
					fSymbolPrecedesNote[si] = False;
				}
			}
		}
	}
	// If we have no symbols in use any more,
	// reset the symbol count. Symbols may be
	// used mid-array, so do not reset the
	// symbol count value unless it should be 0.
	if (nSymbolCount = 0) {
		SymbolCount = 0;
	}
}

if (not fIsChord) {
	if (ThisEntry.NoteCount > 0) {
		if (ThisEntry.GetArticulation(StaccatoArtic)) {
			fAnyArticulation = True;
			fArticulations = True;
			fStaccato = True;
		}
		if (ThisEntry.GetArticulation(StaccatissimoArtic)) {
			fAnyArticulation = True;
			fArticulations = True;
			fStaccatissimo = True;
		}
		if (ThisEntry.GetArticulation(WedgeArtic)) {
			fAnyArticulation = True;
			fArticulations = True;
			fSpiccato = True;
		}
		if (ThisEntry.GetArticulation(TenutoArtic)) {
			fAnyArticulation = True;
			fArticulations = True;
			fTenuto = True;
		}
		if (ThisEntry.GetArticulation(AccentArtic)) {
			fAnyArticulation = True;
			fArticulations = True;
			fAccent = True;
		}
		if (ThisEntry.GetArticulation(MarcatoArtic)) {
			fAnyArticulation = True;
			fArticulations = True;
			fMarcato = True;
		}
		if (ThisEntry.GetArticulation(HarmonicArtic)) {
			fAnyArticulation = True;
			fTechnical = True;
			fHarmonic = True;
		}
		if (ThisEntry.GetArticulation(PlusArtic)) {
			fAnyArticulation = True;
			fTechnical = True;
			fPlus = True;
		}
		if (ThisEntry.GetArticulation(UpBowArtic)) {
			fAnyArticulation = True;
			fTechnical = True;
			fUpBow = True;
		}
		if (ThisEntry.GetArticulation(DownBowArtic)) {
			fAnyArticulation = True;
			fTechnical = True;
			fDownBow = True;
		}
		if (ThisEntry.GetArticulation(Custom1Artic)) {
			fCustom1Artic = True;
			fUnexportedNotation = True;
		}
		if (ThisEntry.GetArticulation(Custom2Artic)) {
			fCustom2Artic = True;
			fUnexportedNotation = True;
		}
		if (ThisEntry.GetArticulation(Custom3Artic)) {
			fCustom3Artic = True;
			fUnexportedNotation = True;
		}

		// We do not want to export slurs, glissandos,
		// trills, or fingerings on a rest either.
		// @todo Double-check this as it may drop lines

		// Check for slurs, recording the first one that
		// we want to use for start and/or stop. Allow
		// for roundoff errors, especially within tuplets.

		oSlurStarts = CreateSparseArray();
		oSlurStops = CreateSparseArray();
		if ((SlurCounts > 0) and (not fIsChord)) {
			nSlurs = CheckSlurs(ThisEntry, StaffNumber, StaffToWrite,
								oSlurStarts, oSlurStops);
		}

		// Check for glissandos using same technique as slurs.
		oGlissandoStarts = CreateSparseArray();
		oGlissandoStops = CreateSparseArray();
		oGlissandoCrossStaffStops = CreateSparseArray();
		if ((GlissandoCounts > 0) and (not fIsChord)) {
			nGlissandos =
				CheckGlissandos(ThisEntry, StaffNumber, StaffToWrite, oGlissandoStarts,
								oGlissandoStops, oGlissandoCrossStaffStops);
		}

		// Check for fingering on first note of chord
		if (fGrace) {
			for fi = 0 to FingeringCount {
				if ((not FingeringWritten[fi]) and
					 ((FingeringVoices[fi] = GetVoice(ThisEntry, StaffNumber)) or
					  (FingeringVoices[fi] = 0))) {
					nDy = 0 + FingeringDy[fi];
					if (oGraceFingeringDyCount[nDy] = 0) {
						oGraceFingeringDyFirst[nDy] = fi;
						oGraceFingeringDyCount[nDy] = 1;
					} else {
						oGraceFingeringDyCount[nDy] = oGraceFingeringDyCount[nDy] + 1;
					}
				}
			}
			for fi = 0 to FingeringCount {
				if ((not FingeringWritten[fi]) and
					 ((FingeringVoices[fi] = GetVoice(ThisEntry, StaffNumber)) or
					  (FingeringVoices[fi] = 0))) {
					nDy = 0 + FingeringDy[fi];
					if ((oGraceFingeringDyFirst[nDy] = fi) and 
						((oGraceFingeringDyCount[nDy] > 1) or (FingeringCueSize[fi]))) {
						nFingeringGraceCount = nFingeringGraceCount + 1;
						oGraceFingeringOK[fi] = True;
					} else {
						oGraceFingeringOK[fi] = False;
					}
				} else {
					oGraceFingeringOK[fi] = False;
				}
			}
			if (nFingeringGraceCount > 0) {
				fFingering = True;
				fTechnical = True;
			}		
		} else {
			for fi = 0 to FingeringCount {
				if ((not FingeringWritten[fi]) and
					 ((FingeringVoices[fi] = GetVoice(ThisEntry, StaffNumber)) or
					  (FingeringVoices[fi] = 0))) {
					fFingering = True;
					fTechnical = True;
				}
			}
		}

		// Check for slides, available as of Sibelius 5.1.
		// For now, use the voice number as the slide number,
		// since we limit slides to single-note NoteRests.
		nOldSlide = 0 + SlideStop[Voice];
		if (nOldSlide > 0) {
			fSlide = True;
		}
		if (ThisNote.Slide) {
			if (HasSlideStop(ThisEntry, Duration)) {
				// Make sure we have a slide number for this
				nNewSlide = GetSlideNumber(nOldSlide);
				if (nNewSlide > 0) { 
					fSlideStart = True;
					fSlide = True;
				} else {
					fUnexportedSlide = True;
					fUnexportedNotation = True;
				}
			} else {
				fUnexportedSlide = True;
				fUnexportedNotation = True;
			}
		}
	}

	// Check for trills using same technique as slurs, but
	// allow trills to end on rests. The difference between
	// notes and rests is handled in the CheckTrills method.
	oTrillStarts = CreateSparseArray();
	oTrillStops = CreateSparseArray();
	if ((TrillCounts > 0) and (not fIsChord)) {
		nTrills = CheckTrills(ThisEntry, StaffNumber,
								 oTrillStarts, oTrillStops);
		if (nTrills > 0) {
			fOrnaments = True;
		}
	}

	// Now check for articulations allowed on rests.
	if (ThisEntry.GetArticulation(SquarePauseArtic)) {
		fAnyArticulation = True;
		fFermata = True;
		sFermata = 'square';
	}
	if (ThisEntry.GetArticulation(PauseArtic)) {
		fAnyArticulation = True;
		fFermata = True;
		sFermata = 'normal';
	}
	if (ThisEntry.GetArticulation(TriPauseArtic)) {
		fAnyArticulation = True;
		fFermata = True;
		sFermata = 'angled';
	}

} else {
	if (ThisEntry.NoteCount > 0) {
		if (ThisNote.Slide) {
			fUnexportedSlide = True;
			fUnexportedNotation = True;
		}
	}
}		

// Now that we have analyzed the notations, write them out.
// For notations that are just a character glyph, try to
// write them out in order from closest to the note to the
// furthest out, based on the settings in Sibelius default
// documents. Some importing apps will be using this to
// guide vertical positioning, since we have no way to export
// any positioning data for Sibelius articulations.
if (fTuplet or fTied or StopTie or (nSlurs > 0) or (nGlissandos > 0) or 
	 fTab or fFermata or fOrnaments or fTechnical or fArticulations or 
	 fArpeggio or (nArpeggioVoice >= 0) or (nNonArpeggiateVoice >= 0) or
	 fAnySymbolNotation or fSlide or fTiedInto) {
	WriteXML('<notations>', 4);
	sLineType = '';
	if (StopTie or fTiedInto) {
		if (AtLeastSib20201 and fTiedInto) {
			if (ThisNote.TieIntoStyle = 'dashed') {
				sLineType = ' line-type=\'dashed\'';
			} else {
				if (ThisNote.TieIntoStyle = 'dotted') {
					sLineType = ' line-type=\'dotted\'';
				}
			}
		}
		WriteXML('<tied type=\'stop\'' & sLineType & '/>', 5);
		TiedStopCount = 1;
	}
	if (fTied) {
		if (AtLeastSib20201) {
			if (ThisNote.TieStyle = 'dashed') {
				sLineType = ' line-type=\'dashed\'';
			} else {
				if (ThisNote.TieStyle = 'dotted') {
					sLineType = ' line-type=\'dotted\'';
				}
			}
		}
		if (fLvTie) {
			WriteXML('<tied type=\'let-ring\'' & sLineType & '/>', 5);
		} else {
			WriteXML('<tied type=\'start\'' & sLineType & '/>', 5);
		}
		TiedStartCount = 1;
	}
	if (fTuplet) {
		for t = 0 to nMaxTuplets {
			nTupletNumber = t + 1;
			nWhichTuplet = nMaxTuplets - nTupletNumber;
			sWhichTuplet = 'oTuplet' & nWhichTuplet;
			if (fStartOfTuplet[nWhichTuplet]) {
				WriteStartTuplet(@sWhichTuplet, nTupletNumber);
			}
			if (fEndOfTuplet[nWhichTuplet]) {
				// If we have deeply nested tuplets, usually used
				// to simulate fanned beaming playback, do not
				// export numbers greater than 16 or the MusicXML
				// file will be invalid.
				sStopNumber = ' number=\'' & nTupletNumber & '\'';
				if (nTupletNumber > 16) {
					sStopNumber = '';
				}
				WriteXML('<tuplet' & sStopNumber & ' type=\'stop\'/>', 5);
			}
		}
		// If we have an extended tuplet, it is not not nested.
		if ((nMaxTuplets = 0) and ExtendedTuplet) {
			WriteXML('<tuplet number=\'1\' type=\'stop\'/>', 5);
		}
	}
	if (nSlurs > 0) {
		WriteSlurs(ThisEntry, oSlurStarts, oSlurStops);
	}
	if (nGlissandos > 0) {
		WriteGlissandos(ThisEntry, oGlissandoStarts, oGlissandoStops,
						oGlissandoCrossStaffStops);
	}

	// Make sure we do not write two arpeggiate elements on a single
	// note. Give preference to old-style arpeggio line given its more
	// complicated global variable status handling.	
	if (nArpeggioVoice >= 0) {
		sColor = '' & ArpeggioColors[nArpeggioVoice];
		if (Length(ArpeggioDirections[nArpeggioVoice]) > 0) {
			WriteXML('<arpeggiate direction=\'' & 
			         ArpeggioDirections[nArpeggioVoice] & 
					 '\'' & sColor & '/>', 5);
		} else {
			WriteXML('<arpeggiate' & sColor & '/>', 5);
		}
		ArpeggioVoiceWritten = nArpeggioVoice;
	} else {
		if (fArpeggio) {
			// ArpeggioBottomDy and ArpeggioTopDy appear to be offsets
			// from default values, so we will not use them for export
			// at this time.
			if (Length(sArpeggiateDirection) > 0) {
				WriteXML('<arpeggiate direction=\'' & 
						 sArpeggiateDirection & '\'/>', 5);
			} else {
				WriteXML('<arpeggiate/>', 5);
			}
		}
	}

	// It would be unusual to have apreggiate and non-arpeggiate
	// together, but allow it for now.
	if (nNonArpeggiateVoice >= 0) {
		sColor = '' & NonArpeggiateColors[nNonArpeggiateVoice];
		if (not fIsChord) {
			WriteXML('<non-arpeggiate type=\'bottom\'' & sColor & '/>', 5);
		} else {
			WriteXML('<non-arpeggiate type=\'top\'' & sColor & '/>', 5);
		}
	}

	if (fSlide) {
		// First write the slide stop, then the slide start
		if (nOldSlide > 0) {
			WriteXML('<slide type=\'stop\' number=\'' &
					  nOldSlide & '\'/>', 5);
			SlideStop[Voice] = 0;
		}
		if (fSlideStart) {
			WriteXML('<slide type=\'start\' number=\'' & 
					  nNewSlide & '\'/>', 5);
			SlideStop[Voice] = nNewSlide;
		}
	}

	// Handle XML articulations
	if (fArticulations) {
		WriteXML('<articulations>', 5);
		if (fStaccato) {
			WriteXML('<staccato/>', 6);
		}
		if (fStaccatissimo) {
			WriteXML('<staccatissimo/>', 6);
		}
		if (fSpiccato) {
			WriteXML('<spiccato/>', 6);
		}
		if (fTenuto) {
			WriteXML('<tenuto/>', 6);
		}
		if (fAccent) {
			WriteXML('<accent/>', 6);
		}
		if (fMarcato) {
			WriteXML('<strong-accent/>', 6);
		}
		if (fScoop) {
			if (ThisEntry.ScoopType = ScoopTypePlop) {
				WriteXML('<plop/>', 6);
			} else {
				WriteXML('<scoop/>', 6);
			}
		}
		if (fFall) {
			if (ThisEntry.FallType = FallTypeDoit) {
				WriteXML('<doit/>', 6);
			} else {
				WriteXML('<falloff/>', 6);
			}
		}
		if (fAnySymbolArticulation) {
			for si = 0 to SymbolCount {
				if (fSymbolArticulations[si]) {		
					WriteSymbolNotation(si, fSymbolPrecedesNote[si], 
										fChordEntry, fLastNote);
				}
			}
		}
		WriteXML('</articulations>', 5);
	}
	
	if (fOrnaments) {
		WriteXML('<ornaments>', 5);
		if (nTrills > 0) {
			WriteTrills(ThisEntry, oTrillStarts, oTrillStops);
		}
		if (fTremolo) {
			sTremoloType = ' type=\'' & TremoloType[Voice] & '\'';
			nTremolo = ThisEntry.SingleTremolos;
			// ZOnStem value is -1 so change that to 0
			if (nTremolo < 0) {
				nTremolo = 0;
			}
			if (DoubleTremolos[Voice] > 0) {
				nTremolo = DoubleTremolos[Voice];
				// We can adjust the beams and tremolo values for
				// double-note tremolos based on engraving rules.
				// @todo We really should modify beams too
				// So we may need to back this out for now, but it seems
				// we probably help more than hurt, at least for the
				// touching stems style.
				if (XmlBeams > 0) {
					switch (DoubleTremoloStyle) {
						case (DoubleTremolosTouchingStems) {
							nTremolo = 0;		
						}
						case (DoubleTremolosOuterTremoloTouchingStems) {
							if (nTremolo > 0) {
								nTremolo = nTremolo - 1;
							}
						}
					}
				}
			}	
			WriteXML('<tremolo' & sTremoloType & '>' & 
					  nTremolo & '</tremolo>', 6);
		}
		if (fAnySymbolOrnament) {
			for si = 0 to SymbolCount {
				if (fSymbolOrnaments[si]) {		
					WriteSymbolNotation(si, fSymbolPrecedesNote[si], 
										fChordEntry, fLastNote);
				}
			}
		}
		WriteXML('</ornaments>', 5);
	}

	// Sibelius numbers strings from low to high starting from 0, 
	// while MusicXML numbers them from high to low starting from 1.
	// Hence the two string variables.
	if (fTechnical) {
		WriteXML('<technical>', 5);
		if (fTab) {
			WriteXML('<string>' & nXmlString & '</string>', 6);
			nFret = ThisNote.Pitch - StringPitch[nSibString];
			if (nFret >= 0) {
				WriteXML('<fret>' & nFret & '</fret>', 6);
			}
		}
		if (fHarmonic) {
			WriteXML('<harmonic placement=\'above\'/>', 6);
		}

		if (fFingering) {
			// Apps can sort fingerings by default-y value as needed,
			// so do not try to do that here. Just have the fingerings
			// as a group in the correct default inside-out ordering.
			for fi = 0 to FingeringCount {
				fGraceFingering = True;
				if (fGrace and (not oGraceFingeringOK[fi])) {
					fGraceFingering = False;
				}
				if (((not FingeringWritten[fi]) and fGraceFingering) and
					 ((FingeringVoices[fi] = GetVoice(ThisEntry, StaffNumber)) or
					  (FingeringVoices[fi] = 0))) {
					fUseDx = False;
					if (FingeringPositions[fi] = ThisEntry.Position) {
						fUseDx = True;
					}
					WriteFingering(fi, StaffNumber, True, fUseDx);
				}
			}
		}

		// Sibelius default documents have these symbols always
		// go above the note regardless of stem direction.
		if (fPlus) {
			WriteXML('<stopped placement=\'above\'/>', 6);
		}
		if (fUpBow) {
			WriteXML('<up-bow placement=\'above\'/>', 6);
		}
		if (fDownBow) {
			WriteXML('<down-bow placement=\'above\'/>', 6);
		}
		if (fAnySymbolTechnical) {
			for si = 0 to SymbolCount {
				if (fSymbolTechnical[si]) {		
					WriteSymbolNotation(si, fSymbolPrecedesNote[si], 
										fChordEntry, fLastNote);
				}
			}
		}
		WriteXML('</technical>', 5);
	}

	if (fAnySymbolNotation) {
		for si = 0 to SymbolCount {
			if (fSymbolNotations[si]) {		
				WriteSymbolNotation(si, fSymbolPrecedesNote[si], 
									fChordEntry, fLastNote);
			}
		}
	}

	if (fFermata) {
		WriteXML('<fermata>' & sFermata & '</fermata>', 5);
	}

	if (fUnexportedNotation) {
		if (fUnexportedSlide) {
			LogError('Unexported slide start', 5);
		}
		if (fCustom1Artic) {
			LogError('Unexported custom articulation 1', 5);
		}
		if (fCustom2Artic) {
			LogError('Unexported custom articulation 2', 5);
		}
		if (fCustom3Artic) {
			LogError('Unexported custom articulation 3', 5);
		}
	}	
	WriteXML('</notations>', 4);
} else {
	if (fUnexportedNotation) {
		if (fUnexportedSlide) {
			LogError('Unexported slide start', 4);
		}
		if (fCustom1Artic) {
			LogError('Unexported custom articulation 1', 4);
		}
		if (fCustom2Artic) {
			LogError('Unexported custom articulation 2', 4);
		}
		if (fCustom3Artic) {
			LogError('Unexported custom articulation 3', 4);
		}
	}
}
}"
	XmlType
	XmlDots "0"
	XmlBeams "0"
	BarCounter "0"
	GetVoice "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// If it is associated with just one voice 1-4, write that out.
if (BarObject.VoiceNumber > 0) {
	nVoice = BarObject.VoiceNumber;
	if (StaffNumber > 1) {
		nVoice = nVoice + (4 * (StaffNumber - 1));
	}
} else {
	nVoice = 0;
}

return nVoice;
}"
	WriteSymbolItem "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Sibelius 4 gave us access to symbol items.

// For debugging
if (ShowTrace) {
	trace('Found symbol ' & BarObject.Index & ' (' &
	      BarObject.Name & ') in bar ' & BarObject.ParentBar.BarNumber & 
	      ', position ' & BarObject.Position & ', voice ' &
		   BarObject.VoiceNumber & ', dx = ' & BarObject.Dx &
	      ', dy = ' & BarObject.Dy);
}

// If hidden, just return without writing.
if (BarObject.Hidden) {
	return 0;
}

// Negative number lookup in array can loop Sibelius.
if (BarObject.Index < 0) {
	LogError('Unrecognized symbol item index ' & BarObject.Index, 3);
	return 0;
}

// If the symbol is a direction, we call the routine to
// write it. Most symbols are notations, though, so we 
// need to save the data away for use with the next note.

sSymbolParent = '' & SymbolIndexParents[BarObject.Index];
if (Length(sSymbolParent) = 0) {
	// Write an other-direction element, which will also
	// log that this is an unrecognized symbol index.
	WriteSymbolDirection(BarObject, StaffNumber);
} else {
	if (sSymbolParent = 'direction-type') {
		WriteSymbolDirection(BarObject, StaffNumber);
	} else {
		if (sSymbolParent = 'percussion') {
			WriteSymbolPercussion(BarObject, StaffNumber);
		} else {
			SymbolIndices[SymbolCount] = 0 + BarObject.Index;
			SymbolPositions[SymbolCount] = (BarObject.Position * 3);
			SymbolDx[SymbolCount] = 0 + BarObject.Dx;
			SymbolDy[SymbolCount] = 0 + BarObject.Dy;
			SymbolColors[SymbolCount] = GetColor(BarObject);
			SymbolCount = SymbolCount + 1;
		}
	}
}
}"
	WriteLyrics "(ThisEntry, Voice, IsChord) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

if (IsChord) {
	return False;
}

// If we have any visible lyrics, do not write out hidden
// lyrics. If all lyrics for the voice are hidden, then
// we can write out the hidden lyrics.
fAllLyricsHidden = True;
if (AnyVisibleLyric[Voice]) {
	fAllLyricsHidden = False;
}

sPosition = '';
if ((Length(Verse1Text[Voice]) > 0) and
	 ((not Verse1Hidden[Voice]) or fAllLyricsHidden)) {
	if (Verse1Positions[Voice] = ThisEntry.Position) {
		sPosition = GetPosition(Verse1Dx[Voice], Verse1Dy[Voice], False);
	} else {
		sPosition = GetYPosition(Verse1Dy[Voice]);
	}
	sColor = '' & Verse1Color[Voice];
	WriteXML('<lyric number=\'1\' name=\'verse\' ' & 
			 sPosition & sColor & '>', 4);
	WriteLyricContent(Verse1Text[Voice], Verse1Type[Voice],
					  Verse1PrevType[Voice], Verse1Notes[Voice]);
	WriteXML('</lyric>', 4);
	Verse1Text[Voice] = '';
	Verse1PrevType[Voice] = 0 + Verse1Type[Voice];
}

if ((Length(Verse2Text[Voice]) > 0) and
	 ((not Verse2Hidden[Voice]) or fAllLyricsHidden)) {
	if (Verse2Positions[Voice] = ThisEntry.Position) {
		sPosition = GetPosition(Verse2Dx[Voice], Verse2Dy[Voice], False);
	} else {
		sPosition = GetYPosition(Verse2Dy[Voice]);
	}
	sColor = '' & Verse2Color[Voice];
	WriteXML('<lyric number=\'2\' name=\'verse\' ' &
			 sPosition & sColor & '>', 4);
	WriteLyricContent(Verse2Text[Voice], Verse2Type[Voice],
					  Verse2PrevType[Voice], Verse2Notes[Voice]);
	WriteXML('</lyric>', 4);
	Verse2Text[Voice] = '';
	Verse2PrevType[Voice] = 0 + Verse2Type[Voice];
}

if ((Length(Verse3Text[Voice]) > 0) and
	 ((not Verse3Hidden[Voice]) or fAllLyricsHidden)) {
	if (Verse3Positions[Voice] = ThisEntry.Position) {
		sPosition = GetPosition(Verse3Dx[Voice], Verse3Dy[Voice], False);
	} else {
		sPosition = GetYPosition(Verse3Dy[Voice]);
	}
	sColor = '' & Verse3Color[Voice];
	WriteXML('<lyric number=\'3\' name=\'verse\' ' & 
			 sPosition & sColor & '>', 4);
	WriteLyricContent(Verse3Text[Voice], Verse3Type[Voice],
					  Verse3PrevType[Voice], Verse3Notes[Voice]);
	WriteXML('</lyric>', 4);
	Verse3Text[Voice] = '';
	Verse3PrevType[Voice] = 0 + Verse3Type[Voice];
}

if ((Length(Verse4Text[Voice]) > 0) and
	 ((not Verse4Hidden[Voice]) or fAllLyricsHidden)) {
	if (Verse4Positions[Voice] = ThisEntry.Position) {
		sPosition = GetPosition(Verse4Dx[Voice], Verse4Dy[Voice], False);
	} else {
		sPosition = GetYPosition(Verse4Dy[Voice]);
	}
	sColor = '' & Verse4Color[Voice];
	WriteXML('<lyric number=\'4\' name=\'verse\' ' & 
			 sPosition & sColor & '>', 4);
	WriteLyricContent(Verse4Text[Voice], Verse4Type[Voice],
					  Verse4PrevType[Voice], Verse4Notes[Voice]);
	WriteXML('</lyric>', 4);
	Verse4Text[Voice] = '';
	Verse4PrevType[Voice] = 0 + Verse4Type[Voice];
}

if ((Length(Verse5Text[Voice]) > 0) and
	 ((not Verse5Hidden[Voice]) or fAllLyricsHidden)) {
	if (Verse5Positions[Voice] = ThisEntry.Position) {
		sPosition = GetPosition(Verse5Dx[Voice], Verse5Dy[Voice], False);
	} else {
		sPosition = GetYPosition(Verse5Dy[Voice]);
	}
	sColor = '' & Verse5Color[Voice];
	WriteXML('<lyric number=\'5\' name=\'verse\' ' & 
			 sPosition & sColor & '>', 4);
	WriteLyricContent(Verse5Text[Voice], Verse5Type[Voice],
					  Verse5PrevType[Voice], Verse5Notes[Voice]);
	WriteXML('</lyric>', 4);
	Verse5Text[Voice] = '';
	Verse5PrevType[Voice] = 0 + Verse5Type[Voice];
}

if ((Length(ChorusText[Voice]) > 0) and
	 ((not ChorusHidden[Voice]) or fAllLyricsHidden)) {
	if (ChorusPositions[Voice] = ThisEntry.Position) {
		sPosition = GetPosition(ChorusDx[Voice], ChorusDy[Voice], False);
	} else {
		sPosition = GetYPosition(ChorusDy[Voice]);
	}
	sColor = '' & ChorusColor[Voice];
	WriteXML('<lyric number=\'1\' name=\'chorus\' ' & 
			 sPosition & sColor & '>', 4);
	WriteLyricContent(ChorusText[Voice], ChorusType[Voice],
					  ChorusPrevType[Voice], ChorusNotes[Voice]);
	WriteXML('</lyric>', 4);
	ChorusText[Voice] = '';
	ChorusPrevType[Voice] = 0 + ChorusType[Voice];
}

if ((Length(AboveText[Voice]) > 0) and
	 ((not AboveHidden[Voice]) or fAllLyricsHidden)) {
	if (AbovePositions[Voice] = ThisEntry.Position) {
		sPosition = GetPosition(AboveDx[Voice], AboveDy[Voice], False);
	} else {
		sPosition = GetYPosition(AboveDy[Voice]);
	}
	sColor = '' & AboveColor[Voice];
	WriteXML('<lyric number=\'1\' name=\'verse\' placement=\'above\' ' & 
			  sPosition & sColor & '>', 4);
	WriteLyricContent(AboveText[Voice], AboveType[Voice],
					  AbovePrevType[Voice], AboveNotes[Voice]);
	WriteXML('</lyric>', 4);
	AboveText[Voice] = '';
	AbovePrevType[Voice] = 0 + AboveType[Voice];
}

// Verse lyrics are done, so clear AnyVisibleLyric and VerseMax
// for this voice.
AnyVisibleLyric[Voice] = False;
VerseMax[Voice] = 0;
}"
	WriteSlurs "(ThisEntry, SlurStarts, SlurStops) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Write out the slur starts, then the slur stops,
// based on the input arrays.
for i = 1 to 17 {
	sStartPosition = '';
	sStopPosition = '';
	if (SlurStarts[i]) {
		// Look ahead and remove any duplicate slurs to this one
		// if we do not have a chord.
		if (ThisEntry.NoteCount < 2) {
			RemoveDuplicateSlurs(i, SlurStarts, SlurStops);
		}
	
		// We cannot tell orientation: the slur style is only
		// a starting point, not the actual orientation.

		// Get line type from style ID. These are not
		// across all documents, but better than nothing.
		sSlurStyleId = '' & SlurStyleIds[i];
		sColor = '' & SlurColors[i];
		sLineType  = '';
		sPosition = '';
		fBend = False;

		// Only write out x position on same-note slurs that have
		// different start and stop x values, and only if the
		// slur position is the same as the note position.
		// Dy and RhDy are unreliable for slur objects.

		if (SlurStops[i]) {
			if (SlurStartPositions[i] = ThisEntry.Position) {
				sStartPosition = ' ' & GetXPosition(SlurStartDx[i], False);
			}
			if (SlurStopPositions[i] = ThisEntry.Position) {
				sStopPosition = ' ' & GetXPosition(SlurStopDx[i], False);
			}			
			// If XML positions do not differ, then do not write them out.
			if (sStartPosition = sStopPosition) {
				sStartPosition = '';
				sStopPosition = '';
			}
		}

		switch (sSlurStyleId) {
			case ('line.staff.slur.down.dashed') {
				sLineType = 'dashed';
			}
			case ('line.staff.slur.up.dashed') {
				sLineType = 'dashed';
			}
			case ('line.staff.slur.down.dotted') {
				sLineType = 'dotted';
			}
			case ('line.staff.slur.up.dotted') {
				sLineType = 'dotted';
			}
			case ('line.staff.bend') {
				// This really should be exported as a bend,
				// so log the error.
				fBend = True;
			}
		}
		if (Length(sLineType) > 0) {
			sLineType = ' line-type=\'' & sLineType & '\'';
		}
		sSlur = '<slur type=\'start\' number=\'' & i & '\'' & sLineType & sStartPosition & 
				 sColor & '/>';
		if (fBend) {
			LogError('Bend exported as slur', 5);
		}
		WriteXML(sSlur, 5);
		// Reset the start bar so this does not get rewritten later.
		SlurStartBars[i] = 0;
	}

	if (SlurStops[i]) {
		WriteXML('<slur type=\'stop\' number=\'' & i & '\'' & sStopPosition & '/>', 5);
		SlurStopBars[i] = 0;	// free this slur for reuse
		SlurCounts = SlurCounts - 1;
	}
}
}"
	InitializeData "(ThisScore) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// If true, show traces.
ShowTrace = False;

// Commonly used character values
SpaceChar = Chr(32);
SpaceCharInt = 32;
ZeroChar = Chr(48);
ZeroCharInt = 48;
PeriodChar = Chr(46);
PeriodCharInt = 46;

// XML writing and buffering
XmlLineNumber = 0;
XmlText = '';
XmlTextBufferSize = 32000;
XmlCrLf = '' & Chr(13) & Chr(10);

// Initial Sibelius version feature availability
AtLeastSib20201 = False;
AtLeastSib20203 = False;
AtLeastSib20209 = False;
AtLeastSib202012 = False;
AtLeastSib20212 = False;
AtLeastSib20219 = False;
AtLeastSib202212 = False;
UseTranspose = ThisScore.TransposingScore;
UseVoice = True;

// TiedInto and friends available in 2020.1
if (Sibelius.ProgramVersion >= 20200100) {
	AtLeastSib20201 = True;
	// LvTie available in 2020.3
	if (Sibelius.ProgramVersion >= 20200300) {
		AtLeastSib20203 = True;
		// Several changes and additions in 2020.9
		if (Sibelius.ProgramVersion >= 20200900) {
			AtLeastSib20209 = True;
			// CloseAllWindowsForScore available in 2020.12
			if (Sibelius.ProgramVersion >= 20201200) {
				AtLeastSib202012 = True;
				// Command access added in 2021.2
				if (Sibelius.ProgramVersion >= 20210200) {
					AtLeastSib20212 = True;
					// Cross-staff added in 2021.9
					if (Sibelius.ProgramVersion >= 20210900) {
						AtLeastSib20219 = True;
						// New barlines and engraving rules added in 2022.12
						if (Sibelius.ProgramVersion >= 20221200) {
							AtLeastSib202212 = True;
						}
					}
				}
			}
		}
	}
}
WrittenDiatonicPitchOK = True;

// We do not have a tab or percussion clef by default.
TabClef = -1;
TabStrings = 6;
PercussionClef = -1;
PercStaffLines = 5;
Staves = 0;

// Second set of standard coda/segno symbols
CodaSymbol2 = 12 + CodaSymbol;
SegnoSymbol12 = 12 + SegnoSymbol;

// Chord symbol data
DegreeCount = 0;
DegreesToPrint = 0;
ChordsParsed = 0;
ChordsTotal = 0;

// Ending data
LeftEndingBar = 0;
RightEndingBar = 0;
LeftEnding = '';
LeftEndingColor = '';
RightEnding = '';
RightEndingType = '';
UnknownEnding = False;

// Beaming data
NextEntryBeam = NoBeam;
NextEntryDuration = 0;
NextGraceEntryBeam = NoBeam;
NextGraceEntryDuration = 0;

// Transpose data
LastTransposeChromatic = 0;
LastTransposeDiatonic = 0;
LastTransposeOctaveChange = 0;
TransposeChromatic = 0;
TransposeDiatonic = 0;
TransposeOctaveChange = 0;
TransposePartClefStyleId = '';

// Key data
LastKeyFifths = 0;
LastKeyMode = '';
KeyFifths = 0;
KeyMode = '';

// Type-related data
TimeModActualNotes = 0;
TimeModNormalNotes = 0;
TimeModNormalType = '';
TimeModNormalDots = 0;
ExtendedTuplet = False;
SymbolSize = '';
IsCue = False;
XmlType = '';
XmlDots = 0;
XmlBeams = 0;
TypeDataType = 'type';
TypeDataDots = 'dots';
TypeDataBeams = 'beams';
IgnoreNestedTuplets = False;

// Text data
DirectionHasParen = False;
MusicTextFontName = '';
WildcardOK = False;
MainTextFontName = '';
MainTextFontSize = 0;
InitialTopSystemDistanceAddition = 0;

// Lyric elision data. We use the hard space to create
// elisions between two separate lyric text items, and
// search for regular space, hard space, soft hyphen,
// and the underscore for elisions. The underscore in
// Sibelius data looks like an undertie in the score.
HardSpace = '' & ' ';
Elisions = '  ­_';
SoftHyphen = '' & '­';
Undertie = '' & '‿';

// Initialize the data elements, mostly our arrays.

// Initialize scalar data
Title = '';
Composer = '';
Lyricist = '';
Copyright = '';

// Initialize NoteRest-specific data
NoteRestColor = '';
NoteRestDuration = 0;

// Engraving rule data for places where we do not
// have easy access to the score element.
CancelKey = 0;
if (ThisScore.EngravingRules.CautionaryNaturalsInKeySignatures) {
	CancelKey = 1;
}
DoubleTremoloStyle = ThisScore.EngravingRules.DoubleTremoloStyle;

// Save live mode setting for the score in a global.
// Save as integer since globals cannot be boolean.
LiveModeOn = 0;
if (ThisScore.LiveMode) {
	LiveModeOn = 1;
}

FirstVisibleStaffForFirstMeasure = 0;

// Text repeat playback data
TextRepeatPlayback = False;
FineBar = 0;
SegnoBar = 0;
CodaBar = 0;
ToCodaBar = 0;
DcFineBar = 0;
DcCodaBar = 0;
DsFineBar = 0;
DsCodaBar = 0;
UnknownRepeatBar = 0;
LastEndRepeatBar = 0;

// Sparse arrays for converting a MIDI value in a fret instrument
// into MusicXML staff-tuning. Biased towards sharp keys since
// that is the majority of fretted string tunings.
Self._property:MidiStringStep =
	CreateSparseArray('C', 'C', 'D', 'D', 'E', 'F', 'F', 'G', 'G', 'A', 'B', 'B' );
Self._property:MidiStringAlter =
	CreateSparseArray(0, 1, 0, 1, 0, 0, 1, 0, 1, 0, -1, 0);

// Conversion from diatonic value to MusicXML step
Self._property:DiatonicToStep = CreateSparseArray('C', 'D', 'E', 'F', 'G', 'A', 'B');
Self._property:DiatonicToChromatic = CreateSparseArray(0, 2, 4, 5, 7, 9, 11);

// Array for converting transposed key signatures.
// This provides the default conversion from chromatic
// values to the alteration of the MusicXML fifths value.
// This is array is for chromatic values from -11 to 11,
// so add 11 to the chromatic value before accessing.
Self._property:ChromaticKeySig =
	CreateSparseArray(5, -2, 3, -4, 1, -6, -1, 4, -3, 2, -5, 0,
					  5, -2, 3, -4, 1, -6, -1, 4, -3, 2, -5);

// Array for accidentals. Offset by 2 since negative
// values do not work for an index.
Self._property:AccidentalValues =
	CreateSparseArray('flat-flat', 'flat', 'natural', 'sharp', 'double-sharp');

// Array for harp pedal step values, with a null
// string where the dividing line goes.
Self._property:HarpPedalSteps = CreateSparseArray('D', 'C', 'B', '', 'E', 'F', 'G', 'A');

// Array for hex conversion, used for color export
Self._property:Hex =
	CreateSparseArray('0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
					  'A', 'B', 'C', 'D', 'E', 'F');

// Dictionary for identifying text repeats we understand for playback
Self._property:KnownTextRepeats = CreateDictionary(
	'fine', 'fine',
	'coda', 'coda',
	'Ø', 'coda',
	'ø', 'coda',
	'Øcoda', 'coda',
	'øcoda', 'coda',
	'codaØ', 'coda',
	'codaø', 'coda',
	'$', 'segno',
	'@', 'segno',
	'tocoda', 'tocoda',
	'tocodaØ', 'tocoda',
	'tocodaø', 'tocoda',
	'toØcoda', 'tocoda',
	'toøcoda', 'tocoda',
	'dc', 'dcfine',
	'dcalfine', 'dcfine',
	'ds', 'dsfine',
	'dsalfine', 'dsfine',
	'ds$alfine', 'dsfine',
	'ds@alfine', 'dsfine',
	'dcalcoda', 'dccoda',
	'dcalØcoda', 'dccoda',
	'dcaløcoda', 'dccoda',
	'dcalcodaØ', 'dccoda',
	'dcalcodaø', 'dccoda',
	'dsalcoda',	'dscoda',
	'ds$alcoda', 'dscoda',
	'ds@alcoda', 'dscoda',
	'dsalØcoda', 'dscoda',
	'ds$alØcoda', 'dscoda',
	'ds@alØcoda', 'dscoda',
	'dsaløcoda', 'dscoda',
	'ds$aløcoda', 'dscoda',
	'ds@aløcoda', 'dscoda',
	'dsalcodaØ', 'dscoda',
	'ds$alcodaØ', 'dscoda',
	'ds@alcodaØ', 'dscoda',
	'dsalcodaø', 'dscoda',
	'ds$alcodaø', 'dscoda',
	'ds@alcodaø', 'dscoda'
);

// Arrays for tie and tied elements

Self._property:TieStopNextBar = CreateSparseArray();
Self._property:TieStopNextStaff = CreateSparseArray();
Self._property:TieStopThisBar = CreateSparseArray();
Self._property:TieStopThisStaff = CreateSparseArray();
Self._property:TieStopThisPosition = CreateSparseArray();
Self._property:TieStartVoice = CreateSparseArray();

// Part instrument arrays and scalars
Self._property:PartEndGroup = CreateSparseArray();
Self._property:PartInstrumentsCount = CreateSparseArray();
Self._property:PartInstrumentsStart = CreateSparseArray();
Self._property:PartInstrumentsSib = CreateSparseArray();
Self._property:PartInstrumentsXml = CreateSparseArray();
PartInstrumentsSize = 0;
Self._property:CurrentPartInstrument = CreateSparseArray();

// Per-staff arrays
Self._property:HiddenStaff = CreateSparseArray();
Self._property:StaffDetailsPrintObject = CreateSparseArray();
Self._property:StaffLines = CreateSparseArray();
Self._property:LastMeasureRepeat = CreateSparseArray();
Self._property:MeasureRepeatStopBars = CreateSparseArray();

// MusicXML clef data
Self._property:LastClefSign = CreateSparseArray();
Self._property:LastClefLine = CreateSparseArray();
Self._property:LastClefOctaveChange = CreateSparseArray();
Self._property:LastClefBar = CreateSparseArray();
Self._property:LastClefPosition = CreateSparseArray();

// Arrays for notations

Self._property:DoubleTremolos = CreateSparseArray();
Self._property:TremoloType = CreateSparseArray();
Self._property:LastTupletPosition = CreateSparseArray();

Self._property:ArpeggioBars = CreateSparseArray();
Self._property:ArpeggioColors = CreateSparseArray();
Self._property:ArpeggioPositions = CreateSparseArray();
Self._property:ArpeggioDirections = CreateSparseArray();

Self._property:NonArpeggiateBars = CreateSparseArray();
Self._property:NonArpeggiateColors = CreateSparseArray();
Self._property:NonArpeggiatePositions = CreateSparseArray();

Self._property:SlurStartBars = CreateSparseArray();
Self._property:SlurStartDx = CreateSparseArray();
Self._property:SlurStartDy = CreateSparseArray();
Self._property:SlurStartPositions = CreateSparseArray();
Self._property:SlurStopBars = CreateSparseArray();
Self._property:SlurStopDx = CreateSparseArray();
Self._property:SlurStopDy = CreateSparseArray();
Self._property:SlurStopPositions = CreateSparseArray();
Self._property:SlurStyleIds = CreateSparseArray();
Self._property:SlurVoices = CreateSparseArray();
Self._property:SlurStaffs = CreateSparseArray();
Self._property:SlurColors = CreateSparseArray();

Self._property:GlissandoStartBars = CreateSparseArray();
Self._property:GlissandoStartPositions = CreateSparseArray();
Self._property:GlissandoStopBars = CreateSparseArray();
Self._property:GlissandoStopPositions = CreateSparseArray();
Self._property:GlissandoStyleIds = CreateSparseArray();
Self._property:GlissandoVoices = CreateSparseArray();
Self._property:GlissandoStaffs = CreateSparseArray();
Self._property:GlissandoColors = CreateSparseArray();
Self._property:GlissandoStartDy = CreateSparseArray();
Self._property:GlissandoStopDy = CreateSparseArray();

Self._property:TrillStartBars = CreateSparseArray();
Self._property:TrillStartPositions = CreateSparseArray();
Self._property:TrillStopBars = CreateSparseArray();
Self._property:TrillStopPositions = CreateSparseArray();
Self._property:TrillVoices = CreateSparseArray();
Self._property:TrillStaffs = CreateSparseArray();
Self._property:TrillColors = CreateSparseArray();
Self._property:TrillStartDx = CreateSparseArray();
Self._property:TrillStartDy = CreateSparseArray();
Self._property:TrillStopDx = CreateSparseArray();
Self._property:TrillStopDy = CreateSparseArray();

SymbolCount = 0;
Self._property:SymbolIndices = CreateSparseArray();
Self._property:SymbolPositions = CreateSparseArray();
Self._property:SymbolParents = CreateSparseArray();
Self._property:SymbolDx = CreateSparseArray();
Self._property:SymbolDy = CreateSparseArray();
Self._property:SymbolColors = CreateSparseArray();

FingeringCount = 0;
Self._property:Fingerings = CreateSparseArray();
Self._property:FingeringPositions = CreateSparseArray();
Self._property:FingeringDx = CreateSparseArray();
Self._property:FingeringDy = CreateSparseArray();
Self._property:FingeringWritten = CreateSparseArray();
Self._property:FingeringVoices = CreateSparseArray();
Self._property:FingeringColor = CreateSparseArray();
Self._property:FingeringCueSize = CreateSparseArray();

Self._property:SlideNumbers = CreateSparseArray();
Self._property:SlideStop = CreateSparseArray();

// Arrays for lyrics

Self._property:AnyVisibleLyric = CreateSparseArray();
Self._property:VerseMax = CreateSparseArray();
Self._property:Verse1Notes = CreateSparseArray();
Self._property:Verse1Dx = CreateSparseArray();
Self._property:Verse1Dy = CreateSparseArray();
Self._property:Verse1Positions = CreateSparseArray();
Self._property:Verse1Text = CreateSparseArray();
Self._property:Verse1Type = CreateSparseArray();
Self._property:Verse1PrevType = CreateSparseArray();
Self._property:Verse1Hidden = CreateSparseArray();
Self._property:Verse1Color = CreateSparseArray();
Self._property:Verse2Notes = CreateSparseArray();
Self._property:Verse2Dx = CreateSparseArray();
Self._property:Verse2Dy = CreateSparseArray();
Self._property:Verse2Positions = CreateSparseArray();
Self._property:Verse2Text = CreateSparseArray();
Self._property:Verse2Type = CreateSparseArray();
Self._property:Verse2PrevType = CreateSparseArray();
Self._property:Verse2Hidden = CreateSparseArray();
Self._property:Verse2Color = CreateSparseArray();
Self._property:Verse3Notes = CreateSparseArray();
Self._property:Verse3Dx = CreateSparseArray();
Self._property:Verse3Dy = CreateSparseArray();
Self._property:Verse3Positions = CreateSparseArray();
Self._property:Verse3Text = CreateSparseArray();
Self._property:Verse3Type = CreateSparseArray();
Self._property:Verse3PrevType = CreateSparseArray();
Self._property:Verse3Hidden = CreateSparseArray();
Self._property:Verse3Color = CreateSparseArray();
Self._property:Verse4Notes = CreateSparseArray();
Self._property:Verse4Dx = CreateSparseArray();
Self._property:Verse4Dy = CreateSparseArray();
Self._property:Verse4Positions = CreateSparseArray();
Self._property:Verse4Text = CreateSparseArray();
Self._property:Verse4Type = CreateSparseArray();
Self._property:Verse4PrevType = CreateSparseArray();
Self._property:Verse4Hidden = CreateSparseArray();
Self._property:Verse4Color = CreateSparseArray();
Self._property:Verse5Notes = CreateSparseArray();
Self._property:Verse5Dx = CreateSparseArray();
Self._property:Verse5Dy = CreateSparseArray();
Self._property:Verse5Positions = CreateSparseArray();
Self._property:Verse5Text = CreateSparseArray();
Self._property:Verse5Type = CreateSparseArray();
Self._property:Verse5PrevType = CreateSparseArray();
Self._property:Verse5Hidden = CreateSparseArray();
Self._property:Verse5Color = CreateSparseArray();
Self._property:ChorusNotes = CreateSparseArray();
Self._property:ChorusDx = CreateSparseArray();
Self._property:ChorusDy = CreateSparseArray();
Self._property:ChorusPositions = CreateSparseArray();
Self._property:ChorusText = CreateSparseArray();
Self._property:ChorusType = CreateSparseArray();
Self._property:ChorusPrevType = CreateSparseArray();
Self._property:ChorusHidden = CreateSparseArray();
Self._property:ChorusColor = CreateSparseArray();
Self._property:AboveNotes = CreateSparseArray();
Self._property:AboveDx = CreateSparseArray();
Self._property:AboveDy = CreateSparseArray();
Self._property:AbovePositions = CreateSparseArray();
Self._property:AboveText = CreateSparseArray();
Self._property:AboveType = CreateSparseArray();
Self._property:AbovePrevType = CreateSparseArray();
Self._property:AboveHidden = CreateSparseArray();
Self._property:AboveColor = CreateSparseArray();

// Arrays for directions

Self._property:BracketStopBars = CreateSparseArray();
Self._property:BracketStopEnds = CreateSparseArray();
Self._property:BracketStopPositions = CreateSparseArray();
Self._property:BracketStopStaffs = CreateSparseArray();
Self._property:BracketStopVoices = CreateSparseArray();
Self._property:BracketStopYs = CreateSparseArray();

Self._property:DashesStopBars = CreateSparseArray();
Self._property:DashesStopPositions = CreateSparseArray();
Self._property:DashesStopStaffs = CreateSparseArray();
Self._property:DashesStopVoices = CreateSparseArray();
Self._property:DashesStopYs = CreateSparseArray();

Self._property:OctaveStopBars = CreateSparseArray();
Self._property:OctaveStopPositions = CreateSparseArray();
Self._property:OctaveStopStaffs = CreateSparseArray();
Self._property:OctaveStopSizes = CreateSparseArray();
Self._property:OctaveAdds = CreateSparseArray();
Self._property:OctaveStopYs = CreateSparseArray();

Self._property:WedgeStopBars = CreateSparseArray();
Self._property:WedgeStopNientes = CreateSparseArray();
Self._property:WedgeStopPositions = CreateSparseArray();
Self._property:WedgeStopStaffs = CreateSparseArray();
Self._property:WedgeStopVoices = CreateSparseArray();
Self._property:WedgeStopYs = CreateSparseArray();

// Arrays for chord symbol degrees
Self._property:DegreeValues = CreateSparseArray();
Self._property:DegreeAlters = CreateSparseArray();
Self._property:DegreeTypes = CreateSparseArray();
Self._property:DegreePrints = CreateSparseArray();
Self._property:DegreeValueTexts = CreateSparseArray();
Self._property:DegreeTypeTexts = CreateSparseArray();
Self._property:DegreeSymbols = CreateSparseArray();

// Array for beaming
Self._property:PreviousEntryDuration = CreateSparseArray();
Self._property:PreviousEntryBeam = CreateSparseArray();
Self._property:PreviousPrimaryBeamOnly = CreateSparseArray();
Self._property:PreviousGraceEntryDuration = CreateSparseArray();
Self._property:PreviousGraceEntryBeam = CreateSparseArray();
Self._property:PreviousGracePrimaryBeamOnly = CreateSparseArray();

// Array for tab strings. This is indexed
// by staff line, so 0 is the bottom string.
// Sibelius always uses 0 as the low 
// string, while MusicXML uses 1 as the
// lowest line but also the highest string.
Self._property:StringPitch = CreateSparseArray();

// Sparse array for credits
Self._property:PageAlignedItems = CreateSparseArray();

// Lookup arrays
Self._property:MusicTextSymbols = CreateSparseArray();
Self._property:MaestroDynamics = CreateSparseArray();
Self._property:SymbolIndexParents = CreateSparseArray();

// Initialize 16 levels of slur, bracket,
// dashes, octave-shift, trill, and wedge.

for i = 1 to 17 {
	SlurStopBars[i] = 0;
	SlurStyleIds[i] = '';
	GlissandoStopBars[i] = 0;
	GlissandoStyleIds[i] = '';
	BracketStopBars[i] = 0;
	DashesStopBars[i] = 0;
	OctaveStopBars[i] = 0;
	OctaveAdds[i] = 0;
	WedgeStopBars[i] = 0;
	TrillStopBars[i] = 0;
	BracketStopEnds[i] = '';
}

// Initialize lookup arrays

// Music text symbols come from Opus Text Std font.
MusicTextSymbols[35] = 'accidentalSharp';
MusicTextSymbols[36] = 'segno';
MusicTextSymbols[40] = 'lyricsElision';
MusicTextSymbols[41] = 'lyricsElision';
MusicTextSymbols[43] = 'csymAugmented';
MusicTextSymbols[46] = 'metAugmentationDot';
MusicTextSymbols[48] = 'tuplet0';
MusicTextSymbols[49] = 'tuplet1';
MusicTextSymbols[50] = 'tuplet2';
MusicTextSymbols[51] = 'tuplet3';
MusicTextSymbols[52] = 'tuplet4';
MusicTextSymbols[53] = 'tuplet5';
MusicTextSymbols[54] = 'tuplet6';
MusicTextSymbols[55] = 'tuplet7';
MusicTextSymbols[56] = 'tuplet8';
MusicTextSymbols[57] = 'tuplet9';
MusicTextSymbols[58] = 'tupletColon';
MusicTextSymbols[60] = 'metricModulationArrowLeft';
MusicTextSymbols[62] = 'metricModulationArrowRight';
MusicTextSymbols[64] = 'segnoJapanese';
MusicTextSymbols[66] = 'figbass2Raised';
MusicTextSymbols[68] = 'figbass4Raised';
MusicTextSymbols[69] = 'figbass5Raised1';
MusicTextSymbols[74] = 'textTuplet3ShortStem';
MusicTextSymbols[75] = 'textTuplet3Symbols';	// Special case name for 3 SMuFL glyphs
MusicTextSymbols[76] = 'harpPedalRaised';
MusicTextSymbols[77] = 'harpPedalCentered';
MusicTextSymbols[78] = 'harpPedalLowered';
MusicTextSymbols[79] = 'harpPedalDivider';
MusicTextSymbols[80] = 'keyboardPedalPed';
MusicTextSymbols[86] = 'metNoteDoubleWholeSquare';
MusicTextSymbols[87] = 'metNoteDoubleWhole';
MusicTextSymbols[88] = 'accidentalDoubleSharp';
MusicTextSymbols[94] = 'csymMajorSeventh';
MusicTextSymbols[95] = 'lyricsElisionNarrow';
MusicTextSymbols[98] = 'accidentalFlat';
MusicTextSymbols[101] = 'metNote8thUp';
MusicTextSymbols[102] = 'dynamicForte';
MusicTextSymbols[104] = 'metNoteHalfUp';
MusicTextSymbols[105] = 'metNote8thUp';			// Beamed in non-SMuFL way
MusicTextSymbols[106] = 'metNote16thUp';		// Beamed in non-SMuFL way
MusicTextSymbols[107] = 'metNote32ndUp';		// Beamed in non-SMuFL way
MusicTextSymbols[108] = 'dynamicMezzo';
MusicTextSymbols[109] = 'dynamicNiente';
MusicTextSymbols[111] = 'dynamicPiano';
MusicTextSymbols[113] = 'metNoteQuarterUp';
MusicTextSymbols[108] = 'dynamicRinforzando';
MusicTextSymbols[108] = 'dynamicSforzando';
MusicTextSymbols[119] = 'metNoteWhole';
MusicTextSymbols[120] = 'metNote16thUp';
MusicTextSymbols[121] = 'metNote32ndUp';
MusicTextSymbols[122] = 'dynamicZ';
MusicTextSymbols[123] = 'restHBarLeft';
MusicTextSymbols[124] = 'miscDoNotPhotocopy';
MusicTextSymbols[125] = 'restHBarRight';
MusicTextSymbols[167] = 'accidentalNatural';
MusicTextSymbols[186] = 'accidentalDoubleFlat';
MusicTextSymbols[188] = 'figbass4Raised';
MusicTextSymbols[189] = 'figbass2Raised';
MusicTextSymbols[190] = 'figbass5Raised1';
MusicTextSymbols[191] = 'figbass6Raised';
MusicTextSymbols[192] = 'figbass7Diminished';
MusicTextSymbols[193] = 'figbass9Raised';
MusicTextSymbols[194] = 'figbass5Raised3';
MusicTextSymbols[215] = 'accidentalDoubleSharp';
MusicTextSymbols[216] = 'coda';
MusicTextSymbols[221] = 'metNoteDoubleWholeSquare';
MusicTextSymbols[248] = 'codaJapanese';

// Sometimes we have Sibelius files using Maestro for
// music text, which does not match the Sibelius standard
// for music text fonts. Start by handling dynamics.

MaestroDynamics[70] = 'mf';
MaestroDynamics[80] = 'mp';
MaestroDynamics[83] = 'sf';
MaestroDynamics[90] = 'fz';
MaestroDynamics[102] = '' & 'f';
MaestroDynamics[112] = '' & 'p';
MaestroDynamics[115] = '' & 's';
MaestroDynamics[122] = '' & 'z';
MaestroDynamics[130] = 'sfp';
MaestroDynamics[141] = 'sffz';
MaestroDynamics[142] = '' & 'r';
MaestroDynamics[150] = '' & 'n';
MaestroDynamics[167] = 'sfz';
MaestroDynamics[175] = 'pppp';
MaestroDynamics[182] = 'sfpp';
MaestroDynamics[184] = 'ppp';
MaestroDynamics[185] = 'pp';
MaestroDynamics[189] = '' & 'm';
MaestroDynamics[196] = 'ff';
MaestroDynamics[234] = 'fp';
MaestroDynamics[235] = 'ffff';
MaestroDynamics[236] = 'fff';

// Symbol index lookup for those we are exporting. Symbols
// up through 480 have fixed meaning in Sibelius.

SymbolIndexParents[1] = 'direction-type';	// segno
SymbolIndexParents[2] = 'direction-type';	// coda
SymbolIndexParents[3] = 'direction-type';	// segno (serpent)
SymbolIndexParents[4] = 'direction-type';	// segno (serpent)	
SymbolIndexParents[5] = 'direction-type';	// symbol repeatBarSlash
SymbolIndexParents[6] = 'direction-type';	// symbol repeat1Bar
SymbolIndexParents[7] = 'direction-type';	// symbol repeat2Bars
SymbolIndexParents[8] = 'direction-type';	// symbol repeat4Bars
SymbolIndexParents[9] = 'direction-type';	// symbol barlineSingle
SymbolIndexParents[10] = 'direction-type';	// symbol repeatLeft
SymbolIndexParents[11] = 'direction-type';	// symbol repeatRight
SymbolIndexParents[12] = 'direction-type';	// symbol barlineFinal
SymbolIndexParents[13] = 'direction-type';	// segno
SymbolIndexParents[14] = 'direction-type';	// coda
SymbolIndexParents[16] = 'direction-type';	// symbol
SymbolIndexParents[18] = 'direction-type';	// words (
SymbolIndexParents[19] = 'direction-type';	// words )
SymbolIndexParents[20] = 'direction-type';	// words {
SymbolIndexParents[21] = 'direction-type';	// words }
SymbolIndexParents[26] = 'direction-type';	// words )
SymbolIndexParents[30] = 'direction-type';	// words -
SymbolIndexParents[31] = 'direction-type';	// words )
SymbolIndexParents[32] = 'ornaments';		// trill-mark
SymbolIndexParents[33] = 'ornaments';		// trill-mark in parens
SymbolIndexParents[36] = 'ornaments';		// inverted-mordent
SymbolIndexParents[37] = 'ornaments';		// mordent
SymbolIndexParents[38] = 'ornaments';		// turn
SymbolIndexParents[39] = 'ornaments';		// slashed turn
SymbolIndexParents[40] = 'ornaments';		// inverted-turn
SymbolIndexParents[41] = 'ornaments';		// inverted-mordent, long
SymbolIndexParents[42] = 'ornaments';		// mordent, long
SymbolIndexParents[43] = 'ornaments';		// inverted-mordent, departure above
SymbolIndexParents[44] = 'ornaments';		// inverted-mordent, long, approach below
SymbolIndexParents[45] = 'ornaments';		// inverted-mordent, long, approach above
SymbolIndexParents[46] = 'ornaments';		// other-ornament
SymbolIndexParents[48] = 'direction-type';	// pedal type='down'
SymbolIndexParents[49] = 'direction-type';	// pedal type='down'
SymbolIndexParents[50] = 'direction-type';	// pedal type='up'
SymbolIndexParents[51] = 'direction-type';	// pedal type='change'
SymbolIndexParents[52] = 'technical';		// heel
SymbolIndexParents[53] = 'technical';		// heel
SymbolIndexParents[54] = 'technical';		// toe
SymbolIndexParents[55] = 'technical';		// toe
SymbolIndexParents[64] = 'percussion';		// pitched glockenspiel
SymbolIndexParents[65] = 'percussion';		// pitched marimba
SymbolIndexParents[66] = 'percussion';		// pitched vibraphone
SymbolIndexParents[67] = 'percussion';		// pitched xylophone
SymbolIndexParents[68] = 'percussion';		// timpani
SymbolIndexParents[69] = 'percussion';		// pitched tubular chimes
SymbolIndexParents[70] = 'percussion';		// metal crotale
SymbolIndexParents[71] = 'percussion';		// effect slide whistle
SymbolIndexParents[80] = 'percussion';		// membrane snare drum
SymbolIndexParents[81] = 'percussion';		// membrane snare drum snares off
SymbolIndexParents[82] = 'percussion';		// membrane miltary drum
SymbolIndexParents[83] = 'percussion';		// membrane bass drum
SymbolIndexParents[84] = 'percussion';		// membrane bass drum on side
SymbolIndexParents[85] = 'percussion';		// membrane bongos
SymbolIndexParents[86] = 'percussion';		// membrane tomtom
SymbolIndexParents[87] = 'percussion';		// wood wood block
SymbolIndexParents[88] = 'percussion';		// membrane tambourine
SymbolIndexParents[89] = 'percussion';		// membrane timbales
SymbolIndexParents[90] = 'percussion';		// wood slit drum
SymbolIndexParents[91] = 'percussion';		// membrane conga drum
SymbolIndexParents[92] = 'percussion';		// wood log drum
SymbolIndexParents[93] = 'percussion';		// wood temple block
SymbolIndexParents[94] = 'percussion';		// membrane tenor drum
SymbolIndexParents[96] = 'percussion';		// metal crash cymbals
SymbolIndexParents[97] = 'percussion';		// metal suspended cymbal
SymbolIndexParents[98] = 'percussion';		// metal hi-hat
SymbolIndexParents[99] = 'percussion';		// metal sizzle cymbal
SymbolIndexParents[100] = 'percussion';		// metal tam tam
SymbolIndexParents[101] = 'percussion';		// metal gong
SymbolIndexParents[102] = 'percussion';		// metal domed gong
SymbolIndexParents[103] = 'percussion';		// metal triangle
SymbolIndexParents[104] = 'percussion';		// metal sleigh bells
SymbolIndexParents[105] = 'percussion';		// metal cowbell
SymbolIndexParents[106] = 'percussion';		// metal almglocken
SymbolIndexParents[107] = 'percussion';		// effect anvil
SymbolIndexParents[108] = 'percussion';		// metal bell plate
SymbolIndexParents[109] = 'percussion';		// metal brake drum
SymbolIndexParents[110] = 'percussion';		// metal flexatone
SymbolIndexParents[112] = 'percussion';		// wood maraca
SymbolIndexParents[113] = 'percussion';		// wood cabasa
SymbolIndexParents[114] = 'percussion';		// wood claves
SymbolIndexParents[115] = 'percussion';		// wood guiro
SymbolIndexParents[116] = 'percussion';		// wood ratchet
SymbolIndexParents[117] = 'percussion';		// wood board clapper
SymbolIndexParents[118] = 'percussion';		// effect lions roar
SymbolIndexParents[119] = 'percussion';		// effect bird whistle
SymbolIndexParents[120] = 'percussion';		// effect siren
SymbolIndexParents[121] = 'percussion';		// effect wind machine
SymbolIndexParents[122] = 'percussion';		// effect thunder sheet
SymbolIndexParents[123] = 'percussion';		// effect police whistle
SymbolIndexParents[124] = 'percussion';		// effect gun shot
SymbolIndexParents[125] = 'percussion';		// wood sandpaper blocks
SymbolIndexParents[126] = 'percussion';		// effect auto horn
SymbolIndexParents[127] = 'percussion';		// glass wind chimes
SymbolIndexParents[128] = 'percussion';		// stick xylophone soft
SymbolIndexParents[129] = 'percussion';		// stick xylophone medium
SymbolIndexParents[130] = 'percussion';		// stick xylophone hard
SymbolIndexParents[131] = 'percussion';		// stick xylophone shaded
SymbolIndexParents[132] = 'percussion';		// stick timpani soft
SymbolIndexParents[133] = 'percussion';		// stick timpani medium
SymbolIndexParents[134] = 'percussion';		// stick timpani hard
SymbolIndexParents[135] = 'percussion';		// stick timpani shaded
SymbolIndexParents[136] = 'percussion';		// stick bass drum soft
SymbolIndexParents[137] = 'percussion';		// stick bass drum medium
SymbolIndexParents[138] = 'percussion';		// stick bass drum hard
SymbolIndexParents[139] = 'percussion';		// stick double bass drum soft
SymbolIndexParents[140] = 'percussion';		// stick yarn soft
SymbolIndexParents[141] = 'percussion';		// stick yarn medium
SymbolIndexParents[142] = 'percussion';		// stick yarn hard
SymbolIndexParents[144] = 'percussion';		// beater snare stick
SymbolIndexParents[145] = 'percussion';		// beater jazz stick
SymbolIndexParents[146] = 'percussion';		// beater triangle beater
SymbolIndexParents[147] = 'percussion';		// beater wire brush
SymbolIndexParents[148] = 'percussion';		// stick xylophone x
SymbolIndexParents[149] = 'percussion';		// beater guiro scraper
SymbolIndexParents[150] = 'percussion';		// beater bow
SymbolIndexParents[151] = 'percussion';		// beater chime hammer
SymbolIndexParents[152] = 'percussion';		// beater hand
SymbolIndexParents[153] = 'percussion';		// beater fingernail
SymbolIndexParents[154] = 'percussion';		// beater coin
SymbolIndexParents[160] = 'technical';		// stopped
SymbolIndexParents[161] = 'technical';		// half-muted
SymbolIndexParents[162] = 'technical';		// open
SymbolIndexParents[163] = 'direction-type';	// damp
SymbolIndexParents[164] = 'direction-type';	// damp
SymbolIndexParents[165] = 'technical';		// harmon-mute
SymbolIndexParents[166] = 'technical';		// harmon-mute
SymbolIndexParents[168] = 'percussion';		// stick-location center
SymbolIndexParents[169] = 'percussion';		// stick-location center
SymbolIndexParents[170] = 'percussion';		// stick-location rim
SymbolIndexParents[171] = 'percussion';		// stick-location rim
SymbolIndexParents[172] = 'percussion';		// other-percussion
SymbolIndexParents[187] = 'technical';		// other-technical
SymbolIndexParents[188] = 'technical';		// other-technical
SymbolIndexParents[192] = 'technical';		// string 0
SymbolIndexParents[193] = 'technical';		// string 1
SymbolIndexParents[194] = 'technical';		// string 2
SymbolIndexParents[195] = 'technical';		// string 3
SymbolIndexParents[196] = 'technical';		// string 4
SymbolIndexParents[197] = 'technical';		// string 5
SymbolIndexParents[198] = 'technical';		// string 6
SymbolIndexParents[199] = 'technical';		// string 7
SymbolIndexParents[200] = 'technical';		// string 8
SymbolIndexParents[201] = 'technical';		// string 9
SymbolIndexParents[202] = 'technical';		// other-technical
SymbolIndexParents[209] = 'articulations';	// staccato
SymbolIndexParents[210] = 'articulations';	// staccatissimo
SymbolIndexParents[211] = 'articulations';	// spiccato
SymbolIndexParents[212] = 'articulations';	// tenuto
SymbolIndexParents[213] = 'articulations';	// accent
SymbolIndexParents[214] = 'articulations';	// strong-accent type='up'
SymbolIndexParents[215] = 'technical';		// harmonic
SymbolIndexParents[216] = 'technical';		// stopped
SymbolIndexParents[217] = 'technical';		// up-bow
SymbolIndexParents[218] = 'technical';		// down-bow
SymbolIndexParents[220] = 'notations';		// fermata type='upright'
SymbolIndexParents[221] = 'notations';		// fermata type='upright'
SymbolIndexParents[222] = 'notations';		// fermata type='upright'
SymbolIndexParents[225] = 'articulations';	// staccato
SymbolIndexParents[226] = 'articulations';	// staccatissimo
SymbolIndexParents[227] = 'articulations';	// spiccato
SymbolIndexParents[228] = 'articulations';	// tenuto
SymbolIndexParents[229] = 'articulations';	// accent
SymbolIndexParents[230] = 'articulations';	// strong-accent type='down'
SymbolIndexParents[231] = 'technical';		// harmonic
SymbolIndexParents[232] = 'technical';		// stopped
SymbolIndexParents[233] = 'technical';		// up-bow
SymbolIndexParents[234] = 'technical';		// down-bow
SymbolIndexParents[236] = 'notations';		// fermata type='inverted'
SymbolIndexParents[237] = 'notations';		// fermata type='inverted'
SymbolIndexParents[238] = 'notations';		// fermata type='inverted'
SymbolIndexParents[240] = 'technical';		// double-tongue
SymbolIndexParents[241] = 'technical';		// triple-tongue
SymbolIndexParents[242] = 'technical';		// other-technical
SymbolIndexParents[243] = 'technical';		// snap-pizzicato
SymbolIndexParents[244] = 'technical';		// snap-pizzicato
SymbolIndexParents[245] = 'technical';		// thumb-position
SymbolIndexParents[246] = 'technical';		// thumb-position
SymbolIndexParents[247] = 'articulations';	// breath-mark comma
SymbolIndexParents[248] = 'articulations';	// breath-mark tick
SymbolIndexParents[249] = 'articulations';	// caesura
SymbolIndexParents[250] = 'articulations';	// caesura
SymbolIndexParents[251] = 'articulations';	// stress
SymbolIndexParents[252] = 'articulations';	// stress
SymbolIndexParents[253] = 'articulations';	// unstress
SymbolIndexParents[254] = 'articulations';	// unstress
SymbolIndexParents[255] = 'articulations';	// spiccato (alternate glyph)
SymbolIndexParents[256] = 'notations';		// accidental-mark flat-flat
SymbolIndexParents[257] = 'notations';		// accidental-mark three-quarters-flat
SymbolIndexParents[258] = 'notations';		// accidental-mark flat
SymbolIndexParents[259] = 'notations';		// accidental-mark quarter-flat
SymbolIndexParents[260] = 'notations';		// accidental-mark natural
SymbolIndexParents[261] = 'notations';		// accidental-mark quarter-sharp
SymbolIndexParents[262] = 'notations';		// accidental-mark sharp
SymbolIndexParents[263] = 'notations';		// accidental-mark three-quarters-sharp
SymbolIndexParents[264] = 'notations';		// accidental-mark double-sharp
SymbolIndexParents[265] = 'notations';		// accidental-mark natural-flat
SymbolIndexParents[266] = 'notations';		// accidental-mark natural-sharp
SymbolIndexParents[267] = 'notations';		// accidental-mark quarter-flat 2
SymbolIndexParents[268] = 'notations';		// accidental-mark flat-up
SymbolIndexParents[269] = 'notations';		// accidental-mark natural-up
SymbolIndexParents[270] = 'notations';		// accidental-mark sharp-up
SymbolIndexParents[271] = 'notations';		// accidental-mark quarter-sharp 3
SymbolIndexParents[272] = 'notations';		// accidental-mark flat-flat paren
SymbolIndexParents[273] = 'notations';		// accidental-mark three-quarters-flat paren
SymbolIndexParents[274] = 'notations';		// accidental-mark flat paren
SymbolIndexParents[275] = 'notations';		// accidental-mark quarter-flat paren
SymbolIndexParents[276] = 'notations';		// accidental-mark natural paren
SymbolIndexParents[277] = 'notations';		// accidental-mark quarter-sharp paren
SymbolIndexParents[278] = 'notations';		// accidental-mark sharp paren
SymbolIndexParents[279] = 'notations';		// accidental-mark three-quarters-sharp paren
SymbolIndexParents[280] = 'notations';		// accidental-mark double-sharp paren
SymbolIndexParents[281] = 'notations';		// accidental-mark natural-flat paren
SymbolIndexParents[282] = 'notations';		// accidental-mark natural-sharp paren
SymbolIndexParents[283] = 'notations';		// accidental-mark three-quarters-flat 2
SymbolIndexParents[284] = 'notations';		// accidental-mark flat-down
SymbolIndexParents[285] = 'notations';		// accidental-mark natural-down
SymbolIndexParents[286] = 'notations';		// accidental-mark sharp-down
SymbolIndexParents[287] = 'notations';		// accidental-mark quarter-flat 5
SymbolIndexParents[288] = 'direction-type';	// symbol note16thUp
SymbolIndexParents[289] = 'direction-type';	// symbol note8thUp
SymbolIndexParents[290] = 'direction-type';	// symbol noteQuarterUp
SymbolIndexParents[291] = 'direction-type';	// symbol noteHalfUp
SymbolIndexParents[292] = 'direction-type';	// symbol flagInternalUp
SymbolIndexParents[293] = 'direction-type';	// symbol augmentationDot
SymbolIndexParents[295] = 'notations';		// tied - l.v. up
SymbolIndexParents[296] = 'direction-type';	// symbol flag8thUp
SymbolIndexParents[297] = 'direction-type';	// symbol flag16thUp
SymbolIndexParents[298] = 'direction-type';	// symbol flag32ndUp
SymbolIndexParents[299] = 'direction-type';	// symbol flag64thUp
SymbolIndexParents[300] = 'direction-type';	// symbol flag128thUp
SymbolIndexParents[301] = 'direction-type';	// symbol flag256thUp
SymbolIndexParents[302] = 'direction-type';	// symbol flag512thUp
SymbolIndexParents[303] = 'direction-type';	// symbol noteheadClusterRoundBlack
SymbolIndexParents[304] = 'direction-type';	// symbol note16thDown
SymbolIndexParents[305] = 'direction-type';	// symbol note8thDown
SymbolIndexParents[306] = 'direction-type';	// symbol noteQuarterDown
SymbolIndexParents[307] = 'direction-type';	// symbol noteHalfDown
SymbolIndexParents[308] = 'direction-type';	// symbol flagInternalDown
SymbolIndexParents[311] = 'notations';		// tied - l.v. down
SymbolIndexParents[312] = 'direction-type';	// symbol flag8thDown
SymbolIndexParents[313] = 'direction-type';	// symbol flag16thDown
SymbolIndexParents[314] = 'direction-type';	// symbol flag32ndDown
SymbolIndexParents[315] = 'direction-type';	// symbol flag64thDown
SymbolIndexParents[316] = 'direction-type';	// symbol flag128thDown
SymbolIndexParents[317] = 'direction-type';	// symbol flag256thDown
SymbolIndexParents[318] = 'direction-type';	// symbol flag512thDown
SymbolIndexParents[320] = 'direction-type';	// symbol noteheadBlack
SymbolIndexParents[321] = 'direction-type';	// symbol noteheadHalf
SymbolIndexParents[322] = 'direction-type';	// symbol noteheadWhole
SymbolIndexParents[323] = 'direction-type';	// symbol noteheadDoubleWhole
SymbolIndexParents[324] = 'direction-type';	// symbol noteheadDoubleWholeSquare
SymbolIndexParents[325] = 'direction-type';	// symbol mensuralWhiteMaxima
SymbolIndexParents[326] = 'direction-type';	// words x
SymbolIndexParents[342] = 'direction-type';	// symbol noteheadWhole (small)
SymbolIndexParents[348] = 'direction-type';	// symbol noteheadBlack (small)
SymbolIndexParents[349] = 'direction-type';	// symbol noteheadHalf (small)
SymbolIndexParents[350] = 'direction-type';	// symbol noteheadBlack (large)
SymbolIndexParents[351] = 'direction-type';	// symbol noteheadHalf (large)
SymbolIndexParents[362] = 'direction-type';	// symbol noteheadBlack (noteShapeRoundBlack)
SymbolIndexParents[363] = 'direction-type';	// symbol noteheadHalf (noteShapeRoundWhite)
SymbolIndexParents[368] = 'direction-type';	// symbol rest512th
SymbolIndexParents[369] = 'direction-type';	// symbol rest256th
SymbolIndexParents[370] = 'direction-type';	// symbol rest128th
SymbolIndexParents[371] = 'direction-type';	// symbol rest64th
SymbolIndexParents[372] = 'direction-type';	// symbol rest32nd
SymbolIndexParents[373] = 'direction-type';	// symbol rest16th
SymbolIndexParents[374] = 'direction-type';	// symbol rest8th
SymbolIndexParents[375] = 'direction-type';	// symbol restQuarter
SymbolIndexParents[376] = 'direction-type';	// symbol restHalf
SymbolIndexParents[377] = 'direction-type';	// symbol restWhole
SymbolIndexParents[378] = 'direction-type';	// symbol restDoubleWhole
SymbolIndexParents[380] = 'direction-type';	// symbol restLonga
SymbolIndexParents[386] = 'direction-type';	// symbol restMaxima
SymbolIndexParents[400] = 'direction-type';	// principal-voice Hauptstimme start
SymbolIndexParents[401] = 'direction-type';	// principal-voice Nebenstimme start
SymbolIndexParents[402] = 'direction-type';	// principal-voice plain start
SymbolIndexParents[403] = 'direction-type';	// principal-voice plain stop
SymbolIndexParents[404] = 'direction-type';	// principal-voice plain start
SymbolIndexParents[405] = 'direction-type';	// principal-voice plain stop
SymbolIndexParents[406] = 'technical';		// arrow northeast
SymbolIndexParents[407] = 'technical';		// arrow southeast
SymbolIndexParents[408] = 'direction-type';	// symbol conductorStrongBeat
SymbolIndexParents[409] = 'direction-type';	// symbol conductorLeftBeat
SymbolIndexParents[410] = 'direction-type';	// symbol conductorRightBeat
SymbolIndexParents[411] = 'direction-type';	// symbol conductorWeakBeat
SymbolIndexParents[412] = 'direction-type';	// symbol conductorBeat2Simple
SymbolIndexParents[413] = 'direction-type';	// symbol conductorBeat3Simple
SymbolIndexParents[414] = 'direction-type';	// symbol conductorBeat2Compound
SymbolIndexParents[415] = 'direction-type';	// symbol conductorBeat3Compound
SymbolIndexParents[416] = 'direction-type';	// symbol gClef
SymbolIndexParents[417] = 'direction-type';	// symbol cClef
SymbolIndexParents[418] = 'direction-type';	// symbol cClef
SymbolIndexParents[419] = 'direction-type';	// symbol fClef
SymbolIndexParents[420] = 'direction-type';	// symbol unpitchedPercussionClef1
SymbolIndexParents[421] = 'direction-type';	// symbol unpitchedPercussionClef2
SymbolIndexParents[422] = 'direction-type';	// symbol 6stringTabClef
SymbolIndexParents[423] = 'direction-type';	// symbol gClef15ma
SymbolIndexParents[424] = 'direction-type';	// symbol gClef8va
SymbolIndexParents[425] = 'direction-type';	// symbol gClef8vb
SymbolIndexParents[426] = 'direction-type';	// symbol gClef8vbParens
SymbolIndexParents[427] = 'direction-type';	// symbol gClef8vbOld
SymbolIndexParents[428] = 'direction-type';	// symbol gClef
SymbolIndexParents[429] = 'direction-type';	// symbol cClef
SymbolIndexParents[430] = 'direction-type';	// symbol cClef
SymbolIndexParents[431] = 'direction-type';	// symbol cClef8vb
SymbolIndexParents[432] = 'direction-type';	// symbol cClef
SymbolIndexParents[433] = 'direction-type';	// symbol fClef8va
SymbolIndexParents[434] = 'direction-type';	// symbol fClef8vb
SymbolIndexParents[435] = 'direction-type';	// symbol fClef15ma
SymbolIndexParents[436] = 'direction-type';	// symbol fClef
SymbolIndexParents[438] = 'direction-type';	// symbol 4stringTabClef
SymbolIndexParents[439] = 'direction-type';	// symbol 6stringTabClefTall
SymbolIndexParents[440] = 'direction-type';	// symbol 4stringTabClefTall
SymbolIndexParents[441] = 'direction-type';	// symbol fClef
SymbolIndexParents[446] = 'direction-type';	// symbol clef8
SymbolIndexParents[447] = 'direction-type';	// symbol clef15
SymbolIndexParents[448] = 'direction-type';	// symbol ottava
SymbolIndexParents[450] = 'direction-type';	// symbol ottavaAlta
SymbolIndexParents[452] = 'direction-type';	// symbol ottavaBassaVb
SymbolIndexParents[454] = 'direction-type';	// symbol ottavaBassaBa
SymbolIndexParents[456] = 'direction-type';	// symbol quindicesima
SymbolIndexParents[458] = 'direction-type';	// symbol quindicesimaBassa
SymbolIndexParents[460] = 'direction-type';	// symbol quindicesimaBassaMb
SymbolIndexParents[474] = 'direction-type';	// eyeglasses
SymbolIndexParents[480] = 'articulations';	// doit
SymbolIndexParents[481] = 'articulations';	// falloff
SymbolIndexParents[482] = 'direction-type';	// string-mute on
SymbolIndexParents[483] = 'technical';		// hole closed yes
SymbolIndexParents[484] = 'technical';		// hole closed half
SymbolIndexParents[485] = 'technical';		// hole closed no
SymbolIndexParents[490] = 'technical';		// fingernails

// Only use accordion symbols if file created in Sibelius 4 or later.
// Accordion symbols were added earlier (they are in 3.1.3) but there
// must have been a reason to restrict to 4.0. Additional percussion
// symbols were added in 4.0 so restrict there too.
if (ThisScore.OriginalProgramVersion >= 4000) {
	SymbolIndexParents[72] = 'percussion';		// stick-location cymbal bell
	SymbolIndexParents[73] = 'percussion';		// stick-location cymbal edge
	SymbolIndexParents[74] = 'percussion';		// other-percussion: stick shot
	SymbolIndexParents[75] = 'technical';		// arrow southeast
	SymbolIndexParents[76] = 'percussion';		// other-percussion: on rim
	SymbolIndexParents[77] = 'percussion';		// beater slide brush on gong
	SymbolIndexParents[78] = 'direction-type';	// words z
	SymbolIndexParents[155] = 'percussion';		// beater drum stick
	SymbolIndexParents[496] = 'direction-type';	// accordion-registration
	SymbolIndexParents[497] = 'direction-type';	// accordion-registration
	SymbolIndexParents[498] = 'direction-type';	// accordion-registration
	SymbolIndexParents[499] = 'direction-type';	// accordion-registration
	SymbolIndexParents[500] = 'direction-type';	// accordion-registration
	SymbolIndexParents[501] = 'direction-type';	// accordion-registration
	SymbolIndexParents[502] = 'direction-type';	// accordion-registration
	SymbolIndexParents[503] = 'direction-type';	// accordion-registration
	SymbolIndexParents[504] = 'direction-type';	// accordion-registration
	SymbolIndexParents[505] = 'direction-type';	// accordion-registration
	SymbolIndexParents[506] = 'direction-type';	// accordion-registration
	SymbolIndexParents[507] = 'direction-type';	// accordion-registration
	SymbolIndexParents[508] = 'direction-type';	// accordion-registration
	SymbolIndexParents[509] = 'direction-type';	// accordion-registration
	SymbolIndexParents[510] = 'direction-type';	// accordion-registration
	SymbolIndexParents[512] = 'direction-type';	// symbol accdnRH4RanksSoprano
	SymbolIndexParents[517] = 'direction-type';	// symbol accdnRH4RanksBassAlto
	SymbolIndexParents[518] = 'direction-type';	// symbol accdnRH4RanksSoftTenor
	SymbolIndexParents[519] = 'direction-type';	// symbol accdnRH4RanksSoftBass
	SymbolIndexParents[520] = 'direction-type';	// symbol accdnRH4RanksMaster
	SymbolIndexParents[521] = 'direction-type';	// symbol accdnRH4RanksAlto
	SymbolIndexParents[522] = 'direction-type';	// symbol accdnRH4RanksTenor
	SymbolIndexParents[528] = 'direction-type';	// symbol accdnLH2Ranks8Round
	SymbolIndexParents[529] = 'direction-type';	// symbol accdnLH2Ranks16Round
	SymbolIndexParents[530] = 'direction-type';	// symbol accdnLH2Ranks8Plus16Round
	SymbolIndexParents[531] = 'direction-type';	// symbol accdnLH2RanksMasterRound
	SymbolIndexParents[532] = 'direction-type';	// symbol accdnLH2RanksMasterPlus16Round
	SymbolIndexParents[533] = 'direction-type';	// symbol accdnLH2RanksFullMasterRound
	SymbolIndexParents[560] = 'technical';		// handbell martellato
	SymbolIndexParents[561] = 'technical';		// handbell martellato lift
	SymbolIndexParents[562] = 'technical';		// handbell hand martellato
	SymbolIndexParents[563] = 'technical';		// handbell muted martellato
	SymbolIndexParents[564] = 'technical';		// stopped
	SymbolIndexParents[565] = 'technical';		// handbell mallet table
	SymbolIndexParents[566] = 'technical';		// handbell mallet lift
	SymbolIndexParents[567] = 'technical';		// arrow up
	SymbolIndexParents[568] = 'technical';		// arrow down
	SymbolIndexParents[569] = 'technical';		// handbell swing
	SymbolIndexParents[570] = 'technical';		// handbell echo
	SymbolIndexParents[571] = 'technical';		// other-technical handbellsEcho2
	SymbolIndexParents[572] = 'technical';		// handbell gyro
	SymbolIndexParents[573] = 'technical';		// handbell damp
	
	// Mute off was added in Sibelius 5.0, along with more ranges.
	if (ThisScore.OriginalProgramVersion >= 5000) {
		SymbolIndexParents[493] = 'direction-type';	// string-mute off
		SymbolIndexParents[577] = 'ornaments';		// inverted-mordent long, approach above
		SymbolIndexParents[578] = 'ornaments';		// mordent long, approach above
		SymbolIndexParents[579] = 'ornaments';		// inverted-mordent, departure below
		SymbolIndexParents[580] = 'ornaments';		// inverted-mordent, approach above
		SymbolIndexParents[581] = 'ornaments';		// inverted-mordent long, approach above
		SymbolIndexParents[582] = 'ornaments';		// inverted-mordent long, approach below
		SymbolIndexParents[583] = 'ornaments';		// inverted-mordent, approach above
		SymbolIndexParents[584] = 'ornaments';		// mordent
		SymbolIndexParents[585] = 'ornaments';		// inverted-mordent
		SymbolIndexParents[586] = 'ornaments';		// inverted-mordent long, approach below
		SymbolIndexParents[587] = 'ornaments';		// inverted-mordent long, approach above
		SymbolIndexParents[588] = 'ornaments';		// inverted-mordent long
		SymbolIndexParents[589] = 'ornaments';		// inverted-mordent, departure above
		SymbolIndexParents[590] = 'ornaments';		// other-ornament
		SymbolIndexParents[592] = 'ornaments';		// other-ornament
		SymbolIndexParents[594] = 'ornaments';		// other-ornament
		SymbolIndexParents[595] = 'ornaments';		// other-ornament
		SymbolIndexParents[596] = 'ornaments';		// other-ornament
		SymbolIndexParents[608] = 'ornaments';		// other-ornament
		SymbolIndexParents[611] = 'ornaments';		// other-ornament
		SymbolIndexParents[612] = 'ornaments';		// other-ornament
		SymbolIndexParents[613] = 'ornaments';		// turn
		SymbolIndexParents[614] = 'ornaments';		// inverted-turn
		SymbolIndexParents[615] = 'ornaments';		// vertical-turn
		SymbolIndexParents[640] = 'technical';		// arrow up
		SymbolIndexParents[641] = 'technical';		// arrow down
		SymbolIndexParents[642] = 'technical';		// arrow left
		SymbolIndexParents[643] = 'technical';		// arrow right
		SymbolIndexParents[644] = 'technical';		// arrow northwest
		SymbolIndexParents[645] = 'technical';		// arrow northeast
		SymbolIndexParents[646] = 'technical';		// arrow southwest
		SymbolIndexParents[647] = 'technical';		// arrow southeast
		SymbolIndexParents[648] = 'technical';		// arrowhead up single
		SymbolIndexParents[649] = 'technical';		// arrowhead down single
		SymbolIndexParents[650] = 'technical';		// arrowhead left single
		SymbolIndexParents[651] = 'technical';		// arrowhead right single
		SymbolIndexParents[652] = 'technical';		// arrowhead northwest single
		SymbolIndexParents[653] = 'technical';		// arrowhead northeast single
		SymbolIndexParents[654] = 'technical';		// arrowhead southwest single
		SymbolIndexParents[655] = 'technical';		// arrowhead southeast single
		SymbolIndexParents[656] = 'technical';		// arrowhead up filled
		SymbolIndexParents[657] = 'technical';		// arrowhead down filled
		SymbolIndexParents[658] = 'technical';		// arrowhead left filled
		SymbolIndexParents[659] = 'technical';		// arrowhead right filled
		SymbolIndexParents[660] = 'technical';		// arrowhead northwest filled
		SymbolIndexParents[661] = 'technical';		// arrowhead northeast filled
		SymbolIndexParents[662] = 'technical';		// arrowhead southwest filled
		SymbolIndexParents[663] = 'technical';		// arrowhead southeast filled
		SymbolIndexParents[752] = 'notations';		// accidental-mark quarter-sharp
		SymbolIndexParents[753] = 'notations';		// accidental-mark three-quarters-sharp
		SymbolIndexParents[754] = 'notations';		// accidental-mark three-quarters-sharp
		SymbolIndexParents[755] = 'notations';		// accidental-mark quarter-sharp
		SymbolIndexParents[756] = 'notations';		// accidental-mark quarter-flat
		SymbolIndexParents[757] = 'notations';		// accidental-mark other turned flat
		SymbolIndexParents[758] = 'notations';		// accidental-mark other turned double flat
		SymbolIndexParents[819] = 'direction-type';	// staff-divide up-down
		
		// Alternate doit / plop added in Sibelius 6.0
		if (ThisScore.OriginalProgramVersion >= 6000) {
			SymbolIndexParents[494] = 'articulations';	// doit
			SymbolIndexParents[495] = 'articulations';	// falloff

		}
	}
}
}"
	ShowTrace "false"
	WriteStaveTypeChange "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

if (ShowTrace) {
	trace('Found stave type change in bar ' & BarCounter & 
	      ', position ' & BarObject.Position);
}
}"
	WriteBeamLine "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

if (ShowTrace) {
	trace('Beam line found with style id ' & BarObject.StyleId & ' (' & 
	      BarObject.StyleAsText & ') at bar ' & BarCounter & ', position ' & 
	      BarObject.Position);
}
}"
	PedalStopStaff
	PedalStopPosition
	PedalStopBar
	DirectionStops "0"
	WedgeStops "0"
	BracketStops "0"
	PedalStops "0"
	DashesStops "0"
	OctaveStops "0"
	CheckDirectionStops "(AtEnd) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

nBarCounter = 0 + BarCounter;
nMeasureCounter = 0 + MeasureCounter;
nStopBar = 0;
nStopPosition = 0;
nStopStaff = 0;
nStopSize = 0;

if (WedgeStops > 0) {
	for i = 1 to 17 {
		nStopBar = WedgeStopBars[i];
		nStopPosition = WedgeStopPositions[i];
		nStopStaff = WedgeStopStaffs[i];
		nStopVoice = WedgeStopVoices[i];
		sNiente = '' & WedgeStopNientes[i];
		if ((nStopBar = nBarCounter) and
		    (AtEnd or (nStopPosition <= nMeasureCounter))) {
			nOffset = nStopPosition - nMeasureCounter;
			sDefaultY = '' & WedgeStopYs[i];
			WriteXML('<direction>', 3);
			WriteXML('<direction-type>', 4);
			WriteXML('<wedge type=\'stop\' number=\'' & i & '\'' &
					 sNiente & sDefaultY & '/>', 5);
			WriteXML('</direction-type>', 4);
			if (nOffset != 0) {
				WriteXML('<offset>' & nOffset & '</offset>', 4);
			}
			if (nStopVoice > 0) {
				WriteXML('<voice>' & nStopVoice & '</voice>', 4);
			}
			if (nStopStaff > 0) {
				WriteXML('<staff>' & nStopStaff & '</staff>', 4);
			}
			WriteXML('</direction>', 3);
			WedgeStopBars[i] = 0;	// free this wedge for reuse
			WedgeStops = WedgeStops - 1;
			DirectionStops = DirectionStops - 1;
		}
	}
}

if (DashesStops > 0) {
	for i = 1 to 17 {
		nStopBar = DashesStopBars[i];
		nStopPosition = DashesStopPositions[i];
		nStopStaff = DashesStopStaffs[i];
		nStopVoice = DashesStopVoices[i];
		if ((nStopBar = nBarCounter) and
		    (AtEnd or (nStopPosition <= nMeasureCounter))) {
			nOffset = nStopPosition - nMeasureCounter;
			sDefaultY = '' & DashesStopYs[i];
			WriteXML('<direction>', 3);
			WriteXML('<direction-type>', 4);
			WriteXML('<dashes type=\'stop\' number=\'' & i & '\'' & 
					 sDefaultY & '/>', 5);
			WriteXML('</direction-type>', 4);
			if (nOffset != 0) {
				WriteXML('<offset>' & nOffset & '</offset>', 4);
			}
			if (nStopVoice > 0) {
				WriteXML('<voice>' & nStopVoice & '</voice>', 4);
			}
			if (nStopStaff > 0) {
				WriteXML('<staff>' & nStopStaff & '</staff>', 4);
			}
			WriteXML('</direction>', 3);
			DashesStopBars[i] = 0;	// free this dashes for reuse
			DashesStops = DashesStops - 1;
			DirectionStops = DirectionStops - 1;
		}
	}
}

if (OctaveStops > 0) {
	for i = 1 to 17 {
		nStopBar = OctaveStopBars[i];
		nStopPosition = OctaveStopPositions[i];
		nStopStaff = OctaveStopStaffs[i];
		nStopSize = OctaveStopSizes[i];
		if ((nStopBar = nBarCounter) and
		    (AtEnd or (nStopPosition <= nMeasureCounter))) {
			nOffset = nStopPosition - nMeasureCounter;
			sDefaultY = '' & OctaveStopYs[i];
			WriteXML('<direction>', 3);
			WriteXML('<direction-type>', 4);
			WriteXML('<octave-shift type=\'stop\' size=\'' & nStopSize &
					 '\' number=\'' & i & '\'' & sDefaultY & '/>', 5);
			WriteXML('</direction-type>', 4);
			if (nOffset != 0) {
				WriteXML('<offset>' & nOffset & '</offset>', 4);
			}
			if (nStopStaff > 0) {
				WriteXML('<staff>' & nStopStaff & '</staff>', 4);
			}
			WriteXML('</direction>', 3);
			OctaveStopBars[i] = 0;	// free this octave-shift for reuse
			OctaveStops = OctaveStops - 1;
			DirectionStops = DirectionStops - 1;
		}
	}
}

if (BracketStops > 0) {
	for i = 1 to 17 {
		nStopBar = BracketStopBars[i];
		nStopPosition = BracketStopPositions[i];
		nStopStaff = BracketStopStaffs[i];
		nStopVoice = BracketStopVoices[i];
		sLineEnd = '' & BracketStopEnds[i];
		if ((nStopBar = nBarCounter) and
		    (AtEnd or (nStopPosition <= nMeasureCounter))) {
			nOffset = nStopPosition - nMeasureCounter;
			sDefaultY = '' & BracketStopYs[i];
			WriteXML('<direction>', 3);
			WriteXML('<direction-type>', 4);
			if (ShowTrace) {
				if (Length(sLineEnd) = 0) {
					trace('Missing a stop line end for bracket ' & i & 
					      ' at bar ' & BarCounter);
				}
			}
			WriteXML('<bracket type=\'stop\' line-end=\'' & sLineEnd &
					 '\' number=\'' & i & '\'' & sDefaultY & '/>', 5);
			WriteXML('</direction-type>', 4);
			if (nOffset != 0) {
				WriteXML('<offset>' & nOffset & '</offset>', 4);
			}
			if (nStopVoice > 0) {
				WriteXML('<voice>' & nStopVoice & '</voice>', 4);
			}
			if (nStopStaff > 0) {
				WriteXML('<staff>' & nStopStaff & '</staff>', 4);
			}
			WriteXML('</direction>', 3);
			BracketStopBars[i] = 0;	// free this bracket for reuse
			BracketStops = BracketStops - 1;
			DirectionStops = DirectionStops - 1;
		}
	}
}

if (PedalStops > 0) {
	nStopBar = 0 + PedalStopBar;
	nStopPosition = 0 + PedalStopPosition;
	nStopStaff = 0 + PedalStopStaff;
	if ((nStopBar = nBarCounter) and
	    (AtEnd or (nStopPosition <= nMeasureCounter))) {
		nOffset = nStopPosition - nMeasureCounter;
		WriteXML('<direction>', 3);
		WriteXML('<direction-type>', 4);
		WriteXML('<pedal type=\'' & PedalStopType & '\'' &
				 PedalStopLine & PedalStopY & PedalStopColor & '/>', 5);
		WriteXML('</direction-type>', 4);
		if (nOffset != 0) {
			WriteXML('<offset>' & nOffset & '</offset>', 4);
		}
		if (nStopStaff > 0) {
			WriteXML('<staff>' & nStopStaff & '</staff>', 4);
		}
		WriteXML('</direction>', 3);
		PedalStopBar = 0;	// free this pedal for reuse
		PedalStops = PedalStops - 1;
		DirectionStops = DirectionStops - 1;
	}
}
}"
	SlurCounts
	PartCounter
	WriteSystemStaffItems "(ThisScore, MeasureNumber, ThisPosition, StartIndex, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Write appropriate text, line, and other system staff objects
// into the current part. Barlines are handled elsewhere.

oSystemBar = ThisScore.SystemStaff.NthBar(MeasureNumber);
fNotDone = True;
nIndex = 0 + StartIndex;

while (fNotDone) {
	oBarObject = oSystemBar.NthBarObject(nIndex);
	nPosition = oBarObject.Position * 3;
	sType = oBarObject.Type;
	if (nPosition <= ThisPosition) {
		// Use indirection to call write routines for
		// each object type. Do not write out any 
		// spurious bar rest system objects.
		if (sType != 'BarRest') {
			sWriteMethod = 'Write' & sType;
			@sWriteMethod(oBarObject, StaffNumber);
		}
		nIndex = nIndex + 1;
		if (nIndex >= SystemStaffCount[MeasureNumber]) {
			fNotDone = False;
		}
	} else {
		fNotDone = False;
	}
}
return nIndex;
}"
	WriteSystemBarline "(ThisScore, ThisType, Ending, EndingType, Where, NewColor, SystemStaff) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

sBarline = '';
sDirection = '';
sPrintObject = '';
sWinged = '';
if (not SystemStaff) {
	sPrintObject = ' print-object=\'no\'';
}
if (AtLeastSib202212) {
	if (ThisScore.EngravingRules.RepeatBarlineWings) {
		sWinged = ' winged=\'curved\'';
	}
}


// Now using special barline internal type, added in
// Sibelius 5 and better for internationalization.
switch (ThisType) {
	case (SpecialBarlineStartRepeat) {
		sBarline = 'heavy-light';
		sDirection = 'forward';
	}
	case (SpecialBarlineEndRepeat) {
		sBarline = 'light-heavy';
		sDirection = 'backward';
	}
	case (SpecialBarlineFinal) {
		sBarline = 'light-heavy';
	}
	case (SpecialBarlineDouble) {
		sBarline = 'light-light';
	}
	case (SpecialBarlineDashed) {
		sBarline = 'dashed';
	}
	case (SpecialBarlineInvisible) {
		sBarline = 'none';
	}
	// Added in MusicXML 2.0
	case (SpecialBarlineTick) {
		sBarline = 'tick';
	}
	case (SpecialBarlineShort) {
		sBarline = 'short';
	}
}

// Handle new barlines added in 2022.12
if ((Length(sBarline) = 0) and AtLeastSib202212) {
	switch (ThisType) {
		case (SpecialBarlineDotted) {
			sBarline = 'dotted';
		}
		case (SpecialBarlineTriple) {
			// No triple in MusicXML 4.0, so approximate as double
			sBarline = 'light-light';
		}
		case (SpecialBarlineThick) {
			sBarline = 'heavy';
		}
	}
}

if ((Length(sBarline) > 0) or (Length(EndingType) > 0) or 
	 (Length(sDirection) > 0) or (Length(NewColor) > 0)) {
	WriteXML('<barline location=\'' & Where & '\'>', 3);
	if ((Length(sBarline) > 0) or (Length(NewColor) > 0)) {
		if (Length(sBarline) = 0) {
			sBarline = 'regular';
		}
		WriteXML('<bar-style' & NewColor & '>' & sBarline & '</bar-style>', 4);
	}
	if (Length(EndingType) > 0) {
		if (Length(Ending) > 0) {
			WriteXML('<ending type=\'' & EndingType & '\' number=\'' & Ending & 
			         '\'' & sPrintObject & '/>', 4);
		} else {
			// Add a space to ending number attribute - it seems that
			// two escaped quote marks in a row give us a double quote
			// rather than two single quotes.
			WriteXML('<ending type=\'' & EndingType & '\' number=\' \'' & 
					 sPrintObject & '/>', 4);
		}
	}
	if (Length(sDirection) > 0) {
		WriteXML('<repeat direction=\'' & sDirection & '\'' & sWinged & '/>', 4);
	}
	WriteXML('</barline>', 3);
}
}"
	LeftEnding
	RightEnding
	WriteAnyLine "(BarObject, StaffNumber, SystemStaff) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// If hidden, just return without writing.
if (BarObject.Hidden) {
	return 0;
}

// For debugging with new line style IDs
if (ShowTrace) {
	trace('Found line style \'' & BarObject.StyleId &
	      '\' (text ' & BarObject.StyleAsText & ') in bar ' & 
	      BarObject.ParentBar.BarNumber & 
	      ', position ' & BarObject.Position);
}

// Check the style and change variables accordingly.
fDashes = False;
fBracket = False;
fNotationsOnly = False;
sWords = '';
sWordStyle = '';
sLineType = '';
sStartLineEnd = '';
sStopLineEnd = '';
fStaffLine = not SystemStaff;
sColor = GetColor(BarObject);
nBarCounter = 0 + BarCounter;

fSystemTempo = False;
nStyleLength = Length(BarObject.StyleId);
if ((nStyleLength > 20) and (Substring(BarObject.StyleId, 0, 18) = 'line.system.tempo.')) {
	fSystemTempo = True;
}

if (fSystemTempo) {
	sTempoType = Substring(BarObject.StyleId, 18, 3);
	sTempoId = Substring(BarObject.StyleId, 18);
	switch (sTempoType) {
		case ('rit') {
			switch (sTempoId) {
				case ('rit.italic.textonly') {
					sWords = 'rit.';
					sWordStyle = 'italic';
				}
				case ('rit.italic') {
					sWords = 'rit.';
					sWordStyle = 'italic';
					fDashes = True;
				}
				case ('rit.molto.textonly') {
					sWords = 'Molto rit.';
					sWordStyle = 'bold';
				}
				case ('rit.molto') {
					sWords = 'Molto rit.';
					sWordStyle = 'bold';
					fDashes = True;
				}
				case ('rit.poco.textonly') {
					sWords = 'Poco rit.';
					sWordStyle = 'bold';
				}
				case ('rit.poco') {
					sWords = 'Poco rit.';
					sWordStyle = 'bold';
					fDashes = True;
				}
				case ('rit.textonly') {
					sWords = 'Rit.';
					sWordStyle = 'bold';
				}
				case ('rit') {
					sWords = 'Rit.';
					sWordStyle = 'bold';
					fDashes = True;
				}
			}
		}
		case ('ral') {
			switch (sTempoId) {
				case ('rall.italic.textonly') {
					sWords = 'rall.';
					sWordStyle = 'italic';
				}
				case ('rall.italic') {
					sWords = 'rall.';
					sWordStyle = 'italic';
					fDashes = True;
				}
				case ('rall.molto.textonly') {
					sWords = 'Molto rall.';
					sWordStyle = 'bold';
				}
				case ('rall.molto') {
					sWords = 'Molto rall.';
					sWordStyle = 'bold';
					fDashes = True;
				}
				case ('rall.poco.textonly') {
					sWords = 'Poco rall.';
					sWordStyle = 'bold';
				}
				case ('rall.poco') {
					sWords = 'Poco rall.';
					sWordStyle = 'bold';
					fDashes = True;
				}
				case ('rall.textonly') {
					sWords = 'Rall.';
					sWordStyle = 'bold';
				}
				case ('rall') {
					sWords = 'Rall.';
					sWordStyle = 'bold';
					fDashes = True;
				}
			}
		}
		case ('acc') {
			switch (sTempoId) {
				case ('accel.italic.textonly') {
					sWords = 'accel.';
					sWordStyle = 'italic';
				}
				case ('accel.italic') {
					sWords = 'accel.';
					sWordStyle = 'italic';
					fDashes = True;
				}
				case ('accel.molto.textonly') {
					sWords = 'Molto accel.';
					sWordStyle = 'bold';
				}
				case ('accel.molto') {
					sWords = 'Molto accel.';
					sWordStyle = 'bold';
					fDashes = True;
				}
				case ('accel.poco.textonly') {
					sWords = 'Poco accel.';
					sWordStyle = 'bold';
				}
				case ('accel.poco') {
					sWords = 'Poco accel.';
					sWordStyle = 'bold';
					fDashes = True;
				}
				case ('accel.textonly') {
					sWords = 'Accel.';
					sWordStyle = 'bold';
				}
				case ('accel') {
					sWords = 'Accel.';
					sWordStyle = 'bold';
					fDashes = True;
				}
			}
		}
		case ('arr') {
			switch (sTempoId) {
				case ('arrowright') {
					fBracket = True;
					sLineType = 'solid';
					sStartLineEnd = 'none';
					sStopLineEnd = 'arrow';
				}
			}
		}
	}
} 

fHarmonicStyle = False;
fBracketStyle = False;
fArrowStyle = False;
fStringStyle = False;

if (Substring(BarObject.StyleId, 0, 11) = 'line.staff.') {
	if (Substring(BarObject.StyleId, 11, 8) = 'harmonic') {
		fHarmonicStyle = True;
	} else {
		if (Substring(BarObject.StyleId, 11, 7) = 'bracket') {
			fBracketStyle = True;
		} else {
			if (Substring(BarObject.StyleId, 11, 5) = 'arrow') {
				fArrowStyle = True;
			} else {
				if (Substring(BarObject.StyleId, 11, 6) = 'string') {
					fStringStyle = True;
				}
			}
		}
	}
}

if (fHarmonicStyle) {
	sLineStaffType = Substring(BarObject.StyleId, 11);
	switch (sLineStaffType) {
		case ('harmonics') {
			fBracket = True;
			sWords = 'Harm.';
			sLineType = 'dashed';
			sStartLineEnd = 'none';
			sStopLineEnd = 'both';
			fStaffLine = True;
		}
		case ('harmonic.artificial') {
			fBracket = True;
			sWords = 'A.H.';
			sLineType = 'dashed';
			sStartLineEnd = 'none';
			sStopLineEnd = 'both';
			fStaffLine = True;
		}
		case ('harmonic.pinch') {
			fBracket = True;
			sWords = 'P.H.';
			sLineType = 'dashed';
			sStartLineEnd = 'none';
			sStopLineEnd = 'both';
			fStaffLine = True;
		}
		case ('harmonic.touch') {
			fBracket = True;
			sWords = 'T.H.';
			sLineType = 'dashed';
			sStartLineEnd = 'none';
			sStopLineEnd = 'both';
			fStaffLine = True;
		}
		case ('harmonic.harp') {
			fBracket = True;
			sWords = 'H.H.';
			sLineType = 'dashed';
			sStartLineEnd = 'none';
			sStopLineEnd = 'both';
			fStaffLine = True;
		}
	}
}

if (fBracketStyle) {
	sLineStaffType = Substring(BarObject.StyleId, 19);
	switch (sLineStaffType) {
		case ('above') {
			fBracket = True;
			sLineType = 'solid';
			sStartLineEnd = 'down';
			sStopLineEnd = 'down';
			fStaffLine = True;
		}
		case ('above.end') {
			fBracket = True;
			sLineType = 'solid';
			sStartLineEnd = 'none';
			sStopLineEnd = 'down';
			fStaffLine = True;
		}
		case ('above.start') {
			fBracket = True;
			sLineType = 'solid';
			sStartLineEnd = 'down';
			sStopLineEnd = 'none';
			fStaffLine = True;
		}
		case ('below') {
			fBracket = True;
			sLineType = 'solid';
			sStartLineEnd = 'up';
			sStopLineEnd = 'up';
			fStaffLine = True;
		}
		case ('below.end') {
			fBracket = True;
			sLineType = 'solid';
			sStartLineEnd = 'none';
			sStopLineEnd = 'up';
			fStaffLine = True;
		}
		case ('below.start') {
			fBracket = True;
			sLineType = 'solid';
			sStartLineEnd = 'up';
			sStopLineEnd = 'none';
			fStaffLine = True;
		}
		case ('vertical') {
			// Non-arpeggiate does not have multiple levels,
			// so store on a per-voice basis. No need to record
			// staves as we output one staff at a time and have
			// no way to determine cross-staff lines.

			nVoice = 0 + BarObject.VoiceNumber;
			NonArpeggiateBars[nVoice] = 0 + BarCounter;
			NonArpeggiatePositions[nVoice] = 0 + BarObject.Position;
			NonArpeggiateColors[nVoice] = '' & sColor;
			fNotationsOnly = True;
		}
		// @todo Figure out what to do with vertical2
	}
}

if (fArrowStyle) {
	sLineStaffType = Substring(BarObject.StyleId, 17);
	switch (sLineStaffType) {
		case ('black.right') {
			fBracket = True;
			sLineType = 'solid';
			sStartLineEnd = 'none';
			sStopLineEnd = 'arrow';
			fStaffLine = True;
		}
		case ('black.right.dashed') {
			fBracket = True;
			sLineType = 'dashed';
			sStartLineEnd = 'none';
			sStopLineEnd = 'arrow';
			fStaffLine = True;
		}
		case ('black.right.left') {
			fBracket = True;
			sLineType = 'solid';
			sStartLineEnd = 'arrow';
			sStopLineEnd = 'arrow';
			fStaffLine = True;
		}
		case ('black.vertical') {
			fBracket = True;
			sLineType = 'solid';
			sStartLineEnd = 'none';
			sStopLineEnd = 'arrow';
			fStaffLine = True;
		}
		case ('white.right') {
			fBracket = True;
			sLineType = 'solid';
			sStartLineEnd = 'none';
			sStopLineEnd = 'arrow';
			fStaffLine = True;
		}
		case ('white.right.dashed') {
			fBracket = True;
			sLineType = 'dashed';
			sStartLineEnd = 'none';
			sStopLineEnd = 'arrow';
			fStaffLine = True;
		}
		case ('white.right.left') {
			fBracket = True;
			sLineType = 'solid';
			sStartLineEnd = 'arrow';
			sStopLineEnd = 'arrow';
			fStaffLine = True;
		}
		case ('white.vertical') {
			fBracket = True;
			sLineType = 'solid';
			sStartLineEnd = 'none';
			sStopLineEnd = 'arrow';
			fStaffLine = True;
		}
	}
}

if (fStringStyle and (Length(BarObject.StyleId) > 24)) {
	sStringLinePlacement = Substring(BarObject.StyleId, 18, 5);
	sStringLineType = Substring(BarObject.StyleId, 24);
	fStringAbove = False;
	fStringBelow = False;
	if (sStringLinePlacement = 'above') {
		fStringAbove = True;
	} else {
		if (sStringLinePlacement = 'below') {
			fStringBelow = True;
		}
	}
	nSymbolIndex = 0;
	switch (sStringLineType) {
		case ('1') {
			nSymbolIndex = 193;
		}
		case ('2') {
			nSymbolIndex = 194;
		}
		case ('3') {
			nSymbolIndex = 195;
		}
		case ('4') {
			nSymbolIndex = 196;
		}
		case ('5') {
			nSymbolIndex = 197;
		}
		case ('6') {
			nSymbolIndex = 198;
		}
		case ('7') {
			nSymbolIndex = 199;
		}
		case ('8') {
			nSymbolIndex = 200;
		}
	}
	if ((nSymbolIndex > 0) and (fStringAbove or fStringBelow)) {
		// If we have placement and a symbol, then we have
		// a fully parsed string line. Go ahead and save
		// away the string symbol and create the appropriate
		// bracket.
		fBracket = True;
		sLineType = 'solid';
		sStartLineEnd = 'none';
		if (fStringAbove) {
			sStopLineEnd = 'down';
		} else {
			sStopLineEnd = 'up';
		}
		fStaffLine = True;

		// Save away the string as if it were a symbol.
		SymbolIndices[SymbolCount] = nSymbolIndex;
		SymbolPositions[SymbolCount] = 3 * BarObject.Position;
		SymbolDx[SymbolCount] = 0 + BarObject.Dx;
		SymbolDy[SymbolCount] = 0 + BarObject.Dy;
		SymbolColors[SymbolCount] = '' & sColor;
		SymbolCount = 1 + SymbolCount;
	}
}

fStillLooking = not (fSystemTempo or fHarmonicStyle or 
						fBracketStyle or fArrowStyle or fStringStyle);
if (fStillLooking) {
	if (Substring(BarObject.StyleId, 0, 11) = 'line.staff.') {
		sLineStaffType = Substring(BarObject.StyleId, 11);
		switch (sLineStaffType) {
			case ('bend.hold') {
				fBracket = True;
				sWords = 'hold bend';
				sLineType = 'dashed';
				sStartLineEnd = 'none';
				sStopLineEnd = 'both';
				fStaffLine = True;
			}
			case ('dashed') {
				fDashes = True;
				fStaffLine = True;
			}
			case ('dashed.vertical') {
				fDashes = True;
				fStaffLine = True;
			}
			case ('dotted') {
				fBracket = True;
				sLineType = 'dotted';
				sStartLineEnd = 'none';
				sStopLineEnd = 'none';
				fStaffLine = True;
			}
			case ('guitareffect') {
				fBracket = True;
				sLineType = 'dashed';
				sStartLineEnd = 'none';
				sStopLineEnd = 'both';
				fStaffLine = True;
			}
			case ('letring') {
				fBracket = True;
				sWords = 'let ring';
				sLineType = 'dashed';
				sStartLineEnd = 'none';
				sStopLineEnd = 'both';
				fStaffLine = True;
			}
			case ('mute.palm') {
				fBracket = True;
				sWords = 'P.M.';
				sLineType = 'dashed';
				sStartLineEnd = 'none';
				sStopLineEnd = 'both';
				fStaffLine = True;
			}
			case ('pick.scrape') {
				fBracket = True;
				sWords = 'P.S.';
				sLineType = 'dashed';
				sStartLineEnd = 'none';
				sStopLineEnd = 'both';
				fStaffLine = True;
			}
			case ('plain') {
				fBracket = True;
				sLineType = 'solid';
				sStartLineEnd = 'none';
				sStopLineEnd = 'none';
				fStaffLine = True;
			}
			case ('rake') {
				fBracket = True;
				sWords = 'rake';
				sLineType = 'dashed';
				sStartLineEnd = 'none';
				sStopLineEnd = 'both';
				fStaffLine = True;
			}
			case ('slide') {
				fBracket = True;
				sWords = 'w/slide';
				sLineType = 'dashed';
				sStartLineEnd = 'none';
				sStopLineEnd = 'both';
				fStaffLine = True;
			}
			case ('vertical') {
				fBracket = True;
				sLineType = 'solid';
				sStartLineEnd = 'none';
				sStopLineEnd = 'none';
				fStaffLine = True;
			}
			case ('vibrato') {
				// @todo See if we can use wavy-line instead
				fBracket = True;
				sLineType = 'wavy';
				sStartLineEnd = 'none';
				sStopLineEnd = 'none';
				fStaffLine = True;
			}
			case ('vibrato.bar') {
				fBracket = True;
				sWords = 'w/bar';
				sLineType = 'dashed';
				sStartLineEnd = 'none';
				sStopLineEnd = 'both';
				fStaffLine = True;
			}
			case ('vibrato.wide') {
				// @todo See if we can use wavy-line instead
				fBracket = True;
				sLineType = 'wavy';
				sStartLineEnd = 'none';
				sStopLineEnd = 'none';
				fStaffLine = True;
			}
		}
	} else {
		switch (BarObject.StyleId) {
			case ('line.system.dashed.wide') {
				fDashes = True;		
			}
			case ('line.system.dashed') {
				fDashes = True;		
			}
		}
	}
}

if (Length(sWords) > 0) {
	fWords = True;
} else {
	fWords = False;
}

fNotDone = True;
nNumber = 1;
nOffset = (BarObject.Position * 3) - MeasureCounter;

// Get the position based on object Dx and Dy properties.
// Only get this for staff lines, not system lines.
if (fStaffLine) {
	sPosition = GetPosition(BarObject.Dx, BarObject.Dy, False);
} else {
	sPosition = '';
}
sPlacement = '';

if (fBracket) {
// Find the first open bracket
	while (fNotDone) {
		if (BracketStopBars[nNumber] = 0) {
			fNotDone = False;
		} else {
			nNumber = nNumber + 1;
			if (nNumber > 16) {
				// Only 16 levels in MusicXML
				nNumber = 0;
				fNotDone = False;
			}
		}
	}

	// If nothing available, cannot write it.
	if (nNumber = 0) {
		fBracket = False;
	}
} else {
	if (fDashes) {
		while (fNotDone) {
			if (DashesStopBars[nNumber] = 0) {
				fNotDone = False;
			} else {
				nNumber = nNumber + 1;
				if (nNumber > 16) {
					// Only 16 levels in MusicXML
					nNumber = 0;
					fNotDone = False;
				}
			}
		}

		// If nothing available, cannot write it.
		if (nNumber = 0) {
			fDashes = False;
		}
	}
}

if (fDashes or fBracket or fWords) {	
	nOffset = (BarObject.Position * 3) - MeasureCounter;
	if (SystemStaff) {
		if (SystemStaffDone[nBarCounter]) {
			WriteXML('<direction placement=\'above\' system=\'also-top\'>', 3);
		} else {
			WriteXML('<direction placement=\'above\' system=\'only-top\'>', 3);
		}
	} else {
		sPlacement = GetPlacement(BarObject.Dy);
		WriteXML('<direction' & sPlacement & '>', 3);
	}
	if (fWords) {
		WriteXML('<direction-type>', 4);
		if (sWordStyle = 'bold') {
			WriteXML('<words ' & sPosition & sColor & ' font-weight=\'bold\'>' & 
					 sWords & '</words>', 5);
		} else {
			if (sWordStyle = 'italic') {
				WriteXML('<words ' & sPosition & sColor & ' font-style=\'italic\'>' &
						 sWords & '</words>', 5);
			} else {
				WriteXML('<words ' & sPosition & sColor & '>' & 
						 sWords & '</words>', 5);
			}
		}
		WriteXML('</direction-type>', 4);
	}
	if (fBracket) {
		WriteXML('<direction-type>', 4);
		WriteXML('<bracket type=\'start\' line-end=\'' & sStartLineEnd & 
				 '\' line-type=\'' & sLineType & '\' number=\'' & nNumber & 
				 '\' ' & sPosition & sColor & '/>', 5);
		WriteXML('</direction-type>', 4);
	} else {
		if (fDashes) {
			WriteXML('<direction-type>', 4);
			WriteXML('<dashes type=\'start\' number=\'' & nNumber & 
					 '\' ' & sPosition & sColor & '/>', 5);
			WriteXML('</direction-type>', 4);
		}
	}
	if (nOffset != 0) {
		WriteXML('<offset>' & nOffset & '</offset>', 4);
	}
	if (BarObject.CueSize) {
		WriteXML('<level size=\'cue\'/>', 4);
	}
	nVoice = GetVoice(BarObject, StaffNumber);
	if (nVoice > 0) {
		WriteXML('<voice>' & nVoice & '</voice>', 4);
	}
	if (StaffNumber > 0) {
		WriteXML('<staff>' & StaffNumber & '</staff>', 4);
	}
	WriteXML('</direction>', 3);
	
	if (fBracket) {
		// Now save the stop information in global arrays.
		BracketStopBars[nNumber] = 0 + BarObject.EndBarNumber;
		BracketStopPositions[nNumber] = BarObject.EndPosition * 3;
		BracketStopStaffs[nNumber] = 0 + StaffNumber;
		BracketStopVoices[nNumber] = 0 + GetVoice(BarObject, StaffNumber);
		BracketStopEnds[nNumber] = '' & sStopLineEnd;
		// Dy and RhDy are bogus for system lines, so ignore them.
		// Starting in 6.1 we have RhDx, which is OK for system lines.
		if ((not SystemStaff) and (BarObject.RhDy != BarObject.Dy)) {
			BracketStopYs[nNumber] = ' ' & GetPosition(BarObject.RhDx, BarObject.RhDy, False);
		} else {
			BracketStopYs[nNumber] = ' ' & GetXPosition(BarObject.RhDx, False);
		}
		BracketStops = BracketStops + 1;
		DirectionStops = DirectionStops + 1;
	} else {
		if (fDashes) {	
			// Now save the stop information in global arrays.
			DashesStopBars[nNumber] = 0 + BarObject.EndBarNumber;
			DashesStopPositions[nNumber] = BarObject.EndPosition * 3;
			DashesStopStaffs[nNumber] = 0 + StaffNumber;
			DashesStopVoices[nNumber] = 0 + GetVoice(BarObject, StaffNumber);
			// Dy and RhDy are bogus for system lines, so ignore them.
			// Starting in 6.1 we have RhDx, which is OK for system lines.
			if ((not SystemStaff) and (BarObject.RhDy != BarObject.Dy)) {
				DashesStopYs[nNumber] = ' ' & GetPosition(BarObject.RhDx, BarObject.RhDy, False);
			} else {
				DashesStopYs[nNumber] = ' ' & GetXPosition(BarObject.RhDx, False);
			}
			DashesStops = DashesStops + 1;
			DirectionStops = DirectionStops + 1;
		}
	}
} else {
	// If we do not recognize the line, log the error.
	// Does not apply to lines that are going to get written
	// out later solely as notations.
	if (not fNotationsOnly) {
		LogError('Unrecognized line style ' & BarObject.StyleId, 3);
	}
}
}"
	IsDynamic "(ThisText) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// If this text appears to be a dynamic, return the dynamic
// name; otherwise return an empty string. This used to
// return a boolean, but now that we are testing for
// leading and trailing spaces, we need to return the string.

// First, convert into Unicode text and strip out any
// non-Unicode characters. Doing this here lets us export
// some strings as dynamics that would otherwise be rejected
// unnecessarily.

sThisText = ToXmlText(TrimTrailingWhitespace(ThisText));
sOutput = '';

if (Length(sThisText) = 0) {
	return sOutput;
}

// Strip out any leading or trailing spaces. If spaces are in
// the middle, give up.
oSplitText = SplitString(sThisText, ' ', True);
if (oSplitText.NumChildren > 1) {
	return sOutput;
}
sText = '' & oSplitText[0];

// Check for parenthesized dynamics
fParen = False;
if (Substring(sText, 0, 1) = '(') {
	if (Substring(sText, Length(sText) - 1, 1) = ')') {
		fParen = True;
		sText = Substring(sText, 1, Length(sText) - 2);
	}
}
if (Length(sText) = 0) {
	return sOutput;
}
sFirst = Substring(sText, 0, 1);

// String equality in ManuScript does not mean equality,
// it means that the initial substrings are equal. So
// we have to check both the length and the contents.
// We can do the top-level switch because we know the
// length is 1, but we cannot do switches later because
// they have the same not-really-equality problem.

switch (sFirst) {
	case ('p') {
		if (((sText = 'p') and (Length(sText) = 1)) or 
			 ((sText = 'pp') and (Length(sText) = 2)) or 
			 ((sText = 'ppp') and (Length(sText) = 3)) or
			 ((sText = 'pppp') and (Length(sText) = 4)) or 
			 ((sText = 'ppppp') and (Length(sText) = 5)) or 
			 ((sText = 'pppppp') and (Length(sText) = 6)) or 
			 ((sText = 'pf') and (Length(sText) = 2))) {
			sOutput = '<' & sText & '/>';
		}
	}
	case ('f') {
		if (((sText = 'f') and (Length(sText) = 1)) or 
			 ((sText = 'ff') and (Length(sText) = 2)) or 
			 ((sText = 'fp') and (Length(sText) = 2)) or 
			 ((sText = 'fz') and (Length(sText) = 2)) or 
			 ((sText = 'fff') and (Length(sText) = 3)) or
			 ((sText = 'ffff') and (Length(sText) = 4)) or 
			 ((sText = 'fffff') and (Length(sText) = 5)) or 
			 ((sText = 'ffffff') and (Length(sText) = 6))) {
			sOutput = '<' & sText & '/>';
		} else {
			// Handle some dynamics that are used in scores but
			// not in MusicXML except as other-dynamics.
			if (((sText = 'ffz') and (Length(sText) = 3)) or
				 ((sText = 'ffp') and (Length(sText) = 3)) or
				 ((sText = 'fmp') and (Length(sText) = 3)) or
				 ((sText = 'fpp') and (Length(sText) = 3)) or
				 ((sText = 'ffmp') and (Length(sText) = 4)) or
				 ((sText = 'fffz') and (Length(sText) = 4))) {
				sOutput = '<other-dynamics>' & sText & '</other-dynamics>';	
			}
		}
	}
	case ('m') {
		if ((Length(sText) = 2) and 
			 ((sText = 'mf') or (sText = 'mp'))) {
			sOutput = '<' & sText & '/>';
		} else {
			// Handle some dynamics that are used in scores but
			// not in MusicXML except as other-dynamics.
			if (((sText = 'mfp') and (Length(sText) = 3)) or
				((sText = 'msfz') and (Length(sText) = 4)) or
				((sText = 'msfzp') and (Length(sText) = 5))) {
				sOutput = '<other-dynamics>' & sText & '</other-dynamics>';	
			}
		}
	}
	case ('s') {
		if (((sText = 'sf') and (Length(sText) = 2)) or 
			 ((sText = 'sfp') and (Length(sText) = 3)) or
			 ((sText = 'sfz') and (Length(sText) = 3)) or
			 ((sText = 'sfpp') and (Length(sText) = 4)) or
			 ((sText = 'sfzp') and (Length(sText) = 4)) or
			 ((sText = 'sffz') and (Length(sText) = 4))) {
			sOutput = '<' & sText & '/>';
		} else {
			// Handle some dynamics that are used in scores but
			// not in MusicXML except as other-dynamics.
			if (((sText = 'sff') and (Length(sText) = 3)) or
				 ((sText = 'sfff') and (Length(sText) = 4)) or
				 ((sText = 'sfffz') and (Length(sText) = 5)) or
				 ((sText = 'sffzpp') and (Length(sText) = 6))) {
				sOutput = '<other-dynamics>' & sText & '</other-dynamics>';	
			}
		}
	}
	case ('r') {
		if (((sText = 'rf') and (Length(sText) = 2)) or 
			 ((sText = 'rfz') and (Length(sText) = 3))) {
			sOutput = '<' & sText & '/>';
		}
	}
	case ('n') {
		if (((sText = 'n') and (Length(sText) = 1)) or
			 ((sText = 'n.') and (Length(sText) = 2))) {
			sOutput = '<n/>';
		}
	}
}

// Set global for parenthesized direction if appropriate
if (fParen and (Length(sOutput) > 0)) {
	DirectionHasParen = True;
}

// Return the dynamic XML text
return sOutput;
}"
	IsMaestroDynamic "(ThisText) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// If this text appears to be a dynamic in the Maestro font,
// return the dynamic name; otherwise return an empty string.

sOutput = '';

if (Length(ThisText) = 0) {
	return sOutput;
}

// Strip out any leading or trailing spaces. If spaces are in
// the middle, give up.
oSplitText = SplitString(ThisText, ' ', True);
if (oSplitText.NumChildren > 1) {
	return sOutput;
}
sText = '' & oSplitText[0];

// Check for parenthesized dynamics
fParen = False;
if (Substring(sText, 0, 1) = '(') {
	if (Substring(sText, Length(sText) - 1, 1) = ')') {
		fParen = True;
		sText = Substring(sText, 1, Length(sText) - 2);
	}
}
if (Length(sText) = 0) {
	return sOutput;
}

// Go through each character one by one and look up
// in our table to get the dynamic character. If we
// find something that is not a dynamic character,
// give up.
sDynamic = '';
for i = 0 to Length(sText) {
	nChar = Asc(CharAt(sText, i));
	sChar = MaestroDynamics[nChar];
	if ((sChar = null) or (sChar = 0)) {
		return sOutput;
	} else {
		sDynamic = sDynamic & sChar;
	}
}

if (Length(sDynamic) = 0) {
	return sOutput;
}
sOutput = '<' & sDynamic & '/>';

// Set global for parenthesized direction if appropriate
if (fParen) {
	DirectionHasParen = True;
}

// Return the dynamic XML text
return sOutput;
}"
	WriteMetronomeMark "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Split text into visible and invisible parts.
// Invisible parts are usually used for MIDI playback.
// Hiding may happen via a tilde or via a hidden bar object.

sHidden = '';
sText = '';
if (BarObject.Hidden) {
	sHidden = BarObject.Text;
	// Check for double-hidden text with a tilde start
	sHiddenFirst = Substring(BarObject.Text, 0, 1);
	if (sHiddenFirst = '~') {
		sHidden = Substring(BarObject.Text, 1);
	}
} else {
	sSplitText = SplitString(BarObject.Text, '~', False);
	sText = ToXmlText(sSplitText[0]);
	if (sSplitText.NumChildren = 2) {
		sHidden = sSplitText[1];
	}
}

fMetronome = False;
nOffset = (BarObject.Position * 3) - MeasureCounter;
nBarCounter = 0 + BarCounter;

// If only applied one time through, we will want to add
// a time-only attribute.
sTimeOnly = GetPlaySequence(BarObject);
if (Length(sTimeOnly) = 1) {
	sTimeOnly = ' time-only=\'' & sTimeOnly & '\'';
} else {
	sTimeOnly = '';
}

if (Length(sText) = 0) {
	// Check to see if we have a hidden MIDI tempo mark.
	// If so, write it out as a sound element before returning.
	if (Length(sHidden) > 0) {
		nHiddenSound = GetTempo(sHidden);
		if (nHiddenSound > 0) {
			if (nOffset != 0) {
				WriteXML('<sound tempo=\'' & nHiddenSound & '\'' & 
						  sTimeOnly & '>', 3);
				WriteXML('<offset>' & nOffset & '</offset>', 4);
				WriteXML('</sound>', 3);
			} else {
				WriteXML('<sound tempo=\'' & nHiddenSound & '\'/>', 3);
			}
		}
	}
	// Nobody else can parse an empty string either, so return True.
	return True;
}

fParen = False;
fParenRight = False;
fParenLeft = False;
fCirca = False;
fHaveBothEqualSides = False;
nTempo = 0;
nSound = 0;
sFirstBeatType = '';
nFirstBeatDots = 0;
sSecondBeatType = '';
nSecondBeatDots = 0;
sLeft = '';
sRight = '';
fUseMetronomeNote = False;
sMetronomeNoteLeft = '';
sMetronomeNoteRight = '';
sNoSpaceRight = '';

// Now see if there is an equal sign for a metronome mark.
// If we have two children, try parsing it that way, but
// only if we have some text in both children.
sEqualSplit = SplitString(sText, '=', False);
if (sEqualSplit.NumChildren = 2) {
	sLeft = sEqualSplit[0];
	sRight = sEqualSplit[1];
	if ((Length(sLeft) > 0) and (Length(sRight) > 0)) {
		fHaveBothEqualSides = True;
	}
}
	
if (fHaveBothEqualSides) {
	// Parse the right side first. Get rid of spaces for easier handling.
	sSpaceRightSplit = SplitString(sRight, ' ', True);
	sNoSpaceRight = JoinStrings(sSpaceRightSplit, '');
	
	// Closing parentheses?
	if (CharAt(sNoSpaceRight, Length(sNoSpaceRight) - 1) = ')') {
		fParenRight = True;
		sNoSpaceRight = Substring(sNoSpaceRight, 0, Length(sNoSpaceRight) - 1);
	}
	
	// Circa?
	if (Substring(sNoSpaceRight, 0, 3) = 'ca.') {
		fCirca = True;
		sNumber = Substring(sNoSpaceRight, 3);
	} else {
		sNumber = sNoSpaceRight;
	}

	// Number range?
	nTempo = 0;
	nTempo1 = 0;
	nTempo2 = 0;
	nPlaybackTempo = 0;
	fIsNumeric = False;
	sTextAfterNumbers = '';
	sNumbers = SplitString(sNumber, '-', False);
	if (sNumbers.NumChildren > 0) {
		nDecimalPoint = 0;
		for i = 0 to Length(sNumbers[0]) {
			if (Length(sTextAfterNumbers) = 0) {
				c = CharAt(sNumbers[0], i);
				intc = Round(c);
				if ((intc >= ZeroCharInt) and (intc <= (ZeroCharInt + 9))) {
					if (nDecimalPoint = 0) {
						nTempo1 = (nTempo1 * 10) + (intc - ZeroCharInt);
					} else {
						nTempo1 = nTempo1 + ((intc - ZeroCharInt) / nDecimalPoint);
						nDecimalPoint = nDecimalPoint * 10.0;
					}
				} else {
					if ((intc = PeriodCharInt) and (nDecimalPoint = 0)) {
						nDecimalPoint = 10.0;	
					} else {
						sTextAfterNumbers = Substring(sNumbers[0], i);
					}
				}
			}
		}
		if (sNumbers.NumChildren > 1) {
			nDecimalPoint = 0;
			if (Length(sTextAfterNumbers) > 0) {
				sTextAfterNumbers = sTextAfterNumbers & '-' & sNumbers[1];
			} else {
				for i = 0 to Length(sNumbers[1]) {
					if (Length(sTextAfterNumbers) = 0) {
						c = CharAt(sNumbers[1], i);
						intc = Round(c);
						if ((intc >= ZeroCharInt) and (intc <= (ZeroCharInt + 9))) {
							if (nDecimalPoint = 0) {
								nTempo2 = (nTempo2 * 10) + (intc - ZeroCharInt);
							} else {
								nTempo2 = nTempo2 + ((intc - ZeroCharInt) / nDecimalPoint);
								nDecimalPoint = nDecimalPoint * 10.0;
							}
						} else {
							if ((intc = PeriodCharInt) and (nDecimalPoint = 0)) {
								nDecimalPoint = 10.0;	
							} else {
								sTextAfterNumbers = Substring(sNumbers[1], i);
							}
						}
					}
				}
			}
			if (sNumbers.NumChildren > 2) {
				for i = 2 to sNumbers.NumChildren {
					sTextAfterNumbers = sTextAfterNumbers & '-' & sNumbers[i];
				}
			}
		}
	}
	
	if (nTempo1 > 0) {
		fIsNumeric = True;
		if (nTempo2 = 0) {
			nTempo = nTempo1;
			nPlaybackTempo = nTempo;
		} else {
			nPlaybackTempo = Round((nTempo1 + nTempo2) / 2.0);
		}
		// Add a leading space to set off from the metronome mark
		if (Length(sTextAfterNumbers) > 0) {
			sTextAfterNumbers = ' ' & sTextAfterNumbers;
		}
	} else {
		// We do not have numbers, so zero out text afterward.
		sTextAfterNumbers = '';
	}
	
	// If we have text after the numbers, whitespace in the middle of the
	// text will have been stripped out by the splitting to get rid of spaces.
	// Search for an initial substring that follows the last number. Using
	// the first 3 characters for now.
	if (Length(sTextAfterNumbers) > 0) {
		sLastNumber = '' & nTempo2;
		if (nTempo2 = 0) {
			sLastNumber = '' & nTempo;
		}
		nNumberInRight = IndexOf(sLastNumber, sRight);
		if (nNumberInRight >= 0) {
			sSubstring = Substring(sTextAfterNumbers, 0, 3);
			nSubstringInRight = IndexOfStartingAt(sSubstring, sRight, nNumberInRight);
			if (nSubstringInRight > 0) {
				sTextAfterNumbers = TrimTrailingSpaces(Substring(sRight, nSubstringInRight));
			}
		}
	}
	
	// If not a number or range, see if it is a beat.
	// Currently we are not handling text after a metric relation.
	if ((not fIsNumeric) and (Length(sNoSpaceRight) > 0)) {
		if (Length(sNoSpaceRight) < 3) {
			sFirst = CharAt(sNoSpaceRight, 0);
			switch (sFirst) {
				case ('q') {
					sSecondBeatType = 'quarter';
				}
				case ('e') {
					sSecondBeatType = 'eighth';
				}
				case ('h') {
					sSecondBeatType = 'half';
				}
				case ('w') {
					sSecondBeatType = 'whole';
				}
				case ('x') {
					sSecondBeatType = '16th';
				}
				case ('y') {
					sSecondBeatType = '32nd';
				}
				case ('W') {
					sSecondBeatType = 'breve';
				}
			}
			if (Length(sNoSpaceRight) = 2) {
				if (CharAt(sNoSpaceRight, 1) = '.') {
					nSecondBeatDots = 1;
				} else {
					// Something we do not understand, so zap the second beat
					sSecondBeatType = '';
				}
			}
		} else {
			// Check for metric modulations that we can represent using
			// the metronome-note features added in MusicXML 2.0. For now
			// we just do a hard-coded match against the common versions
			// included in the built-in word text menu in Sibelius 5.
			switch (sNoSpaceRight) {
				case ('qaaz') {
					fUseMetronomeNote = True;
					sMetronomeNoteRight = sNoSpaceRight;
				}
				case ('qaaaz') {
					fUseMetronomeNote = True;
					sMetronomeNoteRight = sNoSpaceRight;
				}
				case ('[qp]e') {
					fUseMetronomeNote = True;
					sMetronomeNoteRight = sNoSpaceRight;
				}
				case ('qa.aai') {
					fUseMetronomeNote = True;
					sMetronomeNoteRight = sNoSpaceRight;
				}
				case ('qsi') {
					fUseMetronomeNote = True;
					sMetronomeNoteRight = sNoSpaceRight;
				}
				case ('[ep]x') {
					fUseMetronomeNote = True;
					sMetronomeNoteRight = sNoSpaceRight;
				}
				case ('qapaasq') {
					fUseMetronomeNote = True;
					sMetronomeNoteRight = sNoSpaceRight;
				}
			}
		}
	}

	// If we have a tempo, a beat type, or a MusicXML metronome note,
	// we are OK to parse the left side.
	nLeftSplitChildren = 0;
	nFirstLeftMetronomeChild = -1;
	if ((fIsNumeric) or (Length(sSecondBeatType) > 0) or 
		 (Length(sMetronomeNoteRight) > 0)) {
		oSpaceLeftSplit = SplitString(sLeft, ' ', True);
		nLeftSplitChildren = oSpaceLeftSplit.NumChildren;
		if (nLeftSplitChildren = 0) {
			sBeat = '';
		} else {
			nFirstLeftMetronomeChild = nLeftSplitChildren - 1;
			sBeat = '' & oSpaceLeftSplit[nFirstLeftMetronomeChild];
			// Check to see if we have a metric modulation split
			// across two different children.
			if (nLeftSplitChildren > 1) {
				if (((Length(sBeat) = 1) and ((sBeat = 'z') or (sBeat = 'i'))) or (sBeat = 'az')) {
					sPrevChild = oSpaceLeftSplit[nFirstLeftMetronomeChild - 1];
					if ((sPrevChild = 'qaa') or (sPrevChild = 'qs') or
						(sPrevChild = '(qaa') or (sPrevChild = '(qs')) {
						sBeat = sPrevChild & sBeat;
						nFirstLeftMetronomeChild = nFirstLeftMetronomeChild - 1;
					}
				}
			}
		}
		if (CharAt(sBeat, 0) = '(') {
			fParenLeft = True;
			sBeat = Substring(sBeat, 1);
		}
 
		// See if left hand side is a beat or a metronome note.
		if (Length(sBeat) > 0) {
			// If we have a metronome note on the right-hand side,
			// we will need to write the left-hand side as a
			// metronome-note even if it is just a single note.
			if (Length(sMetronomeNoteRight) > 0) {
				sMetronomeNoteLeft = sBeat;
			}
			if (Length(sBeat) < 3) {
				sFirst = CharAt(sBeat, 0);
				switch (sFirst) {	
					case ('q') {
						sFirstBeatType = 'quarter';
						nSound = nPlaybackTempo;
					}
					case ('e') {
						sFirstBeatType = 'eighth';
						nSound = nPlaybackTempo / 2;
					}
					case ('h') {
						sFirstBeatType = 'half';
						nSound = nPlaybackTempo * 2;
					}
					case ('w') {
						sFirstBeatType = 'whole';
						nSound = nPlaybackTempo * 4;
					}
					case ('x') {
						sFirstBeatType = '16th';
						nSound = nPlaybackTempo / 4;
					}
					case ('y') {
						sFirstBeatType = '32nd';
						nSound = nPlaybackTempo / 8;
					}
					case ('W') {
						sFirstBeatType = 'breve';
						nSound = nPlaybackTempo * 8;
					}
				}
				if (Length(sBeat) = 2) {
					if (CharAt(sBeat, 1) = '.') {
						nFirstBeatDots = 1;
						nSound = Round(nSound * 1.5);
					} else {
						// Something we do not understand, so zap the first beat
						sFirstBeatType = '';
					}
				}
			} else {
				// Check for metric modulations that we can represent using
				// the metronome-note features added in MusicXML 2.0. For now
				// we just do a hard-coded match against the common versions
				// included in the built-in word text menu in Sibelius 5.
				// Only works if we do not have a tempo on the right-hand side.
				if (nTempo = 0) {
					switch (sBeat) {
						case ('qaaz') {
							fUseMetronomeNote = True;
							sMetronomeNoteLeft = sBeat;
						}
						case ('qaaaz') {
							fUseMetronomeNote = True;
							sMetronomeNoteLeft = sBeat;
						}
						case ('qsi') {
							fUseMetronomeNote = True;
							sMetronomeNoteLeft = sBeat;
						}
					}
					// If we have a metronome-note on the left, then we have to
					// re-interpret the right-hand side as a metronome note.
					// This is why we checked that the right hand side is not
					// a numeric tempo above.
					// @todo Add this more flexible interpretation
					// For now, to avoid null directions, just give up.
					if ((Length(sMetronomeNoteLeft) > 0) and 
						(Length(sMetronomeNoteRight) = 0)) {
						fMetronome = False;
						sMetronomeNoteLeft = '';
						// sMetronomeNoteRight = sNoSpaceRight;
					}
				}
			}
			if ((Length(sFirstBeatType) > 0) or (Length(sMetronomeNoteLeft) > 0)) {
				fMetronome = True;
				// Rejoin what is left, if anything. Sibelius will loop
				// if we pass a -1 to an array, so double-check that this
				// does not happen.
				if (nFirstLeftMetronomeChild >= 0) {
					for nChild = nFirstLeftMetronomeChild to nLeftSplitChildren {
						oSpaceLeftSplit[nChild] = '';
					}
				}

				// See if there is a left paren separated by a space.
				// Watch out for testing string equality with single-character strings.
				if ((not fParenLeft) and (nFirstLeftMetronomeChild > 0)) {
					sTestParen = oSpaceLeftSplit[nFirstLeftMetronomeChild - 1];
					if ((Length(sTestParen) = 1) and (sTestParen = '(')) {
						fParenLeft = True;
						oSpaceLeftSplit[nFirstLeftMetronomeChild - 1] = '';
					}
				}
				
				// Rejoin string, discarding if it is all whitespace
				sText = JoinStrings(oSpaceLeftSplit, ' ');
				if (Length(TrimTrailingSpaces(sText)) = 0) {
					sText = '';
				}

				// Parenthesize only if both parens set. If only one set,
				// do not worry about it, just drop it.
				fParen = fParenLeft and fParenRight;
			}
		}				
	}		
} else {
	// We only have the text, so trim it as in the metronome case.
	sText = TrimTrailingSpaces(sText);
}

// Make sure metronome note is OK on both sides.
if (fUseMetronomeNote) {
	if ((Length(sMetronomeNoteLeft) = 0) or (Length(sMetronomeNoteRight) = 0)) {
		fMetronome = False;
		fUseMetronomeNote = False;
	}
}

if (not(fMetronome or (Length(sText) > 0))) {
	return False;
}

// Now start writing out the direction - text, metronome, or both
// Assume system text always going above with bold font.
sAttributes = ' placement=\'above\'';
sColor = GetColor(BarObject);
if ((BarCounter = 1) and (BarObject.Position = 0)) {
	sAttributes = sAttributes & ' directive=\'yes\'';
}
if (SystemStaffDone[nBarCounter]) {
	sAttributes = sAttributes & ' system=\'also-top\''; 
} else {
	sAttributes = sAttributes & ' system=\'only-top\'';
}
	
WriteXML('<direction' & sAttributes & '>', 3);
if (Length(sText) > 0) {
	// We sometimes see metronome marks used for segno and coda.
	// Until we have font information we cannot parse reliably,
	// but single segno / coda marks should be pretty accurate.
	fSegno = False;
	fCoda = False;
	if (Length(sText) = 1) {
		if ((sText = '$') or (sText = '@')) {
			fSegno = True;
		} else {
			if ((sText = 'Ø') or (sText = 'ø')) {
				fCoda = True;
			}
		}
	}
	WriteXML('<direction-type>', 4);
	if (fSegno) {
		WriteXML('<segno' & sColor & '/>', 5);
	} else {
		if (fCoda) {
			WriteXML('<coda' & sColor & '/>', 5);
		} else {
			oDictWords = GetDictWords(BarObject, sText);
			if (Length(oDictWords['text']) > 0) {
				if (oDictWords['musictext']) {
					LogError('Unrecognized music text written as words', 5);
				}
				WriteXML('<words font-weight=\'bold\'' & oDictWords['family'] & 
						  oDictWords['size'] & oDictWords['space'] & sColor & '>' &
						  oDictWords['text'] & '</words>', 5);
			}
		}
	}	
	WriteXML('</direction-type>', 4);
}

// Write out the metronome mark if present
if (fMetronome) {
	WriteXML('<direction-type>', 4);
	if (fParen) {
		WriteXML('<metronome parentheses=\'yes\'' & sColor & '>', 5);
	} else {
		WriteXML('<metronome' & sColor & '>', 5);
	}
	if (fUseMetronomeNote) {
		WriteMetronomeNote(sMetronomeNoteLeft);
		WriteXML('<metronome-relation>equals</metronome-relation>', 6);
		WriteMetronomeNote(sMetronomeNoteRight);
	} else {
		WriteXML('<beat-unit>' & sFirstBeatType & '</beat-unit>', 6);
		if (nFirstBeatDots = 1) {
			WriteXML('<beat-unit-dot/>', 6);
		}

		if (fIsNumeric) {
			if (nTempo > 0) {
				if (fCirca) {
					WriteXML('<per-minute>ca. ' & nTempo & '</per-minute>', 6);
				} else {
					WriteXML('<per-minute>' & nTempo & '</per-minute>', 6);
				}
			} else {
				if (fCirca) {
					WriteXML('<per-minute>ca. ' & nTempo1 & '-' & nTempo2 & '</per-minute>', 6);
				} else {
					WriteXML('<per-minute>' & nTempo1 & '-' & nTempo2 & '</per-minute>', 6);
				}
			}
		} else {
			WriteXML('<beat-unit>' & sSecondBeatType & '</beat-unit>', 6);
			if (nSecondBeatDots = 1) {
				WriteXML('<beat-unit-dot/>', 6);
			}		
		}
	}
	WriteXML('</metronome>', 5);
	WriteXML('</direction-type>', 4);
	if (Length(sTextAfterNumbers) > 0) {
		WriteXML('<direction-type>', 4);
		WriteXML('<words>' & sTextAfterNumbers & '</words>', 5);
		WriteXML('</direction-type>', 4);
	}
}

// For debugging
if (ShowTrace) {
	trace('Metronome parse success = ' & fMetronome & ', text = \'' & sText & '\'');
}

if (nOffset != 0) {
	WriteXML('<offset>' & nOffset & '</offset>', 4);
}
if (StaffNumber > 0) {
	WriteXML('<staff>' & StaffNumber & '</staff>', 4);
}

// If we have a hidden part, see if that is sound. If it is, that
// takes priority over any sound we computed from the visual mark.
if (Length(sHidden) > 0) {
	nHiddenSound = GetTempo(sHidden);
	if (nHiddenSound > 0) {
		nSound = nHiddenSound;
	}
}
if (nSound > 0) {
	WriteXML('<sound tempo=\'' & nSound & '\'' & sTimeOnly & '/>', 4);
}

WriteXML('</direction>', 3);

// Metronome exported successfully, so return True.
return True;
}"
	WriteBarNumber "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// We do not output bar numbers here.
// We do some checking of external bar numbers elsewhere.
x = 1;
}"
	Title
	Composer
	Lyricist
	Copyright
	AboutBox "Dialog"
	{
		Controls
		{
			Text
			{
				Title "Dolet 8 for Sibelius"
				X "7"
				Y "7"
				Width "146"
				Height "14"
				RightAlign "0"
				Value
				Method
				SetFocus "0"
			}
			Text
			{
				Title "Version 8.3"
				X "7"
				Y "23"
				Width "146"
				Height "14"
				RightAlign "0"
				Value
				Method
				SetFocus "0"
			}
			Text
			{
				Title "Copyright © 2003-2023 MakeMusic, Inc."
				X "7"
				Y "39"
				Width "146"
				Height "14"
				RightAlign "0"
				Value
				Method
				SetFocus "0"
			}
			Button
			{
				Title "OK"
				X "121"
				Y "75"
				Width "39"
				Height "14"
				DefaultButton "1"
				Value
				Method
				SetFocus "1"
				EndDialog "1"
			}
		}
		Title "About Dolet 8 for Sibelius"
		X "445"
		Y "268"
		Width "176"
		Height "115"
	}
	AboutBox_de "Dialog"
	{
		Controls
		{
			Text
			{
				Title "Dolet 8 für Sibelius"
				X "7"
				Y "7"
				Width "146"
				Height "14"
				RightAlign "0"
				Value
				Method
				SetFocus "0"
			}
			Text
			{
				Title "Version 8.3"
				X "7"
				Y "23"
				Width "146"
				Height "14"
				RightAlign "0"
				Value
				Method
				SetFocus "0"
			}
			Text
			{
				Title "Copyright © 2003-2023 MakeMusic, Inc."
				X "7"
				Y "39"
				Width "146"
				Height "14"
				RightAlign "0"
				Value
				Method
				SetFocus "0"
			}
			Button
			{
				Title "OK"
				X "124"
				Y "75"
				Width "39"
				Height "14"
				DefaultButton "1"
				Value
				Method
				SetFocus "1"
				EndDialog "1"
			}
		}
		Title "Über Dolet 8 für Sibelius"
		X "445"
		Y "268"
		Width "176"
		Height "115"
	}
	AboutBox_fr "Dialog"
	{
		Controls
		{
			Text
			{
				Title "Dolet 8 pour Sibelius"
				X "7"
				Y "7"
				Width "146"
				Height "14"
				RightAlign "0"
				Value
				Method
				SetFocus "0"
			}
			Text
			{
				Title "Version 8.3"
				X "7"
				Y "23"
				Width "146"
				Height "14"
				RightAlign "0"
				Value
				Method
				SetFocus "0"
			}
			Text
			{
				Title "Copyright © 2003-2023 MakeMusic, Inc."
				X "7"
				Y "39"
				Width "146"
				Height "14"
				RightAlign "0"
				Value
				Method
				SetFocus "0"
			}
			Button
			{
				Title "OK"
				X "124"
				Y "75"
				Width "39"
				Height "14"
				DefaultButton "1"
				Value
				Method
				SetFocus "1"
				EndDialog "1"
			}
		}
		Title "A propos de Dolet 8 pour Sibelius"
		X "445"
		Y "268"
		Width "176"
		Height "115"
	}
	AboutBox_it "Dialog"
	{
		Controls
		{
			Text
			{
				Title "Dolet 8 per Sibelius"
				X "7"
				Y "7"
				Width "146"
				Height "14"
				RightAlign "0"
				Value
				Method
				SetFocus "0"
			}
			Text
			{
				Title "Versione 8.3"
				X "7"
				Y "23"
				Width "146"
				Height "14"
				RightAlign "0"
				Value
				Method
				SetFocus "0"
			}
			Text
			{
				Title "Copyright © 2003-2023 MakeMusic, Inc."
				X "7"
				Y "39"
				Width "146"
				Height "14"
				RightAlign "0"
				Value
				Method
				SetFocus "0"
			}
			Button
			{
				Title "OK"
				X "124"
				Y "75"
				Width "39"
				Height "14"
				DefaultButton "1"
				Value
				Method
				SetFocus "1"
				EndDialog "1"
			}
		}
		Title "Info su Dolet 8 per Sibelius"
		X "445"
		Y "268"
		Width "176"
		Height "115"
	}
	AboutBox_es "Dialog"
	{
		Controls
		{
			Text
			{
				Title "Dolet 8 para Sibelius"
				X "7"
				Y "7"
				Width "146"
				Height "14"
				RightAlign "0"
				Value
				Method
				SetFocus "0"
			}
			Text
			{
				Title "Versión 8.3"
				X "7"
				Y "23"
				Width "146"
				Height "14"
				RightAlign "0"
				Value
				Method
				SetFocus "0"
			}
			Text
			{
				Title "Copyright © 2003-2023 MakeMusic, Inc."
				X "7"
				Y "39"
				Width "146"
				Height "14"
				RightAlign "0"
				Value
				Method
				SetFocus "0"
			}
			Button
			{
				Title "Aceptar"
				X "124"
				Y "75"
				Width "39"
				Height "14"
				DefaultButton "1"
				Value
				Method
				SetFocus "1"
				EndDialog "1"
			}
		}
		Title "Acerca de Dolet 8 para Sibelius"
		X "445"
		Y "268"
		Width "176"
		Height "115"
	}
	AboutBox_ja "Dialog"
	{
		Controls
		{
			Text
			{
				Title "Dolet 8 Sibelius"
				X "7"
				Y "7"
				Width "148"
				Height "14"
				RightAlign "0"
				Value
				Method
				SetFocus "0"
			}
			Text
			{
				Title "Version 8.3"
				X "7"
				Y "23"
				Width "148"
				Height "14"
				RightAlign "0"
				Value
				Method
				SetFocus "0"
			}
			Text
			{
				Title "Copyright © 2003-2023 MakeMusic, Inc."
				X "7"
				Y "39"
				Width "148"
				Height "14"
				RightAlign "0"
				Value
				Method
				SetFocus "0"
			}
			Button
			{
				Title "OK"
				X "124"
				Y "75"
				Width "39"
				Height "14"
				DefaultButton "1"
				Value
				Method
				SetFocus "1"
				EndDialog "1"
			}
		}
		Title "Dolet 8 Sibelius対応版"
		X "445"
		Y "268"
		Width "176"
		Height "115"
	}
	ShowAbout "() {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

switch (Sibelius.ApplicationLanguage) {
	case ('English') {
		Sibelius.ShowDialog(AboutBox, Self);
	}
	case ('German') {
		Sibelius.ShowDialog(AboutBox_de, Self);
	}
	case ('French') {
		Sibelius.ShowDialog(AboutBox_fr, Self);
	}
	case ('Italian') {
		Sibelius.ShowDialog(AboutBox_it, Self);
	}
	case ('Spanish') {
		Sibelius.ShowDialog(AboutBox_es, Self);
	}
	case ('Japanese') {
		Sibelius.ShowDialog(AboutBox_ja, Self);
	}
	default {
		Sibelius.ShowDialog(AboutBox, Self);
	}
}
}"
	ToXmlText "(OldText) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Escape ampersands and the like for valid XML text.

sNewText = '';
nOldLength = Length(OldText);

// Watch out for idiosyncratic for syntax (stops before last value)
for i = 0 to nOldLength {
	c = CharAt(OldText, i);
	intc = Round(c);
	// Strange ordering of operands to avoid any possible
	// buggy string-to-char conversion.
	if ('&' = c) {
		sNewText = sNewText & '&amp;';
	} else {
		if ('\'' = c) {
			sNewText = sNewText & '&apos;';
		} else {
			if (Chr(34) = c) {
				sNewText = sNewText & '&quot;';
			} else {
				if ('<' = c) {
					sNewText = sNewText & '&lt;';
				} else {
					if ('>' = c) {
						sNewText = sNewText & '&gt;';
					} else {
						// Do not output C0 control characters
						// with numeric values less than the
						// space character. Make an exception
						// for CR and LF characters.
						if ((SpaceCharInt <= intc) or (intc = 13) or (intc = 10)) {
							sNewText = sNewText & c;
						}
					}
				}
			}
		}
	}
}
return sNewText;
}"
	TabClef "-1"
	PitchStep "(MidiPitch) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get a MusicXML pitch step from a MIDI pitch.
// Used for TAB in Sibelius 2, where MIDI is all we have.
// All naturals or sharps to go with guitar use.

nVal = MidiPitch % 12;
if (nVal < 7) {
	if (nVal < 4) {
		if (nVal < 2) {
			return 'C';
		} else {
			return 'D';
		}
	} else {
		if (nVal < 5) {
			return 'E';
		} else {
			return 'F';
		}
	}
} else {
	if (nVal < 9) {
		return 'G';
	} else {
		if (nVal < 11) {
			return 'A';
		} else {
			return 'B';
		}
	}
}
}"
	PitchAlter "(MidiPitch) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get a MusicXML pitch alter from a MIDI pitch.
// Used for TAB in Sibelius 2, where MIDI is all we have.
// All naturals or sharps to go with guitar use.

nVal = MidiPitch % 12;
if ((nVal = 1) or (nVal = 3) or (nVal = 6) or (nVal = 8) or (nVal = 10)) {
	return 1;
} else {
	return 0;
}
}"
	TabStrings "6"
	WriteSystemSymbolItem "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Sibelius 4 gave us access to symbol items.

// For debugging
if (ShowTrace) {
	trace('Found system symbol ' & BarObject.Index & ' (' &
	      BarObject.Name & ') in bar ' & BarObject.ParentBar.BarNumber & 
	      ', position ' & BarObject.Position);
}

// If hidden, just return without writing.
if (BarObject.Hidden) {
	return 0;
}

// Negative number lookup in array can loop Sibelius.
if (BarObject.Index < 0) {
	LogError('Unrecognized symbol item index ' & BarObject.Index, 3);
	return 0;
}

// System symbols are always directions, not notations, so 
// just delegate to the method for writing symbol directions.
// The only thing we need to check is percussion vs. others.
sSymbolParent = '' & SymbolIndexParents[BarObject.Index];
if (sSymbolParent = 'percussion') {
	WriteSymbolPercussion(BarObject, StaffNumber);
} else {
	WriteSymbolDirection(BarObject, StaffNumber);
}
}"
	PercussionClef "-1"
	SibMeasureCounter "0"
	SpaceChar
	ZeroChar
	PeriodChar
	VersionString "() {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return version string for MusicXML identification

if (Sibelius.ProgramVersion >= 20000000) {
	nMajorVersion = RoundDown(Sibelius.ProgramVersion / 10000);
	nNoMajor = Sibelius.ProgramVersion - (nMajorVersion * 10000);
} else {
	nMajorVersion = RoundDown(Sibelius.ProgramVersion / 1000);
	nNoMajor = Sibelius.ProgramVersion - (nMajorVersion * 1000);
}
nMinorVersion = RoundDown(nNoMajor / 100);
nNoMinor = nNoMajor - (nMinorVersion * 100);
nRevision = RoundDown(nNoMinor / 10);
if (nMajorVersion = 19) {
	nMajorVersion = 2019;
}
if (nRevision > 0) {
	return 'Sibelius ' & nMajorVersion & '.' & nMinorVersion & '.' & nRevision;
} else {
	return 'Sibelius ' & nMajorVersion & '.' & nMinorVersion;
}
}"
	WriteNotehead "(NoteStyle, IsOpen, Bracketed) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

sNotehead = '';
sFilled = '';
fPostSib5 = True;

// If we are writing the notehead element for the
// bracketing, start off with a normal notehead value.
if (Bracketed) {
	sNotehead = 'normal';
}

switch (NoteStyle) {
	case (CrossNoteStyle) {
		if (IsOpen) {
			sNotehead = 'circle-x';
		} else {
			sNotehead = '' & 'x';
		}
	}
	case (DiamondNoteStyle) {
		// Unfilled diamond for all notes.
		sNotehead = 'diamond';
		if (not IsOpen) {
			sFilled = 'no';
		}
	}
	case (BeatWithoutStemNoteStyle) {
		// Slash notation. The open shape is a diamond 
		// by default starting in Sibelius 5, an open slash
		// otherwise.
		if (Sibelius.ActiveScore.OriginalProgramVersion < 5000) {
			fPostSib5 = False;
		}
		if (IsOpen and fPostSib5) {
			sNotehead = 'diamond';
		} else {
			sNotehead = 'slash';
		}
	}
	case (BeatNoteStyle) {
		// Slash notation. The open shape is a diamond 
		// by default starting in Sibelius 5, an open slash
		// otherwise.
		if (Sibelius.ActiveScore.OriginalProgramVersion < 5000) {
			fPostSib5 = False;
		}
		if (IsOpen and fPostSib5) {
			sNotehead = 'diamond';
		} else {
			sNotehead = 'slash';
		}
	}
	case (CrossOrDiamondNoteStyle) {
		if (IsOpen) {
			sNotehead = 'diamond';
		} else {
			sNotehead = '' & 'x';
		}
	}
	case (BlackAndWhiteDiamondNoteStyle) {
		// Filled/unfilled diamond. Follows
		// normal MusicXML rules, so no
		// filled attribute needed.
		sNotehead = 'diamond';
	}
	case (HeadlessNoteStyle) {
		sNotehead = 'none';
	}
	case (SlashedNoteStyle) {
		sNotehead = 'slashed';
	}
	case (BackSlashedNoteStyle) {
		sNotehead = 'back slashed';
	}
	case (ArrowDownNoteStyle) {
		sNotehead = 'arrow down';
	}
	case (ArrowUpNoteStyle) {
		sNotehead = 'arrow up';
	}
	case (InvertedTriangleNoteStyle) {
		sNotehead = 'inverted triangle';
	}
	case (ShapedNote1NoteStyle) {
		sNotehead = 'do';
	}
	case (ShapedNote2NoteStyle) {
		sNotehead = 're';
	}
	case (ShapedNote3NoteStyle) {
		sNotehead = 'mi';
	}
	case (ShapedNote4StemUpNoteStyle) {
		sNotehead = 'fa up';
	}
	case (ShapedNote4StemDownNoteStyle) {
		sNotehead = 'fa';
	}
	case (ShapedNote5NoteStyle) {
		sNotehead = 'so';
	}
	case (ShapedNote6NoteStyle) {
		sNotehead = 'la';
	}
	case (ShapedNote7NoteStyle) {
		sNotehead = 'ti';
	}
	// Noteheads 24-30 are now standard in Sibelius
	// but do not yet have ManuScript constants.
	case (24) {
		if (IsOpen) {
			sNotehead = 'circle-x';
		} else {
			sNotehead = '' & 'x';
		}
	}
	case (25) {
		if (not IsOpen) {
			sNotehead = 'none';
		}
	}
	case (26) {
		if (IsOpen) {
			sNotehead = '' & 'x';
		} else {
			sNotehead = 'diamond';
		}
	}
	case (27) {
		sNotehead = 'slash';
	}
	case (28) {
		sNotehead = 'slash';
	}
	case (29) {
		if (IsOpen) {
			sNotehead = 'circle-x';
		} else {
			sNotehead = '' & 'x';
		}
	}
	case (30) {
		sNotehead = 'circle dot';
	}
}

if (Length(sNotehead) > 0) {
	sFilledAttr = '';
	sBracketed = '';
	if (Length(sFilled) > 0) {
		sFilledAttr = ' filled=\'' & sFilled & '\'';
	}
	if (Bracketed) {
		sBracketed = ' parentheses=\'yes\'';
	}
	WriteXML('<notehead' & sFilledAttr & sBracketed & '>' & 
			 sNotehead & '</notehead>', 4);
}
}"
	WriteHighLight "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// We are not exporting highlights. Not really an
// error, so do not log it.
x = 1;
}"
	CodaSymbol2
	SegnoSymbol2
	SymbolCount
	WriteSymbolDirection "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// See if this is a system symbol item
fSystemSymbol = False;
sPosition = '';
if (BarObject.Type = 'SystemSymbolItem') {
	fSystemSymbol = True;
} else {
	// Get the position based on object Dx and Dy properties.
	sPosition = ' ' & GetPosition(BarObject.Dx, BarObject.Dy, False);
}

nOffset = (BarObject.Position * 3) - MeasureCounter;
sColor = GetColor(BarObject);
nBarCounter = 0 + BarCounter;

// Determine what type of direction we have.
sDirection = '';
sType = '';
sText = '';
sSymbol = '';
sSmufl = '';
fAccordion = False;
fAbbreviated = False;
fUnrecognized = False;

switch (BarObject.Index) {
	case (1) {
		sDirection = 'segno';
	}
	case (2) {
		sDirection = 'coda';
	}
	case (3) {
		sDirection = 'segno';
		sSmufl = 'segnoSerpent1';
	}
	case (4) {
		sDirection = 'segno';
		sSmufl = 'segnoSerpent2';
	}
	case (5) {
		sDirection = 'symbol';
		sText = 'repeatBarSlash';
	}
	case (6) {
		sDirection = 'symbol';
		sText = 'repeat1Bar';
	}
	case (7) {
		sDirection = 'symbol';
		sText = 'repeat2Bars';
	}
	case (8) {
		sDirection = 'symbol';
		sText = 'repeat4Bars';
	}
	case (9) {
		sDirection = 'symbol';
		sText = 'barlineSingle';
	}
	case (10) {
		sDirection = 'symbol';
		sText = 'repeatLeft';
	}
	case (11) {
		sDirection = 'symbol';
		sText = 'repeatRight';
	}
	case (12) {
		sDirection = 'symbol';
		sText = 'barlineFinal';
	}
	case (13) {
		sDirection = 'segno';
		sSmufl = 'segnoJapanese';
	}
	case (14) {
		sDirection = 'coda';
		sSmufl = 'codaJapanese';
	}
	case (16) {
		sDirection = 'symbol';
		sText = 'miscDoNotPhotocopy';
	}
	case (18) {
		sDirection = 'words';
		sText = '' & '(';
	}
	case (19) {
		sDirection = 'words';
		sText = '' & ')';
	}
	case (20) {
		sDirection = 'words';
		sText = '' & '{';
	}
	case (21) {
		sDirection = 'words';
		sText = '' & '}';
	}
	case (26) {
		sDirection = 'words';
		sText = '' & '(';
	}
	case (30) {
		sDirection = 'words';
		sText = '' & '-';
	}
	case (31) {
		sDirection = 'words';
		sText = '' & ')';
	}
	case (48) {
		sDirection = 'pedal';
		sType = 'start';
	}
	case (49) {
		sDirection = 'pedal';
		sType = 'start';
		fAbbreviated = True;
	}
	case (50) {
		sDirection = 'pedal';
		sType = 'stop';
	}
	case (51) {
		sDirection = 'pedal';
		sType = 'change';
	}
	case (78) {
		sDirection = 'words';
		sText = '' & 'z';
	}
	case (163) {
		sDirection = 'damp';
	}
	case (164) {
		sDirection = 'damp';
	}
	case (288) {
		sDirection = 'symbol';
		sText = 'note16thUp';
	}
	case (289) {
		sDirection = 'symbol';
		sText = 'note8thUp';
	}
	case (290) {
		sDirection = 'symbol';
		sText = 'noteQuarterUp';
	}
	case (291) {
		sDirection = 'symbol';
		sText = 'noteHalfUp';
	}
	case (292) {
		sDirection = 'symbol';
		sText = 'flagInternalUp';
	}
	case (293) {
		sDirection = 'symbol';
		sText = 'augmentationDot';
	}
	case (296) {
		sDirection = 'symbol';
		sText = 'flag8thUp';
	}
	case (297) {
		sDirection = 'symbol';
		sText = 'flag16thUp';
	}
	case (298) {
		sDirection = 'symbol';
		sText = 'flag32ndUp';
	}
	case (299) {
		sDirection = 'symbol';
		sText = 'flag64thUp';
	}
	case (300) {
		sDirection = 'symbol';
		sText = 'flag128thUp';
	}
	case (301) {
		sDirection = 'symbol';
		sText = 'flag256thUp';
	}
	case (302) {
		sDirection = 'symbol';
		sText = 'flag512thUp';
	}
	case (303) {
		sDirection = 'symbol';
		sText = 'noteheadClusterRoundBlack';
	}
	case (304) {
		sDirection = 'symbol';
		sText = 'note16thDown';
	}
	case (305) {
		sDirection = 'symbol';
		sText = 'note8thDown';
	}
	case (306) {
		sDirection = 'symbol';
		sText = 'noteQuarterDown';
	}
	case (307) {
		sDirection = 'symbol';
		sText = 'noteHalfDown';
	}
	case (308) {
		sDirection = 'symbol';
		sText = 'flagInternalDown';
	}
	case (312) {
		sDirection = 'symbol';
		sText = 'flag8thDown';
	}
	case (313) {
		sDirection = 'symbol';
		sText = 'flag16thDown';
	}
	case (314) {
		sDirection = 'symbol';
		sText = 'flag32ndDown';
	}
	case (315) {
		sDirection = 'symbol';
		sText = 'flag64thDown';
	}
	case (316) {
		sDirection = 'symbol';
		sText = 'flag128thDown';
	}
	case (317) {
		sDirection = 'symbol';
		sText = 'flag256thDown';
	}
	case (318) {
		sDirection = 'symbol';
		sText = 'flag512thDown';
	}
	case (320) {
		sDirection = 'symbol';
		sText = 'noteheadBlack';
	}
	case (321) {
		sDirection = 'symbol';
		sText = 'noteheadHalf';
	}
	case (322) {
		sDirection = 'symbol';
		sText = 'noteheadWhole';
	}
	case (323) {
		sDirection = 'symbol';
		sText = 'noteheadDoubleWhole';
	}
	case (324) {
		sDirection = 'symbol';
		sText = 'noteheadDoubleWholeSquare';
	}
	case (325) {
		sDirection = 'symbol';
		sText = 'mensuralWhiteMaxima';
	}
	case (326) {
		sDirection = 'words';
		sText = '' & 'x';
	}
	case (342) {
		sDirection = 'symbol';
		sText = 'noteheadWhole';	// noteheadWholeSmall
	}
	case (348) {
		sDirection = 'symbol';
		sText = 'noteheadBlack';	// noteheadBlackSmall
	}
	case (349) {
		sDirection = 'symbol';
		sText = 'noteheadHalf';		// noteheadHalfSmall
	}
	case (350) {
		sDirection = 'symbol';
		sText = 'noteheadBlack';	// noteheadBlackOversized
	}
	case (351) {
		sDirection = 'symbol';
		sText = 'noteheadHalf';		// noteheadHalfOversized
	}
	case (362) {
		sDirection = 'symbol';
		sText = 'noteheadBlack';	// noteShapeRoundBlack
	}
	case (363) {
		sDirection = 'symbol';
		sText = 'noteheadHalf';		// noteShapeRoundWhite
	}
	case (368) {
		sDirection = 'symbol';
		sText = 'rest512th';
	}
	case (369) {
		sDirection = 'symbol';
		sText = 'rest256th';
	}
	case (370) {
		sDirection = 'symbol';
		sText = 'rest128th';
	}
	case (371) {
		sDirection = 'symbol';
		sText = 'rest64th';
	}
	case (372) {
		sDirection = 'symbol';
		sText = 'rest32nd';
	}
	case (373) {
		sDirection = 'symbol';
		sText = 'rest16th';
	}
	case (374) {
		sDirection = 'symbol';
		sText = 'rest8th';
	}
	case (375) {
		sDirection = 'symbol';
		sText = 'restQuarter';
	}
	case (376) {
		sDirection = 'symbol';
		sText = 'restHalf';
	}
	case (377) {
		sDirection = 'symbol';
		sText = 'restWhole';
	}
	case (378) {
		sDirection = 'symbol';
		sText = 'restDoubleWhole';
	}
	case (380) {
		sDirection = 'symbol';
		sText = 'restLonga';
	}
	case (386) {
		sDirection = 'symbol';
		sText = 'restMaxima';
	}
	case (400) {
		sDirection = 'principal-voice';
		sSymbol = 'Hauptstimme';
		sType = 'start';
	}
	case (401) {
		sDirection = 'principal-voice';
		sSymbol = 'Nebenstimme';
		sType = 'start';
	}
	case (402) {
		sDirection = 'principal-voice';
		sSymbol = 'plain';
		sType = 'start';
	}
	case (403) {
		sDirection = 'principal-voice';
		sSymbol = 'plain';
		sType = 'stop';
	}
	case (404) {
		sDirection = 'principal-voice';
		sSymbol = 'plain';
		sType = 'start';
	}
	case (405) {
		sDirection = 'principal-voice';
		sSymbol = 'plain';
		sType = 'stop';
	}
	case (408) {
		sDirection = 'symbol';
		sText = 'conductorStrongBeat';
	}
	case (409) {
		sDirection = 'symbol';
		sText = 'conductorLeftBeat';
	}
	case (410) {
		sDirection = 'symbol';
		sText = 'conductorRightBeat';
	}
	case (411) {
		sDirection = 'symbol';
		sText = 'conductorWeakBeat';
	}
	case (412) {
		sDirection = 'symbol';
		sText = 'conductorBeat2Simple';
	}
	case (413) {
		sDirection = 'symbol';
		sText = 'conductorBeat3Simple';
	}
	case (414) {
		sDirection = 'symbol';
		sText = 'conductorBeat2Compound';
	}
	case (415) {
		sDirection = 'symbol';
		sText = 'conductorBeat3Compound';
	}
	case (416) {
		sDirection = 'symbol';
		sText = 'gClef';
	}
	case (417) {
		sDirection = 'symbol';
		sText = 'cClef';
	}
	case (418) {
		sDirection = 'symbol';
		sText = 'cClef';
	}
	case (419) {
		sDirection = 'symbol';
		sText = 'fClef';
	}
	case (420) {
		sDirection = 'symbol';
		sText = 'unpitchedPercussionClef1';
	}
	case (421) {
		sDirection = 'symbol';
		sText = 'unpitchedPercussionClef2';
	}
	case (422) {
		sDirection = 'symbol';
		sText = '6stringTabClef';
	}
	case (423) {
		sDirection = 'symbol';
		sText = 'gClef15ma';
	}
	case (424) {
		sDirection = 'symbol';
		sText = 'gClef8va';
	}
	case (425) {
		sDirection = 'symbol';
		sText = 'gClef8vb';
	}
	case (426) {
		sDirection = 'symbol';
		sText = 'gClef8vbParens';
	}
	case (427) {
		sDirection = 'symbol';
		sText = 'gClef8vbOld';
	}
	case (428) {
		sDirection = 'symbol';
		sText = 'gClef';
	}
	case (429) {
		sDirection = 'symbol';
		sText = 'cClef';
	}
	case (430) {
		sDirection = 'symbol';
		sText = 'cClef';
	}
	case (431) {
		sDirection = 'symbol';
		sText = 'cClef8vb';
	}
	case (432) {
		sDirection = 'symbol';
		sText = 'cClef';
	}
	case (433) {
		sDirection = 'symbol';
		sText = 'fClef8va';
	}
	case (434) {
		sDirection = 'symbol';
		sText = 'fClef8vb';
	}
	case (435) {
		sDirection = 'symbol';
		sText = 'fClef15ma';
	}
	case (436) {
		sDirection = 'symbol';
		sText = 'fClef';
	}
	case (438) {
		sDirection = 'symbol';
		sText = '4stringTabClef';
	}
	case (439) {
		sDirection = 'symbol';
		sText = '6stringTabClefTall';
	}
	case (440) {
		sDirection = 'symbol';
		sText = '4stringTabClefTall';
	}
	case (441) {
		sDirection = 'symbol';
		sText = 'fClef';
	}
	case (446) {
		sDirection = 'symbol';
		sText = 'clef8';
	}
	case (447) {
		sDirection = 'symbol';
		sText = 'clef15';
	}
	case (448) {
		sDirection = 'symbol';
		sText = 'ottava';
	}
	case (450) {
		sDirection = 'symbol';
		sText = 'ottavaAlta';
	}
	case (452) {
		sDirection = 'symbol';
		sText = 'ottavaBassaVb';
	}
	case (454) {
		sDirection = 'symbol';
		sText = 'ottavaBassaBa';
	}
	case (456) {
		sDirection = 'symbol';
		sText = 'quindicesima';
	}
	case (458) {
		sDirection = 'symbol';
		sText = 'quindicesimaAlta';
	}
	case (460) {
		sDirection = 'symbol';
		sText = 'quindicesimaBassaMb';
	}
	case (474) {
		sDirection = 'eyeglasses';
	}
	case (482) {
		sDirection = 'string-mute';
		sType = 'on';
	}
	case (493) {
		sDirection = 'string-mute';
		sType = 'off';
	}
	case (512) {
		sDirection = 'symbol';
		sText = 'accdnRH4RanksSoprano';
	}
	case (517) {
		sDirection = 'symbol';
		sText = 'accdnRH4RanksBassAlto';
	}
	case (518) {
		sDirection = 'symbol';
		sText = 'accdnRH4RanksSoftTenor';
	}
	case (519) {
		sDirection = 'symbol';
		sText = 'accdnRH4RanksSoftBass';
	}
	case (520) {
		sDirection = 'symbol';
		sText = 'accdnRH4RanksMaster';
	}
	case (521) {
		sDirection = 'symbol';
		sText = 'accdnRH4RanksAlto';
	}
	case (522) {
		sDirection = 'symbol';
		sText = 'accdnRH4RanksTenor';
	}
	case (528) {
		sDirection = 'symbol';
		sText = 'accdnLH2Ranks8Round';
	}
	case (529) {
		sDirection = 'symbol';
		sText = 'accdnLH2Ranks16Round';
	}
	case (530) {
		sDirection = 'symbol';
		sText = 'accdnLH2Ranks8Plus16Round';
	}
	case (531) {
		sDirection = 'symbol';
		sText = 'accdnLH2RanksMasterRound';
	}
	case (532) {
		sDirection = 'symbol';
		sText = 'accdnLH2RanksMasterPlus16Round';
	}
	case (533) {
		sDirection = 'symbol';
		sText = 'accdnLH2RanksFullMasterRound';
	}
	case (819) {
		sDirection = 'staff-divide';
		sType = 'up-down';
	}
	default {
		if ((BarObject.Index >= 496) and (BarObject.Index <= 510)) {
			fAccordion = True;
		} else {
			// Write an other-direction element based on the symbol
			// name, but log that this is an unrecognized symbol index.
			sDirection = 'other-direction';
			sText = ToXmlText(BarObject.Name);
			fUnrecognized = True;
		}
	}
}

// Build the string to write out. Currently relies on
// the fact that none of the directions we are supporting
// here use both a type attribute and element text. If
// this changes, rework it.
sDirectionText = '';
if (Length(sSmufl) > 0) {
	sSmufl = ' smufl=\'' & sSmufl & '\'';
}
if (not fAccordion) {
	if (Length(sType) > 0) {
		if (sDirection = 'pedal') {
				sAbbreviated = '';
				if (fAbbreviated) {
					sAbbreviated = ' abbreviated=\'yes\'';
				}
				sDirectionText = '<pedal line=\'no\' type=\'' & sType & '\'' & 
								 sAbbreviated & sPosition & sColor & '/>';
		} else {
			if (sDirection = 'principal-voice') {
				sDirectionText = '<principal-voice type=\'' & sType & '\' symbol=\'' & 
								 sSymbol & '\'' & sPosition & sColor & '/>';
			} else {
				sDirectionText = '<' & sDirection & ' type=\'' & sType & '\'' &
								 sSmufl & sPosition & sColor & '/>';
			}
		}
	} else {
		if (Length(sText) > 0) {
			sDirectionText = '<' & sDirection & sSmufl & sPosition & sColor & '>' & 
							 sText & '</' & sDirection & '>';
		} else {
			sDirectionText = '<' & sDirection & sSmufl & sPosition & sColor & '/>';
		}
	}
}

// Now write it out
if (fSystemSymbol) {
	if (SystemStaffDone[nBarCounter]) {
		WriteXML('<direction placement=\'above\' system=\'also-top\'>', 3);
	} else {
		WriteXML('<direction placement=\'above\' system=\'only-top\'>', 3);
	}
} else {
	sPlacement = GetPlacement(BarObject.Dy);
	WriteXML('<direction' & sPlacement & '>', 3);
}
WriteXML('<direction-type>', 4);
if (fAccordion) {
	WriteAccordionRegistration(BarObject.Index, sColor);
} else {
	if (fUnrecognized) {
		LogSymbolError(BarObject.Index, 5);
	}
	WriteXML(sDirectionText, 5);
}
WriteXML('</direction-type>', 4);
if (nOffset != 0) {
	WriteXML('<offset>' & nOffset & '</offset>', 4);
}
// We were using the BarObject CueSize property, but probably
// should be using the Size property for symbols instead.
// if (BarObject.CueSize) {
if (not (BarObject.Size = NormalSize)) {
	WriteXML('<level size=\'cue\'/>', 4);
}
nVoice = GetVoice(BarObject, StaffNumber);
if (nVoice > 0) {
	WriteXML('<voice>' & nVoice & '</voice>', 4);
}
if (StaffNumber > 0) {
	WriteXML('<staff>' & StaffNumber & '</staff>', 4);
}
WriteXML('</direction>', 3);
}"
	WriteSymbolNotation "(SymbolArrayIndex, SymbolPrecedesNote, IsChord, LastNote) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

sNotation = '';
sContent = '';
sArrow = '';
sHoleClosed = '';
sAttrib = '';
sOrientation = '';
sHarmonClosed = '';
sHarmonHalfLocation = '';
sSmufl = '';
sArrowStyle = '';
fArrowhead = False;
fParen = False;
fLv = False;
SymbolIndex = SymbolIndices[SymbolArrayIndex];
nXmlIndent = 6;

// Get the position based on object Dx and Dy properties.
sPosition = GetPosition(SymbolDx[SymbolArrayIndex], SymbolDy[SymbolArrayIndex], False);
sColor = '' & SymbolColors[SymbolArrayIndex];
nString = 0;

switch (SymbolIndexParents[SymbolIndex]) {
	case ('technical') {
		if ((SymbolIndex >= 192) and (SymbolIndex <= 201)) {
			nString = SymbolIndex - 192;
			sNotation = '<string ' & sPosition & sColor & '>' & nString & '</string>';
		} else {
			switch (SymbolIndex) {
				case (52) {
					sNotation = 'heel';
				}
				case (53) {
					sNotation = 'heel';
				}
				case (54) {
					sNotation = 'toe';
				}
				case (55) {
					sNotation = 'toe';
				}
				case (75) {
					sNotation = 'arrow';
					sArrow = 'southeast';
				}
				case (77) {
					sNotation = 'arrow';
					sArrow = 'left right';
				}
				case (160) {
					sNotation = 'stopped';
				}
				case (161) {
					sNotation = 'half-muted';
				}
				case (162) {
					sNotation = 'open';
				}
				case (165) {
					sNotation = 'harmon-mute';
					sHarmonClosed = 'half';
					sHarmonHalfLocation = 'right';
				}
				case (166) {
					sNotation = 'harmon-mute';
					sHarmonClosed = 'half';
					sHarmonHalfLocation = 'left';
				}
				case (187) {
					sNotation = 'other-technical';
					sSmufl = 'guitarVibratoBarScoop';
				}
				case (188) {
					sNotation = 'other-technical';
					sSmufl = 'guitarVibratoBarDip';
				}
				case (202) {
					sNotation = 'other-technical';
					sSmufl = 'guitarShake';
				}
				case (215) {
					sNotation = 'harmonic';
				}
				case (216) {
					sNotation = 'stopped';
				}
				case (217) {
					sNotation = 'up-bow';
				}
				case (218) {
					sNotation = 'down-bow';
				}
				case (231) {
					sNotation = 'harmonic';
				}
				case (232) {
					sNotation = 'stopped';
				}
				case (233) {
					sNotation = 'up-bow';
				}
				case (234) {
					sNotation = 'down-bow';
				}
				case (240) {
					sNotation = 'double-tongue';
				}
				case (241) {
					sNotation = 'triple-tongue';
				}
				case (242) {
					sNotation = 'other-technical';
					sSmufl = 'tremoloDivisiDots4';
				}
				case (243) {
					sNotation = 'snap-pizzicato';
				}
				case (244) {
					sNotation = 'snap-pizzicato';
				}
				case (245) {
					sNotation = 'thumb-position';
				}
				case (246) {
					sNotation = 'thumb-position';
				}
				case (406) {
					sNotation = 'arrow';
					sArrow = 'northeast';
					sArrowStyle = 'single';
					sSmufl = 'arrowBlackUpRight';
				}
				case (407) {
					sNotation = 'arrow';
					sArrow = 'southeast';
					sArrowStyle = 'single';
					sSmufl = 'arrowBlackDownRight';
				}
				case (483) {
					sNotation = 'hole';
					sHoleClosed = 'yes';
				}
				case (484) {
					sNotation = 'hole';
					sHoleClosed = 'half';
				}
				case (485) {
					sNotation = 'hole';
					sHoleClosed = 'no';
				}
				case (490) {
					sNotation = 'fingernails';
				}
				case (560) {
					sNotation = 'handbell';
					sContent = 'martellato';
				}
				case (561) {
					sNotation = 'handbell';
					sContent = 'martellato lift';
				}
				case (562) {
					sNotation = 'handbell';
					sContent = 'hand martellato';
				}
				case (563) {
					sNotation = 'handbell';
					sContent = 'muted martellato';
				}
				case (564) {
					sNotation = 'stopped';
					sSmufl = 'handbellsMalletBellSuspended';
				}
				case (565) {
					sNotation = 'handbell';
					sContent = 'mallet table';
				}
				case (566) {
					sNotation = 'handbell';
					sContent = 'mallet lift';
				}
				case (567) {
					sNotation = 'arrow';
					sArrow = 'up';
					sSmufl = 'handbellsSwingUp';
				}
				case (568) {
					sNotation = 'arrow';
					sArrow = 'down';
					sSmufl = 'handbellsSwingDown';
				}
				case (569) {
					sNotation = 'handbell';
					sContent = 'swing';
				}
				case (570) {
					sNotation = 'handbell';
					sContent = 'echo';
				}
				case (571) {
					sNotation = 'other-technical';
					sSmufl = 'handbellsEcho2';
				}
				case (572) {
					sNotation = 'handbell';
					sContent = 'gyro';
				}
				case (573) {
					sNotation = 'handbell';
					sContent = 'damp';
				}
				case (640) {
					sNotation = 'arrow';
					sArrow = 'up';
					sArrowStyle = 'single';
					sSmufl = 'arrowOpenUp';
				}
				case (641) {
					sNotation = 'arrow';
					sArrow = 'down';
					sArrowStyle = 'single';
					sSmufl = 'arrowOpenDown';
				}
				case (642) {
					sNotation = 'arrow';
					sArrow = 'left';
					sArrowStyle = 'single';
					sSmufl = 'arrowOpenLeft';
				}
				case (643) {
					sNotation = 'arrow';
					sArrow = 'right';
					sArrowStyle = 'single';
					sSmufl = 'arrowOpenRight';
				}
				case (644) {
					sNotation = 'arrow';
					sArrow = 'northwest';
					sArrowStyle = 'single';
					sSmufl = 'arrowOpenUpLeft';
				}
				case (645) {
					sNotation = 'arrow';
					sArrow = 'northeast';
					sArrowStyle = 'single';
					sSmufl = 'arrowOpenUpRight';
				}
				case (646) {
					sNotation = 'arrow';
					sArrow = 'southwest';
					sArrowStyle = 'single';
					sSmufl = 'arrowOpenDownLeft';
				}
				case (647) {
					sNotation = 'arrow';
					sArrow = 'southeast';
					sArrowStyle = 'single';
					sSmufl = 'arrowOpenDownRight';
				}
				case (648) {
					sNotation = 'arrow';
					sArrow = 'up';
					sArrowStyle = 'single';
					sSmufl = 'arrowheadOpenUp';
					fArrowhead = True;
				}
				case (649) {
					sNotation = 'arrow';
					sArrow = 'down';
					sArrowStyle = 'single';
					sSmufl = 'arrowheadOpenDown';
					fArrowhead = True;
				}
				case (650) {
					sNotation = 'arrow';
					sArrow = 'left';
					sArrowStyle = 'single';
					sSmufl = 'arrowheadOpenLeft';
					fArrowhead = True;
				}
				case (651) {
					sNotation = 'arrow';
					sArrow = 'right';
					sArrowStyle = 'single';
					sSmufl = 'arrowheadOpenRight';
					fArrowhead = True;
				}
				case (652) {
					sNotation = 'arrow';
					sArrow = 'northwest';
					sArrowStyle = 'single';
					sSmufl = 'arrowheadOpenUpLeft';
					fArrowhead = True;
				}
				case (653) {
					sNotation = 'arrow';
					sArrow = 'northeast';
					sArrowStyle = 'single';
					sSmufl = 'arrowheadOpenUpRight';
					fArrowhead = True;
				}
				case (654) {
					sNotation = 'arrow';
					sArrow = 'southwest';
					sArrowStyle = 'single';
					sSmufl = 'arrowheadOpenDownLeft';
					fArrowhead = True;
				}
				case (655) {
					sNotation = 'arrow';
					sArrow = 'southeast';
					sArrowStyle = 'single';
					sSmufl = 'arrowheadOpenDownRight';
					fArrowhead = True;
				}
				case (656) {
					sNotation = 'arrow';
					sArrow = 'up';
					sArrowStyle = 'filled';
					sSmufl = 'arrowheadBlackUp';
					fArrowhead = True;
				}
				case (657) {
					sNotation = 'arrow';
					sArrow = 'down';
					sArrowStyle = 'filled';
					sSmufl = 'arrowheadBlackDown';
					fArrowhead = True;
				}
				case (658) {
					sNotation = 'arrow';
					sArrow = 'left';
					sArrowStyle = 'filled';
					sSmufl = 'arrowheadBlackLeft';
					fArrowhead = True;
				}
				case (659) {
					sNotation = 'arrow';
					sArrow = 'right';
					sArrowStyle = 'filled';
					sSmufl = 'arrowheadBlackRight';
					fArrowhead = True;
				}
				case (660) {
					sNotation = 'arrow';
					sArrow = 'northwest';
					sArrowStyle = 'filled';
					sSmufl = 'arrowheadBlackUpLeft';
					fArrowhead = True;
				}
				case (661) {
					sNotation = 'arrow';
					sArrow = 'northeast';
					sArrowStyle = 'filled';
					sSmufl = 'arrowheadBlackUpRight';
					fArrowhead = True;
				}
				case (662) {
					sNotation = 'arrow';
					sArrow = 'southwest';
					sArrowStyle = 'filled';
					sSmufl = 'arrowheadBlackDownLeft';
					fArrowhead = True;
				}
				case (663) {
					sNotation = 'arrow';
					sArrow = 'southeast';
					sArrowStyle = 'filled';
					sSmufl = 'arrowheadBlackDownRight';
					fArrowhead = True;
				}
			}
			if (Length(sSmufl) > 0) {
				sSmufl = ' smufl=\'' & sSmufl & '\'';
			}
			if (Length(sNotation) > 0) {
				if (Length(sContent) > 0) {
					sNotation = '<' & sNotation & ' ' & sPosition & sSmufl & sColor & '>' &
								sContent & '</' & sNotation & '>';
				} else {
					if ((Length(sArrow) > 0) or (Length(sHoleClosed) > 0) or
						(Length(sHarmonClosed) > 0)) {
						sNotation = '<' & sNotation & ' ' & sPosition & sSmufl & sColor & '>';
					} else {
						sNotation = '<' & sNotation & ' ' & sPosition & sSmufl & sColor & '/>';
					}
				}
			}
		}
	}
	case ('articulations') {
		switch (SymbolIndex) {
			case (209) {
				sNotation = 'staccato';
			}
			case (210) {
				sNotation = 'staccatissimo';
			}
			case (211) {
				sNotation = 'spiccato';
			}
			case (212) {
				sNotation = 'tenuto';
			}
			case (213) {
				sNotation = 'accent';
			}
			case (214) {
				sNotation = 'strong-accent type=\'up\'';
			}
			case (225) {
				sNotation = 'staccato';
			}
			case (226) {
				sNotation = 'staccatissimo';
			}
			case (227) {
				sNotation = 'spiccato';
			}
			case (228) {
				sNotation = 'tenuto';
			}
			case (229) {
				sNotation = 'accent';
			}
			case (230) {
				sNotation = 'strong-accent type=\'down\'';
			}
			case (247) {
				sNotation = 'breath-mark';
				sContent = 'comma';
			}
			case (248) {
				sNotation = 'breath-mark';
				sContent = 'tick';
			}
			case (249) {
				sNotation = 'caesura';
			}
			case (250) {
				sNotation = 'caesura';
			}
			case (251) {
				sNotation = 'stress';
			}
			case (252) {
				sNotation = 'stress';
			}
			case (253) {
				sNotation = 'unstress';
			}
			case (254) {
				sNotation = 'unstress';
			}
			case (255) {
				sNotation = 'spiccato';
			}
			case (480) {
				sNotation = 'doit';
				if (SymbolPrecedesNote) {
					sNotation = 'scoop';
				}
			}
			case (481) {
				sNotation = 'falloff';
				if (SymbolPrecedesNote) {
					sNotation = 'plop';
				}
			}
			case (494) {
				sNotation = 'doit';
				if (SymbolPrecedesNote) {
					sNotation = 'scoop';
				}
			}
			case (495) {
				sNotation = 'falloff';
				if (SymbolPrecedesNote) {
					sNotation = 'plop';
				}
			}
		}
		if (Length(sNotation) > 0) {
			if (Length(sContent) > 0) {
				sNotation = '<' & sNotation & ' ' & sPosition & sColor & '>' &
							sContent & '</' & sNotation & '>';
			} else {
				sNotation = '<' & sNotation & ' ' & sPosition & sColor & '/>';
			}
		}
	}
	case ('ornaments') {
		switch (SymbolIndex) {
			case (32) {
				sNotation = 'trill-mark';
			}
			case (33) {
				sNotation = 'trill-mark';
			}
			case (36) {
				sNotation = 'inverted-mordent';
			}
			case (37) {
				sNotation = 'mordent';
			}
			case (38) {
				sNotation = 'turn';
			}
			case (39) {
				sNotation = 'turn slash=\'yes\'';
			}
			case (40) {
				sNotation = 'inverted-turn';
			}
			case (41) {
				sNotation = 'inverted-mordent long=\'yes\'';
			}
			case (42) {
				sNotation = 'mordent long=\'yes\'';
			}
			case (43) {
				sNotation = 'inverted-mordent departure=\'above\'';
			}
			case (44) {
				sNotation = 'inverted-mordent long=\'yes\' approach=\'below\'';
			}
			case (45) {
				sNotation = 'inverted-mordent long=\'yes\' approach=\'above\'';
			}
			case (46) {
				sNotation = 'other-ornament smufl=\'ornamentRightFacingHalfCircle\'';
			}
			case (577) {
				sNotation = 'inverted-mordent long=\'yes\' approach=\'above\'';
			}
			case (578) {
				sNotation = 'mordent long=\'yes\' approach=\'above\'';
			}
			case (579) {
				sNotation = 'inverted-mordent departure=\'below\'';
			}
			case (580) {
				sNotation = 'inverted-mordent approach=\'above\'';
			}
			case (581) {
				sNotation = 'inverted-mordent long=\'yes\' approach=\'above\'';
			}
			case (582) {
				sNotation = 'inverted-mordent long=\'yes\' approach=\'below\'';
			}
			case (583) {
				sNotation = 'inverted-mordent approach=\'above\'';
			}
			case (584) {
				sNotation = 'mordent';
			}
			case (585) {
				sNotation = 'inverted-mordent';
			}
			case (586) {
				sNotation = 'inverted-mordent long=\'yes\' approach=\'below\'';
			}
			case (587) {
				sNotation = 'inverted-mordent long=\'yes\' approach=\'above\'';
			}
			case (588) {
				sNotation = 'inverted-mordent long=\'yes\'';
			}
			case (589) {
				sNotation = 'inverted-mordent departure=\'above\'';
			}
			case (590) {
				sNotation = 'other-ornament smufl=\'ornamentPortDeVoixV\'';
			}
			case (592) {
				sNotation = 'other-ornament smufl=\'ornamentLeftFacingHook\'';
			}
			case (594) {
				sNotation = 'other-ornament smufl=\'ornamentRightFacingHook\'';
			}
			case (595) {
				sNotation = 'other-ornament smufl=\'ornamentHookAfterNote\'';
			}
			case (596) {
				sNotation = 'other-ornament smufl=\'ornamentHookBeforeNote\'';
			}
			case (608) {
				sNotation = 'other-ornament smufl=\'ornamentShakeMuffat1\'';
			}
			case (611) {
				sNotation = 'other-ornament smufl=\'ornamentObliqueLineHorizBeforeNote\'';
			}
			case (612) {
				sNotation = 'other-ornament smufl=\'ornamentObliqueLineHorizAfterNote\'';
			}
			case (613) {
				sNotation = 'turn';
			}
			case (614) {
				sNotation = 'inverted-turn';
			}
			case (615) {
				sNotation = 'vertical-turn';
			}
		}
		if (Length(sNotation) > 0) {
			sNotation = '<' & sNotation & ' ' & sPosition & sColor & '/>';
		}
	}
	case ('notations') {
		switch (SymbolIndex) {
			case (220) {
				sNotation = 'fermata';
				sAttrib = ' type=\'upright\'';
				sContent = 'square';
			}
			case (221) {
				sNotation = 'fermata';
				sAttrib = ' type=\'upright\'';
				sContent = 'normal';
			}
			case (222) {
				sNotation = 'fermata';
				sAttrib = ' type=\'upright\'';
				sContent = 'angled';
			}
			case (236) {
				sNotation = 'fermata';
				sAttrib = ' type=\'inverted\'';
				sContent = 'square';
			}
			case (237) {
				sNotation = 'fermata';
				sAttrib = ' type=\'inverted\'';
				sContent = 'normal';
			}
			case (238) {
				sNotation = 'fermata';
				sAttrib = ' type=\'inverted\'';
				sContent = 'angled';
			}
			case (256) {
				sNotation = 'accidental-mark';
				sContent = 'flat-flat';
			}
			case (257) {
				sNotation = 'accidental-mark';
				sContent = 'three-quarters-flat';
			}
			case (258) {
				sNotation = 'accidental-mark';
				sContent = 'flat';
			}
			case (259) {
				sNotation = 'accidental-mark';
				sContent = 'quarter-flat';
			}
			case (260) {
				sNotation = 'accidental-mark';
				sContent = 'natural';
			}
			case (261) {
				sNotation = 'accidental-mark';
				sContent = 'quarter-sharp';
			}
			case (262) {
				sNotation = 'accidental-mark';
				sContent = 'sharp';
			}
			case (263) {
				sNotation = 'accidental-mark';
				sContent = 'three-quarters-sharp';
			}
			case (264) {
				sNotation = 'accidental-mark';
				sContent = 'double-sharp';
			}
			case (265) {
				sNotation = 'accidental-mark';
				sContent = 'natural-flat';
			}
			case (266) {
				sNotation = 'accidental-mark';
				sContent = 'natural-sharp';
			}
			case (267) {
				sNotation = 'accidental-mark';
				sContent = 'quarter-flat';
				sSmufl = 'accidentalQuarterToneFlatFilledReversed';
			}
			case (268) {
				sNotation = 'accidental-mark';
				sContent = 'flat-up';
			}
			case (269) {
				sNotation = 'accidental-mark';
				sContent = 'natural-up';
			}
			case (270) {
				sNotation = 'accidental-mark';
				sContent = 'sharp-up';
			}
			case (271) {
				sNotation = 'accidental-mark';
				sContent = 'quarter-sharp';
				sSmufl = 'accidentalQuarterToneSharp4';
			}
			case (272) {
				sNotation = 'accidental-mark';
				sContent = 'flat-flat';
				fParen = True;
			}
			case (273) {
				sNotation = 'accidental-mark';
				sContent = 'three-quarters-flat';
				fParen = True;
			}
			case (274) {
				sNotation = 'accidental-mark';
				sContent = 'flat';
				fParen = True;
			}
			case (275) {
				sNotation = 'accidental-mark';
				sContent = 'quarter-flat';
				fParen = True;
			}
			case (276) {
				sNotation = 'accidental-mark';
				sContent = 'natural';
				fParen = True;
			}
			case (277) {
				sNotation = 'accidental-mark';
				sContent = 'quarter-sharp';
				fParen = True;
			}
			case (278) {
				sNotation = 'accidental-mark';
				sContent = 'sharp';
				fParen = True;
			}
			case (279) {
				sNotation = 'accidental-mark';
				sContent = 'three-quarters-sharp';
				fParen = True;
			}
			case (280) {
				sNotation = 'accidental-mark';
				sContent = 'double-sharp';
				fParen = True;
			}
			case (281) {
				sNotation = 'accidental-mark';
				sContent = 'natural-flat';
				fParen = True;
			}
			case (282) {
				sNotation = 'accidental-mark';
				sContent = 'natural-sharp';
				fParen = True;
			}
			case (283) {
				sNotation = 'accidental-mark';
				sContent = 'three-quarters-flat';
			}
			case (284) {
				sNotation = 'accidental-mark';
				sContent = 'flat-down';
			}
			case (285) {
				sNotation = 'accidental-mark';
				sContent = 'natural-down';
			}
			case (286) {
				sNotation = 'accidental-mark';
				sContent = 'sharp-down';
			}
			case (287) {
				sNotation = 'accidental-mark';
				sContent = 'quarter-flat';
				sSmufl = 'accidentalQuarterToneFlat4';
			}
			case (295) {
				fLv = True;
				sOrientation = 'over';
				// If we have a chord we may mismatch under / over
				// symbols, so do not try to export orientation then.
				if (SymbolPrecedesNote) {
					if (TiedStopCount = 0) {
						sNotation = 'tied';
						sAttrib = ' type=\'stop\'';
						if (not IsChord) {
							sAttrib = sAttrib & ' orientation=\'over\'';
						}
						sPosition = '';
						TiedStopCount = 1;
					}
				} else {
					if (TiedStartCount = 0) {
						sNotation = 'tied';
						sAttrib = ' type=\'let-ring\'';
						if (not IsChord) {
							sAttrib = sAttrib & ' orientation=\'over\'';
						}
						sPosition = '';
						TiedStartCount = 1;
					}
				}
			}
			case (311) {
				fLv = True;
				sOrientation = 'under';
				// If we have a chord we may mismatch under / over
				// symbols, so do not try to export orientation then.
				if (SymbolPrecedesNote) {
					if (TiedStopCount = 0) {
						sNotation = 'tied';
						sAttrib = ' type=\'stop\'';
						if (not IsChord) {
							sAttrib = sAttrib & ' orientation=\'under\'';
						}
						sPosition = '';
						TiedStopCount = 1;
					}
				} else {
					if (TiedStartCount = 0) {
						sNotation = 'tied';
						sAttrib = ' type=\'let-ring\'';
						if (not IsChord) {
							sAttrib = sAttrib & ' orientation=\'under\'';
						}
						sPosition = '';
						TiedStartCount = 1;
					}
				}
			}
			case (752) {
				sNotation = 'accidental-mark';
				sContent = 'quarter-sharp';
				sSmufl = 'accidentalQuarterToneSharpBusotti';
			}
			case (753) {
				sNotation = 'accidental-mark';
				sContent = 'three-quarters-sharp';
				sSmufl = 'accidentalSharpOneHorizontalStroke';
			}
			case (754) {
				sNotation = 'accidental-mark';
				sContent = 'three-quarters-sharp';
				sSmufl = 'accidentalThreeQuarterTonesSharpBusotti';
			}
			case (755) {
				sNotation = 'accidental-mark';
				sContent = 'quarter-sharp';
				sSmufl = 'accidentalQuarterToneSharpWiggle';
			}
			case (756) {
				sNotation = 'accidental-mark';
				sContent = 'quarter-flat';
				sSmufl = 'accidentalQuarterToneFlatPenderecki';
			}
			case (757) {
				sNotation = 'accidental-mark';
				sContent = 'other';
				sSmufl = 'accidentalFlatTurned';
			}
			case (758) {
				sNotation = 'accidental-mark';
				sContent = 'other';
				sSmufl = 'accidentalDoubleFlatTurned';
			}
		}
		if (Length(sSmufl) > 0) {
			sSmufl = ' smufl=\'' & sSmufl & '\'';
		}
		if (Length(sNotation) > 0) {
			if (Length(sContent) > 0) {
				sNotation = '<' & sNotation & sAttrib & ' ' & sPosition & sSmufl & 
							sColor & '>' & sContent & '</' & sNotation & '>';
			} else {
				sNotation = '<' & sNotation & sAttrib & ' ' & sPosition & sSmufl &
							sColor & '/>';
			}
		}
		nXmlIndent = 5;
	}
}

if (Length(sNotation) > 0) {
	// Parentheses are at the notations level, vs. the individual notation.
	// With our current logic we cannot export them, so at least log them.
	if (fParen) {
		LogError('Unexported parentheses around following notation', nXmlIndent);
	}
	WriteXML(sNotation, nXmlIndent);
	if (Length(sArrow) > 0) {
		WriteXML('<arrow-direction>' & sArrow & '</arrow-direction>', nXmlIndent + 1);
		if (Length(sArrowStyle) > 0) {
			WriteXML('<arrow-style>' & sArrowStyle & '</arrow-style>', nXmlIndent + 1);
		}
		if (fArrowhead) {
			WriteXML('<arrowhead/>', nXmlIndent + 1);
		}
		WriteXML('</arrow>', nXmlIndent);
	} else {
		if (Length(sHoleClosed) > 0) {
			WriteXML('<hole-closed>' & sHoleClosed & '</hole-closed>', nXmlIndent + 1);
			WriteXML('</hole>', nXmlIndent);
		} else {
			if (Length(sHarmonClosed) > 0) {
				if (Length(sHarmonHalfLocation) > 0) {
					WriteXML('<harmon-closed location=\'' & sHarmonHalfLocation & '\'>' &
							 sHarmonClosed & '</harmon-closed>', nXmlIndent + 1);
				} else {
					WriteXML('<harmon-closed>' & sHarmonClosed & '</harmon-closed>',
							 nXmlIndent + 1);
				}
				WriteXML('</harmon-mute>', nXmlIndent);
			}
		}
	}			
	// Reset so we do not write it out again
	SymbolIndices[SymbolArrayIndex] = -1;
} else {
	// If we have an l.v. symbol that we do not write because the
	// tie count is full, we might be able to write it out later on 
	// another note in the chord.
	if (not fLv) {
		LogSymbolError(SymbolIndex, nXmlIndent);
		// Reset so we do not write it out again
		SymbolIndices[SymbolArrayIndex] = -1;
	} else {
		if (LastNote) {
			LogError('Tied already present, cannot export l.v. ' & sOrientation, nXmlIndent);
			// Reset so we do not write it out again
			SymbolIndices[SymbolArrayIndex] = -1;
		}
	}
}
}"
	GetPosition "(Dx, Dy, UseDefaultX) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return a position string using default-y and relative-x
// based on the Dx and Dy values of a bar object. Use default-x
// instead of relative-x if UseDefaultX is True. Use individual
// Dx and Dy values as attributes in case we have to save
// them away separately, as is the case for symbols.

// Dx and Dy are in 1/32 of staff space. Dy is measured from
// middle line, whereas it is top line in MusicXML.
nDefaultY = Round(Dy / 3.2) - 20;

// If we have tab or percussion clefs, compute based on number
// of staff lines and (for tab) default 150% staff size. The
// Dy value in this case is measured from the middle of the staff.
if (TabClef = 0) {
	nDefaultY = Round((Dy / 3.2) - ((TabStrings - 1) * 7.5));
} else {
	if (PercussionClef = 0) {
		nDefaultY = Round((Dy / 3.2) - ((PercStaffLines - 1) * 5));
	}
}

nX = Round(Dx / 3.2);
sPosition = 'default-y=\'' & nDefaultY & '\'';
if (UseDefaultX) {
	sPosition = sPosition & ' default-x=\'' & nX & '\'';
} else {
	if (nX != 0) {
		sPosition = sPosition & ' relative-x=\'' & nX & '\'';
	}
}
return sPosition;
}"
	FiguredBassAccidental "(FiguredBassChar) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

nChar = 0 + FiguredBassChar;
sAccidental = '';
switch (nChar) {
		case (33) {
			sAccidental = 'flat';
		}
		case (35) {
			sAccidental = 'sharp';
		}
		case (37) {
			sAccidental = 'flat-flat';
		}
		case (63) {
			sAccidental = 'double-sharp';
		}
		case (167) {
			sAccidental = 'natural';
		}
}

return sAccidental;
}"
	WriteFiguredBassText "(BarObject) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

sPosition = GetPosition(BarObject.Dx, BarObject.Dy, False);
sColor = GetColor(BarObject);
// If offset if non-zero, we will write as a direction vs. figured bass
nOffset = (BarObject.Position * 3) - MeasureCounter;
if (nOffset != 0) {
	return False;
}

nFigureCount = 0;
oFigureChar = CreateSparseArray();
oPrefix = CreateSparseArray();
oFigureNumber = CreateSparseArray();
oSuffix = CreateSparseArray();
oLevelType = CreateSparseArray();
fFiguresOK = True;

oFiguredBassText = BarObject.TextWithFormatting;
for i = 0 to oFiguredBassText.NumChildren {
	sFigureText = '' & oFiguredBassText[i];
	oPrefix[nFigureCount] = '';
	oSuffix[nFigureCount] = '';
	if (Length(sFigureText) = 1) {
		oFigureChar[nFigureCount] = Asc(CharAt(sFigureText, 0));
		nFigureCount = nFigureCount + 1;
	} else {
		if (Length(sFigureText) = 2) {
			nChar1 = Asc(CharAt(sFigureText, 0));
			nChar2 = Asc(CharAt(sFigureText, 1));
			sAcci1 = FiguredBassAccidental(nChar1);
			sAcci2 = FiguredBassAccidental(nChar2);
			if ((Length(sAcci1) > 0) and (Length(sAcci2) > 0)) {
				fFiguresOK = False;
			} else {
				if (Length(sAcci1) > 0) {
					oFigureChar[nFigureCount] = nChar2;
					oPrefix[nFigureCount] = sAcci1;
					nFigureCount = nFigureCount + 1; 
				} else {
					if (Length(sAcci2) > 0) {
						oFigureChar[nFigureCount] = nChar1;
						oSuffix[nFigureCount] = sAcci2;
						nFigureCount = nFigureCount + 1;
					} else {
						fFiguresOK = False;
					} 
				}				
			}
		} else {
			if (not ((sFigureText = '\\N\\') or (sFigureText = '\\n\\'))) {
				fFiguresOK = False;
			}
		}
	}
}

if ((not fFiguresOK) or (nFigureCount = 0)) {
	return False;
}

// Now parse each single-character figure bass font character
// into MusicXML semantics. We need to be sure we can parse
// everything before writing out as figured bass. Otherwise
// we will return without writing and let the caller write
// it as text.

for i = 0 to nFigureCount {
	oFigureNumber[i] = '';
	oLevelType[i] = '';
	fAlreadyHasPrefix = False;
	fAlreadyHasSuffix = False;
	if (Length(oPrefix[i]) > 0) {
		fAlreadyHasPrefix = True;
	}
	if (Length(oSuffix[i]) > 0) {
		fAlreadyHasSuffix = True;
	}
	switch (oFigureChar[i]) {
		case (33) {
			oPrefix[i] = 'flat';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (35) {
			oPrefix[i] = 'sharp';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (36) {
			oFigureNumber[i] = '6';
			oLevelType = 'parentheses';
		}
		case (37) {
			oPrefix[i] = 'flat-flat';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (38) {
			oFigureNumber[i] = '7';
			oSuffix[i] = 'back-slash';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (44) {
			oFigureNumber[i] = '6';
			oSuffix[i] = 'plus';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (48) {
			oFigureNumber[i] = '0';
		}
		case (49) {
			oFigureNumber[i] = '1';
		}
		case (50) {
			oFigureNumber[i] = '2';
		}
		case (51) {
			oFigureNumber[i] = '3';
		}
		case (52) {
			oFigureNumber[i] = '4';
		}
		case (53) {
			oFigureNumber[i] = '5';
		}
		case (54) {
			oFigureNumber[i] = '6';
		}
		case (55) {
			oFigureNumber[i] = '7';
		}
		case (56) {
			oFigureNumber[i] = '8';
		}
		case (57) {
			oFigureNumber[i] = '9';
		}
		case (58) {
			oPrefix[i] = 'flat';
			oFigureNumber[i] = '9';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (59) {
			oFigureNumber[i] = '7';
			oLevelType[i] = 'bracket';
		}
		case (60) {
			oFigureNumber[i] = '7';
			oSuffix[i] = 'plus';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (61) {
			oFigureNumber[i] = '8';
			oLevelType[i] = 'parentheses';
		}
		case (62) {
			oPrefix[i] = 'plus';
			oFigureNumber[i] = '7';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (63) {
			oPrefix[i] = 'double-sharp';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (65) {
			oFigureNumber[i] = '4';
			oLevelType[i] = 'parentheses';
		}
		case (66) {
			oPrefix[i] = 'flat';
			oFigureNumber[i] = '5';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (67) {
			oPrefix[i] = 'flat';
			oFigureNumber[i] = '3';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (68) {
			oPrefix[i] = 'sharp';
			oFigureNumber[i] = '3';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (69) {
			oPrefix[i] = 'natural';
			oFigureNumber[i] = '3';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (70) {
			oPrefix[i] = 'sharp';
			oFigureNumber[i] = '4';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (71) {
			oPrefix[i] = 'sharp';
			oFigureNumber[i] = '5';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (72) {
			oPrefix[i] = 'sharp';
			oFigureNumber[i] = '6';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (73) {
			oFigureNumber[i] = '4';
			oLevelType[i] = 'bracket';
		}
		case (74) {
			oPrefix[i] = 'sharp';
			oFigureNumber[i] = '7';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (75) {
			oFigureNumber[i] = '4';
			oSuffix[i] = 'plus';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (76) {
			oPrefix[i] = 'sharp';
			oFigureNumber[i] = '9';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (77) {
			oPrefix[i] = 'flat';
			oFigureNumber[i] = '7';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (78) {
			oPrefix[i] = 'flat';
			oFigureNumber[i] = '6';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (79) {
			oPrefix[i] = 'natural';
			oFigureNumber[i] = '9';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (80) {
			oFigureNumber[i] = '5';
			oLevelType[i] = 'parentheses';
		}
		case (81) {
			oFigureNumber[i] = '5';
			oLevelType[i] = 'bracket';
		}
		case (82) {
			oPrefix[i] = 'natural';
			oFigureNumber[i] = '4';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (83) {
			oPrefix[i] = 'sharp';
			oFigureNumber[i] = '2';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (84) {
			oPrefix[i] = 'natural';
			oFigureNumber[i] = '5';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (85) {
			oPrefix[i] = 'natural';
			oFigureNumber[i] = '7';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (86) {
			oPrefix[i] = 'flat';
			oFigureNumber[i] = '4';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (87) {
			oPrefix[i] = 'natural';
			oFigureNumber[i] = '2';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (88) {
			oPrefix[i] = 'flat';
			oFigureNumber[i] = '2';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (89) {
			oPrefix[i] = 'natural';
			oFigureNumber[i] = '6';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (90) {
			oFigureNumber[i] = '5';
			oSuffix[i] = 'plus';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (97) {
			oFigureNumber[i] = '2';
			oLevelType[i] = 'parentheses';
		}
		case (98) {
			oFigureNumber[i] = '5';
			oSuffix[i] = 'flat';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (99) {
			oFigureNumber[i] = '3';
			oSuffix[i] = 'flat';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (100) {
			oFigureNumber[i] = '3';
			oSuffix[i] = 'sharp';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (101) {
			oFigureNumber[i] = '3';
			oSuffix[i] = 'natural';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (102) {
			oFigureNumber[i] = '4';
			oSuffix[i] = 'sharp';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (103) {
			oFigureNumber[i] = '5';
			oSuffix[i] = 'sharp';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (104) {
			oFigureNumber[i] = '6';
			oSuffix[i] = 'sharp';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (105) {
			oFigureNumber[i] = '2';
			oLevelType[i] = 'bracket';
		}
		case (106) {
			oFigureNumber[i] = '7';
			oSuffix[i] = 'sharp';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (107) {
			oFigureNumber[i] = '2';
			oSuffix[i] = 'plus';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (108) {
			oFigureNumber[i] = '9';
			oSuffix[i] = 'sharp';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (109) {
			oFigureNumber[i] = '7';
			oSuffix[i] = 'flat';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (110) {
			oFigureNumber[i] = '6';
			oSuffix[i] = 'flat';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (111) {
			oFigureNumber[i] = '9';
			oSuffix[i] = 'natural';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (112) {
			oFigureNumber[i] = '3';
			oLevelType[i] = 'parentheses';
		}
		case (113) {
			oFigureNumber[i] = '3';
			oLevelType[i] = 'bracket';
		}
		case (114) {
			oFigureNumber[i] = '4';
			oSuffix[i] = 'natural';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (115) {
			oFigureNumber[i] = '2';
			oSuffix[i] = 'sharp';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (116) {
			oFigureNumber[i] = '5';
			oSuffix[i] = 'natural';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (117) {
			oFigureNumber[i] = '7';
			oSuffix[i] = 'natural';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (118) {
			oFigureNumber[i] = '4';
			oSuffix[i] = 'flat';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (119) {
			oFigureNumber[i] = '2';
			oSuffix[i] = 'natural';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (120) {
			oFigureNumber[i] = '2';
			oSuffix[i] = 'flat';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (121) {
			oFigureNumber[i] = '6';
			oSuffix[i] = 'natural';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (122) {
			oFigureNumber[i] = '3';
			oSuffix[i] = 'plus';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (123) {
			oFigureNumber[i] = '9';
			oLevelType[i] = 'bracket';
		}
		case (125) {
			oFigureNumber[i] = '9';
			oSuffix[i] = 'plus';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (167) {
			oPrefix[i] = 'natural';
			if (fAlreadyHasPrefix) {
				fFiguresOK = False;
			}
		}
		case (168) {
			oFigureNumber[i] = '6';
			oLevelType[i] = 'bracket';
		}
		case (169) {
			oFigureNumber[i] = '2';
			oSuffix[i] = 'vertical';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (180) {
			oFigureNumber[i] = '6';
			oSuffix[i] = 'back-slash';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (192) {
			oFigureNumber[i] = '9';
			oLevelType[i] = 'parentheses';
		}
		case (194) {
			oFigureNumber[i] = '7';
			oLevelType[i] = 'parentheses';
		}
		case (196) {
			oFigureNumber[i] = '4';
			oSuffix[i] = 'vertical';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (203) {
			oFigureNumber[i] = '5';
			oSuffix[i] = 'vertical';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (207) {
			oFigureNumber[i] = '5';
			oSuffix[i] = 'back-slash';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (214) {
			oFigureNumber[i] = '8';
			oLevelType[i] = 'bracket';
		}
		case (228) {
			oFigureNumber[i] = '7';
			oSuffix[i] = 'vertical';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (235) {
			oFigureNumber[i] = '9';
			oSuffix[i] = 'flat';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (239) {
			oFigureNumber[i] = '5';
			oSuffix[i] = 'back-slash';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		case (246) {
			oFigureNumber[i] = '9';
			oSuffix[i] = 'back-slash';
			if (fAlreadyHasSuffix) {
				fFiguresOK = False;
			}
		}
		default {
			fFiguresOK = False;
		}
	}
}

if (not fFiguresOK) {
	return False;
}

WriteXML('<figured-bass ' & sPosition & sColor & '>', 3);
for i = 0 to nFigureCount {
	WriteXML('<figure>', 4);
	if (Length(oPrefix[i]) > 0) {
		WriteXML('<prefix>' & oPrefix[i] & '</prefix>', 5);
	}
	if (Length(oFigureNumber[i]) > 0) {
		WriteXML('<figure-number>' & oFigureNumber[i] & '</figure-number>', 5);
	}
	if (Length(oSuffix[i]) > 0) {
		WriteXML('<suffix>' & oSuffix[i] & '</suffix>', 5);
	}
	if (Length(oLevelType[i]) > 0) {
		WriteXML('<level ' & oLevelType[i] & '=\'yes\'/>', 5);
	}
	WriteXML('</figure>', 4);
}
WriteXML('</figured-bass>', 3);

return True;
}"
	WriteChordSymbolText "(BarObject, StaffNumber, ChordText, ShowFrame) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get the position based on object Dx and Dy properties.
// If showing the frame, only use Dx for harmony and save
// Dy for the frame object itself, as it refers to the
// bottom of the frame.
sPosition = '';
if (ShowFrame) {
	sPosition = GetXPosition(BarObject.Dx, False);
} else {
	sPosition = GetPosition(BarObject.Dx, BarObject.Dy, False);
}
sColor = GetColor(BarObject);
nOffset = (BarObject.Position * 3) - MeasureCounter;

// Now try to parse the chord symbol
sRootStep = '';
nRootAlter = 0;
sBassStep = '';
nBassAlter = 0;
sKind = '';
sParseText = '';
sDirectionText = '';
fHarmonyFailed = False;
fParenDegrees = False;
fParenChord = False;
fSymbols = False;
KindText = '';
EmptyKindText = False;
StackDegrees = False;
DegreeCount = 0;
DegreesToPrint = 0;

// First, substitute any of the Sibelius chord font
// characters that can be translated directly into
// text: e.g. things like sus and ma, not things like
// the modified chord degree symbols. We want to do
// this whether or not we can parse the chord symbol.
sDirectionText = NormalizeChordFontText(ChordText);

// Now get rid of all spaces - regular, non breaking, tab, newlines
sChordText = RemoveSpaces(sDirectionText, 0);
if (Length(sChordText) = 0) {
	return 0;
}

// See if it is all parenthesized. Brackets are big parens in chord fonts,
// so bracket-degrees is not an option here. Mismatched parens will fail
// the parse and output as text. Parentheses do not start at the beginning
// of the string if just degrees are parenthesized, so do not test the
// match if the string ends with a right paren.
if (CharAt(sChordText, 0) = '(') {
	if (CharAt(sChordText, Length(sChordText) - 1) = ')') {
		fParenChord = True;
		sChordText = Substring(sChordText, 1, Length(sChordText) - 2);
	} else {
		fHarmonyFailed = True;
	}
}	

// Now look for the root.
// @todo Handle international roots such as Do and H.
cRootChar = CharAt(sChordText, 0);
if ((cRootChar >= 'A') and (cRootChar <= 'G')) {
	sRootStep = Substring(sChordText, 0, 1);
	if (Length(sChordText) > 1) {
		sRootAlter = Substring(sChordText, 1, 1);
		// Handle alternate accidentals in Sibelius chord fonts
		if (sRootAlter = 'b') {
			nRootAlter = -1;
			sChordText = Substring(sChordText, 2);
		} else {
			if (sRootAlter = '#') {
				nRootAlter = 1;
				sChordText = Substring(sChordText, 2);
			} else {
				sChordText = Substring(sChordText, 1);
			}
		} 
	} else {
		sChordText = '';
	}
} else {
	fHarmonyFailed = True;
}

// Now look for the bass, if any. Watch out for 6/9 chords.
if (not fHarmonyFailed) {
	nBassChild = 1;	
	oBassStrings = SplitString(sChordText, '/', False);	
	if (oBassStrings.NumChildren > 1) {
		cBassChar = CharAt(oBassStrings[1], 0);
		// Check that we do not have a 6/9 chord causing
		// the first two divisions.
		if (cBassChar = '9') {
			nBassChild = 2;
		}
		if (oBassStrings.NumChildren = (nBassChild + 1)) {
			sChordText = '' & oBassStrings[0];
			if (nBassChild > 1) {
				sChordText = sChordText & '/' & oBassStrings[1];
			}
			sBassText = '' & oBassStrings[nBassChild];
			if (Length(sBassText) <= 2) {
				cBassChar = CharAt(sBassText, 0);
				if ((cBassChar >= 'A') and (cBassChar <= 'G')) {
					sBassStep = Substring(sBassText, 0, 1);
					if (Length(sBassText) = 2) {
						sBassAlter = Substring(sBassText, 1, 1);
						if (sBassAlter = 'b') {
							nBassAlter = -1;
						} else {
							if (sBassAlter = '#') {
								nBassAlter = 1;
							} else {
								fHarmonyFailed = True;
							}
						}
					}
				} else {
					fHarmonyFailed = True;
				}
			} else {
				fHarmonyFailed = True;
			}
		} else {
			if (oBassStrings.NumChildren > (nBassChild + 1)) {
				fHarmonyFailed = True;
			}
		}
	}
}

// We now have the chord text for kind and degrees,
// minus root, bass, or overall level elements, and
// minus whitespace. Now we need to normalize text,
// and then we can parse it.
if (not fHarmonyFailed) {	

	// Now lowercase the ASCII part of the string, unless
	// we need to preserve M vs. m for major-minor distinctions.
	fLowercaseAscii = OkToLowercaseAscii(sChordText);

	// Starting with lowercasing, make a distinction between
	// our normalized version for lookup and the original
	// version used later for kind text.
	sParseText = sChordText;
	if (fLowercaseAscii) {
		sParseText = ToAsciiLowercase(sChordText);
	}

	// See if there are any chord symbols in text by splitting.
	// If there is more than one child, then at least one symbol
	// is present somewhere in the string.
	oSplitSymbols = SplitString(sParseText, '^-+ºØ', False);
	if (oSplitSymbols.NumChildren > 1) {
		fSymbols = True;
	}

	// Now normalize by replacing different spellings for 
	// major, minor, aug, and dim with the chord symbol characters.
	// This substitution is just done at the start of the chord text.
	sParseText = NormalizeChordSymbol(sParseText);

	// Now strip the parens out of the chord symbol string.
	oSplitParens = SplitString(sParseText, '()[]', True);
	sParseText = JoinStrings(oSplitParens, '');

	// Store kind text and parenthesization. We do not use
	// kind text if we are using symbols.
	if (oSplitParens.NumChildren > 1) {
		fParenDegrees = True;
		if (not fSymbols) {
			oSplitInternalParen = SplitString(sChordText, '([', False);
			KindText = '' & oSplitInternalParen[0];
		}
	}

	// Now parse the kind and degrees, assuming no prior failure.
	// This will be primarily via lookup. To make the size of this
	// method manageable, separate into separate parsing routines,
	// communicating stack degrees and empty kind text via globals.	
	nParseLength = Length(sParseText);
	switch (nParseLength) {
		case (0) {
			sKind = 'major';
		}
		case (1) {
			sKind = ParseChordText1(sParseText, fSymbols);
		}
		case (2) {
			sKind = ParseChordText2(sParseText, fSymbols);
		}
		case (3) {
			sKind = ParseChordText3(sParseText, fSymbols);
		}
		case (4) {
			sKind = ParseChordText4(sParseText, fSymbols, fParenDegrees);
		}
		case (5) {
			sKind = ParseChordText5(sParseText, fSymbols, fParenDegrees);
		}
		case (6) {
			sKind = ParseChordText6(sParseText, fSymbols, fParenDegrees);
		}
		case (7) {
			sKind = ParseChordText7(sParseText, fSymbols);
		}
		case (8) {
			sKind = ParseChordText8(sParseText, fSymbols);
		}
		case (9) {
			sKind = ParseChordText9(sParseText, fSymbols);
		}
		case (10) {
			sKind = ParseChordText10(sParseText, fSymbols);
		}
		case (11) {
			sKind = ParseChordText11(sParseText, fSymbols);
		}
	}
	if (Length(sKind) = 0) {
		fHarmonyFailed = True;
	}
} 

// For debugging
ChordsTotal = ChordsTotal + 1;
fLogFailure = fHarmonyFailed;
if (fHarmonyFailed) {
	sSuccess = '*** Failed';
} else {
	sSuccess = 'Parsed';
	ChordsParsed = ChordsParsed + 1;
}

if (ShowTrace) {
	trace(sSuccess & ' chord text \'' & ChordText & '\', bar ' & BarObject.ParentBar.BarNumber & 
		  ', kind text = \'' & KindText & '\', parse text = \'' & sParseText & 
		  '\': kind = \'' & sKind & '\', paren chord = ' & fParenChord & 
		  ', dir text =\'' & sDirectionText & '\'');
}

// If we have an N.C. chord, hide the root and
// remove any surrounding parentheses.
fNoChord = False;
if (sKind = 'none') {
	fNoChord = True;
	oSplitNoChordParens = SplitString(sChordText, '()[]', True);
	sChordText = JoinStrings(oSplitNoChordParens, '');
}

// Look for an N.C. without a root and let that export
if (fHarmonyFailed) {
	oSplitHarmonyFailParens = SplitString(sChordText, '()[]', True);
	sChordTestText = JoinStrings(oSplitHarmonyFailParens, '');
	sNcTestText = ToAsciiLowercase(sChordTestText);
	if ((sNcTestText = 'n.c.') or (sNcTestText = 'nc')) {
		fHarmonyFailed = False;
		sKind = 'none';
		sChordText = sChordTestText;
		fNoChord = True;
		sRootStep = '' & 'C';	// Need something; arbitrary choice
		nRootAlter = 0;
	}
}

// If we can parse the chord, write it out as a harmony element.
// Otherwise, write it out as a words direction.
if (not fHarmonyFailed) {
	if (ShowFrame) {
		WriteXML('<harmony print-frame=\'yes\' ' & sPosition & sColor & '>', 3);
	} else {
		WriteXML('<harmony print-frame=\'no\' ' & sPosition & sColor & '>', 3);
	}
	WriteXML('<root>', 4);
	if (fNoChord) {
		// Hide the root if we have an N.C. chord. MusicXML requires
		// a root even for kind values of 'none'.
		WriteXML('<root-step text=\'\'>' & sRootStep & '</root-step>', 5);
		if (nRootAlter != 0) {
			WriteXML('<root-alter print-object=\'no\'>' & nRootAlter & '</root-alter>', 5);
		}
	} else {
		WriteXML('<root-step>' & sRootStep & '</root-step>', 5);
		if (nRootAlter != 0) {
			WriteXML('<root-alter>' & nRootAlter & '</root-alter>', 5);
		}
	}
	WriteXML('</root>', 4);
	sDegreesHow = '';
	if (fParenDegrees) {
		sDegreesHow = ' parentheses-degrees=\'yes\'';
	}
	if (StackDegrees) {
		sDegreesHow = sDegreesHow & ' stack-degrees=\'yes\'';
	}
	if (fSymbols) {
		WriteXML('<kind use-symbols=\'yes\'' & sDegreesHow & '>' & sKind & '</kind>', 4);
	} else {
		// If there are no degrees to print, then the whole chord text
		// is the kind text.
		if (DegreesToPrint = 0) {
			KindText = sChordText;
		}
		if (EmptyKindText) {
			KindText = '';
		}
		// We know the kind text if there are either parenthesized
		// degrees, if there are no degrees to print, or in special
		// cases where we have assigned the text.
		if (fParenDegrees or (DegreesToPrint = 0) or (Length(KindText) > 0) or EmptyKindText) {
			WriteXML('<kind text=\'' & KindText & '\'' & 
					 sDegreesHow & '>' & sKind & '</kind>', 4);
		} else {
			WriteXML('<kind' & sDegreesHow & '>' & sKind & '</kind>', 4);
		}
	}
	if (Length(sBassStep) > 0) {
		WriteXML('<bass>', 4);
		WriteXML('<bass-step>' & sBassStep & '</bass-step>', 5);
		if (nBassAlter != 0) {
			WriteXML('<bass-alter>' & nBassAlter & '</bass-alter>', 5);
		}
		WriteXML('</bass>', 4);
	}
	for di = 0 to DegreeCount {
		if (not (DegreePrints[di])) {			
			WriteXML('<degree print-object=\'no\'>', 4);
		} else {
			WriteXML('<degree>', 4);
		}
		// Add text attributes for degree type and value if present.
		// If we have one of these set, print both so we can distinguish
		// between 2 and add2, for example.
		sDegreeValueText = '';
		sDegreeTypeText = '';
		sDegreeSymbol = '';
		if (DegreePrints[di]) {
			sDegreeValueText = '' & DegreeValueTexts[di];
			sDegreeTypeText = '' & DegreeTypeTexts[di];
			sDegreeSymbol = '' & DegreeSymbols[di];
			if ((Length(sDegreeValueText) > 0) or (Length(sDegreeTypeText) > 0)) {
				sDegreeValueText = ' text=\'' & sDegreeValueText & '\'';
				sDegreeTypeText = ' text=\'' & sDegreeTypeText & '\'';
			}
			if (Length(sDegreeSymbol) > 0) {
				sDegreeSymbol = ' symbol=\'' & sDegreeSymbol & '\'';
			}
		}
		WriteXML('<degree-value' & sDegreeSymbol & sDegreeValueText & '>' & 
				 DegreeValues[di] & '</degree-value>', 5);
		WriteXML('<degree-alter>' & DegreeAlters[di] & '</degree-alter>', 5);
		WriteXML('<degree-type' & sDegreeTypeText & '>' & DegreeTypes[di] & '</degree-type>', 5);
		WriteXML('</degree>', 4);
	}

	// Sibelius 5.2 adds full support for reading guitar frame data.
	if (ShowFrame) {
		WriteFrame(BarObject);
	}
} else { 
	sPlacement = GetPlacement(BarObject.Dy);
	WriteXML('<direction' & sPlacement & '>', 3);
	WriteXML('<direction-type>', 4);
	sXmlSafeText = ToXmlText(sDirectionText);
	if (fLogFailure) {
		sLogError = 'Chord symbol saved as text (' & sXmlSafeText & ')';
		if (ShowFrame) {
			sLogError = 'Frame missing; chord symbol saved as text (' & sXmlSafeText & ')';
		}
		LogError(sLogError, 5);
	}
	WriteXML('<words ' & sPosition & sColor & '>' & 
	         sXmlSafeText & '</words>', 5);
	WriteXML('</direction-type>', 4);
	fParenChord = False;
}

// Write the offset and staff elements as needed for
// either the harmony or direction element.
if (nOffset != 0) {
	WriteXML('<offset>' & nOffset & '</offset>', 4);
}
if (fParenChord or BarObject.CueSize) {
	sLevelAttributes = '';
	if (fParenChord) {
		sLevelAttributes = sLevelAttributes & ' parentheses=\'yes\'';
	}
	if (BarObject.CueSize) {
		sLevelAttributes = sLevelAttributes & ' size=\'cue\'';
	}
	WriteXML('<level' & sLevelAttributes & '/>', 4);
}
if (StaffNumber > 0) {
	WriteXML('<staff>' & StaffNumber & '</staff>', 4);
}

// Now end the harmony or direction element
if (not fHarmonyFailed) {
	WriteXML('</harmony>', 3);
} else {
	WriteXML('</direction>', 3);
}
}"
	RegFullName
	RightEndingBar
	RightEndingType
	LeftEndingBar
	UnknownEnding
	ExportXML "() {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Export a single MusicXML file from the current score.

// For performance testing
Sibelius.ResetStopWatch(1);

// Turning redraw can make Sibelius unresponsive in multi-
// window situations. If it is set, you do not see the score
// refreshed if you go to another application and then back 
// to Sibelius. But it can speed things up quite a bit,
// so we set it starting in Dolet 6.
oMyScore = Sibelius.ActiveScore;
oMyScore.Redraw = False;
Sibelius.CreateTextFile(FileName);

// For debugging
// trace('Original program version = ' & oMyScore.OriginalProgramVersion);

// Set up work in progress box
ProgressMax = oMyScore.StaffCount * oMyScore.NthStaff(1).BarCount;
ProgressCurrent = 0;
UserContinue = True;
Sibelius.CreateProgressDialog(_ProgressTitle, 0, ProgressMax);

// Clear values from prior invocations of this plug-in
InitializeData(oMyScore);

// Initialize the system staff since it has title/composer/etc.
// information for the MusicXML header, along with credits.	
InitializeSystemStaff(oMyScore);
	
InitializeXML(oMyScore);
InitializeParts(oMyScore);
nStaff = 1;
nStaves = 0;
PartCounter = 0;
for each oStaff in oMyScore {
	if (oStaff.Type = 'Stave') {
		if (nStaves = 0) {
			PartCounter = PartCounter + 1;
			nStaves = WriteStaff(oMyScore, oStaff, nStaff, PartCounter);
			nStaff = nStaff + nStaves;
			nStaves = nStaves - 1;
		} else {
			nStaves = nStaves - 1;
		}
	}
	if (UserContinue = False) {
		FinalizeXML();
		oMyScore.Redraw = True;
		Sibelius.DestroyProgressDialog();
		return False;
	}
}
FinalizeXML();
oMyScore.Redraw = True;

// For debugging and performance testing
nSeconds = Sibelius.GetElapsedSeconds(1);
// !!! For debugging
if (ShowTrace) {
	trace('Elapsed seconds: ' & nSeconds);
}

Sibelius.DestroyProgressDialog();
return True;
}"
	SetXMLFileName "() {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Set the FileName global variable for the XML file name
// based on the currently active score.

oMyScore = Sibelius.ActiveScore;
// Sibelius 7 can have problems with batch processing.
if (oMyScore = null) {
	return False;
}

// Try to strip off the .sib file extension before adding .musicxml
sScoreFileName = oMyScore.FileName;

if (Length(sScoreFileName) > 4) {
	sBaseName = Substring(sScoreFileName, 0, Length(sScoreFileName) - 4);
	sExtension = Substring(sScoreFileName, Length(sScoreFileName) - 4, 4);
	if (sExtension = '.sib') {
		FileName = sBaseName & '.musicxml';
	} else {
		if (sExtension = '.SIB') {
			FileName = sBaseName & '.MUSICXML';
		} else {
			FileName = sScoreFileName & '.musicxml';
		}
	}
} else {
	FileName = sScoreFileName & '.musicxml';
}

return True;
}"
	SetXMLFileNameForPart "(PartNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Set the FileName global variable for the XML file name
// based on the currently active score.

oMyScore = Sibelius.ActiveScore;
// Sibelius 7 can have problems with batch processing.
if (oMyScore = null) {
	return False;
}

// Try to strip off the .sib file extension before adding part data
sScoreFileName = oMyScore.FileName;
sFileNameStart = '';
fUppercase = False;

if (Length(sScoreFileName) > 4) {
	sBaseName = Substring(sScoreFileName, 0, Length(sScoreFileName) - 4);
	sExtension = Substring(sScoreFileName, Length(sScoreFileName) - 4, 4);
	if (sExtension = '.sib') {
		sFileNameStart = sBaseName;
	} else {
		if (sExtension = '.SIB') {
			sFileNameStart = sBaseName;
			fUppercase = True;
		} else {
			sFileNameStart = sScoreFileName;
		}
	}
} else {
	sFileNameStart = sScoreFileName;
}

// Add the part number for uniqueness, then the first 25 characters of the
// name - truncating to avoid really long part names.
sFileName = sFileNameStart & _Hyphen & _Part & _Space & PartNumber & _Hyphen & _Space;
sPartName = oMyScore.PartName;
if (Length(sPartName) > 25) {
	sPartName = Substring(sPartName, 0, 25);
}
sFileName = sFileName & sPartName;
if (fUppercase) {
	sFileName = sFileName & '.MUSICXML';
} else {
	sFileName = sFileName & '.musicxml';
}
FileName = '' & sFileName;

return True;
}"
	GlissandoCounts
	WriteGlissandos "(ThisEntry, GlissandoStarts, GlissandoStops, GlissandoCrossStaffStops) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Write out the glissando starts, then the glissando stops,
// based on the input sparse arrays.
for i = 1 to 17 {
	sPosition = '';
	if (GlissandoStarts[i]) {
		// We cannot tell orientation: the slur style is only
		// a starting point, not the actual orientation.

		// Get line type from style ID. These are not
		// across all documents, but better than nothing.
		sGlissandoStyleId = '' & GlissandoStyleIds[i];
		sColor = '' & GlissandoColors[i];
		sLineType = '';
		sGlissText = '';
		switch (sGlissandoStyleId) {
			case ('line.staff.gliss.straight') {
				sLineType = 'solid';
				sGlissText = 'gliss.';
			}
			case ('line.staff.gliss.wavy') {
				sLineType = 'wavy';
			}
			case ('line.staff.port.straight') {
				sLineType = 'solid';
			}
		}
		if (Length(sLineType) > 0) {
			sLineType = ' line-type=\'' & sLineType & '\'';
		}
		// Do not export relative-x unless we know that the
		// glissando position matches the note position - we have
		// no offset element here.
		sPosition = ' ' & GetYPosition(GlissandoStartDy[i]);
		sGlissando = '<glissando type=\'start\' number=\'' & i & '\'' & 
					 sLineType & sPosition & sColor;
		if (Length(sGlissText) > 0) {
			sGlissando = sGlissando & '>' & sGlissText & '</glissando>';
		} else {
			sGlissando = sGlissando & '/>';
		}
		WriteXML(sGlissando, 5);
		// Reset the start bar so this does not get rewritten later.
		GlissandoStartBars[i] = 0;
	}

	sPosition = '';
	if (GlissandoStops[i]) {
		// Do not export default-y if the stop is cross-staff,
		// as the value will be from the other staff.
		if (not GlissandoCrossStaffStops[i]) {
			sPosition = ' ' & GetYPosition(GlissandoStopDy[i]);
		}
		WriteXML('<glissando type=\'stop\' number=\'' & i & '\'' & sPosition & '/>', 5);
		GlissandoStopBars[i] = 0;	// free this glissando for reuse
		GlissandoCounts = GlissandoCounts - 1;
	}
}
}"
	FormatMessage "(Message, ValueChar, NewValue) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Substitute NewValue in Message where ValueChar is.
// Do this by splitting the string with ValueChar, then
// filling in the blank portions with NewValue. Sometimes
// ValueChar will need to be doubled in the Message string for
// this to work.

// This only works if there is one argument in the Message.
// Otherwise NewValue will be inserted 0 or multiple times.

sMessage = '' & Message;
sNewValue = '' & NewValue;
oSplit = SplitString(sMessage, ValueChar, False);
for i = 0 to oSplit.NumChildren {
	if (Length(oSplit[i]) = 0) {
		oSplit[i] = sNewValue;
	}
}
sNewMessage = JoinStrings(oSplit, '');
return sNewMessage;
}"
	NormalizeChordFontText "(ChordString) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

sNewString = '';
nChordLength = Length(ChordString);
for i = 0 to nChordLength {
	sChordChar = '' & CharAt(ChordString, i);
	nChordChar = Asc(sChordChar);
	// Split into ASCII and non-ASCII switches
	if ((nChordChar >= 32) and (nChordChar <= 127)) {
		switch (sChordChar) {
			case ('%') {
				// 6/9 in Opus Chords, 69 in Opus Plain Chords	
				sNewString = sNewString & '69';
			}
			case ('&') {
				sNewString = sNewString & '+';
			}
			case ('\'') {
				sNewString = sNewString & 'add';
			}
			case (',') {
				sNewString = sNewString & 'ma';
			}
			case ('.') {
				sNewString = sNewString & 'mi';
			}
			case (':') {
				sNewString = sNewString & 'OMIT';
			}
			case (';') {
				sNewString = sNewString & 'omit';
			}
			case ('<') {
				sNewString = sNewString & 'MA';
			}
			case ('>') {
				sNewString = sNewString & 'MI';
			}
			case ('@') {
				sNewString = sNewString & 'ADD';
			}
			case ('[') {
				sNewString = sNewString & '(';
			}
			case (']') {
				sNewString = sNewString & ')';
			}
			default {
				sNewString = sNewString & sChordChar;
			}
		}
	} else {
		switch (sChordChar) {
			case ('¡') {
				sNewString = sNewString & 'alt.';
			}
			case ('¢') {
				sNewString = sNewString & 'ALT.';
			}
			case ('¤') {
				sNewString = sNewString & 'ALT.';
			}
			case ('¥') {
				sNewString = sNewString & 'MAJ';
			}
			case ('¦') {
				sNewString = sNewString & 'MIN';
			}
			case ('¨') {
				sNewString = sNewString & 'b';
			}
			case ('©') {
				sNewString = sNewString & '#';
			}
			case ('®') {
				sNewString = sNewString & 'MIN';
			}
			case ('¯') {
				sNewString = sNewString & 'MAJ';
			}
			case ('°') {
				sNewString = sNewString & 'º';
			}
			case ('±') {
				sNewString = sNewString & 'Ø';
			}
			case ('²') {
				sNewString = sNewString & '^';
			}
			case ('²') {
				sNewString = sNewString & '^';
			}
			case ('³') {
				sNewString = sNewString & 'M';
			}
			case ('´') {
				sNewString = sNewString & 'DIM';
			}
			case ('µ') {
				sNewString = sNewString & 'N.C.';
			}
			case ('¶') {
				sNewString = sNewString & 'DIM';
			}
			case ('·') {
				sNewString = sNewString & 'SUS';
			}
			case ('¸') {
				sNewString = sNewString & 'sus';
			}
			case ('¹') {
				sNewString = sNewString & '1';
			}
			case ('½') {
				sNewString = sNewString & 'alt.';
			}
			case ('¾') {
				sNewString = sNewString & 'MA';
			}
			case ('¿') {
				sNewString = sNewString & 'MI';
			}
			case ('õ') {
				sNewString = sNewString & 'AUG';
			}
			case ('ö') {
				sNewString = sNewString & 'AUG';
			}
			case ('Ù') {
				sNewString = sNewString & '2';
			}
			case ('Ú') {
				sNewString = sNewString & '3';
			}
			case ('Û') {
				sNewString = sNewString & '4';
			}
			case ('Ü') {
				sNewString = sNewString & '5';
			}
			case ('Ý') {
				sNewString = sNewString & '6';
			}
			case ('Þ') {
				sNewString = sNewString & '7';
			}
			case ('ß') {
				sNewString = sNewString & '9';
			}
			case ('æ') {
				sNewString = sNewString & 'aug';
			}
			case ('ç') {
				sNewString = sNewString & 'aug';
			}
			case ('Œ') {
				sNewString = sNewString & 'm';
			}
			case ('Š') {
				sNewString = sNewString & 'j';
			}
			case ('Ž') {
				sNewString = sNewString & 'M';
			}
			case ('ƒ') {
				sNewString = sNewString & 'a';
			}
			case ('ˆ') {
				sNewString = sNewString & 'd';
			}
			case ('–') {
				sNewString = sNewString & 'o';
			}
			case ('—') {
				sNewString = sNewString & 'o';
			}
			case ('‘') {
				sNewString = sNewString & 'n';
			}
			case ('’') {
				sNewString = sNewString & 'n';
			}
			case ('‚') {
				sNewString = sNewString & '/';
			}
			case ('“') {
				sNewString = sNewString & 'sus';
			}
			case ('”') {
				sNewString = sNewString & 't';
			}
			case ('„') {
				sNewString = sNewString & 'a';
			}
			case ('†') {
				sNewString = sNewString & 'i';
			}
			case ('‡') {
				sNewString = sNewString & 'd';
			}
			case ('•') {
				sNewString = sNewString & 't';
			}
			case ('…') {
				sNewString = sNewString & 'i';
			}
			case ('‰') {
				sNewString = sNewString & 'j';
			}
			case ('‹') {
				sNewString = sNewString & 'm';
			}
			case ('€') {
				sNewString = sNewString & '-';
			}
			
			// Handle stacked 6/9, 2/4, and 4/2 characters,
			// but not the other stacked degrees.
			case ('Ê') {
				sNewString = sNewString & '2/4';
			}
			case ('Ð') {
				sNewString = sNewString & '6/9';
			}
			case ('Ñ') {
				sNewString = sNewString & '4/2';
			}

			default {
				sNewString = sNewString & sChordChar;
			}
		}
	}
}
return sNewString;
}"
	ToAsciiLowercase "(ThisString) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Convert string to lowercase, but only for
// ASCII character range.

sNewString = '';
nLength = Length(ThisString);
for i = 0 to nLength {
	sChar = CharAt(ThisString, i);
	nChar = Asc(sChar);
	// 65 to 90 is the range of Asc('A') to Asc('Z')
	if ((nChar >= 65) and (nChar <= 90)) {
		// 97 to 122 is the range of Asc('a') to Asc('z')
		sNewString = sNewString & Chr(nChar + 32);
	} else {
		sNewString = sNewString & sChar;
	}	
}
return sNewString;
}"
	OkToLowercaseAscii "(ChordText) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

fLowercaseAscii = False;
nChordLength = Length(ChordText);
sChar1 = CharAt(ChordText, 0);
sChar2 = '';
sChar3 = '';
if (nChordLength > 1) {
	sChar2 = CharAt(ChordText, 1);
}
if (nChordLength > 2) {
	sChar3 = CharAt(ChordText, 2);
}

if ((sChar1 != 'M') and (sChar2 != 'M')) {
	fLowercaseAscii = True;
} else {
	if (sChar1 != 'M') {
		sChar1 = sChar2;
		sChar2 = sChar3;
		sChar3 = '';
		if (nChordLength > 3) {
			sChar3 = CharAt(ChordText, 3);
		}
	}
	if ((sChar2 = 'a') or (sChar2 = 'A')) {
		// Lowercase if we can disambiguate with 'ma' spelling,
		// but not if this could be 'add' or 'aug'.
		switch (sChar3) {
			case ('') {
				fLowercaseAscii = True;
			}
			case ('d') {
				fLowercaseAscii = False;
			}
			case ('D') {
				fLowercaseAscii = False;
			}
			case ('u') {
				fLowercaseAscii = False;
			}
			case ('U') {
				fLowercaseAscii = False;
			}
			default {
				fLowercaseAscii = True;
			}
		}
	} else {
		// Lowercase if we can disambiguate from 'mi' or 'mj' spelling
		if ((sChar2 = 'i') or (sChar2 = 'I') or (sChar2 = 'j') or (sChar2 = 'J')) {
			fLowercaseAscii = True;
		}
	}	
}
return fLowercaseAscii;
}"
	NormalizeChordSymbol "(ChordText) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Replace different major / minor / aug / dim spellings
// at start of chord text with the corresponding symbol.

nLength = Length(ChordText);
s1 = CharAt(ChordText, 0);
switch (s1) {
	case ('m') {
		if (nLength = 1) {
			return '-';
		}
		s2 = CharAt(ChordText, 1);
		if (s2 = 'a') {
			if (Substring(ChordText, 0, 5) = 'major') {
				return '^' & Substring(ChordText, 5);
			} else {
				if (Substring(ChordText, 0, 3) = 'maj') {
					return '^' & Substring(ChordText, 3);
				} else {
					s4 = Substring(ChordText, 0, 4);
					// A couple of cases where ma is not major!
					if ((s4 = 'madd') or (s4 = 'maug')) {
						return '-' & Substring(ChordText, 1);
					} else {
						return '^' & Substring(ChordText, 2);
					}
				}
			}
		} else {
			if (s2 = 'i') {
				if (Substring(ChordText, 0, 5) = 'minor') {
					return '-' & Substring(ChordText, 5);
				} else {
					if (Substring(ChordText, 0, 3) = 'min') {
						return '-' & Substring(ChordText, 3);
					} else {
						return  '-' & Substring(ChordText, 2);
					}
				}
			} else {
				if (s2 = 'j') {
					return '^' & Substring(ChordText, 2);
				} else {
					return '-' & Substring(ChordText, 1);
				}
			}
		}
	}
	case ('M') {
		return '^' & Substring(ChordText, 1);
	}
	case ('a') {
		if (Substring(ChordText, 0, 3) = 'aug') {
			return '+' & Substring(ChordText, 3);		
		} else {
			return ChordText;
		}
	}
	case ('d') {
		if (Substring(ChordText, 0, 3) = 'dim') {
			return 'º' & Substring(ChordText, 3);		
		} else {
			return ChordText;
		}
	}
	case ('²') {
		// Alternate major spelling
		return '^' & Substring(ChordText, 1);
	}
	default {
		return ChordText;
	}
}
}"
	DegreeCount
	AddDegree "(DegValue, DegType, DegAlter, DegPrint) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Add a degree value to the global arrays
// and increment the degree counter. Reset the
// texts for value and type; these can then
// be set via AddDegreeTexts afterwards.
DegreeValues[DegreeCount] = 0 + DegValue;
DegreeTypes[DegreeCount] = '' & DegType;
DegreeAlters[DegreeCount] = 0 + DegAlter;
DegreeValueTexts[DegreeCount] = '';
DegreeTypeTexts[DegreeCount] = '';

if (DegPrint) {
	DegreePrints[DegreeCount] = True;
	DegreesToPrint = DegreesToPrint + 1;
} else {
	DegreePrints[DegreeCount] = False;
}
DegreeCount = DegreeCount + 1;
}"
	DegreesToPrint
	ChordsTotal
	ChordsParsed
	ScoreInfoSubstitute "(BarObject, DisplayedPage) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// For our metadata elements, we cannot use full formatting as for
// credits and directions. But use similar logic to do score info
// substitutions and line breaks.

oSourceText = BarObject.TextWithFormatting;
fHidden = False;
sText = '';

for i = 0 to oSourceText.NumChildren {
	sFirstChar = '';
	sSecondChar = '';
	sLastChar = '';
	sSourceText = '' & oSourceText[i];
	
	if (not fHidden) {
		if (Length(sSourceText) > 0) {
			sFirstChar = '' & CharAt(sSourceText, 0);
			if (Length(sSourceText) > 1) {
				sSecondChar = '' & CharAt(sSourceText, 1);
				sLastChar = '' & CharAt(sSourceText, Length(sSourceText) - 1);
			}
		}
		if (sFirstChar = '\\' and sLastChar = '\\') {
			// All we handle here are new lines and wildcard substitutions.
			switch (sSecondChar) {
				case ('n') {
					// Add CR. Compose turns LF into a space, so use Mac/Unix endings.
					sText = sText & Chr(13);
				}
				case ('N') {
					// Add CR - used starting in Sibelius 7
					sText = sText & Chr(13);
				}
				case ('$') {
					if (Length(sSourceText) > 3) {
						sKeyword = Substring(sSourceText, 2, Length(sSourceText) - 3);
						sText = sText & GetWildcard(sKeyword, True, DisplayedPage);
					}
				}
			}
		} else {
			// Check for a tilde that starts an invisible section.
			// If present, complete the previous text before the
			// hidden section.
			if (sFirstChar = '~') {
				fHidden = True;
			}
	
			// We have text. Backslashes seem to always start a new
			// section, so we do not seem to need any further double-
			// backslash handling here.
			if (not fHidden) {
				sText = sText & sSourceText;
			}
		}
	}
}

return ToXmlText(sText);
}"
	CheckOctava "(ThisOctave, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return the octave number to output to MusicXML to 
// adjust for the presence of an octava line on this staff.
// Return the original octave number if no match found.

if (OctaveStops = 0) {
	return ThisOctave;
} else {
	for i = 1 to 17 {
		if ((OctaveStopBars[i] > 0) and (OctaveStopStaffs[i] = StaffNumber)) {
			return ThisOctave + OctaveAdds[i];
		}
	}
	// If no match found, return original octave
	return ThisOctave;
}
}"
	FingeringCount
	WriteFingering "(FingeringArrayIndex, StaffNumber, AsNotation, UseDx) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

sFingering = '';

// Get the position based on object Dx and Dy properties.
sPosition = '';
if (UseDx) {
	sPosition = GetPosition(FingeringDx[FingeringArrayIndex],
							FingeringDy[FingeringArrayIndex], True);
} else {
	sPosition = GetYPosition(FingeringDy[FingeringArrayIndex]);
}
sColor = '' & FingeringColor[FingeringArrayIndex];

if (Length(Fingerings[FingeringArrayIndex]) > 0) {
	if (AsNotation) {
		sFingering = '<fingering ' & sPosition & sColor & '>' & 
						Fingerings[FingeringArrayIndex] & '</fingering>';
		WriteXML(sFingering, 6);
	} else {
		nOffset = (FingeringPositions[FingeringArrayIndex] * 3) - MeasureCounter;
		WriteXML('<direction>', 3);
		WriteXML('<direction-type>', 4);
		WriteXML('<words ' & sPosition & sColor & '>' & 
					Fingerings[FingeringArrayIndex] & '</words>', 5);
		WriteXML('</direction-type>', 4);
		if (nOffset != 0) {
			WriteXML('<offset>' & nOffset & '</offset>', 4);
		}
		nVoice = FingeringVoices[FingeringArrayIndex];
		if (nVoice > 0) {
			WriteXML('<voice>' & nVoice & '</voice>', 4);
		}
		if (StaffNumber > 0) {
			WriteXML('<staff>' & StaffNumber & '</staff>', 4);
		}
		WriteXML('</direction>', 3);
	}
	FingeringWritten[FingeringArrayIndex] = True;
}
}"
	WriteBarRestNotations "() {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// We tried this for fermata symbols. But the position
// for symbols directly over a bar rest is not 0, but
// somewhere midway in the measure. Until we can do 
// something better about positioning, do not call this
// for now.

// In Sibelius 6, we can access fermatas from the BarRest
// object. This will be handled directly in WriteBarRest.
// Leave this stub routine here for the more general issue
// of writing out symbol notations for a time when we can
// handle positioning better.

// Group 3 different fermatas together here
fSymbolNotations = False;

// Allow some roundoff slack in this test
nSibMeasureCounter = 0 + SibMeasureCounter;
nSymbolTest1 = nSibMeasureCounter - 4;
nSymbolTest2 = nSibMeasureCounter + 4;

// Check for fermata symbols. Other notation symbols
// seem unlikely over a BarRest. Unfortunately, we
// cannot export fermatas when used as an articulation
// with a BarRest.

for si = 0 to SymbolCount {
	if ((SymbolPositions[si] >= nSymbolTest1) and
		(SymbolPositions[si] <= nSymbolTest2)) {		
		sSymbolParent = SymbolIndexParents[SymbolIndices[si]];
		switch (sSymbolParent) {
			case ('notations') {
				fSymbolNotations = True;
			}
		}
	}
}

if (fSymbolNotations) {
	WriteXML('<notations>', 4);
	for si = 0 to SymbolCount {
		if ((SymbolPositions[si] >= nSymbolTest1) and
			(SymbolPositions[si] <= nSymbolTest2)) {		
			if (SymbolIndexParents[SymbolIndices[si]] = 'notations') {
				WriteSymbolNotation(si);
			}
		}
	}
	WriteXML('</notations>', 4);
}
}"
	LocalizeData "() {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// For localization, look up application language.
// We can then change the global strings if the
// returned value is something other than 'English'.
// We currently support the languages included with
// Sibelius 5. Sibelius 2021.2 also has 'Russian',
// 'Brazilian Portuguese', and 'Simplified Chinese'.
// For those we stay with the English wordings.

switch (Sibelius.ApplicationLanguage) {
	case ('German') {
		_AboutCopyright = 'Copyright © 2003-2023 MakeMusic, Inc.';
		_AboutDolet = 'Dolet 8 für Sibelius';
		_AboutTitle = 'Über Dolet 8 für Sibelius';
		_AboutVersion = 'Version 8.3';
		_Cancel = 'Abbrechen';
		_Hyphen = ' -';
		_NoScore = 'Bitte öffnen Sie eine Partitur und versuchen es nochmals.';
		_OK = 'OK';
		_Overwrite = '& besteht bereits.
Möchten Sie sie ersetzen?';
		_Part = ' Stimme';
		_PluginMenuName = 'MusicXML Export';
		_Progress = 'Stimme &, Takt &';
		_ProgressTitle = 'MusicXML Export';
		_SibVersionTooEarly = 'Dieses Plug-In benötigt Sibelius 2019.5 oder neuer.';
		_Space = '' & ' ';
	}
	case ('French') {
		_AboutCopyright = 'Copyright © 2003-2023 MakeMusic, Inc.';
		_AboutDolet = 'Dolet 8 pour Sibelius';
		_AboutTitle = 'A propos de Dolet 8 pour Sibelius';
		_AboutVersion = 'Version 8.3';
		_Cancel = 'Annuler';
		_Hyphen = ' -';
		_NoScore = 'Veuillez ouvrir une partition à exporter et essayez à nouveau.';
		_OK = 'OK';
		_Overwrite = '& existe déjà.
Voulez-vous le remplacer ?';
		_Part = ' Partie';
		_PluginMenuName = 'Exporter MusicXML';
		_Progress = 'Partie &, mesure &';
		_ProgressTitle = 'Exporter MusicXML';
		_SibVersionTooEarly = 'Cette extension nécessite Sibelius 2019.5 ou une version plus récente.';
		_Space = '' & ' ';
	}
	case ('Italian') {
		_AboutCopyright = 'Copyright © 2003-2023 MakeMusic, Inc.';
		_AboutDolet = 'Dolet 8 per Sibelius';
		_AboutTitle = 'Info su Dolet 8 per Sibelius';
		_AboutVersion = 'Versione 8.3';
		_Cancel = 'Annulla';
		_Hyphen = ' -';
		_NoScore = 'Aprite uno spartito e riprovate.';
		_OK = 'OK';
		_Overwrite = '& esiste già.
Sostituirlo?';
		_Part = ' Parte';
		_PluginMenuName = 'Esportazione MusicXML';
		_Progress = 'Parte &, battuta &';
		_ProgressTitle = 'Esportazione MusicXML';
		_SibVersionTooEarly = 'Questo plug-in richiede Sibelius versione 2019.5 o più recente.';
		_Space = '' & ' ';
	}
	case ('Spanish') {
		_AboutCopyright = 'Copyright © 2003-2023 MakeMusic, Inc.';
		_AboutDolet = 'Dolet 8 para Sibelius';
		_AboutTitle = 'Acerca Dolet 8 para Sibelius';
		_AboutVersion = 'Versión 8.3';
		_Cancel = 'Cancelar';
		_Hyphen = ' -';
		_NoScore = 'Por favor, abra una partitura e inténtelo de nuevo.';
		_OK = 'Aceptar';
		_Overwrite = '& ya existe.
¿Desea reemplazarlo?';
		_Part = ' Parte';
		_PluginMenuName = 'Exportar MusicXML';
		_Progress = 'Parte &, compás &';
		_ProgressTitle = 'Exportar MusicXML';
		_SibVersionTooEarly = 'Este plug-in requiere Sibelius versión 2019.5 o superior.';
		_Space = '' & ' ';
	}
	case ('Japanese') {
		_AboutCopyright = 'Copyright © 2003-2023 MakeMusic, Inc。';
		_AboutDolet = 'Dolet 8 Sibelius';
		_AboutTitle = 'Dolet 8 Sibelius対応版';
		_AboutVersion = 'Version 8.3';
		_Cancel = 'キャンセル';
		_Hyphen = ' -';
		_NoScore = 'スコアを開いて、再び実行してください。';
		_OK = 'OK';
		_Overwrite = '& は既に存在します。
上書きしますか?';
		_Part = ' パート「';
		_PluginMenuName = 'MusicXMLへのエクスポート';
		_Progress = 'パート「&」の&';
		_ProgressTitle = 'MusicXMLへのエクスポートL';
		_SibVersionTooEarly = 'このプラグインは、Sibelius バージョン 2019.5 以降に対応します。';
		_Space = '' & ' ';
	}
	default {
		_AboutCopyright = 'Copyright © 2003-2023 MakeMusic, Inc.';
		_AboutDolet = 'Dolet 8 for Sibelius';
		_AboutTitle = 'About Dolet 8 for Sibelius';
		_AboutVersion = 'Version 8.3';
		_Cancel = 'Cancel';
		_Hyphen = ' -';
		_NoScore = 'Please open a score to export and try again.';
		_OK = 'OK';
		_Overwrite = '& already exists.
Do you want to replace it?';
		_Part = ' Part';
		_PluginMenuName = 'Export MusicXML';
		_Progress = 'Part &, bar &';
		_ProgressTitle = 'Export MusicXML';
		_SibVersionTooEarly = 'This plug-in requires Sibelius version 2019.5 or later.';
		_Space = '' & ' ';
	}
}
}"
	_AboutCopyright "Copyright © 2003-2023 MakeMusic, Inc."
	_AboutDolet "Dolet 8 for Sibelius"
	_AboutTitle "About Dolet 8 for Sibelius"
	_AboutVersion "Version 8.3"
	_Cancel "Cancel"
	_Hyphen " -"
	_NoScore "Please open a score to export and try again."
	_OK "OK"
	_Overwrite "& already exists.
Do you want to replace it?"
	_Part " Part"
	_PluginMenuName "Export MusicXML"
	_Progress "Part &, bar &"
	_ProgressTitle "Export MusicXML"
	_SibVersionTooEarly "This plug-in requires Sibelius version 2019.5 or later."
	_Space " "

	FormatMessage2 "(Message, ValueChar, NewValue1, NewValue2) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Substitute NewValue in Message where ValueChar is.
// Do this by splitting the string with ValueChar, then
// filling in the blank portions with NewValue. Sometimes
// ValueChar will need to be doubled in the Message string for
// this to work.

// This only works if there are two arguments in the Message.
// Otherwise NewValue2 will be inserted 0 or multiple times.

sMessage = '' & Message;
sNewValue1 = '' & NewValue1;
sNewValue2 = '' & NewValue2;
nSubstitute = 0;
oSplit = SplitString(sMessage, ValueChar, False);
for i = 0 to oSplit.NumChildren {
	if (i < (oSplit.NumChildren - 1)) {
		if (nSubstitute = 0) {
			oSplit[i] = oSplit[i] & sNewValue1;
		} else {
			oSplit[i] = oSplit[i] & sNewValue2;
		}
		nSubstitute = nSubstitute + 1;
	}
}
sNewMessage = JoinStrings(oSplit, '');
return sNewMessage;
}"
	SpaceCharInt
	ZeroCharInt
	PeriodCharInt
	LiveModeOn
	FirstVisibleStaffForFirstMeasure
	GetLiveMode "(ThisNote, ThisDuration) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Check live playback properties for this note and
// return a string that contains the MusicXML attributes
// to add to the note element.

sLive = '';
nDynamics = 0;
nAttack = 0;
nDuration = 0;
nRelease = 0;

if (ThisNote.UseOriginalVelocityForPlayback) {
	// MusicXML dynamics are relative to default of 90
	nDynamics = Round((100.0 * ThisNote.OriginalVelocity) / 90.0);
	sLive = sLive & ' dynamics=\'' & nDynamics & '\'';
}

if (ThisNote.UseOriginalDeltaSrForPlayback) {
	nAttack = ThisNote.OriginalDeltaSr * 3;
	if (nAttack != 0) {
		sLive = sLive & ' attack=\'' & nAttack & '\'';
	}
}

if (ThisNote.UseOriginalDurationForPlayback) {
	nDuration = ThisNote.OriginalDuration * 3;
	nRelease = (nAttack + nDuration) - ThisDuration;
	if (nRelease != 0) {
		sLive = sLive & ' release=\'' & nRelease & '\'';
	}
}

return sLive;
}"
	AddUnnumberedLyric "(LyricText, LyricType, LyricNumber, LyricNotes, LyricDx, LyricDy, LyricPosition, LyricHidden, LyricColor, Voice) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// If we have an unknown lyric, assign it to either the
// first unused verse, or the first verse that has the
// same (or close) Dy as this lyric. Return True if
// assignment is successful or False if not.

// These user styles are most common for verses 3 to 5
// since earlier versions of Sibelius did not
// always have built-in styles for these verses.

// The LyricNumber parameter comes from the StyleAsText
// option. It is used in order to try to provide a 
// better lyric number match for user-defined styles.

// Slack for lyric Dy comparison
nLyricSlack = 4;
nNumeric = 0;

for i = -1 to 5 {
	fMatch = False;
	fAddElision = False;
	fOnlyNewHidden = False;
	fOnlyOldHidden = False;
	if (VerseMax[Voice] <= i) {
		fMatch = True;
	}
	nWhich = i;
	// The lyric number parameter has a preferred number
	// to use. Use it the first time through the loop.
	// It will be 0 if unused, which will lead to a 
	// non-matching -1 value here.
	if (i = -1) {
		nWhich = -1 + LyricNumber;
	}
	switch (nWhich) {
		case (0) {
			if (fMatch or (Length(Verse1Text[Voice]) = 0)) {
				Verse1Text[Voice] = '' & LyricText;
				Verse1Type[Voice] = 0 + LyricType;
				Verse1Notes[Voice] = 0 + LyricNotes;
				Verse1Dx[Voice] = 0 + LyricDx;
				Verse1Dy[Voice] = 0 + LyricDy;
				Verse1Positions[Voice] = 0 + LyricPosition;
				Verse1Hidden[Voice] = LyricHidden;
				Verse1Color[Voice] = '' & LyricColor;
				VerseMax[Voice] = 1;
				return True;
			}
			nNumeric = Verse1Dy[Voice] - LyricDy;
			if (MathAbs(nNumeric) <= nLyricSlack) {
				fAddElision = True;
				// Handle a mix of hidden and visible in the same voice.
				// If the new lyric is hidden, ignore it. If the old lyric
				// is hidden, replace it with the new lyric instead of
				// eliding it, and turn the hidden array value off.
				if (LyricHidden and (not Verse1Hidden[Voice])) {
					fOnlyNewHidden = True;
				} else {
					if ((not LyricHidden) and Verse1Hidden[Voice]) {
						fOnlyOldHidden = True;
					}
				}
			}

			// If we have an elision, add the text. Check Dx values
			// to see if text should go before or after. Dx and Dy
			// values come from left-most text; type and notes values
			// come from right-most text.
			if (fAddElision) {
				// Ignore a hidden new syllable if the old one was visible.
				if (not fOnlyNewHidden) {
					if (fOnlyOldHidden) {
						// Replace the old hidden syllable rather than eliding.
						Verse1Text[Voice] = ToXmlText(LyricText);
						Verse1Hidden[Voice] = False;
						Verse1Dx[Voice] = 0 + LyricDx;
						Verse1Dy[Voice] = 0 + LyricDy;
						Verse1Positions[Voice] = 0 + LyricPosition;
					} else {
						Verse1Text[Voice] = Verse1Text[Voice] & HardSpace & LyricText;
						Verse1Type[Voice] = 0 + LyricType;
						Verse1Notes[Voice] = 0 + LyricNotes;
					}
				}
				return True;
			}
		}
		case (1) {
			if (fMatch or (Length(Verse2Text[Voice]) = 0)) {
				Verse2Text[Voice] = '' & LyricText;
				Verse2Type[Voice] = 0 + LyricType;
				Verse2Notes[Voice] = 0 + LyricNotes;
				Verse2Dx[Voice] = 0 + LyricDx;
				Verse2Dy[Voice] = 0 + LyricDy;
				Verse2Positions[Voice] = 0 + LyricPosition;
				Verse2Hidden[Voice] = LyricHidden;
				Verse2Color[Voice] = '' & LyricColor;
				VerseMax[Voice] = 2;
				return True;
			}

			// If we have an elision, add the text, use the new
			// type and extend, but leave the Dx and Dy alone.
			nNumeric = Verse2Dy[Voice] - LyricDy;
			if (MathAbs(nNumeric) <= nLyricSlack) {
				fAddElision = True;
				if (LyricHidden and (not Verse2Hidden[Voice])) {
					fOnlyNewHidden = True;
				} else {
					if ((not LyricHidden) and Verse2Hidden[Voice]) {
						fOnlyOldHidden = True;
					}
				}
			}
			if (fAddElision) {
				// Ignore a hidden new syllable if the old one was visible.
				if (not fOnlyNewHidden) {
					if (fOnlyOldHidden) {
						// Replace the old hidden syllable rather than eliding.
						Verse2Text[Voice] = ToXmlText(LyricText);
						Verse2Hidden[Voice] = False;
						Verse2Dx[Voice] = 0 + LyricDx;
						Verse2Dy[Voice] = 0 + LyricDy;
						Verse2Positions[Voice] = 0 + LyricPosition;
					} else {
						Verse2Text[Voice] = Verse2Text[Voice] & HardSpace & LyricText;
						Verse2Type[Voice] = 0 + LyricType;
						Verse2Notes[Voice] = 0 + LyricNotes;
					}
				}
				return True;
			}
		}
		case (2) {
			if (fMatch or (Length(Verse3Text[Voice]) = 0)) {
				Verse3Text[Voice] = '' & LyricText;
				Verse3Type[Voice] = 0 + LyricType;
				Verse3Notes[Voice] = 0 + LyricNotes;
				Verse3Dx[Voice] = 0 + LyricDx;
				Verse3Dy[Voice] = 0 + LyricDy;
				Verse3Positions[Voice] = 0 + LyricPosition;
				Verse3Hidden[Voice] = LyricHidden;
				Verse3Color[Voice] = '' & LyricColor;
				VerseMax[Voice] = 3;
				return True;
			}

			// If we have an elision, add the text, use the new
			// type and extend, but leave the Dx and Dy alone.
			nNumeric = Verse3Dy[Voice] - LyricDy;
			if (MathAbs(nNumeric) <= nLyricSlack) {
				fAddElision = True;
				if (LyricHidden and (not Verse3Hidden[Voice])) {
					fOnlyNewHidden = True;
				} else {
					if ((not LyricHidden) and Verse3Hidden[Voice]) {
						fOnlyOldHidden = True;
					}
				}
			}
			if (fAddElision) {
				// Ignore a hidden new syllable if the old one was visible.
				if (not fOnlyNewHidden) {
					if (fOnlyOldHidden) {
						// Replace the old hidden syllable rather than eliding.
						Verse3Text[Voice] = ToXmlText(LyricText);
						Verse3Hidden[Voice] = False;
						Verse3Dx[Voice] = 0 + LyricDx;
						Verse3Dy[Voice] = 0 + LyricDy;
						Verse3Positions[Voice] = 0 + LyricPosition;
					} else {
						Verse3Text[Voice] = Verse3Text[Voice] & HardSpace & LyricText;
						Verse3Type[Voice] = 0 + LyricType;
						Verse3Notes[Voice] = 0 + LyricNotes;
					}
				}
				return True;
			}
		}
		case (3) {
			if (fMatch or (Length(Verse4Text[Voice]) = 0)) {
				Verse4Text[Voice] = '' & LyricText;
				Verse4Type[Voice] = 0 + LyricType;
				Verse4Notes[Voice] = 0 + LyricNotes;
				Verse4Dx[Voice] = 0 + LyricDx;
				Verse4Dy[Voice] = 0 + LyricDy;
				Verse4Positions[Voice] = 0 + LyricPosition;
				Verse4Hidden[Voice] = LyricHidden;
				Verse4Color[Voice] = '' & LyricColor;
				VerseMax[Voice] = 4;
				return True;
			}

			// If we have an elision, add the text, use the new
			// type and extend, but leave the Dx and Dy alone.
			nNumeric = Verse4Dy[Voice] - LyricDy;
			if (MathAbs(nNumeric) <= nLyricSlack) {
				fAddElision = True;
				if (LyricHidden and (not Verse4Hidden[Voice])) {
					fOnlyNewHidden = True;
				} else {
					if ((not LyricHidden) and Verse4Hidden[Voice]) {
						fOnlyOldHidden = True;
					}
				}
			}
			if (fAddElision) {
				// Ignore a hidden new syllable if the old one was visible.
				if (not fOnlyNewHidden) {
					if (fOnlyOldHidden) {
						// Replace the old hidden syllable rather than eliding.
						Verse4Text[Voice] = ToXmlText(LyricText);
						Verse4Hidden[Voice] = False;
						Verse4Dx[Voice] = 0 + LyricDx;
						Verse4Dy[Voice] = 0 + LyricDy;
						Verse4Positions[Voice] = 0 + LyricPosition;
					} else {
						Verse4Text[Voice] = Verse4Text[Voice] & HardSpace & LyricText;
						Verse4Type[Voice] = 0 + LyricType;
						Verse4Notes[Voice] = 0 + LyricNotes;
					}
				}
				return True;
			}
		}
		case (4) {
			if (fMatch or (Length(Verse5Text[Voice]) = 0)) {
				Verse5Text[Voice] = '' & LyricText;
				Verse5Type[Voice] = 0 + LyricType;
				Verse5Notes[Voice] = 0 + LyricNotes;
				Verse5Dx[Voice] = 0 + LyricDx;
				Verse5Positions[Voice] = 0 + LyricPosition;
				Verse5Dy[Voice] = 0 + LyricDy;
				Verse5Hidden[Voice] = LyricHidden;
				Verse5Color[Voice] = '' & LyricColor;
				VerseMax[Voice] = 5;
				return True;
			}

			// If we have an elision, add the text, use the new
			// type and extend, but leave the Dx and Dy alone.
			nNumeric = Verse5Dy[Voice] - LyricDy;
			if (MathAbs(nNumeric) <= nLyricSlack) {
				fAddElision = True;
				if (LyricHidden and (not Verse5Hidden[Voice])) {
					fOnlyNewHidden = True;
				} else {
					if ((not LyricHidden) and Verse5Hidden[Voice]) {
						fOnlyOldHidden = True;
					}
				}
			}
			if (fAddElision) {
				// Ignore a hidden new syllable if the old one was visible.
				if (not fOnlyNewHidden) {
					if (fOnlyOldHidden) {
						// Replace the old hidden syllable rather than eliding.
						Verse5Text[Voice] = ToXmlText(LyricText);
						Verse5Hidden[Voice] = False;
						Verse5Dx[Voice] = 0 + LyricDx;
						Verse5Dy[Voice] = 0 + LyricDy;
						Verse5Positions[Voice] = 0 + LyricPosition;
					} else {
						Verse5Text[Voice] = Verse5Text[Voice] & HardSpace & LyricText;
						Verse5Type[Voice] = 0 + LyricType;
						Verse5Notes[Voice] = 0 + LyricNotes;
					}
				}
				return True;
			}
		}
	}
}

// Nothing matched or fit, so log failure to add lyric.
// Negative number lookup in array can loop Sibelius.
LogError('No place for user-defined or conflicting lyric \'' & LyricText & '\'', 3);
return False;
}"
	GetLyricVoice "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// MIDI import can put lyric text in voice 0 rather
// than the correct voice. In those cases, assume
// voice 1 - not always correct, but better than
// leaving everything out.

nVoice = 0;
if (BarObject.VoiceNumber > 0) {
	nVoice = BarObject.VoiceNumber;
} else {
	if (BarObject.VoiceNumber = 0) {
		nVoice = 1;
	}
}
if ((nVoice > 0) and (StaffNumber > 1)) {
	nVoice = nVoice + (4 * (StaffNumber - 1));
}

return nVoice;
}"
	WriteInstrumentChange "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

if (ShowTrace) {
	trace('Found instrument change in bar ' & BarCounter & 
	      ', position ' & BarObject.Position & ', text = \'' & 
		  BarObject.TextLabel & '\', hidden = ' & BarObject.Hidden);
}

// Split text into visible and invisible parts, and
// ignore anything that is invisible. It looks like
// Sibelius is not correctly reporting the Hidden
// variable for the InstrumentChange BarObject,
// but at least we can support the tilde style of
// hiding the instrument change text.
sTextLabel = '';
if (not (BarObject.Hidden)) {
	sTextArray = SplitString(BarObject.TextLabel, '~', False);
	sTextLabel = sTextArray[0];
}

// Instrument changes have two aspects: the text that appears for
// the instrument change, and the semantics of the instrument change.
// We always export the former as long as it is not hidden and not
// just whitespace, and are now exporting transpositions if possible.

sTextLabel = ToXmlText(sTextLabel);
sTrimTextLabel = TrimTrailingSpaces(sTextLabel);
if (Length(sTrimTextLabel) = 0) {
	sTextLabel = '';
}

if (Length(sTextLabel) > 0) {
	nOffset = (BarObject.Position * 3) - MeasureCounter;
	sPosition = GetPosition(BarObject.Dx, BarObject.Dy, False);
	sColor = GetColor(BarObject);
	sPlacement = GetPlacement(BarObject.Dy);
	WriteXML('<direction' & sPlacement & '>', 3);
	WriteXML('<direction-type>', 4);
	WriteXML('<words ' & sPosition & sColor & '>' & sTextLabel & '</words>', 5);
	WriteXML('</direction-type>', 4);

	// Write the offset, level, and staff if needed.
	if (nOffset != 0) {
		WriteXML('<offset>' & nOffset & '</offset>', 4);
	}
	if (BarObject.CueSize) {
		WriteXML('<level size=\'cue\'/>', 4);
	}
	nVoice = GetVoice(BarObject, StaffNumber);
	if (nVoice > 0) {
		WriteXML('<voice>' & nVoice & '</voice>', 4);
	}
	if (StaffNumber > 0) {
		WriteXML('<staff>' & StaffNumber & '</staff>', 4);
	}
	WriteXML('</direction>', 3);
}

// Assign the current part instrument for use with the
// MusicXML instrument element.
AssignCurrentPartInstrument(BarObject.StyleId, StaffNumber);

// See if we have any staff detail changes. First, we need
// to get the new InstrumentType for the InstrumentChange.

oTypeList = Sibelius.ActiveScore.InstrumentTypes;
oInstrumentType = null;
for each oType in oTypeList {
	if (oType.StyleId = BarObject.StyleId) {
		oInstrumentType = oType;
	}
}

// Now see if the staff lines and tab or percussion clefs
// have changed.
nStaff = 0 + StaffNumber;
if (nStaff = 0) {
	nStaff = 1;
}
fStaffLinesChanged = False;
fTabClefChanged = False;
fPercussionClefChanged = False;
nOldStaffLines = 5;
nNewStaffLines = 5;
nNewTabClef = 0 + TabClef;
nNewPercussionClef = 0 + PercussionClef;
nNewTabStrings = 0 + TabStrings;
nNewPercStaffLines = 0 + PercStaffLines;

if (TabClef = StaffNumber) {
	if (oInstrumentType.Category != 2) {
		fTabClefChanged = True;
		nNewTabClef = -1;
		nNewTabStrings = 0;
		if (oInstrumentType.Category = 1) {
			fPercussionClefChanged = True;
			nNewPercussionClef = StaffNumber;
			nPercStaffLines = oInstrumentType.NumStaveLines;
		}
	}
} else {
	if (PercussionClef = StaffNumber) {
		nOldStaffLines = 0 + PercStaffLines;
		if (oInstrumentType.Category != 1) {
			fPercussionClefChanged = True;
			nNewPercussionClef = -1;
			// Go back to default 5-line staff,
			// in case percussion staff is reset by
			// using a percussion clef on a normal
			// notation staff.
			nNewPercStaffLines = 5;
			if (oInstrumentType.Category = 2) {
				fTabClefChanged = True;
				nNewTabClef = StaffNumber;
				nNewTabStrings = oInstrumentType.NumStrings;
			}
		}
	} else {
		if (oInstrumentType.Category = 2) {
			fTabClefChanged = True;
			nNewTabClef = StaffNumber;
			nNewTabStrings = oInstrumentType.NumStrings;
		} else {
			if (oInstrumentType.Category = 1) {
				fPercussionClefChanged = True;
				nNewPercussionClef = StaffNumber;
				nNewPercStaveLines = oInstrumentType.NumStaveLines;
			}
		}
	}
}
		
if (oInstrumentType.Category = 2) {
	nNewStaffLines = oInstrumentType.NumStrings;
} else {
	nNewStaffLines = oInstrumentType.NumStaveLines;
}
if (StaffLines[nStaff] != nNewStaffLines) {
	fStaffLinesChanged = True;
	StaffLines[nStaff] = nNewStaffLines;
}

// See if staff tuning changed, either via a
// new tab clef or a differently tuned tab clef
fStaffTuningChanged = False;
nNewStringPitch = CreateSparseArray();
if (fTabClefChanged and (TabClef != StaffNumber)) {
	fStaffTuningChanged = True;
} else {
	if ((TabClef = StaffNumber) and (not fTabClefChanged)) {
		if (fStaffLinesChanged) {
			fStaffTuningChanged = True;
			nNewTabStrings = oInstrumentType.NumStrings;
		} 
		for nThisString = 0 to oInstrumentType.NumStrings {
			nNewStringPitch[nThisString] = oInstrumentType.PitchOfNthString(nThisString);
			if (nNewStringPitch[nThisString] != StringPitch[nThisString]) {
				fStaffTuningChanged = True;
			}
		}
	}
}

// Now set up the globals with the new values.
if (fTabClefChanged) {
	TabClef = nNewTabClef;
	TabStrings = nNewTabStrings;
} else {
	if ((TabClef = StaffNumber) and fStaffLinesChanged) {
		TabStrings = nNewTabStrings;
	}
}

if (fPercussionClefChanged) {
	PercussionClef = nNewPercussionClef;
	PercStaffLines = nNewPercStaffLines;
}	

// Percussion clef change does not cause a staff-details
// change unless the staff lines are changing. Otherwise,
// everything else causes a staff-details change.
fStaffDetailsChanged = fStaffLinesChanged or fStaffTuningChanged or fTabClefChanged;

// Now write out the staff-details element if needed.
// Do this in a separate attributes element from the
// transpose element, since the logic would be convoluted
// to put them together.
if (fStaffDetailsChanged) {
	WriteXML('<attributes>', 3);
	sDetailsNumber = '';
	if (StaffNumber > 0) {
		sDetailsNumber = ' number=\'' & StaffNumber & '\'';
	}
	WriteXML('<staff-details' & sDetailsNumber & '>', 4);
	if (fStaffLinesChanged) {
		WriteXML('<staff-lines>' & nNewStaffLines & '</staff-lines>', 5);
	}
	if (fStaffTuningChanged) {
		for nThisString = 0 to TabStrings {
			StringPitch[nThisString] = nNewStringPitch[nThisString];
			nXmlLine = nThisString + 1;
			WriteStaffTuning(StringPitch[nThisString], nXmlLine);
		}
	}
	if (fTabClefChanged) {
		if (TabClef = StaffNumber) {
			WriteXML('<staff-size>150</staff-size>', 5);
		} else {
			WriteXML('<staff-size>100</staff-size>', 5);
		}
	}
	WriteXML('</staff-details>', 4);
	WriteXML('</attributes>', 3);
}


// Output transposition if needed. If this is not at the
// start of the bar, and there are no note rests following,
// postpone until the start of the next bar to make the output
// more idiomatic.
oNextNoteRest = BarObject.NextItem(0, 'NoteRest');
if ((oNextNoteRest != null) or (BarObject.Position = 0)) {
	// Instrument changes can happen at the end of bars,
	// so trying to short cut via GetInstrumentTypeAt may
	// not work. So loop to find the type give the style ID.
	// Now see if we need to write the transpose element.
	CheckTranspose(oInstrumentType, BarObject.ParentBar.BarNumber, 
				   BarObject.Position, StaffNumber, BarObject);
	if ((TransposeChromatic != LastTransposeChromatic) or
		(TransposeDiatonic != LastTransposeDiatonic) or
		(TransposeOctaveChange != LastTransposeOctaveChange)) {
		// If we need to write a transpose element, we may need
		// to write a key signature too. 
		oBar = BarObject.ParentBar;
		oKeySig = oBar.ParentStaff.CurrentKeySignature(oBar.BarNumber);
		
		// Do not write key signature on percussion clefs or on
		// regular notation staves if the current instrument does
		// not use keys signatures.
		fHasKey = True;
		fKeyChanged = False;
		if (oInstrumentType.Category = 1) {
			fHasKey = False;
		} else {
			if ((oInstrumentType.Category = 0) and 
				 (not oInstrumentType.HasKeySignatureOrTuning)) {
				fHasKey = False;
			}
		}
		if (fHasKey) { 
			CheckKey(oKeySig, oInstrumentType);
			// Mode will not change here, just fifths.
			fKeyChanged = (KeyFifths != LastKeyFifths);
		}
		
		// Now write out the attributes element with transpose and
		// key element if needed.
		WriteXML('<attributes>', 3);
		if (fKeyChanged) {
			WriteKey(0);
		}
		WriteTranspose();
		WriteXML('</attributes>', 3);
	}
}
}"
	WriteStaffTuning "(MidiNote, StaffLine) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Write the staff-tuning element given a MIDI pitch and staff line.

// First, compute the values for the staff-tuning element.
nStringOctave = RoundDown(MidiNote / 12) - 1;
nTone = MidiNote % 12;
sStringStep = '' & MidiStringStep[nTone];
nStringAlter = MidiStringAlter[nTone];

// Now write the MusicXML.
WriteXML('<staff-tuning line=\'' & StaffLine & '\'>', 5);
WriteXML('<tuning-step>' & sStringStep & '</tuning-step>', 6);
if (nStringAlter != 0) {
	WriteXML('<tuning-alter>' & nStringAlter & '</tuning-alter>', 6);
}
WriteXML('<tuning-octave>' & nStringOctave & '</tuning-octave>', 6);
WriteXML('</staff-tuning>', 5);
}"
	WriteFrame "(BarObject) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get the data that we need for writing the frame.
nStrings = BarObject.NumberOfStrings;
nFrets = BarObject.NumberOfFrets;
nFirstFret = BarObject.LowestVisibleFret;
sFingerings = BarObject.Fingerings;
nBarres = BarObject.NumBarresInChord;
sPosition = GetYPosition(BarObject.Dy);

// Start the frame.
WriteXML('<frame ' & sPosition & ' valign=\'bottom\'>', 4);
WriteXML('<frame-strings>' & nStrings & '</frame-strings>', 5);
WriteXML('<frame-frets>' & nFrets & '</frame-frets>', 5);
if (nFirstFret > 1) {
	WriteXML('<first-fret>' & nFirstFret & '</first-fret>', 5);
}

// Now write the frame-note elements, one per string.
for nSibString = 0 to nStrings {
	nXmlString = nStrings - nSibString;
	nXmlFret = BarObject.GetPositionOfFingerOnNthString(nSibString);
	// A value of -1 is muted, so it will not appear as a frame-note.
	// A value of 0 is open, which matches the MusicXML use.
	if (nXmlFret >= 0) {
		WriteXML('<frame-note>', 5);
		WriteXML('<string>' & nXmlString & '</string>', 6);
		WriteXML('<fret>' & nXmlFret & '</fret>', 6);
		
		// Handle fingerings
		if (BarObject.ShowFingerings) {
			sFingering = CharAt(sFingerings, nSibString);
			if (sFingering != '-') {
				WriteXML('<fingering>' & sFingering & '</fingering>', 6);
			}
		}
		
		// Handle barres
		if (BarObject.IsNthStringPartOfBarre(nSibString)) {
			for nBarre = 0 to nBarres {
				fBarreStart = False;
				fBarreStop = False;
				if (BarObject.GetStartStringForNthBarre(nBarre) = nSibString) {
					fBarreStart = True;
				}
				if (BarObject.GetEndStringForNthBarre(nBarre) = nSibString) {
					fBarreStop = True;
				}
				// Watch out for a degenerate barre that starts and
				// stops on the same string. It does not appear as
				// a barre in Sibelius and would create invalid
				// MusicXML if exported.
				if (fBarreStart and (not fBarreStop)) {
					WriteXML('<barre type=\'start\'/>', 6);
				}
				if (fBarreStop and (not fBarreStart)) {
					WriteXML('<barre type=\'stop\'/>', 6);
				}
			}	
		}
		WriteXML('</frame-note>', 5);
	}
}

// Finish the frame
WriteXML('</frame>', 4);
}"
	GetXPosition "(Dx, UseDefaultX) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return a position string using relative-x or default-x
// based on the Dx value of a bar object.

// Dx and Dy are in 1/32 of staff space.
nX = Round(Dx / 3.2);
sPosition = '';
if (UseDefaultX) {
	sPosition = 'default-x=\'' & nX & '\'';
} else {
	if (nX != 0) {
		sPosition = 'relative-x=\'' & nX & '\'';
	}
}
return sPosition;
}"
	GetYPosition "(Dy) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return a position string using default-y based on the 
// Dy value of a bar object.

// Dx and Dy are in 1/32 of staff space. Dy is measured from
// middle line, whereas it is top line in MusicXML.

nDefaultY = Round(Dy / 3.2) - 20;

// If we have tab or percussion clefs, compute based on number
// of staff lines and (for tab) default 150% staff size. The
// Dy value in this case is measured from the middle of the staff.

if (TabClef = 0) {
	nDefaultY = Round((Dy / 3.2) - ((TabStrings - 1) * 7.5));
} else {
	if (PercussionClef = 0) {
		nDefaultY = Round((Dy / 3.2) - ((PercStaffLines - 1) * 5));
	}
}

sPosition = 'default-y=\'' & nDefaultY & '\'';
return sPosition;
}"
	GetPlacement "(Dy) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return a placement string based on the Dy value of a bar
// object, or an empty string if placed somewhere on the staff.

// Dy is in 1/32 of staff space and is measured from the
// middle line, versus the top line in MusicXML.

sPlacement = '';
nStaffLines = 5;
nDefaultY = Round(Dy / 3.2) - 20;

// If we have tab or percussion clefs, compute based on number
// of staff lines and (for tab) default 150% staff size. The
// Dy value in this case is measured from the middle of the staff.

if (TabClef = 0) {
	nStaffLines = 0 + TabStrings;
	nDefaultY = Round((Dy / 3.2) - ((nStaffLines - 1) * 7.5));
} else {
	if (PercussionClef = 0) {
		nStaffLines = 0 + PercStaffLines;
		nDefaultY = Round((Dy / 3.2) - ((nStaffLines - 1) * 5));
	}
}

if (nStaffLines > 0) {
	if (nDefaultY > 0) {
		sPlacement = ' placement=\'above\'';
	} else {
		if (nDefaultY < (-10 * (nStaffLines - 1))) {
			sPlacement = ' placement=\'below\'';
		}
	}
}

return sPlacement;
}"
	GetBeams "(ThisDuration) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return possible beams based on duration.

if ((ThisDuration >= Quarter) or (ThisDuration <= 0)) {
	return 0;
}
if (ThisDuration >= Eighth) {
	return 1;
}
if (ThisDuration >= Sixteenth) {
	return 2;
}
if (ThisDuration >= ThirtySecond) {
	return 3;
}
if (ThisDuration >= SixtyFourth) {
	return 4;
}
if (ThisDuration >= OneHundredTwentyEighth) {
	return 5;
}
if (ThisDuration >= (OneHundredTwentyEighth / 2)) {
	return 6;
}
if (ThisDuration >= (OneHundredTwentyEighth / 4)) {
	return 7;
}
return 8;
}"
	NextEntryBeam
	NextEntryDuration
	NextGraceEntryBeam
	NextGraceEntryDuration
	WriteAccidental "(ThisNote, QuarterAlter) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Prior to Sibelius 7.1.3, we did not have full access to whether
// accidentals appeared or not in a Sibelius file. However, two of
// the accidental settings force accidentals to display, so we can
// export those from earlier versions. MusicXML 2.0 clarified the
// supports semantics to indicate that a missing accidental is 
// not an absent accidental.

// Check for slash notation note styles - no accidentals there,
// despite what IsAccidentalVisible says. There might be more
// note styles that have this property of hiding accidentals.
if ((ThisNote.NoteStyle = BeatNoteStyle) or 
	(ThisNote.NoteStyle = BeatWithoutStemNoteStyle)) {
	return False;
}

sAttrib = '';
fDisplay = ThisNote.IsAccidentalVisible;
if (ThisNote.AccidentalStyle = BracketedAcc) {
	fDisplay = True;
	sAttrib = ' parentheses=\'yes\'';
} else {
	if (ThisNote.AccidentalStyle = HiddenAcc) {
		fDisplay = False;
	}
}

// The written accidental is what appears on the screen,
// so it works with both transposed and concert scores.
nAccidental = ThisNote.WrittenAccidental;

if (fDisplay and (nAccidental >= DoubleFlat)) {
	// Lookup normal accidental value
	sAccidental = '' & AccidentalValues[nAccidental + 2];

	// Handle quarter-tone accidentals
	if (Length(QuarterAlter) = 1) {
		if (nAccidental = 0) {
			if (QuarterAlter = '+') {
				sAccidental = 'quarter-sharp';
			} else {
				if (QuarterAlter = '-') {
					sAccidental = 'quarter-flat';
				}
			}
		} else {
			if ((nAccidental = -1) and (QuarterAlter = '-')) {
				sAccidental = 'three-quarters-flat';
			} else {
				if ((nAccidental = 1) and (QuarterAlter = '+')) {
					sAccidental = 'three-quarters-sharp';
				}
			}
		}
	}

	// Now write the accidental
	if (Length(sAccidental) > 0) {
		WriteXML('<accidental' & sAttrib & '>' & sAccidental & 
				 '</accidental>', 4);
	}
}
}"
	WriteTextDirectionContent "(BarObject, IsSystemText, CreditPosition, DisplayedPage) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Write the content of a text direction - the children elements
// of a direction-type element. Usually this is a words elements,
// but different style IDs can have different MusicXML elements
// associated with them. This is called by the routines that
// write both system text and staff text.

// With Sibelius 5, we can split styled text into an array that has
// separate elements for text, style commands enclosed in backslashes,
// and the hidden parts that follow a tilde. Since Sibelius 5 does not
// give us access to default font styles, we try to infer where possible
// by how the various style commands are used to turn formatting on or
// off. Newlines and wildcards are split into their own elements, but
// we want to combine them with other text, so use two sets of arrays:
// the source array split into styles, and the destination array that
// corresponds to individual words elements.

// Initialize inferred defaults. If fonts don't change within text
// we now have the initial font family and size. If fonts change,
// assume the default font family and size from the words-font element.
sInferredDefaultWeight = '';
sInferredDefaultStyle = '';
sInferredDefaultUnderline = '';

// Initialize current formatting values.
sWeight = '';
sStyle = '';
sUnderline = '';
sFamily = '';
sText = '';
sSize = '';
sLetterSpacing = '';

// Create the source and destination arrays.
oSourceText = BarObject.TextWithFormatting;
oDestText = CreateSparseArray();
oDestWeight = CreateSparseArray();
oDestStyle = CreateSparseArray();
oDestUnderline = CreateSparseArray();
oDestFamily = CreateSparseArray();
oDestSize = CreateSparseArray();
oDestLetterSpacing = CreateSparseArray();
oDestSymbol = CreateSparseArray();
oDestMusicText = CreateSparseArray();
oDestXmlSpace = CreateSparseArray();
nDestChildren = 0;
fHidden = False;
fXmlSpace = False;
fUseFamily = True;
nSize = 0;
sOldWeight = '';
sOldStyle = '';
sOldUnderline = '';
sOldFamily = '';
sOldSize = '';
sOldLetterSpacing = '';
sSourceText = '';
fMusicText = False;
fMusicTextSet = False;
if (BarObject.InitialFontName = MusicTextFontName) {
	fMusicText = True;
}
UseVoice = True;
fIsCredit = False;
if (Length(CreditPosition) > 0) {
	fIsCredit = True;
}
// Although only documented as of 2020.9,
// InitialFontName has been available much longer.
sInitFamily = BarObject.InitialFontName;
if (sInitFamily != MainTextFontName) {
	sFamily = sInitFamily;
}
nSize = 0 + BarObject.InitialFontSize;
sInitSize = GetFontSize(nSize);
if (BarObject.InitialFontSize != MainTextFontSize) {
	sSize = sInitSize;
}

// Check to see if this is a credit.
sWordsType = 'words';
sSymbolType = 'symbol';
nFirstIndent = 5;
if (fIsCredit) {
	sWordsType = 'credit-words';
	sSymbolType = 'credit-symbol';
	nFirstIndent = 2;
}

// Assume the expressions start with italics and repeats
// start with bold unless we learn otherwise later.
if (StartsWith('text.staff.expression', BarObject.StyleId)) {
	sStyle = 'italic';
}
if (StartsWith('text.system.repeat', BarObject.StyleId)) {
	sWeight = 'bold';
}

if (ShowTrace) {
	sDebugText = BarObject.TextWithFormattingAsString;
	if (IndexOf('except', sDebugText) >= 0) {
		trace('Processing text content \'' & sDebugText & '\'');
	}
}

for i = 0 to oSourceText.NumChildren {
	fStyleOnly = False;
	sFirstChar = '';
	sSecondChar = '';
	sLastChar = '';
	fNewDest = False;
	sOldWeight = sWeight;
	sOldStyle = sStyle;
	sOldUnderline = sUnderline;
	fOldMusicText = fMusicText;
	if (i > 0) {
		sOldFamily = sFamily;
		sOldSize = sSize;
		sOldStyle = sStyle;
		sOldLetterSpacing = sLetterSpacing;
	}
	sSourceText = '' & oSourceText[i];
	nFlat = IndexOf('^b^', sSourceText);
	
	if (not fHidden) {
		if (Length(sSourceText) > 0) {
			sFirstChar = '' & CharAt(sSourceText, 0);
			if (Length(sSourceText) > 1) {
				sSecondChar = '' & CharAt(sSourceText, 1);
				sLastChar = '' & CharAt(sSourceText, Length(sSourceText) - 1);
			}
		}
		if (sFirstChar = '\\' and sLastChar = '\\') {
			switch (sSecondChar) {
				case ('n') {
					// Add CR. Compose turns LF into a space, so use Mac/Unix endings.
					sText = sText & Chr(13);
					fXmlSpace = True;
				}
				case ('N') {
					// Add CR. Compose turns LF into a space, so use Mac/Unix endings.
					sText = sText & Chr(13);
					fXmlSpace = True;
				}
				case ('B') {
					fNewDest = True;
					sWeight = 'bold';
					if (Length(sInferredDefaultWeight) = 0) {
						sInferredDefaultWeight = 'normal';
					}
				}
				case ('b') {
					fNewDest = True;
					sWeight = 'normal';
					if (Length(sInferredDefaultWeight) = 0) {
						sInferredDefaultWeight = 'bold';
					}
				}
				case ('I') {
					fNewDest = True;
					sStyle = 'italic';
					if (Length(sInferredDefaultStyle) = 0) {
						sInferredDefaultStyle = 'normal';
					}
				}
				case ('i') {
					fNewDest = True;
					sStyle = 'normal';
					if (Length(sInferredDefaultStyle) = 0) {
						sInferredDefaultStyle = 'italic';
					}
				}
				case ('U') {
					fNewDest = True;
					sUnderline = '' & '1';
					if (Length(sInferredDefaultUnderline) = 0) {
						sInferredDefaultUnderline = '' & '0';
					}
				}
				case ('u') {
					fNewDest = True;
					sUnderline = '' & '0';
					if (Length(sInferredDefaultUnderline) = 0) {
						sInferredDefaultUnderline = '' & '1';
					}
				}
				case ('s') {
					if (Length(sSourceText) > 3) {
						nNewSize = 0 + Substring(sSourceText, 2, Length(sSourceText) - 3);
						sNewSize = GetFontSize(nNewSize);
						if ((nDestChildren > 0) or (Length(sText) > 0) or (nNewSize != MainTextFontSize)) {
							fNewDest = True;
							sSize = sNewSize;
							nSize = nNewSize;
						} else {
							sSize = '';
						}
					}
				}
				case ('t') {
					// Do not use letter-spacing with music text such as dynamics.
					if ((Length(sSourceText) > 3) and (not fMusicText)) {
						nNewLetterSpacing = 0 + Substring(sSourceText, 2, Length(sSourceText) - 3);
						sNewLetterSpacing = GetLetterSpacing(nNewLetterSpacing, nSize);
						if ((nDestChildren > 0) or (Length(sText) > 0) or (nNewLetterSpacing != 0)) {
							fNewDest = True;
							sLetterSpacing = sNewLetterSpacing;
						} else {
							sLetterSpacing = '';
						}
					}
				}
				case ('f') {
					if (Length(sSourceText) > 3) {
						// If we have a change back to the default font,
						// there is no way to know what the font family is,
						// so give up there. But do try to handle inferred
						// default weight, style, and underline. It might
						// be better if those were post-processed after
						// all the styles were parsed, but for now this
						// should be OK.
						// For now, still make a new destination for
						// handling parenthesized dynamics and better
						// error reporting.
						fNewDest = True;
						if (CharAt(sSourceText, 2) = '_') {
							fUseFamily = False;
							if (Length(sInferredDefaultWeight) > 0) {
								sWeight = sInferredDefaultWeight;
							}
							if (Length(sInferredDefaultStyle) > 0) {
								sStyle = sInferredDefaultStyle;
							}
							if (Length(sInferredDefaultUnderline) > 0) {
								sUnderline = sInferredDefaultUnderline;
							}
							if (fMusicTextSet) {
								fMusicTextSet = False;
								fMusicText = False;
							}
						} else {
							sTestFamily = Substring(sSourceText, 2, Length(sSourceText) - 3);
							if (IsMusicTextFont(sTestFamily)) {
								fMusicText = True;
								fMusicTextSet = True;
							} else {
								fMusicText = False;
							}
							if (fUseFamily) {
								sFamily = sTestFamily;
							}
						}
					}
				}
				case ('c') {
					if (sSourceText = '\\ctext.character.musictext\\') {
						fNewDest = True;
						sFamily = '' & MusicTextFontName;
						fMusicText = True;
						// If this is here, the previous text is not music text,
						// even if the initial font indicates otherwise.
						fOldMusicText = False;
						fMusicTextSet = True;
					} else {
						if (Length(sSourceText) = 3) {
							fNewDest = True;
							fUseFamily = False;
							if (fMusicTextSet) {
								fMusicTextSet = False;
								fMusicText = False;
							}
						} else {
							LogError('Unrecognized c format string ' & sSourceText, 
									  nFirstIndent);
						}
					}
				}
				case ('$') {
					if (Length(sSourceText) > 3) {
						sKeyword = Substring(sSourceText, 2, Length(sSourceText) - 3);
						sWildcard = GetWildcard(sKeyword, False, DisplayedPage);
						// A wildcard can be empty, so check a global instead of the
						// length of the wildcard text.
						if (WildcardOK) {
							// Check for a flat symbol mixed in with text.
							// Sometimes the wildcard includes a trailing ^
							// and other times it does not.
							nFlat = IndexOf('^b^', sWildcard);
							nFlatLength = 3;
							if (nFlat < 0) {
								nFlat = IndexOf('^b', sWildcard);
								nFlatLength = 2;
							}
							if (nFlat >= 0) {
								sText = sText & Substring(sWildcard, 0, nFlat);
								// Add any preceding text
								if (Length(sText) > 0) {
									oDestText.Push(sText);
									oDestWeight.Push(sWeight);
									oDestStyle.Push(sStyle);
									oDestUnderline.Push(sUnderline);
									oDestFamily.Push(sFamily);
									oDestSize.Push(sSize);
									oDestLetterSpacing.Push(sLetterSpacing);
									oDestSymbol.Push(False);
									oDestXmlSpace.Push(fXmlSpace);
									oDestMusicText.Push(fMusicText);
									nDestChildren = nDestChildren + 1;
									sText = '';
									fXmlSpace = False;
								}
								// Add the flat symbol
								oDestText.Push('accidentalFlat');
								oDestWeight.Push(sWeight);
								oDestStyle.Push(sStyle);
								oDestUnderline.Push(sUnderline);
								oDestFamily.Push(sFamily);
								oDestSize.Push(sSize);
								oDestLetterSpacing.Push(sLetterSpacing);
								oDestSymbol.Push(True);
								oDestXmlSpace.Push(False);
								oDestMusicText.Push(fMusicText);
								nDestChildren = nDestChildren + 1;
				
								// Set up remaining text
								sText = Substring(sWildcard, nFlat + nFlatLength);
							} else {
								sText = sText & sWildcard;
							}
						} else {
							// We have a wildcard like copyist that we cannot access.
							// It seems better to export the wildcard than an empty string.
							// First warn about the untranslated wildcard.
							LogError('Untranslated wildcard ' & sKeyword, nFirstIndent);
							sText = sText & sSourceText;
						}
					}
				}
				default {
					LogError('Unexported format code ' & sSourceText, nFirstIndent);
				}
			}
		} else {
			// Check for a tilde that starts an invisible section.
			// If present, complete the previous text before the
			// hidden section.
			if (sFirstChar = '~') {
				if (Length(sText) > 0) {
					oDestText.Push(sText);
					oDestWeight.Push(sWeight);
					oDestStyle.Push(sStyle);
					oDestUnderline.Push(sUnderline);
					oDestFamily.Push(sFamily);
					oDestSize.Push(sSize);
					oDestLetterSpacing.Push(sLetterSpacing);
					oDestSymbol.Push(False);
					oDestXmlSpace.Push(fXmlSpace);
					oDestMusicText.Push(fMusicText);
					nDestChildren = nDestChildren + 1;
					sText = '';
					fXmlSpace = False;
				}
				fHidden = True;
			}
			
			// We have text. Backslashes seem to always start a new
			// section, so we do not seem to need any further double-
			// backslash handling here.
			if (not fHidden) {
				sText = sText & sSourceText;
			}
		}

		// If we had a new style command, enter the previous text.
		if (fNewDest and (Length(sText) > 0)) {
			oDestText.Push(sText);
			oDestWeight.Push(sOldWeight);
			oDestStyle.Push(sOldStyle);
			oDestUnderline.Push(sOldUnderline);
			oDestFamily.Push(sOldFamily);
			oDestSize.Push(sOldSize);
			oDestLetterSpacing.Push(sOldLetterSpacing);
			oDestSymbol.Push(False);
			oDestXmlSpace.Push(fXmlSpace);
			oDestMusicText.Push(fOldMusicText);
			nDestChildren = nDestChildren + 1;
			sText = '';
			fXmlSpace = False;
		}
	}
}

// After completing the loop, fill in the last child if needed.
if ((Length(sText) > 0) and (not fHidden)) {
	oDestText.Push(sText);
	oDestWeight.Push(sWeight);
	oDestStyle.Push(sStyle);
	oDestUnderline.Push(sUnderline);
	oDestFamily.Push(sFamily);
	oDestSize.Push(sSize);
	oDestLetterSpacing.Push(sLetterSpacing);
	oDestSymbol.Push(False);
	oDestXmlSpace.Push(fXmlSpace);
	oDestMusicText.Push(fMusicText);
	nDestChildren = nDestChildren + 1;
	sText = '';
	fXmlSpace = False;
}

// Remove any trailing spaces in the overall string
nCounter = nDestChildren - 1;
while (nCounter >= 0) {
	if (Length(TrimTrailingWhitespace(oDestText[nCounter])) = 0) {
		oDestText[nCounter] = '';
		nDestChildren = nDestChildren - 1;
		nCounter = nCounter - 1;
	} else {
		nCounter = -1;
	}
}

// Get the position based on object Dx and Dy properties. This is
// not accurate for system text, so only do for staff text.
sPosition = '';
if (not IsSystemText) {
	sPosition = GetPosition(BarObject.Dx, BarObject.Dy, False);
	// Add a leading space if needed
	if (Length(sPosition) > 0) {
		sPosition = ' ' & sPosition;
	}
} else {
	if (fIsCredit) {
		sPosition = '' & CreditPosition;
	}
}
sColor = GetColor(BarObject);

// Check for enclosed text. Use any user style that
// is based on the built-in boxed text style.
sBoxed = '';
sFormat = '';
if ((StartsWith('text.staff.boxed', BarObject.StyleId)) or
	 (StartsWith('text.system.boxed', BarObject.StyleId)) or
	 (StartsWith('text.blankpage.boxed', BarObject.StyleId)) or
	 (StartsWith('text.system.timecode.hitpoints', BarObject.StyleId))) {
	sBoxed = ' enclosure=\'rectangle\'';
}

// Check for rehearsal, dynamics, and pedal marks.
// Only use these if we have one destination child.
// If we only have one child, we have no formatting,
// so just write out the words too.

fTextWritten = False;
fParen = False;

// Look for parenthesized dynamics
sSingleText = '';
sSingleWeight = '';
sSingleStyle = '';
sSingleUnderline = '';
sSingleFamily = '';
sSingleSize = '';
sSingleLetterSpacing = '';
fSingleXmlSpace = False;
fSingleMusicText = False;
if (not fIsCredit) {
	if (nDestChildren = 1) {
		sSingleText = oDestText[0];
		sSingleWeight = oDestWeight[0];
		sSingleStyle = oDestStyle[0];
		sSingleUnderline = oDestUnderline[0];
		sSingleFamily = oDestFamily[0];
		sSingleSize = oDestSize[0];
		sSingleLetterSpacing = oDestLetterSpacing[0];
		fSingleXmlSpace = oDestXmlSpace[0];
		fSingleMusicText = oDestMusicText[0];
	} else {
		if (nDestChildren = 3) {
			sChild1 = oDestText[0];
			sChild2 = oDestText[1];
			sChild3 = oDestText[2];
			if (((Length(sChild1) = 1) and (sChild1 = '(')) and
			    ((Length(sChild3) = 1) and (sChild3 = ')'))) {
				sSingleText = sChild2;
				fSingleXmlSpace = oDestXmlSpace[1];
				fSingleMusicText = oDestMusicText[1];
				fParen = True;
				// For parenthesized fonts, use either the formatting of the first
				// paren or the first text as long as the other one is not set to
				// something other than the default.
				if ((Length(oDestWeight[0]) > 0) and (Length(oDestWeight[1]) = 0)) {
					sSingleWeight = oDestWeight[0];
				} else {
					if ((Length(oDestWeight[1]) > 0) and (Length(oDestWeight[0]) = 0)) {
						sSingleWeight = oDestWeight[1];
					}
				}					
				if ((Length(oDestStyle[0]) > 0) and (Length(oDestStyle[1]) = 0)) {
					sSingleStyle = oDestStyle[0];
				} else {
					if ((Length(oDestStyle[1]) > 0) and (Length(oDestStyle[0]) = 0)) {
						sSingleStyle = oDestStyle[1];
					}
				}
				if ((Length(oDestUnderline[0]) > 0) and (Length(oDestUnderline[1]) = 0)) {
					sSingleUnderline = oDestUnderline[0];
				} else {
					if ((Length(oDestUnderline[1]) > 0) and (Length(oDestUnderline[0]) = 0)) {
						sSingleUnderline = oDestUnderline[1];
					}
				}
				if ((Length(oDestFamily[0]) > 0) and (Length(oDestFamily[1]) = 0)) {
					sSingleFamily = oDestFamily[0];
				} else {
					if ((Length(oDestFamily[1]) > 0) and (Length(oDestFamily[0]) = 0)) {
						sSingleFamily = oDestFamily[1];
					}
				}
				if ((Length(oDestSize[0]) > 0) and (Length(oDestSize[1]) = 0)) {
					sSingleSize = oDestSize[0];
				} else {
					if ((Length(oDestSize[1]) > 0) and (Length(oDestSize[0]) = 0)) {
						sSingleSize = oDestSize[1];
					}
				}
				if ((Length(oDestLetterSpacing[0]) > 0) and (Length(oDestLetterSpacing[1]) = 0)) {
					sSingleLetterSpacing = oDestLetterSpacing[0];
				} else {
					if ((Length(oDestLetterSpacing[1]) > 0) and (Length(oDestLetterSpacing[0]) = 0)) {
						sSingleLetterSpacing = oDestLetterSpacing[1];
					}
				}
			}
		}
	}
}

if (Length(sSingleText) > 0) {
	if (StartsWith('text.system.rehearsalmarks', BarObject.StyleId)) {
		// Do not parenthesize a rehearsal mark; put parentheses in text
		if (fParen) {
			sSingleText = '(' & sSingleText & ')';
			fParen = False;
		}
		WriteXML('<rehearsal' & sColor & '>' & ToXmlText(sSingleText) & 
				 '</rehearsal>', nFirstIndent);
		fTextWritten = True;
		UseVoice = False;
	} else {
		if (IsHarpPedals(sSingleText, sSingleFamily)) {
			WriteHarpPedals(sSingleText, sSingleFamily, sPosition, sColor, nFirstIndent);
			fTextWritten = True;
			UseVoice = False;
		} else {
			if (IsSegnoCoda(sSingleText, sSingleFamily)) {
				WriteSegnoCoda(sSingleText, sSingleFamily, sPosition, sColor, nFirstIndent);
				fTextWritten = True;
				UseVoice = False;
			}
		}
	}
	if ((not fTextWritten) and (StartsWith('text.staff.expression', BarObject.StyleId))) {
		if (sSingleFamily = 'Maestro') {
			sDynamic = IsMaestroDynamic(sSingleText);
		} else {
			sDynamic = IsDynamic(sSingleText);
		}
		if (Length(sDynamic) > 0) {
			WriteXML('<dynamics' & sPosition & sColor & '>', nFirstIndent);
			WriteXML(sDynamic, nFirstIndent + 1);
			WriteXML('</dynamics>', nFirstIndent);
			fTextWritten = True;
		} else {
			// Handle pedal stop as expression text
			if ((sSingleText = '') and (Length(sSingleText) = 1)) {
				WriteXML('<pedal type=\'stop\' line=\'no\'' &
						 sPosition & sColor & '/>', nFirstIndent);
				UseVoice = False;
			} else {
				// Build up the text formatting string.
				if (Length(sSingleWeight) > 0) {
					sFormat = sFormat & ' font-weight=\'' & sSingleWeight & '\'';
				}
				if (Length(sSingleStyle) > 0) {
					sFormat = sFormat & ' font-style=\'' & sSingleStyle & '\'';
				}
				if (Length(sSingleUnderline) > 0) {
					sFormat = sFormat & ' underline=\'' & sSingleUnderline & '\'';
				}
				// If we reset to a default font, we cannot figure out font
				// family or size
				if (fUseFamily) {
					if (Length(sSingleFamily) > 0) {
						sFormat = sFormat & ' font-family=\'' & sSingleFamily & '\'';
					}
				}
				sFormat = sFormat & sSingleSize & sSingleLetterSpacing;
				if (fSingleXmlSpace) {
					sFormat = sFormat & ' xml:space=\'preserve\'';
				}
				// If this is a music text font, warn about writing it as words
				if (fSingleMusicText) {
					if (Length(TrimTrailingWhitespace(sSingleText)) > 0) {
						LogError('Unrecognized music text written as words', nFirstIndent);
					}
				}
				WriteXML('<words' & sPosition & sFormat & sBoxed & sColor & '>' & 
						 ToXmlText(sSingleText) & '</words>', nFirstIndent);
			}
			fTextWritten = True;
		}
	}
} 

// If we have parenthesized dynamics written, set the global appropriately.
if (fTextWritten and fParen) {
	DirectionHasParen = True;
}

if (not fTextWritten) {
	if (Length(oDestWeight[0]) = 0) {
		oDestWeight[0] = sInferredDefaultWeight;
	}
	if (Length(oDestStyle[0]) = 0) {
		oDestStyle[0] = sInferredDefaultStyle;
	}
	if (Length(oDestUnderline[0]) = 0) {
		oDestUnderline[0] = sInferredDefaultUnderline;
	}
	sLastWordsType = '';
	for i = 0 to nDestChildren {
		// Check for mixed segno / coda / text if not a credit
		sDestText = oDestText[i];
		sDestTestText = TrimTrailingWhitespace(sDestText);
		sDestFamily = oDestFamily[i];
		sThisWordsType = 'words';
		sDynamic = '';
		sSymbol = '';
		fMusicTextType = False;
		if (not fIsCredit) {
			if (IsSegnoCoda(sDestTestText, sDestFamily)) {
				sThisWordsType = 'segno-coda';
				fMusicTextType = True;
			} else {
			 	if (oDestMusicText[i]) {
					sDynamic = IsDynamic(sDestTestText);
				} else {
					if (sDestFamily = 'Maestro') {
						sDynamic = IsMaestroDynamic(sDestTextText);
					}
				}
				if (Length(sDynamic) > 0) {
					sThisWordsType = 'dynamics';
					fMusicTextType = True;
				}
			}
		}
		
		if (oDestMusicText[i] and (not fMusicTextType)) {
			sSymbol = IsSymbol(sDestTestText);
			if (Length(sSymbol) > 0) {
				sThisWordsType = 'symbol';
				fMusicTextType = True;
			}
		}

		
		// If we have a music text type, we do not export
		// the size, so zero it out. Maintain status so that
		// switching between words and symbols does not
		// export unneeded font-size attributes on the later
		// words elements. We cannot export whitespace,
		// so if we have trailing whitespace, move it into
		// the next child. We should not have any on the
		// last child, but drop it if we do.
		if (fMusicTextType) {
			if (i > 0) {
				oDestSize[i] = oDestSize[i = 1];
			} else {
				oDestSize[i] = '';
			}
			if (i < (nDestChildren - 1)) {
				nOrigLength = Length(sDestText);
				nTestLength = Length(sDestTestText);
				if (nTestLength < nOrigLength) {
					sTrailingWhitespace = Substring(sDestText, nTestLength);
					oDestText[i + 1] = sTrailingWhitespace & oDestText[i + 1];
					oDestXmlSpace[i + 1] = True;
				}
			}
		}
		
		// If we are switching direction-types, need to close old one
		// and start new one.
		fNeedNewDirectionType = False;
		if ((not fIsCredit) and (sThisWordsType != sLastWordsType)) {
			if ((sThisWordsType = 'symbol') and (sLastWordsType = 'words')) {
				fNeedNewDirectionType = False;
			} else {
				if ((sThisWordsType = 'words') and (sLastWordsType = 'symbol')) {
					fNeedNewDirectionType = False;
				} else {
					fNeedNewDirectionType = True;
				}
			}
		}
		if ((i > 0) and fNeedNewDirectionType) {
			WriteXML('</direction-type>', nFirstIndent - 1);
			WriteXML('<direction-type>', nFirstIndent - 1);
		}

		fDestTextWritten = False;
		switch (sThisWordsType) {
			case ('segno-coda') {
				sSegnoCodaPosition = sPosition;
				if (i > 0) {
					sSegnoCodaPosition = '';
				}
				WriteSegnoCoda(sDestText, sDestFamily, sSegnoCodaPosition, sColor, nFirstIndent);
				UseVoice = False;
				fDestTextWritten = True;
			}
			case ('dynamics') {
				sDynamicsPosition = sPosition;
				if (i > 0) {
					sDynamicsPosition = '';
				}
				WriteXML('<dynamics' & sDynamicsPosition & sColor & '>', nFirstIndent);
				WriteXML(sDynamic, nFirstIndent + 1);
				WriteXML('</dynamics>', nFirstIndent);
				fDestTextWritten = True;
			}
			case ('symbol') {
				sSymbolPosition = sPosition;
				if (i > 0) {
					sSymbolPosition = '';
				}
				// Special case music text characters that convert into
				// multiple symbol elements.
				if (sSymbol = 'textTuplet3Symbols') {
					WriteXML('<' & sSymbolType & sSymbolPosition & sColor & 
							 '>textTupletBracketStartShortStem</' & sSymbolType & '>',
							 nFirstIndent);
					WriteXML('<' & sSymbolType & '>textTuplet3ShortStem</' & 
							 sSymbolType & '>', nFirstIndent);
					WriteXML('<' & sSymbolType & '>textTupletBracketEndShortStem</' & 
							 sSymbolType & '>', nFirstIndent);
				} else {
					WriteXML('<' & sSymbolType & sSymbolPosition & sColor & 
							 '>' & sSymbol & '</' & sSymbolType & '>', nFirstIndent);
				}
				fDestTextWritten = True;
			}
		}
		if (not fDestTextWritten) { 
			// If this is a music text font, warn about writing it as words
			if (oDestMusicText[i]) {
				if (Length(sDestTestText) > 0) {
					if (Length(sDestTestText) > 1) {
						LogError('Unrecognized music text written as words', nFirstIndent);
					} else {
						// Music text characters that do not have music glyphs
						// will show up as normal text, so do not log an error.
						// Handle any exceptions here where there is a glyph in
						// the font that we cannot map to a SMuFL symbol.
						nSingleChar = CharAt(sDestTestText, 0);
						switch (nSingleChar) {
							case (37) {
								sDestText = '6/9';
							}
							case (247) {
								sDestText = '' & '≈';	// Actually equal with two dots
							}
 						}
					}
				}
			}
			// Build up the text formatting string.
			sFormat = '';
			if (Length(oDestWeight[i]) > 0) {
				if ((i = 0) or (('' & oDestWeight[i]) != ('' & oDestWeight[i - 1]))) { 
					sFormat = sFormat & ' font-weight=\'' & oDestWeight[i] & '\'';
				}
			}
			if (Length(oDestStyle[i]) > 0) {
				if ((i = 0) or (('' & oDestStyle[i]) != ('' & oDestStyle[i - 1]))) { 
					sFormat = sFormat & ' font-style=\'' & oDestStyle[i] & '\'';
				}
			}
			if (Length(oDestUnderline[i]) > 0) {
				if ((i = 0) or (('' & oDestUnderline[i]) != ('' & oDestUnderline[i - 1]))) { 
					sFormat = sFormat & ' underline=\'' & oDestUnderline[i] & '\'';
				}
			}
			// If we reset to a default font, we cannot figure out font families
			// or sizes
			if (fUseFamily) {
			 	if (Length(oDestFamily[i]) > 0) {
					if ((i = 0) or (('' & oDestFamily[i]) != ('' & oDestFamily[i - 1]))) {
						sFormat = sFormat & ' font-family=\'' & oDestFamily[i] & '\'';
					}
				}
			}
			if (Length(oDestSize[i]) > 0) {
				if ((i = 0) or (('' & oDestSize[i]) != ('' & oDestSize[i - 1]))) {
					sFormat = sFormat & oDestSize[i];
				}
			}
			if (Length(oDestLetterSpacing[i]) > 0) {
				if ((i = 0) or (('' & oDestLetterSpacing[i]) != ('' & oDestLetterSpacing[i - 1]))) {
					sFormat = sFormat & oDestLetterSpacing[i];
				}
			}
			if (oDestXmlSpace[i]) {
				sFormat = sFormat & ' xml:space=\'preserve\'';
			}
			
			// For repeats, right justify if at the end of the bar
			if (BarObject.Position > BarObject.ParentBar.Length - 8) {
				if (StartsWith('text.system.repeat', BarObject.StyleId)) {
					sFormat = sFormat & ' justify=\'right\'';
				}
			}
			
			// Watch out for single-character text in Unicode private area F020 - F0FF.
			// Convert back into 32 - 255 range. This is generally more useful than
			// the Unicode private area character even if not always what we want.
			// It particularly helps with bracket characters done in music fonts.
			sXmlDestText = ToXmlText(sDestText);
			if (Length(sXmlDestText) = 1) {
				nXmlDestChar = Asc(sXmlDestText);
				if ((nXmlDestChar >= 61472) and (nXmlDestChar <= 61695)) {
					// For debugging
					if (ShowTrace) {
						trace('Found character in private use area: ' & nXmlDestChar);
					}
					sXmlDestText = Chr(nXmlDestChar - 61440);
				}
			}
			sElementType = sWordsType;
			if (oDestSymbol[i]) {
				sElementType = sSymbolType;
			}
			if (i = 0) {
				WriteXML('<' & sElementType & sPosition & sFormat & sBoxed & sColor & '>' &
						 sXmlDestText & '</' & sElementType & '>', nFirstIndent);
			} else {
				WriteXML('<' & sElementType & sFormat & sColor & '>' &
						 sXmlDestText & '</' & sElementType & '>', nFirstIndent);
			}
		}
		sLastWordsType = sThisWordsType;
	}
	if (nDestChildren = 0) {
		// We have an empty string, unexpectedly. We need to write something
		// out at this point in order to maintain a valid MusicXML file, so
		// write out an empty words / credit-words element.
		WriteXML('<' & sWordsType & '/>', nFirstIndent);
		// For debugging
		if (ShowTrace) {
			trace('Could not write text direction content: \'' & 
				  BarObject.TextWithFormattingAsString & '\'');
		}
	}
}
}"
	GetCreditPosition "(BarObject, DisplayedPage) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// We do not have access to text styles to determine the
// exact page-aligned position, just the offset from an
// unknown position. Instead of giving up, we use positions
// based on the default house style you get when creating
// standard engraved scores such as treble staff. A lot of
// these page positions and alignments are pretty standardized.
// Even if we get it wrong, it is easier to fix after import
// if we are starting from a pretty good guess rather than
// just giving up.

// DisplayedPage needs to be passed in separately for 
// multi-page objects, where the credit position can flip
// based on even and odd pages and the bar object only reflects
// the first page.

sStyleId = BarObject.StyleId;
sPosition = '';

nDefaultX = 0;
nDefaultY = 0;
sJustify = '';
sVAlign = '';
fNoPosition = False;

nStaffHeight = 0 + Sibelius.ActiveScore.StaffHeight;
nPageHeight = 40.0 * Sibelius.ActiveScore.ScoreHeight / nStaffHeight;
nPageWidth = 40.0 * Sibelius.ActiveScore.ScoreWidth / nStaffHeight;
oSetup = Sibelius.ActiveScore.DocumentSetup;
nTopMargin = 40.0 * oSetup.PageTopMargin / nStaffHeight;
nBottomMargin = 40.0 * oSetup.PageBottomMargin / nStaffHeight;
nLeftMargin = 40.0 * oSetup.PageLeftMargin / nStaffHeight;
nRightMargin = 40.0 * oSetup.PageRightMargin / nStaffHeight;
nAboveTopStaveGap = 40.0 * oSetup.AboveTopStaveGap / nStaffHeight;
if ((BarObject.ParentBar.BarNumber = 1) and (BarObject.ParentBar.NumBlankPagesBefore = 0)) {
	nAboveTopStaveGap = nAboveTopStaveGap + InitialTopSystemDistanceAddition;
}
nCenterX = nLeftMargin + (((nPageWidth - nRightMargin) - nLeftMargin) / 2.0);
nTopY = nPageHeight - nTopMargin;

// Needed for inside/outside styles
fEvenPage = False;
nPage = BarObject.ParentBar.OnNthPage + 1;
if (utils.IsNumeric(DisplayedPage, True)) {
	nPage = 0 + DisplayedPage;
}
// If we cannot tell odd from even because the displayed
// page is in roman numerals or something, just use the
// internal page number. The positions are approximations
// anyway; some scores redefine the inner/outer style names
// to mean left or right positioning.	
if (nPage > 0) {
	if ((nPage % 2) = 0) {
		fEvenPage = True;
	}
}

nUser = IndexOf('.user', sStyleId);
if (nUser > 0) {
	sStyleId = Substring(sStyleId, 0, nUser);
}	
switch (sStyleId) {
	case ('text.blankpage.boxed') {
		sJustify = 'left';
		sVAlign = 'top';
		// Dx and Dy will position from bottom left margin.
		nDefaultX = nLeftMargin;
		nDefaultY = nBottomMargin;
	}
	case ('text.blankpage.composer') {
		sJustify = 'center';
		sVAlign = 'top';
		nDefaultX = nPageWidth / 2.0;
		nDefaultY = nPageHeight * 0.75;
	}
	case ('text.blankpage.dedication') {
		sJustify = 'center';
		sVAlign = 'top';
		nDefaultX = nPageWidth / 2.0;
		nDefaultY = nPageHeight * 0.875;
	}
	case ('text.blankpage.instrumentname') {
		sJustify = 'left';
		sVAlign = 'top';
		nDefaultX = 0;		// Not left margin, unlike others
		nDefaultY = nTopY;
	}
	case ('text.blankpage.subtitle') {
		sJustify = 'center';
		sVAlign = 'middle';
		nDefaultX = nPageWidth / 2.0;
		nDefaultY = nPageHeight * 0.25;
	}
	case ('text.blankpage.plain') {
		sJustify = 'left';
		sVAlign = 'top';
		// Dx and Dy will position from bottom left margin.
		nDefaultX = nLeftMargin;
		nDefaultY = nBottomMargin;
	}
	case ('text.blankpage.plain.centered') {
		sJustify = 'center';
		sVAlign = 'top';
		// Dx and Dy will position from bottom left margin.
		nDefaultX = nLeftMargin;
		nDefaultY = nBottomMargin;
	}
	case ('text.blankpage.plain.right') {
		sJustify = 'right';
		sVAlign = 'top';
		// Dx and Dy will position from bottom left margin.
		nDefaultX = nLeftMargin;
		nDefaultY = nBottomMargin;
	}
	case ('text.blankpage.title') {
		sJustify = 'center';
		sVAlign = 'middle';
		nDefaultX = nPageWidth / 2.0;
		nDefaultY = nPageHeight / 2.0;
	}
	case ('text.system.page_aligned.composer.ontitlepage') {
		sJustify = 'center';
		sVAlign = 'top';
		nDefaultX = nPageWidth / 2.0;
		nDefaultY = nPageHeight * 0.75;
	}
	case ('text.system.page_aligned.composer') {
		sJustify = 'right';
		sVAlign = 'top';
		nDefaultX = nPageWidth - nRightMargin;
		nDefaultY = nTopY - (nAboveTopStaveGap * 0.5);
	}
	case ('text.system.page_aligned.copyright') {
		sJustify = 'center';
		sVAlign = 'bottom';
		nDefaultX = nCenterX;
		nDefaultY = nBottomMargin;
	}
	case ('text.system.page_aligned.dedication') {
		sJustify = 'center';
		sVAlign = 'top';
		nDefaultX = nCenterX;
		nDefaultY = nTopY - (nAboveTopStaveGap * 0.5);
	}
	// We have seen these Finale styles in test scores,
	// perhaps created by Sibelius's old Finale importer.
	case ('text.system.page_aligned.finale.center') {
		sJustify = 'center';
		sVAlign = 'top';
		nDefaultX = nCenterX;
		nDefaultY = nTopY - (nAboveTopStaveGap * 0.35);
	}
	case ('text.system.page_aligned.finale.centered') {
		sJustify = 'center';
		sVAlign = 'top';
		nDefaultX = nCenterX;
		nDefaultY = nTopY - (nAboveTopStaveGap * 0.35);
	}
	case ('text.system.page_aligned.finale.left') {
		sJustify = 'left';
		sVAlign = 'top';
		nDefaultX = nLeftMargin;
		nDefaultY = nTopY - (nAboveTopStaveGap * 0.35);
	}
	case ('text.system.page_aligned.finale.right') {
		sJustify = 'right';
		sVAlign = 'top';
		nDefaultX = nPageWidth - nRightMargin;
		nDefaultY = nTopY - (nAboveTopStaveGap * 0.35);
	}
	case ('text.system.page_aligned.footer.inside') {
		sVAlign = 'bottom';
		nDefaultY = nBottomMargin;
		if (fEvenPage) {
			sJustify = 'right';
			nDefaultX = nPageWidth - nRightMargin;
		} else {
			sJustify = 'left';
			nDefaultX = nLeftMargin;
		}
	}
	case ('text.system.page_aligned.footer.outside') {
		sVAlign = 'bottom';
		nDefaultY = nBottomMargin;
		if (fEvenPage) {
			sJustify = 'left';
			nDefaultX = nLeftMargin;
		} else {
			sJustify = 'right';
			nDefaultX = nPageWidth - nRightMargin;
		}
	}
	case ('text.system.page_aligned.footer.worksheet.left') {
		sJustify = 'left';
		sVAlign = 'bottom';
		nDefaultX = nLeftMargin;
		nDefaultY = nBottomMargin;
	}
	case ('text.system.page_aligned.header') {
		sJustify = 'center';
		sVAlign = 'top';
		nDefaultX = nCenterX;
		nDefaultY = nTopY;
	}
	case ('text.system.page_aligned.header.worksheet.left') {
		sJustify = 'left';
		sVAlign = 'top';
		nDefaultX = nLeftMargin;
		nDefaultY = nTopY;
	}
	case ('text.system.page_aligned.header.worksheet.right') {
		sJustify = 'right';
		sVAlign = 'top';
		nDefaultX = nPageWidth - nRightMargin;
		nDefaultY = nTopY;
	}
	case ('text.system.page_aligned.header_notp1.inside') {
		sVAlign = 'top';
		nDefaultY = nTopY;
		if (fEvenPage) {
			sJustify = 'right';
			nDefaultX = nPageWidth - nRightMargin;
		} else {
			sJustify = 'left';
			nDefaultX = nLeftMargin;
		}
	}
	case ('text.system.page_aligned.header_notp1') {
		sJustify = 'center';
		sVAlign = 'top';
		nDefaultX = nCenterX;
		nDefaultY = nTopY;
	}
	case ('text.system.page_aligned.instrnametopleft') {
		sJustify = 'left';
		sVAlign = 'top';
		nDefaultX = nLeftMargin;
		nDefaultY = nTopY;
	}
	case ('text.system.page_aligned.lyricist') {
		sJustify = 'left';
		sVAlign = 'top';
		nDefaultX = nLeftMargin;
		nDefaultY = nTopY - (nAboveTopStaveGap * 0.5);
	}
	case ('text.system.page_aligned.pagenumber') {
		// Although defined in Sibelius, plug-ins do not see
		// page numbers as text. They can only be seen via
		// PageNumberChange objects. But we cannot get the
		// PageNumberChange that comes before the first bar,
		// so that is not much help. In case we do see text
		// like this, treat it as positioned on the outside
		// edge of the header.
		sVAlign = 'bottom';
		nDefaultY = nBottomMargin;
		if (fEvenPage) {
			sJustify = 'left';
			nDefaultX = nLeftMargin;
		} else {
			sJustify = 'right';
			nDefaultX = nPageWidth - nRightMargin;
		}
	}
	case ('text.system.page_aligned.subtitle.ontitlepage') {
		sJustify = 'center';
		sVAlign = 'middle';
		nDefaultX = nPageWidth / 2.0;
		nDefaultY = nPageHeight * 0.25;
	}
	case ('text.system.page_aligned.subtitle') {
		sJustify = 'center';
		sVAlign = 'top';
		nDefaultX = nCenterX;
		nDefaultY = nTopY - (nAboveTopStaveGap * 0.25);
	}
	case ('text.system.page_aligned.title.ontitlepage') {
		sJustify = 'center';
		sVAlign = 'middle';
		nDefaultX = nPageWidth / 2.0;
		nDefaultY = nPageHeight / 2.0;
	}
	case ('text.system.page_aligned.title') {
		sJustify = 'center';
		sVAlign = 'top';
		nDefaultX = nCenterX;
		nDefaultY = nTopY;
	}
	default {
		fNoPosition = True;
	}
}

if (fNoPosition) {
	if (ShowTrace) {
		trace('Unsupported credit position for style ' & BarObject.StyleId & ' in file ' &
			  FileName & ', text = \'' & BarObject.TextWithFormattingAsString & 
			  '\', Dx = ' & BarObject.Dx & ', Dy = ' & BarObject.Dy);
	}
} else {
	nDefaultX = Round(nDefaultX + (BarObject.Dx / 3.2));
	nDefaultY = Round(nDefaultY + (BarObject.Dy / 3.2));
	// Do not position off of the top of the page
	nMaxY = Round(nPageHeight - (nTopMargin * 0.25));
	nMinY = Round(nBottomMargin * 0.25);
	if (nDefaultY > nMaxY) {
		nDefaultY = nMaxY;
	}
	if (nDefaultY < nMinY) {
		nDefaultY = nMinY;
	}
	sPosition = ' default-x=\'' & nDefaultX & '\' default-y=\'' & nDefaultY &
				'\' justify=\'' & sJustify & '\' valign=\'' & sVAlign & '\'';
}

return sPosition;
}"
	InitializeCredit "(SystemText, XmlPage, DisplayedPage) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

if (not IsNoText(SystemText, True, DisplayedPage)) {
	// Start the credit, write the content, then finish.
	// If we cannot figure out the position, write a processing
	// instruction instead.
	sCreditPosition = GetCreditPosition(SystemText, DisplayedPage);
	if (Length(sCreditPosition) = 0) {
		sReportText = ScoreInfoSubstitute(SystemText, DisplayedPage);
		LogError('Unexported credit in style ' & SystemText.StyleId & ': ' & 
					sReportText, 1);		
	} else {
		WriteXML('<credit page=\'' & XmlPage & '\'>', 1);
		oCreditTypes = GetCreditTypes(SystemText);
		for i = 0 to oCreditTypes.NumChildren {
			WriteXML('<credit-type>' & oCreditTypes[i] & 
					  '</credit-type>', 2);
		}
		WriteTextDirectionContent(SystemText, True, sCreditPosition, DisplayedPage);
		WriteXML('</credit>', 1);
	}
}
}"
	InitializeCredits "() {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

for each oSystemText in Self.PageAlignedItems {
	sStyleId = oSystemText.StyleId;
	nHeader = IndexOf('header', sStyleId);
	nFooter = IndexOf('footer', sStyleId);
	nPageNumber = IndexOf('pagenumber', sStyleId);
	nWorksheet = IndexOf('worksheet', sStyleId);
	if (((nHeader > 0) or (nFooter > 0) or (nPageNumber > 0)) and (nWorksheet < 0)) {
		nNotP1 = IndexOf('notp1', sStyleId);
		nStartPage = 1;
		if ((nNotP1 > 0) or (nPageNumber > 0)) {
			nStartPage = 2;
		}
		for nPage = nStartPage to Sibelius.ActiveScore.PageCount + 1 {
			sPage = Sibelius.ActiveScore.InternalPageNumToExternalPageNum(nPage);
			InitializeCredit(oSystemText, nPage, sPage);
		}
	} else {
		nPage = oSystemText.ParentBar.OnNthPage + 1 + oSystemText.OnNthBlankPage;
		sPage = GetDisplayedPage(oSystemText);
		InitializeCredit(oSystemText, nPage, sPage);
	}
}
}"
	IsNoText "(BarObject, IsCredit, DisplayedPage) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// If the whole thing is invisible, just return.
// The second parameter indicates whether we should
// handle all-hidden text. We want to handle it for
// exporting directions, but not for exporting credits.

// Empty strings should always be ignored.
if (Length(BarObject.Text) = 0) {
	return True;
}

sFirst = Substring(BarObject.Text, 0, 1);

// This wacky text should always be ignored.
if ((sFirst = '') and Length(BarObject.Text) = 1) {
	return False;
}

// If we are exporting a credit, ignore hidden text
// in all its varieties.
if (IsCredit) {
	if (BarObject.Hidden) {
		return True;
	}
	if (sFirst = '~') {
		return True;
	}
	sSubstitutedText = ScoreInfoSubstitute(BarObject, DisplayedPage);
	if (Length(sSubstitutedText) = 0) {
		return True;
	}
}

// Otherwise we have text
return False;
}"
	InitializeDefaults "(ThisScore) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Create MusicXML defaults based on the style information
// available to us via ManuScript. A lot of information was
// added to ManuScript in Sibelius 6.1.

oSetup = null;
oRules = null;
nStaffHeight = ThisScore.StaffHeight;
WriteXML('<defaults>', 1);
WriteXML('<scaling>', 2);
sData = '<millimeters>' & nStaffHeight & '</millimeters>';
WriteXML(sData, 3);
WriteXML('<tenths>40</tenths>', 3);
WriteXML('</scaling>', 2);
if (not UseTranspose) {
	WriteXML('<concert-score/>', 2);
}
WriteXML('<page-layout>', 2);
nPageHeight = 40.0 * ThisScore.ScoreHeight / nStaffHeight;
nPageWidth = 40.0 * ThisScore.ScoreWidth / nStaffHeight;
sData = '<page-height>' & Round(nPageHeight) & '</page-height>';
WriteXML(sData, 3);
sData = '<page-width>' & Round(nPageWidth) & '</page-width>';
WriteXML(sData, 3);
oSetup = ThisScore.DocumentSetup;
nTopMargin = 40.0 * oSetup.PageTopMargin / nStaffHeight;
nBottomMargin = 40.0 * oSetup.PageBottomMargin / nStaffHeight;
nLeftMargin = 40.0 * oSetup.PageLeftMargin / nStaffHeight;
nRightMargin = 40.0 * oSetup.PageRightMargin / nStaffHeight;
if (oSetup.MarginType = PageMarginsSame) {
	WriteXML('<page-margins type=\'both\'>', 3);
	WriteXML('<left-margin>' & nLeftMargin & '</left-margin>', 4);
	WriteXML('<right-margin>' & nRightMargin & '</right-margin>', 4);
	WriteXML('<top-margin>' & nTopMargin & '</top-margin>', 4);
	WriteXML('<bottom-margin>' & nBottomMargin & '</bottom-margin>', 4);
	WriteXML('</page-margins>', 3);
} else {
	nOddLeftMargin = 40.0 * oSetup.RightPageLeftMargin / ThisScore.StaffHeight;
	nOddRightMargin = 40.0 * oSetup.RightPageRightMargin / ThisScore.StaffHeight;
	WriteXML('<page-margins type=\'odd\'>', 3);
	WriteXML('<left-margin>' & nOddLeftMargin & '</left-margin>', 4);
	WriteXML('<right-margin>' & nOddRightMargin & '</right-margin>', 4);
	WriteXML('<top-margin>' & nTopMargin & '</top-margin>', 4);
	WriteXML('<bottom-margin>' & nBottomMargin & '</bottom-margin>', 4);
	WriteXML('</page-margins>', 3);
	WriteXML('<page-margins type=\'even\'>', 3);
	WriteXML('<left-margin>' & nLeftMargin & '</left-margin>', 4);
	WriteXML('<right-margin>' & nRightMargin & '</right-margin>', 4);
	WriteXML('<top-margin>' & nTopMargin & '</top-margin>', 4);
	WriteXML('<bottom-margin>' & nBottomMargin & '</bottom-margin>', 4);
	WriteXML('</page-margins>', 3);
}
WriteXML('</page-layout>', 2);

// Compute the left system margin. If we are confused,
// we will skip export of the system-margins element.
oRules = ThisScore.EngravingRules;
nWhichLeft = 0;
fExportSystemMargins = True;
switch (oRules.InstrumentNamesSubsequentSystems) {
	case (InstrumentNamesFull) {
		nWhichLeft = oSetup.StaffLeftMarginFullNames;
	}
	case (InstrumentNamesShort) {
		nWhichLeft = oSetup.StaffLeftMarginShortNames;
	}
	case (InstrumentNamesNone) {
		nWhichLeft = oSetup.StaffLeftMarginNoNames;
	}
	default {
		fExportSystemMargins = False;
	}
}
nLeftMargin = 40.0 * nWhichLeft / nStaffHeight;

// Initialize the system layout. Start with the system margins.
// Use the values from after the first system, then add the first
// system value when exporting the first measure. Default right
// system margin is always 0.
WriteXML('<system-layout>', 2);
if (fExportSystemMargins) {
	WriteXML('<system-margins>', 3);
	WriteXML('<left-margin>' & nLeftMargin & '</left-margin>', 4);
	WriteXML('<right-margin>0</right-margin>', 4);
	WriteXML('</system-margins>', 3);
}

// Write out the system distance. The Sibelius value is a
// default minimum distance that gets scaled by vertical 
// justification - usually bigger, but can be smaller.
nData = oRules.SpacesBetweenSystems * 10;
WriteXML('<system-distance>' & nData & '</system-distance>', 3);

// Write out the top system distance. As with the margins,
// do this using the values for after the first page, then
// add the first page value when exporting the first measure.
nData = 40.0 * oSetup.AboveTopStaveGapAfterFirstPage / nStaffHeight;
WriteXML('<top-system-distance>' & nData & '</top-system-distance>', 3);
WriteXML('</system-layout>', 2);

// Initialize the staff layout with a default distance 
// between staves, again subject to vertical justification.
// There are several additional gaps for brackets, vocal
// staves, and staves with system objects that we can add
// when writing the first measure of a part where the preceding
// or current staff falls into the appropriate category.
// Handle these decisions - including whether to even write out
// a staff-layout element or not - to a separate method.
InitializeStaffLayout(ThisScore);

// Vertical justification affects both staves and systems.
// Output the cutoff percentage here as a processing instruction
// since we are not trying to duplicate the Sibelius vertical 
// justification algorithm here.
LogError('StaffJustificationPercentage=' & 
		  oRules.StaffJustificationPercentage, 2);

// Write out the default line widths and note size scaling that
// we have available starting in 6.1.
InitializeAppearance(ThisScore);

// Write out the default fonts.
sMusicFont = ThisScore.MainMusicFontName;
// Distinguish engraved vs. handwritten for the builtin fonts.
// Support both older and newer Sibelius 7 font names.
if ((StartsWith('Opus', sMusicFont)) or 
    (StartsWith('Helsinki', sMusicFont))) {
	sMusicFont = sMusicFont & ',engraved';
} else {
	if ((StartsWith('Reprise', sMusicFont)) or 
	    (StartsWith('Inkpen', sMusicFont))) {
		sMusicFont = sMusicFont & ',handwritten';
	}
}

WriteXML('<music-font font-family=\'' & sMusicFont & '\'/>', 2);

// MainTextFontName no longer works, so we poll the text items
// to determine the default text font name and size. We also 
// use this to set up globals to guide repeat playback since
// we cannot do this with just one pass.
SetTextAndRepeatGlobals(ThisScore);

sTextFont = '' & MainTextFontName;
if (Length(sTextFont) > 0) {
	nTextFontSize = 0 + MainTextFontSize;
	sGeneric = GetGenericTextFont(sTextFont);
	if (Length(sGeneric) > 0) {
		sTextFont = sTextFont & ',' & sGeneric;
	}
	sXmlFontSize = '';
	if (nTextFontSize > 0) {
		sXmlFontSize = GetFontSize(nTextFontSize);
	}
	WriteXML('<word-font font-family=\'' & sTextFont & '\'' & sXmlFontSize & '/>', 2);
}

// Save away the music text font
MusicTextFontName = '' & ThisScore.MusicTextFontName;
WriteXML('</defaults>', 1);
}"
	WriteAccordionRegistration "(SymbolIndex, NewColor) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

if ((SymbolIndex < 496) or (SymbolIndex > 510)) {
	return 0;
}
WriteXML('<accordion-registration' & NewColor & '>', 5);
switch (SymbolIndex) {
	case (496) {
		WriteXML('<accordion-high/>', 6);
	}
	case (497) {
		WriteXML('<accordion-low/>', 6);
	}
	case (498) {
		WriteXML('<accordion-high/>', 6);
		WriteXML('<accordion-low/>', 6);
	}
	case (499) {
		WriteXML('<accordion-middle>1</accordion-middle>', 6);
	}
	case (500) {
		WriteXML('<accordion-high/>', 6);
		WriteXML('<accordion-middle>1</accordion-middle>', 6);
	}
	case (501) {
		WriteXML('<accordion-middle>1</accordion-middle>', 6);
		WriteXML('<accordion-low/>', 6);
	}
	case (502) {
		WriteXML('<accordion-high/>', 6);
		WriteXML('<accordion-middle>1</accordion-middle>', 6);
		WriteXML('<accordion-low/>', 6);
	}
	case (503) {
		WriteXML('<accordion-middle>2</accordion-middle>', 6);
	}
	case (504) {
		WriteXML('<accordion-high/>', 6);
		WriteXML('<accordion-middle>2</accordion-middle>', 6);
	}
	case (505) {
		WriteXML('<accordion-middle>2</accordion-middle>', 6);
		WriteXML('<accordion-low/>', 6);
	}
	case (506) {
		WriteXML('<accordion-high/>', 6);
		WriteXML('<accordion-middle>2</accordion-middle>', 6);
		WriteXML('<accordion-low/>', 6);
	}
	case (507) {
		WriteXML('<accordion-middle>3</accordion-middle>', 6);
	}
	case (508) {
		WriteXML('<accordion-high/>', 6);
		WriteXML('<accordion-middle>3</accordion-middle>', 6);
	}
	case (509) {
		WriteXML('<accordion-middle>3</accordion-middle>', 6);
		WriteXML('<accordion-low/>', 6);
	}
	case (510) {
		WriteXML('<accordion-high/>', 6);
		WriteXML('<accordion-middle>3</accordion-middle>', 6);
		WriteXML('<accordion-low/>', 6);
	}
}
WriteXML('</accordion-registration>', 5);
}"
	TrimTrailingSpaces "(ThisString) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Trim all trailing spaces from the end of a string.

fTrim = False;
sText = '' & ThisString;
if (Length(sText) > 0) {
	if (CharAt(sText, Length(sText) - 1) = ' ') {
		fTrim = True;
	}
	while (fTrim) {
		sText = Substring(sText, 0, Length(sText) - 1);
		fTrim = False;
		if (Length(sText) > 0) {
			if (CharAt(sText, Length(sText) - 1) = ' ') {
				fTrim = True;
			}
		}
	}
}
return sText;
}"
	TrimTrailingWhitespace "(ThisString) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Trim trailing whitespace from the end of a string:
// not just spaces, but tab, CR, LF, and non-breaking
// space too.

fTrim = True;
sText = '' & ThisString;
nLength = Length(sText);
nIndex = nLength - 1;
if (nIndex < 0) {
	fTrim = False; 
}
while (fTrim) {
	nChar = CharAt(sText, nIndex);
	switch (nChar) {
		case (9) {
			nIndex = nIndex - 1;
		}
		case (10) {
			nIndex = nIndex - 1;
		}
		case (13) {
			nIndex = nIndex - 1;
		}
		case (32) {
			nIndex = nIndex - 1;
		}
		case (160) {
			nIndex = nIndex - 1;
		}
		default {
			fTrim = False;
		}
	}
	if (nIndex < 0) {
		fTrim = False;
	}
}
if (nIndex < 0) {
	sText = '';
} else {
	sText = Substring(sText, 0, nIndex + 1);
}

return sText;
}"
	WriteMetronomeNote "(ThisText) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

sText = '' & ThisText;
sType = '';
fDot = False;
if (Length(sText) < 3) {
	sFirst = CharAt(sText, 0);
	switch (sFirst) {
		case ('q') {
			sType = 'quarter';
		}
		case ('e') {
			sType = 'eighth';
		}
		case ('h') {
			sType = 'half';
		}
		case ('w') {
			sType = 'whole';
		}
		case ('x') {
			sType = '16th';
		}
		case ('y') {
			sType = '32nd';
		}
		case ('W') {
			sType = 'breve';
		}
	}
	if (Length(sText) = 2) {
		if (CharAt(sText, 1) = '.') {
			fDot = True;
		}
	}
	WriteXML('<metronome-note>', 6);
	WriteXML('<metronome-type>' & sType & '</metronome-type>', 7);
	if (fDot) {
		WriteXML('<metronome-dot/>', 7);
	}
	WriteXML('<metronome-note>', 6);
} else {
	// Check for metric modulations that we can represent using
	// the metronome-note features added in MusicXML 2.0. For now
	// we just do a hard-coded match against the common versions
	// included in the built-in word text menu in Sibelius 5.
	switch (sText) {
		case ('qaaz') {
			WriteXML('<metronome-note>', 6);
			WriteXML('<metronome-type>eighth</metronome-type>', 7);			
			WriteXML('<metronome-beam number=\'1\'>begin</metronome-beam>', 7);
			WriteXML('</metronome-note>', 6);
			WriteXML('<metronome-note>', 6);
			WriteXML('<metronome-type>eighth</metronome-type>', 7);
			WriteXML('<metronome-beam number=\'1\'>end</metronome-beam>', 7);
			WriteXML('</metronome-note>', 6);
		}
		case ('qaaaz') {
			WriteXML('<metronome-note>', 6);
			WriteXML('<metronome-type>eighth</metronome-type>', 7);			
			WriteXML('<metronome-beam number=\'1\'>begin</metronome-beam>', 7);
			WriteXML('</metronome-note>', 6);
			WriteXML('<metronome-note>', 6);
			WriteXML('<metronome-type>eighth</metronome-type>', 7);
			WriteXML('<metronome-beam number=\'1\'>end</metronome-beam>', 7);
			WriteXML('</metronome-note>', 6);
		}
		case ('[qp]e') {
			WriteXML('<metronome-note>', 6);
			WriteXML('<metronome-type>quarter</metronome-type>', 7);			
			WriteXML('<metronome-tuplet type=\'start\' bracket=\'yes\'>', 7);
			WriteXML('<actual-notes>3</actual-notes>', 8);
			WriteXML('<normal-notes>2</normal-notes>', 8);
			WriteXML('<normal-type>eighth</normal-type>', 8);
			WriteXML('</metronome-tuplet>', 7);
			WriteXML('</metronome-note>', 6);
			WriteXML('<metronome-note>', 6);
			WriteXML('<metronome-type>eighth</metronome-type>', 7);
			WriteXML('<metronome-tuplet type=\'stop\' bracket=\'yes\'>', 7);
			WriteXML('<actual-notes>3</actual-notes>', 8);
			WriteXML('<normal-notes>2</normal-notes>', 8);
			WriteXML('<normal-type>eighth</normal-type>', 8);
			WriteXML('</metronome-tuplet>', 7);
			WriteXML('</metronome-note>', 6);
		}
		case ('qa.aai') {
			WriteXML('<metronome-note>', 6);
			WriteXML('<metronome-type>eighth</metronome-type>', 7);
			WriteXML('<metronome-dot/>', 7);			
			WriteXML('<metronome-beam number=\'1\'>begin</metronome-beam>', 7);
			WriteXML('</metronome-note>', 6);
			WriteXML('<metronome-note>', 6);
			WriteXML('<metronome-type>16th</metronome-type>', 7);
			WriteXML('<metronome-beam number=\'1\'>end</metronome-beam>', 7);
			WriteXML('<metronome-beam number=\'2\'>backward hook</metronome-beam>', 7);
			WriteXML('</metronome-note>', 6);
		}
		case ('qsi') {
			WriteXML('<metronome-note>', 6);
			WriteXML('<metronome-type>16th</metronome-type>', 7);			
			WriteXML('<metronome-beam number=\'1\'>begin</metronome-beam>', 7);
			WriteXML('<metronome-beam number=\'2\'>begin</metronome-beam>', 7);
			WriteXML('</metronome-note>', 6);
			WriteXML('<metronome-note>', 6);
			WriteXML('<metronome-type>16th</metronome-type>', 7);
			WriteXML('<metronome-beam number=\'1\'>end</metronome-beam>', 7);
			WriteXML('<metronome-beam number=\'2\'>end</metronome-beam>', 7);
			WriteXML('</metronome-note>', 6);
		}
		case ('[ep]x') {
			WriteXML('<metronome-note>', 6);
			WriteXML('<metronome-type>eighth</metronome-type>', 7);			
			WriteXML('<metronome-tuplet type=\'start\' bracket=\'yes\'>', 7);
			WriteXML('<actual-notes>3</actual-notes>', 8);
			WriteXML('<normal-notes>2</normal-notes>', 8);
			WriteXML('<normal-type>16th</normal-type>', 8);
			WriteXML('</metronome-tuplet>', 7);
			WriteXML('</metronome-note>', 6);
			WriteXML('<metronome-note>', 6);
			WriteXML('<metronome-type>16th</metronome-type>', 7);
			WriteXML('<metronome-tuplet type=\'stop\' bracket=\'yes\'>', 7);
			WriteXML('<actual-notes>3</actual-notes>', 8);
			WriteXML('<normal-notes>2</normal-notes>', 8);
			WriteXML('<normal-type>16th</normal-type>', 8);
			WriteXML('</metronome-tuplet>', 7);
			WriteXML('</metronome-note>', 6);
		}
		case ('qapaasq') {
			WriteXML('<metronome-note>', 6);
			WriteXML('<metronome-type>eighth</metronome-type>', 7);			
			WriteXML('<metronome-beam number=\'1\'>begin</metronome-beam>', 7);
			WriteXML('<metronome-tuplet type=\'start\' bracket=\'no\'>', 7);
			WriteXML('<actual-notes>3</actual-notes>', 8);
			WriteXML('<normal-notes>2</normal-notes>', 8);
			WriteXML('<normal-type>16th</normal-type>', 8);
			WriteXML('</metronome-tuplet>', 7);
			WriteXML('</metronome-note>', 6);
			WriteXML('<metronome-note>', 6);
			WriteXML('<metronome-type>16th</metronome-type>', 7);
			WriteXML('<metronome-beam number=\'1\'>end</metronome-beam>', 7);
			WriteXML('<metronome-beam number=\'2\'>backward hook</metronome-beam>', 7);
			WriteXML('<metronome-tuplet type=\'stop\' bracket=\'no\'>', 7);
			WriteXML('<actual-notes>3</actual-notes>', 8);
			WriteXML('<normal-notes>2</normal-notes>', 8);
			WriteXML('<normal-type>16th</normal-type>', 8);
			WriteXML('</metronome-tuplet>', 7);
			WriteXML('</metronome-note>', 6);
		}
	}
}
}"
	LogError "(ThisError, Tabs) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// When we have an error, export it in place as an 
// XML processing instruction, vs. tracing or a separate
// log file. Put this in a separate method so we can change
// the processing as needed in the future.

WriteXML('<?DoletSibelius ' & ToXmlText(ThisError) & '?>', Tabs);
}"
	LogSymbolError "(Symbol, Tabs) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

nCutoff = 928;
sUserDefinedSymbolType = 'Unknown user-defined symbol index ';
nOriginalScore = Sibelius.ActiveScore.OriginalProgramVersion;
if (nOriginalScore < 4000) {
	nCutoff = 496;
	sUserDefinedSymbolType = 'Unknown user-defined Sibelius 3 symbol index ';
	if (nOriginalScore < 2000) {
		sUserDefinedSymbolType = 'Unknown user-defined Sibelius 1 symbol index ';
	} else {
		if (nOriginalScore < 3000) {
			sUserDefinedSymbolType = 'Unknown user-defined Sibelius 2 symbol index ';
		}
	}
} else {
	if (nOriginalScore < 5000) {
		nCutoff = 576;
		sUserDefinedSymbolType = 'Unknown user-defined Sibelius 4 symbol index ';
	}
}
if (Symbol >= nCutoff) {
	LogError(sUserDefinedSymbolType & Symbol, Tabs);
} else {
	LogError('Unknown symbol index ' & Symbol, Tabs);
}
}"
	IndexOf "(Pattern, StringToSearch) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Like IndexOf in Java - return the index where the
// pattern starts in the string to be searched, or -1
// if not found.

return IndexOfStartingAt(Pattern, StringToSearch, 0);
}"
	IndexOfStartingAt "(Pattern, StringToSearch, StartAt) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Like IndexOf in Java - return the index where the
// pattern starts in the string to be searched, starting
// at the specified index in the string, or -1 if not found.

// Setup the search and return -1 if the pattern is
// longer than the string to be searched.
nPatternLength = Length(Pattern);
nLastSearch = Length(StringToSearch) - nPatternLength + 1;
if ((nLastSearch <= 0) or (Length(StringToSearch) = 0)) {
	return -1;
}

// Now loop through the string
for i = StartAt to nLastSearch {
	sTest = Substring(StringToSearch, i, nPatternLength);
	if (sTest = Pattern) {
		// Found, so return index
		return i;
	}
}
// Not found, so return -1
return -1;
}"
	DirectionHasParen
	PercStaffLines
	TransposePercussion "(PitchDict) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Transpose unpitched data to match the MusicXML definition
// based on the PercStaffLines global for the number of lines
// in the percussion staff. Handles the built-in percussion
// instruments with 1 to 4 staff lines.
if ((PercStaffLines = 1) or (PercStaffLines = 2)) {
	// Transpose down a fifth.
	switch (PitchDict['step']) {
		case ('C') {
			PitchDict['step'] = '' & 'F';
			PitchDict['octave'] = PitchDict['octave'] - 1;
		}
		case ('D') {
			PitchDict['step'] = '' & 'G';
			PitchDict['octave'] = PitchDict['octave'] - 1;
		}
		case ('E') {
			PitchDict['step'] = '' & 'A';
			PitchDict['octave'] = PitchDict['octave'] - 1;
		}
		case ('F') {
			PitchDict['step'] = '' & 'B';
			PitchDict['octave'] = PitchDict['octave'] - 1;
		}
		case ('G') {
			PitchDict['step'] = '' & 'C';
		}
		case ('A') {
			PitchDict['step'] = '' & 'D';
		}
		case ('B') {
			PitchDict['step'] = '' & 'E';
		}
	}
} else {
	if (PercStaffLines = 3) {
		// Transpose down a third.
		switch (PitchDict['step']) {
			case ('C') {
				PitchDict['step'] = '' & 'A';
				PitchDict['octave'] = PitchDict['octave'] - 1;
			}
			case ('D') {
				PitchDict['step'] = '' & 'B';
				PitchDict['octave'] = PitchDict['octave'] - 1;
			}
			case ('E') {
				PitchDict['step'] = '' & 'C';
			}
			case ('F') {
				PitchDict['step'] = '' & 'D';
			}
			case ('G') {
				PitchDict['step'] = '' & 'E';
			}
			case ('A') {
				PitchDict['step'] = '' & 'F';
			}
			case ('B') {
				PitchDict['step'] = '' & 'G';
			}
		}
	} else {
		if (PercStaffLines = 4) {
			// Transpose down a second
			switch (PitchDict['step']) {
				case ('C') {
					PitchDict['step'] = '' & 'B';
					PitchDict['octave'] = PitchDict['octave'] - 1;
				}
				case ('D') {
					PitchDict['step'] = '' & 'C';
				}
				case ('E') {
					PitchDict['step'] = '' & 'D';
				}
				case ('F') {
					PitchDict['step'] = '' & 'E';
				}
				case ('G') {
					PitchDict['step'] = '' & 'F';
				}
				case ('A') {
					PitchDict['step'] = '' & 'G';
				}
				case ('B') {
					PitchDict['step'] = '' & 'A';
				}
			}
		}
	}
}
}"
	NextV0Item "(ThisObject, SameType) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Using a voice number of 0 in NextItem gets you
// the next item in any voice. This function gets
// the next item with a voice number of 0, with
// an option to only return one with the same type.
// Returns null if no later object in this
// bar has a voice number of 0.
oObject = ThisObject;
while (oObject != null) {
	if (SameType) {
		oObject = oObject.NextItem(0, ThisObject.Type);
	} else {
		oObject = oObject.NextItem();
	}
	if (oObject != null) {
		if (oObject.VoiceNumber = 0) {
			return oObject;
		}
	}
}
return null;
}"
	EndOfTuplet "(ThisNoteRest, ThisTuplet) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// See if this is the end of the tuplet by looking ahead
// to the next note and seeing if it has a tuplet at
// the same position with the same played duration. 
// This seems to be more accurate than comparing tuplet
// and note durations given the roundoff errors involved. 
oNextNoteRest = ThisNoteRest.NextItem(ThisNoteRest.VoiceNumber, ThisNoteRest.Type);
if (oNextNoteRest = null) {
	return True;
}

// Sometimes tuplets end prematurely when the played duration does not
// match the unit * right value, even though the tuplet is not nested.
// The last note of the tuplet then does not have a parent tuplet as
// it should. Test to see if we are in that situation.
nRightTimesUnit = ThisTuplet.Right * ThisTuplet.Unit;
fCheckTupletEnd = False;
if (ThisTuplet.ParentTupletIfAny = null) {
	if (nRightTimesUnit > ThisTuplet.PlayedDuration) {
		fCheckTupletEnd = True;
	}
}

oNextTuplet = oNextNoteRest.ParentTupletIfAny;
if (oNextTuplet = null) {
	fShouldEndNow = True;
 	// See if we have a prematurely ending tuplet.
	if (fCheckTupletEnd) {
		nEndOfTupletPos = ThisTuplet.Position + (ThisTuplet.Right * ThisTuplet.Unit);
		if (nEndOfTupletPos > oNextNoteRest.Position) {
			fShouldEndNow = False;

			// Set a global so next NoteRest is handled OK.
			ExtendedTuplet = True;

			// Log that we are making this change.
			LogError('Extending tuplet to compensate for data inconsistency', 4);
		}
	}
	return fShouldEndNow;
}

// Keep checking nested tuplets to find a match. If we have
// a match, then this is not the end of the tuplet. If no
// match, keep looking up the nested tuplet chain.

// Some files can get messed up so that tuplets appear to
// be infinitely nested in ManuScript. Max out the tuplet
// count at a certain point. The end of tuplet determination
// may be wrong in this case, but it will not hang export.
fMatch = False;
nMaxNestedTuplets = 1000;
nNestedTuplet = 0;
while ((oNextTuplet != null) and (nNestedTuplet < nMaxNestedTuplets)) {
	fMatch = ((ThisTuplet.Position = oNextTuplet.Position) and
			  (ThisTuplet.PlayedDuration = oNextTuplet.PlayedDuration));
	if (fMatch) {
		return False;
	} else {
		// This global will have been set by WriteNoteRest if
		// we have a bogus file where the tuplets appear to be
		// infinitely nested. But that check is for the original
		// NoteRest, not the lookahead one we are checking here.
		if (IgnoreNestedTuplets) {
			oNextTuplet = null;
		} else {
			oNextTuplet = oNextTuplet.ParentTupletIfAny;
			nNestedTuplet = nNestedTuplet + 1;
		}
	}
}

// No match found, so it is the end of the tuplet.
return True;
}"
	TimeModActualNotes
	TimeModNormalNotes
	TimeModNormalType
	HasDoubleTremolo "(ThisNoteRest) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// First make sure this NoteRest thinks it has double tremolos.
if (ThisNoteRest.DoubleTremolos <= 0) {
	return False;
}

// Now check that the following NoteRest has the same duration
// and grace note values.
oNextNoteRest = ThisNoteRest.NextItem(ThisNoteRest.VoiceNumber, ThisNoteRest.Type);
if (oNextNoteRest = null) {
	// @todo Handle cross-bar double tremolos
	// For now we just return False.
	return False;
}
if ((ThisNoteRest.Duration = oNextNoteRest.Duration) and
	 (ThisNoteRest.GraceNote = oNextNoteRest.GraceNote)) {
	return True;
} else {
	return False;
}
}"
	IsCue
	WriteStartTuplet "(ThisTuplet, TupletNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Write as much tuplet formatting as we can at the start of a tuplet.

sBracket = '';
sStyle = '';

if (ThisTuplet.Hidden) {
	// If the tuplet is hidden, show neither the number nor
	// the bracket, no matter what we computed earlier.
	sBracket = ' bracket=\'no\'';
	sStyle = ' show-number=\'none\'';
} else {
	// See if bracket if forced on or off.
	if (ThisTuplet.Bracket = TupletBracketOn) {
		sBracket = ' bracket=\'yes\'';
	} else {
		if (ThisTuplet.Bracket = TupletBracketOff) {
			sBracket = ' bracket=\'no\'';
		}
	}

	// See how tuplet style is set. The TupletLeft value
	// represents the MusicXML default of show-number='yes',
	// so nothing needs to be output there.
	switch (ThisTuplet.Style) {
		case (TupletNoNumber) {
			sStyle = ' show-number=\'none\'';
		}
		case (TupletLeftRight) {
			sStyle = ' show-number=\'both\'';
		}
		case (TupletLeftRightNote) {
			// Sibelius actual shows the normal note type only,
			// which is not in MusicXML 2.0. Approximate this
			// by using the actual, since actual and normal
			// are the same in Sibelius 5 tuplets.
			sStyle = ' show-number=\'both\' show-type=\'actual\'';
		}
	}
}

// Get type data in XML form from tuplet unit.
oTypeData = CreateDictionary();
GetType(ThisTuplet.Unit, oTypeData);

// Write tuplet-actual and tuplet-normal elements if they are
// different than the time-modification value.
fWriteActualNormal = False;
if ((TimeModActualNotes != ThisTuplet.Left) or
	(TimeModNormalNotes != ThisTuplet.Right) or
	(TimeModNormalType != oTypeData[TypeDataType]) or
	(TimeModNormalDots != oTypeData[TypeDataDots])) {
	fWriteActualNormal = True;
}

// If we have deeply nested tuplets, usually used
// to simulate fanned beaming playback, do not
// export numbers greater than 16 or the MusicXML
// file will be invalid.
sStopNumber = ' number=\'' & TupletNumber & '\'';
if (TupletNumber > 16) {
	sStopNumber = '';
}

// Now write out the tuplet.

sTupletAttributes = sStopNumber & ' type=\'start\'' & sBracket & sStyle;

if (fWriteActualNormal) {
	WriteXML('<tuplet' & sTupletAttributes & '>', 5);
	WriteXML('<tuplet-actual>', 6);
	WriteXML('<tuplet-number>' & ThisTuplet.Left & '</tuplet-number>', 7);
	if (Length(oTypeData[TypeDataType]) > 0) {
		WriteXML('<tuplet-type>' & oTypeData[TypeDataType] & '</tuplet-type>', 7);
		for i = 0 to oTypeData[TypeDataDots] {
			WriteXML('<tuplet-dot/>', 7);
		}
	}
	WriteXML('</tuplet-actual>', 6);
	WriteXML('<tuplet-normal>', 6);
	WriteXML('<tuplet-number>' & ThisTuplet.Right & '</tuplet-number>', 7);
	if (Length(oTypeData[TypeDataType]) > 0) {
		WriteXML('<tuplet-type>' & oTypeData[TypeDataType] & '</tuplet-type>', 7);
		for i = 0 to oTypeData[TypeDataDots] {
			WriteXML('<tuplet-dot/>', 7);
		}
	}
	WriteXML('</tuplet-normal>', 6);
	WriteXML('</tuplet>', 5);
} else {
	WriteXML('<tuplet' & sTupletAttributes & '/>', 5);
}
}"
	TypeDataType
	TypeDataDots
	TypeDataBeams
	WriteTuplet "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Tuplets are written from the NoteRest, using the
// ParentTupletIfAny property added in Sibelius 5.
if (ShowTrace) {
	trace('Found tuplet in bar ' & BarObject.ParentBar.BarNumber & 
	      ', position ' & BarObject.Position);
}
}"
	TimeModNormalDots
	PedalStopY
	WriteLyricContent "(ThisText, ThisType, ThisPrevType, ThisNotes) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Write the child element content of the lyric element:
// the syllabic, text, and extend elements.

// Split the text up based on elision characters.
oSyllables = SplitString(ThisText, Elisions, True);
nPrevType = 0 + ThisPrevType;
fLast = False;

// Try to assign elision content to more accurately
// as we export them. Currently just checking for
// underties and hard spaces.
// @todo See if we can do this for hyphens too.
sElisionContent = '';
sElision = '<elision/>';
if (oSyllables.NumChildren != 1) {
	oUnderscore = SplitString(ThisText, '_', True);
	if (oUnderscore.NumChildren = oSyllables.NumChildren) {
		sElisionContent = '' & Undertie;
	} else {
		oHardSpace = SplitString(ThisText, HardSpace, True);
		if (oHardSpace.NumChildren = oSyllables.NumChildren) {
			sElisionContent = '' & HardSpace;
		}
	}
	if (Length(sElisionContent) > 0) {
		sElision = '<elision>' & sElisionContent & '</elision>';
	}	
}

// If the lyric has only an elision, then the number of children
// will be 0, and we will not have any text elements exporting.
// In that case, export two empty text elements with an elision
// element in between to avoid creating an invalid MusicXML file.
if (oSyllables.NumChildren = 0) {
	WriteXML('<text/>', 5);
	WriteXML(sElision, 5);
	WriteXML('<text/>', 5);
} else {
	// Otherwise loop through each syllable.
	for i = 0 to oSyllables.NumChildren {
		if (i = (oSyllables.NumChildren - 1)) {
			fLast = True;
		}
		if ((ThisType = EndOfWord) or (not fLast)) {
			if (nPrevType = EndOfWord) {
				WriteXML('<syllabic>single</syllabic>', 5);
			} else {
				WriteXML('<syllabic>end</syllabic>', 5);
			}
		} else {
			if (nPrevType = EndOfWord) {
				WriteXML('<syllabic>begin</syllabic>', 5);
			} else {
				WriteXML('<syllabic>middle</syllabic>', 5);
			}
		}
		// If we have an elision, the syllables before the
		// last are treated as the ends of words.
		nPrevType = EndOfWord;

		// Now write the actual lyric text. The ToXmlText call
		// was done earlier when setting up the lyric array.
		WriteXML('<text>' & oSyllables[i] & '</text>', 5);

		// Write out an elision if not the last text.
		// @todo Write out the elision character.
		// Underscores generally represent an undertie in this context.
		if (not fLast) {
			WriteXML(sElision, 5);
		}
	}
}

// Extensions go after the last syllable/text combination.
if (ThisNotes > 1) {
	WriteXML('<extend/>', 5);
}
}"
	HardSpace
	Elisions
	AlwaysBefore "(BarObject) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return True if this object should always go before a note
// when in between notes - e.g. caesura, breath marks.

switch (BarObject.Type) {
	case ('SymbolItem') {
		// If caesura or breath mark, return True.
		if ((BarObject.Index >= 247) and (BarObject.Index <= 250)) {
			return True;
		} else {
			return False;
		}
	}
	default {
		return False;
	}
}
}"
	AddDegreeText "(DegValueText, DegTypeText) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Add a degree text attribute values to the
// global arrays for the previous degree.
nDegreeCount = DegreeCount - 1;
if (nDegreeCount >= 0) {
	DegreeValueTexts[nDegreeCount] = '' & DegValueText;
	DegreeTypeTexts[nDegreeCount] = '' & DegTypeText;
}
}"
	IsNoteAttached "(BarObject) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return True if this symbol or line object is note-attached,
// needing to be output as part of a note rather than as a
// direction. This is needed to make sure that note-attached
// objects at the end of a measure are sorted before the 
// last note, not after.

switch (BarObject.Type) {
	case ('LyricItem') {
		return True;
	}
	case ('Slur') {
		return True;
	}
	case ('Text') {
		if (BarObject.StyleId = 'text.staff.space.fingering') {
			return True;
		} else {
			return False;
		}
	}
	case ('SymbolItem') {
		sSymbolParent = '' & SymbolIndexParents[BarObject.Index];
		if (sSymbolParent = 'direction-type') {
			return False;
		} else {
			return True;
		}
	}
	case ('Trill') {
		return True;
	}
	case ('ArpeggioLine') {
		return True;
	}
	case ('GlissandoLine') {
		return True;
	}
	default {
		return False;
	}
}
}"
	AlwaysAfter "(BarObject) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return True if this object should always go after a note
// when in between notes - e.g. arpeggios.

switch (BarObject.Type) {
	case ('ArpeggioLine') {
		return True;
	}
	default {
		return False;
	}
}
}"
	CheckSlurs "(ThisEntry, StaffNumber, StaffToWrite, SlurStarts, SlurStops) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Check to see which slurs we should write out for starts
// and stops. Fill out the two output sparse arrays, and
// return the total number of slurs to be written.

nSlurs = 0;
nVoice = 0 + ThisEntry.VoiceNumber;
nBarCounter = 0 + BarCounter;

for i = 1 to 17 {
	SlurStarts[i] = False;
	SlurStops[i] = False;
	nSlurVoice = SlurVoices[i];
	fThisSlurStop = False;
	oNextEntry = null;
	fGraceFollowingGrace = False;
	fStartOnGrace = False;

	// WriteMeasure will put the slurs in correct order, so the only
	// thing we need to check on is staff and voice mismatches.
	if (SlurStartBars[i] = nBarCounter) {
		// Do not match if on a different staff. If cross-staff,
		// match either on original or written staff.
		if ((SlurStaffs[i] = StaffNumber) or (SlurStaffs[i] = StaffToWrite)) {
			// If the voice matches, or the slur has no voice,
			// we use it. The exception is for grace notes,
			// which we examine in more detail below.
			if ((nSlurVoice = nVoice) or (nSlurVoice = 0)) {
				if (ThisEntry.GraceNote) {
					// There does not appear to be a direct way to tell
					// if a slur is associated with a grace note or a
					// main note, as they both have the same position,
					// and a normally-positioned slur will have a Dx
					// value of 0. So try this:
					// - If the slur starts and stops at the same position,
					//   assume it starts on the grace and ends of the main.
					// - If the Dx is negative, assume it goes on the grace
					//   note. This can be useful for bend slurs in tab.
					// 	  Make it negative by at least half a space though.
					// - Otherwise assume the slur starts on the main note.
					if (SlurStartDx[i] < (-Space/2)) {
						fStartOnGrace = True;
					} else {
						if ((SlurStartBars[i] = SlurStopBars[i]) and
							(SlurStartPositions[i] = SlurStopPositions[i])) {
							fStartOnGrace = True;
						}
					}
					if (fStartOnGrace) {
						SlurStarts[i] = True;
						nSlurs = nSlurs + 1;
					} else {
						// If there is no main note following, then attach
						// to this grace note anyway.
						oNextNonGrace = NextNonGraceNote(ThisEntry, nSlurVoice);
						// oNextEntry = ThisEntry.NextItem(nSlurVoice, ThisEntry.Type);
						if (oNextNonGrace = null) {
							SlurStarts[i] = True;
							nSlurs = nSlurs + 1;
						}
					}
				} else {
					SlurStarts[i] = True;
					nSlurs = nSlurs + 1;
				}
			} else {
				oNextEntry = ThisEntry.NextItem(nSlurVoice, ThisEntry.Type);
				if (oNextEntry = null) {
					SlurStarts[i] = True;
					nSlurs = nSlurs + 1;
				} else {
					if ((oNextEntry.Position > ThisEntry.Position) and
						(oNextEntry.Position > SlurStartPositions[i]))  {
						SlurStarts[i] = True;
						nSlurs = nSlurs + 1;
					}
				} 
			}
		}	
	}
	
	// For slur stops, we do not have things already quantized, so the test
	// is more complicated.	We also do not want to stop a slur on a grace note.
	if (SlurStopBars[i] = nBarCounter) {
		// Check for both the original staff and the cross-staff if different.
		// While Dy and RhDy are unreliable in slurs, we can still use RhDy
		// to help detect cross-staff slurs ending in a lower staff, because
		// candidate notes in an upper staff will have already been tested.
		// If we try doing this for cross-staff slurs ending in an upper staff,
		// that causes problems.
		fStaffMatch = False;
		fCrossStaffLower = False;
		if ((SlurStaffs[i] = StaffNumber) or (SlurStaffs[i] = StaffToWrite)) {
			fStaffMatch = True;
			if (StaffToWrite > StaffNumber) {
				fCrossStaffLower = True;
			}
		} else {
			if ((StaffNumber = (SlurStaffs[i] + 1)) and (SlurStopDy[i] < -128)) {
				fStaffMatch = True;
			} else {
				if ((StaffNumber = (SlurStaffs[i] + 2)) and (SlurStopDy[i] < -256)) {
					fStaffMatch = True;
				}
			}
		}
		if (fStaffMatch) {
			// If the voice matches, or the slur has no voice,
			// we use it if we have an exact position match or
			// the slur ended before the current NoteRest.
			if ((not ThisEntry.GraceNote) and
				((nSlurVoice = nVoice) or (nSlurVoice = 0))) {
				fPositionOK = False;
				if (SlurStopPositions[i] <= ThisEntry.Position) {
					if ((not fCrossStaffLower) or 
					    (SlurStopPositions[i] = ThisEntry.Position)) {
						fPositionOK = True;
					}
				}
				if (fPositionOK) {
					SlurStops[i] = True;
					nSlurs = nSlurs + 1;
					fThisSlurStop = True;
				}
			}
			if (not fThisSlurStop) {
				// Compare against the next entry in this voice, or the
				// next entry overall if no next entry in this voice.
				if (oNextEntry != null) {
					if (oNextEntry.GraceNote) {
						oNonGrace = NextNonGraceNote(oNextEntry, nSlurVoice);
						if (oNonGrace != null) {
							oNextEntry = oNonGrace;
						}
					}
				}
				if (oNextEntry = null) {
					oNextEntry = NextNonGraceNote(ThisEntry, 0);
					// If a grace note follows but not main note follows in this measure,
					// stop the slur on the next grace note, not this one.
					if ((oNextEntry = null) and ThisEntry.GraceNote and fStartOnGrace) {
						oNextGrace = ThisEntry.NextItem(nSlurVoice, ThisEntry.Type);
						if (oNextGrace.GraceNote) {
							fGraceFollowingGrace = True;
						}
					}
				}
				if (not fGraceFollowingGrace) {
					if (oNextEntry = null) {
						if (not fCrossStaffLower) {
							SlurStops[i] = True;
							nSlurs = nSlurs + 1;
						}
					} else {
						// If this entry is closer than the next entry,
						// stop the slur here. For cross-staff slurs to a
						// lower staff, we need an exact match.
						if (SlurStopPositions[i] < oNextEntry.Position) {
							nThisDistance = SlurStopPositions[i] - ThisEntry.Position;
							nNextDistance = oNextEntry.Position - SlurStopPositions[i];
							fDistanceMatch = False;
							if (fCrossStaffLower) {
								if (nThisDistance = 0) {
									fDistanceMatch = True;
								} 
							} else {
								if (nThisDistance <= nNextDistance) {
									fDistanceMatch = True;
								}
							}
							if (fDistanceMatch) {
								SlurStops[i] = True;
								nSlurs = nSlurs + 1;
							}
						}
					}
				} 
			}
		}
	}
}
return nSlurs;
}"
	NextNonGraceNote "(ThisEntry, Voice) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return the next NoteRest that is not a grace note.
// Used for stopping slurs, because we do not want to
// stop slurs on a grace note in the absence of any
// way to reliably distinguish between grace and
// regular note attachment within ManuScript.
// Also skip over hidden notes as well as grace notes.

fDone = False;
oEntry = ThisEntry;
while (not fDone) {
	oEntry = oEntry.NextItem(Voice, 'NoteRest');
	if (oEntry = null) {
		fDone = True;
	} else {
		if (not (oEntry.GraceNote or oEntry.Hidden)) {
			fDone = True;
		}
	}
}
return oEntry;
}"
	CheckGlissandos "(ThisEntry, StaffNumber, StaffToWrite, GlissandoStarts, GlissandoStops, GlissandoCrossStaffStops) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// This code is nearly identical to CheckSlurs, but no great
// way to reuse this within ManuScript.

// Check to see which glissandos we should write out for starts
// and stops. Fill out the two output arrays, using 1 for
// True and 0 for False, and return the total number of 
// glissandos to be written.

nGlissandos = 0;
nVoice = 0 + ThisEntry.VoiceNumber;
nBarCounter = 0 + BarCounter;

for i = 1 to 17 {
	GlissandoStarts[i] = False;
	GlissandoStops[i] = False;
	GlissandoCrossStaffStops[i] = False;
	nGlissandoVoice = GlissandoVoices[i];
	fThisGlissandoStop = False;
	oNextEntry = null;

	// WriteMeasure will put the glissandos in correct order, so the only
	// thing we need to check on is staff and voice mismatches.
	if (GlissandoStartBars[i] = nBarCounter) {
		// Do not match if on a different staff. If cross-staff,
		// match either on original or written staff.
		if ((GlissandoStaffs[i] = StaffNumber) or (GlissandoStaffs[i] = StaffToWrite)) {
			// If the voice matches, or the glissando has no voice,
			// we use it. Do more checking with grace note.
			if ((nGlissandoVoice = nVoice) or (nGlissandoVoice = 0)) {
				if (ThisEntry.GraceNote) {
					// Try to determine if glissando starts on grace
					// or main note - see comments in CheckSlurs.
					fStartOnGrace = False;
					if ((GlissandoStartBars[i] = GlissandoStopBars[i]) and
						 (GlissandoStartPositions[i] = GlissandoStopPositions[i])) {
						fStartOnGrace = True;
					}
					if (fStartOnGrace) {
						GlissandoStarts[i] = True;
						nGlissandos = nGlissandos + 1;
					} else {
						// If there is no note following, then attach
						// to this grace note anyway.
						oNextNonGrace = NextNonGraceNote(ThisEntry, nGlissandoVoice);
						// oNextEntry = ThisEntry.NextItem(nGlissandoVoice, ThisEntry.Type);
						if (oNextNonGrace = null) {
							GlissandoStarts[i] = True;
							nGlissandos = nGlissandos + 1;
						}
					}
				} else {
					GlissandoStarts[i] = True;
					nGlissandos = nGlissandos + 1;
				}
			} else {
				oNextEntry = ThisEntry.NextItem(nGlissandoVoice, ThisEntry.Type);
				if (oNextEntry = null) {
					GlissandoStarts[i] = True;
					nGlissandos = nGlissandos + 1;
				} else {
					if ((oNextEntry.Position > ThisEntry.Position) and
						(oNextEntry.Position > GlissandoStartPositions[i]))  {
						GlissandoStarts[i] = True;
						nGlissandos = nGlissandos + 1;
					}
				} 
			}
		}	
	}
	
	// For glissando stops, we do not have things already quantized, so the test
	// is more complicated.	We also do not want to stop a glissando on a grace note.
	if (GlissandoStopBars[i] = nBarCounter) {
		// Do not match if on a different staff unless
		// the end of the glissando is positioned vertically
		// that it could be cross-staff.
		fStaffMatch = False;
		fCrossStaffMatch = False;
		fCrossStaffLower = False;
		if ((GlissandoStaffs[i] = StaffNumber) or (GlissandoStaffs[i] = StaffToWrite)) {
			fStaffMatch = True;
			if ((StaffToWrite > 0) and (GlissandoStaffs[i] != StaffToWrite)) {
				fCrossStaffMatch = True;
				if (StaffToWrite > StaffNumber) {
					fCrossStaffLower = True;
				}
			}
		} else {
			if (StaffNumber >= (GlissandoStaffs[i] + 1)) {
				if ((StaffNumber = (GlissandoStaffs[i] + 1)) and (GlissandoStopDy[i] < -128)) {
					fStaffMatch = True;
					fCrossStaffMatch = True;
				} else {
					if ((StaffNumber = (GlissandoStaffs[i] + 2)) and (GlissandoStopDy[i] < -256)) {
						fStaffMatch = True;
						fCrossStaffMatch = True;
					}
				}
			} else {
				// There is a much greater chance of false positives here since these
				// notes come before the same staff notes, so make the cutoffs higher.
				if (StaffNumber <= (GlissandoStaffs[i] - 1)) {
					if ((StaffNumber = (GlissandoStaffs[i] - 1)) and (GlissandoStopDy[i] > 200)) {
						fStaffMatch = True;
						fCrossStaffMatch = True;
					} else {
						if ((StaffNumber = (GlissandoStaffs[i] - 2)) and (GlissandoStopDy[i] > 328)) {
							fStaffMatch = True;
							fCrossStaffMatch = True;
						}
					}
				}
			}
		}

		if (fStaffMatch) {
			// If the voice matches, or the glissando has no voice,
			// we use it if we have an exact position match or
			// the glissando ended before the current NoteRest.
			if ((not ThisEntry.GraceNote) and 
				 ((nGlissandoVoice = nVoice) or (nGlissandoVoice = 0))) {
				fPositionOK = False;
				if (GlissandoStopPositions[i] <= ThisEntry.Position) {
					if ((not fCrossStaffLower) or 
					    (GlissandoStopPositions[i] = ThisEntry.Position)) {
						fPositionOK = True;
					}
				}
				if (fPositionOK) {
					GlissandoStops[i] = True;
					GlissandoCrossStaffStops[i] = fCrossStaffMatch;
					nGlissandos = nGlissandos + 1;
					fThisGlissandoStop = True;
				}
			}
			if (not fThisGlissandoStop) {
				// Compare against the next entry in this voice, or the
				// next entry overall if no next entry in this voice.
				if (oNextEntry != null) {
					if (oNextEntry.GraceNote) {
						oNonGrace = NextNonGraceNote(oNextEntry, nGlissandoVoice);
						if (oNonGrace != null) {
							oNextEntry = oNonGrace;
						}
					}
				}
				if (oNextEntry = null) {
					oNextEntry = NextNonGraceNote(ThisEntry, 0);
				}
				if (oNextEntry = null) {
					if (not fCrossStaffLower) {
						GlissandoStops[i] = True;
						nGlissandos = nGlissandos + 1;
					}
				} else {
					// If this entry is closer than the next entry,
					// stop the glissando here. For cross-staff glissandos
					// to a lower staff, we need an exact match.
					if (GlissandoStopPositions[i] < oNextEntry.Position) {
						nThisDistance = GlissandoStopPositions[i] - ThisEntry.Position;
						nNextDistance = oNextEntry.Position - GlissandoStopPositions[i];
						fDistanceMatch = False;
						if (fCrossStaffLower) {
							if (nThisDistance = 0) {
								fDistanceMatch = True;
							}
						} else {
							if (nThisDistance <= nNextDistance) {
								fDistanceMatch = True;
							}
						}
						if (fDistanceMatch) {
							GlissandoStops[i] = True;
							GlissandoCrossStaffStops[i] = fCrossStaffMatch;
							nGlissandos = nGlissandos + 1;
						}
					}
				} 
			}
		}	
	}
}
return nGlissandos;
}"
	TrillCounts
	CheckTrills "(BarObject, StaffNumber, TrillStarts, TrillStops) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Check to see if the BarObject is a BarRest vs. a NoteRest.
fBarRest = False;
fGrace = False;
nNoteCount = 0;
if (BarObject.Type = 'BarRest') {
	fBarRest = True;
} else {
	fGrace = BarObject.GraceNote;
	nNoteCount = BarObject.NoteCount;
}

// This code is nearly identical to CheckSlurs, but no great
// way to reuse this within ManuScript.

// Check to see which trills we should write out for starts
// and stops. Fill out the two output sparse arrays, and return
// the total number of trills to be written.

nTrills = 0;
nVoice = 0 + BarObject.VoiceNumber;
nBarCounter = 0 + BarCounter;

for i = 1 to 17 {
	TrillStarts[i] = False;
	TrillStops[i] = False;
	nTrillVoice = TrillVoices[i];
	fThisTrillStop = False;
	oNextEntry = null;

	// WriteMeasure will put the trills in correct order, so the only
	// thing we need to check on is staff and voice mismatches. Do not
	// export trill starts on a bar rest.
	if ((TrillStartBars[i] = nBarCounter) and (not fBarRest)) {
		// Do not match if on a different staff or on a rest.
		if ((TrillStaffs[i] = StaffNumber) or (nNoteCount = 0)) {
			// If the voice matches, or the trill has no voice,
			// we use it. Do more checking if grace note.
			if ((nTrillVoice = nVoice) or (nTrillVoice = 0)) {
				if (fGrace) {
					// Try to determine if trill starts on grace
					// or main note - see comments in CheckSlurs.
					fStartOnGrace = False;
					if (TrillStartDx[i] < (-Space/2)) {
						fStartOnGrace = True;
					} else {
						if ((TrillStartBars[i] = TrillStopBars[i]) and
							 (TrillStartPositions[i] = TrillStopPositions[i])) {
							fStartOnGrace = True;
						}
					}
					if (fStartOnGrace) {
						TrillStarts[i] = True;
						nTrills = nTrills + 1;
					} else {
						// If there is no main note following, then attach
						// to this grace note anyway.
						oNextNonGrace = NextNonGraceNote(BarObject, nTrillVoice);
						// oNextEntry = BarObject.NextItem(nTrillVoice, BarObject.Type);
						if (oNextNonGrace = null) {
							TrillStarts[i] = True;
							nTrills = nTrills + 1;
						}
					}
				} else {
					TrillStarts[i] = True;
					nTrills = nTrills + 1;
				}
			} else {
				// Do not check for next entry if this is a bar rest.
				fNextEntryDone = fBarRest;
				oThisEntry = BarObject;
				while (not fNextEntryDone) {
					oNextEntry = oThisEntry.NextItem(nTrillVoice, BarObject.Type);
					if (oNextEntry = null) {
						fNextEntryDone = True;
					} else {
						if (not (oNextEntry.Hidden)) {
							fNextEntryDone = True;
						}
					}
					oThisEntry = oNextEntry;	
				}
				if (oNextEntry = null) {
					TrillStarts[i] = True;
					nTrills = nTrills + 1;
				} else {
					if ((oNextEntry.Position > BarObject.Position) and
						(oNextEntry.Position > TrillStartPositions[i]))  {
						TrillStarts[i] = True;
						nTrills = nTrills + 1;
					}
				} 
			}
		}	
	}
	
	// For trill stops, we do not have things already quantized, so the test
	// is more complicated.	We also do not want to stop a trill on a grace note.
	if (TrillStopBars[i] = nBarCounter) {
		// Do not match if on a different staff. Rests are OK for stops.
		if (TrillStaffs[i] = StaffNumber) {
			// If the voice matches, or the trill has no voice,
			// we use it if we have an exact position match or
			// the trill ended before the current NoteRest.
			if ((not fGrace) and 
				 ((nTrillVoice = nVoice) or (nTrillVoice = 0))) {
				if (TrillStopPositions[i] <= BarObject.Position) {
					TrillStops[i] = True;
					nTrills = nTrills + 1;
					fThisTrillStop = True;
				}
			}
			if (not fThisTrillStop) {
				// Compare against the next entry in this voice, or the
				// next entry overall if no next entry in this voice.
				if (oNextEntry != null) {
					if (oNextEntry.GraceNote) {
						oNonGrace = NextNonGraceNote(oNextEntry, nTrillVoice);
						if (oNonGrace != null) {
							oNextEntry = oNonGrace;
						}
					}
				}
				if ((oNextEntry = null) and (not fBarRest)) {
					oNextEntry = NextNonGraceNote(BarObject, 0);
				}
				if (oNextEntry = null) {
					TrillStops[i] = True;
					nTrills = nTrills + 1;
				} else {
					// If this entry is closer than the next entry,
					// stop the trill here.
					if (TrillStopPositions[i] < oNextEntry.Position) {
						nThisDistance = TrillStopPositions[i] - BarObject.Position;
						nNextDistance = oNextEntry.Position - TrillStopPositions[i];
						if (nThisDistance <= nNextDistance) {
							TrillStops[i] = True;
							nTrills = nTrills + 1;
						}
					}
				} 
			}
		}	
	}
}
return nTrills;
}"
	WriteTrills "(BarObject, TrillStarts, TrillStops) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Check to see if the BarObject is a BarRest vs. a NoteRest.
fBarRest = False;
if (BarObject.Type = 'BarRest') {
	fBarRest = True;
}

// Write out the trill starts, then the trill stops,
// based on the input arrays (1 for True, 0 for False).
// Write out trill stops on a bar rest, but not trill starts.

for i = 1 to 17 {
	if (TrillStarts[i] and (not fBarRest)) {
		// The default-y position is really more accurately placed
		// on the wavy-line rather than the trill-mark element, but
		// leave it on trill-mark for better import into other apps.
		sPosition = '';
		if (BarObject.Position = TrillStartPositions[i]) {
			sPosition = ' ' & GetPosition(TrillStartDx[i], TrillStartDy[i], False);
		} else {
			sPosition = ' ' & GetYPosition(TrillStartDy[i]);
		}
		sColor = '' & TrillColors[i];
		WriteXML('<trill-mark' & sPosition & sColor & '/>', 6);
		WriteXML('<wavy-line type=\'start\' number=\'' & i & '\'' & 
				  sColor & '/>', 6);
		// Reset the start bar so this does not get rewritten later.
		TrillStartBars[i] = 0;
	}

	if (TrillStops[i]) {
		sPosition = '';

		// Also do not export relative-x unless we know that the
		// trill position matches the note position - we have
		// no offset element here.		
		// Trill RhDx and RhDy positions both seem buggy as of
		// Sibelius 6.2, so leave out for now.

		// if (TrillStartDy[i] != TrillStopDy[i]) {
		//		if (BarObject.Position = TrillStopPositions[i]) {
		//			sPosition = ' ' & GetPosition(TrillStopDx[i], TrillStopDy[i], False);
		// 		} else {
		//			sPosition = ' ' & GetYPosition(TrillStopDy[i]);
		// 		} 
		// } else {
		//		if (BarObject.Position = TrillStopPositions[i]) {
		//			sPosition = ' ' & GetXPosition(TrillStopDx[i], False);
		//		}
		// }
		WriteXML('<wavy-line type=\'stop\' number=\'' & i & '\'' & 
				  sPosition & '/>', 6);
		TrillStopBars[i] = 0;	// free this trill for reuse
		TrillCounts = TrillCounts - 1;
	}
}
}"
	ArpeggioVoiceWritten
	HasSlideStop "(ThisNoteRest, Duration) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Check to see if we can export a slide stop. Given the
// lack of available information, we can only export slides
// that go from one single-note NoteRest to another. As
// with ties, they should not have a gap between them,
// though they can cross bar boundaries. Do allow for
// some slack or it will not work well with tuplets.

fNextBar = False;
nSlideSlack = 6;

nTestPosition = (ThisNoteRest.Position * 3) + Duration;
if ((nTestPosition + nSlideSlack) >= (ThisNoteRest.ParentBar.Length * 3)) {
	fNextBar = True;
	nTestPosition = 0;
}	

oNextNoteRest = null;
if (fNextBar) {
	// Get the first note rest in the next bar
	oNextNoteRest = FirstInNextBar(ThisNoteRest);
} else {
	oNextNoteRest =
		ThisNoteRest.NextItem(ThisNoteRest.VoiceNumber, ThisNoteRest.Type);
}

if (oNextNoteRest = null) {
	return False;
}
// @todo Exact position test causes a problem with tuplets 
if ((ThisNoteRest.NoteCount = 1) and (oNextNoteRest.NoteCount = 1)) {
	nNumeric = (oNextNoteRest.Position * 3) - nTestPosition;
	if (MathAbs(nNumeric) <= nSlideSlack) {
		return True;
	} else {
		return False;
	}
} else {
	return False;
}
}"
	FirstInNextBar "(BarObject) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return the first object that has the same type and
// voice number 
oThisBar = BarObject.ParentBar;
oThisStaff = oThisBar.ParentStaff;
oNextObj = null;
if (oThisStaff.BarCount = oThisBar.BarNumber) {
	return False;
} else {
	oNextBar = oThisStaff.NthBar(oThisBar.BarNumber + 1);
	oFirstObj = oNextBar.NthBarObject(0);
	if ((oFirstObj.Type = BarObject.Type) and
		 (oFirstObj.VoiceNumber = BarObject.VoiceNumber)) {
		oNextObj = oFirstObj;
	} else {
		if (BarObject.VoiceNumber = 0) {
			oNextObj = NextV0Item(oFirstObj, True);
		} else {
			oNextObj = oFirstObj.NextItem(BarObject.VoiceNumber, BarObject.Type);
		}
	}
}
return oNextObj;
}"
	MathAbs "(NumericValue) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return absolute value of numeric value
nNumeric = 0 + NumericValue;
if (nNumeric < 0) {
	return -nNumeric;
} else {
	return nNumeric;
}
}"
	FoundMatchedVoicePitch "(TiePitch, ThisEntry) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return true if there is an entry that follows this one, at the same time,
// that matches the voice for the current tie pitch.

// Make sure we are looking for a specific voice
nVoice = TieStartVoice[TiePitch];
if (nVoice = 0) {
	return False;
}

// Do we have an object in the target voice?
oNextVoiceObj = ThisEntry.NextItem(nVoice, 'NoteRest');
if (oNextVoiceObj = null) {
	return False;
}

// Is it at the same position as the current entry?
if (oNextVoiceObj.Position != ThisEntry.Position) {
	return False;
}

// OK, now we loop through and see if we have a note
// at the correct pitch.
for each oNote in oNextVoiceObj {
	if (oNote.Pitch = TiePitch) {
		return True;
	}
}

// If nothing found, return False.
return False;
}"
	IgnoreNestedTuplets
	XmlLineNumber
	Wait "(Seconds) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Wait until a certain number of seconds has elapsed.
// Probably not super-accurate, but should be good enough
// for our needs.

fWaiting = True;
nTimerNumber = 1742;
Sibelius.ResetStopWatch(nTimerNumber);
while (fWaiting) {
	nSeconds = Sibelius.GetElapsedSeconds(nTimerNumber);
	if (nSeconds >= Seconds) {
		fWaiting = False;
	}
}
}"
	WriteComment "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get the position based on object Dx and Dy properties.
sPosition = GetPosition(BarObject.Dx, BarObject.Dy, False);
nOffset = (BarObject.Position * 3) - MeasureCounter;

// Write a comment as an invisible other-direction element.
// So far just using the Text and UserName variables, not TimeStamp.
sComment = BarObject.UserName & ': ' & BarObject.Text;
WriteXML('<direction>', 3);
WriteXML('<direction-type>', 4);
WriteXML('<other-direction print-object=\'no\' ' & sPosition & 
		  '>' & sComment & '</other-direction>', 5);
WriteXML('</direction-type>', 4);
if (nOffset != 0) {
	WriteXML('<offset>' & nOffset & '</offset>', 4);
}
nVoice = GetVoice(BarObject, StaffNumber);
if (nVoice > 0) {
	WriteXML('<voice>' & nVoice & '</voice>', 4);
}
if (StaffNumber > 0) {
	WriteXML('<staff>' & StaffNumber & '</staff>', 4);
}
WriteXML('</direction>', 3);
}"
	WriteGuitarScaleDiagram "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

if (ShowTrace) {
	trace('Found guitar scale diagram in bar ' & BarCounter & 
	      ', position ' & BarObject.Position);
}

// Cannot write it, so log the error
LogError('Unexported guitar scale diagram', 3);
}"
	IsoDate "(ThisDate) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return an ISO date in YYYY-MM-DD format from
// a Sibelius DateTime object.

sYear = '' & ThisDate.Year;
sMonth = '' & ThisDate.Month;
if (Length(sMonth) = 1) {
	sMonth = '0' & sMonth;
}
sDay = '' & ThisDate.DayOfMonth;
if (Length(sDay) = 1) {
	sDay = '0' & sDay;
}
return sYear & '-' & sMonth & '-' & sDay;
}"
	SetStaffDetailsPrintObject "(ThisScore, MeasureNumber, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

nHighStaff = StaffNumber + Staves;

if (ThisScore.FocusOnStaves) {
	// First check to see if we have focus on staves set,
	// in which case the focus on staves value sets the
	// visibility for the entire piece, overriding anything
	// in the Sibelius layout. This works with Sibelius 5.1
	// and later.

	for i = StaffNumber to nHighStaff {
		nStaff = i - StaffNumber + 1;
		if (MeasureNumber > 1) {
			StaffDetailsPrintObject[nStaff] = '';
		} else {
			oStaff = ThisScore.NthStaff(i);
			if (oStaff.ShowInFocusOnStaves) {
				StaffDetailsPrintObject[nStaff] = '';
				if (FirstVisibleStaffForFirstMeasure = 0) {
					FirstVisibleStaffForFirstMeasure = StaffNumber;
				}
			} else {
				StaffDetailsPrintObject[nStaff] = ' print-object=\'no\'';
			}
		}
	}
} else {
	// Check to see if we have a change in hidden staff for
	// each staff in a part, and set the global variables
	// accordingly. Only works starting with Sibelius 6.

	for i = StaffNumber to nHighStaff {
		oStaff = ThisScore.NthStaff(i);
		oBar = oStaff.NthBar(MeasureNumber);
		nStaff = i - StaffNumber + 1;
		fWasHidden = False;
		if (HiddenStaff[nStaff]) {
			fWasHidden = True;
		}
		fChange = False;
		sPrintObjectValue = '';
		if (fWasHidden and (not oBar.OnHiddenStave)) {
			fChange = True;
			HiddenStaff[nStaff] = False;
			StaffDetailsPrintObject[nStaff] = ' print-object=\'yes\'';
		} else {
			if (oBar.OnHiddenStave and (not fWasHidden)) {
				fChange = True;
				sPrintObjectValue = 'no';
				HiddenStaff[nStaff] = True;
				StaffDetailsPrintObject[nStaff] = ' print-object=\'no\'';
			}
		}
		// If nothing has changed, leave the HiddenStaff value
		// alone, but make sure we reset the print object value
		// in case we made the change in the previous measure.
		if (not fChange) {
			StaffDetailsPrintObject[nStaff] = '';
		}
		// Check if this is the first visible staff in measure 1.
		if ((MeasureNumber = 1) and (not oBar.OnHiddenStave)) {
			if (FirstVisibleStaffForFirstMeasure = 0) {
				FirstVisibleStaffForFirstMeasure = StaffNumber;
			}
		}
	}
}

// Duplicate first staff details into element 0 of array
// since we may look for the first staff two different ways.
StaffDetailsPrintObject[0] = '' & StaffDetailsPrintObject[1];	
}"
	IsHarpPedals "(NewText, NewFamily) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Check to see if this string in this font represents a
// harp pedal mark. Return True if harp pedals, False othewise.
// This then lets WriteHarpPedals proceed without worrying
// about pedal error checking in the multi-part MusicXML element.

// Handle any music text font, old or new, as a harp pedal font.
fFontOK = IsMusicTextFont(NewFamily);
if (not fFontOK) {
	fFontOK = IsOldMusicTextFont(NewFamily);
	if (not fFontOK) {
		return False;
	}
}

// Harp pedal characters are L, M, N, and O. O is the
// pedal dividing line character. We take a strict view
// of the harp pedals - it must be 8 characters long, 
// with the O in the fourth character and nowhere else.
if (Length(NewText) = 8) {
	for i = 0 to 8 {
		nChar = Asc(CharAt(NewText, i));
		if ((nChar < 76) or (nChar > 79)) {
			return False;
		} else { 
			if (i = 3) {
				if (nChar != 79) {
					return False;
				}
			} else {
				if (nChar = 79) {
					return False;
				}
			}
		}
	}
	// Everything matches, so return True
	return True;
} else {
	return False;
}
}"
	WriteHarpPedals "(NewText, NewFamily, NewPosition, NewColor, FirstIndent) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Write out MusicXML harp-pedals direction. This is only
// called after having done an IsHarpPedals check, so do
// not do redundant error checking here.

// Harp pedals use music text font, so always write the family
// as it is not a default font.
sFamily = ' font-family=\'' & NewFamily & '\'';

WriteXML('<harp-pedals' & sFamily & NewPosition & NewColor & '>', 0 + FirstIndent);

// Harp pedal characters are L, M, and N. Skip the dividing 
// character O which is the fourth character in the string.
for i = 0 to 8 {
	if (i != 3) {
		WriteXML('<pedal-tuning>', 1 + FirstIndent);
		WriteXML('<pedal-step>' & HarpPedalSteps[i] & '</pedal-step>',
				  2 + FirstIndent);
		sChar = CharAt(NewText, i);
		sPedalAlter = '' & '0';
		if (sChar = 'L') {
			sPedalAlter = '-1';
		} else {
			if (sChar = 'N') {
				sPedalAlter = 1;
			}
		}
		WriteXML('<pedal-alter>' & sPedalAlter & '</pedal-alter>',
				  2 + FirstIndent);
		WriteXML('</pedal-tuning>', 1 + FirstIndent);
	}
}
WriteXML('</harp-pedals>', 0 + FirstIndent);
}"
	UseTranspose
	UseVoice
	WriteTranspose "() {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Write out transpose or for-part element. Checking for
// whether we need to write one is done by the caller. If we
// did it here, we would risk writing an empty attributes
// element, which is invalid MusicXML.

fUseForPart = False;
if ((not UseTranspose) and ((TransposeDiatonic != 0) or (TransposeChromatic != 0))) {
	fUseForPart = True;
}

if (fUseForPart) {
	WriteXML('<for-part>', 4);
	if (Length(TransposePartClefStyleId) > 0) {
		oDictClefData = ParseClefStyleId(TransposePartClefStyleId, 0, False);
		sSign = oDictClefData['sign'];
		nLine = oDictClefData['line'];
		nOctaveChange = oDictClefData['clef-octave-change'];
		if (Length(sSign) > 0) {
			WriteXML('<part-clef>', 5);
			WriteXML('<sign>' & sSign & '</sign>', 6);
			if (nLine != 0) {
				WriteXML('<line>' & nLine & '</line>', 6);
			}
			if (nOctaveChange != 0) {
				WriteXML('<clef-octave-change>' & nOctaveChange & 
						  '</clef-octave-change>', 6);
			}
			WriteXML('</part-clef>', 5);
		}
	}
	WriteXML('<part-transpose>', 5);
	WriteXML('<diatonic>' & TransposeDiatonic & '</diatonic>', 6);
	WriteXML('<chromatic>' & TransposeChromatic & '</chromatic>', 6);
	if ((TransposeOctaveChange != 0) or (TransposeOctaveChange != LastTransposeOctaveChange)) {
		WriteXML('<octave-change>' & TransposeOctaveChange & '</octave-change>', 6);
	}
	WriteXML('</part-transpose>', 5);
	WriteXML('</for-part>', 4);
} else {
	WriteXML('<transpose>', 4);
	WriteXML('<diatonic>' & TransposeDiatonic & '</diatonic>', 5);
	WriteXML('<chromatic>' & TransposeChromatic & '</chromatic>', 5);
	if ((TransposeOctaveChange != 0) or (TransposeOctaveChange != LastTransposeOctaveChange)) {
		WriteXML('<octave-change>' & TransposeOctaveChange & '</octave-change>', 5);
	}
	WriteXML('</transpose>', 4);
}

// Save these values for comparison
LastTransposeDiatonic = 0 + TransposeDiatonic;
LastTransposeChromatic = 0 + TransposeChromatic;
LastTransposeOctaveChange = 0 + TransposeOctaveChange;

// If we do not have a MusicXML transposition in place,
// do not use written pitch even if transpose is OK.
// This check is needed for octave-transposing clefs.
WrittenDiatonicPitchOK = ((TransposeChromatic != 0) or 
						  (TransposeDiatonic != 0) or 
						  (TransposeOctaveChange != 0));
}"
	LastTransposeChromatic
	LastTransposeDiatonic
	LastTransposeOctaveChange
	CheckOctaveChange "(OctaveChange, BarNumber, Position, StaffNumber, BarObject) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// See if this octave transposition is already covered by
// a clef-octave-change element. Return True if the octave-change
// element is needed in a transpose element, False if not.

// If we have a clef at the same position, like at the start
// of a staff, then we can just check and exit.
if ((BarNumber = LastClefBar[StaffNumber]) and 
	(Position = LastClefPosition[StaffNumber])) {
	return (OctaveChange != LastClefOctaveChange[StaffNumber]);
}

// Otherwise we need to figure out what our clef is. If we have
// an InstrumentChange bar object, see if we have a simultaneous 
// clef object.
oSamePositionClef = null;
if (BarObject != null) {
	oClef = BarObject.NextItem(0, 'Clef');
	if (oClef != null)  {
		if (oClef.Position = BarObject.Position) {
			oSamePositionClef = oClef;
		} else {
			oClef = BarObject.PreviousItem(0, 'Clef');
			if (oClef != null) {
				if (oClef.Position = BarObject.Position) {
					oSamePositionClef = oClef;
				}
			}  
		}
	}
}

if (oSamePositionClef != null) {
	sClef = oSamePositionClef.TransposingClefStyleId;
	switch (OctaveChange) {
		case (-1) {
			return ((sClef != 'clef.treble.down.8') and
					(sClef != 'clef.bass.down.8') and
					(sClef != 'clef.tenor.down.8'));
		}
		case (1) {
			return ((sClef != 'clef.treble.up.8') and
					(sClef != 'clef.bass.up.8'));
		}
		case (2) {
			return ((sClef != 'clef.treble.up.15') and
					(sClef != 'clef.bass.up.15'));
		}
		default {
			return True;
		}
	}
} else {
	// This is not really correct if the clef position
	// is ahead of the instrument change position, but
	// it is the best we can do in this unusual situation.
	return (OctaveChange != LastClefOctaveChange[StaffNumber]);
}
}"
	WrittenDiatonicPitchOK
	TransposeSharps "(OriginalSharps, InstrumentType) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return the fifths value to use for a transposed key signature,
// given the diatonic and chromatic transposition values.

// Normalize diatonic and chromatic values of InstrumentType.
nChromatic = InstrumentType.ChromaticTransposition;
nDiatonic = InstrumentType.DiatonicTransposition;

while (nChromatic > 11) {
	nChromatic = nChromatic - 12;
}
while (nChromatic < -11) {
	nChromatic = nChromatic + 12;
}
while (nDiatonic > 6) {
	nDiatonic = nDiatonic - 7;
}
while (nDiatonic < -6) {
	nDiatonic = nDiatonic + 7;
}

// A sharps value of -8 reflects an open key signature
// that does not transpose. And chromatic values of 0
// do not affect the key either, as in octave transpositions.
if ((OriginalSharps = -8) or (nChromatic = 0)) {
	return OriginalSharps;
}

// Get the default alteration based on the chromatic
// value, then adjust for some chromatic / diatonic
// combinations.
nSharpsAlter = ChromaticKeySig[11 + nChromatic];

// For debugging unusual diatonic / chromatic combinations
if (ShowTrace) {
	trace('TransposeSharps pre-adjustment: OriginalSharps = ' & OriginalSharps & 
		  ', chromatic = ' & InstrumentType.ChromaticTransposition & 
		  ', diatonic = ' & InstrumentType.DiatonicTransposition & 
		  ', nChromatic = ' & nChromatic & ', nDiatonic = ' & nDiatonic & 
		  ', nSharpsAlter = ' & nSharpsAlter);
}

// Combinations can just use a 0 to 11 chromatic range.
if (nChromatic < 0) {
	nChromatic = nChromatic + 12;
}
switch (nChromatic) {
	case (1) {
		if (nDiatonic = 0) {
			nSharpsAlter = -7;
		}
	}
	case (6) {
		if ((nDiatonic = -3) or (nDiatonic = 4)) {
			nSharpsAlter = 6;
		}
	}
	case (10) {
		if (nDiatonic = -2) {
			nSharpsAlter = -10;
		}
	}
	case (11) {
		if (nDiatonic = 0) {
			nSharpsAlter = 7;
		}
	}

}

nNewSharps = nSharpsAlter + OriginalSharps;

// Always simplify if more than 7 sharps/flats.
// Simplify 7 sharps/flats only if transposing.

nMaxSharps = 7;
if (nSharpsAlter != 0) {
	nMaxSharps = 6;
}
while (nNewSharps < (-nMaxSharps)) {
	nNewSharps = nNewSharps + 12;
}
while (nNewSharps > nMaxSharps) {
	nNewSharps = nNewSharps - 12;
}

return nNewSharps;
}"
	LastKeyFifths
	LastKeyMode
	KeyFifths
	KeyMode
	CheckKey "(BarObject, InstrumentType) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Check the new key signature, taking transposition from
// instrument type into account. Since instrument changes
// can happen mid-measure, affecting the MusicXML key
// signature (though not the Sibelius key signature),
// we need to divide checking key signature values from
// writing key signature values. Otherwise we could end
// up with an empty attributes element, which is invalid
// MusicXML.

nSharps = BarObject.Sharps;
sMode = '';
// A sharps value of -8 is open key vs. F-flat major.
if (BarObject.Sharps = -8) {
	nSharps = 0;
	sMode = 'none';
} else {
	if (BarObject.Major) {
		sMode = 'major';
	} else {
		sMode = 'minor';
	}
	// If transposed instrument, adjust accordingly.
	// Open key does not transpose, so not needed there.
	if (UseTranspose and (InstrumentType != null)) {
		nSharps = TransposeSharps(nSharps, InstrumentType);
	}
}

// Save in global variables for testing
KeyFifths = nSharps;
KeyMode = '' & sMode;
}"
	CheckTranspose "(InstrumentType, BarNumber, Position, StaffNumber, BarObject) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Transpose element does not have a staff number.
// For saving and comparing, we change a 0 staff
// number (e.g. single-staff instrument) to a
// staff number of 1.
nStaffNumber = 0 + StaffNumber;
if (nStaffNumber = 0) {
	nStaffNumber = 1;
}

// MusicXML has an octave-change value for transpositions
// that Sibelius does not, so normalize Sibelius values
// accounting for octave transposition.
nChromatic = InstrumentType.ChromaticTransposition;
nDiatonic = InstrumentType.DiatonicTransposition;
nOctaveChange = 0;
while (nChromatic > 11) {
	nChromatic = nChromatic - 12;
	nOctaveChange = nOctaveChange + 1;
}
while (nChromatic < -11) {
	nChromatic = nChromatic + 12;
	nOctaveChange = nOctaveChange - 1;
}
while (nDiatonic > 6) {
	nDiatonic = nDiatonic - 7;
}
while (nDiatonic < -6) {
	nDiatonic = nDiatonic + 7;
}

// Sibelius transposition includes both the MusicXML
// transpose and clef-octave-change elements. Do not
// write the transpose element if the clef-octave-change
// element is already handling the transposition.

// If this transposition is covered by a clef-octave-change,
// exit unless we need to reset an earlier transposition.
// In that case, do not write the octave change element;
// reset it to zero instead.

if ((nOctaveChange != 0) and (nChromatic = 0) and (nDiatonic = 0)) {
	fUseOctaveChange = CheckOctaveChange(nOctaveChange, BarNumber, Position, 
											  nStaffNumber, BarObject);
	if (not fUseOctaveChange) {
		nOctaveChange = 0;
	}
}

// Check to see if the clef is different in concert score
// and transposed parts. We will only use this value with
// a concert score.
sPartClefStyleId = '';
if (InstrumentType.ConcertClefStyleId != InstrumentType.TransposingClefStyleId) {
	sPartClefStyleId = InstrumentType.TransposingClefStyleId;
} 

// OK, we are ready to save the transpose values to global
// variables for use by the WriteTranspose method.
TransposeDiatonic = nDiatonic;
TransposeChromatic = nChromatic;
TransposeOctaveChange = nOctaveChange;
TransposePartClefStyleId = sPartClefStyleId;
}"
	TransposeChromatic
	TransposeDiatonic
	TransposeOctaveChange
	TransposePartClefStyleId
	ConvertNewLines "(OldText, UseComma) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Convert Sibelius \n\ newlines into CRLFs or commas.
// Used for the InstrumentChanges and HeaderInstrumentChanges
// wildcards where we have new line characters that need to
// be converted into either XML newlines or commas.

sNewText = '';
nOldLength = Length(OldText);
nDoNotAdd = 0;

// Watch out for idiosyncratic for syntax (stops before last value)
for i = 0 to nOldLength {
	c = CharAt(OldText, i);
	if (nDoNotAdd > 0) {
		// Part of a \n\ newline sequence, so
		// do not add to the new string.
		nDoNotAdd = nDoNotAdd - 1;
	} else {
		if (('\\' = c) and (i < nOldLength - 2)) {
			c2 = CharAt(OldText, i + 1);
			c3 = CharAt(OldText, i + 2);
			if ((('n' = c2) or ('N' = c2)) and ('\\' = c3)) {
				// We have the \n\ or \N\ newline, so convert to
				// a CR or comma. Do not add any of this 3-character
				// sequence later in the loop. The \N\ newline is
				// new in Sibelius 7.
				nDoNotAdd = 2;
				if (UseComma) {
					sNewText = sNewText & ',';
				} else {
					sNewText = sNewText & Chr(13);
				}
			} else {
				sNewText = sNewText & c;
			}
		} else {
			sNewText = sNewText & c;
		}
	}
}
return sNewText;
}"
	ConvertPartName "(OldPartName) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Convert flats in Sibelius part names into text.
// We need this for metadata and error messages,
// not for regular exported text where the flats get
// handled later.

oSubstrings = SplitString(OldPartName, '^', False);
sNewText = JoinStrings(oSubstrings, '');

return sNewText;
}"
	WriteMeasureRepeatStop "(StaffNumber, WriteAttributes) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Write the end point of a measure-repeat element. If the
// WriteAttributes parameter is true, write the attributes
// element too. Otherwise this is being paired with another
// measure-repeat element, so the caller will write the
// attributes element.

nMeasureRepeatStaff = 0 + StaffNumber;
if (nMeasureRepeatStaff = 0) {
	nMeasureRepeatStaff = 1;
}

// If there is no measure-repeat to stop, exit now.
if (LastMeasureRepeat[nMeasureRepeatStaff] = 0) {
	return 0;
}

sMeasureStyleNumber = '';
if (StaffNumber > 0) {
	sMeasureStyleNumber = ' number=\'' & StaffNumber & '\'';
}

if (WriteAttributes) {
	WriteXML('<attributes>', 3);
}
WriteXML('<measure-style' & sMeasureStyleNumber & '>', 4);
WriteXML('<measure-repeat type=\'stop\'>' & 
		  LastMeasureRepeat[nMeasureRepeatStaff] & 
		  '</measure-repeat>', 5);
WriteXML('</measure-style>', 4);
if (WriteAttributes) {
	WriteXML('</attributes>', 3);
}
LastMeasureRepeat[nMeasureRepeatStaff] = 0;
}"
	WriteChordSymbolFrame "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Starting in Sibelius 6, we can use the semantics of 
// recognized chord symbols to export chord symbols much
// more accurately than with the old string-based lookup.
// Make sure that we can handle the symbol before writing
// it. If we write the chord symbol, return True; else
// return False.

// Get the position based on object Dx and Dy properties.
// If showing the frame, only use Dx for harmony and save
// Dy for the frame object itself, as it refers to the
// bottom of the frame.
sPosition = '';
if (BarObject.FrameIsVisible) {
	sPosition = GetXPosition(BarObject.Dx, False);
} else {
	sPosition = GetPosition(BarObject.Dx, BarObject.Dy, False);
}
sColor = GetColor(BarObject);
nOffset = (BarObject.Position * 3) - MeasureCounter;

// Now try to parse the recognized chord symbol
sRootStep = '';
nRootAlter = 0;
sBassStep = '';
nBassAlter = 0;
sKind = '';
fKindSpecified = False;
sParseText = '';
fHarmonyFailed = False;
fParenDegrees = False;
fParenChord = False;
fSymbols = False;
KindText = '';
EmptyKindText = False;
StackDegrees = False;
DegreeCount = 0;
DegreesToPrint = 0;
sRootStepText = '';
sBassStepText = '';
fFormatOK = True;
fRootFormatOK = True;

// See if it is all parenthesized. Brackets are big parens in chord 
// fonts, so bracket-degrees is not an option here. Parentheses do
// not start at the beginning of the string if just degrees or just
// the suffix are parenthesized, so do not test on just right paren.
sChordText = BarObject.ChordNameAsStyledString;
sOrigChordText = sChordText;
if (CharAt(sChordText, 0) = '(') {
	if (CharAt(sChordText, Length(sChordText) - 1) = ')') {
		fParenChord = True;
	}
}

// Now determine what our suffix text is. It should be the
// SuffixText variable, but when importing from earlier Sibelius
// versions, this can be set to pretty random values in 6.0.
// So if SuffixText is not empty and not a substring of 
// the ChordNameAsStyledString variable, use suffix text
// grabbing logic similar to what we do for exporting legacy
// chord text.

fSuffixTextNeeded = True;
if (Length(BarObject.SuffixText) = 0) {
	fSuffixTextNeeded = False;
} else {
	if (IndexOf(BarObject.SuffixText, sOrigChordText) >= 0) {
		fSuffixTextNeeded = False;
	}
}
if (fSuffixTextNeeded) {
	sGetSuffixText = GetSuffix(sChordText);
	if (sGetSuffixText = GetSuffixFailValue) {
		fFormatOK = False;
	} else {
		sChordText = sGetSuffixText;
	}
	// What we are guessing on the suffix is good enough
	// for symbols and parentheses, but not for root and
	// bass formatting.
	fRootFormatOK = False;
} else {
	sChordText = BarObject.SuffixText;
}
// Use this version for determining root/bass text
sSuffixText = sChordText;

// @todo Add checks for fFormatOK before adding formatting to XML

// See if there are any symbols in suffix text by splitting.
// If there is more than one child, then at least one symbol
// is present somewhere in the string. Do a similar test for
// stacked degrees by looking for the stacked degrees characters
// in the chord font (just the degrees, not the accidentals).
if (fFormatOK) {
	oSplitSymbols = SplitString(sChordText, '^-+ºØ', False);
	oSplitStack = SplitString(sChordText, 'ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔ', False);
} else {
	// Back up to the whole chord text, including root and bass,
	// if we do not have reliable suffix text. Risks confusion
	// from funky root/bass alteration, but better than not using it.
	oSplitSymbols = SplitString(sOrigChordText, '^-+ºØ', False);
	oSplitStack = SplitString(sChordText, 'ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔ', False);
}
if (oSplitSymbols.NumChildren > 1) {
	fSymbols = True;
}
if (oSplitStack.NumChildren > 1) {
	StackDegrees = True;
}

// We want to be able to output at least some text
// attributes for the kind and other elements.
// Substitute any of the Sibelius chord font
// characters that can be translated directly into
// text: e.g. things like sus and ma, not things like
// the modified chord degree symbols.
sChordText = NormalizeChordFontText(sChordText);

if (ShowTrace) {
	trace('Chord in bar ' & BarObject.ParentBar.BarNumber & ': styled string = \'' &
		  BarObject.ChordNameAsStyledString & '\', suffix text = \'' &
		  BarObject.SuffixText & '\', plain text = \'' & BarObject.ChordNameAsPlainText &
		  '\', normalized suffix = \'' & sChordText & '\''); 
}

// Now get rid of all spaces - regular, non breaking, tab, newlines
sChordText = RemoveSpaces(sChordText, 0);

// Now strip the parens out of the chord symbol string.
sParenChordText = sChordText;
oSplitParens = SplitString(sChordText, '()[]', True);
sChordText = JoinStrings(oSplitParens, '');
// Store kind text and parenthesization. We do not use
// kind text if we are using symbols, nor if the we do
// not have correctly formatted text.
if (fFormatOK and (oSplitParens.NumChildren > 1)) {
	fParenDegrees = True;
	// We have to be sure the root is OK, or we can get
	// the kind text wrong.
	if (fRootFormatOK and (not fSymbols)) {
		oSplitInternalParen = SplitString(sParenChordText, '([', False);
		KindText = '' & oSplitInternalParen[0];
	}
}

// Now look for the root and bass. By using the parsed properties,
// we can now export chords that use different language styles
// (e.g., H, Do). However, these styles are not available in
// separate parsed out fields, so we will not export their
// appearance correctly yet.

nDiatonicRoot = BarObject.DiatonicRoot;
nChromaticRoot = BarObject.ChromaticRoot;
if (UseTranspose) {
	nDiatonicRoot = BarObject.TransposingDiatonicRoot;
	nChromaticRoot = BarObject.TransposingChromaticRoot;
}
while (nDiatonicRoot < 0) {
	nDiatonicRoot = nDiatonicRoot + 7;
}
while (nDiatonicRoot > 6) {
	nDiatonicRoot = nDiatonicRoot - 7;
}
sRootStep = DiatonicToStep[nDiatonicRoot];
sRootStepText = sRootStep;
nRootAlter = GetXmlAlter(nDiatonicRoot, nChromaticRoot);
fNoPrintRootAlter = False;

// Only output bass if BassAsString has some data

if ((Length(BarObject.BassAsString) > 0) and 
	(BarObject.BassAsString != BarObject.RootAsString)) {
	nDiatonicBass = BarObject.DiatonicBass;
	nChromaticBass = BarObject.ChromaticBass;
	if (UseTranspose) {
		nDiatonicBass = BarObject.TransposingDiatonicBass;
		nChromaticBass = BarObject.TransposingChromaticBass;
	}
	while (nDiatonicBass < 0) {
		nDiatonicBass = nDiatonicBass + 7;
	}
	while (nDiatonicRoot > 6) {
		nDiatonicBass = nDiatonicBass - 7;
	}
	sBassStep = DiatonicToStep[nDiatonicBass];
	sBassStepText = sBassStep;
	nBassAlter = GetXmlAlter(nDiatonicBass, nChromaticBass);
}
fNoPrintBassAlter = False;

// See if we have different root and/or bass text due to
// German, solfege, or other chord styles.
if (fRootFormatOK) {
	if (Length(sSuffixText) > 0) {
		nRootEnds = IndexOf(sSuffixText, sOrigChordText);
	} else {
		nRootEnds = IndexOf('/', sOrigChordText);
		if (nRootEnds < 0) {
			nRootEnds = Length(sOrigChordText);
		}
	}
	if ((nRootEnds >= 0) and (nRootAlter >= -1) and (nRootAlter <= 1)) {
		sRootInScore = Substring(sOrigChordText, 0, nRootEnds);
		sRootInScore = NormalizeChordFontText(sRootInScore);
		switch (nRootAlter) {
			case (-1) {
				if (Substring(sRootInScore, Length(sRootInScore) - 1) = 'b') {
					sRootStepText = Substring(sRootInScore, 0, Length(sRootInScore) - 1);
				} else {
					sRootStepText = sRootInScore;
					fNoPrintRootAlter = True;
				}
			}
			case (0) {
				sRootStepText = sRootInScore;
			}
			case (1) {
				if (Substring(sRootInScore, Length(sRootInScore) - 1) = '#') {
					sRootStepText = Substring(sRootInScore, 0, Length(sRootInScore) - 1);
				} else {
					sRootStepText = sRootInScore;
					fNoPrintRootAlter = True;
				}
			}
		}
		if ((Length(sBassStep) > 0) and (nBassAlter >= -1) and (nBassAlter <= 1)) {	
			sBassInScore = 
				Substring(sOrigChordText, nRootEnds + Length(sSuffixText));
			sBassInScore = NormalizeChordFontText(sBassInScore);
			if (Length(sBassInScore) > 1) {
				// Remove the slash
				sBassInScore = Substring(sBassInScore, 1);
				switch (nBassAlter) {
					case (-1) {
						if (Substring(sBassInScore, Length(sBassInScore) - 1) = 'b') {
							sBassStepText =
								Substring(sBassInScore, 0, Length(sBassInScore) - 1);
						} else {
							sBassStepText = sBassInScore;
							fNoPrintBassAlter = True;
						}
					}
					case (0) {
						sBassStepText = sBassInScore;
					}
					case (1) {
						if (Substring(sBassInScore, Length(sBassInScore) - 1) = '#') {
							sBassStepText =
								Substring(sBassInScore, 0, Length(sBassInScore) - 1);
						} else {
							sBassStepText = sBassInScore;
							fNoPrintBassAlter = True;
						}
					}
				}
			}
		}
	}	
}

// Now go through the Suffixes array to assemble the kind
// and the degrees.
sNewKind = '';
oSuffixes = BarObject.CopyOutSuffixes();
for i = 0 to oSuffixes.NumChildren {
	sSuffixElement = '' & oSuffixes[i];
	nElementLength = Length(sSuffixElement);
	switch (nElementLength) {
		case (1) {
			sNewKind = ParseSuffixElement1(sSuffixElement, sKind);
		}
		case (2) {
			sNewKind = ParseSuffixElement2(sSuffixElement, sKind);
		}
		case (3) {
			sNewKind = ParseSuffixElement3(sSuffixElement, sKind);
		}
		case (4) {
			sNewKind = ParseSuffixElement4(sSuffixElement, sKind);
		}
		case (5) {
			sNewKind = ParseSuffixElement5(sSuffixElement, sKind);
		}
		case (6) {
			sNewKind = ParseSuffixElement6(sSuffixElement, sKind);
		}
		case (7) {
			sNewKind = ParseSuffixElement7(sSuffixElement, sKind);
		}
		// default {
		//	trace('Unrecognized suffix element ' & sSuffixElement);
		// }
	}
	if (Length(sNewKind) = 0) {
		fHarmonyFailed = True;
	} else {
		sKind = sNewKind;
	}
}

// If we do not have a valid harmony element, quit and try
// again by parsing the text of the symbol vs. the component
// elements of the symbol.
if (fHarmonyFailed) {
	// !!! For debugging
	if (ShowTrace) {
		trace('Could not parse chord ' & sChordText & ', suffix count = ' & 
			  oSuffixes.NumChildren);
	 	for j = 0 to oSuffixes.NumChildren {
			trace('Suffix ' & j & ': ' & oSuffixes[j]);
	 	}
	}
	return False;
}

// If we can parse the chord, write it out as a harmony element.
if (BarObject.FrameIsVisible) {
	WriteXML('<harmony print-frame=\'yes\' ' & sPosition & sColor & '>', 3);
} else {
	WriteXML('<harmony print-frame=\'no\' ' & sPosition & sColor & '>', 3);
}

// Write the root, including alternate root text if needed
WriteXML('<root>', 4);
if (sRootStep != sRootStepText) {
	WriteXML('<root-step text=\'' & sRootStepText & '\'>' & sRootStep & 
			 '</root-step>', 5);
} else {
	WriteXML('<root-step>' & sRootStep & '</root-step>', 5);
}
if (nRootAlter != 0) {
	if (fNoPrintRootAlter) {
		WriteXML('<root-alter print-object=\'no\'>' & nRootAlter & '</root-alter>', 5);
	} else {
		WriteXML('<root-alter>' & nRootAlter & '</root-alter>', 5);
	}
}
WriteXML('</root>', 4);

sDegreesHow = '';
if (fParenDegrees) {
	sDegreesHow = ' parentheses-degrees=\'yes\'';
}
if (StackDegrees) {
	sDegreesHow = sDegreesHow & ' stack-degrees=\'yes\'';
}
if (fSymbols) {
	WriteXML('<kind use-symbols=\'yes\'' & sDegreesHow & '>' & sKind & '</kind>', 4);
} else {
	// If there are no degrees to print, then the whole chord text
	// is the kind text if the root formatting is OK.
	if (DegreesToPrint = 0) {
		KindText = sChordText;
	}
	if (EmptyKindText) {
		KindText = '';
	}
	// We know the kind text if there are either parenthesized
	// degrees, if there are no degrees to print, or in special
	// cases where we have assigned the text.
	if (fRootFormatOK and (fParenDegrees or (DegreesToPrint = 0) or 
						   (Length(KindText) > 0) or EmptyKindText)) {
		WriteXML('<kind text=\'' & KindText & '\'' & 
				 sDegreesHow & '>' & sKind & '</kind>', 4);
	} else {
		WriteXML('<kind' & sDegreesHow & '>' & sKind & '</kind>', 4);
	}
}

// Write the bass if present, including altered text if needed
if (Length(sBassStep) > 0) {
	WriteXML('<bass>', 4);
	if (sBassStep != sBassStepText) {
		WriteXML('<bass-step text=\'' & sBassStepText & '\'>' & sBassStep & 
				 '</bass-step>', 5);
	} else {
		WriteXML('<bass-step>' & sBassStep & '</bass-step>', 5);
	}
	if (nBassAlter != 0) {
		if (fNoPrintBassAlter) {
			WriteXML('<bass-alter print-object=\'no\'>' & nBassAlter &
					 '</bass-alter>', 5);
		} else {
			WriteXML('<bass-alter>' & nBassAlter & '</bass-alter>', 5);
		}
	}
	WriteXML('</bass>', 4);
}

for di = 0 to DegreeCount {
	if (fFormatOK and (not (DegreePrints[di]))) {			
		WriteXML('<degree print-object=\'no\'>', 4);
	} else {
		WriteXML('<degree>', 4);
	}
	// Add text attributes for degree type and value if present.
	// If we have one of these set, print both so we can distinguish
	// between 2 and add2, for example.
	sDegreeValueText = '';
	sDegreeTypeText = '';
	if (fFormatOK and (DegreePrints[di])) {
		sDegreeValueText = '' & DegreeValueTexts[di];
		sDegreeTypeText = '' & DegreeTypeTexts[di];
		if ((Length(sDegreeValueText) > 0) or (Length(sDegreeTypeText) > 0)) {
			sDegreeValueText = ' text=\'' & sDegreeValueText & '\'';
			sDegreeTypeText = ' text=\'' & sDegreeTypeText & '\'';
		}
	}
	WriteXML('<degree-value' & sDegreeValueText & '>' & DegreeValues[di] &
			 '</degree-value>', 5);
	WriteXML('<degree-alter>' & DegreeAlters[di] & '</degree-alter>', 5);
	WriteXML('<degree-type' & sDegreeTypeText & '>' & DegreeTypes[di] &
			 '</degree-type>', 5);
	WriteXML('</degree>', 4);
}

// Sibelius 5.2 adds full support for reading guitar frame data.
if (BarObject.FrameIsVisible) {
	WriteFrame(BarObject);
}

// Write the offset and staff elements as needed for
// either the harmony or direction element.
if (nOffset != 0) {
	WriteXML('<offset>' & nOffset & '</offset>', 4);
}
if (fParenChord or BarObject.CueSize) {
	sLevelAttributes = '';
	if (fParenChord) {
		sLevelAttributes = sLevelAttributes & ' parentheses=\'yes\'';
	}
	if (BarObject.CueSize) {
		sLevelAttributes = sLevelAttributes & ' size=\'cue\'';
	}
	WriteXML('<level' & sLevelAttributes & '/>', 4);
}
if (StaffNumber > 0) {
	WriteXML('<staff>' & StaffNumber & '</staff>', 4);
}

// Now end the harmony element and return.
WriteXML('</harmony>', 3);
return True;
}"
	StackDegrees
	ParseChordText1 "(ParseText, UseSymbols) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Parse 1-character chord text into kind and degrees.

sKind = '';
switch (ParseText) {
	case ('-') {
		sKind = 'minor';
	}
	case ('^') {
		// If we have a standalone triangle symbol,
		// interpret it as a major-seventh. In other
		// cases we treat the triangle as meaning
		// major rather than major-seventh. Usage of
		// this symbol is not consistent across 
		// musical communities.
		if (UseSymbols) {
			sKind = 'major-seventh';
		} else {
			sKind = 'major';
		}
	}
	case ('+') {
		sKind = 'augmented';
	}
	case ('º') {
		sKind = 'diminished';
	}
	case ('Ø') {
		sKind = 'half-diminished';
	}
	case ('7') {
		sKind = 'dominant';
	}
	case ('9') {
		sKind = 'dominant-ninth';
	}
	case ('6') {
		sKind = 'major-sixth';
	}
	case ('5') {
		sKind = 'pedal';
		AddDegree(5, 'add', 0, False);
	}
	case ('2') {
		sKind = 'major';
		AddDegree(2, 'add', 0, False);
	}
	case ('4') {
		sKind = 'major';
		AddDegree(4, 'add', 0, False);
	}
}
return sKind;
}"
	ParseChordText2 "(ParseText, UseSymbols) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Parse 2-character chord text into kind and degrees.

sKind = '';
switch (ParseText) {
	case ('^7') {
		sKind = 'major-seventh';
	}
	case ('^9') {
		sKind = 'major-ninth';
	}
	case ('^6') {
		sKind = 'major-sixth';
	}
	case ('-7') {
		sKind = 'minor-seventh';
	}
	case ('-9') {
		sKind = 'minor-ninth';
	}
	case ('-6') {
		sKind = 'minor-sixth';
	}
	case ('11') {
		sKind = 'dominant-11th';
	}
	case ('13') {
		sKind = 'dominant-13th';
	}
	case ('69') {
		sKind = 'major-sixth';
		AddDegree(9, 'add', 0, False);
	}
	case ('nc') {
		sKind = 'none';
	}
	case ('7º') {
		sKind = 'diminished-seventh';
	}
	case ('º7') {
		sKind = 'diminished-seventh';
	}
	case ('7+') {
		sKind = 'augmented-seventh';
	}
	case ('+7') {
		sKind = 'augmented-seventh';
	}
	case ('9+') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', 0, False);
	}
	case ('+9') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', 0, False);
	}
	case ('b5') {
		sKind = 'major';
		EmptyKindText = True;
		AddDegree(5, 'alter', -1, True);
	}
	case ('#4') {
		sKind = 'major';
		EmptyKindText = True;
		AddDegree(4, 'add', 1, True);
	}
	case ('-2') {
		sKind = 'minor';
		AddDegree(2, 'add', 0, False);
	}
	case ('-4') {
		sKind = 'minor';
		AddDegree(4, 'add', 0, False);
	}
	case ('-^') {
		sKind = 'major-minor';
	}
	case ('Ø7') {
		sKind = 'half-diminished';
	}
	case ('Ø9') {
		sKind = 'half-diminished';
		AddDegree(9, 'add', 0, True);
	}
}
return sKind;
}"
	ParseChordText3 "(ParseText, UseSymbols) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Parse 3-character chord text into kind and degrees.

sKind = '';
switch (ParseText) {
	case ('^11') {
		sKind = 'major-11th';
	}
	case ('^13') {
		sKind = 'major-13th';
	}
	case ('-11') {
		sKind = 'minor-11th';
	}
	case ('-13') {
		sKind = 'minor-13th';
	}
	case ('7b5') {
		sKind = 'dominant';
		AddDegree(5, 'alter', -1, True);
	}
	case ('7b6') {
		sKind = 'dominant';
		AddDegree(6, 'add', -1, True);
	}
	case ('7b9') {
		sKind = 'dominant';
		AddDegree(9, 'add', -1, True);
	}
	case ('7#5') {
		sKind = 'dominant';
		AddDegree(5, 'alter', 1, True);
	}
	case ('7#9') {
		sKind = 'dominant';
		AddDegree(9, 'add', 1, True);
	}
	case ('711') {
		sKind = 'dominant';
		AddDegree(11, 'add', 0, True);
	}
	case ('713') {
		sKind = 'dominant';
		AddDegree(13, 'add', 0, True);
	}
	case ('6/9') {
		sKind = 'major-sixth';
		AddDegree(9, 'add', 0, False);
	}
	case ('^69') {
		sKind = 'major-sixth';
		AddDegree(9, 'add', 0, False);
	}
	case ('-69') {
		sKind = 'minor-sixth';
		AddDegree(9, 'add', 0, False);
	}
	case ('sus') {
		sKind = 'suspended-fourth';
	}
	case ('9#5') {
		sKind = 'dominant-ninth';
		AddDegree(5, 'alter', 1, True);
	}
	case ('9b5') {
		sKind = 'dominant-ninth';
		AddDegree(5, 'alter', -1, True);
	}
	case ('no3') {
		sKind = 'major';
		EmptyKindText = True;
		AddDegree(3, 'subtract', 0, True);
		AddDegreeText('3', 'no');
	}
	case ('+^7') {
		sKind = 'augmented';
		AddDegree(7, 'add', 1, True);
	}
	case ('-^7') {
		sKind = 'major-minor';
		AddDegree(7, 'alter', 0, True);
		AddDegreeText('7', '');
		AddDegreeSymbol('major');
	}
	case ('-M7') {
		sKind = 'major-minor';
	}
	case ('-+7') {
		sKind = 'major-minor';
	}
	case ('+^9') {
		sKind = 'augmented';
		AddDegree(7, 'add', 1, True);
		AddDegree(9, 'add', 0, True);
	}
	case ('+b9') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', -1, False);
	}
	case ('+#9') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', 1, False);
	}
	case ('º^7') {
		sKind = 'diminished';
		AddDegree(7, 'add', 1, True);
	}
	case ('Øb9') {
		sKind = 'half-diminished';
		AddDegree(9, 'add', -1, True);
	}
	case ('ped') {
		sKind = 'pedal';
	}
	case ('^#5') {
		// In this case we treat the symbol
		// as a major seventh vs. plain major.
		if (UseSymbols) {
			sKind = 'major-seventh';
			AddDegree(5, 'alter', 1, True);
		} else {
			sKind = 'augmented';
		}
	}
	case ('7âÅ') {
		sKind = 'dominant';
		AddDegree(11, 'add', 1, True);
		AddDegree(9, 'add', -1, True);
		StackDegrees = True;
	}
	case ('7âÄ') {
		sKind = 'dominant';
		AddDegree(9, 'add', 1, True);
		AddDegree(9, 'add', -1, True);
		StackDegrees = True;
	}
	case ('7åÅ') {
		sKind = 'dominant';
		AddDegree(11, 'add', 1, True);
		AddDegree(9, 'add', 1, True);
		StackDegrees = True;
	}
	case ('7áÆ') {
		sKind = 'dominant';
		AddDegree(13, 'add', -1, True);
		AddDegree(9, 'add', -1, True);
		StackDegrees = True;
	}
	case ('7äÆ') {
		sKind = 'dominant';
		AddDegree(13, 'add', -1, True);
		AddDegree(9, 'add', 1, True);
		StackDegrees = True;
	}
	case ('7àÆ') {
		sKind = 'dominant';
		AddDegree(13, 'add', 0, True);
		AddDegree(9, 'add', -1, True);
		StackDegrees = True;
	}
	case ('7áÁ') {
		sKind = 'dominant';
		AddDegree(9, 'add', -1, True);
		AddDegree(5, 'alter', -1, True);
		StackDegrees = True;
	}
	case ('7äÁ') {
		sKind = 'dominant';
		AddDegree(9, 'add', -1, True);
		AddDegree(5, 'alter', 1, True);
		StackDegrees = True;
	}
	case ('7åÁ') {
		sKind = 'dominant';
		AddDegree(9, 'add', 1, True);
		AddDegree(5, 'alter', 1, True);
		StackDegrees = True;
	}
	case ('9äÈ') {
		sKind = 'dominant-ninth';
		AddDegree(13, 'add', -1, True);
		AddDegree(11, 'add', 1, True);
	}
	case ('13Å') {
		sKind = 'dominant-13th';
		AddDegree(11, 'alter', 0, True);
		AddDegree(9, 'alter', 0, True);
		StackDegrees = True;
	}
	case ('alt') {
		// As close an approximation as we
		// can automate at this point.
		sKind = 'dominant';
		AddDegree(5, 'subtract', 0, False);
		AddDegree(9, 'add', -1, False);
		AddDegree(9, 'add', 1, False);
		AddDegree(11, 'add', 1, False);
		AddDegree(13, 'alter', -1, False);
	}
}
return sKind;
}"
	ParseChordText4 "(ParseText, UseSymbols, ParenDegrees) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Parse 4-character chord text into kind and degrees.

sKind = '';
switch (ParseText) {
	case ('n.c.') {
		sKind = 'none';
	}
	case ('sus4') {
		sKind = 'suspended-fourth';
	}
	case ('sus2') {
		sKind = 'suspended-second';
	}
	case ('^6/9') {
		sKind = 'major-sixth';
		AddDegree(9, 'add', 0, False);
	}
	case ('-6/9') {
		sKind = 'minor-sixth';
		AddDegree(9, 'add', 0, False);
	}
	case ('^7b5') {
		sKind = 'major-seventh';
		AddDegree(5, 'alter', -1, True);
	}
	case ('^7#5') {
		sKind = 'major-seventh';
		AddDegree(5, 'alter', 1, True);
	}
	case ('^7b9') {
		sKind = 'major-seventh';
		AddDegree(9, 'add', -1, True);
	}
	case ('^7#9') {
		sKind = 'major-seventh';
		AddDegree(9, 'add', 1, True);
	}
	case ('-7b5') {
		sKind = 'minor-seventh';
		AddDegree(5, 'alter', -1, True);
	}
	case ('-7#5') {
		sKind = 'minor-seventh';
		AddDegree(5, 'alter', 1, True);
	}
	case ('^9b5') {
		sKind = 'major-ninth';
		AddDegree(5, 'alter', -1, True);
	}
	case ('^9#5') {
		sKind = 'major-ninth';
		AddDegree(5, 'alter', 1, True);
	}
	case ('-9b5') {
		sKind = 'minor-ninth';
		AddDegree(5, 'alter', -1, True);
	}
	case ('-9#5') {
		sKind = 'minor-ninth';
		AddDegree(5, 'alter', 1, True);
	}
	case ('-7b9') {
		sKind = 'minor-seventh';
		AddDegree(9, 'add', -1, True);
	}
	case ('-7#9') {
		sKind = 'minor-seventh';
		AddDegree(9, 'add', 1, True);
	}
	case ('-7âÅ') {
		sKind = 'minor-seventh';
		AddDegree(11, 'add', 1, True);
		AddDegree(9, 'add', -1, True);
		StackDegrees = True;
	}
	case ('-711') {
		sKind = 'minor-seventh';
		AddDegree(11, 'add', 0, True);
	}
	case ('7b13') {
		sKind = 'dominant';
		AddDegree(13, 'add', -1, True);
	}
	case ('7#11') {
		sKind = 'dominant';
		AddDegree(11, 'add', 1, True);
	}
	case ('^#11') {
		sKind = 'major-seventh';
		AddDegree(11, 'add', 1, True);
	}
	case ('^713') {
		sKind = 'major-seventh';
		AddDegree(13, 'add', 0, True);
	}
	case ('11#5') {
		sKind = 'dominant-11th';
		AddDegree(5, 'alter', 1, True);
	}
	case ('11b5') {
		sKind = 'dominant-11th';
		AddDegree(5, 'alter', -1, True);
	}
	case ('11#9') {
		sKind = 'dominant-11th';
		AddDegree(9, 'alter', 1, True);
	}
	case ('11b9') {
		sKind = 'dominant-11th';
		AddDegree(9, 'alter', -1, True);
	}
	case ('11âÄ') {
		sKind = 'dominant-11th';
		AddDegree(9, 'alter', 1, True);
		AddDegree(9, 'add', -1, True);
		StackDegrees = True;
	}
	case ('11äÄ') {
		sKind = 'dominant-11th';
		AddDegree(9, 'alter', -1, True);
		AddDegree(9, 'add', 1, True);
		StackDegrees = True;
	}
	case ('13b5') {
		sKind = 'dominant-13th';
		AddDegree(5, 'alter', -1, True);
	}
	case ('13#5') {
		sKind = 'dominant-13th';
		AddDegree(5, 'alter', 1, True);
	}
	case ('13b9') {
		sKind = 'dominant-13th';
		AddDegree(9, 'alter', -1, True);
	}
	case ('13#9') {
		sKind = 'dominant-13th';
		AddDegree(9, 'alter', 1, True);
	}
	case ('13âÅ') {
		sKind = 'dominant-13th';
		AddDegree(11, 'alter', 1, True);
		AddDegree(9, 'alter', -1, True);
		StackDegrees = True;
	}
	case ('13åÅ') {
		sKind = 'dominant-13th';
		AddDegree(11, 'alter', 1, True);
		AddDegree(9, 'alter', 1, True);
		StackDegrees = True;
	}
	case ('7alt') {
		// As close an approximation as we
		// can automate at this point.
		sKind = 'dominant';
		AddDegree(5, 'subtract', 0, False);
		AddDegree(9, 'add', -1, False);
		AddDegree(9, 'add', 1, False);
		AddDegree(11, 'add', 1, False);
		AddDegree(13, 'add', -1, False);
	}
	case ('7sus') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 0, False);
	}
	case ('9sus') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 0, False);
		AddDegree(9, 'add', 0, False);
	}
	case ('2sus') {
		sKind = 'suspended-fourth';
		AddDegree(2, 'add', 0, False);
	}
	case ('6sus') {
		sKind = 'suspended-fourth';
		AddDegree(6, 'add', 0, False);
	}
	case ('4sus') {
		sKind = 'suspended-fourth';
	}
	case ('69b5') {
		sKind = 'major-sixth';
		if (not ParenDegrees) {
			KindText = '69';
		}
		AddDegree(9, 'add', 0, False);
		AddDegree(5, 'alter', -1, True);
	}
	case ('7+11') {
		sKind = 'augmented-seventh';
		AddDegree(11, 'add', 0, True);
	}
	case ('add2') {
		sKind = 'major';
		EmptyKindText = True;
		AddDegree(2, 'add', 0, True);
		AddDegreeText('2', 'add');
	}
	case ('add4') {
		sKind = 'major';
		EmptyKindText = True;
		AddDegree(4, 'add', 0, True);
		AddDegreeText('4', 'add');
			}
	case ('add9') {
		sKind = 'major';
		EmptyKindText = True;
		AddDegree(9, 'add', 0, True);
		AddDegreeText('9', 'add');
	}
	case ('9#11') {
		sKind = 'dominant-ninth';
		AddDegree(11, 'add', 1, True);
	}
	case ('9b13') {
		sKind = 'dominant-ninth';
		AddDegree(13, 'add', -1, True);
	}
	case ('+ma7') {
		sKind = 'augmented';
		AddDegree(7, 'add', 1, True);
	}
	case ('+ma9') {
		sKind = 'augmented';
		AddDegree(7, 'add', 1, True);
		AddDegree(9, 'add', 0, True);
	}
	case ('-ma7') {
		sKind = 'major-minor';
	}
	case ('7ºb9') {
		sKind = 'diminished-seventh';
		AddDegree(9, 'add', -1, True);
	}
	case ('º7b9') {
		sKind = 'diminished-seventh';
		AddDegree(9, 'add', -1, True);
	}
	case ('7º#9') {
		sKind = 'diminished-seventh';
		AddDegree(9, 'add', 1, True);
	}
	case ('º7#9') {
		sKind = 'diminished-seventh';
		AddDegree(9, 'add', 1, True);
	}
	case ('7º^7') {
		sKind = 'diminished-seventh';
		AddDegree(7, 'alter', 2, True);
	}
	case ('º7^7') {
		sKind = 'diminished-seventh';
		AddDegree(7, 'alter', 2, True);
	}
	case ('+7^7') {
		sKind = 'augmented-seventh';
		AddDegree(7, 'alter', 1, True);
	}
	case ('7+^7') {
		sKind = 'augmented-seventh';
		AddDegree(7, 'alter', 1, True);
	}
	case ('7+b9') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', -1, True);
	}
	case ('+7b9') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', -1, True);
	}
	case ('7+#9') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', 1, True);
	}
	case ('+7#9') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', 1, True);
	}
	case ('7+11') {
		sKind = 'augmented-seventh';
		AddDegree(11, 'add', 0, True);
	}
	case ('+7âÅ') {
		sKind = 'augmented-seventh';
		AddDegree(11, 'add', 1, True);
		AddDegree(9, 'add', -1, True);
		StackDegrees = True;
	}
	case ('7+âÅ') {
		sKind = 'augmented-seventh';
		AddDegree(11, 'add', 1, True);
		AddDegree(9, 'add', -1, True);
		StackDegrees = True;
	}
	case ('+7åÅ') {
		sKind = 'augmented-seventh';
		AddDegree(11, 'add', 1, True);
		AddDegree(9, 'add', 1, True);
		StackDegrees = True;
	}
	case ('7+åÅ') {
		sKind = 'augmented-seventh';
		AddDegree(11, 'add', 1, True);
		AddDegree(9, 'add', 1, True);
		StackDegrees = True;
	}
	case ('+7áÁ') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', -1, True);
		AddDegree(5, 'alter', -1, True);
		StackDegrees = True;
	}
	case ('7+áÁ') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', -1, True);
		AddDegree(5, 'alter', -1, True);
		StackDegrees = True;
	}
	case ('+7âÁ') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', 1, True);
		AddDegree(5, 'alter', -1, True);
		StackDegrees = True;
	}
	case ('7+âÁ') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', 1, True);
		AddDegree(5, 'alter', -1, True);
		StackDegrees = True;
	}
	case ('^9äÀ') {
		sKind = 'major-ninth';
		AddDegree(5, 'alter', -1, True);
		AddDegree(5, 'add', 1, True);
		StackDegrees = True;
	}
	case ('^9âÀ') {
		sKind = 'major-ninth';
		AddDegree(5, 'alter', 1, True);
		AddDegree(5, 'add', -1, True);
		StackDegrees = True;
	}
	case ('-9äÀ') {
		sKind = 'minor-ninth';
		AddDegree(5, 'alter', -1, True);
		AddDegree(5, 'add', 1, True);
		StackDegrees = True;
	}
	case ('-9âÀ') {
		sKind = 'minor-ninth';
		AddDegree(5, 'alter', 1, True);
		AddDegree(5, 'add', -1, True);
		StackDegrees = True;
	}
	case ('Ø7b9') {
		sKind = 'half-diminished';
		AddDegree(9, 'add', -1, True);
	}
	case ('-9^7') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
	}
	case ('-9M7') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
	}
	case ('-^11') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 0, False);
	}
	case ('-M11') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 0, False);
	}
	case ('-^13') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 0, False);
		AddDegree(13, 'add', 0, False);
	}
	case ('-M13') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 0, False);
		AddDegree(13, 'add', 0, False);
	}
	case ('2no3') {
		sKind = 'suspended-second';
	}
	case ('7no3') {
		sKind = 'dominant';
		AddDegree(3, 'subtract', 0, True);
		AddDegreeText('3', 'no');
	}
	case ('alt.') {
		// As close an approximation as we
		// can automate at this point.
		sKind = 'dominant';
		AddDegree(5, 'subtract', 0, False);
		AddDegree(9, 'add', -1, False);
		AddDegree(9, 'add', 1, False);
		AddDegree(11, 'add', 1, False);
		AddDegree(13, 'alter', -1, False);
	}
}
return sKind;
}"
	ParseChordText5 "(ParseText, UseSymbols, ParenDegrees) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Parse 5-character chord text into kind and degrees.

sKind = '';
switch (ParseText) {
	case ('7b9b5') {
		sKind = 'dominant';
		AddDegree(9, 'add', -1, True);
		AddDegree(5, 'alter', -1, True);
				}
	case ('7b5b9') {
		sKind = 'dominant';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', -1, True);
	}
	case ('7#9b5') {
		sKind = 'dominant';
		AddDegree(9, 'add', 1, True);
		AddDegree(5, 'alter', -1, True);
	}
	case ('7b5#9') {
		sKind = 'dominant';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('7b9#5') {
		sKind = 'dominant';
		AddDegree(9, 'add', -1, True);
		AddDegree(5, 'alter', 1, True);
	}
	case ('7b5âÄ') {
		sKind = 'dominant';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', 1, True);
		AddDegree(9, 'add', -1, True);
	}
	case ('7#5b9') {
		sKind = 'dominant';
		AddDegree(5, 'alter', 1, True);
		AddDegree(9, 'add', -1, True);
	}
	case ('7#5áÁ') {
		sKind = 'dominant';
		AddDegree(5, 'alter', 1, True);
		AddDegree(9, 'add', -1, True);
		AddDegree(5, 'add', -1, True);
	}
	case ('7#9#5') {
		sKind = 'dominant';
		AddDegree(9, 'add', 1, True);
		AddDegree(5, 'alter', 1, True);
	}
	case ('7#5#9') {
		sKind = 'dominant';
		AddDegree(5, 'alter', 1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('7#9b9') {
		sKind = 'dominant';
		AddDegree(9, 'add', 1, True);
		AddDegree(9, 'add', -1, True);
	}
	case ('7b9#9') {
		sKind = 'dominant';
		AddDegree(9, 'add', -1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('7#5âÅ') {
		sKind = 'dominant';
		AddDegree(5, 'alter', 1, False);
		AddDegree(11, 'add', 1, True);
		AddDegree(9, 'add', -1, True);
		StackDegrees = True;
	}
	case ('7#5åÅ') {
		sKind = 'dominant';
		AddDegree(5, 'alter', 1, False);
		AddDegree(11, 'add', 1, True);
		AddDegree(9, 'add', 1, True);
		StackDegrees = True;
	}
	case ('7alt.') {
		// As close an approximation as we
		// can automate at this point.
		sKind = 'dominant';
		AddDegree(5, 'subtract', 0, False);
		AddDegree(9, 'add', -1, False);
		AddDegree(9, 'add', 1, False);
		AddDegree(11, 'add', 1, False);
		AddDegree(13, 'add', -1, False);
	}
	case ('7add4') {
		sKind = 'dominant';
		AddDegree(4, 'add', 0, True);
		AddDegreeText('4', 'add');
	}
	case ('7sus4') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 0, False);
	}
	case ('9sus4') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 0, False);
		AddDegree(9, 'add', 0, False);
	}
	case ('^9sus') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 1, False);
		AddDegree(9, 'add', 0, False);
	}
	case ('susb9') {
		sKind = 'suspended-fourth';
		AddDegree(9, 'add', -1, True);
	}
	case ('6sus4') {
		sKind = 'suspended-fourth';
		AddDegree(6, 'add', 0, False);
	}
	case ('7sus2') {
		sKind = 'suspended-second';
		AddDegree(7, 'add', 0, False);
	}
	case ('6sus2') {
		sKind = 'suspended-second';
		AddDegree(6, 'add', 0, False);
	}
	case ('69sus') {
		sKind = 'suspended-fourth';
		AddDegree(6, 'add', 0, False);
		AddDegree(9, 'add', 0, False);
	}
	case ('11sus') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 0, False);
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 0, False);
	}
	case ('13sus') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 0, False);
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 0, False);
		AddDegree(13, 'add', 0, False);
	}
	case ('5sus4') {
		sKind = 'suspended-fourth';
	}
	case ('-7sus') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 0, False);
	}
	case ('^7#11') {
		sKind = 'major-seventh';
		AddDegree(11, 'add', 1, True);
	}
	case ('7+#11') {
		sKind = 'augmented-seventh';
		AddDegree(11, 'add', 1, True);
	}
	case ('+7#11') {
		sKind = 'augmented-seventh';
		AddDegree(11, 'add', 1, True);
	}
	case ('6add9') {
		sKind = 'major-sixth';
		AddDegree(9, 'add', 0, True);
		AddDegreeText('9', 'add');
	}
	case ('^add2') {
		sKind = 'major';
		AddDegree(2, 'add', 0, True);
		AddDegreeText('2', 'add');
	}
	case ('^add4') {
		sKind = 'major';
		AddDegree(4, 'add', 0, True);
		AddDegreeText('4', 'add');
	}
	case ('^add9') {
		sKind = 'major';
		AddDegree(9, 'add', 0, True);
		AddDegreeText('9', 'add');
	}
	case ('-add2') {
		sKind = 'minor';
		AddDegree(2, 'add', 0, True);
		AddDegreeText('2', 'add');
	}
	case ('-add4') {
		sKind = 'minor';
		AddDegree(4, 'add', 0, True);
		AddDegreeText('4', 'add');
	}
	case ('-add9') {
		sKind = 'minor';
		AddDegree(9, 'add', 0, True);
		AddDegreeText('9', 'add');
	}
	case ('^9#11') {
		sKind = 'major-ninth';
		AddDegree(11, 'add', 1, True);
	}
	case ('-9#11') {
		sKind = 'minor-ninth';
		AddDegree(11, 'add', 1, True);
	}
	case ('69#11') {
		sKind = 'major-sixth';
		if (not ParenDegrees) {
			sKindText = '69';
		}
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 1, True);
	}	
	case ('6/9b5') {
		sKind = 'major-sixth';
		if (not ParenDegrees) {
			KindText = '69';
		}
		AddDegree(9, 'add', 0, False);
		AddDegree(5, 'alter', -1, True);
	}
	case ('-maj7') {
		sKind = 'major-minor';
	}
	case ('-maj9') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
	}
	case ('omit3') {
		sKind = 'major';
		EmptyKindText = True;
		AddDegree(3, 'subtract', 0, True);
		AddDegreeText('3', 'omit');
	}
	case ('omit5') {
		sKind = 'major';
		EmptyKindText = True;
		AddDegree(5, 'subtract', 0, True);
		AddDegreeText('5', 'omit');
	}
	case ('no3rd') {
		sKind = 'major';
		EmptyKindText = True;
		AddDegree(3, 'subtract', 0, True);
		AddDegreeText('3rd', 'no');
	}
	case ('add13') {
		sKind = 'major';
		EmptyKindText = True;
		AddDegree(13, 'add', 0, True);
		AddDegreeText('13', 'add');
	}
	case ('add#9') {
		sKind = 'major';
		EmptyKindText = True;
		AddDegree(9, 'add', 1, True);
		AddDegreeText('9', 'add');
	}
	case ('dim#9') {
		sKind = 'diminished';
		EmptyKindText = True;
		AddDegree(9, 'add', 1, True);
	}
	case ('#9b13') {
		sKind = 'major';
		EmptyKindText = True;
		AddDegree(9, 'add', 1, True);
		AddDegree(13, 'add', -1, True);
	}
	case ('b13#9') {
		sKind = 'major';
		EmptyKindText = True;
		AddDegree(13, 'add', -1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('b9b13') {
		sKind = 'major';
		EmptyKindText = True;
		AddDegree(9, 'add', -1, True);
		AddDegree(13, 'add', -1, True);
	}
	case ('b13b9') {
		sKind = 'major';
		EmptyKindText = True;
		AddDegree(13, 'add', -1, True);
		AddDegree(9, 'add', -1, True);
	}
	case ('11b13') {
		sKind = 'dominant-11th';
		AddDegree(13, 'add', -1, True);
	}
	case ('^11b9') {
		sKind = 'major-11th';
		AddDegree(9, 'alter', -1, True);
	}
	case ('^11#9') {
		sKind = 'major-11th';
		AddDegree(9, 'alter', 1, True);
	}
	case ('-11b5') {
		sKind = 'minor-11th';
		AddDegree(5, 'alter', -1, True);
	}
	case ('-11b9') {
		sKind = 'minor-11th';
		AddDegree(9, 'alter', -1, True);
	}
	case ('-11#9') {
		sKind = 'minor-11th';
		AddDegree(9, 'alter', 1, True);
	}
	case ('13#11') {
		sKind = 'dominant-13th';
		AddDegree(11, 'alter', 1, True);
	}
	case ('^13b9') {
		sKind = 'major-13th';
		AddDegree(9, 'alter', -1, True);
	}
	case ('^13#9') {
		sKind = 'major-13th';
		AddDegree(9, 'alter', 1, True);
	}
	case ('^13âÅ') {
		sKind = 'major-13th';
		AddDegree(11, 'alter', 1, True);
		AddDegree(9, 'alter', -1, True);
		StackDegrees = True;
	}
	case ('^13åÅ') {
		sKind = 'major-13th';
		AddDegree(11, 'alter', 1, True);
		AddDegree(9, 'alter', 1, True);
		StackDegrees = True;
	}
	case ('-13b9') {
		sKind = 'minor-13th';
		AddDegree(9, 'alter', -1, True);
	}
	case ('-13#9') {
		sKind = 'minor-13th';
		AddDegree(9, 'alter', 1, True);
	}
	case ('-13âÅ') {
		sKind = 'minor-13th';
		AddDegree(11, 'alter', 1, True);
		AddDegree(9, 'alter', -1, True);
		StackDegrees = True;
	}
	case ('-13åÅ') {
		sKind = 'minor-13th';
		AddDegree(11, 'alter', 1, True);
		AddDegree(9, 'alter', 1, True);
		StackDegrees = True;
	}
	case ('+maj7') {
		sKind = 'augmented';
		AddDegree(7, 'add', 1, True);
	}
	case ('+maj9') {
		sKind = 'augmented';
		AddDegree(7, 'add', 1, True);
		AddDegree(9, 'add', 0, True);
	}
	case ('9+#11') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 1, True);
	}
	case ('+9#11') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 1, True);
	}
	case ('ºadd2') {
		sKind = 'diminished';
		AddDegree(2, 'add', 0, True);
		AddDegreeText('2', 'add');
	}
	case ('+7ma7') {
		sKind = 'augmented-seventh';
		AddDegree(7, 'alter', 1, True);
	}
	case ('7+ma7') {
		sKind = 'augmented-seventh';
		AddDegree(7, 'alter', 1, True);
	}
	case ('+7âÁ') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', 1, True);
		AddDegree(5, 'alter', -1, True);
		StackDegrees = True;
	}
	case ('7ºma7') {
		sKind = 'diminished-seventh';
		AddDegree(7, 'alter', 2, True);
	}
	case ('º7ma7') {
		sKind = 'diminished-seventh';
		AddDegree(7, 'alter', 2, True);
	}
	case ('-^7#5') {
		sKind = 'major-minor';
		AddDegree(5, 'alter', 1, True);
	}
	case ('-M7#5') {
		sKind = 'major-minor';
		AddDegree(5, 'alter', 1, True);
	}
	case ('-+7#5') {
		sKind = 'major-minor';
		AddDegree(5, 'alter', 1, True);
	}
	case ('-11^7') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 0, False);
	}
	case ('-11M7') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 0, False);
	}
	case ('-9ma7') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
	}
	case ('-ma11') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 0, False);
	}
	case ('-ma13') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 0, False);
		AddDegree(13, 'add', 0, False);
	}
}
return sKind;
}"
	ParseChordText6 "(ParseText, UseSymbols, ParenDegrees) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Parse 6-character chord text into kind and degrees.

sKind = '';
switch (ParseText) {
	case ('11sus4') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 0, False);
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 0, False);
	}
	case ('13sus4') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 0, False);
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 0, False);
		AddDegree(13, 'add', 0, False);
	}
	case ('69sus4') {
		sKind = 'suspended-fourth';
		AddDegree(6, 'add', 0, False);
		AddDegree(9, 'add', 0, False);
	}
	case ('6/9sus') {
		sKind = 'suspended-fourth';
		AddDegree(6, 'add', 0, False);
		AddDegree(9, 'add', 0, False);
	}
	case ('^6add9') {
		sKind = 'major-sixth';
		AddDegree(9, 'add', 0, True);
		AddDegreeText('9', 'add');
	}
	case ('-6add9') {
		sKind = 'minor-sixth';
		AddDegree(9, 'add', 0, True);
		AddDegreeText('9', 'add');
	}
	case ('sus4b9') {
		sKind = 'suspended-fourth';
		AddDegree(9, 'add', -1, True);
	}
	case ('^9sus4') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 1, False);
		AddDegree(9, 'add', 0, False);
	}
	case ('7susb9') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 0, False);
		AddDegree(9, 'add', -1, True);
	}
	case ('-7sus4') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 0, False);
	}
	case ('-7add4') {
		sKind = 'minor-seventh';
		AddDegree(4, 'add', 0, True);
		AddDegreeText('4', 'add');
	}
	case ('6/9#11') {
		sKind = 'major-sixth';
		if (not ParenDegrees) {
			KindText = '6/9';
		}
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 1, True);
	}
	case ('^69#11') {
		sKind = 'major-sixth';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 1, True);
	}
	case ('-69#11') {
		sKind = 'minor-sixth';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 1, True);
	}
	case ('7b13#9') {
		sKind = 'dominant';
		AddDegree(13, 'add', -1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('7#9b13') {
		sKind = 'dominant';
		AddDegree(9, 'add', 1, True);
		AddDegree(13, 'add', -1, True);
	}
	case ('7#11#5') {
		sKind = 'dominant';
		AddDegree(11, 'add', 1, True);
		AddDegree(5, 'alter', 1, True);
	}
	case ('7#5#11') {
		sKind = 'dominant';
		AddDegree(5, 'alter', 1, True);
		AddDegree(11, 'add', 1, True);
	}
	case ('7#11#9') {
		sKind = 'dominant';
		AddDegree(11, 'add', 1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('7#9#11') {
		sKind = 'dominant';
		AddDegree(9, 'add', 1, True);
		AddDegree(11, 'add', 1, True);
	}
	case ('7#11b9') {
		sKind = 'dominant';
		AddDegree(11, 'add', 1, True);
		AddDegree(9, 'add', -1, True);
	}
	case ('7b9#11') {
		sKind = 'dominant';
		AddDegree(9, 'add', -1, True);
		AddDegree(11, 'add', 1, True);
	}
	case ('9#5#11') {
		sKind = 'dominant-ninth';
		AddDegree(5, 'alter', 1, True);
		AddDegree(11, 'add', 1, True);
	}
	case ('9#11#5') {
		sKind = 'dominant-ninth';
		AddDegree(11, 'add', 1, True);
		AddDegree(5, 'alter', 1, True);
	}
	case ('9b5#11') {
		sKind = 'dominant-ninth';
		AddDegree(5, 'alter', -1, True);
		AddDegree(11, 'add', 1, True);
	}
	case ('9#11b5') {
		sKind = 'dominant-ninth';
		AddDegree(11, 'add', 1, True);
		AddDegree(5, 'alter', -1, True);
	}
	case ('^9#5b5') {
		sKind = 'major-ninth';
		AddDegree(5, 'alter', 1, True);
		AddDegree(5, 'add', -1, True);
	}
	case ('^9b5#5') {
		sKind = 'major-ninth';
		AddDegree(5, 'alter', -1, True);
		AddDegree(5, 'add', 1, True);
	}
	case ('-9#5b5') {
		sKind = 'minor-ninth';
		AddDegree(5, 'alter', 1, True);
		AddDegree(5, 'add', -1, True);
	}
	case ('-9b5#5') {
		sKind = 'minor-ninth';
		AddDegree(5, 'alter', -1, True);
		AddDegree(5, 'add', 1, True);
	}
	case ('-7b5b9') {
		sKind = 'minor-seventh';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', -1, True);
	}
	case ('-7b9b5') {
		sKind = 'minor-seventh';
		AddDegree(9, 'add', -1, True);
		AddDegree(5, 'alter', -1, True);
	}
	case ('-7add4') {
		sKind = 'minor-seventh';
		AddDegree(4, 'add', 0, True);
		AddDegreeText('4', 'add');
	}
	case ('-9add4') {
		sKind = 'minor-ninth';
		AddDegree(4, 'add', 0, True);
		AddDegreeText('4', 'add');
	}
	case ('^13#11') {
		sKind = 'major-13th';
		AddDegree(11, 'alter', 1, True);
	}
	case ('-13#11') {
		sKind = 'minor-13th';
		AddDegree(11, 'alter', 1, True);
	}
	case ('7ïðîëÌ') {
		sKind = 'dominant';
		AddDegree(11, 'add', 1, True);
		AddDegree(9, 'add', 1, True);
		AddDegree(9, 'add', -1, True);
		StackDegrees = True;
	}
	case ('7ìðîëÍ') {
		sKind = 'dominant';
		AddDegree(13, 'add', -1, True);
		AddDegree(11, 'add', 1, True);
		AddDegree(9, 'add', -1, True);
		StackDegrees = True;
	}
	case ('7ìðñëÍ') {
		sKind = 'dominant';
		AddDegree(13, 'add', -1, True);
		AddDegree(11, 'add', 1, True);
		AddDegree(9, 'add', 1, True);
		StackDegrees = True;
	}
	case ('11b5b9') {
		sKind = 'dominant-11th';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'alter', -1, True);
	}
	case ('11b9b5') {
		sKind = 'dominant-11th';
		AddDegree(9, 'alter', -1, True);
		AddDegree(5, 'alter', -1, True);
	}
	case ('11b5#9') {
		sKind = 'dominant-11th';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'alter', 1, True);
	}
	case ('11#9b5') {
		sKind = 'dominant-11th';
		AddDegree(9, 'alter', 1, True);
		AddDegree(5, 'alter', -1, True);
	}
	case ('11#5#9') {
		sKind = 'dominant-11th';
		AddDegree(5, 'alter', 1, True);
		AddDegree(9, 'alter', 1, True);
	}
	case ('11#9#5') {
		sKind = 'dominant-11th';
		AddDegree(9, 'alter', 1, True);
		AddDegree(5, 'alter', 1, True);
	}
	case ('11b9#9') {
		sKind = 'dominant-11th';
		AddDegree(9, 'alter', -1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('11#9b9') {
		sKind = 'dominant-11th';
		AddDegree(9, 'alter', 1, True);
		AddDegree(9, 'add', -1, True);
	}
	case ('13b5b9') {
		sKind = 'dominant-13th';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'alter', -1, True);
	}
	case ('13b9b5') {
		sKind = 'dominant-13th';
		AddDegree(9, 'alter', -1, True);
		AddDegree(5, 'alter', -1, True);
	}
	case ('13b5àÅ') {
		sKind = 'dominant-13th';
		AddDegree(5, 'alter', -1, True);
		AddDegree(11, 'alter', 0, True);
		AddDegree(9, 'alter', -1, True);
		StackDegrees = True;
	}
	case ('13b5#9') {
		sKind = 'dominant-13th';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'alter', 1, True);
	}
	case ('13#9b5') {
		sKind = 'dominant-13th';
		AddDegree(9, 'alter', 1, True);
		AddDegree(5, 'alter', -1, True);
	}
	case ('13#5#9') {
		sKind = 'dominant-13th';
		AddDegree(5, 'alter', 1, True);
		AddDegree(9, 'alter', 1, True);
	}
	case ('13#9#5') {
		sKind = 'dominant-13th';
		AddDegree(9, 'alter', 1, True);
		AddDegree(5, 'alter', 1, True);
	}
	case ('+7b9b5') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', -1, True);
		AddDegree(5, 'alter', -1, True);
	}
	case ('7+b9b5') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', -1, True);
		AddDegree(5, 'alter', -1, True);
	}
	case ('+7b5b9') {
		sKind = 'augmented-seventh';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', -1, True);
	}
	case ('7+b5b9') {
		sKind = 'augmented-seventh';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', -1, True);
	}
	case ('+7#9b5') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', 1, True);
		AddDegree(5, 'alter', -1, True);
	}
	case ('7+#9b5') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', 1, True);
		AddDegree(5, 'alter', -1, True);
	}
	case ('+7b5#9') {
		sKind = 'augmented-seventh';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('7+b5#9') {
		sKind = 'augmented-seventh';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('+7maj7') {
		sKind = 'augmented-seventh';
		AddDegree(7, 'alter', 1, True);
	}
	case ('7+maj7') {
		sKind = 'augmented-seventh';
		AddDegree(7, 'alter', 1, True);
	}
	case ('7ºmaj7') {
		sKind = 'diminished-seventh';
		AddDegree(7, 'alter', 2, True);
	}
	case ('º7maj7') {
		sKind = 'diminished-seventh';
		AddDegree(7, 'alter', 2, True);
	}
	case ('7ºadd9') {
		sKind = 'diminished-seventh';
		AddDegree(9, 'add', 0, True);
		AddDegreeText('9', 'add');
	}
	case ('º7add9') {
		sKind = 'diminished-seventh';
		AddDegree(9, 'add', 0, True);
		AddDegreeText('9', 'add');
	}
	case ('-ma7#5') {
		sKind = 'major-minor';
		AddDegree(5, 'alter', 1, True);
	}
	case ('-9maj7') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
	}
	case ('-11ma7') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 0, False);
	}
	case ('-maj11') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 0, False);
	}
	case ('-maj13') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 0, False);
		AddDegree(13, 'add', 0, False);
	}
	case ('7ïðîëÏ') {
		sKind = 'dominant';
		AddDegree(9, 'add', 1, True);
		AddDegree(5, 'alter', -1, True);
		AddDegree(5, 'add', -1, True);
	}
	case ('7omit3') {
		sKind = 'dominant';
		AddDegree(3, 'subtract', 0, True);
		AddDegreeText('3', 'omit');
	}
	case ('7omit5') {
		sKind = 'dominant';
		AddDegree(5, 'subtract', 0, True);
		AddDegreeText('5', 'omit');
	}
	case ('add#13') {
		sKind = 'major';
		fEmptyKindText = True;
		AddDegree(13, 'add', 1, True);
		AddDegreeText('13', 'add');
	}
	case ('2no3rd') {
		sKind = 'suspended-second';
	}
	case ('^triad') {
		sKind = 'major';
	}
	case ('-triad') {
		sKind = 'minor';
	}
}
return sKind;
}"
	ParseChordText7 "(ParseText, UseSymbols) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Parse 7-character chord text into kind and degrees.

sKind = '';
switch (ParseText) {
	case ('^6/9#11') {
		sKind = 'major-sixth';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 1, True);
	}
	case ('-6/9#11') {
		sKind = 'minor-sixth';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 1, True);
	}
	case ('7b5b9#9') {
		sKind = 'dominant';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', -1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('7b5#9b9') {
		sKind = 'dominant';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', 1, True);
		AddDegree(9, 'add', -1, True);
	}
	case ('9b13#11') {
		sKind = 'dominant-ninth';
		AddDegree(13, 'add', -1, True);
		AddDegree(11, 'add', 1, True);
	}
	case ('9#11b13') {
		sKind = 'dominant-ninth';
		AddDegree(11, 'add', 1, True);
		AddDegree(13, 'add', -1, True);
	}
	case ('11b9#13') {
		sKind = 'dominant-11th';
		AddDegree(9, 'alter', -1, True);
		AddDegree(13, 'add', 1, True);
	}
	case ('11#13b9') {
		sKind = 'dominant-11th';
		AddDegree(13, 'add', 1, True);
		AddDegree(9, 'alter', -1, True);
	}
	case ('11b9b13') {
		sKind = 'dominant-11th';
		AddDegree(9, 'alter', -1, True);
		AddDegree(13, 'add', -1, True);
	}
	case ('11b13b9') {
		sKind = 'dominant-11th';
		AddDegree(13, 'add', -1, True);
		AddDegree(9, 'alter', -1, True);
	}
	case ('-11b9b5') {
		sKind = 'minor-11th';
		AddDegree(9, 'alter', -1, True);
		AddDegree(5, 'alter', -1, True);
	}
	case ('-11b5b9') {
		sKind = 'minor-11th';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'alter', -1, True);
	}
	case ('13b5#11') {
		sKind = 'dominant-13th';
		AddDegree(5, 'alter', -1, True);
		AddDegree(11, 'alter', 1, True);
	}
	case ('13#11b5') {
		sKind = 'dominant-13th';
		AddDegree(11, 'alter', 1, True);
		AddDegree(5, 'alter', -1, True);
	}
	case ('13b9#11') {
		sKind = 'dominant-13th';
		AddDegree(9, 'alter', -1, True);
		AddDegree(11, 'alter', 1, True);
	}
	case ('13#11b9') {
		sKind = 'dominant-13th';
		AddDegree(11, 'alter', 1, True);
		AddDegree(9, 'alter', -1, True);
	}
	case ('13#9#11') {
		sKind = 'dominant-13th';
		AddDegree(9, 'alter', 1, True);
		AddDegree(11, 'alter', 1, True);
	}
	case ('13#11#9') {
		sKind = 'dominant-13th';
		AddDegree(11, 'alter', 1, True);
		AddDegree(9, 'alter', 1, True);
	}
	case ('13ïðîëÌ') {
		sKind = 'dominant-13th';
		AddDegree(11, 'alter', 1, True);
		AddDegree(9, 'alter', 1, True);
		AddDegree(9, 'add', -1, True);
		StackDegrees = True;
	}
	case ('6/9sus4') {
		sKind = 'suspended-fourth';
		AddDegree(6, 'add', 0, False);
		AddDegree(9, 'add', 0, False);
	}
	case ('7sus4b9') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 0, False);
		AddDegree(9, 'add', -1, True);
	}
	case ('13susb9') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 0, False);
		AddDegree(9, 'add', -1, False);
		AddDegree(11, 'add', 0, False);
		AddDegree(13, 'add', 0, False);
	}
	case ('9sus#11') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 0, False);
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 1, True);
	}
	case ('^7#5#11') {
		sKind = 'major-seventh';
		AddDegree(5, 'alter', 1, True);
		AddDegree(11, 'add', 1, True);
	}
	case ('^7add13') {
		sKind = 'major-seventh';
		AddDegree(13, 'add', 0, True);
		AddDegreeText('13', 'add');
	}
	case ('-7add11') {
		sKind = 'minor-seventh';
		AddDegree(11, 'add', 0, True);
		AddDegreeText('11', 'add');
	}
	case ('-7add13') {
		sKind = 'minor-seventh';
		AddDegree(13, 'add', 0, True);
		AddDegreeText('13', 'add');
	}
	case ('+7#11b9') {
		sKind = 'augmented-seventh';
		AddDegree(11, 'add', 1, True);
		AddDegree(9, 'add', -1, True);
	}
	case ('7+#11b9') {
		sKind = 'augmented-seventh';
		AddDegree(11, 'add', 1, True);
		AddDegree(9, 'add', -1, True);
	}
	case ('+7b9#11') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', -1, True);
		AddDegree(11, 'add', 1, True);
	}
	case ('7+b9#11') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', -1, True);
		AddDegree(11, 'add', 1, True);
	}
	case ('+7#11#9') {
		sKind = 'augmented-seventh';
		AddDegree(11, 'add', 1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('7+#11#9') {
		sKind = 'augmented-seventh';
		AddDegree(11, 'add', 1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('+7#9#11') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', 1, True);
		AddDegree(11, 'add', 1, True);
	}
	case ('7+#9#11') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', 1, True);
		AddDegree(11, 'add', 1, True);
	}
	case ('-11maj7') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 0, False);
	}
	case ('11omit3') {
		sKind = 'dominant-11th';
		AddDegree(3, 'subtract', 0, True);
		AddDegreeText('3', 'omit');
	}
	case ('-maj7#5') {
		sKind = 'major-minor';
		AddDegree(5, 'alter', 1, True);
	}
	case ('-9^7#11') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 1, True);
	}
	case ('-9M7#11') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 1, True);
	}
	case ('-9#11^7') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 1, True);
	}
	case ('-9#11M7') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 1, True);
	}
	case ('-maj9b5') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(5, 'alter', -1, True);
	}
	case ('-maj9#5') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(5, 'alter', 1, True);
	}
	case ('-addb13') {
		sKind = 'minor';
		AddDegree(13, 'add', -1, True);
		AddDegreeText('13', 'add');
	}
}
return sKind;
}"
	ParseChordText8 "(ParseText, UseSymbols) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Parse 8-character chord text into kind and degrees.

sKind = '';
switch (ParseText) {
	case ('13sus4b9') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 0, False);
		AddDegree(9, 'add', -1, False);
		AddDegree(11, 'add', 0, False);
		AddDegree(13, 'add', 0, False);
	}
	case ('9sus4#11') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 0, False);
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 1, True);
	}
	case ('^7add#11') {
		sKind = 'major-seventh';
		AddDegree(11, 'add', 1, True);
		AddDegreeText('11', 'add');
	}
	case ('7áÆomit3') {
		sKind = 'dominant';
		AddDegree(13, 'add', -1, True);
		AddDegree(9, 'add', -1, True);
		AddDegree(3, 'subtract', 0, True);
		AddDegreeText('3', 'omit');
		StackDegrees = True;
	}
	case ('-7b5add2') {
		sKind = 'minor-seventh';
		AddDegree(5, 'alter', -1, True);
		AddDegree(2, 'add', 0, True);
		AddDegreeText('2', 'add');
	}
	case ('-7addb13') {
		sKind = 'minor-seventh';
		AddDegree(13, 'add', -1, True);
		AddDegreeText('13', 'add');
	}
	case ('-9ma7#11') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 1, True);
	}
	case ('-9#11ma7') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 1, True);
	}
	case ('^13b9#11') {
		sKind = 'major-13th';
		AddDegree(9, 'alter', -1, True);
		AddDegree(11, 'alter', 1, True);
	}
	case ('^13#11b9') {
		sKind = 'major-13th';
		AddDegree(11, 'alter', 1, True);
		AddDegree(9, 'alter', -1, True);
	}
	case ('^13#9#11') {
		sKind = 'major-13th';
		AddDegree(9, 'alter', 1, True);
		AddDegree(11, 'alter', 1, True);
	}
	case ('^13#11#9') {
		sKind = 'major-13th';
		AddDegree(11, 'alter', 1, True);
		AddDegree(9, 'alter', 1, True);
	}
	case ('-13b9#11') {
		sKind = 'minor-13th';
		AddDegree(9, 'alter', -1, True);
		AddDegree(11, 'alter', 1, True);
	}
	case ('-13#11b9') {
		sKind = 'minor-13th';
		AddDegree(11, 'alter', 1, True);
		AddDegree(9, 'alter', -1, True);
	}
	case ('-13#9#11') {
		sKind = 'minor-13th';
		AddDegree(9, 'alter', 1, True);
		AddDegree(11, 'alter', 1, True);
	}
	case ('-13#11#9') {
		sKind = 'minor-13th';
		AddDegree(11, 'alter', 1, True);
		AddDegree(9, 'alter', 1, True);
	}
	case ('+7b5b9#9') {
		sKind = 'augmented-seventh';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', -1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('+7b5#9b9') {
		sKind = 'augmented-seventh';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', -1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('+7b9bb#9') {
		sKind = 'augmented-seventh';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', -1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('+7b9#9b5') {
		sKind = 'augmented-seventh';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', -1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('+7#9b5b9') {
		sKind = 'augmented-seventh';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', -1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('+7#9b9b5') {
		sKind = 'augmented-seventh';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', -1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('7+b5b9#9') {
		sKind = 'augmented-seventh';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', -1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('7+b5#9b9') {
		sKind = 'augmented-seventh';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', -1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('7+b9bb#9') {
		sKind = 'augmented-seventh';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', -1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('7+b9#9b5') {
		sKind = 'augmented-seventh';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', -1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('7+#9b5b9') {
		sKind = 'augmented-seventh';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', -1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('7+#9b9b5') {
		sKind = 'augmented-seventh';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', -1, True);
		AddDegree(9, 'add', 1, True);
	}
	case ('13omit11') {
		sKind = 'dominant-13th';
		AddDegree(11, 'subtract', 0, True);
		AddDegreeText('11', 'omit');
	}
}
return sKind;
}"
	ParseChordText9 "(ParseText, UseSymbols) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Parse 9-character chord text into kind and degrees.

sKind = '';
switch (ParseText) {
	case ('^13omit11') {
		sKind = 'major-13th';
		AddDegree(11, 'subtract', 0, True);
		AddDegreeText('11', 'omit');
	}
	case ('-13omit11') {
		sKind = 'minor-13th';
		AddDegree(11, 'subtract', 0, True);
		AddDegreeText('11', 'omit');
	}
	case ('7susadd10') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 0, False);
		AddDegree(10, 'add', 0, True);
		AddDegreeText('10', 'add');
	}
	case ('-9maj7#11') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 1, True);
	}
	case ('-9#11maj7') {
		sKind = 'major-minor';
		AddDegree(9, 'add', 0, False);
		AddDegree(11, 'add', 1, True);
	}
	case ('+13omit11') {
		sKind = 'augmented-seventh';
		AddDegree(9, 'add', 0, False);
		AddDegree(13, 'add', 0, False);
	}
	case ('add#11#13') {
		sKind = 'major';
		EmptyKindText = True;
		AddDegree(11, 'add', 1, True);
		AddDegreeText('11', 'add');
		AddDegree(13, 'add', 1, True);
	}
	case ('º7addmaj7') {
		sKind = 'diminished-seventh';
		AddDegree(7, 'add', 1, True);
	}
}
return sKind;
}"
	ParseChordText10 "(ParseText, UseSymbols) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Parse 10-character chord text into kind and degrees.

sKind = '';
switch (ParseText) {
	case ('7susb9add3') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 0, False);
		AddDegree(9, 'add', -1, True);
		AddDegree(3, 'add', 0, True);
		AddDegreeText('3', 'add');
	}
	case ('7sus4add10') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 0, False);
		AddDegree(10, 'add', 0, True);
		AddDegreeText('10', 'add');
	}
	case ('7b5b9omit3') {
		sKind = 'dominant';
		AddDegree(5, 'alter', -1, True);
		AddDegree(9, 'add', -1, True);
		AddDegree(3, 'subtract', 0, True);
		AddDegreeText('3', 'omit');
	}
	case ('7b9b5omit3') {
		sKind = 'dominant';
		AddDegree(9, 'add', -1, True);
		AddDegree(5, 'alter', -1, True);
		AddDegree(3, 'subtract', 0, True);
		AddDegreeText('3', 'omit');
	}
	case ('13b9omit11') {
		sKind = 'dominant-13th';
		AddDegree(9, 'alter', -1, True);
		AddDegree(11, 'subtract', 0, True);
		AddDegreeText('11', 'omit');
	}
	case ('13#9omit11') {
		sKind = 'dominant-13th';
		AddDegree(9, 'alter', 1, True);
		AddDegreeText('11', 'omit');
		AddDegree(11, 'subtract', 0, True);
	}
	case ('13#5omit11') {
		sKind = 'dominant-13th';
		AddDegree(5, 'alter', 1, True);
		AddDegree(11, 'subtract', 0, True);
		AddDegreeText('11', 'omit');
	}
}
return sKind;
}"
	ParseChordText11 "(ParseText, UseSymbols) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Parse 11-character chord text into kind and degrees.

sKind = '';
switch (ParseText) {
	case ('7sus4b9add3') {
		sKind = 'suspended-fourth';
		AddDegree(7, 'add', 0, False);
		AddDegree(9, 'add', -1, True);
		AddDegree(3, 'add', 0, True);
		AddDegreeText('3', 'add');
	}
}
return sKind;
}"
	EmptyKindText
	KindText
	GetXmlAlter "(Diatonic, Chromatic) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return the MusicXML alter value given a diatonic/
// chromatic pair, as for the root and bass of a guitar
// frame chord symbol. Assume that the diatonic value 
// is normalized, but that the chromatic value is not.

// Normalize the chromatic value.
nChromatic = 0 + Chromatic;
while (nChromatic < 0) {
	nChromatic = nChromatic + 12;
}
while (nChromatic > 11) {
	nChromatic = nChromatic - 12;
}

nAlter = nChromatic - DiatonicToChromatic[Diatonic];
if (nAlter > 2) {
	nAlter = nAlter - 12;
} else {
	if (nAlter < -2) {
		nAlter = nAlter + 12;
	}
}
return nAlter;
}"
	ParseSuffixElement1 "(SuffixElement, OldKind) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Parse 1-character suffix element into kind and degrees.

sKind = '';
switch (SuffixElement) {
	case ('m') {
		if (Length(OldKind) = 0) {
			sKind = 'minor';
		}
	}
	case ('7') {
		if (Length(OldKind) = 0) {
			sKind = 'dominant';
		} else {
			if (OldKind = 'minor') {
				sKind = 'minor-seventh';
			} else {
				if (OldKind = 'major') {
					sKind = 'major-seventh';
				}
			}
		}
	}
	case ('9') {
		if (Length(OldKind) = 0) {
			sKind = 'dominant-ninth';
		} else {
			if (OldKind = 'minor') {
				sKind = 'minor-ninth';
			} else {
				if (OldKind = 'major') {
					sKind = 'major-ninth';
				}
			}
		}
	}
	case ('5') {
		if (Length(OldKind) = 0) {
			sKind = 'power';
		}
	}
	case ('6') {
		if (Length(OldKind) = 0) {
			sKind = 'major-sixth';
		} else {
			if (OldKind = 'minor') {
				sKind = 'minor-sixth';
			} else {
				if (OldKind = 'major') {
					sKind = 'major-sixth';
				}
			}
		}
	}
	case ('/') {
		// This is a repeat slash, so nothing to do here
		// @todo Double check that it is not a polychord too
		sKind = '';
	}
	default {
		sKind = '';
		// !!! For debugging
		// trace('Unrecognized suffix element ' & SuffixElement);
	}
}
return sKind;
}"
	ParseSuffixElement2 "(SuffixElement, OldKind) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Parse 2-character suffix element into kind and degrees.

sKind = '';
switch (SuffixElement) {
	case ('nc') {
		if (Length(OldKind) = 0) {
			sKind = 'none';
		}
	}
	case ('11') {
		if (Length(OldKind) = 0) {
			sKind = 'dominant-11th';
		} else {
			if (OldKind = 'minor') {
				sKind = 'minor-11th';
			}
		}
	}
	case ('13') {
		if (Length(OldKind) = 0) {
			sKind = 'dominant-13th';
		} else {
			if (OldKind = 'minor') {
				sKind = 'minor-13th';
			}
		}
	}
	case ('#4') {
		if (Length(OldKind) = 0) {
			sKind = 'major';
		} else {
			sKind = OldKind;
		}
		if (sKind != 'suspended-fourth') {
			AddDegree(4, 'alter', 1, True);
		} else {
			AddDegree(4, 'add', 1, True);
		}
	}
	case ('#5') {
		if (Length(OldKind) = 0) {
			sKind = 'augmented';
		} else {
			sKind = OldKind;
			AddOrAlterDegree(5, 'alter', 1, True);
		}
	}
	case ('b5') {
		if (Length(OldKind) = 0) {
			sKind = 'major';
		} else {
			sKind = OldKind;
		}
		AddOrAlterDegree(5, 'alter', -1, True);
	}
	case ('b6') {
		if (Length(OldKind) = 0) {
			sKind = 'major';
		} else {
			sKind = OldKind;
		}
		if (IndexOf('sixth', sKind) >= 0) {
			AddOrAlterDegree(6, 'alter', -1, True);
		} else {
			AddOrAlterDegree(6, 'add', -1, True);
		}	
	}
	case ('#9') {
		if (Length(OldKind) = 0) {
			sKind = 'major';
		} else {
			sKind = OldKind;
		}
		if ((IndexOf('9th', sKind) >= 0) or 
			 (IndexOf('11th', sKind) >= 0) or
			 (IndexOf('13th', sKind) >= 0)) {
			AddOrAlterDegree(9, 'alter', 1, True);
		} else {
			AddOrAlterDegree(9, 'add', 1, True);
		}	
	}
	case ('b9') {
		if (Length(OldKind) = 0) {
			sKind = 'major';
		} else {
			sKind = OldKind;
		}
		if ((IndexOf('9th', sKind) >= 0) or 
			 (IndexOf('11th', sKind) >= 0) or
			 (IndexOf('13th', sKind) >= 0)) {
			AddOrAlterDegree(9, 'alter', -1, True);
		} else {
			AddOrAlterDegree(9, 'add', -1, True);
		}	
	}
	default {
		sKind = '';
		// !!! For debugging
		// trace('Unrecognized suffix element ' & SuffixElement);
	}
}
return sKind;
}"
	ParseSuffixElement3 "(SuffixElement, OldKind) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Parse 3-character suffix element into kind and degrees.

sKind = '';
switch (SuffixElement) {
	case ('maj') {
		if (Length(OldKind) = 0) {
			sKind = 'major';
		}
	}
	case ('dim') {
		if (Length(OldKind) = 0) {
			sKind = 'diminished';
		}
	}
	case ('aug') {
		if (Length(OldKind) = 0) {
			sKind = 'augmented';
		}
	}
	case ('6/9') {
		if (Length(OldKind) = 0) {
			sKind = 'major-sixth';
		} else {
			if (OldKind = 'minor') {
				sKind = 'minor-sixth';
			} else {
				if (OldKind = 'major') {
					sKind = 'major-sixth';
				}
			}
		}
		AddDegree(9, 'add', 0, False);
	}
	case ('b13') {
		if (Length(OldKind) = 0) {
			sKind = 'major';
		} else {
			sKind = OldKind;
		}
		if (IndexOf('13th', sKind) >= 0) {
			AddDegree(13, 'alter', -1, True);
		} else {
			AddDegree(13, 'add', -1, True);
		}	
	}
	case ('#11') {
		if (Length(OldKind) = 0) {
			sKind = 'major';
		} else {
			sKind = OldKind;
		}
		if ((IndexOf('11th', sKind) >= 0) or (IndexOf('13th', sKind) >= 0)) {
			AddDegree(11, 'alter', 1, True);
		} else {
			AddDegree(11, 'add', 1, True);
		}	
	}
	case ('alt') {
		if (Length(OldKind) > 0) {
			// As close an approximation as we
			// can automate at this point.
			AddDegree(5, 'subtract', 0, False);
			AddDegree(9, 'add', -1, False);
			AddDegree(9, 'add', 1, False);
			AddDegree(11, 'add', 1, False);
			AddDegree(13, 'add', -1, False);
		}
	}
	default {
		sKind = '';
		// !!! For debugging
		// trace('Unrecognized suffix element ' & SuffixElement);
	}
}
return sKind;
}"
	ParseSuffixElement4 "(SuffixElement, OldKind) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Parse 4-character suffix element into kind and degrees.

sKind = '';
switch (SuffixElement) {
	case ('maj7') {
		if (Length(OldKind) = 0) {
			sKind = 'major-seventh';
		} else {
			sKind = OldKind;
			AddDegree(7, 'add', 1, True);
		}
	}
	case ('maj9') {
		if (Length(OldKind) = 0) {
			sKind = 'major-ninth';
		} else {
			sKind = OldKind;
			AddDegree(9, 'add', 0, True);
		}
	}
	case ('dim7') {
		if (Length(OldKind) = 0) {
			sKind = 'diminished-seventh';
		}
	}
	case ('sus4') {
		if (Length(OldKind) = 0) {
			sKind = 'suspended-fourth';
		} else {
			sKind = OldKind;
			AddDegree(4, 'add', 0, False);
			AddDegree(3, 'subtract', 0, False);
		}
	}
	case ('sus2') {
		if (Length(OldKind) = 0) {
			sKind = 'suspended-second';
		} else {
			sKind = OldKind;
			AddDegree(2, 'add', 0, False);
			AddDegree(3, 'subtract', 0, False);
		}
	}
	case ('dim9') {
		if (Length(OldKind) = 0) {
			sKind = 'diminished-seventh';
			// Degree based on Sibelius default voicing.
			AddDegree(9, 'add', 0, False);
		}
	}
	case ('add9') {
		if (Length(OldKind) = 0) {
			sKind = 'major';
		} else {
			sKind = OldKind;
		}
		AddDegree(9, 'add', 0, True);
	}
	case ('sus9') {
		if (Length(OldKind) = 0) {
			sKind = 'suspended-second';
			AddDegree(2, 'subtract', 0, False);
			AddDegree(9, 'add', 0, False);
		} else {
			sKind = OldKind;
			AddDegree(9, 'add', 0, False);
			AddDegree(3, 'subtract', 0, False);
		}
	}
	case ('add4') {
		if (Length(OldKind) = 0) {
			sKind = 'major';
		} else {
			sKind = OldKind;
		}
		AddDegree(4, 'add', 0, True);
	}
	case ('add2') {
		if (Length(OldKind) = 0) {
			sKind = 'major';
		} else {
			sKind = OldKind;
		}
		AddDegree(2, 'add', 0, True);
	}
	default {
		sKind = '';
		// !!! For debugging
		// trace('Unrecognized suffix element ' & SuffixElement);
	}
}
return sKind;
}"
	ParseSuffixElement5 "(SuffixElement, OldKind) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Parse 5-character suffix element into kind and degrees.

sKind = '';
switch (SuffixElement) {
	case ('maj11') {
		if (Length(OldKind) = 0) {
			sKind = 'major-11th';
		} else {
			sKind = OldKind;
			AddDegree(11, 'add', 0, True);
		}
	}
	case ('maj13') {
		if (Length(OldKind) = 0) {
			sKind = 'major-13th';
		} else {
			sKind = OldKind;
			AddDegree(13, 'add', 0, True);
		}
	}
	case ('omit3') {
		if (Length(OldKind) = 0) {
			sKind = 'power';
		} else {
			sKind = OldKind;
			AddDegree(3, 'subtract', 0, True);
		}
	}
	case ('dim11') {
		if (Length(OldKind) = 0) {
			sKind = 'diminished-seventh';
			// Degrees based on Sibelius default voicing.
			AddDegree(9, 'add', 0, False);
			AddDegree(11, 'add', 0, False);
		}
	}
	case ('dim13') {
		if (Length(OldKind) = 0) {
			sKind = 'diminished-seventh';
			// Degrees based on Sibelius default voicing.
			AddDegree(9, 'add', 0, False);
			AddDegree(11, 'add', 0, False);
			AddDegree(13, 'add', -1, False);
		}
	}
	case ('add13') {
		if (Length(OldKind) = 0) {
			sKind = 'major';
		} else {
			sKind = OldKind;
		}
		AddDegree(13, 'add', 0, True);
	}
	case ('omit5') {
		if (Length(OldKind) = 0) {
			sKind = 'major';
		} else {
			sKind = OldKind;
		}
		AddDegree(5, 'subtract', 0, True);
	}
	default {
		sKind = '';
		// !!! For debugging
		// trace('Unrecognized suffix element ' & SuffixElement);
	}
}
return sKind;
}"
	ParseSuffixElement6 "(SuffixElement, OldKind) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Parse 6-character suffix element into kind and degrees.

sKind = '';
switch (SuffixElement) {
	case ('add6/9') {
		if (Length(OldKind) = 0) {
			sKind = 'major';
		} else {
			sKind = OldKind;
		}
		AddDegree(6, 'add', 0, True);
		AddDegree(9, 'add', 0, True);
	}
	case ('sus2/4') {
		if (Length(OldKind) = 0) {
			sKind = 'suspended-second';
			AddDegree(4, 'add', 0, False);
		} else {
			sKind = OldKind;
			AddDegree(2, 'add', 0, False);
			AddDegree(4, 'add', 0, False);
			AddDegree(3, 'subtract', 0, False);
		}
	}
	default {
		sKind = '';
		// !!! For debugging
		// trace('Unrecognized suffix element ' & SuffixElement);
	}
}
return sKind;
}"
	ParseSuffixElement7 "(SuffixElement, OldKind) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Parse 7-character suffix element into kind and degrees.

sKind = '';
switch (SuffixElement) {
	case ('halfdim') {
		if (Length(OldKind) = 0) {
			sKind = 'half-diminished';
		}
	}
	default {
		sKind = '';
		// !!! For debugging
		// trace('Unrecognized suffix element ' & SuffixElement);
	}
}
return sKind;
}"
	AddOrAlterDegree "(DegValue, DegType, DegAlter, DegPrint) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// We often cannot tell if this degree is altering
// something already present or adding something new
// (e.g., a b5#5 chord; the first is an alter, the
// second is an add).

// So check to see if we have this degree already
// present. If we have a new alter degree, but there
// is already an alter of a different value, do an
// add instead. If we have a new add degree of an
// altered value, but there is already an add of
// the same degree with a 0 value, change that into
// an altered add.

sDegType = '' & DegType;
for i = 0 to DegreeCount {
	if (DegreeValues[i] = DegValue) {
		// Scenario where we are handling an altered version
		// of a degree already added as unaltered version. 
		if ((DegreeAlters[i] = 0) and (DegreeTypes[i] = 'add')) {
			DegreeAlters[i] = 0 + DegAlter;
			if (DegPrint and (not (DegreePrints[i]))) {
				DegreePrints[i] = True;
				DegreesToPrint = DegreesToPrint + 1;
			}
			return 0;
		} else {
			// Scenario where we already have an alteration of
			// this degree and need to convert to an add instead.
			if ((sDegType = 'alter') and (DegreeAlters[i] != DegAlter)) {
				sDegType = 'add';
			}
		}	
	}		
}

// Add a degree value to the global arrays
// and increment the degree counter. Reset the
// texts for value and type; these can then
// be set via AddDegreeTexts afterwards.
DegreeValues[DegreeCount] = 0 + DegValue;
DegreeTypes[DegreeCount] = sDegType;
DegreeAlters[DegreeCount] = 0 + DegAlter;
DegreeValueTexts[DegreeCount] = '';
DegreeTypeTexts[DegreeCount] = '';

if (DegPrint) {
	DegreePrints[DegreeCount] = True;
	DegreesToPrint = DegreesToPrint + 1;
} else {
	DegreePrints[DegreeCount] = False;
}
DegreeCount = DegreeCount + 1;
}"
	GetColor "(BarObject) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return a string with the color attribute for bar objects.
// Return an empty string if black.

sColor = '';
nRed = BarObject.ColorRed;
nGreen = BarObject.ColorGreen;
nBlue = BarObject.ColorBlue;
nAlpha = BarObject.ColorAlpha;
if ((nRed > 0) or (nGreen > 0) or (nBlue > 0) or (nAlpha < 255)) {
	if ((nRed < 256) and (nGreen < 256) and 
		 (nBlue < 256) and (nAlpha >= 0))	{
		nRGB1 = RoundDown(nRed / 16);
		nRGB2 = nRed % 16;
		nRGB3 = RoundDown(nGreen / 16);
		nRGB4 = nGreen % 16;
		nRGB5 = RoundDown(nBlue / 16);
		nRGB6 = nBlue % 16;
		nARGB1 = RoundDown(nAlpha / 16);
		nARGB2 = nAlpha % 16;
		// Use ARGB tuples
		sColor = ' color=\'#' & Hex[nARGB1] & Hex[nARGB2] & 
				 Hex[nRGB1] & Hex[nRGB2] & Hex[nRGB3] & 
				 Hex[nRGB4] & Hex[nRGB5] & Hex[nRGB6] & '\'';
	}
}
return sColor;
}"
	GetFontSize "(FontSize) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return a string with the font-size attribute.
// Return an empty string non-positive.

sFontSize = '';
nFontSize = 0 + FontSize;
sAttributeStart = ' font-size=\'';
if (nFontSize > 0) {
	fFontInMm = (nFontSize * Sibelius.ActiveScore.StaffHeight) / 128.0;
	fFontInPoints = fFontInMm * 2.83465;
	nFontSizeHundred = Round(fFontInPoints * 100.0);
	nIntegerFontSize = nFontSizeHundred / 100;
	nRemainderFontSize = nFontSizeHundred % 100;
	if (nRemainderFontSize >= 95) {
		nIntegerFontSize = nIntegerFontSize + 1;
		nRemainderFontSize = 0;	
	}
	sFontSize = sAttributeStart & nIntegerFontSize;
	if (nRemainderFontSize >= 5) {
		if (nRemainderFontSize < 10) {
			sFontSize = sFontSize & '.0' & nRemainderFontSize;	
		} else {
			sFontSize = sFontSize & '.' & nRemainderFontSize;	
		}
	}
	sFontSize = sFontSize  & '\'';
}
return sFontSize;
}"
	GetLetterSpacing "(TrackingSize, FontSize) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return a string with the font-size attribute.
// Return an empty string non-positive.

sLetterSpacing = '';
fLetterSpacingHundred = 0;
fNegative = False;
if (FontSize > 0) {
	fLetterSpacingHundred = (TrackingSize * 100.0) / FontSize;
	if (TrackingSize < 0) {
		fNegative = True;
		fLetterSpacingHundred = -fLetterSpacingHundred;
	}	
}
sAttributeStart = ' letter-spacing=\'';
if (fLetterSpacingHundred > 0) {
	nLetterSpacingHundred = Round(fLetterSpacingHundred);
	nIntegerLetterSpacing = nLetterSpacingHundred / 100;
	nRemainderLetterSpacing = nLetterSpacingHundred % 100;
	sLetterSpacing = sAttributeStart;
	if (fNegative) {
		sLetterSpacing = sLetterSpacing & '-';
	}	
	sLetterSpacing = sLetterSpacing & nIntegerLetterSpacing;
	if (nRemainderLetterSpacing > 0) {
		if (nRemainderLetterSpacing < 10) {
			sLetterSpacing = sLetterSpacing & '.0' & nRemainderLetterSpacing;	
		} else {
			sLetterSpacing = sLetterSpacing & '.' & nRemainderLetterSpacing;	
		}
	}
	sLetterSpacing = sLetterSpacing  & '\'';
}
return sLetterSpacing;
}"

	NoteRestColor
	LeftBarlineColor
	LeftEndingColor
	RightBarlineColor
	WildcardOK
	GetWildcard "(Wildcard, TextOnly, DisplayedPage) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return the text value for a wildcard

// Wildcard names are case insensitive, so convert
// everything to lowercase.
sWildcard = ToAsciiLowercase(Wildcard);
fMayBeFormatted = True;
WildcardOK = True;

switch (sWildcard) {
	case ('title') {
		sText = Sibelius.ActiveScore.Title;
	}
	case ('composer') {
		sText = Sibelius.ActiveScore.Composer;
	}
	case ('arranger') {
		sText = Sibelius.ActiveScore.Arranger;
	}
	case ('lyricist') {
		sText = Sibelius.ActiveScore.Lyricist;
	}
	case ('artist') {
		sText = Sibelius.ActiveScore.Artist;
	}
	case ('copyright') {
		sText = Sibelius.ActiveScore.Copyright;
	}
	case ('publisher') {
		sText = Sibelius.ActiveScore.Publisher;
	}
	case ('subtitle') {
		sText = Sibelius.ActiveScore.Subtitle;
	}
	case ('partname') {
		if (TextOnly) {
			sText = ConvertPartName(Sibelius.ActiveScore.PartName);
		} else {
			sText = Sibelius.ActiveScore.PartName;
		}
		// If exporting from a dynamic part, there will be \n\
		// newlines separating any different parts.
		sText = ConvertNewLines(sText, False);
	}
	case ('headerpartname') {
		if (TextOnly) {
			sText = ConvertPartName(Sibelius.ActiveScore.PartName);
		} else {
			sText = Sibelius.ActiveScore.PartName;
		}
		// If exporting from a dynamic part, there will be \n\
		// newlines separating any different parts. Change them to commas.
		sText = ConvertNewLines(sText, True);
	}
	case ('instrumentchanges') {
		if (TextOnly) {
			sText = ConvertPartName(Sibelius.ActiveScore.InstrumentChanges);
		} else {
			sText = Sibelius.ActiveScore.InstrumentChanges;
		}
		// The instrument changes wildcard has a lot of \n\ newline
		// characters that we need to convert into XML CRLFs.
		sText = ConvertNewLines(sText, False);
	}
	case ('headerinstrumentchanges') {
		if (TextOnly) {
			sText = ConvertPartName(Sibelius.ActiveScore.InstrumentChanges);
		} else {
			sText = Sibelius.ActiveScore.InstrumentChanges;
		}
		// The instrument changes wildcard has a lot of \n\ newline
		// characters that we need to convert into commas.
		sText = ConvertNewLines(sText, True);
	}
	case ('moreinfo') {
		sText = Sibelius.ActiveScore.OtherInformation;
	}
	case ('opusnumber') {
		sText = Sibelius.ActiveScore.OpusNumber;
	}
	case ('dateshort') {
		sText = Sibelius.CurrentDateShort;
		fMayBeFormatted = False;
	}
	case ('datelong') {
		sText = Sibelius.CurrentDateLong;
		fMayBeFormatted = False;
	}
	case ('time') {
		sText = Sibelius.CurrentTime;
		fMayBeFormatted = False;
	}
	case ('filename') {
		sText = Sibelius.ActiveScore.FileName;
		fMayBeFormatted = False;
	}
	case ('composerdates') {
		sText = Sibelius.ActiveScore.ComposerDates;
		fMayBeFormatted = False;
	}
	case ('yearofcomposition') {
		sText = Sibelius.ActiveScore.YearOfComposition;
		fMayBeFormatted = False;
	}
	case ('pagenum') {
		if (Length(DisplayedPage) = 0) {
			sText = '';
			fMayBeFormatted = False;
			WildcardOK = False;
		} else {
			sText = '' & DisplayedPage;
		}
	}
	default {
		// Cannot translate other wildcards, including User, FilePath,
		// and FileDate.
		sText = '';
		fMayBeFormatted = False;
		WildcardOK = False;
	}
}

// Strip out any extra formatting, including newlines in other
// fields, escaped backslashes, etc. before returning, unless
// we know there is no formatting due to the wildcard.
if (fMayBeFormatted) {
	return ConvertFormattedText(sText);
} else {
	return sText;
}
}"
	PartInstrumentsSize
	InitializeScoreInstruments "(ThisScore, ThisStaff, PartCount) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Write out the list of score-instrument elements for
// the current score-part. Get initial instruments and
// instrument changes for all staves in the part. Most
// of the work is deferred to InitializeScoreInstrument,
// which stores the data for use when writing out the
// part elements, and eliminates duplicate instruments.

// We have to loop twice since all score-instrument
// elements must precede all midi-instrument elements.
// Create the arrays to store the MIDI instrument data.
sXmlIds = CreateSparseArray();
nBalance = CreateSparseArray();
nPan = CreateSparseArray();
nInstruments = 0;

oTypeList = ThisScore.InstrumentTypes;
for i = 0 to ThisStaff.NumStavesInSameInstrument {
	if (i = 0) {
		oStaff = ThisStaff;
	} else {
		oStaff = ThisScore.NthStaff(ThisStaff.StaffNum + i);
	}

	// Get instrument type to check for names etc.
	oInstrumentType = oStaff.InitialInstrumentType;

	if (oInstrumentType != null) {	
		sXmlId = WriteScoreInstrument(oInstrumentType, PartCount, oStaff);
		if (Length(sXmlId) > 0) {
			sXmlIds[nInstruments] = '' & sXmlId;
			nBalance[nInstruments] = 0 + oInstrumentType.Balance;
			nPan[nInstruments] = 0 + oInstrumentType.Pan;
			nInstruments = nInstruments + 1;
		}
	}

	oInstrumentType = null;
	for each InstrumentChange ic in oStaff {
		// Loop through the list, since instrument changes
		// only have a style ID.
		for each oType in oTypeList {
			if (oType.StyleId = ic.StyleId) {
				oInstrumentType = oType;
			}
		}
		if (oInstrumentType != null) {
			sXmlId = WriteScoreInstrument(oInstrumentType, PartCount, null);
			if (Length(sXmlId) > 0) {
				sXmlIds[nInstruments] = '' & sXmlId;
				nBalance[nInstruments] = 0 + oInstrumentType.Balance;
				nPan[nInstruments] = 0 + oInstrumentType.Pan;
				nInstruments = nInstruments + 1;
			}
		}
	}
}

// Now loop through the MIDI instruments to create
for i = 0 to nInstruments {
	WriteMidiInstrument(sXmlIds[i], nBalance[i], nPan[i]);
}
}"
	AssignCurrentPartInstrument "(InstrumentStyleId, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Assign the value of the CurrentPartInstrument array
// indexed by StaffNumber, based on conversion from
// Sibelius to MusicXML instrument name stored in the
// global PartInstrument arrays.

// If we only have one instrument, we do not want to
// write out any instrument elements.
if (PartInstrumentsCount[PartCounter] < 2) {
	CurrentPartInstrument[StaffNumber] = '';
	return 0;
}

nStart = PartInstrumentsStart[PartCounter];
nStop = nStart + PartInstrumentsCount[PartCounter];
for i = nStart to nStop {
	if (PartInstrumentsSib[i] = InstrumentStyleId) {
		CurrentPartInstrument[StaffNumber] = '' & PartInstrumentsXml[i];
		return 0;
	}
}

// Nothing found, so blank it out
CurrentPartInstrument[StaffNumber] = '';
}"
	WriteScoreInstrument "(InstrumentType, PartCount, ThisStaff) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Initialize a score-instrument for a score-part. We also store
// away the score-instrument data for use by the instruments and
// instrument elements while writing out a part. Do not store
// or write out duplicate instruments. Return the XML instrument
// id so we can use later for initializing the MIDI instrument.

sSibName = InstrumentType.StyleId;
nCount = PartInstrumentsCount[PartCount];

// Search for duplicates, and return a null string if found.
if (nCount > 0) {
	nStart = PartInstrumentsStart[PartCount];
	nStop = nStart + PartInstrumentsCount[PartCount] + 1;
	for i = nStart to nStop {
		if (PartInstrumentsSib[i] = sSibName) {
			return '';
		}
	}
}

// This is a new instrument, so enter it into the arrays
nIndex = 0 + PartInstrumentsSize;
PartInstrumentsCount[PartCount] = 1 + nCount;
if (PartInstrumentsCount[PartCount] = 1) {
	PartInstrumentsStart[PartCount] = nIndex;
}
sXmlName = 'P' & PartCount & '-I' & PartInstrumentsCount[PartCount];
PartInstrumentsSib[nIndex] = '' & sSibName;
PartInstrumentsXml[nIndex] = '' & sXmlName;
PartInstrumentsSize = 1 + PartInstrumentsSize;

// Now set up the score instrument with as much information as we can.
// First, set up a score-instrument.
WriteXML('<score-instrument id=\'' & sXmlName & '\'>', 3);
sInstrumentName = TrimTrailingSpaces(ToXmlText(InstrumentType.FullName));
if (Length(sInstrumentName) > 0) {
	sInstrumentName = ToXmlText(InstrumentType.DialogName);
}
WriteXML('<instrument-name>' & sInstrumentName & '</instrument-name>', 4);
sInstrumentAbbrv = TrimTrailingSpaces(ToXmlText(InstrumentType.ShortName));
if (Length(sInstrumentAbbrv) > 0) {
	WriteXML('<instrument-abbreviation>' & sInstrumentAbbrv & 
			  '</instrument-abbreviation>', 4);
}

// Write instrument-sound and solo/ensemble information
// from the sound ID override if available, or the default 
// sound ID for this instrument type if not. Both of these
// ManuScript features were added in Sibelius 5.1. For
// instrument changes, we cannot get a mid-staff override,
// so the staff will be null and we will always go with 
// the default sound id.
sSoundId = '';
if (ThisStaff != null) {
	sSoundId = ThisStaff.SoundIdOverrideIfAny;
}
if (Length(sSoundId) = 0) {
	sSoundId = InstrumentType.DefaultSoundId;
}
WriteSoundId(sSoundId);

WriteXML('</score-instrument>', 3);
return sXmlName;
}"
	WriteMidiInstrument "(XmlId, Balance, Pan) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Write the midi-instrument element. Since we are now
// handling instrument changes by writing multiple
// score-instrument and midi-instrument elements, this
// needs to be handled separately. Convert Sibelius
// instrument type data into corresponding MusicXML data.

// As of Sibelius 5.1 we can get the balance and pan, so output
// a corresponding midi-instrument element.
WriteXML('<midi-instrument id=\'' & XmlId & '\'>', 3);

// Volume is 0 to 100 in MusicXML, 0 to 127 in Sibelius
nVolume = Round(Balance * 100.0 / 127.0);
WriteXML('<volume>' & nVolume & '</volume>', 4);

// Pan is -90 to 90 in MusicXML, -100 to 100 in Sibelius
nPan = Round(Pan * 90.0 / 100.0);
WriteXML('<pan>' & nPan & '</pan>', 4);

WriteXML('</midi-instrument>', 3);
}"
	GetDuration "(ThisNoteRest, Voice) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Compute the duration, unless it is a grace note.
// Need to do this before checking for live mode
// playback in order to convert Sibelius live mode
// representation into MusicXML format.
nDuration = 0;
if (not ThisNoteRest.GraceNote) {
	nDuration = ThisNoteRest.Duration * 3;
	if (DoubleTremolos[Voice] > 0) {
		nDuration = nDuration * 2;
	}
	if ((TimeModActualNotes > 0) and (TimeModNormalNotes > 0)) { 
		// Modify duration to match tuplet
		nNumerator = nDuration * TimeModNormalNotes;
		nDuration = Round(nNumerator / TimeModActualNotes);

		// Do a look ahead to avoid roundoff errors on the last note
		// of a tuplet that would require adding a forward or backup
		// element. Better to do it just on the last note than on
		// each note of the tuplet or you get more fluctuation of
		// duration values within the tuplet. Do not do this for
		// double tremolo notes.
		if (DoubleTremolos[Voice] = 0) {
			oNextNoteRest = ThisNoteRest.NextItem(ThisNoteRest.VoiceNumber,
			                                      ThisNoteRest.Type);
			nNextPosition = 0;
			if (oNextNoteRest != null) {
				if (oNextNoteRest.ParentTupletIfAny = null) {
					// Do not adjust the duration here if we are going to
					// be extending the tuplet beyond what is indicated by
					// ParentTupletIfAny, instead following what is in the
					// tuplet multiplier of right and unit values. Note 
					// that this logic duplicates what is in EndOfTuplet.
					// !!! See if we can consolidate
					oTuplet = ThisNoteRest.ParentTupletIfAny;
					if (oTuplet != null) {
						nRightUnit = oTuplet.Right * oTuplet.Unit;
						if ((nRightUnit <= oTuplet.PlayedDuration) or
						    ((oTuplet.Position + nRightUnit) <= 
						      oNextNoteRest.Position)) {
							nNextPosition = 
								oNextNoteRest.Position * 3;
						}		
					} else {
						nNextPosition = oNextNoteRest.Position * 3;
					}
				}
			} else {
				nNextPosition = ThisNoteRest.ParentBar.Length * 3;
			}
			if (nNextPosition > 0) {
				nDiff = nNextPosition - (MeasureCounter + nDuration);
				// For now, just adjust for off-by-1-or-2 (multiplied by 3).
				// We were not doing this before, by accident, and it
				// caused problems with the end of bar for extended tuplets.
				if (nDiff != 0) {
					if ((nDiff >= -6) and (nDiff <= 6)) {
						nDuration = nDuration + nDiff;
					}
				}
			}
		}
	}
}

return nDuration;
}"
	NoteRestDuration
	PedalStopType
	PedalStopLine
	PedalStopColor
	GetSuffix "(ChordText) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get the suffix out of chord text. Used in 6.0 for
// GuitarFrame when the SuffixText variable is not
// a substring of the ChordNameAsStyledString variable.
// Returns the suffix string if found, or the value of
// the GetSuffixFailValue global if not.

// Assumes that the parentheses surrounding an entire
// chord symbol have been removed. But this should work
// fine regardless of normalization or whitespace removal
// being done before or after.

// @todo See if we can use an output parameter, or
// if we can use null string assuming SuffixText will
// be empty appropriately.

// @todo Handle international roots such as Do and H.

// Parse off the root
sChordText = '' & ChordText;
sFail = '' & GetSuffixFailValue;
cRootChar = CharAt(sChordText, 0);
if ((cRootChar >= 'A') and (cRootChar <= 'G')) {
	if (Length(sChordText) > 1) {
		sRootAlter = Substring(sChordText, 1, 1);
		// Handle alternate accidentals in Sibelius chord fonts
		if (sRootAlter = 'b') {
			sChordText = Substring(sChordText, 2);
		} else {
			if (sRootAlter = '#') {
				sChordText = Substring(sChordText, 2);
			} else {
				sChordText = Substring(sChordText, 1);
			}
		} 
	} else {
		sChordText = '';
	}
} else {
	return sFail;
}

// Now look for the bass, if any. Watch out for 6/9 chords.
nBassChild = 1;	
oBassStrings = SplitString(sChordText, '/', False);	
if (oBassStrings.NumChildren > 1) {
	cBassChar = CharAt(oBassStrings[1], 0);
	// Check that we do not have a 6/9 chord causing
	// the first two divisions.
	if (cBassChar = '9') {
		nBassChild = 2;
	}
	if (oBassStrings.NumChildren = (nBassChild + 1)) {
		sChordText = '' & oBassStrings[0];
		if (nBassChild > 1) {
			sChordText = sChordText & '/' & oBassStrings[1];
		}
		sBassText = '' & oBassStrings[nBassChild];
		if (Length(sBassText) <= 2) {
			cBassChar = CharAt(sBassText, 0);
			if ((cBassChar >= 'A') and (cBassChar <= 'G')) {
				if (Length(sBassText) = 2) {
					sBassAlter = Substring(sBassText, 1, 1);
					if (not ((sBassAlter = 'b') or (sBassAlter = '#'))) {
						return sFail;
					}
				}
			} else {
				return sFail;
			}
		} else {
			return sFail;
		}
	} else {
		if (oBassStrings.NumChildren > (nBassChild + 1)) {
			return sFail;
		}
	}
}

return sChordText;
}"
	GetSuffixFailValue "xxx"
	RemoveSpaces "(ThisString, MinNewLength) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get rid of all spaces - regular, non breaking, tab, newlines
oSplitWhitespace = SplitString(ThisString, '  \t\r\n', True);
sNewString = JoinStrings(oSplitWhitespace, '');

// Make sure the new string meets any minimum length
// requirements, if any. If not, return the original
// input string.
if (Length(sNewString) >= MinNewLength) {
	return sNewString;
} else {
	return ThisString;
}
}"
	StartsWith "(Pattern, StringToSearch) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Like StartsWith in Java - returns True if the
// second parameter starts with the string in the
// first parameter.

// Check that pattern is not longer than string,
// or that pattern is not empty.
nPatternLength = Length(Pattern);
nStringLength = Length(StringToSearch);
if ((nPatternLength > nStringLength) or (nPatternLength = 0)) {
	return False;
}

// Now test the start of the string
sTest = Substring(StringToSearch, 0, nPatternLength);
if (sTest = Pattern) {
	return True;
} else {
	return False;
}
}"
	GetNewSlide "(OldSlide) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Check to see which slide number we will use.
// If OldSlide is greater than 0, this is a slide
// that will be available for reuse due to a slide
// stopping on this note.

nSlurs = 0;
nVoice = 0 + ThisEntry.VoiceNumber;
nBarCounter = 0 + BarCounter;

for i = 1 to 17 {
	if ((SlideNumbers[i] = 0) or (i = OldSlide)) {
		return i;
	}
}
// Nothing found, so return 0
return 0;
}"
	GetSlideNumber "(OldSlide) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Check to see which slide number we will use.
// If OldSlide is greater than 0, this is a slide
// that will be available for reuse due to a slide
// stopping on this note.

for i = 1 to 17 {
	if ((SlideNumbers[i] = 0) or (i = OldSlide)) {
		return i;
	}
}
// Nothing found, so return 0
return 0;
}"
	WriteBend "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

if (ShowTrace) {
	trace('Found bend with style ID ' & BarObject.StyleId & ' (' &
	      BarObject.StyleAsText & ') in bar ' & BarObject.ParentBar.BarNumber & 
	      ', position ' & BarObject.Position);
}

// In older versions of Sibelius, these were reported
// as slurs with a bend line style. For now, do the
// same thing, treating these as slurs versus dropping
// them altogether.

WriteSlur(BarObject, StaffNumber);
}"
	AtLeastSib20195
	AtLeastSib20201
	AtLeastSib20203
	AtLeastSib20209
	AtLeastSib202012
	AtLeastSib20212
	AtLeastSib20219
	AtLeastSib202212
	WriteNameDisplay "(DisplayName, StyleId, FlatIndex, SharpIndex, PrintObject, IsFull) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

nAccIndex = -1;
fFlat = True;
sTag = '';
sAccidental = '';

if (FlatIndex > 0) {
	sChar = '' & CharAt(StyleId, (FlatIndex - 1));
	switch (sChar) {
		case ('b') {
			nAccIndex = IndexOf('Bb', DisplayName);
		}
		case ('e') {
			nAccIndex = IndexOf('Eb', DisplayName);
		}
		case ('a') {
			nAccIndex = IndexOf('Ab', DisplayName);
		}
		case ('d') {
			nAccIndex = IndexOf('Db', DisplayName);
		}
	}
}
if ((nAccIndex < 0) and (SharpIndex > 0)) {
	sChar = '' & CharAt(StyleId, (SharpIndex - 1));
	switch (sChar) {
		case ('f') {
			nAccIndex = IndexOf('F#', DisplayName);
			if (nAccIndex >= 0) {
				fFlat = False;
			}
		}
	}
}

// No accidental, so nothing to write.
if (nAccIndex < 0) {
	return 0;
}

// Otherwise prepare the data to write.
if (IsFull) {
	sTag = 'part-name-display';
} else {
	sTag = 'part-abbreviation-display';
}

if (fFlat) {
	sAccidental = 'flat';
} else {
	sAccidental = 'sharp';
}

sFirstText = Substring(DisplayName, 0, nAccIndex + 1);
sSecondText = Substring(DisplayName, nAccIndex + 2);
if (Length(sFirstText) > 0) {
	sFirstText = ToXmlText(sFirstText);
}
if (Length(sSecondText) > 0) {
	sSecondText = ToXmlText(sSecondText);
}

// Now write the name-display type element.
WriteXML('<' & sTag & PrintObject & '>', 3);
if (Length(sFirstText) > 0) {
	WriteXML('<display-text>' & sFirstText & '</display-text>', 4);
}
WriteXML('<accidental-text>' & sAccidental & '</accidental-text>', 4);
if (Length(sSecondText) > 0) {
	WriteXML('<display-text>' & sSecondText & '</display-text>', 4);
}
WriteXML('</' & sTag & '>', 3);
}"
	ComputeGlyphs "(ThisScore) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return a dictionary used to generate glyph elements,
// using MusicXML glyph type / value pairs. If no glyph
// of a given type is present, it is not included in
// the dictionary.

// Reprise does not have a unpitched percussion clef 2 glyph.
fNoUnpitchedPercussion2 = False;
if (StartsWith('Reprise', ThisScore.MainMusicFontName)) {
	fNoUnpitchedPercussion2 = True;
}

oGClefOttavaBassa = CreateDictionary('gClef8vb', 0, 'gClef8vbOld', 0, 'gClef8vbParens', 0);
oPercussionClef = CreateDictionary('unpitchedPercussionClef1', 0, 'unpitchedPercussionClef2', 0);

// Loop through all initial clef styles and clef changes, 
// counting up the number of clefs of each variety.

for each Staff oStaff in ThisScore {
	sClefStyle = oStaff.InitialClefStyleId;
	if (StartsWith('clef.percussion', sClefStyle)) {
		if (fNoUnpitchedPercussion2) {
			sClefStyle = 'clef.percussion';
		}
		sGlyphValue = '';
		if (sClefStyle = 'clef.percussion_2') {
			sGlyphValue = 'unpitchedPercussionClef2';
		} else {		
			if (sClefStyle = 'clef.percussion') {
				sGlyphValue = 'unpitchedPercussionClef1';
			}
		}
		if (Length(sGlyphValue) > 0) {
			nClefCount = oPercussionClef[sGlyphValue];
			oPercussionClef[sGlyphValue] = nClefCount + 1;	
		}
	} else {
		if (StartsWith('clef.treble.down.8', sClefStyle)) {
			sGlyphValue = '';
			if (sClefStyle = 'clef.treble.down.8.bracketed') {
				sGlyphValue = 'gClef8vbParens';
			} else {		
				if (sClefStyle = 'clef.treble.down.8.old') {
					sGlyphValue = 'gClef8vbOld';
				} else {
					if (sClefStyle = 'clef.treble.down.8') {
						sGlyphValue = 'gClef8vb';
					}
				}
			}
			if (Length(sGlyphValue) > 0) {
				nClefCount = oGClefOttavaBassa[sGlyphValue];
				oGClefOttavaBassa[sGlyphValue] = nClefCount + 1;	
			}
		}
	}
}

for each Clef oClef in ThisScore {
	sClefStyle = oClef.ConcertClefStyleId;
	if (UseTranspose) {
		sClefStyle = oClef.TransposingClefStyleId;
	}
	if (StartsWith('clef.percussion', sClefStyle)) {
		if (fNoUnpitchedPercussion2) {
			sClefStyle = 'clef.percussion';
		}
		sGlyphValue = '';
		if (sClefStyle = 'clef.percussion_2') {
			sGlyphValue = 'unpitchedPercussionClef2';
		} else {		
			if (sClefStyle = 'clef.percussion') {
				sGlyphValue = 'unpitchedPercussionClef1';
			}
		}
		if (Length(sGlyphValue) > 0) {
			nClefCount = oPercussionClef[sGlyphValue];
			oPercussionClef[sGlyphValue] = nClefCount + 1;	
		}
	} else {
		if (StartsWith('clef.treble.down.8', sClefStyle)) {
			sGlyphValue = '';
			if (sClefStyle = 'clef.treble.down.8.bracketed') {
				sGlyphValue = 'gClef8vbParens';
			} else {		
				if (sClefStyle = 'clef.treble.down.8.old') {
					sGlyphValue = 'gClef8vbOld';
				} else {
					if (sClefStyle = 'clef.treble.down.8') {
						sGlyphValue = 'gClef8vb';
					}
				}
			}
			if (Length(sGlyphValue) > 0) {
				nClefCount = oGClefOttavaBassa[sGlyphValue];
				oGClefOttavaBassa[sGlyphValue] = nClefCount + 1;	
			}
		}
	}
}

nMaxGClefOttavaBassa = 0;
sMaxGClefOttavaBassa = '';
nTotalGClefOttavaBassa = 0;
nMaxPercussionClef = 0;
sMaxPercussionClef = '';
nTotalPercussionClef = 0;

for each Pair oPair in oGClefOttavaBassa {
	nTotalGClefOttavaBassa = nTotalGClefOttavaBassa + oPair.Value;
	if (oPair.Value > nMaxGClefOttavaBassa) {
		nMaxGClefOttavaBassa = oPair.Value;
		sMaxGClefOttavaBassa = oPair.Name;
	} else {
		if (oPair.Value = nMaxGClefOttavaBassa) {
			sMaxGClefOttavaBassa = '';
		}
	}
}

// Only export if used at least 75% of the time.
if (Length(sMaxGClefOttavaBassa) > 0) {
	nPercent = Round((nMaxGClefOttavaBassa * 100.0) / nTotalGClefOttavaBassa);
	if (nPercent < 75) {
		sMaxGClefOttavaBassa = '';
	}
}

// Do not export the most common gClef8vb value, only the less common ones.
if (sMaxGClefOttavaBassa = 'gClef8vb') {
	sMaxGClefOttavaBassa = '';
}

for each Pair oPair in oPercussionClef {
	nTotalPercussionClef = nTotalPercussionClef + oPair.Value;
	if (oPair.Value > nMaxPercussionClef) {
		nMaxPercussionClef = oPair.Value;
		sMaxPercussionClef = oPair.Name;
	} else {
		if (oPair.Value = nMaxPercussionClef) {
			sMaxPercussionClef = '';
		}
	}
}

// Only export if used at least 75% of the time.
if (Length(sMaxPercussionClef) > 0) {
	nPercent = Round((nMaxPercussionClef * 100.0) / nTotalPercussionClef);
	if (nPercent < 75) {
		sMaxPercussionClef = '';
	}
}

oDictionary = CreateDictionary();
if (Length(sMaxGClefOttavaBassa) > 0) {
	if (Length(sMaxPercussionClef) > 0) {
		oDictionary = CreateDictionary('g-clef-ottava-bassa', sMaxGClefOttavaBassa,
										'percussion-clef', sMaxPercussionClef);
	} else {
		oDictionary = CreateDictionary('g-clef-ottava-bassa', sMaxGClefOttavaBassa);
	}
} else {
	if (Length(sMaxPercussionClef) > 0) {
		oDictionary = CreateDictionary('percussion-clef', sMaxPercussionClef);
	}
}
	
return oDictionary;
}"
	InitializeAppearance "(ThisScore) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Create a MusicXML appearance element based on the style
// information available to us in ManuScript.

oRules = ThisScore.EngravingRules;
WriteXML('<appearance>', 2);

// Write line widths

WriteLineWidth('beam', oRules.BeamThickness, 3);
WriteLineWidth('heavy barline', oRules.FinalBarlineWidth, 3);
WriteLineWidth('leger', oRules.LegerLineThickness, 3);
WriteLineWidth('light barline', oRules.BarlineWidth, 3);
nData = oRules.SlurOutlineWidth + oRules.SlurMiddleThickness;
WriteLineWidth('slur middle', nData, 3);
WriteLineWidth('slur tip', oRules.SlurOutlineWidth, 3);
WriteLineWidth('staff', oRules.StaffLineWidth, 3);
WriteLineWidth('stem', oRules.StemThickness, 3);
nData = oRules.TieOutlineWidth + oRules.TieMiddleThickness;
WriteLineWidth('tie middle', nData, 3);
WriteLineWidth('tie tip', oRules.TieOutlineWidth, 3);

// Write note sizes

WriteXML('<note-size type=\'grace\'>' & oRules.GraceNoteScale & 
		 '</note-size>', 3);
WriteXML('<note-size type=\'cue\'>' & oRules.CueNoteScale & 
		 '</note-size>', 3);
		  
// Write glyphs
oGlyphDictionary = ComputeGlyphs(ThisScore);
for each Pair oPair in oGlyphDictionary {
	WriteXML('<glyph type=\'' & oPair.Name & '\'>' & oPair.Value & '</glyph>', 3);
}

// Finish
WriteXML('</appearance>', 2);
}"
	WriteLineWidth "(LineType, Width, Tabs) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Write a MusicXML 2.0 line-width element. Assume width is
// in spaces, as is usual for Sibelius EngravingRules variables.

nWidth = 10 * Width;
sData = '<line-width type=\'' & LineType & '\'>' & nWidth & '</line-width>';
WriteXML(sData, Tabs);
}"
	DoubleTremoloStyle
	CancelKey
	CheckSystemStaff "(ThisScore, BarNumber, SibStaffNumber, PartStaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Do not output system objects on a hidden staff.
if (HiddenStaff[PartStaffNumber]) {
	return false;
}

// We do not always know where system staff items go within
// ManuScript. Sibelius 6.1 gave us access to which staves
// show system objects, so use that if available. This will not
// catch if a system object is hidden on a staff that otherwise
// shows the objects, but is the best we can do. Always put on
// the first visible staff of the first visible part.

oPos = ThisScore.SystemObjectPositions;
fSystemStaff = oPos.GetNthStaffShowsSystemObjects(SibStaffNumber);

// Top visible staff is compulsory even if not listed
// in the system objects above. Since we check for
// hidden staff above, we know this is the first
// visible staff.
if (not SystemStaffDone[BarNumber]) {
	fSystemStaff = True;
}	

return fSystemStaff;	
}"
	InitializeGroups "(ThisScore) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Initialize data for MusicXML part-group elements using the
// BracketsAndBraces and Barlines objects. We return a 
// SparseArray containing Dictionary objects, each object
// corresponding to a MusicXML part-group.

oArray = CreateSparseArray();
oBarlineInGroup = CreateSparseArray();
oBarlines = ThisScore.Barlines;
oBrackets = ThisScore.BracketsAndBraces;
nBarlineCount = oBarlines.NumChildren;
for i = 0 to nBarlineCount {
	oBarlineInGroup[i] = False;
}

for each oBracket in oBrackets {
	// Make sure we do not export a brace for a multi-staff
	// instrument as a part-group.
	fExportGroup = True;
	if (oBracket.BracketType = BracketBrace) {
		oStaff = ThisScore.NthStaff(oBracket.TopStaveNum);
		nStavesInBrace = (oBracket.BottomStaveNum - oBracket.TopStaveNum) + 1;
		if ((nStavesInBrace > 1) and
			 (nStavesInBrace = oStaff.NumStavesInSameInstrument)) {
			fExportGroup = False;
		}
	}
	if (fExportGroup) {
		// Create a dictionary object based on the bracket.
		// Initially the barline is set to no; it gets reset
		// if there is a corresponding barline element.
		oDictionary =
			CreateDictionary('TopStaff', oBracket.TopStaveNum,
			                 'BottomStaff', oBracket.BottomStaveNum,
			                 'BracketType', oBracket.BracketType,
			                 'GroupBarline', 'no');

		// Since there usually are not many barlines and brackets
		// in a score, just check the barlines each time rather than
		// pre-processing. Using a for/each was not working
		fBarlineDone = False;
		nBraceBarline = 0;
		while ((not fBarlineDone) and (nBraceBarline < nBarlineCount)) {
			oBraceBarline = oBarlines[nBraceBarline];
			if ((oBraceBarline.TopStaveNum = oBracket.TopStaveNum) and
				(oBraceBarline.BottomStaveNum = oBracket.BottomStaveNum)) {
				oDictionary.GroupBarline = 'yes';
				oBarlineInGroup[nBraceBarline] = True;
				fBarlineDone = True;
			}
			nBraceBarline = nBraceBarline + 1;
		}

		// Add to the sparse array
		oArray.Push(oDictionary);
	}	
}

// Now see if there are barlines without associated brackets
// that we should add as groups.
nBarline = 0;
for each oBarline in ThisScore.Barlines {
	if (not (oBarlineInGroup[nBarline] = True)) {
		// Do not export if this corresponds to a multi-staff instrument.
		// or if it is set to a single staff.
		fExportGroup = True;
		nStavesInBarline = (oBarline.BottomStaveNum - oBarline.TopStaveNum) + 1;
		// Need to check for bogus barline object with TopStaveNum of -1
		// to keep the oStaff assignment from failing.
		if ((nStavesInBarline = 1) or (oBarline.TopStaveNum < 0)) {
			fExportGroup = False;
		} else {
			oStaff = ThisScore.NthStaff(oBarline.TopStaveNum);
			if (nStavesInBarline = oStaff.NumStavesInSameInstrument) {
				fExportGroup = False;
			}
		}
		if (fExportGroup) {
			// Create a dictionary object based on the barline.
			// Use -1 to indicate the lack of a bracket.
			oDictionary =
				CreateDictionary('TopStaff', oBarline.TopStaveNum,
				                 'BottomStaff', oBarline.BottomStaveNum,
				                 'BracketType', -1,
				                 'GroupBarline', 'yes');
			oArray.Push(oDictionary);
		}
	}
	nBarline = nBarline + 1;
}

return oArray;
}"
	WritePartGroup "(Group, GroupIndex, GroupType) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Write a MusicXML part-group based on information in the Group
// dictionary object and attribute data in the GroupIndex and
// GroupType parameters. Assumes that a Sibelius 6.1 check has
// already been done.

if (GroupType = 'stop') {
	sData = '<part-group number=\'' & GroupIndex & '\' type=\'stop\'/>';
	WriteXML(sData, 2);
} else {
	sData = '<part-group number=\'' & GroupIndex & '\' type=\'start\'>';
	WriteXML(sData, 2);
	sGroupSymbol = 'bracket';
	if (Group.BracketType = BracketBrace) {
		sGroupSymbol = 'brace';
	} else {
		if (Group.BracketType < 0) {
			sGroupSymbol = 'none';
		}
	}
	sData = '<group-symbol>' & sGroupSymbol & '</group-symbol>';
	WriteXML(sData, 3);
	// Do not write a group-symbol element for a 1-staff group
	if (Group.BottomStaff != Group.TopStaff) {
		sData = '<group-barline>' & Group.GroupBarline & '</group-barline>';
		WriteXML(sData, 3);
	}
	WriteXML('</part-group>', 2);
}
}"
	WritePartNameAndAbbr "(Staff, PrintObjectName, PrintObjectAbbr) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Write part name and abbreviation. Sibelius 4 gives access to
// instrument setup GUI and internal names. Sibelius 6.1 gives
// access to formatted names. Use whatever information we have
// to output what we can.

// If this is a flat- or sharp- instrument, we will check to
// see if we should write a name-display type element to 
// better export the accidental in the name and/or abbreviation.
nFlatIndex = IndexOf('flat', Staff.InitialStyleId);
nSharpIndex = IndexOf('sharp', Staff.InitialStyleId);
fNameDisplayCheck = ((nFlatIndex > 0) or (nSharpIndex > 0));

sPartName = '';
sPrintObjectName = '' & PrintObjectName;

// Sibelius 6.1 lets us see the formatted names in the score.
// If it is empty, then do not print the part name, and continue
// on with pre-6.1 methods to get the part name.
sPartName = ConvertFormattedText(Staff.FullInstrumentNameWithFormatting);
sPartName = TrimTrailingSpaces(ToXmlText(sPartName));
if (Length(sPartName) = 0) {
	sPrintObjectName = ' print-object=\'no\'';
}

// If formatted name is empty or we are pre-6.1, use the setup GUI
// name, then the internal name as a last resort.
if (Length(sPartName) = 0) {
	sPartName = TrimTrailingSpaces(ToXmlText(Staff.FullInstrumentName));
	sPrintObjectName = '' & PrintObjectName;
	if (Length(sPartName) = 0) {
		sPartName = ToXmlText(Staff.InstrumentName);
		sPrintObjectName = ' print-object=\'no\'';
	}
}

// Now write out the part-name. Write the part-name-display
// if there is an accidental.
WriteXML('<part-name' & sPrintObjectName & '>' & sPartName & '</part-name>', 3);
if (fNameDisplayCheck) {
	WriteNameDisplay(sPartName, Staff.InitialStyleId,
					 nFlatIndex, nSharpIndex, PrintObjectName, True);
}

// Now do the same thing with the part abbreviation.
sAbbrName = '';
sPrintObjectAbbr = '' & PrintObjectAbbr;
sAbbrName = ConvertFormattedText(Staff.ShortInstrumentNameWithFormatting);
sAbbrName = TrimTrailingSpaces(ToXmlText(sAbbrName));
if (Length(sAbbrName) = 0) {
	sPrintObjectAbbr = ' print-object=\'no\'';
}

// For abbreviations, we just have the setup GUI name for pre-6.1
// or backup use.
if (Length(sAbbrName) = 0) {
	sAbbrName = TrimTrailingSpaces(ToXmlText(Staff.ShortInstrumentName));
}

// Now write out the part-abbreviation. Write the part-abbreviation-display
// if there is an accidental.
if (Length(sAbbrName) > 0) {
	WriteXML('<part-abbreviation' & PrintObjectAbbr & '>' & 
			 sAbbrName & '</part-abbreviation>', 3);
	if (fNameDisplayCheck) {
		WriteNameDisplay(sAbbrName, Staff.InitialStyleId,
						 nFlatIndex, nSharpIndex, PrintObjectAbbr, False);
	}
}
}"
	ConvertFormattedText "(FormattedText) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Convert Sibelius formatted strings into XML-ready text.
// We convert \n\ newlines into CRLFs, handle escaped
// backslashes, and get rid of any other styles.

sNewText = '';
nFormattedLength = Length(FormattedText);
fInFormat = False;

// Watch out for idiosyncratic for syntax (stops before last value)
for i = 0 to nFormattedLength {
	c = CharAt(FormattedText, i);
	if (fInFormat) {
		if ('\\' = c) {
			// We are done with the format,
			// so start adding with next character.
			fInFormat = False;
		}
	} else {
		if ('\\' = c) {
			// Check for an escaped backslash.
			c2 = 0;
			c3 = 0;
			if (i < (nFormattedLength - 1)) {
				c2 = CharAt(FormattedText, i + 1);
			}
			if (i < (nFormattedLength - 2)) {
				c3 = CharAt(FormattedText, i + 2);
			}
			if ('\\' = c2) {
				sNewText = sNewText & '\\';
			} else {
				if ((('n' = c2) or ('N' = c2)) and ('\\' = c3)) {
					// We have the \n\ or \N\ newline, so 
					// convert to a CR. The \N\ newline is
					// new in Sibelius 7.
					sNewText = sNewText & Chr(13);
				}
			}
			fInFormat = True;
		} else {
			// If we have a tilde, the rest is invisible, 
			// so exit now.
			if ('~' = c) {
				return sNewText;
			} else {
				sNewText = sNewText & c;
			}
		}
	}
}
return sNewText;
}"
	InitializeStaffLayout "(ThisScore) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Compute the default staff distance and write out a
// staff-layout element if needed. To get something better
// than just the default spaces between staves, add in and
// average out the extra gaps for system objects, vocal
// staves, and end of groups.

// If only 1 staff, no staff-layout.
if (ThisScore.StaffCount <= 1) {
	return 0;
}

// @todo Leave this out until we can get vertical justification
// By itself, it tends to make the staff distance too small.

// Accumulate all the added gaps in addition to main between
// staff gap. We will then average them and add to the default
// staff distance.

oRules = ThisScore.EngravingRules;
oPositions = ThisScore.SystemObjectPositions;
oGroupEnd = CreateSparseArray();
oSystemObject = CreateSparseArray();
oVocal = CreateSparseArray();
nLastStaff = ThisScore.StaffCount + 1;
for i = 1 to nLastStaff {
	oGroupEnd[i] = False;
	oSystemObject[i] = oPositions.GetNthStaffShowsSystemObjects(i);
	oStaff = ThisScore.NthStaff(i);
	oVocal[i] = oStaff.InitialInstrumentType.IsVocal;
}
for each oBarline in ThisScore.Barlines {
	oGroupEnd[oBarline.BottomStave] = True;
}

nAddedGap = 0;
for i = 1 to nLastStaff {
	if (i > 1) {
		if (oSystemObject[i]) {
			nAddedGap = nAddedGap + oRules.ExtraSpacesAboveForSystemObjectPositions;
		}
	}
	if (i < ThisScore.StaffCount) {
		if (oGroupEnd[i]) {
			nAddedGap = nAddedGap + oRules.ExtraSpacesBetweenGroupsOfStaves;
		}
		if (oVocal[i]) {
			nAddedGap = nAddedGap + oRules.ExtraSpacesBelowVocalStaves;
		}
	}
}

// Add up and average the gap. Do not ever reduce the default gap,
// only increase it. Vertical justification will usually make gaps
// get bigger, not smaller.
nAddedGap = (10.0 * nAddedGap) / (ThisScore.StaffCount - 1);
if (nAddedGap < 0) {
	nAddedGap = 0;
}
nDistance = Round((10.0 * oRules.SpacesBetweenStaves) + nAddedGap);
	
WriteXML('<staff-layout>', 2);
WriteXML('<staff-distance>' & nDistance & '</staff-distance>', 3);
WriteXML('</staff-layout>', 2); 
}"
	IsMusicalFont "(NewFamily) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Check for a music or music text font. Currently this
// just checks for Sibelius built-in fonts.

if (StartsWith('Opus', NewFamily)) {
	return True;
}
if (StartsWith('Reprise', NewFamily)) {
	if (IndexOf('Script', NewFamily) > 0) {
		return False;
	}
	if (IndexOf('Title', NewFamily) > 0) {
		return False;
	}
	if (IndexOf('Stamp', NewFamily) > 0) {
		return False;
	}
	return True;
}
if (StartsWith('Helsinki', NewFamily)) {
	return True;
}
if (StartsWith('Inkpen', NewFamily)) {
	if (IndexOf('Script', NewFamily) > 0) {
		return False;
	}
	return True;
}
return False;
}
}"
	IsMusicTextFont "(NewFamily) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Check for music text font, used for harp pedals and
// coda/segno symbols. The older Inkpen font is checked
// separately in IsOldMusicTextFont since it does not
// have all the symbols present in the newer fonts,
// specifically both variants of the coda/segno symbols.
// Sometimes we see font family names with a space and
// sometimes without, so handle both here.

nLength = Length(NewFamily);
switch (nLength) {
	case (8) {
		return (NewFamily = 'OpusText');
	}
	case (9) {
		return (NewFamily = 'Opus Text');
	}
	case (11) {
		return ((NewFamily = 'RepriseText') or 
				 (NewFamily = 'Inkpen2Text'));
	}
	case (12) {
		return ((NewFamily = 'Reprise Text') or 
				 (NewFamily = 'Inkpen2 Text') or
				 (NewFamily = 'HelsinkiText'));
	}
	case (13) {
		return ((NewFamily = 'Opus Text Std') or
				 (NewFamily = 'Helsinki Text'));
	}
	case (16) {
		return ((NewFamily = 'Reprise Text Std') or 
				 (NewFamily = 'Inkpen2 Text Std'));
	}
	case (17) {
		return (NewFamily = 'Helsinki Text Std');
	}
	default {
		return False;
	}
}
}"
	IsOldMusicTextFont "(NewFamily) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Check for older music text font, used for harp pedals 
// and coda/segno symbols. Older fonts are checked 
// separately because they do not have all the symbols
// present in the newer fonts, specifically both variants
// of the coda/segno symbols. Sometimes we see font family
// names with a space and sometimes without, so handle 
// both here.

nLength = Length(NewFamily);
switch (nLength) {
	case (10) {
		return (NewFamily = 'InkpenText');
	}
	default {
		return False;
	}
}
}"
	IsSegnoCoda "(NewText, NewFamily) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Check to see if this string in this font represents a
// segno or coda, either double or single. Return True if
// so, False otherwise. This then lets WriteSegnoCoda proceed
// without worrying about error checking, and makes it easier
// to process mixed coda / segno / words directions.

// Handle any music text font, old or new, as a harp pedal font.

// Segno characters are $ and @; coda characters are Ø and ø.
// Both characters are used in new music text fonts, but only
// the first of each are used in old music text fonts.
sText = TrimTrailingWhitespace(NewText);
nLength = Length(sText);
if ((nLength > 2) or (nLength = 0)) {
	return False;
}
fFont = IsMusicTextFont(NewFamily);
if (fFont) {
	if (nLength = 1) {
		return ((sText = '$') or (sText = 'Ø') or (sText = '@') or (sText = 'ø'));
	} else {
		return ((sText = '$$') or (sText = 'ØØ') or (sText = '@@') or (sText = 'øø'));
	}
} else {		
	fFont = IsOldMusicTextFont(NewFamily);
	if (fFont) {
		if (nLength = 1) {
			return ((sText = '$') or (sText = 'Ø'));
		} else {
			return ((sText = '$$') or (sText = 'ØØ'));
		}
	}
}

// Otherwise we do not have a segno or coda, so return.
return False;
}"
	WriteSegnoCoda "(NewText, NewFamily, NewPosition, NewColor, FirstIndent) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Write out MusicXML segno or coda direction from text.
// This uses music text fonts, so always specify the font
// as it will not be the default music font. This is always
// called after having done an IsSegnoCoda check, so do
// not do redundant error checking here.

sText = TrimTrailingWhitespace(NewText);
nLength = Length(sText);
sFamily = ' font-family=\'' & NewFamily & '\'';
if (nLength = 1) {
	if ((sText = 'Ø') or (sText = 'ø')) {
		WriteXML('<coda' & sFamily & NewPosition & NewColor & '/>', FirstIndent);
	} else {
		WriteXML('<segno' & sFamily & NewPosition & NewColor & '/>', FirstIndent);
	}
}
else {
	if ((sText = 'ØØ') or (sText = 'øø')) {
		WriteXML('<coda' & sFamily & NewPosition & NewColor & '/>', FirstIndent);
		WriteXML('<coda/>', FirstIndent);
	} else {
		WriteXML('<segno' & sFamily & NewPosition & NewColor & '/>', FirstIndent);
		WriteXML('<segno/>', FirstIndent);
	}
}
}"
	GetTempo "(HiddenString) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return the tempo from the hidden string that can follow
// a metronome mark or other text direction. This is the
// value that should be used for the tempo attribute of
// the sound element. Return 0 if no tempo mark found.

sFirstBeatType = '';
nFirstBeatDots = 0;
sSecondBeatType = '';
nSecondBeatDots = 0;
fUseMetronomeNote = False;
sMetronomeNoteLeft = '';
sMetronomeNoteRight = '';
sNoSpaceRight = '';

// Now see if there is an equal sign for a metronome mark.
// If not, give up.
oEqualSplit = SplitString(HiddenString, '=', False);
if (oEqualSplit.NumChildren != 2) {
	return 0;
}

// Make sure we have text on both sides of the equal sign.
sLeft = RemoveSpaces(oEqualSplit[0], 0);
sRight = TrimSpaces(oEqualSplit[1]);
if ((Length(sLeft) = 0) or (Length(sRight) = 0)) {
	return 0;
}
	
// See if the right side is a number. If not, give up.
// The number can be followed by ' straight' or ' swing'
// so split it off with whitespace first.
sSplitRight = SplitString(sRight, ' ', True);
sRight = sSplitRight[0];
nTempo = 0 + sRight;
if (nTempo = 0) {
	return 0;
}

// Now parse the left side.

nSound = 0;
if (Length(sLeft) < 3) {
	sFirst = CharAt(sLeft, 0);
	switch (sFirst) {	
		case ('q') {
			nSound = nTempo;
		}
		case ('e') {
			nSound = nTempo / 2;
		}
		case ('h') {
			nSound = nTempo * 2;
		}
		case ('w') {
			nSound = nTempo * 4;
		}
		case ('x') {
			nSound = nTempo / 4;
		}
		case ('y') {
			nSound = nTempo / 8;
		}
		case ('W') {
			nSound = nTempo * 8;
		}
	}
	if (Length(sLeft) = 2) {
		if (CharAt(sLeft, 1) = '.') {
			nSound = Round(nSound * 1.5);
		} else {
			// Something we do not understand, so zap the first beat
			nSound = 0;
		}
	}
}

// Return the tempo attribute value for the sound element.
return nSound;
}"
	TrimSpaces "(ThisString) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Trim all leading and trailing spaces from the start and 
// end of a string.

sText = TrimTrailingSpaces(ThisString);
fTrim = False;
if (Length(sText) > 0) {
	if (CharAt(sText, 0) = ' ') {
		fTrim = True;
	}
	while (fTrim) {
		sText = Substring(sText, 1);
		fTrim = False;
		if (Length(sText) > 0) {
			if (CharAt(sText, 0) = ' ') {
				fTrim = True;
			}
		}
	}
}
return sText;
}"
	WriteSymbolPercussion "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// See if this is a system symbol item
fSystemSymbol = False;
sPosition = '';
if (BarObject.Type = 'SystemSymbolItem') {
	fSystemSymbol = True;
} else {
	// Get the position based on object Dx and Dy properties.
	sPosition = ' ' & GetPosition(BarObject.Dx, BarObject.Dy, False);
}

nOffset = (BarObject.Position * 3) - MeasureCounter;
sColor = GetColor(BarObject);

// Determine what type of direction we have.
sDirection = 'percussion';
sTag = '';
sText = '';
sType = '';
sMaterial = '';
sTip = '';
sSmufl = '';
fUnrecognized = False;
nBarCounter = 0 + BarCounter;

switch (BarObject.Index) {
	case (64) {
		sTag = 'pitched';
		sText = 'glockenspiel';
	}
	case (65) {
		sTag = 'pitched';
		sText = 'marimba';
	}
	case (66) {
		sTag = 'pitched';
		sText = 'xylophone';
	}
	case (67) {
		sTag = 'pitched';
		sText = 'vibraphone';
	}
	case (68) {
		sTag = 'timpani';
	}
	case (69) {
		sTag = 'pitched';
		sText = 'tubular chimes';
	}
	case (70) {
		sTag = 'metal';
		sText = 'crotale';
	}
	case (71) {
		sTag = 'effect';
		sText = 'slide whistle';
	}
	case (72) {
		sTag = 'stick-location';
		sText = 'cymbal bell';
	}
	case (73) {
		sTag = 'stick-location';
		sText = 'cymbal edge';
	}
	case (74) {
		sTag = 'other-percussion';
		sSmufl = 'pictStickShot';
	}
	case (76) {
		sTag = 'other-percussion';
		sSmufl = 'pictOnRim';
	}
	case (77) {
		sTag = 'beater';
		sText = 'slide brush on gong';
	}
	case (80) {
		sTag = 'membrane';
		sText = 'snare drum';
	}
	case (81) {
		sTag = 'membrane';
		sText = 'snare drum snares off';
	}
	case (82) {
		sTag = 'membrane';
		sText = 'military drum';
	}
	case (83) {
		sTag = 'membrane';
		sText = 'bass drum';
	}
	case (84) {
		sTag = 'membrane';
		sText = 'bass drum on side';
	}
	case (85) {
		sTag = 'membrane';
		sText = 'bongos';
	}
	case (86) {
		sTag = 'membrane';
		sText = 'tomtom';
	}
	case (87) {
		sTag = 'wood';
		sText = 'wood block';
	}
	case (88) {
		sTag = 'membrane';
		sText = 'tambourine';
	}
	case (89) {
		sTag = 'membrane';
		sText = 'timbales';
	}
	case (90) {
		sTag = 'wood';
		sText = 'slit drum';
	}
	case (91) {
		sTag = 'membrane';
		sText = 'conga drum';
	}
	case (92) {
		sTag = 'wood';
		sText = 'log drum';
	}
	case (93) {
		sTag = 'wood';
		sText = 'temple block';
	}
	case (94) {
		sTag = 'membrane';
		sText = 'tenor drum';
	}
	case (96) {
		sTag = 'metal';
		sText = 'crash cymbals';
	}
	case (97) {
		sTag = 'metal';
		sText = 'suspended cymbal';
	}
	case (98) {
		sTag = 'metal';
		sText = 'hi-hat';
	}
	case (99) {
		sTag = 'metal';
		sText = 'sizzle cymbal';
	}
	case (100) {
		sTag = 'metal';
		sText = 'tam tam';
	}
	case (101) {
		sTag = 'metal';
		sText = 'gong';
	}
	case (102) {
		sTag = 'metal';
		sText = 'domed gong';
	}
	case (103) {
		sTag = 'metal';
		sText = 'triangle';
	}
	case (104) {
		sTag = 'metal';
		sText = 'sleigh bells';
	}
	case (105) {
		sTag = 'metal';
		sText = 'cowbell';
	}
	case (106) {
		sTag = 'metal';
		sText = 'almglocken';
	}
	case (107) {
		sTag = 'effect';
		sText = 'anvil';
	}
	case (108) {
		sTag = 'metal';
		sText = 'bell plate';
	}
	case (109) {
		sTag = 'metal';
		sText = 'brake drum';
	}
	case (110) {
		sTag = 'metal';
		sText = 'flexatone';
	}
	case (112) {
		sTag = 'wood';
		sText = 'maraca';
	}
	case (113) {
		sTag = 'wood';
		sText = 'cabasa';
	}
	case (114) {
		sTag = 'wood';
		sText = 'claves';
	}
	case (115) {
		sTag = 'wood';
		sText = 'guiro';
	}
	case (116) {
		sTag = 'wood';
		sText = 'ratchet';
	}
	case (117) {
		sTag = 'wood';
		sText = 'board clapper';
	}
	case (118) {
		sTag = 'effect';
		sText = 'lions roar';
	}
	case (119) {
		sTag = 'effect';
		sText = 'bird whistle';
	}
	case (120) {
		sTag = 'effect';
		sText = 'siren';
	}
	case (121) {
		sTag = 'effect';
		sText = 'wind machine';
	}
	case (122) {
		sTag = 'effect';
		sText = 'thunder sheet';
	}
	case (123) {
		sTag = 'effect';
		sText = 'police whistle';
	}
	case (124) {
		sTag = 'effect';
		sText = 'gun shot';
	}
	case (125) {
		sTag = 'wood';
		sText = 'sandpaper blocks';
	}
	case (126) {
		sTag = 'effect';
		sText = 'auto horn';
	}
	case (127) {
		sTag = 'glass';
		sText = 'wind chimes';
	}
	case (128) {
		sTag = 'stick';
		sType = 'xylophone';
		sMaterial = 'soft';
		sTip = 'up';
	}
	case (129) {
		sTag = 'stick';
		sType = 'xylophone';
		sMaterial = 'medium';
		sTip = 'up';
	}
	case (130) {
		sTag = 'stick';
		sType = 'xylophone';
		sMaterial = 'hard';
		sTip = 'up';
	}
	case (131) {
		sTag = 'stick';
		sType = 'xylophone';
		sMaterial = 'shaded';
		sTip = 'up';
	}
	case (132) {
		sTag = 'stick';
		sType = 'timpani';
		sMaterial = 'soft';
		sTip = 'up';
	}
	case (133) {
		sTag = 'stick';
		sType = 'timpani';
		sMaterial = 'medium';
		sTip = 'up';
	}
	case (134) {
		sTag = 'stick';
		sType = 'timpani';
		sMaterial = 'hard';
		sTip = 'up';
	}
	case (135) {
		sTag = 'stick';
		sType = 'timpani';
		sMaterial = 'shaded';
		sTip = 'up';
	}
	case (136) {
		sTag = 'stick';
		sType = 'bass drum';
		sMaterial = 'soft';
		sTip = 'up';
	}
	case (137) {
		sTag = 'stick';
		sType = 'bass drum';
		sMaterial = 'medium';
		sTip = 'up';
	}
	case (138) {
		sTag = 'stick';
		sType = 'bass drum';
		sMaterial = 'hard';
		sTip = 'up';
	}
	case (139) {
		sTag = 'stick';
		sType = 'double bass drum';
		sMaterial = 'soft';
		sTip = 'up';
	}
	case (140) {
		sTag = 'stick';
		sType = 'yarn';
		sMaterial = 'soft';
		sTip = 'up';
	}
	case (141) {
		sTag = 'stick';
		sType = 'yarn';
		sMaterial = 'medium';
		sTip = 'up';
	}
	case (142) {
		sTag = 'stick';
		sType = 'yarn';
		sMaterial = 'hard';
		sTip = 'up';
	}
	case (144) {
		sTag = 'beater';
		sText = 'snare stick';
	}
	case (145) {
		sTag = 'beater';
		sText = 'jazz stick';
	}
	case (146) {
		sTag = 'beater';
		sText = 'triangle beater';
	}
	case (147) {
		sTag = 'beater';
		sText = 'wire brush';
	}
	case (148) {
		sTag = 'stick';
		sType = 'xylophone';
		sMaterial = '' & 'x';
		sTip = 'up';
	}
	case (149) {
		sTag = 'beater';
		sText = 'guiro scraper';
	}
	case (150) {
		sTag = 'beater';
		sText = 'bow';
	}
	case (151) {
		sTag = 'beater';
		sText = 'chime hammer';
	}
	case (152) {
		sTag = 'beater';
		sText = 'hand';
	}
	case (153) {
		sTag = 'beater';
		sText = 'fingernail';
	}
	case (154) {
		sTag = 'beater';
		sText = 'coin';
	}
	case (155) {
		sTag = 'beater';
		sText = 'drum stick';
	}
	case (168) {
		sTag = 'stick-location';
		sText = 'center';
		// No smufl attribute for stick-location in MusicXML 4.0,
		// so we need to switch to other-percussion if we want it.
		// sSmufl = 'pictCenter1';
	}
	case (169) {
		sTag = 'stick-location';
		sText = 'center';
		// sSmufl = 'pictCenter3';
	}
	case (170) {
		sTag = 'stick-location';
		sText = 'rim';
		// sSmufl = 'pictRim1';
	}
	case (171) {
		sTag = 'stick-location';
		sText = 'rim';
		// sSmufl = 'pictRim3';
	}
	case (172) {
		sTag = 'other-percussion';
		sSmufl = 'pictNormalPosition';
	}
	default {
		// Write an other-direction element based on the symbol
		// name, but log that this is an unrecognized symbol index.
		sDirection = 'other-direction';
		sText = ToXmlText(BarObject.Name);
		fUnrecognized = True;
	}
}

if (Length(sSmufl) > 0) {
	sSmufl = ' smufl=\'' & sSmufl & '\'';
}

// Build the string to write out. Currently relies on
// the fact that none of the directions we are supporting
// here use both a type attribute and element text. If
// this changes, rework it.
sDirectionText = '<' & sDirection & sPosition & sColor & '/>';

// Now write it out
if (fSystemSymbol) {
	if (SystemStaffDone[nBarCounter]) {
		WriteXML('<direction placement=\'above\' system=\'also-top\'>', 3);
	} else {
		WriteXML('<direction placement=\'above\' system=\'only-top\'>', 3);
	}
} else {
	sPlacement = GetPlacement(BarObject.Dy);
	WriteXML('<direction' & sPlacement & '>', 3);
}
WriteXML('<direction-type>', 4);
if (sDirection = 'percussion') {
	sDirectionText = '<percussion' & sPosition & sColor & '>';
	WriteXML(sDirectionText, 5);
	if (sTag = 'stick') {
		WriteXML('<stick tip=\'' & sTip & sSmufl & '\'>', 6);
		WriteXML('<stick-type>' & sType & '</stick-type>', 7);
		WriteXML('<stick-material>' & sMaterial & '</stick-material>', 7);
		WriteXML('</stick>', 6);
	} else {
		if (Length(sText) = 0) {
			sPercussion = '<' & sTag & sSmufl & '/>';
		} else {
			sPercussion = '<' & sTag & sSmufl & '>' & sText & '</' & sTag & '>';
		}
		WriteXML(sPercussion, 6);
	}
	WriteXML('</percussion>', 5);
} else {
	sDirectionText = '<' & sDirection & sPosition & sColor & '>' & 
					 sText & '</' & sDirection & '>';
	WriteXML(sDirectionText, 5);
}
WriteXML('</direction-type>', 4);

if (nOffset != 0) {
	WriteXML('<offset>' & nOffset & '</offset>', 4);
}

// We were using the BarObject CueSize property, but probably
// should be using the Size property for symbols instead.
// if (BarObject.CueSize) {
if (not (BarObject.Size = NormalSize)) {
	WriteXML('<level size=\'cue\'/>', 4);
}
nVoice = GetVoice(BarObject, StaffNumber);
if (nVoice > 0) {
	WriteXML('<voice>' & nVoice & '</voice>', 4);
}
if (StaffNumber > 0) {
	WriteXML('<staff>' & StaffNumber & '</staff>', 4);
}
WriteXML('</direction>', 3);
}"
	ExtendedTuplet
	WriteSoundId "(SoundId) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Write instrument-sound and solo/ensemble elements from a sound ID.

sSoundId = '' & SoundId;
sInstrumentSound = '';

while ((Length(sSoundId) > 0) and (Length(sInstrumentSound) = 0)) {	
	sInstrumentSound = GetInstrumentSound(sSoundId);
	if (Length(sInstrumentSound) > 0) {
		WriteXML('<instrument-sound>' & sInstrumentSound & '</instrument-sound>', 4);
	} else {
		sSoundIdSplits = SplitString(sSoundId, '.', True);
		nNewSplits = sSoundIdSplits.NumChildren - 1;
		if (nNewSplits <= 0) {
			LogError('Unknown sound id ' & SoundId, 4);
			sSoundId = '';
		} else {
			// Since this is an argument to JoinStrings,
			// use a regular vs. sparse array.
			sNewSoundIdSplits = CreateArray();
			for i = 0 to nNewSplits {
				sNewSoundIdSplits[i] = '' & sSoundIdSplits[i];
			}
			sSoundId = JoinStrings(sNewSoundIdSplits, '.');
		}
	}
}

if (IndexOf('solo', SoundId) >= 0) {
	WriteXML('<solo/>', 4);
} else {
	if ((IndexOf('ensemble', SoundId) >= 0) or 
		(IndexOf('orchestra', SoundId) >= 0) or
		(IndexOf('group', SoundId) >= 0) or
		(IndexOf('.kit.', SoundId) >= 0)) {
		WriteXML('<ensemble/>', 4);
	}
}
}"
	GetInstrumentSound "(SoundId) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get the MusicXML instrument sound from a
// Sibelius sound ID.

sInstrumentSound = '';

sStart = Substring(SoundId, 0, 2);

switch (sStart) {
	case ('br') {
		sInstrumentSound = GetBrassSound(SoundId);
	}
	case ('gu') {
		sInstrumentSound = GetGuitarSound(SoundId);
	}
	case ('ke') {
		sInstrumentSound = GetKeyboardSound(SoundId);
	}
	case ('pi') {
		sInstrumentSound = GetPitchedPercussionSound(SoundId);
	}
	case ('st') {
		sInstrumentSound = GetStringsSound(SoundId);
	}
	case ('sy') {
		sInstrumentSound = GetSynthSound(SoundId);
	}
	case ('un') {
		sInstrumentSound = GetUnpitchedSound(SoundId);
	}
	case ('vo') {
		sInstrumentSound = GetVoiceSound(SoundId);
	}
	case ('wi') {
		sInstrumentSound = GetWindSound(SoundId);
	}
}

return sInstrumentSound;
}"
	GetBrassSound "(SoundId) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get the MusicXML instrument sound from a
// Sibelius brass sound ID.

sInstrumentSound = '';
sLookup = Substring(SoundId, 6);

switch (sLookup) {
	case ('trumpets.trumpet') {
		sInstrumentSound = 'brass.trumpet';
	}
	case ('trumpets.cornet.soprano') {
		sInstrumentSound = 'brass.cornet.soprano';
	}
	case ('trumpets.cornet') {
		sInstrumentSound = 'brass.cornet';
	}
	case ('trumpets.flugel horn') {
		sInstrumentSound = 'brass.flugelhorn';
	}
	case ('trumpets.piccolo') {
		sInstrumentSound = 'brass.trumpet.piccolo';
	}
	case ('trumpets.tenor') {
		sInstrumentSound = 'brass.trumpet.tenor';
	}
	case ('trumpets.bass') {
		sInstrumentSound = 'brass.trumpet.bass';
	}
	case ('trumpets.bugle.baritone') {
		sInstrumentSound = 'brass.bugle.baritone';
	}
	case ('trumpets.bugle.contrabass') {
		sInstrumentSound = 'brass.bugle.contrabass';
	}
	case ('trumpets.bugle.euphonium bugle') {
		sInstrumentSound = 'brass.bugle.euphonium-bugle';
	}
	case ('trumpets.bugle.mellophone bugle') {
		sInstrumentSound = 'brass.bugle.mellophone-bugle';
	}
	case ('trumpets.bugle.soprano') {
		sInstrumentSound = 'brass.bugle.soprano';
	}
	case ('trumpets.bugle') {
		sInstrumentSound = 'brass.bugle';
	}
	case ('horns.french horn.ensemble') {
		sInstrumentSound = 'brass.french-horn';
	}
	case ('horns.french horn') {
		sInstrumentSound = 'brass.french-horn';
	}
	case ('horns.natural horn') {
		sInstrumentSound = 'brass.natural-horn';
	}
	case ('horns.mellophone.ensemble') {
		sInstrumentSound = 'brass.mellophone';
	}
	case ('horns.mellophone') {
		sInstrumentSound = 'brass.mellophone';
	}
	case ('horns.alp horn') {
		sInstrumentSound = 'brass.alphorn';
	}
	case ('trombones.tenor.ensemble') {
		sInstrumentSound = 'brass.trombone.tenor';
	}
	case ('trombones.tenor') {
		sInstrumentSound = 'brass.trombone.tenor';
	}
	case ('trombones.alto.ensemble') {
		sInstrumentSound = 'brass.trombone.alto';
	}
	case ('trombones.alto') {
		sInstrumentSound = 'brass.trombone.alto';
	}
	case ('trombones.bass.ensemble') {
		sInstrumentSound = 'brass.trombone.bass';
	}
	case ('trombones.bass') {
		sInstrumentSound = 'brass.trombone.bass';
	}
	case ('trombones.contrabass.ensemble') {
		sInstrumentSound = 'brass.trombone.contrabass';
	}
	case ('trombones.contrabass') {
		sInstrumentSound = 'brass.trombone.contrabass';
	}
	case ('trombones.cimbasso') {
		sInstrumentSound = 'brass.cimbasso';
	}
	case ('trombones.ophicleide') {
		sInstrumentSound = 'brass.ophicleide';
	}
	case ('trombones.serpent') {
		sInstrumentSound = 'brass.serpent';
	}
	case ('tubas.tuba.ensemble') {
		sInstrumentSound = 'brass.tuba';
	}
	case ('tubas.tuba') {
		sInstrumentSound = 'brass.tuba';
	}
	case ('tubas.baritone horn') {
		sInstrumentSound = 'brass.baritone-horn';
	}
	case ('tubas.contratuba') {
		sInstrumentSound = 'brass.tuba.bass';
	}
	case ('tubas.euphonium') {
		sInstrumentSound = 'brass.euphonium';
	}
	case ('tubas.sousaphone') {
		sInstrumentSound = 'brass.sousaphone';
	}
	case ('tubas.tenor horn') {
		sInstrumentSound = 'brass.alto-horn';
	}
	case ('wagner tuba.ensemble') {
		sInstrumentSound = 'brass.wagner-tuba';
	}
	case ('wagner tuba') {
		sInstrumentSound = 'brass.wagner-tuba';
	}
	case ('brass group.synth.fifths') {
		sInstrumentSound = 'brass.group.fifths';
	}
	case ('brass group.synth.polysynth') {
		sInstrumentSound = 'synth.pad.polysynth';
	}
	case ('brass group.synth') {
		sInstrumentSound = 'brass.group.synth';
	}
	case ('brass group.horn section') {
		sInstrumentSound = 'brass.group';
	}
}

return sInstrumentSound;
}"
	GetGuitarSound "(SoundId) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get the MusicXML instrument sound from a
// Sibelius guitar sound ID.

sInstrumentSound = '';
sLookup = Substring(SoundId, 7);

switch (sLookup) {
	case ('electric.synth.charang') {
		sInstrumentSound = 'pluck.synth.charang';
	}
	case ('electric.synth.chiff') {
		sInstrumentSound = 'pluck.synth.chiff';
	}
	case ('electric.synth') {
		sInstrumentSound = 'pluck.synth';
	}
	case ('electric') {
		sInstrumentSound = 'pluck.guitar.electric';
	}
	case ('nylon string.cuatro') {
		sInstrumentSound = 'pluck.cuatro';
	}
	case ('nylon string.kora') {
		sInstrumentSound = 'pluck.kora';
	}
	case ('nylon string.oud') {
		sInstrumentSound = 'pluck.oud';
	}
	case ('nylon string.ukulele') {
		sInstrumentSound = 'pluck.ukulele';
	}
	case ('nylon string') {
		sInstrumentSound = 'pluck.guitar.nylon-string';
	}
	case ('steel string.banjo') {
		sInstrumentSound = 'pluck.banjo';
	}
	case ('steel string.bouzouki') {
		sInstrumentSound = 'pluck.bouzouki';
	}
	case ('steel string.ektara') {
		sInstrumentSound = 'pluck.ektara';
	}
	case ('steel string.laud') {
		sInstrumentSound = 'pluck.laud';
	}
	case ('steel string.mandolin') {
		sInstrumentSound = 'pluck.mandolin';
	}
	case ('steel string.resonator') {
		sInstrumentSound = 'pluck.guitar.resonator';
	}
	case ('steel string.semi-acoustic.jazz.pedal steel') {
		sInstrumentSound = 'pluck.guitar.pedal-steel';
	}
	case ('steel string.tiple') {
		sInstrumentSound = 'pluck.tiple';
	}
	case ('steel string.tres') {
		sInstrumentSound = 'pluck.tres';
	}
	case ('steel string') {
		sInstrumentSound = 'pluck.guitar.steel-string';
	}
	case ('bass.acoustic.guitarron') {
		sInstrumentSound = 'pluck.bass.guitarron';
	}
	case ('bass.acoustic') {
		sInstrumentSound = 'pluck.bass.acoustic';
	}
	case ('bass.electric.fretless') {
		sInstrumentSound = 'pluck.bass.fretless';
	}
	case ('bass.electric') {
		sInstrumentSound = 'pluck.bass.electric';
	}
	case ('bass.synth.bass+lead') {
		sInstrumentSound = 'pluck.bass.synth.lead';
	}
	case ('bass.synth') {
		sInstrumentSound = 'pluck.bass.synth';
	}
	case ('banjo') {
		sInstrumentSound = 'pluck.banjo';
	}
	case ('gut string.bajo') {
		sInstrumentSound = 'pluck.bajo';
	}
	case ('gut string.bandola') {
		sInstrumentSound = 'pluck.bandola';
	}
	case ('gut string.bandurria') {
		sInstrumentSound = 'pluck.bandurria';
	}
	case ('gut string.bordonua') {
		sInstrumentSound = 'pluck.bordonua';
	}
	case ('gut string.requinto') {
		sInstrumentSound = 'pluck.guitar.requinto';
	}
	case ('gut string.vihuela') {
		sInstrumentSound = 'pluck.vihuela';
	}
	case ('balalaika.alto') {
		sInstrumentSound = 'pluck.balalaika.alto';
	}
	case ('balalaika.bass') {
		sInstrumentSound = 'pluck.balalaika.bass';
	}
	case ('balalaika.contrabass') {
		sInstrumentSound = 'pluck.balalaika.contrabass';
	}
	case ('balalaika.piccolo') {
		sInstrumentSound = 'pluck.balalaika.piccolo';
	}
	case ('balalaika.prima') {
		sInstrumentSound = 'pluck.balalaika.prima';
	}
	case ('balalaika.secunda') {
		sInstrumentSound = 'pluck.balalaika.secunda';
	}
	case ('balalaika') {
		sInstrumentSound = 'pluck.balalaika';
	}
	case ('lute.biwa') {
		sInstrumentSound = 'pluck.biwa';
	}
	case ('lute.ngoni') {
		sInstrumentSound = 'pluck.ngoni';
	}
	case ('lute.santoor') {
		sInstrumentSound = 'pluck.santoor';
	}
	case ('lute.sarod') {
		sInstrumentSound = 'pluck.sarod';
	}
	case ('lute.yuet chin') {
		sInstrumentSound = 'pluck.yueqin';
	}
	case ('lute') {
		sInstrumentSound = 'pluck.lute';
	}
	case ('dulcimer') {
		sInstrumentSound = 'pluck.dulcimer';
	}
	case ('koto') {
		sInstrumentSound = 'pluck.koto';
	}
	case ('shamisen') {
		sInstrumentSound = 'pluck.shamisen';
	}
	case ('sitar') {
		sInstrumentSound = 'pluck.sitar';
	}
	case ('tambura.female') {
		sInstrumentSound = 'pluck.tambura.female';
	}
	case ('tambura.male') {
		sInstrumentSound = 'pluck.tambura.male';
	}
	case ('tambura') {
		sInstrumentSound = 'pluck.tambura';
	}
}

return sInstrumentSound;
}"
	GetWindSound "(SoundId) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get the MusicXML instrument sound from a
// Sibelius wind sound ID.

sInstrumentSound = '';
sLookup = Substring(SoundId, 5);

switch (sLookup) {
	case ('flutes.flute.alto') {
		sInstrumentSound = 'wind.flutes.flute.alto';
	}
	case ('flutes.flute.bass') {
		sInstrumentSound = 'wind.flutes.flute.bass';
	}
	case ('flutes.flute.contra-alto') {
		sInstrumentSound = 'wind.flutes.flute.contra-alto';
	}
	case ('flutes.flute.contrabass') {
		sInstrumentSound = 'wind.flutes.flute.contrabass';
	}
	case ('flutes.flute.double contrabass') {
		sInstrumentSound = 'wind.flutes.flute.double-contrabass';
	}
	case ('flutes.flute.ensemble.synth.calliope') {
		sInstrumentSound = 'wind.flutes.callipoe';
	}
	case ('flutes.flute.piccolo') {
		sInstrumentSound = 'wind.flutes.flute.piccolo';
	}
	case ('flutes.flute.subcontrabass') {
		sInstrumentSound = 'wind.flutes.flute.subcontrabass';
	}
	case ('flutes.flute.ensemble') {
		sInstrumentSound = 'wind.flutes.flute';
	}
	case ('flutes.flute') {
		sInstrumentSound = 'wind.flutes.flute';
	}
	case ('flutes.breathy.blown blottle') {
		sInstrumentSound = 'wind.flutes.blown-bottle';
	}
	case ('flutes.breathy.dizi') {
		sInstrumentSound = 'wind.flutes.di-zi';
	}
	case ('flutes.breathy.ney') {
		sInstrumentSound = 'wind.flutes.ney';
	}
	case ('flutes.breathy.ocarina') {
		sInstrumentSound = 'wind.flutes.ocarina';
	}
	case ('flutes.breathy.pan pipe') {
		sInstrumentSound = 'wind.flutes.panpipes';
	}
	case ('flutes.breathy.shakuhachi') {
		sInstrumentSound = 'wind.flutes.shakuhachi';
	}
	case ('flutes.whistle.flageolet') {
		sInstrumentSound = 'wind.flutes.flageolet';
	}
	case ('flutes.whistle.irish.low') {
		sInstrumentSound = 'wind.flutes.whistle.low-irish';
	}
	case ('flutes.whistle.slide') {
		sInstrumentSound = 'wind.flutes.whistle.slide';
	}
	case ('flutes.whistle.tin') {
		sInstrumentSound = 'wind.flutes.whistle.tin';
	}
	case ('flutes.whistle') {
		sInstrumentSound = 'wind.flutes.whistle';
	}
	case ('flutes.bansuri') {
		sInstrumentSound = 'wind.flutes.bansuri';
	}
	case ('flutes.kawala') {
		sInstrumentSound = 'wind.flutes.kawala';
	}
	case ('flutes.ryuteki') {
		sInstrumentSound = 'wind.flutes.ryuteki';
	}
	case ('bassoons.bassoon') {
		sInstrumentSound = 'wind.reed.bassoon';
	}
	case ('bassoons.contrabassoon') {
		sInstrumentSound = 'wind.reed.contrabassoon';
	}
	case ('clarinets.clarinet') {
		sInstrumentSound = 'wind.reed.clarinet';
	}
	case ('clarinets.alto') {
		sInstrumentSound = 'wind.reed.clarinet.alto';
	}
	case ('clarinets.bass') {
		sInstrumentSound = 'wind.reed.clarinet.bass';
	}
	case ('clarinets.basset-horn') {
		sInstrumentSound = 'wind.reed.basset-horn';
	}
	case ('clarinets.contra alto') {
		sInstrumentSound = 'wind.reed.clarinet.contra-alto';
	}
	case ('clarinets.contrabass') {
		sInstrumentSound = 'wind.reed.clarinet.contrabass';
	}
	case ('clarinets.eb') {
		sInstrumentSound = 'wind.reed.clarinet.eflat';
	}
	case ('oboes.oboe d\'amore') {
		sInstrumentSound = 'wind.reed.oboe-damore';
	}
	case ('oboes.oboe') {
		sInstrumentSound = 'wind.reed.oboe';
	}
	case ('oboes.bass') {
		sInstrumentSound = 'wind.reed.oboe.bass';
	}
	case ('oboes.duduk') {
		sInstrumentSound = 'wind.reed.oboe';
	}
	case ('oboes.english horn') {
		sInstrumentSound = 'wind.reed.english-horn';
	}
	case ('oboes.heckelphone') {
		sInstrumentSound = 'wind.reed.heckelphone';
	}
	case ('oboes.hichiriki') {
		sInstrumentSound = 'wind.reed.hichiriki';
	}
	case ('oboes.launeddas') {
		sInstrumentSound = 'wind.reed.launeddas';
	}
	case ('oboes.shanai') {
		sInstrumentSound = 'wind.reed.shenai';
	}
	case ('oboes.zourna') {
		sInstrumentSound = 'wind.reed.zurna';
	}
	case ('saxophones.alto') {
		sInstrumentSound = 'wind.reed.saxophone.alto';
	}
	case ('saxophones.tenor') {
		sInstrumentSound = 'wind.reed.saxophone.tenor';
	}
	case ('saxophones.baritone') {
		sInstrumentSound = 'wind.reed.saxophone.baritone';
	}
	case ('saxophones.soprano') {
		sInstrumentSound = 'wind.reed.saxophone.soprano';
	}
	case ('saxophones.bass') {
		sInstrumentSound = 'wind.reed.saxophone.bass';
	}
	case ('saxophones.contrabass') {
		sInstrumentSound = 'wind.reed.saxophone.contrabass';
	}
	case ('saxophones.melody') {
		sInstrumentSound = 'wind.reed.saxophone.melody';
	}
	case ('saxophones.mezzo-soprano') {
		sInstrumentSound = 'wind.reed.saxophone.mezzo-soprano';
	}
	case ('saxophones.sopranino') {
		sInstrumentSound = 'wind.reed.saxophone.sopranino';
	}
	case ('saxophones.subcontrabass') {
		sInstrumentSound = 'wind.reed.saxophone.subcontrabass';
	}
	case ('wind group') {
		sInstrumentSound = 'wind.group';
	}
	case ('wood.flutes.recorder.alto') {
		sInstrumentSound = 'wind.flutes.recorder.alto';
	}
	case ('wood.flutes.recorder.bass') {
		sInstrumentSound = 'wind.flutes.recorder.bass';
	}
	case ('wood.flutes.recorder.contrabass') {
		sInstrumentSound = 'wind.flutes.recorder.contrabass';
	}
	case ('wood.flutes.recorder.descant') {
		sInstrumentSound = 'wind.flutes.recorder.descant';
	}
	case ('wood.flutes.recorder.great bass') {
		sInstrumentSound = 'wind.flutes.recorder.great-bass';
	}
	case ('wood.flutes.recorder.sopranino') {
		sInstrumentSound = 'wind.flutes.recorder.sopranino';
	}
	case ('wood.flutes.recorder.soprano') {
		sInstrumentSound = 'wind.flutes.recorder.soprano';
	}
	case ('wood.flutes.recorder.tenor') {
		sInstrumentSound = 'wind.flutes.recorder.tenor';
	}
	case ('wood.flutes.recorder') {
		sInstrumentSound = 'wind.flutes.recorder';
	}
	case ('pipes.bagpipes') {
		sInstrumentSound = 'wind.pipes.bagpipes';
	}
	case ('pipes.highland pipes') {
		sInstrumentSound = 'wind.pipes.highland';
	}
	case ('pipes.uilleann') {
		sInstrumentSound = 'wind.pipes.uilleann';
	}
	case ('harmonica') {
		sInstrumentSound = 'wind.harmonica';
	}
	case ('didgeridoo') {
		sInstrumentSound = 'brass.didgeridoo';
	}
	case ('pungi') {
		sInstrumentSound = 'wind.pungi';
	}
	case ('rag dung') {
		sInstrumentSound = 'brass.rag-dung';
	}
}

return sInstrumentSound;
}"
	GetSynthSound "(SoundId) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get the MusicXML instrument sound from a
// Sibelius synth sound ID.

sInstrumentSound = '';
sLookup = Substring(SoundId, 6);

switch (sLookup) {
	case ('pad.warm.static.bowed') {
		sInstrumentSound = 'synth.pad.bowed';
	}
	case ('pad.warm') {
		sInstrumentSound = 'synth.pad.warm';
	}
	case ('pad.bright.metallic') {
		sInstrumentSound = 'synth.pad.metallic';
	}
	case ('pad.bright.static.sci-fi') {
		sInstrumentSound = 'synth.effects.sci-fi';
	}
	case ('tone.thin.square') {
		sInstrumentSound = 'synth.tone.square';
	}
	case ('tone.thin.filtered saw') {
		sInstrumentSound = 'synth.tone.sawtooth';
	}
	case ('tone.pure.sine') {
		sInstrumentSound = 'synth.tone.sine';
	}
	case ('tone.pure.theremin') {
		sInstrumentSound = 'synth.theremin';
	}
	case ('sweep.goblins') {
		sInstrumentSound = 'synth.effects.goblins';
	}
	case ('sweep.rain') {
		sInstrumentSound = 'synth.effects.rain';
	}
	case ('sweep.soundtrack') {
		sInstrumentSound = 'synth.effects.soundtrack';
	}
	case ('sweep') {
		sInstrumentSound = 'synth.pad.sweep';
	}
}

return sInstrumentSound;
}"
	GetKeyboardSound "(SoundId) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get the MusicXML instrument sound from a
// Sibelius keyboard sound ID.

sInstrumentSound = '';
sLookup = Substring(SoundId, 9);

switch (sLookup) {
	case ('piano.grand') {
		sInstrumentSound = 'keyboard.piano.grand';
	}
	case ('piano.upright.honky-tonk') {
		sInstrumentSound = 'keyboard.piano.honky-tonk';
	}
	case ('piano.upright') {
		sInstrumentSound = 'keyboard.piano.upright';
	}
	case ('piano.electric') {
		sInstrumentSound = 'keyboard.piano.electric';
	}
	case ('piano.toy') {
		sInstrumentSound = 'keyboard.piano.toy';
	}
	case ('piano.synth.atmosphere') {
		sInstrumentSound = 'synth.effects.atmosphere';
	}
	case ('piano') {
		sInstrumentSound = 'keyboard.piano';
	}
	case ('organ.reed.accordion.tango') {
		sInstrumentSound = 'keyboard.bandoneon';
	}
	case ('organ.reed.accordion') {
		sInstrumentSound = 'keyboard.accordion';
	}
	case ('organ.reed.harmonium') {
		sInstrumentSound = 'keyboard.harmonium';
	}
	case ('organ.reed') {
		sInstrumentSound = 'keyboard.organ.reed';
	}
	case ('organ.pipe') {
		sInstrumentSound = 'keyboard.organ.pipe';
	}
	case ('organ.drawbar.percussive.with rotary speaker') {
		sInstrumentSound = 'keyboard.organ.rotary';
	}
	case ('organ.drawbar.percussive') {
		sInstrumentSound = 'keyboard.organ.percussive';
	}
	case ('organ.drawbar') {
		sInstrumentSound = 'keyboard.organ.drawbar';
	}
	case ('organ') {
		sInstrumentSound = 'keyboard.organ';
	}
	case ('harpsichord.synth.clavichord') {
		sInstrumentSound = 'keyboard.clavichord.synth';
	}
	case ('harpsichord') {
		sInstrumentSound = 'keyboard.harpsichord';
	}
	case ('clavichord') {
		sInstrumentSound = 'keyboard.clavichord';
	}
	case ('celesta') {
		sInstrumentSound = 'keyboard.celesta';
	}
	case ('ondes martenot') {
		sInstrumentSound = 'keyboard.ondes-martenot';
	}
	case ('organ') {
		sInstrumentSound = 'keyboard.organ';
	}
}

return sInstrumentSound;
}"
	GetVoiceSound "(SoundId) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get the MusicXML instrument sound from a
// Sibelius voice sound ID.

sInstrumentSound = '';
sLookup = Substring(SoundId, 6);

switch (sLookup) {
	case ('female.soprano.ensemble.ah') {
		sInstrumentSound = 'voice.soprano';
	}
	case ('female.soprano.ensemble.oo') {
		sInstrumentSound = 'voice.soprano';
	}
	case ('female.soprano.ensemble.ee') {
		sInstrumentSound = 'voice.soprano';
	}
	case ('female.soprano.ensemble.doo') {
		sInstrumentSound = 'voice.soprano';
	}
	case ('female.soprano.ensemble.mm') {
		sInstrumentSound = 'voice.soprano';
	}
	case ('female.soprano.ensemble') {
		sInstrumentSound = 'voice.soprano';
	}
	case ('female.alto.ensemble.ah') {
		sInstrumentSound = 'voice.alto';
	}
	case ('female.alto.ensemble.oo') {
		sInstrumentSound = 'voice.alto';
	}
	case ('female.alto.ensemble.ee') {
		sInstrumentSound = 'voice.alto';
	}
	case ('female.alto.ensemble.doo') {
		sInstrumentSound = 'voice.alto';
	}
	case ('female.alto.ensemble.mm') {
		sInstrumentSound = 'voice.alto';
	}
	case ('female.alto.ensemble') {
		sInstrumentSound = 'voice.alto';
	}
	case ('female.ensemble.ah') {
		sInstrumentSound = 'voice.female';
	}
	case ('female.ensemble.oo') {
		sInstrumentSound = 'voice.female';
	}
	case ('female.ensemble.ee') {
		sInstrumentSound = 'voice.female';
	}
	case ('female.ensemble.doo') {
		sInstrumentSound = 'voice.female';
	}
	case ('female.ensemble.mm') {
		sInstrumentSound = 'voice.female';
	}
	case ('female.ensemble') {
		sInstrumentSound = 'voice.female';
	}
	case ('male.tenor.ensemble.ah') {
		sInstrumentSound = 'voice.tenor';
	}
	case ('male.tenor.ensemble.oo') {
		sInstrumentSound = 'voice.tenor';
	}
	case ('male.tenor.ensemble.ee') {
		sInstrumentSound = 'voice.tenor';
	}
	case ('male.tenor.ensemble.doo') {
		sInstrumentSound = 'voice.tenor';
	}
	case ('male.tenor.ensemble.mm') {
		sInstrumentSound = 'voice.tenor';
	}
	case ('male.tenor.ensemble') {
		sInstrumentSound = 'voice.tenor';
	}
	case ('male.bass.ensemble.ah') {
		sInstrumentSound = 'voice.bass';
	}
	case ('male.bass.ensemble.oo') {
		sInstrumentSound = 'voice.bass';
	}
	case ('male.bass.ensemble.ee') {
		sInstrumentSound = 'voice.bass';
	}
	case ('male.bass.ensemble.doo') {
		sInstrumentSound = 'voice.bass';
	}
	case ('male.bass.ensemble.mm') {
		sInstrumentSound = 'voice.bass';
	}
	case ('male.bass.ensemble') {
		sInstrumentSound = 'voice.bass';
	}
	case ('male.ensemble.ah') {
		sInstrumentSound = 'voice.male';
	}
	case ('male.ensemble.oo') {
		sInstrumentSound = 'voice.male';
	}
	case ('male.ensemble.ee') {
		sInstrumentSound = 'voice.male';
	}
	case ('male.ensemble.doo') {
		sInstrumentSound = 'voice.male';
	}
	case ('male.ensemble.mm') {
		sInstrumentSound = 'voice.male';
	}
	case ('male.ensemble') {
		sInstrumentSound = 'voice.male';
	}
	case ('female.soprano.ah') {
		sInstrumentSound = 'voice.soprano';
	}
	case ('female.soprano.oo') {
		sInstrumentSound = 'voice.soprano';
	}
	case ('female.soprano.ee') {
		sInstrumentSound = 'voice.soprano';
	}
	case ('female.soprano.doo') {
		sInstrumentSound = 'voice.soprano';
	}
	case ('female.soprano.mm') {
		sInstrumentSound = 'voice.soprano';
	}
	case ('female.soprano') {
		sInstrumentSound = 'voice.soprano';
	}
	case ('female.alto.ah') {
		sInstrumentSound = 'voice.alto';
	}
	case ('female.alto.oo') {
		sInstrumentSound = 'voice.alto';
	}
	case ('female.alto.ee') {
		sInstrumentSound = 'voice.alto';
	}
	case ('female.alto.doo') {
		sInstrumentSound = 'voice.alto';
	}
	case ('female.alto.mm') {
		sInstrumentSound = 'voice.alto';
	}
	case ('female.alto') {
		sInstrumentSound = 'voice.alto';
	}
	case ('female.ah') {
		sInstrumentSound = 'voice.female';
	}
	case ('female.oo') {
		sInstrumentSound = 'voice.female';
	}
	case ('female.ee') {
		sInstrumentSound = 'voice.female';
	}
	case ('female.doo') {
		sInstrumentSound = 'voice.female';
	}
	case ('female.mm') {
		sInstrumentSound = 'voice.female';
	}
	case ('female') {
		sInstrumentSound = 'voice.female';
	}
	case ('female.scat') {
		sInstrumentSound = 'voice.female';
	}
	case ('female') {
		sInstrumentSound = 'voice.female';
	}
	case ('male.tenor.ah') {
		sInstrumentSound = 'voice.tenor';
	}
	case ('male.tenor.oo') {
		sInstrumentSound = 'voice.tenor';
	}
	case ('male.tenor.ee') {
		sInstrumentSound = 'voice.tenor';
	}
	case ('male.tenor.doo') {
		sInstrumentSound = 'voice.tenor';
	}
	case ('male.tenor.mm') {
		sInstrumentSound = 'voice.tenor';
	}
	case ('male.tenor') {
		sInstrumentSound = 'voice.tenor';
	}
	case ('male.bass.ah') {
		sInstrumentSound = 'voice.bass';
	}
	case ('male.bass.oo') {
		sInstrumentSound = 'voice.bass';
	}
	case ('male.bass.ee') {
		sInstrumentSound = 'voice.bass';
	}
	case ('male.bass.doo') {
		sInstrumentSound = 'voice.bass';
	}
	case ('male.bass.mm') {
		sInstrumentSound = 'voice.bass';
	}
	case ('male.bass') {
		sInstrumentSound = 'voice.bass';
	}
	case ('male.ah') {
		sInstrumentSound = 'voice.male';
	}
	case ('male.oo') {
		sInstrumentSound = 'voice.male';
	}
	case ('male.ee') {
		sInstrumentSound = 'voice.male';
	}
	case ('male.doo') {
		sInstrumentSound = 'voice.male';
	}
	case ('male.mm') {
		sInstrumentSound = 'voice.male';
	}
	case ('male') {
		sInstrumentSound = 'voice.male';
	}
	case ('synth.aa') {
		sInstrumentSound = 'voice.aa';
	}
	case ('synth.aw') {
		sInstrumentSound = 'voice.aw';
	}
	case ('synth.doo') {
		sInstrumentSound = 'voice.doo';
	}
	case ('synth.ee') {
		sInstrumentSound = 'voice.ee';
	}
	case ('synth.mm') {
		sInstrumentSound = 'voice.mm';
	}
	case ('synth.oo') {
		sInstrumentSound = 'voice.oo';
	}
	case ('synth.ensemble.ah.brightness') {
		sInstrumentSound = 'synth.effects.brightness';
	}
	case ('synth.ensemble.ah.echoes') {
		sInstrumentSound = 'synth.effects.echoes';
	}
	case ('synth.ensemble.ah.halo') {
		sInstrumentSound = 'synth.pad.halo';
	}
	case ('synth.ensemble.ah') {
		sInstrumentSound = 'synth.pad.choir';
	}
	case ('synth.ensemble.aa') {
		sInstrumentSound = 'voice.aa';
	}
	case ('synth.ensemble.aw') {
		sInstrumentSound = 'voice.aw';
	}
	case ('synth.ensemble.doo') {
		sInstrumentSound = 'voice.doo';
	}
	case ('synth.ensemble.ee') {
		sInstrumentSound = 'voice.ee';
	}
	case ('synth.ensemble.mm') {
		sInstrumentSound = 'voice.mm';
	}
	case ('synth.ensemble.oo') {
		sInstrumentSound = 'voice.oo';
	}
	case ('synth.ensemble') {
		sInstrumentSound = 'voice.synth';
	}
	case ('synth') {
		sInstrumentSound = 'voice.synth';
	}
	case ('ensemble.ah') {
		sInstrumentSound = 'voice.vocals';
	}
	case ('ensemble.oo') {
		sInstrumentSound = 'voice.vocals';
	}
	case ('ensemble.ee') {
		sInstrumentSound = 'voice.vocals';
	}
	case ('ensemble.doo') {
		sInstrumentSound = 'voice.vocals';
	}
	case ('ensemble.mm') {
		sInstrumentSound = 'voice.vocals';
	}
	case ('ensemble') {
		sInstrumentSound = 'voice.vocals';
	}
	case ('') {
		sInstrumentSound = 'voice.vocals';
	}
}

return sInstrumentSound;
}"
	GetStringsSound "(SoundId) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get the MusicXML instrument sound from a
// Sibelius strings sound ID.

sInstrumentSound = '';
sLookup = Substring(SoundId, 8);

switch (sLookup) {
	case ('violin.ensemble') {
		sInstrumentSound = 'strings.violin';
	}
	case ('violin') {
		sInstrumentSound = 'strings.violin';
	}
	case ('viola.ensemble') {
		sInstrumentSound = 'strings.viola';
	}
	case ('viola') {
		sInstrumentSound = 'strings.viola';
	}
	case ('violoncello.ensemble') {
		sInstrumentSound = 'strings.cello';
	}
	case ('violoncello') {
		sInstrumentSound = 'strings.cello';
	}
	case ('contrabass.ensemble') {
		sInstrumentSound = 'strings.contrabass';
	}
	case ('contrabass') {
		sInstrumentSound = 'strings.contrabass';
	}
	case ('string orchestra.strings and brass') {
		sInstrumentSound = 'strings.group.orchestra';
	}
	case ('string orchestra.synth') {
		sInstrumentSound = 'strings.group.synth';
	}
	case ('string orchestra') {
		sInstrumentSound = 'strings.group';
	}
	case ('viols.alto') {
		sInstrumentSound = 'strings.viol.alto';
	}
	case ('viols.bass') {
		sInstrumentSound = 'strings.viol.bass';
	}
	case ('viols.tenor') {
		sInstrumentSound = 'strings.viol.tenor';
	}
	case ('viols.treble') {
		sInstrumentSound = 'strings.viol.treble';
	}
	case ('viols.viola da gamba') {
		sInstrumentSound = 'strings.viol';
	}
	case ('fiddle.erhu') {
		sInstrumentSound = 'strings.erhu';
	}
	case ('fiddle.esraj') {
		sInstrumentSound = 'strings.esraj';
	}
	case ('fiddle.gadulka') {
		sInstrumentSound = 'strings.gadulka';
	}
	case ('fiddle.hardanger') {
		sInstrumentSound = 'strings.fiddle.hardanger';
	}
	case ('fiddle.rebab') {
		sInstrumentSound = 'strings.rebab';
	}
	case ('fiddle.sarangi') {
		sInstrumentSound = 'strings.sarangi';
	}
	case ('fiddle.yalli tambur') {
		sInstrumentSound = 'strings.yayli-tanbur';
	}
	case ('fiddle') {
		sInstrumentSound = 'strings.fiddle';
	}
	case ('hurdy-gurdy') {
		sInstrumentSound = 'strings.hurdy-gurdy';
	}
}

return sInstrumentSound;
}"
	GetPitchedPercussionSound "(SoundId) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get the MusicXML instrument sound from a
// Sibelius pitched percussion sound ID.

sInstrumentSound = '';
sLookup = Substring(SoundId, 19);

switch (sLookup) {
	case ('drum.timpani') {
		sInstrumentSound = 'drum.timpani';
	}
	case ('stringed.harp.level') {
		sInstrumentSound = 'pluck.celtic-harp';
	}
	case ('stringed.harp') {
		sInstrumentSound = 'pluck.harp';
	}
	case ('metal.glockenspiel') {
		sInstrumentSound = 'pitched-percussion.glockenspiel';
	}
	case ('metal.vibraphone') {
		sInstrumentSound = 'pitched-percussion.vibraphone';
	}
	case ('wood.marimba') {
		sInstrumentSound = 'pitched-percussion.marimba';
	}
	case ('wood.xylophone.gyil') {
		sInstrumentSound = 'pitched-percussion.gyil';
	}
	case ('wood.xylophone') {
		sInstrumentSound = 'pitched-percussion.xylophone';
	}
	case ('metal.bells.almglocken') {
		sInstrumentSound = 'metal.bells.almglocken';
	}
	case ('metal.bells.carillon') {
		sInstrumentSound = 'metal.bells.carillon';
	}
	case ('metal.bells.church bells') {
		sInstrumentSound = 'metal.bells.church';
	}
	case ('metal.bells.hand bells') {
		sInstrumentSound = 'pitched-percussion.handbells';
	}
	case ('metal.bells.synth.crystal') {
		sInstrumentSound = 'synth.effects.crystal';
	}
	case ('metal.bells.tinkle bells') {
		sInstrumentSound = 'metal.bells.tinklebell';
	}
	case ('metal.bells.tubular bells') {
		sInstrumentSound = 'pitched-percussion.tubular-bells';
	}
	case ('metal.bells.gamelan.bonang') {
		sInstrumentSound = 'pitched-percussion.bonang';
	}
	case ('metal.bells.gamelan.kengong') {
		sInstrumentSound = 'metal.kengong';
	}
	case ('metal.bells.gamelan.slentam') {
		sInstrumentSound = 'pitched-percussion.slentem';
	}
	case ('metal.bells') {
		sInstrumentSound = 'pitched-percussion.bells';
	}
	case ('metal.bell lyre') {
		sInstrumentSound = 'pitched-percussion.bell-lyre';
	}
	case ('metal.crotales') {
		sInstrumentSound = 'metal.crotales';
	}
	case ('metal.kalimba') {
		sInstrumentSound = 'pitched-percussion.kalimba';
	}
	case ('metal.music box') {
		sInstrumentSound = 'pitched-percussion.music-box';
	}
	case ('metal.steel drums') {
		sInstrumentSound = 'metal.steel-drums';
	}
	case ('wood.anklung') {
		sInstrumentSound = 'pitched-percussion.angklung';
	}
	case ('wood.balafon') {
		sInstrumentSound = 'pitched-percussion.balafon';
	}
	case ('wood.xylorimba') {
		sInstrumentSound = 'pitched-percussion.xylorimba';
	}
	case ('stringed.hammer dulcimer.cimbalom') {
		sInstrumentSound = 'pitched-percussion.cimbalom';
	}
	case ('stringed.harp.hammer dulcimer') {
		sInstrumentSound = 'pitched-percussion.hammer-dulcimer';
	}
	case ('stringed.zither.kanun') {
		sInstrumentSound = 'pluck.kanun';
	}
	case ('stringed.zither.zheng') {
		sInstrumentSound = 'pluck.guzheng';
	}
	case ('stringed.zither') {
		sInstrumentSound = 'pluck.zither';
	}
	case ('glass.glass harmonica') {
		sInstrumentSound = 'pitched-percussion.glass-harmonica';
	}
}

return sInstrumentSound;
}"
	GetUnpitchedSound "(SoundId) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get the MusicXML instrument sound from a
// Sibelius unpitched sound ID.

sInstrumentSound = '';
sLookup = Substring(SoundId, 10);

// For wood and drum, we need to get rid of the
// high, medium-high, etc. in the middle of the id

nFirstDot = IndexOf('.', sLookup);
sType = Substring(sLookup, 0, nFirstDot);
if ((sType = 'wood') or (sType = 'drum')) {
	sLookup = Substring(sLookup, nFirstDot + 1);
	nSecondDot = IndexOf('.', sLookup);
	sHiLow = Substring(sLookup, 0, nSecondDot);
	if (sHiLow != 'kit') {
		sLookup = Substring(sHiLow, nSecondDot + 1);
	}
}

switch (sType) {
	case ('drum') {
		sInstrumentSound = GetDrumSound(sLookup);
	}
	case ('exotic') {
		sInstrumentSound = GetExoticSound(SoundId);
	}
	case ('metal') {
		sInstrumentSound = GetMetalSound(SoundId);
	}
	case ('rattle') {
		sInstrumentSound = GetRattleSound(SoundId);
	}
	case ('wood') {
		sInstrumentSound = GetWoodSound(sLookup);
	}
	default {
		switch (SoundId) {
			case ('unpitched.wind.whistle.police') {
				sInstrumentSound = 'effect.whistle.police';
			}
			case ('unpitched.wind.whistle.siren') {
				sInstrumentSound = 'effect.whistle.mouth-siren';
			}
			case ('unpitched.wind.whistle.slide') {
				sInstrumentSound = 'effect.whistle.slide';
			}
			case ('unpitched.wind.whistle.train') {
				sInstrumentSound = 'effect.whistle.train';
			}
			case ('unpitched.wind.whistle') {
				sInstrumentSound = 'effect.whistle';
			}
		}
	}
}

return sInstrumentSound;
}"
	GetDrumSound "(Lookup) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get the MusicXML instrument sound from the
// lookup part of a Sibelius unpitched drum sound ID.

sInstrumentSound = '';
switch (Lookup) {
	case ('bass drum.ensemble') {
		sInstrumentSound = 'drum.bass-drum';
	}
	case ('bass drum') {
		sInstrumentSound = 'drum.bass-drum';
	}
	case ('snare drum.snares on.electric') {
		sInstrumentSound = 'drum.snare-drum.electric';
	}
	case ('snare drum') {
		sInstrumentSound = 'drum.snare-drum';
	}
	case ('tenor drum.ensemble') {
		sInstrumentSound = 'drum.tenor-drum';
	}
	case ('tenor drum') {
		sInstrumentSound = 'drum.tenor-drum';
	}
	case ('tom-tom.electric') {
		sInstrumentSound = 'drum.tom-tom.synth';
	}
	case ('tom-tom.rototom') {
		sInstrumentSound = 'drum.rototom';
	}
	case ('tom-tom') {
		sInstrumentSound = 'drum.tom-tom';
	}
	case ('kit.gm') {
		sInstrumentSound = 'drum.group.set';
	}
	case ('tambourine.pandeiro') {
		sInstrumentSound = 'drum.pandeiro';
	}
	case ('tambourine') {
		sInstrumentSound = 'drum.tambourine';
	}
	case ('bongo') {
		sInstrumentSound = 'drum.bongo';
	}
	case ('cajon') {
		sInstrumentSound = 'drum.cajon';
	}
	case ('conga') {
		sInstrumentSound = 'drum.conga';
	}
	case ('cuica') {
		sInstrumentSound = 'drum.cuica';
	}
	case ('djembe') {
		sInstrumentSound = 'drum.djembe';
	}
	case ('dumbek') {
		sInstrumentSound = 'drum.dumbek';
	}
	case ('frame drum') {
		sInstrumentSound = 'drum.frame-drum';
	}
	case ('kick drum') {
		sInstrumentSound = 'drum.kick-drum';
	}
	case ('log drum') {
		sInstrumentSound = 'drum.log-drum';
	}
	case ('tabla.bayan') {
		sInstrumentSound = 'drum.tabla.bayan';
	}
	case ('tabla.dayan') {
		sInstrumentSound = 'drum.tabla.dayan';
	}
	case ('tabla') {
		sInstrumentSound = 'drum.tabla';
	}
	case ('taiko') {
		sInstrumentSound = 'drum.taiko';
	}
	case ('the box') {
		sInstrumentSound = 'drum.the-box';
	}
	case ('timbale') {
		sInstrumentSound = 'drum.timbale';
	}
	case ('atsimevu') {
		sInstrumentSound = 'drum.atsimevu';
	}
	case ('bata.itotele') {
		sInstrumentSound = 'drum.bata.itotele';
	}
	case ('bata.iya') {
		sInstrumentSound = 'drum.bata.iya';
	}
	case ('bata.okonkolo') {
		sInstrumentSound = 'drum.bata.okonkolo';
	}
	case ('bata') {
		sInstrumentSound = 'drum.bata';
	}
	case ('ewe') {
		sInstrumentSound = 'drum.group.ewe';
	}
	case ('kendhang.ageng') {
		sInstrumentSound = 'drum.kendhang.ageng';
	}
	case ('kendhang.ciblon') {
		sInstrumentSound = 'drum.kendhang.ciblon';
	}
	case ('kendhang') {
		sInstrumentSound = 'drum.kendhang';
	}
	case ('kidi') {
		sInstrumentSound = 'drum.kidi';
	}
	case ('surdo') {
		sInstrumentSound = 'drum.surdo';
	}
	case ('udu') {
		sInstrumentSound = 'drum.udu';
	}
}

return sInstrumentSound;
}"
	GetWoodSound "(Lookup) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get the MusicXML instrument sound from the
// lookup part of a Sibelius unpitched wood sound ID.

sInstrumentSound = '';
switch (Lookup) {
	case ('castanets') {
		sInstrumentSound = 'wood.castanets';
	}
	case ('claves') {
		sInstrumentSound = 'wood.claves';
	}
	case ('drum sticks') {
		sInstrumentSound = 'wood.drum-sticks';
	}
	case ('gourd') {
		sInstrumentSound = 'wood.gourd';
	}
	case ('granite block') {
		sInstrumentSound = 'wood.granite-block';
	}
	case ('guira') {
		sInstrumentSound = 'metal.guira';
	}
	case ('guiro') {
		sInstrumentSound = 'wood.guiro';
	}
	case ('jam block') {
		sInstrumentSound = 'wood.jam-block';
	}
	case ('metronome click') {
		sInstrumentSound = 'wood.metronome-click';
	}
	case ('slapsticks') {
		sInstrumentSound = 'wood.slapstick';
	}
	case ('tang tang') {
		sInstrumentSound = 'wood.tonetang';
	}
	case ('temple block') {
		sInstrumentSound = 'wood.temple-block';
	}
	case ('woodblock') {
		sInstrumentSound = 'wood.wood-block';
	}
}

return sInstrumentSound;
}"
	GetExoticSound "(SoundId) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get the MusicXML instrument sound from a
// Sibelius unpitched exotic sound ID.

sInstrumentSound = '';
sLookup = Substring(SoundId, 17);

switch (sLookup) {
	case ('acoustic bass string slap') {
		sInstrumentSound = 'effect.bass-string-slap';
	}
	case ('applause') {
		sInstrumentSound = 'effect.applause';
	}
	case ('berimbau') {
		sInstrumentSound = 'metal.berimbau';
	}
	case ('bird.nightingale') {
		sInstrumentSound = 'effect.bird.nightingale';
	}
	case ('bird.tweet') {
		sInstrumentSound = 'effect.bird.tweet';
	}
	case ('bird') {
		sInstrumentSound = 'effect.bird';
	}
	case ('breath noise') {
		sInstrumentSound = 'effect.breath';
	}
	case ('bubble') {
		sInstrumentSound = 'effect.bubble';
	}
	case ('burst') {
		sInstrumentSound = 'effect.burst';
	}
	case ('car.crash') {
		sInstrumentSound = 'effect.car.crash';
	}
	case ('car.engine') {
		sInstrumentSound = 'effect.car.engine';
	}
	case ('car.pass') {
		sInstrumentSound = 'effect.car.pass';
	}
	case ('car.stop') {
		sInstrumentSound = 'effect.car.stop';
	}
	case ('car') {
		sInstrumentSound = 'effect.car';
	}
	case ('cricket') {
		sInstrumentSound = 'effect.crickets';
	}
	case ('dog') {
		sInstrumentSound = 'effect.dog';
	}
	case ('door creak') {
		sInstrumentSound = 'effect.door.creak';
	}
	case ('door slam') {
		sInstrumentSound = 'effect.door.slam';
	}
	case ('explosion') {
		sInstrumentSound = 'effect.explosion';
	}
	case ('finger click') {
		sInstrumentSound = 'effect.snap';
	}
	case ('flute key click') {
		sInstrumentSound = 'effect.flute-key-click';
	}
	case ('footsteps.marching machine') {
		sInstrumentSound = 'effect.marching-machine';
	}
	case ('footsteps') {
		sInstrumentSound = 'effect.footsteps';
	}
	case ('frogs') {
		sInstrumentSound = 'effect.frogs';
	}
	case ('guitar cutting') {
		sInstrumentSound = 'effect.guitar-cutting';
	}
	case ('guitar fret') {
		sInstrumentSound = 'effect.guitar-fret';
	}
	case ('gunshot') {
		sInstrumentSound = 'effect.gunshot';
	}
	case ('hand clap') {
		sInstrumentSound = 'effect.hand-clap';
	}
	case ('heartbeat') {
		sInstrumentSound = 'effect.heartbeat';
	}
	case ('helicopter') {
		sInstrumentSound = 'effect.helicopter';
	}
	case ('high q') {
		sInstrumentSound = 'effect.high-q';
	}
	case ('horse gallop') {
		sInstrumentSound = 'effect.horse-gallop';
	}
	case ('jet plane') {
		sInstrumentSound = 'effect.jet-plane';
	}
	case ('laser gun') {
		sInstrumentSound = 'effect.laser-gun';
	}
	case ('laugh') {
		sInstrumentSound = 'effect.laugh';
	}
	case ('lion\'s roar') {
		sInstrumentSound = 'effect.lions-roar';
	}
	case ('machine gun') {
		sInstrumentSound = 'effect.machine-gun';
	}
	case ('punch') {
		sInstrumentSound = 'effect.punch';
	}
	case ('rain') {
		sInstrumentSound = 'effect.rain';
	}
	case ('scratch') {
		sInstrumentSound = 'effect.scratch';
	}
	case ('scream') {
		sInstrumentSound = 'effect.scream';
	}
	case ('seashore') {
		sInstrumentSound = 'effect.seashore';
	}
	case ('siren') {
		sInstrumentSound = 'effect.siren';
	}
	case ('slap') {
		sInstrumentSound = 'effect.slap';
	}
	case ('starship') {
		sInstrumentSound = 'effect.starship';
	}
	case ('stream') {
		sInstrumentSound = 'effect.stream';
	}
	case ('telephone ring') {
		sInstrumentSound = 'effect.telephone-ring';
	}
	case ('thunder.thundersheet') {
		sInstrumentSound = 'metal.thundersheet';
	}
	case ('thunder') {
		sInstrumentSound = 'effect.thunder';
	}
	case ('train') {
		sInstrumentSound = 'effect.train';
	}
	case ('trash can') {
		sInstrumentSound = 'effect.trash-can';
	}
	case ('whip') {
		sInstrumentSound = 'effect.whip';
	}
	case ('wind') {
		sInstrumentSound = 'effect.wind';
	}
}

return sInstrumentSound;
}"
	GetMetalSound "(SoundId) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get the MusicXML instrument sound from a
// Sibelius unpitched metal sound ID.

sInstrumentSound = '';
sLookup = Substring(SoundId, 16);

switch (sLookup) {
	case ('bells.agogo') {
		sInstrumentSound = 'metal.bells.agogo';
	}
	case ('bells.ankle') {
		sInstrumentSound = 'metal.bells.ghungroo';
	}
	case ('bells.anvil') {
		sInstrumentSound = 'metal.anvil';
	}
	case ('bells.bell plate') {
		sInstrumentSound = 'metal.bells.bell-plate';
	}
	case ('bells.bell tree') {
		sInstrumentSound = 'metal.bells.bell-tree';
	}
	case ('bells.brake drums') {
		sInstrumentSound = 'metal.brake-drums';
	}
	case ('bells.chimes') {
		sInstrumentSound = 'metal.bells.chimes';
	}
	case ('bells.cowbell') {
		sInstrumentSound = 'metal.bells.agogo';
	}
	case ('bells.gankokwe') {
		sInstrumentSound = 'metal.bells.gankokwe';
	}
	case ('bells.jingle bell') {
		sInstrumentSound = 'metal.bells.jingle-bell';
	}
	case ('bells.mark tree') {
		sInstrumentSound = 'metal.bells.mark-tree';
	}
	case ('bells.metronome bell') {
		sInstrumentSound = 'effect.metronome-bell';
	}
	case ('bells.sleigh bells') {
		sInstrumentSound = 'metal.bells.sleigh-bells';
	}
	case ('bells.triangle') {
		sInstrumentSound = 'metal.triangle';
	}
	case ('bells.wind chimes') {
		sInstrumentSound = 'metal.bells.wind-chimes';
	}
	case ('bells.zil-bells') {
		sInstrumentSound = 'metal.bells.zills';
	}
	case ('hi-hat.ensemble') {
		sInstrumentSound = 'metal.hi-hat';
	}
	case ('hi-hat') {
		sInstrumentSound = 'metal.hi-hat';
	}
	case ('cymbal.chinese') {
		sInstrumentSound = 'metal.cymbal.chinese';
	}
	case ('cymbal.clash') {
		sInstrumentSound = 'metal.cymbal.clash';
	}
	case ('cymbal.ensemble.crash') {
		sInstrumentSound = 'metal.cymbal.crash';
	}
	case ('cymbal.crash') {
		sInstrumentSound = 'metal.cymbal.crash';
	}
	case ('cymbal.finger') {
		sInstrumentSound = 'metal.cymbal.finger';
	}
	case ('cymbal.reverse') {
		sInstrumentSound = 'metal.cymbal.reverse';
	}
	case ('cymbal.ride') {
		sInstrumentSound = 'metal.cymbal.ride';
	}
	case ('cymbal.ensemble.sizzle') {
		sInstrumentSound = 'metal.cymbal.sizzle';
	}
	case ('cymbal.sizzle') {
		sInstrumentSound = 'metal.cymbal.sizzle';
	}
	case ('cymbal.splash') {
		sInstrumentSound = 'metal.cymbal.splash';
	}
	case ('cymbal.suspended') {
		sInstrumentSound = 'metal.cymbal.suspended';
	}
	case ('cymbal.tam tam') {
		sInstrumentSound = 'metal.tamtam';
	}
	case ('cymbal.gong.chinese') {
		sInstrumentSound = 'metal.gong.chinese';
	}
	case ('cymbal.gong.thai') {
		sInstrumentSound = 'metal.gong.thai';
	}
	case ('cymbal.gong.gamelan.ageng') {
		sInstrumentSound = 'metal.gong.ageng';
	}
	case ('cymbal.gong.gamelan.kempyang') {
		sInstrumentSound = 'metal.gong.kempyang';
	}
	case ('cymbal.gong.gamelan.ketuk') {
		sInstrumentSound = 'metal.gong.ketuk';
	}
	case ('cymbal.gong') {
		sInstrumentSound = 'metal.gong';
	}
	case ('flexatone') {
		sInstrumentSound = 'metal.flexatone';
	}
	case ('jaw harp') {
		sInstrumentSound = 'metal.jaw-harp';
	}
}

return sInstrumentSound;
}"
	GetRattleSound "(SoundId) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get the MusicXML instrument sound from a
// Sibelius unpitched rattle sound ID.

sInstrumentSound = '';
sLookup = Substring(SoundId, 17);

switch (sLookup) {
	case ('maraca') {
		sInstrumentSound = 'rattle.maraca';
	}
	case ('cabasa') {
		sInstrumentSound = 'rattle.cabasa';
	}
	case ('jawbone') {
		sInstrumentSound = 'rattle.jawbone';
	}
	case ('rainsticks') {
		sInstrumentSound = 'rattle.rain-stick';
	}
	case ('ratchet') {
		sInstrumentSound = 'rattle.ratchet';
	}
	case ('birds meinl') {
		sInstrumentSound = 'rattle.birds';
	}
	case ('vibraslap') {
		sInstrumentSound = 'rattle.vibraslap';
	}
	case ('shaker.caxixi') {
		sInstrumentSound = 'rattle.caxixi';
	}
	case ('shaker.egg') {
		sInstrumentSound = 'rattle.shaker.egg';
	}
	case ('shaker.ganza') {
		sInstrumentSound = 'rattle.ganza';
	}
	case ('shaker.kayamba') {
		sInstrumentSound = 'rattle.kayamba';
	}
	case ('shaker.shekere') {
		sInstrumentSound = 'rattle.shekere';
	}
	case ('shaker.wasembe') {
		sInstrumentSound = 'rattle.wasembe';
	}
	case ('shaker') {
		sInstrumentSound = 'rattle.shaker';
	}
}

return sInstrumentSound;
}"
	GetPlaySequence "(BarObject) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return a comma-separated string constructed from
// GetPlayedOnNthPass values.

sSequence = '';
nPasses = 0;
for i = 1 to 9 {
	if (BarObject.GetPlayedOnNthPass(i)) {
		if (nPasses = 0) {
			sSequence = sSequence & i;
		} else {
			sSequence = sSequence & ', ' & i;
		}
		nPasses = nPasses + 1;
	}
}

// Return an empty string if all passes are on.
if (nPasses = 8) {
	sSequence = '';
}
return sSequence;
}"
	LeftEndingBumped
	TiedStartCount
	TiedStopCount
	GetDisplayedPage "(BarObject) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get the displayed page number, taking blank page offsets into account.
if (BarObject.OnNthBlankPage != 0) {
	nPage = BarObject.ParentBar.OnNthPage + 1 + BarObject.OnNthBlankPage;
	sPage = Sibelius.ActiveScore.InternalPageNumToExternalPageNum(nPage);
} else {
	sPage = BarObject.ParentBar.OnNthPageExternal;
}
return sPage;
}"
	GetCreditTypes "(SystemText) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return a sparse array of credit types to use for the system text.
// The credit-type element was added in MusicXML 3.0.

oCreditTypes = CreateSparseArray();
nCounter = 0;
oTexts = SystemText.TextWithFormatting;

// Check for a credit type based on the style id.
sStyleId = '' & SystemText.StyleId;
sStyleCreditType = '';

if (IndexOf('.title', sStyleId) >= 0) {
	sStyleCreditType = 'title';
} else {
	if (IndexOf('.subtitle', sStyleId) >= 0) {
		sStyleCreditType = 'subtitle';
	} else {
		if (IndexOf('.copyright', sStyleId) >= 0) {
			sStyleCreditType = 'rights';
		} else {
			if (IndexOf('.composer', sStyleId) >= 0) {
				sStyleCreditType = 'composer';
			} else {
				if (IndexOf('.lyricist', sStyleId) >= 0) {
					sStyleCreditType = 'lyricist';
				} else {
					if (IndexOf('.arrange', sStyleId) >= 0) {
						sStyleCreditType = 'arranger';
					}
				}
			}
		}
	}
}
if (Length(sStyleCreditType) > 0) {
	oCreditTypes[nCounter] = sStyleCreditType;
	nCounter = nCounter + 1;
}

for i = 0 to oTexts.NumChildren {
	sText = '' & oTexts[i];
	if (Length(sText) > 3) {
		sFirstChar = '' & CharAt(sText, 0);
		sSecondChar = '' & CharAt(sText, 1);
		if (sFirstChar = '\\' and sSecondChar = '$') {
			sCreditType = GetWildcardCreditType(sText, GetDisplayedPage(SystemText));
			if ((Length(sCreditType) > 0) and 
				 (not (sCreditType = sStyleCreditType))) {
				oCreditTypes[nCounter] = sCreditType;
				nCounter = nCounter + 1;
			}
		}
	}
}

return oCreditTypes;
}"
	GetWildcardCreditType "(Wildcard, DisplayedPage) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return a credit type for a particular wildcard, including
// the backslash and $ characters. The credit-type element 
// was added in MusicXML 3.0.

// Strip off the bracketing characters
sWildcard = Substring(Wildcard, 2, Length(Wildcard) - 3);

// Wildcard names are case insensitive, so convert
// everything to lowercase.
sWildcard = ToAsciiLowercase(sWildcard);

sCreditType = '';
switch (sWildcard) {
	// Do not add credit-type if wildcard points to an empty string
	case ('title') {
		if (Length(Sibelius.ActiveScore.Title) > 0) {
			sCreditType = sWildcard;
		}
	}
	case ('composer') {
		if (Length(Sibelius.ActiveScore.Composer) > 0) {
			sCreditType = sWildcard;
		}
	}
	case ('arranger') {
		if (Length(Sibelius.ActiveScore.Arranger) > 0) {
			sCreditType = sWildcard;
		}
	}
	case ('lyricist') {
		if (Length(Sibelius.ActiveScore.Lyricist) > 0) {
			sCreditType = sWildcard;
		}
	}
	case ('copyright') {
		if (Length(Sibelius.ActiveScore.Copyright) > 0) {
			sCreditType = 'rights';
		}
	}
	case ('partname') {
		if (Length(Sibelius.ActiveScore.PartName) > 0) {
			sCreditType = 'part name';
		}
	}
	case ('headerpartname') {
		if (Length(Sibelius.ActiveScore.PartName) > 0) {
			sCreditType = 'part name';
		}
	}
	case ('pagenum') {
		if (Length(DisplayedPage) > 0) {
			sCreditType = 'page number';
		}
	}
	default {
		sCreditType = '';
	}
}

return sCreditType;
}"
	StemWeight
	AddDegreeSymbol "(DegreeSymbol) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Add a degree symbol attribute value to the
// global arrays for the previous degree.
nDegreeCount = DegreeCount - 1;
if (nDegreeCount >= 0) {
	DegreeSymbols[nDegreeCount] = '' & DegreeSymbol;
}
}"
	MusicTextFontName
	MainTextFontName
	MainTextFontSize
	SoftHyphen
	Undertie
	StemXml
	XmlText
	XmlTextBufferSize
	XmlCrLf
	TextRepeatPlayback
	FineBar
	SegnoBar
	CodaBar
	ToCodaBar
	DcFineBar
	DcCodaBar
	DsFineBar
	DsCodaBar
	UnknownRepeatBar
	LastEndRepeatBar
	InitialTopSystemDistanceAddition
	GetNonNegativeInteger "(ThisText) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Convert non-negative integer string to a numeric value.
// Return -1 if the string does not represent a non-negative 
// integer.

if (ThisText = 0) {
	return -1;
}

if (ThisText = '') {
	return -1;
}

nTotal = 0;
nTextLength = Length(ThisText);
for i = 0 to nTextLength {
	sChar = CharAt(ThisText, i);
	nVal = Asc(sChar);
	if ((nVal < '0') or (nVal > '9')) {
		return -1;
	}
}

return 0 + ThisText;
}"
	SetTextAndRepeatGlobals "(ThisScore) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Set globals for text and repeat data when we need
// information before our single pass through all
// music objects.

// Set the MainTextFontName and MainTextFontSize globals
// to be the most popular initial font name and size used
// for text items in the score, not including music or
// music text fonts. Font size is stored in Sibelius units
// rather than MusicXML units. Use a blank string and 0
// respectively if no non-music text is found.

// For repeats, set global variables that indicate whether
// we are doing playback for text repeats in simple cases
// like a single D.C. al Fine, D.S. al Fine, D.C. al Coda,
// and D.S. al Coda. 

oDictName = CreateDictionary();
oArraySize = CreateSparseArray();
oRepeated = CreateSparseArray();
nLargestNameCount = 0;
nLargestSizeCount = 0;
sMostCommonName = '';
nMostCommonSize = 0;
nSizeCounted = 0;
nTextRepeatCount = 0;
nLastRepeatStart = 1;
nLastRepeatEnd = 0;
fHasRepeatBarlines = False;
sRepeatType = '';

oScore = Sibelius.ActiveScore;
for each oStaff in oScore {
	for each Text oText in oStaff {
		// Do not include fingerings and similar in this poll
		if (not (oText.Hidden or (StartsWith('text.staff.space', oText.StyleId)))) {
			sName = oText.InitialFontName;
			if (Length(sName) > 0) {
				if (not IsMusicalFont(sName)) {
					if (oDictName[sName] = null) {
						oDictName[sName] = 1;
					} else {
						oDictName[sName] = oDictName[sName] + 1;
					}
					if (oDictName[sName] > nLargestNameCount) {
						nLargestNameCount = oDictName[sName];
						sMostCommonName = sName;
					}
					nSize = oText.InitialFontSize;	
					if (nSize > 0) {
						if (oArraySize[nSize] = null) {
							oArraySize[nSize] = 1;
						} else {
							oArraySize[nSize] = oArraySize[nSize] + 1;
						}
						if (oArraySize[nSize] > nLargestSizeCount) {
							nLargestSizeCount = oArraySize[nSize];
							nMostCommonSize = nSize;
						}
						nSizeCounted = nSizeCounted + 1;
					}
				}
			}
		}
	}
}
for each SpecialBarline oBarline in oScore.SystemStaff {
	switch (oBarline.BarlineInternalType) {
		case (SpecialBarlineStartRepeat) {
			nLastRepeatStart = oBarline.ParentBar.BarNumber;
			fHasRepeatBarlines = True;
		}
		case (SpecialBarlineEndRepeat) {
			nLastRepeatEnd = oBarline.ParentBar.BarNumber;
			fHasRepeatBarlines = True;
			for nRepeatBar = nLastRepeatStart to nLastRepeatEnd + 1 {
				oRepeated[nRepeatBar] = True;
			}
			nLastRepeatStart = nLastRepeatEnd + 1;
			LastEndRepeatBar = 0 + nLastRepeatEnd;
		}
	}
}
for each SystemTextItem oSystemText in oScore.SystemStaff {
	sName = oSystemText.InitialFontName;
	if (Length(sName) > 0) {
		if (not (oSystemText.Hidden or (IsMusicalFont(sName)))) {
			if (oDictName[sName] = null) {
				oDictName[sName] = 1;
			} else {
				oDictName[sName] = oDictName[sName] + 1;
			}
			if (oDictName[sName] > nLargestNameCount) {
				nLargestNameCount = oDictName[sName];
				sMostCommonName = sName;
			}
			nSize = oSystemText.InitialFontSize;
			if (nSize > 0) {
				if (oArraySize[nSize] = null) {
					oArraySize[nSize] = 1;
				} else {
					oArraySize[nSize] = oArraySize[nSize] + 1;
				}
				if (oArraySize[nSize] > nLargestSizeCount) {
					nLargestSizeCount = oArraySize[nSize];
					nMostCommonSize = nSize;
				}
				nSizeCounted = nSizeCounted + 1;
			}
		}
	}
	if (StartsWith('text.system.repeat', oSystemText.StyleId)) {
		sRepeatType = GetRepeatType(oSystemText);
		switch (sRepeatType) {
			case ('fine') {
				if (FineBar = 0) {
					FineBar = oSystemText.ParentBar.BarNumber;
					nTextRepeatCount = nTextRepeatCount + 1;
				} else {
					if (FineBar > 0) {
						FineBar = -1;
						nTextRepeatCount = nTextRepeatCount - 1;
					}
				}
			}
			case ('segno') {
				if (SegnoBar = 0) {
					SegnoBar = oSystemText.ParentBar.BarNumber;
					nTextRepeatCount = nTextRepeatCount + 1;
				} else {
					if (SegnoBar > 0) {
						SegnoBar = -1;
						nTextRepeatCount = nTextRepeatCount - 1;
					}
				}
			}
			case ('coda') {
				if (CodaBar = 0) {
					CodaBar = oSystemText.ParentBar.BarNumber;
					nTextRepeatCount = nTextRepeatCount + 1;
				} else {
					if (CodaBar > 0) {
						CodaBar = -1;
						nTextRepeatCount = nTextRepeatCount - 1;
					}
				}
			}
			case ('tocoda') {
				if (ToCodaBar = 0) {
					ToCodaBar = oSystemText.ParentBar.BarNumber;
					nTextRepeatCount = nTextRepeatCount + 1;
				} else {
					if (ToCodaBar > 0) {
						ToCodaBar = -1;
						nTextRepeatCount = nTextRepeatCount - 1;
					}
				}
			}
			case ('dccoda') {
				if (DcCodaBar = 0) {
					DcCodaBar = oSystemText.ParentBar.BarNumber;
					nTextRepeatCount = nTextRepeatCount + 1;
				} else {
					if (DcCodaBar > 0) {
						DcCodaBar = -1;
						nTextRepeatCount = nTextRepeatCount - 1;
					}
				}
			}
			case ('dcfine') {
				if (DcFineBar = 0) {
					DcFineBar = oSystemText.ParentBar.BarNumber;
					nTextRepeatCount = nTextRepeatCount + 1;
				} else {
					if (DcFineBar > 0) {
						DcFineBar = -1;
						nTextRepeatCount = nTextRepeatCount - 1;
					}
				}
			}
			case ('dscoda') {
				if (DsCodaBar = 0) {
					DsCodaBar = oSystemText.ParentBar.BarNumber;
					nTextRepeatCount = nTextRepeatCount + 1;
				} else {
					if (DsCodaBar > 0) {
						DsCodaBar = -1;
						nTextRepeatCount = nTextRepeatCount - 1;
					}
				}
			}
			case ('dsfine') {
				if (DsFineBar = 0) {
					DsFineBar = oSystemText.ParentBar.BarNumber;
					nTextRepeatCount = nTextRepeatCount + 1;
				} else {
					if (DsFineBar > 0) {
						DsFineBar = -1;
						nTextRepeatCount = nTextRepeatCount - 1;
					}
				}
			}
			default {
				UnknownRepeatBar = oSystemText.ParentBar.BarNumber;
			}
		}
	}
}

if (Length(sMostCommonName) > 0) {
	MainTextFontName = '' & sMostCommonName;
}
// Only export default font size if we have more than
// three texts counted. That way we are more likely to
// avoid some strange font size default choices without
// making files much more complex.
if ((nMostCommonSize > 0) and (nSizeCounted > 3)) {
	MainTextFontSize = 0 + nMostCommonSize;
}

// Determine if we support this repeat combination for playback.
if (UnknownRepeatBar = 0) {
	switch (nTextRepeatCount) {
		case (2) {
			if ((FineBar > 0) and (DcFineBar > 0)) {
				if (FineBar < DcFineBar) {
					if (oRepeated[FineBar] = null) {
						TextRepeatPlayback = True;
					}
				}
			}
		}
		case (3) {
			if ((FineBar > 0) and (DsFineBar > 0) and (SegnoBar > 0)) {
				if ((SegnoBar < FineBar) and (FineBar < DsFineBar)) {
					if (oRepeated[FineBar] = null) {
						TextRepeatPlayback = True;
					}
				}
			} else {
				if (not fHasRepeatBarlines) {
					if ((CodaBar > 0) and (ToCodaBar > 0) and (DcCodaBar > 0)) {
						if ((ToCodaBar < CodaBar) and (ToCodaBar < DcCodaBar)) {
							TextRepeatPlayback = True;
						}
					}
				}
			}
		}
		case (4) {
			if (not fHasRepeatBarlines) {
				if ((CodaBar > 0) and (ToCodaBar > 0) and (DsCodaBar > 0) and (SegnoBar > 0)) {
					if ((SegnoBar < ToCodaBar) and (ToCodaBar < CodaBar) and (SegnoBar < DsCodaBar)) {
						TextRepeatPlayback = True;
					}
				}
			}
		}
	}
}
}"
	GetGenericTextFont "(TextFontName) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Return the generic type of text font (e.g. serif,
// sans-serif) for appending to a font-family attribute.

sTextFontName = '' & TextFontName;
if (StartsWith('Times', sTextFontName)) {
	return 'serif';
}
if (StartsWith('Arial', sTextFontName)) {
	return 'sans-serif';
}
if (StartsWith('Helvetica', sTextFontName)) {
	return 'sans-serif';
}
if (StartsWith('Quicksand', sTextFontName)) {
	return 'sans-serif';
}
if (StartsWith('Century', sTextFontName)) {
	return 'serif';
}
if (StartsWith('New Century', sTextFontName)) {
	return 'serif';
}
if (StartsWith('Palatino', sTextFontName)) {
	return 'serif';
}
if (StartsWith('Georgia', sTextFontName)) {
	return 'serif';
}
if (StartsWith('Verdana', sTextFontName)) {
	return 'sans-serif';
}
if (StartsWith('Reprise Script', sTextFontName)) {
	return 'cursive';
}
if (StartsWith('Apple Chancery', sTextFontName)) {
	return 'cursive';
}
if (StartsWith('Courier', sTextFontName)) {
	return 'monospace';
}
return '';
}"
	GetDictWords "(BarObject, TextToMatch) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Used for words that precede a metronome mark.
// Return a dictionary with font family, font size,
// xml:space, a music text font flag, and full text
// with line breaks that matches the second argument.

oDictWords = CreateDictionary('text', TextToMatch, 'family', '', 'size', '',
							  'space', '', 'musictext', False);
sInitFamily = BarObject.InitialFontName;
if ((Length(sInitFamily) > 0) and (sInitFamily != MainTextFontName)) {
	oDictWords['family'] = ' font-family=\'' & sInitFamily & '\'';
	if (IsMusicTextFont(sInitFamily)) {
		oDictWords['musictext'] = True;
	}
}
sInitSize = GetFontSize(BarObject.InitialFontSize);
if (BarObject.InitialFontSize != MainTextFontSize) {
	oDictWords['size'] = sInitSize;
}

oSourceText = BarObject.TextWithFormatting;
sDictText = '';
nTextMatchIndex = 0;
fProcessing = True;

for i = 0 to oSourceText.NumChildren {
	sFirstChar = '';
	sSecondChar = '';
	sLastChar = '';
	sSourceText = '' & oSourceText[i];
	
	if (fProcessing) {
		if (Length(sSourceText) > 0) {
			sFirstChar = '' & CharAt(sSourceText, 0);
			if (Length(sSourceText) > 1) {
				sSecondChar = '' & CharAt(sSourceText, 1);
				sLastChar = '' & CharAt(sSourceText, Length(sSourceText) - 1);
			}
		}
		if (sFirstChar = '\\' and sLastChar = '\\') {
			switch (sSecondChar) {
				case ('n') {
					// Add CR if it matches with a space.
					// Compose turns the LF into a space, so use Mac/Unix endings.
					if (CharAt(TextToMatch, nTextMatchIndex) = ' ') {
						sDictText = sDictText & Chr(13);
						oDictWords['space'] = ' xml:space=\'preserve\'';
						nTextMatchIndex = nTextMatchIndex + 1;
					} else {
						if (Length(sDictText) > 0) {
							fProcessing = False;
						}
					}
				}
				case ('N') {
					// Add CR if it matches with a space.
					// Compose turns the LF into a space, so use Mac/Unix endings.
					if (CharAt(TextToMatch, nTextMatchIndex) = ' ') {
						sDictText = sDictText & Chr(13);
						oDictWords['space'] = ' xml:space=\'preserve\'';
						nTextMatchIndex = nTextMatchIndex + 1;
					} else {
						if (Length(sDictText) > 0) {
							fProcessing = False;
						}
					}
				}
				case ('s') {
					if ((Length(sDictText) = 0) and (Length(sInitSize) = 0) and
						(Length(sSourceText) > 3)) {
						nSize = 0 + Substring(sSourceText, 2, Length(sSourceText) - 3);
						sSize = GetFontSize(nSize);
						if ((Length(sSize) > 0) and (nSize != MainTextFontSize)) {
							if (Length(oDictWords['size']) = 0) {
								oDictWords['size'] = sSize;
							} else {
								// If the size changes midway through, give up
								oDictWords['size'] = '';
							}
						}
					}
				}
				case ('f') {
					if (CharAt(sSourceText, 2) = '_') {
						oDictWords['family'] = '';
						oDictWords['size'] = '';
						oDictWords['musictext'] = False;
					} else {
						if ((Length(sDictText) = 0) and (Length(sInitFamily) = 0) and
							(Length(sSourceText) > 3)) {
							sFamily = Substring(sSourceText, 2, Length(sSourceText) - 3);
							if ((Length(sFamily) > 0) and (sFamily != MainTextFontName)) {
								if (Length(oDictWords['family']) = 0) {
									oDictWords['family'] = ' font-family=\'' & sFamily & '\'';
									if (IsMusicTextFont(sFamily)) {
										oDictWords['musictext'] = True;
									}
								} else {
									// If the family changes midway through, give up
									oDictWords['family'] = '';
									oDictWords['musictext'] = False;
								}
							}
						}
					}
				}
				case ('c') {
					if (sSourceText = '\\ctext.character.musictext\\') {
						fProcessing = False;
					}
				}
				case ('$') {
					// Give up if we have a wildcard
					fProcessing = False;
				}
			}
		} else {
			// Match text one character at a time against input string.
			for j = 0 to Length(sSourceText) {
				if (fProcessing) {
					sSourceChar = '' & CharAt(sSourceText, j);
					sMatchChar = '' & CharAt(TextToMatch, nTextMatchIndex);
					if (sSourceChar = sMatchChar) {
						sDictText = sDictText & sSourceChar;
						nTextMatchIndex = nTextMatchIndex + 1;
						if (nTextMatchIndex = Length(TextToMatch)) {
							fProcessing = False;
							oDictWords['text'] = sDictText;
						}
					} else {
						fProcessing = False;
					}
				}
			}
		}
	}
}

return oDictWords;
}"
	GetRepeatType "(BarObject) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get a repeat type based on the text. We assume
// that the StyleId check has been done before calling
// this method.

// Strip spaces from string, then periods
sText = BarObject.Text;
oSplit = SplitString(sText, ' ', True);
sText = JoinStrings(oSplit, '');
oSplit = SplitString(sText, '.', True);
sText = JoinStrings(oSplit, '');
sText = ToAsciiLowercase(sText);

// Lookup in our dictionary of known texts.
sRepeatType = KnownTextRepeats[sText];
if (sRepeatType = null) {
	sRepeatType = '';
}
return sRepeatType;
}"
	GetRepeatPlayback "(BarObject) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Get repeat playback for a text repeat.
sSound = '';
if (not TextRepeatPlayback) {
	return sSound;
}
sType = GetRepeatType(BarObject);
nBar = BarObject.ParentBar.BarNumber;
switch (sType) {
	case ('fine') {
		if (nBar = FineBar) {
			sSound = ' fine=\'yes\' time-only=\'2\'';
		}
	}
	case ('segno') {
		if (nBar = SegnoBar) {
			sSound = ' segno=\'' & SegnoBar & '\'';
		}
	}
	case ('coda') {
		if (nBar = CodaBar) {
			sSound = ' coda=\'' & CodaBar & '\'';
		}
	}
	case ('tocoda') {
		if (nBar = ToCodaBar) {
			sSound = ' tocoda=\'' & CodaBar & '\'';
		}
	}
	case ('dccoda') {
		if (nBar = DcCodaBar) {
			sSound = ' dacapo=\'yes\'';
			if (nBar = LastEndRepeatBar) {
				sSound = sSound & ' time-only=\'2\'';
			}
		}
	}
	case ('dcfine') {
		if (nBar = DcFineBar) {
			sSound = ' dacapo=\'yes\'';
			if (nBar = LastEndRepeatBar) {
				sSound = sSound & ' time-only=\'2\'';
			}
		}
	}
	case ('dscoda') {
		if (nBar = DsCodaBar) {
			sSound = ' dalsegno=\'' & SegnoBar & '\'';
			if (nBar = LastEndRepeatBar) {
				sSound = sSound & ' time-only=\'2\'';
			}
		}
	}
	case ('dsfine') {
		if (nBar = DsFineBar) {
			sSound = ' dalsegno=\'' & SegnoBar & '\'';
			if (nBar = LastEndRepeatBar) {
				sSound = sSound & ' time-only=\'2\'';
			}
		}
	}
}

return sSound;
}"
	IsSymbol "(MusicTextString) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// If this music text string represents a MusicXML symbol
// or credit-symbol, return the content string for that
// element. Currently only works with single-character text.
sSymbol = '';
if (Length(MusicTextString) = 1) {
	nLookupChar = CharAt(MusicTextString, 0);
	sLookup = MusicTextSymbols[nLookupChar];
	if (sLookup != null) {
		sSymbol = sLookup;
	}
}
return sSymbol;
}"
	Staves
	WriteAnnotationItem "(BarObject, StaffNumber) {
// Dolet 8 for Sibelius
// Copyright © 2003-2023 MakeMusic, Inc.

// Nothing to write here, but need a method anyway.
x = 1;
}"
}