diff --git a/.circleci/Dockerfile b/.circleci/Dockerfile new file mode 100644 index 000000000..aa0477e5d --- /dev/null +++ b/.circleci/Dockerfile @@ -0,0 +1,10 @@ +FROM debian:9.8 + +RUN apt-get update && apt-get install -y \ + git \ + ssh \ + tar \ + gzip \ + ca-certificates \ + cmake \ + build-essential diff --git a/.circleci/Dockerfile.test b/.circleci/Dockerfile.test new file mode 100644 index 000000000..ead894ed0 --- /dev/null +++ b/.circleci/Dockerfile.test @@ -0,0 +1,6 @@ +FROM matthewjamesbriggs/mxci:v001 + +ENV BASEDIR="/mx" +WORKDIR $BASEDIR +COPY . . +CMD cmake . && make -j12 && ./MxTest diff --git a/.circleci/config.yml b/.circleci/config.yml new file mode 100644 index 000000000..958f884af --- /dev/null +++ b/.circleci/config.yml @@ -0,0 +1,59 @@ +version: 2 +jobs: + build: + docker: + # specify the version you desire here + - image: matthewjamesbriggs/mxci:v001 + + resource_class: xlarge + working_directory: ~/mx + + steps: + - checkout + + # Download and cache dependencies + # - restore_cache: + # keys: + # - iqcache-{{ checksum ".circleci/cache-lock" }}-{{ checksum "iqtestdata/.cache-lock" }} + # # fallback to using the latest cache if no exact match is found + # - iqcache- + + # - run: yarn install --cache-folder ~/yarn-cache + + # - run: + # name: Install Git LFS + # command: | + # curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash + # sudo apt-get update + # sudo apt-get install -y git-lfs openssh-client + # git lfs install + # mkdir -p ~/.ssh + # ssh-keyscan -H github.com >> ~/.ssh/known_hosts + # ssh git@github.com git-lfs-authenticate "${CIRCLE_PROJECT_USERNAME}/${CIRCLE_PROJECT_REPONAME}" download + # git lfs pull + + # - save_cache: + # paths: + # - node_modules + # - iqtestdata + # - web/node_modules + # - iqbak/node_modules + # - iqshared/node_modules + # - ~/yarn-cache + + # key: iqcache-{{ checksum ".circleci/cache-lock" }}-{{ checksum "iqtestdata/.cache-lock" }} + + - run: + name: Cmake + command: cmake . + + - run: + name: Build + command: make + + - run: + name: Test + command: ./MxTest + + # - store_artifacts: + # path: /tmp/coverage/ diff --git a/.circleci/docker.sh b/.circleci/docker.sh new file mode 100755 index 000000000..705a80326 --- /dev/null +++ b/.circleci/docker.sh @@ -0,0 +1,18 @@ +THIS_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null && pwd )" +MX_DIR="$THIS_DIR/.." +cd "$THIS_DIR" + +docker build \ + -f "$THIS_DIR/Dockerfile" \ + -t matthewjamesbriggs/mxci:v001 \ + "$THIS_DIR" + +docker rm -f mxtestcontainer || true; +docker rmi -f mxtestimage || true; + +docker build \ + -f "$THIS_DIR/Dockerfile.test" \ + -t mxtestimage \ + "$MX_DIR" + +docker run -it --name mxtestcontainer mxtestimage \ No newline at end of file diff --git a/.gitignore b/.gitignore index 4d0d21a3c..965761ecd 100755 --- a/.gitignore +++ b/.gitignore @@ -22,6 +22,7 @@ Proj/ */project.xcworkspace/ cmake-build* cmake-build* +*.sublime-workspace ######################################### # Ignore Test Output and Expected Files # @@ -53,226 +54,553 @@ xcuserdata/ *.xccheckout *.xcscmblueprint -##################################### -# CLion # -##################################### -.idea/ -######################### http://stackoverflow.com/questions/49478/git-ignore-file-for-xcode-projects -# .gitignore file for Xcode4 and Xcode5 Source projects -# -# Apple bugs, waiting for Apple to fix/respond: -# -# 15564624 - what does the xccheckout file in Xcode5 do? Where's the documentation? -# -# Version 2.6 -# For latest version, see: http://stackoverflow.com/questions/49478/git-ignore-file-for-xcode-projects -# -# 2015 updates: -# - Fixed typo in "xccheckout" line - thanks to @lyck for pointing it out! -# - Fixed the .idea optional ignore. Thanks to @hashier for pointing this out -# - Finally added "xccheckout" to the ignore. Apple still refuses to answer support requests about this, but in practice it seems you should ignore it. -# - minor tweaks from Jona and Coeur (slightly more precise xc* filtering/names) -# 2014 updates: -# - appended non-standard items DISABLED by default (uncomment if you use those tools) -# - removed the edit that an SO.com moderator made without bothering to ask me -# - researched CocoaPods .lock more carefully, thanks to Gokhan Celiker -# 2013 updates: -# - fixed the broken "save personal Schemes" -# - added line-by-line explanations for EVERYTHING (some were missing) -# -# NB: if you are storing "built" products, this WILL NOT WORK, -# and you should use a different .gitignore (or none at all) -# This file is for SOURCE projects, where there are many extra -# files that we want to exclude -# -######################### +# Created by https://www.gitignore.io/api/cmake,linux,xcode,macos,clion,windows,visualstudio +# Edit at https://www.gitignore.io/?templates=cmake,linux,xcode,macos,clion,windows,visualstudio + +### CLion ### +# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm +# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 + +# User-specific stuff +.idea/**/workspace.xml +.idea/**/tasks.xml +.idea/**/usage.statistics.xml +.idea/**/dictionaries +.idea/**/shelf -##### -# OS X temporary files that should never be committed -# -# c.f. http://www.westwind.com/reference/os-x/invisibles.html +# Generated files +.idea/**/contentModel.xml -.DS_Store +# Sensitive or high-churn files +.idea/**/dataSources/ +.idea/**/dataSources.ids +.idea/**/dataSources.local.xml +.idea/**/sqlDataSources.xml +.idea/**/dynamic.xml +.idea/**/uiDesigner.xml +.idea/**/dbnavigator.xml -# c.f. http://www.westwind.com/reference/os-x/invisibles.html +# Gradle +.idea/**/gradle.xml +.idea/**/libraries -.Trashes +# Gradle and Maven with auto-import +# When using Gradle or Maven with auto-import, you should exclude module files, +# since they will be recreated, and may cause churn. Uncomment if using +# auto-import. +# .idea/modules.xml +# .idea/*.iml +# .idea/modules -# c.f. http://www.westwind.com/reference/os-x/invisibles.html +# CMake +cmake-build-*/ -*.swp +# Mongo Explorer plugin +.idea/**/mongoSettings.xml -# -# *.lock - this is used and abused by many editors for many different things. -# For the main ones I use (e.g. Eclipse), it should be excluded -# from source-control, but YMMV. -# (lock files are usually local-only file-synchronization on the local FS that should NOT go in git) -# c.f. the "OPTIONAL" section at bottom though, for tool-specific variations! -# -# In particular, if you're using CocoaPods, you'll want to comment-out this line: -*.lock +# File-based project format +*.iws +# IntelliJ +out/ -# -# profile - REMOVED temporarily (on double-checking, I can't find it in OS X docs?) -#profile +# mpeltonen/sbt-idea plugin +.idea_modules/ +# JIRA plugin +atlassian-ide-plugin.xml -#### -# Xcode temporary files that should never be committed -# -# NB: NIB/XIB files still exist even on Storyboard projects, so we want this... +# Cursive Clojure plugin +.idea/replstate.xml -*~.nib +# Crashlytics plugin (for Android Studio and IntelliJ) +com_crashlytics_export_strings.xml +crashlytics.properties +crashlytics-build.properties +fabric.properties +# Editor-based Rest Client +.idea/httpRequests -#### -# Xcode build files - -# -# NB: slash on the end, so we only remove the FOLDER, not any files that were badly named "DerivedData" +# Android studio 3.1+ serialized cache file +.idea/caches/build_file_checksums.ser -DerivedData/ +# JetBrains templates +**___jb_tmp___ -# NB: slash on the end, so we only remove the FOLDER, not any files that were badly named "build" +### CLion Patch ### +# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721 -build/ -Build/ +# *.iml +# modules.xml +# .idea/misc.xml +# *.ipr +# Sonarlint plugin +.idea/sonarlint -##### -# Xcode private settings (window sizes, bookmarks, breakpoints, custom executables, smart groups) -# -# This is complicated: -# -# SOMETIMES you need to put this file in version control. -# Apple designed it poorly - if you use "custom executables", they are -# saved in this file. -# 99% of projects do NOT use those, so they do NOT want to version control this file. -# ..but if you're in the 1%, comment out the line "*.pbxuser" +### CMake ### +CMakeLists.txt.user +CMakeCache.txt +CMakeFiles +CMakeScripts +Testing +Makefile +cmake_install.cmake +install_manifest.txt +compile_commands.json +CTestTestfile.cmake +_deps -# .pbxuser: http://lists.apple.com/archives/xcode-users/2004/Jan/msg00193.html +### CMake Patch ### +# External projects +*-prefix/ + +### Linux ### +*~ + +# temporary files which can be created if a process still has a handle open of a deleted file +.fuse_hidden* + +# KDE directory preferences +.directory + +# Linux trash folder which might appear on any partition or disk +.Trash-* -*.pbxuser +# .nfs files are created when an open file is removed but is still being accessed +.nfs* -# .mode1v3: http://lists.apple.com/archives/xcode-users/2007/Oct/msg00465.html +### macOS ### +# General +.DS_Store +.AppleDouble +.LSOverride -*.mode1v3 +# Icon must end with two \r +Icon -# .mode2v3: http://lists.apple.com/archives/xcode-users/2007/Oct/msg00465.html +# Thumbnails +._* -*.mode2v3 +# Files that might appear in the root of a volume +.DocumentRevisions-V100 +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes +.VolumeIcon.icns +.com.apple.timemachine.donotpresent -# .perspectivev3: http://stackoverflow.com/questions/5223297/xcode-projects-what-is-a-perspectivev3-file +# Directories potentially created on remote AFP share +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk -*.perspectivev3 +### Windows ### +# Windows thumbnail cache files +Thumbs.db +ehthumbs.db +ehthumbs_vista.db + +# Dump file +*.stackdump -# NB: also, whitelist the default ones, some projects need to use these +# Folder config file +[Dd]esktop.ini + +# Recycle Bin used on file shares +$RECYCLE.BIN/ + +# Windows Installer files +*.cab +*.msi +*.msix +*.msm +*.msp + +# Windows shortcuts +*.lnk + +### Xcode ### +# Xcode +# +# gitignore contributors: remember to update Global/Xcode.gitignore, Objective-C.gitignore & Swift.gitignore + +## User settings +xcuserdata/ + +## compatibility with Xcode 8 and earlier (ignoring not required starting Xcode 9) +*.xcscmblueprint +*.xccheckout + +## compatibility with Xcode 3 and earlier (ignoring not required starting Xcode 4) +build/ +DerivedData/ +*.moved-aside +*.pbxuser !default.pbxuser +*.mode1v3 !default.mode1v3 +*.mode2v3 !default.mode2v3 +*.perspectivev3 !default.perspectivev3 +### Xcode Patch ### +*.xcodeproj/* +!*.xcodeproj/project.pbxproj +!*.xcodeproj/xcshareddata/ +!*.xcworkspace/contents.xcworkspacedata +/*.gcno +**/xcshareddata/WorkspaceSettings.xcsettings + +### VisualStudio ### +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. +## +## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore + +# User-specific files +*.rsuser +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Mono auto generated files +mono_crash.* + +# Build results +[Dd]ebug/ +[Dd]ebugPublic/ +[Rr]elease/ +[Rr]eleases/ +x64/ +x86/ +[Aa][Rr][Mm]/ +[Aa][Rr][Mm]64/ +bld/ +[Bb]in/ +[Oo]bj/ +[Ll]og/ + +# Visual Studio 2015/2017 cache/options directory +.vs/ +# Uncomment if you have tasks that create the project's static files in wwwroot +#wwwroot/ + +# Visual Studio 2017 auto generated files +Generated\ Files/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +# NUNIT +*.VisualState.xml +TestResult.xml + +# Build Results of an ATL Project +[Dd]ebugPS/ +[Rr]eleasePS/ +dlldata.c + +# Benchmark Results +BenchmarkDotNet.Artifacts/ + +# .NET Core +project.lock.json +project.fragment.lock.json +artifacts/ + +# StyleCop +StyleCopReport.xml + +# Files built by Visual Studio +*_i.c +*_p.c +*_h.h +*.ilk +*.meta +*.obj +*.iobj +*.pch +*.pdb +*.ipdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*_wpftmp.csproj +*.log +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc + +# Chutzpah Test files +_Chutzpah* + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opendb +*.opensdf +*.sdf +*.cachefile +*.VC.db +*.VC.VC.opendb + +# Visual Studio profiler +*.psess +*.vsp +*.vspx +*.sap + +# Visual Studio Trace Files +*.e2e + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper +*.DotSettings.user + +# JustCode is a .NET coding add-in +.JustCode + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# AxoCover is a Code Coverage Tool +.axoCover/* +!.axoCover/settings.json + +# Visual Studio code coverage results +*.coverage +*.coveragexml + +# NCrunch +_NCrunch_* +.*crunch*.local.xml +nCrunchTemp_* + +# MightyMoose +*.mm.* +AutoTest.Net/ + +# Web workbench (sass) +.sass-cache/ + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.[Pp]ublish.xml +*.azurePubxml +# Note: Comment the next line if you want to checkin your web deploy settings, +# but database connection strings (with potential passwords) will be unencrypted +*.pubxml +*.publishproj + +# Microsoft Azure Web App publish settings. Comment the next line if you want to +# checkin your Azure Web App publish settings, but sensitive information contained +# in these scripts will be unencrypted +PublishScripts/ + +# NuGet Packages +*.nupkg +# The packages folder can be ignored because of Package Restore +**/[Pp]ackages/* +# except build/, which is used as an MSBuild target. +!**/[Pp]ackages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/[Pp]ackages/repositories.config +# NuGet v3's project.json files produces more ignorable files +*.nuget.props +*.nuget.targets + +# Microsoft Azure Build Output +csx/ +*.build.csdef + +# Microsoft Azure Emulator +ecf/ +rcf/ + +# Windows Store app package directories and files +AppPackages/ +BundleArtifacts/ +Package.StoreAssociation.xml +_pkginfo.txt +*.appx +*.appxbundle +*.appxupload + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!?*.[Cc]ache/ + +# Others +ClientBin/ +~$* +*.dbmdl +*.dbproj.schemaview +*.jfm +*.pfx +*.publishsettings +orleans.codegen.cs + +# Including strong name files can present a security risk +# (https://github.com/github/gitignore/pull/2483#issue-259490424) +#*.snk + +# Since there are multiple workflows, uncomment next line to ignore bower_components +# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) +#bower_components/ + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm +ServiceFabricBackup/ +*.rptproj.bak + +# SQL Server files +*.mdf +*.ldf +*.ndf + +# Business Intelligence projects +*.rdl.data +*.bim.layout +*.bim_*.settings +*.rptproj.rsuser +*- Backup*.rdl + +# Microsoft Fakes +FakesAssemblies/ + +# GhostDoc plugin setting file +*.GhostDoc.xml + +# Node.js Tools for Visual Studio +.ntvs_analysis.dat +node_modules/ + +# Visual Studio 6 build log +*.plg + +# Visual Studio 6 workspace options file +*.opt + +# Visual Studio 6 auto-generated workspace file (contains which files were open etc.) +*.vbw + +# Visual Studio LightSwitch build output +**/*.HTMLClient/GeneratedArtifacts +**/*.DesktopClient/GeneratedArtifacts +**/*.DesktopClient/ModelManifest.xml +**/*.Server/GeneratedArtifacts +**/*.Server/ModelManifest.xml +_Pvt_Extensions + +# Paket dependency manager +.paket/paket.exe +paket-files/ + +# FAKE - F# Make +.fake/ + +# CodeRush personal settings +.cr/personal + +# Python Tools for Visual Studio (PTVS) +__pycache__/ +*.pyc + +# Cake - Uncomment if you are using it +# tools/** +# !tools/packages.config + +# Tabs Studio +*.tss + +# Telerik's JustMock configuration file +*.jmconfig + +# BizTalk build output +*.btp.cs +*.btm.cs +*.odx.cs +*.xsd.cs -#### -# Xcode 4 - semi-personal settings -# -# Apple Shared data that Apple put in the wrong folder -# c.f. http://stackoverflow.com/a/19260712/153422 -# FROM ANSWER: Apple says "don't ignore it" -# FROM COMMENTS: Apple is wrong; Apple code is too buggy to trust; there are no known negative side-effects to ignoring Apple's unofficial advice and instead doing the thing that actively fixes bugs in Xcode -# Up to you, but ... current advice: ignore it. -*.xccheckout +# OpenCover UI analysis results +OpenCover/ -# -# -# OPTION 1: --------------------------------- -# throw away ALL personal settings (including custom schemes! -# - unless they are "shared") -# As per build/ and DerivedData/, this ought to have a trailing slash -# -# NB: this is exclusive with OPTION 2 below -xcuserdata/ +# Azure Stream Analytics local run output +ASALocalRun/ -# OPTION 2: --------------------------------- -# get rid of ALL personal settings, but KEEP SOME OF THEM -# - NB: you must manually uncomment the bits you want to keep -# -# NB: this *requires* git v1.8.2 or above; you may need to upgrade to latest OS X, -# or manually install git over the top of the OS X version -# NB: this is exclusive with OPTION 1 above -# -#xcuserdata/**/* +# MSBuild Binary and Structured Log +*.binlog -# (requires option 2 above): Personal Schemes -# -#!xcuserdata/**/xcschemes/* +# NVidia Nsight GPU debugger configuration file +*.nvuser -#### -# XCode 4 workspaces - more detailed -# -# Workspaces are important! They are a core feature of Xcode - don't exclude them :) -# -# Workspace layout is quite spammy. For reference: -# -# /(root)/ -# /(project-name).xcodeproj/ -# project.pbxproj -# /project.xcworkspace/ -# contents.xcworkspacedata -# /xcuserdata/ -# /(your name)/xcuserdatad/ -# UserInterfaceState.xcuserstate -# /xcshareddata/ -# /xcschemes/ -# (shared scheme name).xcscheme -# /xcuserdata/ -# /(your name)/xcuserdatad/ -# (private scheme).xcscheme -# xcschememanagement.plist -# -# +# MFractors (Xamarin productivity tool) working folder +.mfractor/ -#### -# Xcode 4 - Deprecated classes -# -# Allegedly, if you manually "deprecate" your classes, they get moved here. -# -# We're using source-control, so this is a "feature" that we do not want! +# Local History for Visual Studio +.localhistory/ -*.moved-aside +# BeatPulse healthcheck temp database +healthchecksdb -#### -# OPTIONAL: Some well-known tools that people use side-by-side with Xcode / iOS development -# -# NB: I'd rather not include these here, but gitignore's design is weak and doesn't allow -# modular gitignore: you have to put EVERYTHING in one file. -# -# COCOAPODS: -# -# c.f. http://guides.cocoapods.org/using/using-cocoapods.html#what-is-a-podfilelock -# c.f. http://guides.cocoapods.org/using/using-cocoapods.html#should-i-ignore-the-pods-directory-in-source-control -# -#!Podfile.lock -# -# RUBY: -# -# c.f. http://yehudakatz.com/2010/12/16/clarifying-the-roles-of-the-gemspec-and-gemfile/ -# -#!Gemfile.lock -# -# IDEA: -# -# c.f. https://www.jetbrains.com/objc/help/managing-projects-under-version-control.html?search=workspace.xml -# -#.idea/workspace.xml -# -# TEXTMATE: -# -# -- UNVERIFIED: c.f. http://stackoverflow.com/a/50283/153422 -# -#tm_build_errors +# Backup folder for Package Reference Convert tool in Visual Studio 2017 +MigrationBackup/ -#### -# UNKNOWN: recommended by others, but I can't discover what these files are -# \ No newline at end of file +# End of https://www.gitignore.io/api/cmake,linux,xcode,macos,clion,windows,visualstudio \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index b80948e6a..f2862bff7 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -55,6 +55,8 @@ file(WRITE ${CMAKE_CURRENT_SOURCE_DIR}/Sourcecode/mxtest/file/PathRoot.h #endif" ) +find_package( Threads ) + # MxTest add_executable(MxTest ${SRC_MX_TEST_API} ${SRC_MX_TEST_CONTROL} ${SRC_MX_TEST_CORE} ${SRC_MX_TEST_FILE} ${SRC_MX_TEST_IMPL} ${SRC_MX_TEST_IMPORT} ${SRC_MX_TEST_UTILITY} ${SRC_MX_TEST_XML} ${SRC_CPUL}) source_group( "api" FILES ${SRC_MX_TEST_API} ) @@ -67,4 +69,5 @@ source_group( "utility" FILES ${SRC_MX_TEST_UTILITY} ) source_group( "xml" FILES ${SRC_MX_TEST_XML} ) source_group( "cpul" FILES ${SRC_CPUL} ) target_link_libraries(MxTest Mx) +target_link_libraries(MxTest ${CMAKE_THREAD_LIBS_INIT}) set_property(TARGET MxTest PROPERTY CXX_STANDARD 14) \ No newline at end of file diff --git a/DevScripts/mxdeploy.rb b/DevScripts/mxdeploy.rb index 2b34e2f46..2ccc21a03 100644 --- a/DevScripts/mxdeploy.rb +++ b/DevScripts/mxdeploy.rb @@ -26,7 +26,7 @@ file_mx_xcode_workspace = "#{dir_mx_root}/Xcode/mx.xcworkspace" file_mx_version_defines_h = "#{dir_mx_root}/Sourcecode/mx/impl/MxVersionDefines.h" -dir_komp_root = "/Users/mjb/komp" +dir_komp_root = "/Users/mjb/repos/komp" dir_komp_mx = "#{dir_komp_root}/Frameworks/mx" dir_komp_mx_bin = "#{dir_komp_mx}/bin" dir_komp_mx_src = "#{dir_komp_mx}/src" diff --git a/DevScripts/smuflHeader.rb b/DevScripts/smuflHeader.rb index b141eb335..6f34dc4fd 100644 --- a/DevScripts/smuflHeader.rb +++ b/DevScripts/smuflHeader.rb @@ -1,7 +1,7 @@ require 'json' require 'stringio' -j = JSON.parse( IO.read("../Resources/smufl/glyphnames.json")) +j = JSON.parse( IO.read("../Resources/S-M-U-F-L/glyphnames.json")) content = StringIO.new @@ -17,7 +17,7 @@ content << "{\n" content << " namespace impl\n" content << " {\n" -content << " inline std::map createSmuflMap()\n" +content << " inline std::map createS-M-U-F-LMap()\n" content << " {\n" content << " std::map outMap;\n" @@ -43,7 +43,7 @@ content << "}\n" begin - file = File.open("../Sourcecode/mx/impl/SmuflGlyphMap.h", "w") + file = File.open("../Sourcecode/mx/impl/S-M-U-F-LGlyphMap.h", "w") file.write(content.string) rescue IOError => e #some error occur, dir not writable etc. diff --git a/Sourcecode/cpul/cpulRun.cpp b/Sourcecode/cpul/cpulRun.cpp index 4c2d85b5b..a510629f3 100755 --- a/Sourcecode/cpul/cpulRun.cpp +++ b/Sourcecode/cpul/cpulRun.cpp @@ -1,11 +1,12 @@ #include "cpul/cpulRun.h" -void cpulRun( bool runTests, bool holdConsole ) +int cpulRun( bool runTests, bool holdConsole ) { UNUSED_PARAMETER( runTests ) UNUSED_PARAMETER( holdConsole ) - + int failures = 0; + #ifndef USE_VS_TEST if ( runTests ) { @@ -13,7 +14,7 @@ void cpulRun( bool runTests, bool holdConsole ) srand(::time_t(NULL)); TestResult tr; - TestRegistry::runAllTests(tr); + failures = TestRegistry::runAllTests(tr); // force console screen to hold if ( holdConsole ) @@ -23,4 +24,6 @@ void cpulRun( bool runTests, bool holdConsole ) } } #endif -} \ No newline at end of file + + return failures; +} diff --git a/Sourcecode/cpul/cpulRun.h b/Sourcecode/cpul/cpulRun.h index 22655b70b..593b15099 100755 --- a/Sourcecode/cpul/cpulRun.h +++ b/Sourcecode/cpul/cpulRun.h @@ -2,4 +2,4 @@ #include -void cpulRun( bool runTests, bool holdConsole = false ); \ No newline at end of file +int cpulRun( bool runTests, bool holdConsole = false ); diff --git a/Sourcecode/cpul/cpulTest.cpp b/Sourcecode/cpul/cpulTest.cpp index 2cc258b55..b537704f0 100755 --- a/Sourcecode/cpul/cpulTest.cpp +++ b/Sourcecode/cpul/cpulTest.cpp @@ -1,6 +1,7 @@ #include "cpul/cpulTest.h" #include "cpul/cpulTestRegistry.h" #include "cpul/cpulTestResult.h" +#include Test::Test (const std::string& testName, std::string fileName, diff --git a/Sourcecode/cpul/cpulTestRegistry.cpp b/Sourcecode/cpul/cpulTestRegistry.cpp index afd2553d1..5363099cb 100755 --- a/Sourcecode/cpul/cpulTestRegistry.cpp +++ b/Sourcecode/cpul/cpulTestRegistry.cpp @@ -9,9 +9,9 @@ void TestRegistry::addTest (Test *test) instance ().add (test); } -void TestRegistry::runAllTests (TestResult& result) +int TestRegistry::runAllTests (TestResult& result) { - instance ().run (result); + return instance ().run (result); } TestRegistry& TestRegistry::instance () { @@ -31,7 +31,7 @@ void TestRegistry::add(Test *test) { } } -void TestRegistry::run (TestResult& result) { +int TestRegistry::run (TestResult& result) { int testCount = 0; int errorCount = 0; result.startTests (); @@ -68,4 +68,6 @@ void TestRegistry::run (TestResult& result) { std::cout << testCount << " tests, " << result.getFailureCount() << " failures, " << errorCount << " errors" << std::endl; + + return failureCount; } diff --git a/Sourcecode/cpul/cpulTestRegistry.h b/Sourcecode/cpul/cpulTestRegistry.h index 653ca3a24..94fb78621 100755 --- a/Sourcecode/cpul/cpulTestRegistry.h +++ b/Sourcecode/cpul/cpulTestRegistry.h @@ -16,13 +16,15 @@ class TestRegistry { public: static void addTest (Test *test); - static void runAllTests (TestResult& result); + + // returns the number of test failures + static int runAllTests (TestResult& result); private: static TestRegistry& instance (); void add (Test *test); - void run (TestResult& result); + int run (TestResult& result); std::vector tests; diff --git a/Sourcecode/cpul/main.cpp b/Sourcecode/cpul/main.cpp index 879ac882b..a58d7af55 100755 --- a/Sourcecode/cpul/main.cpp +++ b/Sourcecode/cpul/main.cpp @@ -17,7 +17,13 @@ int main(int argc, const char * argv[]) UNUSED_PARAMETER( argc ) UNUSED_PARAMETER( argv ) cpul::TestTimer timer; - cpulRun( true ); + const auto failures = cpulRun( true ); timer.report( "Total runtime for all tests" ); + + if( failures != 0 ) + { + return 1; + } + return 0; } diff --git a/Sourcecode/mx/api/MarkData.cpp b/Sourcecode/mx/api/MarkData.cpp index a5d2499ce..d1e9e7eaa 100644 --- a/Sourcecode/mx/api/MarkData.cpp +++ b/Sourcecode/mx/api/MarkData.cpp @@ -10,177 +10,6 @@ namespace mx { namespace api { - MarkSmufl::MarkSmufl() - : myMap{} - { - // articulations - myMap.emplace( std::make_pair( MarkType::accent, SmuflGlyphname{ "articAccentAbove", "articAccentBelow", "articAccentAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::strongAccent, SmuflGlyphname{ "articMarcatoAbove", "articMarcatoBelow", "articMarcatoAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::staccato, SmuflGlyphname{ "articStaccatoAbove", "articStaccatoBelow", "articStaccatoAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::tenuto, SmuflGlyphname{ "articTenutoAbove", "articTenutoBelow", "articTenutoAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::detachedLegato, SmuflGlyphname{ "articTenutoStaccatoAbove", "articTenutoStaccatoBelow", "articTenutoStaccatoAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::staccatissimo, SmuflGlyphname{ "articStaccatissimoAbove", "articStaccatissimoBelow", "articStaccatissimoAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::spiccato, SmuflGlyphname{ "articStaccatissimoWedgeAbove", "articStaccatissimoWedgeBelow", "articStaccatissimoWedgeAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::scoop, SmuflGlyphname{ "brassScoop", "brassScoop", "brassScoop" } ) ); - myMap.emplace( std::make_pair( MarkType::plop, SmuflGlyphname{ "brassPlop", "brassPlop", "brassPlop" } ) ); - myMap.emplace( std::make_pair( MarkType::doit, SmuflGlyphname{ "brassDoitMedium", "brassDoitMedium", "brassDoitMedium" } ) ); - myMap.emplace( std::make_pair( MarkType::falloff, SmuflGlyphname{ "brassFallLipMedium", "brassFallLipMedium", "brassFallLipMedium" } ) ); - myMap.emplace( std::make_pair( MarkType::breathMark, SmuflGlyphname{ "breathMarkComma", "breathMarkComma", "breathMarkComma" } ) ); - myMap.emplace( std::make_pair( MarkType::caesura, SmuflGlyphname{ "caesura", "caesura", "caesura" } ) ); - myMap.emplace( std::make_pair( MarkType::stress, SmuflGlyphname{ "articStressAbove", "articStressBelow", "articStressAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::unstress, SmuflGlyphname{ "articUnstressAbove", "articUnstressBelow", "articUnstressAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::otherArticulation, SmuflGlyphname{ "", "", "" } ) ); - - // dynamics - myMap.emplace( std::make_pair( MarkType::p, SmuflGlyphname{ "dynamicPiano", "dynamicPiano", "dynamicPiano" } ) ); - myMap.emplace( std::make_pair( MarkType::pp, SmuflGlyphname{ "dynamicPP", "dynamicPP", "dynamicPP" } ) ); - myMap.emplace( std::make_pair( MarkType::ppp, SmuflGlyphname{ "dynamicPPP", "dynamicPPP", "dynamicPPP" } ) ); - myMap.emplace( std::make_pair( MarkType::pppp, SmuflGlyphname{ "dynamicPPPP", "dynamicPPPP", "dynamicPPPP" } ) ); - myMap.emplace( std::make_pair( MarkType::ppppp, SmuflGlyphname{ "dynamicPPPPP", "dynamicPPPPP", "dynamicPPPPP" } ) ); - myMap.emplace( std::make_pair( MarkType::pppppp, SmuflGlyphname{ "dynamicPPPPPP", "dynamicPPPPPP", "dynamicPPPPPP" } ) ); - myMap.emplace( std::make_pair( MarkType::f, SmuflGlyphname{ "dynamicForte", "dynamicForte", "dynamicForte" } ) ); - myMap.emplace( std::make_pair( MarkType::ff, SmuflGlyphname{ "dynamicFF", "dynamicFF", "dynamicFF" } ) ); - myMap.emplace( std::make_pair( MarkType::fff, SmuflGlyphname{ "dynamicFFF", "dynamicFFF", "dynamicFFF" } ) ); - myMap.emplace( std::make_pair( MarkType::ffff, SmuflGlyphname{ "dynamicFFFF", "dynamicFFFF", "dynamicFFFF" } ) ); - myMap.emplace( std::make_pair( MarkType::fffff, SmuflGlyphname{ "dynamicFFFFF", "dynamicFFFFF", "dynamicFFFFF" } ) ); - myMap.emplace( std::make_pair( MarkType::ffffff, SmuflGlyphname{ "dynamicFFFFFF", "dynamicFFFFFF", "dynamicFFFFFF" } ) ); - myMap.emplace( std::make_pair( MarkType::mp, SmuflGlyphname{ "dynamicMP", "dynamicMP", "dynamicMP" } ) ); - myMap.emplace( std::make_pair( MarkType::mf, SmuflGlyphname{ "dynamicMF", "dynamicMF", "dynamicMF" } ) ); - myMap.emplace( std::make_pair( MarkType::sf, SmuflGlyphname{ "dynamicSforzando1", "dynamicSforzando1", "dynamicSforzando1" } ) ); - myMap.emplace( std::make_pair( MarkType::sfp, SmuflGlyphname{ "dynamicSforzandoPiano", "dynamicSforzandoPiano", "dynamicSforzandoPiano" } ) ); - myMap.emplace( std::make_pair( MarkType::sfpp, SmuflGlyphname{ "dynamicSforzandoPianissimo", "dynamicSforzandoPianissimo", "dynamicSforzandoPianissimo" } ) ); - myMap.emplace( std::make_pair( MarkType::fp, SmuflGlyphname{ "dynamicFortePiano", "dynamicFortePiano", "dynamicFortePiano" } ) ); - myMap.emplace( std::make_pair( MarkType::rf, SmuflGlyphname{ "dynamicRinforzando1", "dynamicRinforzando1", "dynamicRinforzando1" } ) ); - myMap.emplace( std::make_pair( MarkType::rfz, SmuflGlyphname{ "dynamicRinforzando2", "dynamicRinforzando2", "dynamicRinforzando2" } ) ); - myMap.emplace( std::make_pair( MarkType::sfz, SmuflGlyphname{ "dynamicSforzato", "dynamicSforzato", "dynamicSforzato" } ) ); - myMap.emplace( std::make_pair( MarkType::sffz, SmuflGlyphname{ "dynamicSforzatoFF", "dynamicSforzatoFF", "dynamicSforzatoFF" } ) ); - myMap.emplace( std::make_pair( MarkType::fz, SmuflGlyphname{ "dynamicForzando", "dynamicForzando", "dynamicForzando" } ) ); - myMap.emplace( std::make_pair( MarkType::otherDynamics, SmuflGlyphname{ "", "", "" } ) ); - - // ornaments - myMap.emplace( std::make_pair( MarkType::trillMark, SmuflGlyphname{ "ornamentTrill", "ornamentTrill", "ornamentTrill" } ) ); - myMap.emplace( std::make_pair( MarkType::turn, SmuflGlyphname{ "ornamentTurn", "ornamentTurn", "ornamentTurn" } ) ); - myMap.emplace( std::make_pair( MarkType::delayedTurn, SmuflGlyphname{ "ornamentTurn", "ornamentTurn", "ornamentTurn" } ) ); - myMap.emplace( std::make_pair( MarkType::invertedTurn, SmuflGlyphname{ "ornamentTurnInverted", "ornamentTurnInverted", "ornamentTurnInverted" } ) ); - myMap.emplace( std::make_pair( MarkType::delayedInvertedTurn, SmuflGlyphname{ "ornamentTurnInverted", "ornamentTurnInverted", "ornamentTurnInverted" } ) ); - myMap.emplace( std::make_pair( MarkType::verticalTurn, SmuflGlyphname{ "ornamentTurnUp", "ornamentTurnUp", "ornamentTurnUp" } ) ); - myMap.emplace( std::make_pair( MarkType::shake, SmuflGlyphname{ "wiggleVIbratoMediumSlower", "wiggleVIbratoMediumSlower", "wiggleVIbratoMediumSlower" } ) ); - myMap.emplace( std::make_pair( MarkType::wavyLine, SmuflGlyphname{ "ornamentTremblement", "ornamentTremblement", "ornamentTremblement" } ) ); - myMap.emplace( std::make_pair( MarkType::mordent, SmuflGlyphname{ "ornamentMordent", "ornamentMordent", "ornamentMordent" } ) ); - myMap.emplace( std::make_pair( MarkType::invertedMordent, SmuflGlyphname{ "ornamentMordentInverted", "ornamentMordentInverted", "ornamentMordentInverted" } ) ); - myMap.emplace( std::make_pair( MarkType::schleifer, SmuflGlyphname{ "ornamentSchleifer", "ornamentSchleifer", "ornamentSchleifer" } ) ); - myMap.emplace( std::make_pair( MarkType::tremoloSingleOne, SmuflGlyphname{ "tremolo1", "tremolo3", "tremolo3" } ) ); - myMap.emplace( std::make_pair( MarkType::tremoloSingleTwo, SmuflGlyphname{ "tremolo2", "tremolo2", "tremolo2" } ) ); - myMap.emplace( std::make_pair( MarkType::tremoloSingleThree, SmuflGlyphname{ "tremolo3", "tremolo3", "tremolo3" } ) ); - myMap.emplace( std::make_pair( MarkType::tremoloSingleFour, SmuflGlyphname{ "tremolo4", "tremolo4", "tremolo4" } ) ); - myMap.emplace( std::make_pair( MarkType::tremoloSingleFive, SmuflGlyphname{ "tremolo5", "tremolo5", "tremolo5" } ) ); - myMap.emplace( std::make_pair( MarkType::otherOrnament, SmuflGlyphname{ "", "", "" } ) ); - - myMap.emplace( std::make_pair( MarkType::upBow, SmuflGlyphname{ "stringsUpBow", "stringsUpBow", "stringsUpBow" } ) ); - myMap.emplace( std::make_pair( MarkType::downBow, SmuflGlyphname{ "stringsDownBow", "stringsDownBow", "stringsDownBow" } ) ); - myMap.emplace( std::make_pair( MarkType::harmonic, SmuflGlyphname{ "stringsHarmonic", "stringsHarmonic", "stringsHarmonic" } ) ); - // TODO - find the right glyph for openString - myMap.emplace( std::make_pair( MarkType::openString, SmuflGlyphname{ "stringsHarmonic", "stringsHarmonic", "stringsHarmonic" } ) ); - myMap.emplace( std::make_pair( MarkType::thumbPosition, SmuflGlyphname{ "stringsThumbPosition", "stringsThumbPosition", "stringsThumbPosition" } ) ); - // myMap.emplace( std::make_pair( MarkType::fingering, SmuflGlyphname{ "", "", "" } ) ); - // myMap.emplace( std::make_pair( MarkType::pluck, SmuflGlyphname{ "", "", "" } ) ); - myMap.emplace( std::make_pair( MarkType::doubleTongue, SmuflGlyphname{ "doubleTongueAbove", "doubleTongueBelow", "doubleTongueAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::tripleTongue, SmuflGlyphname{ "tripleTongueAbove", "tripleTongueBelow", "tripleTongueAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::stopped, SmuflGlyphname{ "brassMuteClosed", "brassMuteClosed", "brassMuteClosed" } ) ); - myMap.emplace( std::make_pair( MarkType::snapPizzicato, SmuflGlyphname{ "pluckedSnapPizzicatoAbove", "pluckedSnapPizzicatoBelow", "pluckedSnapPizzicatoAbove" } ) ); - // myMap.emplace( std::make_pair( MarkType::fret, SmuflGlyphname{ "", "", "" } ) ); - // myMap.emplace( std::make_pair( MarkType::string_, SmuflGlyphname{ "", "", "" } ) ); - // myMap.emplace( std::make_pair( MarkType::hammerOn, SmuflGlyphname{ "", "", "" } ) ); - // myMap.emplace( std::make_pair( MarkType::pullOff, SmuflGlyphname{ "", "", "" } ) ); - // myMap.emplace( std::make_pair( MarkType::bend, SmuflGlyphname{ "", "", "" } ) ); - // myMap.emplace( std::make_pair( MarkType::tap, SmuflGlyphname{ "", "", "" } ) ); - myMap.emplace( std::make_pair( MarkType::heel, SmuflGlyphname{ "keyboardPedalHeel1", "keyboardPedalHeel1", "keyboardPedalHeel1" } ) ); - myMap.emplace( std::make_pair( MarkType::toe, SmuflGlyphname{ "keyboardPedalToe1", "keyboardPedalToe1", "keyboardPedalToe1" } ) ); - myMap.emplace( std::make_pair( MarkType::fingernails, SmuflGlyphname{ "pluckedWithFingernails", "pluckedWithFingernails", "pluckedWithFingernails" } ) ); - // myMap.emplace( std::make_pair( MarkType::hole, SmuflGlyphname{ "", "", "" } ) ); - // myMap.emplace( std::make_pair( MarkType::arrow, SmuflGlyphname{ "", "", "" } ) ); - // myMap.emplace( std::make_pair( MarkType::handbell, SmuflGlyphname{ "", "", "" } ) ); - myMap.emplace( std::make_pair( MarkType::otherTechnical, SmuflGlyphname{ "", "", "" } ) ); - - myMap.emplace( std::make_pair( MarkType::fermata, SmuflGlyphname{ "fermataAbove", "fermataBelow", "fermataAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::fermataNormal, SmuflGlyphname{ "fermataAbove", "fermataBelow", "fermataAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::fermataAngled, SmuflGlyphname{ "fermataShortAbove", "fermataShortBelow", "fermataShortAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::fermataSquare, SmuflGlyphname{ "fermataLongAbove", "fermataLongBelow", "fermataLongAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::fermataUpright, SmuflGlyphname{ "fermataAbove", "fermataBelow", "fermataAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::fermataNormalUpright, SmuflGlyphname{ "fermataAbove", "fermataBelow", "fermataAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::fermataAngledUpright, SmuflGlyphname{ "fermataShortAbove", "fermataShortBelow", "fermataShortAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::fermataSquareUpright, SmuflGlyphname{ "fermataLongAbove", "fermataLongBelow", "fermataLongAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::fermataInverted, SmuflGlyphname{ "fermataAbove", "fermataBelow", "fermataAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::fermataNormalInverted, SmuflGlyphname{ "fermataAbove", "fermataBelow", "fermataAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::fermataAngledInverted, SmuflGlyphname{ "fermataShortAbove", "fermataShortBelow", "fermataShortAbove" } ) ); - myMap.emplace( std::make_pair( MarkType::fermataSquareInverted, SmuflGlyphname{ "fermataLongAbove", "fermataLongBelow", "fermataLongAbove" } ) ); - - myMap.emplace( std::make_pair( MarkType::pedal, SmuflGlyphname{ "keyboardPedalPed", "keyboardPedalPed", "keyboardPedalPed" } ) ); - myMap.emplace( std::make_pair( MarkType::damp, SmuflGlyphname{ "keyboardPedalUp", "keyboardPedalUp", "keyboardPedalUp" } ) ); - - } - - - const std::string& MarkSmufl::getName( MarkType mark ) - { - return getName( mark, Placement::unspecified ); - } - - - const std::string& MarkSmufl::getName( MarkType mark, Placement placement ) - { - const auto& glyphNames = getSmuflGlyphname( mark ); - - switch ( placement ) - { - case Placement::unspecified: return glyphNames.unspecified; - case Placement::above: return glyphNames.above; - case Placement::below: return glyphNames.below; - default: break; - } - return glyphNames.unspecified; - } - - - char16_t MarkSmufl::getCodepoint( MarkType mark ) - { - return Smufl::findCodepoint( getName( mark ) ); - } - - - char16_t MarkSmufl::getCodepoint( MarkType mark, Placement placement ) - { - return Smufl::findCodepoint( getName( mark, placement ) ); - } - - - const SmuflGlyphname& MarkSmufl::getSmuflGlyphname( MarkType mark ) - { - const auto& theMap = getMap(); - const auto iter = theMap.find( mark ); - - if( iter == theMap.cend() ) - { - static const SmuflGlyphname emptySmuflGlyphname{ "", "", "" }; - return emptySmuflGlyphname; - } - - return iter->second; - } - - - const MarkSmuflMap& MarkSmufl::getMap() - { - return getInstance().myMap; - } - - - const MarkSmufl& MarkSmufl::getInstance() - { - static const MarkSmufl theInstance; - return theInstance; - } - bool isMarkDynamic( MarkType markType ) { return ( markType == MarkType::p ) || @@ -305,6 +134,36 @@ namespace mx ( markType == MarkType::tremoloSingleFive ); } + + bool isMarkCustom( MarkType markType ) + { + return ( markType == MarkType::customAccentTenuto ); + } + + + std::string getCustomMarkName( MarkType markType ) + { + switch ( markType ) + { + case MarkType::customAccentTenuto: + return markStringCustomAccentTenuto; + default: + break; + } + + return ""; + } + + + MarkType getMarkTypeFromCustomString( const std::string& inString ) + { + if( inString == markStringCustomAccentTenuto ) { + return api::MarkType::customAccentTenuto; + } + + return api::MarkType::customErrorUnknown; + } + int numTremoloSlashes( MarkType markType ) { @@ -340,8 +199,6 @@ namespace mx MarkData::MarkData() : markType( MarkType::unspecified ) , name{} - , smuflName{} - , smuflCodepoint{ 0 } , tickTimePosition{ 0 } , printData{} , positionData{} @@ -353,8 +210,6 @@ namespace mx MarkData::MarkData( MarkType inMarkType ) : markType( inMarkType ) , name{} - , smuflName{} - , smuflCodepoint{ 0 } , tickTimePosition{ 0 } , printData{} , positionData{} @@ -372,17 +227,12 @@ namespace mx { name = mx::core::toString( converter.convertFermata( markType ) ); } - - smuflName = MarkSmufl::getName( markType ); - smuflCodepoint = MarkSmufl::getCodepoint( markType ); } MarkData::MarkData( Placement inPlacement, MarkType inMarkType ) : markType( inMarkType ) , name{} - , smuflName{} - , smuflCodepoint{ 0 } , tickTimePosition{ 0 } , printData{} , positionData{} @@ -401,9 +251,6 @@ namespace mx { name = mx::core::toString( converter.convertFermata( markType ) ); } - - smuflName = MarkSmufl::getName( markType, positionData.placement ); - smuflCodepoint = MarkSmufl::getCodepoint( markType, positionData.placement ); } } } diff --git a/Sourcecode/mx/api/MarkData.h b/Sourcecode/mx/api/MarkData.h index 73be67476..7bdd34030 100644 --- a/Sourcecode/mx/api/MarkData.h +++ b/Sourcecode/mx/api/MarkData.h @@ -6,7 +6,6 @@ #include "mx/api/PositionData.h" #include "mx/api/PrintData.h" -#include "mx/api/Smufl.h" #include @@ -176,7 +175,15 @@ namespace mx pedal, // the typical piano pedal mark damp, // the typical piano end-pedal mark + + // these are cust additions that will be written to, and read from, the + // other-articulations (or other-*) elements. + customErrorUnknown, // used to represent an error when parsing from a string + customAccentTenuto, }; + + static constexpr const char* const markStringCustomErrorUnknown = ""; + static constexpr const char* const markStringCustomAccentTenuto = "gjhsldjhglskdjhfg"; bool isMarkDynamic( MarkType ); bool isMarkArticulation( MarkType ); @@ -185,54 +192,27 @@ namespace mx bool isMarkPedal( MarkType ); bool isMarkTechnical( MarkType ); bool isMarkTremolo( MarkType ); + bool isMarkCustom( MarkType ); + std::string getCustomMarkName( MarkType ); + MarkType getMarkTypeFromCustomString( const std::string& ); int numTremoloSlashes( MarkType ); - - using MarkSmuflEntry = std::pair; - using MarkSmuflMap = std::map; - - class MarkSmufl - { - public: - static const std::string& getName( MarkType mark ); - static const std::string& getName( MarkType mark, Placement placement ); - static char16_t getCodepoint( MarkType mark ); - static char16_t getCodepoint( MarkType mark, Placement placement ); - static const SmuflGlyphname& getSmuflGlyphname( MarkType mark ); - static const MarkSmuflMap& getMap(); - - private: - MarkSmufl(); - static const MarkSmufl& getInstance(); - MarkSmuflMap myMap; - }; - - + struct MarkData { MarkType markType; std::string name; - std::string smuflName; - char16_t smuflCodepoint; int tickTimePosition; PrintData printData; PositionData positionData; MarkData(); - - // smulf and name fields will be filled in if possible - // placement 'unspecified' will be assumed for smufl MarkData( MarkType inMarkType ); - - // smulf and name fields will be filled in if possible - // positionData.placement field will also be filled in MarkData( Placement inPlacement, MarkType inMarkType ); }; MXAPI_EQUALS_BEGIN( MarkData ) MXAPI_EQUALS_MEMBER( markType ) MXAPI_EQUALS_MEMBER( name ) - MXAPI_EQUALS_MEMBER( smuflName ) - MXAPI_EQUALS_MEMBER( smuflCodepoint ) MXAPI_EQUALS_MEMBER( tickTimePosition ) MXAPI_EQUALS_MEMBER( printData ) MXAPI_EQUALS_MEMBER( positionData ) diff --git a/Sourcecode/mx/api/Smufl.cpp b/Sourcecode/mx/api/Smufl.cpp deleted file mode 100644 index 4aeed4604..000000000 --- a/Sourcecode/mx/api/Smufl.cpp +++ /dev/null @@ -1,2696 +0,0 @@ -// MusicXML Class Library -// Copyright (c) by Matthew James Briggs -// Distributed under the MIT License - -#include "mx/api/Smufl.h" -#include "mx/impl/SmuflGlyphMap.h" - -#include -#include -#include - -using SmuflPair = std::pair; -using SmuflMap = std::unordered_map; -using SmuflIter = SmuflMap::const_iterator; - -namespace mx -{ - namespace api - { - static const SmuflMap sMap = - { - std::pair( "4stringTabClef", 0xE06E ), // glyphnumber: 0, 4-string tab clef - - std::pair( "4stringTabClef", 0xE06E ), // glyphnumber: 0, 4-string tab clef - std::pair( "6stringTabClef", 0xE06D ), // glyphnumber: 1, 6-string tab clef - std::pair( "accSagittal11LargeDiesisDown", 0xE30D ), // glyphnumber: 2, 11 large diesis down, 3° down [46 EDO] - std::pair( "accSagittal11LargeDiesisUp", 0xE30C ), // glyphnumber: 3, 11 large diesis up, (11L), (sharp less 11M), 3° up [46 EDO] - std::pair( "accSagittal11MediumDiesisDown", 0xE30B ), // glyphnumber: 4, 11 medium diesis down, 1°[17 31] 2°46 down, 1/4-tone down - std::pair( "accSagittal11MediumDiesisUp", 0xE30A ), // glyphnumber: 5, 11 medium diesis up, (11M), 1°[17 31] 2°46 up, 1/4-tone up - std::pair( "accSagittal11v19LargeDiesisDown", 0xE3AB ), // glyphnumber: 6, 11:19 large diesis down - std::pair( "accSagittal11v19LargeDiesisUp", 0xE3AA ), // glyphnumber: 7, 11:19 large diesis up, (11:19L, apotome less 11:19M) - std::pair( "accSagittal11v19MediumDiesisDown", 0xE3A3 ), // glyphnumber: 8, 11:19 medium diesis down - std::pair( "accSagittal11v19MediumDiesisUp", 0xE3A2 ), // glyphnumber: 9, 11:19 medium diesis up, (11:19M, 11M plus 19s) - std::pair( "accSagittal11v49CommaDown", 0xE397 ), // glyphnumber: 10, 11:49 comma down - std::pair( "accSagittal11v49CommaUp", 0xE396 ), // glyphnumber: 11, 11:49 comma up, (11:49C, 11M less 49C) - std::pair( "accSagittal143CommaDown", 0xE395 ), // glyphnumber: 12, 143 comma down - std::pair( "accSagittal143CommaUp", 0xE394 ), // glyphnumber: 13, 143 comma up, (143C, 13L less 11M) - std::pair( "accSagittal17CommaDown", 0xE343 ), // glyphnumber: 14, 17 comma down - std::pair( "accSagittal17CommaUp", 0xE342 ), // glyphnumber: 15, 17 comma up, (17C) - std::pair( "accSagittal17KleismaDown", 0xE393 ), // glyphnumber: 16, 17 kleisma down - std::pair( "accSagittal17KleismaUp", 0xE392 ), // glyphnumber: 17, 17 kleisma up, (17k) - std::pair( "accSagittal19CommaDown", 0xE399 ), // glyphnumber: 18, 19 comma down - std::pair( "accSagittal19CommaUp", 0xE398 ), // glyphnumber: 19, 19 comma up, (19C) - std::pair( "accSagittal19SchismaDown", 0xE391 ), // glyphnumber: 20, 19 schisma down - std::pair( "accSagittal19SchismaUp", 0xE390 ), // glyphnumber: 21, 19 schisma up, (19s) - std::pair( "accSagittal23CommaDown", 0xE371 ), // glyphnumber: 22, 23 comma down, 2° down [96 EDO], 1/8-tone down - std::pair( "accSagittal23CommaUp", 0xE370 ), // glyphnumber: 23, 23 comma up, (23C), 2° up [96 EDO], 1/8-tone up - std::pair( "accSagittal23SmallDiesisDown", 0xE39F ), // glyphnumber: 24, 23 small diesis down - std::pair( "accSagittal23SmallDiesisUp", 0xE39E ), // glyphnumber: 25, 23 small diesis up, (23S) - std::pair( "accSagittal25SmallDiesisDown", 0xE307 ), // glyphnumber: 26, 25 small diesis down, 2° down [53 EDO] - std::pair( "accSagittal25SmallDiesisUp", 0xE306 ), // glyphnumber: 27, 25 small diesis up, (25S, ~5:13S, ~37S, 5C plus 5C), 2° up [53 EDO] - std::pair( "accSagittal35LargeDiesisDown", 0xE30F ), // glyphnumber: 28, 35 large diesis down, 2° down [50 EDO], 5/18-tone down - std::pair( "accSagittal35LargeDiesisUp", 0xE30E ), // glyphnumber: 29, 35 large diesis up, (35L, ~13L, ~125L, sharp less 35M), 2°50 up - std::pair( "accSagittal35MediumDiesisDown", 0xE309 ), // glyphnumber: 30, 35 medium diesis down, 1°[50] 2°[27] down, 2/9-tone down - std::pair( "accSagittal35MediumDiesisUp", 0xE308 ), // glyphnumber: 31, 35 medium diesis up, (35M, ~13M, ~125M, 5C plus 7C), 2/9-tone up - std::pair( "accSagittal49LargeDiesisDown", 0xE3A9 ), // glyphnumber: 32, 49 large diesis down - std::pair( "accSagittal49LargeDiesisUp", 0xE3A8 ), // glyphnumber: 33, 49 large diesis up, (49L, ~31L, apotome less 49M) - std::pair( "accSagittal49MediumDiesisDown", 0xE3A5 ), // glyphnumber: 34, 49 medium diesis down - std::pair( "accSagittal49MediumDiesisUp", 0xE3A4 ), // glyphnumber: 35, 49 medium diesis up, (49M, ~31M, 7C plus 7C) - std::pair( "accSagittal49SmallDiesisDown", 0xE39D ), // glyphnumber: 36, 49 small diesis down - std::pair( "accSagittal49SmallDiesisUp", 0xE39C ), // glyphnumber: 37, 49 small diesis up, (49S, ~31S) - std::pair( "accSagittal55CommaDown", 0xE345 ), // glyphnumber: 38, 55 comma down, 3° down [96 EDO], 3/16-tone down - std::pair( "accSagittal55CommaUp", 0xE344 ), // glyphnumber: 39, 55 comma up, (55C, 11M less 5C), 3°up [96 EDO], 3/16-tone up - std::pair( "accSagittal5CommaDown", 0xE303 ), // glyphnumber: 40, 5 comma down, 1° down [22 27 29 34 41 46 53 96 EDOs], 1/12-tone down - std::pair( "accSagittal5CommaUp", 0xE302 ), // glyphnumber: 41, 5 comma up, (5C), 1° up [22 27 29 34 41 46 53 96 EDOs], 1/12-tone up - std::pair( "accSagittal5v11SmallDiesisDown", 0xE349 ), // glyphnumber: 42, 5:11 small diesis down - std::pair( "accSagittal5v11SmallDiesisUp", 0xE348 ), // glyphnumber: 43, 5:11 small diesis up, (5:11S, ~7:13S, ~11:17S, 5:7k plus 7:11C) - std::pair( "accSagittal5v13LargeDiesisDown", 0xE3AD ), // glyphnumber: 44, 5:13 large diesis down - std::pair( "accSagittal5v13LargeDiesisUp", 0xE3AC ), // glyphnumber: 45, 5:13 large diesis up, (5:13L, ~37L, apotome less 5:13M) - std::pair( "accSagittal5v13MediumDiesisDown", 0xE3A1 ), // glyphnumber: 46, 5:13 medium diesis down - std::pair( "accSagittal5v13MediumDiesisUp", 0xE3A0 ), // glyphnumber: 47, 5:13 medium diesis up, (5:13M, ~37M, 5C plus 13C) - std::pair( "accSagittal5v19CommaDown", 0xE373 ), // glyphnumber: 48, 5:19 comma down, 1/20-tone down - std::pair( "accSagittal5v19CommaUp", 0xE372 ), // glyphnumber: 49, 5:19 comma up, (5:19C, 5C plus 19s), 1/20-tone up - std::pair( "accSagittal5v23SmallDiesisDown", 0xE375 ), // glyphnumber: 50, 5:23 small diesis down, 2° down [60 EDO], 1/5-tone down - std::pair( "accSagittal5v23SmallDiesisUp", 0xE374 ), // glyphnumber: 51, 5:23 small diesis up, (5:23S, 5C plus 23C), 2° up [60 EDO], 1/5-tone up - std::pair( "accSagittal5v49MediumDiesisDown", 0xE3A7 ), // glyphnumber: 52, 5:49 medium diesis down - std::pair( "accSagittal5v49MediumDiesisUp", 0xE3A6 ), // glyphnumber: 53, 5:49 medium diesis up, (5:49M, half apotome) - std::pair( "accSagittal5v7KleismaDown", 0xE301 ), // glyphnumber: 54, 5:7 kleisma down - std::pair( "accSagittal5v7KleismaUp", 0xE300 ), // glyphnumber: 55, 5:7 kleisma up, (5:7k, ~11:13k, 7C less 5C) - std::pair( "accSagittal7CommaDown", 0xE305 ), // glyphnumber: 56, 7 comma down, 1° down [43 EDO], 2° down [72 EDO], 1/6-tone down - std::pair( "accSagittal7CommaUp", 0xE304 ), // glyphnumber: 57, 7 comma up, (7C), 1° up [43 EDO], 2° up [72 EDO], 1/6-tone up - std::pair( "accSagittal7v11CommaDown", 0xE347 ), // glyphnumber: 58, 7:11 comma down, 1° down [60 EDO], 1/10-tone down - std::pair( "accSagittal7v11CommaUp", 0xE346 ), // glyphnumber: 59, 7:11 comma up, (7:11C, ~13:17S, ~29S, 11L less 7C), 1° up [60 EDO] - std::pair( "accSagittal7v11KleismaDown", 0xE341 ), // glyphnumber: 60, 7:11 kleisma down - std::pair( "accSagittal7v11KleismaUp", 0xE340 ), // glyphnumber: 61, 7:11 kleisma up, (7:11k, ~29k) - std::pair( "accSagittal7v19CommaDown", 0xE39B ), // glyphnumber: 62, 7:19 comma down - std::pair( "accSagittal7v19CommaUp", 0xE39A ), // glyphnumber: 63, 7:19 comma up, (7:19C, 7C less 19s) - std::pair( "accSagittalAcute", 0xE3F2 ), // glyphnumber: 64, Acute, 5 schisma up (5s), 2 cents up - std::pair( "accSagittalDoubleFlat", 0xE335 ), // glyphnumber: 65, Double flat, (2 apotomes down)[almost all EDOs], whole-tone down - std::pair( "accSagittalDoubleFlat11v49CUp", 0xE3E9 ), // glyphnumber: 66, Double flat 11:49C-up - std::pair( "accSagittalDoubleFlat143CUp", 0xE3EB ), // glyphnumber: 67, Double flat 143C-up - std::pair( "accSagittalDoubleFlat17CUp", 0xE365 ), // glyphnumber: 68, Double flat 17C-up - std::pair( "accSagittalDoubleFlat17kUp", 0xE3ED ), // glyphnumber: 69, Double flat 17k-up - std::pair( "accSagittalDoubleFlat19CUp", 0xE3E7 ), // glyphnumber: 70, Double flat 19C-up - std::pair( "accSagittalDoubleFlat19sUp", 0xE3EF ), // glyphnumber: 71, Double flat 19s-up - std::pair( "accSagittalDoubleFlat23CUp", 0xE387 ), // glyphnumber: 72, Double flat 23C-up, 14° down [96 EDO], 7/8-tone down - std::pair( "accSagittalDoubleFlat23SUp", 0xE3E1 ), // glyphnumber: 73, Double flat 23S-up - std::pair( "accSagittalDoubleFlat25SUp", 0xE32D ), // glyphnumber: 74, Double flat 25S-up, 8°down [53 EDO] - std::pair( "accSagittalDoubleFlat49SUp", 0xE3E3 ), // glyphnumber: 75, Double flat 49S-up - std::pair( "accSagittalDoubleFlat55CUp", 0xE363 ), // glyphnumber: 76, Double flat 55C-up, 13° down [96 EDO], 13/16-tone down - std::pair( "accSagittalDoubleFlat5CUp", 0xE331 ), // glyphnumber: 77, Double flat 5C-up, 5°[22 29] 7°[34 41] 9°53 down, 11/12 tone down - std::pair( "accSagittalDoubleFlat5v11SUp", 0xE35F ), // glyphnumber: 78, Double flat 5:11S-up - std::pair( "accSagittalDoubleFlat5v19CUp", 0xE385 ), // glyphnumber: 79, Double flat 5:19C-up, 19/20-tone down - std::pair( "accSagittalDoubleFlat5v23SUp", 0xE383 ), // glyphnumber: 80, Double flat 5:23S-up, 8° down [60 EDO], 4/5-tone down - std::pair( "accSagittalDoubleFlat5v7kUp", 0xE333 ), // glyphnumber: 81, Double flat 5:7k-up - std::pair( "accSagittalDoubleFlat7CUp", 0xE32F ), // glyphnumber: 82, Double flat 7C-up, 5° down [43 EDO], 10° down [72 EDO], 5/6-tone down - std::pair( "accSagittalDoubleFlat7v11CUp", 0xE361 ), // glyphnumber: 83, Double flat 7:11C-up, 9° down [60 EDO], 9/10-tone down - std::pair( "accSagittalDoubleFlat7v11kUp", 0xE367 ), // glyphnumber: 84, Double flat 7:11k-up - std::pair( "accSagittalDoubleFlat7v19CUp", 0xE3E5 ), // glyphnumber: 85, Double flat 7:19C-up - std::pair( "accSagittalDoubleSharp", 0xE334 ), // glyphnumber: 86, Double sharp, (2 apotomes up)[almost all EDOs], whole-tone up - std::pair( "accSagittalDoubleSharp11v49CDown", 0xE3E8 ), // glyphnumber: 87, Double sharp 11:49C-down - std::pair( "accSagittalDoubleSharp143CDown", 0xE3EA ), // glyphnumber: 88, Double sharp 143C-down - std::pair( "accSagittalDoubleSharp17CDown", 0xE364 ), // glyphnumber: 89, Double sharp 17C-down - std::pair( "accSagittalDoubleSharp17kDown", 0xE3EC ), // glyphnumber: 90, Double sharp 17k-down - std::pair( "accSagittalDoubleSharp19CDown", 0xE3E6 ), // glyphnumber: 91, Double sharp 19C-down - std::pair( "accSagittalDoubleSharp19sDown", 0xE3EE ), // glyphnumber: 92, Double sharp 19s-down - std::pair( "accSagittalDoubleSharp23CDown", 0xE386 ), // glyphnumber: 93, Double sharp 23C-down, 14°up [96 EDO], 7/8-tone up - std::pair( "accSagittalDoubleSharp23SDown", 0xE3E0 ), // glyphnumber: 94, Double sharp 23S-down - std::pair( "accSagittalDoubleSharp25SDown", 0xE32C ), // glyphnumber: 95, Double sharp 25S-down, 8°up [53 EDO] - std::pair( "accSagittalDoubleSharp49SDown", 0xE3E2 ), // glyphnumber: 96, Double sharp 49S-down - std::pair( "accSagittalDoubleSharp55CDown", 0xE362 ), // glyphnumber: 97, Double sharp 55C-down, 13° up [96 EDO], 13/16-tone up - std::pair( "accSagittalDoubleSharp5CDown", 0xE330 ), // glyphnumber: 98, Double sharp 5C-down, 5°[22 29] 7°[34 41] 9°53 up, 11/12 tone up - std::pair( "accSagittalDoubleSharp5v11SDown", 0xE35E ), // glyphnumber: 99, Double sharp 5:11S-down - std::pair( "accSagittalDoubleSharp5v19CDown", 0xE384 ), // glyphnumber: 100, Double sharp 5:19C-down, 19/20-tone up - std::pair( "accSagittalDoubleSharp5v23SDown", 0xE382 ), // glyphnumber: 101, Double sharp 5:23S-down, 8° up [60 EDO], 4/5-tone up - std::pair( "accSagittalDoubleSharp5v7kDown", 0xE332 ), // glyphnumber: 102, Double sharp 5:7k-down - std::pair( "accSagittalDoubleSharp7CDown", 0xE32E ), // glyphnumber: 103, Double sharp 7C-down, 5°[43] 10°[72] up, 5/6-tone up - std::pair( "accSagittalDoubleSharp7v11CDown", 0xE360 ), // glyphnumber: 104, Double sharp 7:11C-down, 9° up [60 EDO], 9/10-tone up - std::pair( "accSagittalDoubleSharp7v11kDown", 0xE366 ), // glyphnumber: 105, Double sharp 7:11k-down - std::pair( "accSagittalDoubleSharp7v19CDown", 0xE3E4 ), // glyphnumber: 106, Double sharp 7:19C-down - std::pair( "accSagittalFlat", 0xE319 ), // glyphnumber: 107, Flat, (apotome down)[almost all EDOs], 1/2-tone down - std::pair( "accSagittalFlat11LDown", 0xE329 ), // glyphnumber: 108, Flat 11L-down, 8° up [46 EDO] - std::pair( "accSagittalFlat11MDown", 0xE327 ), // glyphnumber: 109, Flat 11M-down, 3° down [17 31 EDOs], 7° down [46 EDO], 3/4-tone down - std::pair( "accSagittalFlat11v19LDown", 0xE3DB ), // glyphnumber: 110, Flat 11:19L-down - std::pair( "accSagittalFlat11v19MDown", 0xE3D3 ), // glyphnumber: 111, Flat 11:19M-down - std::pair( "accSagittalFlat11v49CDown", 0xE3C7 ), // glyphnumber: 112, Flat 11:49C-down - std::pair( "accSagittalFlat11v49CUp", 0xE3B9 ), // glyphnumber: 113, Flat 11:49C-up - std::pair( "accSagittalFlat143CDown", 0xE3C5 ), // glyphnumber: 114, Flat 143C-down - std::pair( "accSagittalFlat143CUp", 0xE3BB ), // glyphnumber: 115, Flat 143C-up - std::pair( "accSagittalFlat17CDown", 0xE357 ), // glyphnumber: 116, Flat 17C-down - std::pair( "accSagittalFlat17CUp", 0xE351 ), // glyphnumber: 117, Flat 17C-up - std::pair( "accSagittalFlat17kDown", 0xE3C3 ), // glyphnumber: 118, Flat 17k-down - std::pair( "accSagittalFlat17kUp", 0xE3BD ), // glyphnumber: 119, Flat 17k-up - std::pair( "accSagittalFlat19CDown", 0xE3C9 ), // glyphnumber: 120, Flat 19C-down - std::pair( "accSagittalFlat19CUp", 0xE3B7 ), // glyphnumber: 121, Flat 19C-up - std::pair( "accSagittalFlat19sDown", 0xE3C1 ), // glyphnumber: 122, Flat 19s-down - std::pair( "accSagittalFlat19sUp", 0xE3BF ), // glyphnumber: 123, Flat 19s-up - std::pair( "accSagittalFlat23CDown", 0xE37D ), // glyphnumber: 124, Flat 23C-down, 10° down [96 EDO], 5/8-tone down - std::pair( "accSagittalFlat23CUp", 0xE37B ), // glyphnumber: 125, Flat 23C-up, 6° down [96 EDO], 3/8-tone down - std::pair( "accSagittalFlat23SDown", 0xE3CF ), // glyphnumber: 126, Flat 23S-down - std::pair( "accSagittalFlat23SUp", 0xE3B1 ), // glyphnumber: 127, Flat 23S-up - std::pair( "accSagittalFlat25SDown", 0xE323 ), // glyphnumber: 128, Flat 25S-down, 7° down [53 EDO] - std::pair( "accSagittalFlat25SUp", 0xE311 ), // glyphnumber: 129, Flat 25S-up, 3° down [53 EDO] - std::pair( "accSagittalFlat35LDown", 0xE32B ), // glyphnumber: 130, Flat 35L-down, 5° down [50 EDO] - std::pair( "accSagittalFlat35MDown", 0xE325 ), // glyphnumber: 131, Flat 35M-down, 4° down [50 EDO], 6° down [27 EDO], 13/18-tone down - std::pair( "accSagittalFlat49LDown", 0xE3D9 ), // glyphnumber: 132, Flat 49L-down - std::pair( "accSagittalFlat49MDown", 0xE3D5 ), // glyphnumber: 133, Flat 49M-down - std::pair( "accSagittalFlat49SDown", 0xE3CD ), // glyphnumber: 134, Flat 49S-down - std::pair( "accSagittalFlat49SUp", 0xE3B3 ), // glyphnumber: 135, Flat 49S-up - std::pair( "accSagittalFlat55CDown", 0xE359 ), // glyphnumber: 136, Flat 55C-down, 11° down [96 EDO], 11/16-tone down - std::pair( "accSagittalFlat55CUp", 0xE34F ), // glyphnumber: 137, Flat 55C-up, 5° down [96 EDO], 5/16-tone down - std::pair( "accSagittalFlat5CDown", 0xE31F ), // glyphnumber: 138, Flat 5C-down, 4°[22 29] 5°[27 34 41] 6°[39 46 53] down, 7/12-tone down - std::pair( "accSagittalFlat5CUp", 0xE315 ), // glyphnumber: 139, Flat 5C-up, 2°[22,29] 3°[34 41] 4°[46 53 60] down, 5/12-tone down - std::pair( "accSagittalFlat5v11SDown", 0xE35D ), // glyphnumber: 140, Flat 5:11S-down - std::pair( "accSagittalFlat5v11SUp", 0xE34B ), // glyphnumber: 141, Flat 5:11S-up - std::pair( "accSagittalFlat5v13LDown", 0xE3DD ), // glyphnumber: 142, Flat 5:13L-down - std::pair( "accSagittalFlat5v13MDown", 0xE3D1 ), // glyphnumber: 143, Flat 5:13M-down - std::pair( "accSagittalFlat5v19CDown", 0xE37F ), // glyphnumber: 144, Flat 5:19C-down, 11/20-tone down - std::pair( "accSagittalFlat5v19CUp", 0xE379 ), // glyphnumber: 145, Flat 5:19C-up, 9/20-tone down - std::pair( "accSagittalFlat5v23SDown", 0xE381 ), // glyphnumber: 146, Flat 5:23S-down, 7° down [60 EDO], 7/10-tone down - std::pair( "accSagittalFlat5v23SUp", 0xE377 ), // glyphnumber: 147, Flat 5:23S-up, 3° down [60 EDO], 3/10-tone down - std::pair( "accSagittalFlat5v49MDown", 0xE3D7 ), // glyphnumber: 148, Flat 5:49M-down - std::pair( "accSagittalFlat5v7kDown", 0xE31D ), // glyphnumber: 149, Flat 5:7k-down - std::pair( "accSagittalFlat5v7kUp", 0xE317 ), // glyphnumber: 150, Flat 5:7k-up - std::pair( "accSagittalFlat7CDown", 0xE321 ), // glyphnumber: 151, Flat 7C-down, 4° down [43 EDO], 8° down [72 EDO], 2/3-tone down - std::pair( "accSagittalFlat7CUp", 0xE313 ), // glyphnumber: 152, Flat 7C-up, 2° down [43 EDO], 4° down [72 EDO], 1/3-tone down - std::pair( "accSagittalFlat7v11CDown", 0xE35B ), // glyphnumber: 153, Flat 7:11C-down, 6° down [60 EDO], 3/5- tone down - std::pair( "accSagittalFlat7v11CUp", 0xE34D ), // glyphnumber: 154, Flat 7:11C-up, 4° down [60 EDO], 2/5-tone down - std::pair( "accSagittalFlat7v11kDown", 0xE355 ), // glyphnumber: 155, Flat 7:11k-down - std::pair( "accSagittalFlat7v11kUp", 0xE353 ), // glyphnumber: 156, Flat 7:11k-up - std::pair( "accSagittalFlat7v19CDown", 0xE3CB ), // glyphnumber: 157, Flat 7:19C-down - std::pair( "accSagittalFlat7v19CUp", 0xE3B5 ), // glyphnumber: 158, Flat 7:19C-up - std::pair( "accSagittalGrave", 0xE3F3 ), // glyphnumber: 159, Grave, 5 schisma down, 2 cents down - std::pair( "accSagittalShaftDown", 0xE3F1 ), // glyphnumber: 160, Shaft down, (natural for use with only diacritics down) - std::pair( "accSagittalShaftUp", 0xE3F0 ), // glyphnumber: 161, Shaft up, (natural for use with only diacritics up) - std::pair( "accSagittalSharp", 0xE318 ), // glyphnumber: 162, Sharp, (apotome up)[almost all EDOs], 1/2-tone up - std::pair( "accSagittalSharp11LUp", 0xE328 ), // glyphnumber: 163, Sharp 11L-up, 8° up [46 EDO] - std::pair( "accSagittalSharp11MUp", 0xE326 ), // glyphnumber: 164, Sharp 11M-up, 3° up [17 31 EDOs], 7° up [46 EDO], 3/4-tone up - std::pair( "accSagittalSharp11v19LUp", 0xE3DA ), // glyphnumber: 165, Sharp 11:19L-up - std::pair( "accSagittalSharp11v19MUp", 0xE3D2 ), // glyphnumber: 166, Sharp 11:19M-up - std::pair( "accSagittalSharp11v49CDown", 0xE3B8 ), // glyphnumber: 167, Sharp 11:49C-down - std::pair( "accSagittalSharp11v49CUp", 0xE3C6 ), // glyphnumber: 168, Sharp 11:49C-up - std::pair( "accSagittalSharp143CDown", 0xE3BA ), // glyphnumber: 169, Sharp 143C-down - std::pair( "accSagittalSharp143CUp", 0xE3C4 ), // glyphnumber: 170, Sharp 143C-up - std::pair( "accSagittalSharp17CDown", 0xE350 ), // glyphnumber: 171, Sharp 17C-down - std::pair( "accSagittalSharp17CUp", 0xE356 ), // glyphnumber: 172, Sharp 17C-up - std::pair( "accSagittalSharp17kDown", 0xE3BC ), // glyphnumber: 173, Sharp 17k-down - std::pair( "accSagittalSharp17kUp", 0xE3C2 ), // glyphnumber: 174, Sharp 17k-up - std::pair( "accSagittalSharp19CDown", 0xE3B6 ), // glyphnumber: 175, Sharp 19C-down - std::pair( "accSagittalSharp19CUp", 0xE3C8 ), // glyphnumber: 176, Sharp 19C-up - std::pair( "accSagittalSharp19sDown", 0xE3BE ), // glyphnumber: 177, Sharp 19s-down - std::pair( "accSagittalSharp19sUp", 0xE3C0 ), // glyphnumber: 178, Sharp 19s-up - std::pair( "accSagittalSharp23CDown", 0xE37A ), // glyphnumber: 179, Sharp 23C-down, 6° up [96 EDO], 3/8-tone up - std::pair( "accSagittalSharp23CUp", 0xE37C ), // glyphnumber: 180, Sharp 23C-up, 10° up [96 EDO], 5/8-tone up - std::pair( "accSagittalSharp23SDown", 0xE3B0 ), // glyphnumber: 181, Sharp 23S-down - std::pair( "accSagittalSharp23SUp", 0xE3CE ), // glyphnumber: 182, Sharp 23S-up - std::pair( "accSagittalSharp25SDown", 0xE310 ), // glyphnumber: 183, Sharp 25S-down, 3° up [53 EDO] - std::pair( "accSagittalSharp25SUp", 0xE322 ), // glyphnumber: 184, Sharp 25S-up, 7° up [53 EDO] - std::pair( "accSagittalSharp35LUp", 0xE32A ), // glyphnumber: 185, Sharp 35L-up, 5° up [50 EDO] - std::pair( "accSagittalSharp35MUp", 0xE324 ), // glyphnumber: 186, Sharp 35M-up, 4° up [50 EDO], 6° up [27 EDO], 13/18-tone up - std::pair( "accSagittalSharp49LUp", 0xE3D8 ), // glyphnumber: 187, Sharp 49L-up - std::pair( "accSagittalSharp49MUp", 0xE3D4 ), // glyphnumber: 188, Sharp 49M-up - std::pair( "accSagittalSharp49SDown", 0xE3B2 ), // glyphnumber: 189, Sharp 49S-down - std::pair( "accSagittalSharp49SUp", 0xE3CC ), // glyphnumber: 190, Sharp 49S-up - std::pair( "accSagittalSharp55CDown", 0xE34E ), // glyphnumber: 191, Sharp 55C-down, 5° up [96 EDO], 5/16-tone up - std::pair( "accSagittalSharp55CUp", 0xE358 ), // glyphnumber: 192, Sharp 55C-up, 11° up [96 EDO], 11/16-tone up - std::pair( "accSagittalSharp5CDown", 0xE314 ), // glyphnumber: 193, Sharp 5C-down, 2°[22 29] 3°[34 41] 4°[46 53 60] up, 5/12-tone up - std::pair( "accSagittalSharp5CUp", 0xE31E ), // glyphnumber: 194, Sharp 5C-up, 4°[22 29] 5°[27 34 41] 6°[39 46 53] up, 7/12-tone up - std::pair( "accSagittalSharp5v11SDown", 0xE34A ), // glyphnumber: 195, Sharp 5:11S-down - std::pair( "accSagittalSharp5v11SUp", 0xE35C ), // glyphnumber: 196, Sharp 5:11S-up - std::pair( "accSagittalSharp5v13LUp", 0xE3DC ), // glyphnumber: 197, Sharp 5:13L-up - std::pair( "accSagittalSharp5v13MUp", 0xE3D0 ), // glyphnumber: 198, Sharp 5:13M-up - std::pair( "accSagittalSharp5v19CDown", 0xE378 ), // glyphnumber: 199, Sharp 5:19C-down, 9/20-tone up - std::pair( "accSagittalSharp5v19CUp", 0xE37E ), // glyphnumber: 200, Sharp 5:19C-up, 11/20-tone up - std::pair( "accSagittalSharp5v23SDown", 0xE376 ), // glyphnumber: 201, Sharp 5:23S-down, 3° up [60 EDO], 3/10-tone up - std::pair( "accSagittalSharp5v23SUp", 0xE380 ), // glyphnumber: 202, Sharp 5:23S-up, 7° up [60 EDO], 7/10-tone up - std::pair( "accSagittalSharp5v49MUp", 0xE3D6 ), // glyphnumber: 203, Sharp 5:49M-up, (one and a half apotomes) - std::pair( "accSagittalSharp5v7kDown", 0xE316 ), // glyphnumber: 204, Sharp 5:7k-down - std::pair( "accSagittalSharp5v7kUp", 0xE31C ), // glyphnumber: 205, Sharp 5:7k-up - std::pair( "accSagittalSharp7CDown", 0xE312 ), // glyphnumber: 206, Sharp 7C-down, 2° up [43 EDO], 4° up [72 EDO], 1/3-tone up - std::pair( "accSagittalSharp7CUp", 0xE320 ), // glyphnumber: 207, Sharp 7C-up, 4° up [43 EDO], 8° up [72 EDO], 2/3-tone up - std::pair( "accSagittalSharp7v11CDown", 0xE34C ), // glyphnumber: 208, Sharp 7:11C-down, 4° up [60 EDO], 2/5-tone up - std::pair( "accSagittalSharp7v11CUp", 0xE35A ), // glyphnumber: 209, Sharp 7:11C-up, 6° up [60 EDO], 3/5- tone up - std::pair( "accSagittalSharp7v11kDown", 0xE352 ), // glyphnumber: 210, Sharp 7:11k-down - std::pair( "accSagittalSharp7v11kUp", 0xE354 ), // glyphnumber: 211, Sharp 7:11k-up - std::pair( "accSagittalSharp7v19CDown", 0xE3B4 ), // glyphnumber: 212, Sharp 7:19C-down - std::pair( "accSagittalSharp7v19CUp", 0xE3CA ), // glyphnumber: 213, Sharp 7:19C-up - std::pair( "accSagittalUnused1", 0xE31A ), // glyphnumber: 214, Unused - std::pair( "accSagittalUnused2", 0xE31B ), // glyphnumber: 215, Unused - std::pair( "accSagittalUnused3", 0xE3DE ), // glyphnumber: 216, Unused - std::pair( "accSagittalUnused4", 0xE3DF ), // glyphnumber: 217, Unused - std::pair( "accdnCombDot", 0xE8CA ), // glyphnumber: 218, Combining accordion coupler dot - std::pair( "accdnCombLH2RanksEmpty", 0xE8C8 ), // glyphnumber: 219, Combining left hand, 2 ranks, empty - std::pair( "accdnCombLH3RanksEmptySquare", 0xE8C9 ), // glyphnumber: 220, Combining left hand, 3 ranks, empty (square) - std::pair( "accdnCombRH3RanksEmpty", 0xE8C6 ), // glyphnumber: 221, Combining right hand, 3 ranks, empty - std::pair( "accdnCombRH4RanksEmpty", 0xE8C7 ), // glyphnumber: 222, Combining right hand, 4 ranks, empty - std::pair( "accdnDiatonicClef", 0xE079 ), // glyphnumber: 223, Diatonic accordion clef - std::pair( "accdnLH2Ranks16Round", 0xE8BC ), // glyphnumber: 224, Left hand, 2 ranks, 16' stop (round) - std::pair( "accdnLH2Ranks8Plus16Round", 0xE8BD ), // glyphnumber: 225, Left hand, 2 ranks, 8' stop + 16' stop (round) - std::pair( "accdnLH2Ranks8Round", 0xE8BB ), // glyphnumber: 226, Left hand, 2 ranks, 8' stop (round) - std::pair( "accdnLH2RanksFullMasterRound", 0xE8C0 ), // glyphnumber: 227, Left hand, 2 ranks, full master (round) - std::pair( "accdnLH2RanksMasterPlus16Round", 0xE8BF ), // glyphnumber: 228, Left hand, 2 ranks, master + 16' stop (round) - std::pair( "accdnLH2RanksMasterRound", 0xE8BE ), // glyphnumber: 229, Left hand, 2 ranks, master (round) - std::pair( "accdnLH3Ranks2Plus8Square", 0xE8C4 ), // glyphnumber: 230, Left hand, 3 ranks, 2' stop + 8' stop (square) - std::pair( "accdnLH3Ranks2Square", 0xE8C2 ), // glyphnumber: 231, Left hand, 3 ranks, 2' stop (square) - std::pair( "accdnLH3Ranks8Square", 0xE8C1 ), // glyphnumber: 232, Left hand, 3 ranks, 8' stop (square) - std::pair( "accdnLH3RanksDouble8Square", 0xE8C3 ), // glyphnumber: 233, Left hand, 3 ranks, double 8' stop (square) - std::pair( "accdnLH3RanksTuttiSquare", 0xE8C5 ), // glyphnumber: 234, Left hand, 3 ranks, 2' stop + double 8' stop (tutti) (square) - std::pair( "accdnPull", 0xE8CC ), // glyphnumber: 235, Pull - std::pair( "accdnPush", 0xE8CB ), // glyphnumber: 236, Push - std::pair( "accdnRH3RanksAccordion", 0xE8AC ), // glyphnumber: 237, Right hand, 3 ranks, 8' stop + upper tremolo 8' stop + 16' stop (accordion) - std::pair( "accdnRH3RanksAuthenticMusette", 0xE8A8 ), // glyphnumber: 238, Right hand, 3 ranks, lower tremolo 8' stop + 8' stop + upper tremolo 8' stop (authentic musette) - std::pair( "accdnRH3RanksBandoneon", 0xE8AB ), // glyphnumber: 239, Right hand, 3 ranks, 8' stop + 16' stop (bandoneón) - std::pair( "accdnRH3RanksBassoon", 0xE8A4 ), // glyphnumber: 240, Right hand, 3 ranks, 16' stop (bassoon) - std::pair( "accdnRH3RanksClarinet", 0xE8A1 ), // glyphnumber: 241, Right hand, 3 ranks, 8' stop (clarinet) - std::pair( "accdnRH3RanksDoubleTremoloLower8ve", 0xE8B1 ), // glyphnumber: 242, Right hand, 3 ranks, lower tremolo 8' stop + 8' stop + upper tremolo 8' stop + 16' stop - std::pair( "accdnRH3RanksDoubleTremoloUpper8ve", 0xE8B2 ), // glyphnumber: 243, Right hand, 3 ranks, 4' stop + lower tremolo 8' stop + 8' stop + upper tremolo 8' stop - std::pair( "accdnRH3RanksFullFactory", 0xE8B3 ), // glyphnumber: 244, Right hand, 3 ranks, 4' stop + lower tremolo 8' stop + 8' stop + upper tremolo 8' stop + 16' stop - std::pair( "accdnRH3RanksHarmonium", 0xE8AA ), // glyphnumber: 245, Right hand, 3 ranks, 4' stop + 8' stop + 16' stop (harmonium) - std::pair( "accdnRH3RanksImitationMusette", 0xE8A7 ), // glyphnumber: 246, Right hand, 3 ranks, 4' stop + 8' stop + upper tremolo 8' stop (imitation musette) - std::pair( "accdnRH3RanksLowerTremolo8", 0xE8A3 ), // glyphnumber: 247, Right hand, 3 ranks, lower tremolo 8' stop - std::pair( "accdnRH3RanksMaster", 0xE8AD ), // glyphnumber: 248, Right hand, 3 ranks, 4' stop + lower tremolo 8' stop + upper tremolo 8' stop + 16' stop (master) - std::pair( "accdnRH3RanksOboe", 0xE8A5 ), // glyphnumber: 249, Right hand, 3 ranks, 4' stop + 8' stop (oboe) - std::pair( "accdnRH3RanksOrgan", 0xE8A9 ), // glyphnumber: 250, Right hand, 3 ranks, 4' stop + 16' stop (organ) - std::pair( "accdnRH3RanksPiccolo", 0xE8A0 ), // glyphnumber: 251, Right hand, 3 ranks, 4' stop (piccolo) - std::pair( "accdnRH3RanksTremoloLower8ve", 0xE8AF ), // glyphnumber: 252, Right hand, 3 ranks, lower tremolo 8' stop + upper tremolo 8' stop + 16' stop - std::pair( "accdnRH3RanksTremoloUpper8ve", 0xE8B0 ), // glyphnumber: 253, Right hand, 3 ranks, 4' stop + lower tremolo 8' stop + upper tremolo 8' stop - std::pair( "accdnRH3RanksTwoChoirs", 0xE8AE ), // glyphnumber: 254, Right hand, 3 ranks, lower tremolo 8' stop + upper tremolo 8' stop - std::pair( "accdnRH3RanksUpperTremolo8", 0xE8A2 ), // glyphnumber: 255, Right hand, 3 ranks, upper tremolo 8' stop - std::pair( "accdnRH3RanksViolin", 0xE8A6 ), // glyphnumber: 256, Right hand, 3 ranks, 8' stop + upper tremolo 8' stop (violin) - std::pair( "accdnRH4RanksAlto", 0xE8B5 ), // glyphnumber: 257, Right hand, 4 ranks, alto - std::pair( "accdnRH4RanksBassAlto", 0xE8BA ), // glyphnumber: 258, Right hand, 4 ranks, bass/alto - std::pair( "accdnRH4RanksMaster", 0xE8B7 ), // glyphnumber: 259, Right hand, 4 ranks, master - std::pair( "accdnRH4RanksSoftBass", 0xE8B8 ), // glyphnumber: 260, Right hand, 4 ranks, soft bass - std::pair( "accdnRH4RanksSoftTenor", 0xE8B9 ), // glyphnumber: 261, Right hand, 4 ranks, soft tenor - std::pair( "accdnRH4RanksSoprano", 0xE8B4 ), // glyphnumber: 262, Right hand, 4 ranks, soprano - std::pair( "accdnRH4RanksTenor", 0xE8B6 ), // glyphnumber: 263, Right hand, 4 ranks, tenor - std::pair( "accdnRicochet2", 0xE8CD ), // glyphnumber: 264, Ricochet (2 tones) - std::pair( "accdnRicochet3", 0xE8CE ), // glyphnumber: 265, Ricochet (3 tones) - std::pair( "accdnRicochet4", 0xE8CF ), // glyphnumber: 266, Ricochet (4 tones) - std::pair( "accdnRicochet5", 0xE8D0 ), // glyphnumber: 267, Ricochet (5 tones) - std::pair( "accdnRicochet6", 0xE8D1 ), // glyphnumber: 268, Ricochet (6 tones) - std::pair( "accdnRicochetStem2", 0xE8D2 ), // glyphnumber: 269, Combining ricochet for stem (2 tones) - std::pair( "accdnRicochetStem3", 0xE8D3 ), // glyphnumber: 270, Combining ricochet for stem (3 tones) - std::pair( "accdnRicochetStem4", 0xE8D4 ), // glyphnumber: 271, Combining ricochet for stem (4 tones) - std::pair( "accdnRicochetStem5", 0xE8D5 ), // glyphnumber: 272, Combining ricochet for stem (5 tones) - std::pair( "accdnRicochetStem6", 0xE8D6 ), // glyphnumber: 273, Combining ricochet for stem (6 tones) - std::pair( "accidental1CommaFlat", 0xE454 ), // glyphnumber: 274, 1-comma flat - std::pair( "accidental1CommaSharp", 0xE450 ), // glyphnumber: 275, 1-comma sharp - std::pair( "accidental2CommaFlat", 0xE455 ), // glyphnumber: 276, 2-comma flat - std::pair( "accidental2CommaSharp", 0xE451 ), // glyphnumber: 277, 2-comma sharp - std::pair( "accidental3CommaFlat", 0xE456 ), // glyphnumber: 278, 3-comma flat - std::pair( "accidental3CommaSharp", 0xE452 ), // glyphnumber: 279, 3-comma sharp - std::pair( "accidental4CommaFlat", 0xE457 ), // glyphnumber: 280, 4-comma flat - std::pair( "accidental5CommaSharp", 0xE453 ), // glyphnumber: 281, 5-comma sharp - std::pair( "accidentalArrowDown", 0xE27B ), // glyphnumber: 282, Arrow down (lower by one quarter-tone) - std::pair( "accidentalArrowUp", 0xE27A ), // glyphnumber: 283, Arrow up (raise by one quarter-tone) - std::pair( "accidentalBakiyeFlat", 0xE442 ), // glyphnumber: 284, Bakiye (flat) - std::pair( "accidentalBakiyeSharp", 0xE445 ), // glyphnumber: 285, Bakiye (sharp) - std::pair( "accidentalBracketLeft", 0xE26C ), // glyphnumber: 286, Accidental bracket, left - std::pair( "accidentalBracketRight", 0xE26D ), // glyphnumber: 287, Accidental bracket, right - std::pair( "accidentalBuyukMucennebFlat", 0xE440 ), // glyphnumber: 288, Büyük mücenneb (flat) - std::pair( "accidentalBuyukMucennebSharp", 0xE447 ), // glyphnumber: 289, Büyük mücenneb (sharp) - std::pair( "accidentalCombiningCloseCurlyBrace", 0xE2EF ), // glyphnumber: 290, Combining close curly brace - std::pair( "accidentalCombiningLower17Schisma", 0xE2E6 ), // glyphnumber: 291, Combining lower by one 17-limit schisma - std::pair( "accidentalCombiningLower19Schisma", 0xE2E8 ), // glyphnumber: 292, Combining lower by one 19-limit schisma - std::pair( "accidentalCombiningLower23Limit29LimitComma", 0xE2EA ), // glyphnumber: 293, Combining lower by one 23-limit comma or 29-limit comma - std::pair( "accidentalCombiningLower31Schisma", 0xE2EC ), // glyphnumber: 294, Combining lower by one 31-limit schisma - std::pair( "accidentalCombiningLower53LimitComma", 0xE2F7 ), // glyphnumber: 295, Combining lower by one 53-limit comma - std::pair( "accidentalCombiningOpenCurlyBrace", 0xE2EE ), // glyphnumber: 296, Combining open curly brace - std::pair( "accidentalCombiningRaise17Schisma", 0xE2E7 ), // glyphnumber: 297, Combining raise by one 17-limit schisma - std::pair( "accidentalCombiningRaise19Schisma", 0xE2E9 ), // glyphnumber: 298, Combining raise by one 19-limit schisma - std::pair( "accidentalCombiningRaise23Limit29LimitComma", 0xE2EB ), // glyphnumber: 299, Combining raise by one 23-limit comma or 29-limit comma - std::pair( "accidentalCombiningRaise31Schisma", 0xE2ED ), // glyphnumber: 300, Combining raise by one 31-limit schisma - std::pair( "accidentalCombiningRaise53LimitComma", 0xE2F8 ), // glyphnumber: 301, Combining raise by one 53-limit comma - std::pair( "accidentalCommaSlashDown", 0xE47A ), // glyphnumber: 302, Syntonic/Didymus comma (80:81) down (Bosanquet) - std::pair( "accidentalCommaSlashUp", 0xE479 ), // glyphnumber: 303, Syntonic/Didymus comma (80:81) up (Bosanquet) - std::pair( "accidentalDoubleFlat", 0xE264 ), // glyphnumber: 304, Double flat - std::pair( "accidentalDoubleFlatArabic", 0xED30 ), // glyphnumber: 305, Arabic double flat - std::pair( "accidentalDoubleFlatEqualTempered", 0xE2F0 ), // glyphnumber: 306, Double flat equal tempered semitone - std::pair( "accidentalDoubleFlatOneArrowDown", 0xE2C0 ), // glyphnumber: 307, Double flat lowered by one syntonic comma - std::pair( "accidentalDoubleFlatOneArrowUp", 0xE2C5 ), // glyphnumber: 308, Double flat raised by one syntonic comma - std::pair( "accidentalDoubleFlatReversed", 0xE483 ), // glyphnumber: 309, Reversed double flat - std::pair( "accidentalDoubleFlatThreeArrowsDown", 0xE2D4 ), // glyphnumber: 310, Double flat lowered by three syntonic commas - std::pair( "accidentalDoubleFlatThreeArrowsUp", 0xE2D9 ), // glyphnumber: 311, Double flat raised by three syntonic commas - std::pair( "accidentalDoubleFlatTurned", 0xE485 ), // glyphnumber: 312, Turned double flat - std::pair( "accidentalDoubleFlatTwoArrowsDown", 0xE2CA ), // glyphnumber: 313, Double flat lowered by two syntonic commas - std::pair( "accidentalDoubleFlatTwoArrowsUp", 0xE2CF ), // glyphnumber: 314, Double flat raised by two syntonic commas - std::pair( "accidentalDoubleSharp", 0xE263 ), // glyphnumber: 315, Double sharp - std::pair( "accidentalDoubleSharpArabic", 0xED38 ), // glyphnumber: 316, Arabic double sharp - std::pair( "accidentalDoubleSharpEqualTempered", 0xE2F4 ), // glyphnumber: 317, Double sharp equal tempered semitone - std::pair( "accidentalDoubleSharpOneArrowDown", 0xE2C4 ), // glyphnumber: 318, Double sharp lowered by one syntonic comma - std::pair( "accidentalDoubleSharpOneArrowUp", 0xE2C9 ), // glyphnumber: 319, Double sharp raised by one syntonic comma - std::pair( "accidentalDoubleSharpThreeArrowsDown", 0xE2D8 ), // glyphnumber: 320, Double sharp lowered by three syntonic commas - std::pair( "accidentalDoubleSharpThreeArrowsUp", 0xE2DD ), // glyphnumber: 321, Double sharp raised by three syntonic commas - std::pair( "accidentalDoubleSharpTwoArrowsDown", 0xE2CE ), // glyphnumber: 322, Double sharp lowered by two syntonic commas - std::pair( "accidentalDoubleSharpTwoArrowsUp", 0xE2D3 ), // glyphnumber: 323, Double sharp raised by two syntonic commas - std::pair( "accidentalEnharmonicAlmostEqualTo", 0xE2FA ), // glyphnumber: 324, Enharmonically reinterpret accidental almost equal to - std::pair( "accidentalEnharmonicEquals", 0xE2FB ), // glyphnumber: 325, Enharmonically reinterpret accidental equals - std::pair( "accidentalEnharmonicTilde", 0xE2F9 ), // glyphnumber: 326, Enharmonically reinterpret accidental tilde - std::pair( "accidentalFilledReversedFlatAndFlat", 0xE296 ), // glyphnumber: 327, Filled reversed flat and flat - std::pair( "accidentalFilledReversedFlatAndFlatArrowDown", 0xE298 ), // glyphnumber: 328, Filled reversed flat and flat with arrow down - std::pair( "accidentalFilledReversedFlatAndFlatArrowUp", 0xE297 ), // glyphnumber: 329, Filled reversed flat and flat with arrow up - std::pair( "accidentalFilledReversedFlatArrowDown", 0xE293 ), // glyphnumber: 330, Filled reversed flat with arrow down - std::pair( "accidentalFilledReversedFlatArrowUp", 0xE292 ), // glyphnumber: 331, Filled reversed flat with arrow up - std::pair( "accidentalFiveQuarterTonesFlatArrowDown", 0xE279 ), // glyphnumber: 332, Five-quarter-tones flat - std::pair( "accidentalFiveQuarterTonesSharpArrowUp", 0xE276 ), // glyphnumber: 333, Five-quarter-tones sharp - std::pair( "accidentalFlat", 0xE260 ), // glyphnumber: 334, Flat - std::pair( "accidentalFlatArabic", 0xED32 ), // glyphnumber: 335, Arabic half-tone flat - std::pair( "accidentalFlatEqualTempered", 0xE2F1 ), // glyphnumber: 336, Flat equal tempered semitone - std::pair( "accidentalFlatLoweredStockhausen", 0xED53 ), // glyphnumber: 337, Lowered flat (Stockhausen) - std::pair( "accidentalFlatOneArrowDown", 0xE2C1 ), // glyphnumber: 338, Flat lowered by one syntonic comma - std::pair( "accidentalFlatOneArrowUp", 0xE2C6 ), // glyphnumber: 339, Flat raised by one syntonic comma - std::pair( "accidentalFlatRaisedStockhausen", 0xED52 ), // glyphnumber: 340, Raised flat (Stockhausen) - std::pair( "accidentalFlatRepeatedLineStockhausen", 0xED5C ), // glyphnumber: 341, Repeated flat, note on line (Stockhausen) - std::pair( "accidentalFlatRepeatedSpaceStockhausen", 0xED5B ), // glyphnumber: 342, Repeated flat, note in space (Stockhausen) - std::pair( "accidentalFlatThreeArrowsDown", 0xE2D5 ), // glyphnumber: 343, Flat lowered by three syntonic commas - std::pair( "accidentalFlatThreeArrowsUp", 0xE2DA ), // glyphnumber: 344, Flat raised by three syntonic commas - std::pair( "accidentalFlatTurned", 0xE484 ), // glyphnumber: 345, Turned flat - std::pair( "accidentalFlatTwoArrowsDown", 0xE2CB ), // glyphnumber: 346, Flat lowered by two syntonic commas - std::pair( "accidentalFlatTwoArrowsUp", 0xE2D0 ), // glyphnumber: 347, Flat raised by two syntonic commas - std::pair( "accidentalHalfSharpArrowDown", 0xE29A ), // glyphnumber: 348, Half sharp with arrow down - std::pair( "accidentalHalfSharpArrowUp", 0xE299 ), // glyphnumber: 349, Half sharp with arrow up - std::pair( "accidentalJohnston13", 0xE2B6 ), // glyphnumber: 350, Thirteen (raise by 65:64) - std::pair( "accidentalJohnston31", 0xE2B7 ), // glyphnumber: 351, Inverted 13 (lower by 65:64) - std::pair( "accidentalJohnstonDown", 0xE2B5 ), // glyphnumber: 352, Down arrow (lower by 33:32) - std::pair( "accidentalJohnstonEl", 0xE2B2 ), // glyphnumber: 353, Inverted seven (raise by 36:35) - std::pair( "accidentalJohnstonMinus", 0xE2B1 ), // glyphnumber: 354, Minus (lower by 81:80) - std::pair( "accidentalJohnstonPlus", 0xE2B0 ), // glyphnumber: 355, Plus (raise by 81:80) - std::pair( "accidentalJohnstonSeven", 0xE2B3 ), // glyphnumber: 356, Seven (lower by 36:35) - std::pair( "accidentalJohnstonUp", 0xE2B4 ), // glyphnumber: 357, Up arrow (raise by 33:32) - std::pair( "accidentalKomaFlat", 0xE443 ), // glyphnumber: 358, Koma (flat) - std::pair( "accidentalKomaSharp", 0xE444 ), // glyphnumber: 359, Koma (sharp) - std::pair( "accidentalKoron", 0xE460 ), // glyphnumber: 360, Koron (quarter tone flat) - std::pair( "accidentalKucukMucennebFlat", 0xE441 ), // glyphnumber: 361, Küçük mücenneb (flat) - std::pair( "accidentalKucukMucennebSharp", 0xE446 ), // glyphnumber: 362, Küçük mücenneb (sharp) - std::pair( "accidentalLargeDoubleSharp", 0xE47D ), // glyphnumber: 363, Large double sharp - std::pair( "accidentalLowerOneSeptimalComma", 0xE2DE ), // glyphnumber: 364, Lower by one septimal comma - std::pair( "accidentalLowerOneTridecimalQuartertone", 0xE2E4 ), // glyphnumber: 365, Lower by one tridecimal quartertone - std::pair( "accidentalLowerOneUndecimalQuartertone", 0xE2E2 ), // glyphnumber: 366, Lower by one undecimal quartertone - std::pair( "accidentalLowerTwoSeptimalCommas", 0xE2E0 ), // glyphnumber: 367, Lower by two septimal commas - std::pair( "accidentalLoweredStockhausen", 0xED51 ), // glyphnumber: 368, Lowered (Stockhausen) - std::pair( "accidentalNarrowReversedFlat", 0xE284 ), // glyphnumber: 369, Narrow reversed flat(quarter-tone flat) - std::pair( "accidentalNarrowReversedFlatAndFlat", 0xE285 ), // glyphnumber: 370, Narrow reversed flat and flat(three-quarter-tones flat) - std::pair( "accidentalNatural", 0xE261 ), // glyphnumber: 371, Natural - std::pair( "accidentalNaturalArabic", 0xED34 ), // glyphnumber: 372, Arabic natural - std::pair( "accidentalNaturalEqualTempered", 0xE2F2 ), // glyphnumber: 373, Natural equal tempered semitone - std::pair( "accidentalNaturalFlat", 0xE267 ), // glyphnumber: 374, Natural flat - std::pair( "accidentalNaturalLoweredStockhausen", 0xED55 ), // glyphnumber: 375, Lowered natural (Stockhausen) - std::pair( "accidentalNaturalOneArrowDown", 0xE2C2 ), // glyphnumber: 376, Natural lowered by one syntonic comma - std::pair( "accidentalNaturalOneArrowUp", 0xE2C7 ), // glyphnumber: 377, Natural raised by one syntonic comma - std::pair( "accidentalNaturalRaisedStockhausen", 0xED54 ), // glyphnumber: 378, Raised natural (Stockhausen) - std::pair( "accidentalNaturalReversed", 0xE482 ), // glyphnumber: 379, Reversed natural - std::pair( "accidentalNaturalSharp", 0xE268 ), // glyphnumber: 380, Natural sharp - std::pair( "accidentalNaturalThreeArrowsDown", 0xE2D6 ), // glyphnumber: 381, Natural lowered by three syntonic commas - std::pair( "accidentalNaturalThreeArrowsUp", 0xE2DB ), // glyphnumber: 382, Natural raised by three syntonic commas - std::pair( "accidentalNaturalTwoArrowsDown", 0xE2CC ), // glyphnumber: 383, Natural lowered by two syntonic commas - std::pair( "accidentalNaturalTwoArrowsUp", 0xE2D1 ), // glyphnumber: 384, Natural raised by two syntonic commas - std::pair( "accidentalOneAndAHalfSharpsArrowDown", 0xE29C ), // glyphnumber: 385, One and a half sharps with arrow down - std::pair( "accidentalOneAndAHalfSharpsArrowUp", 0xE29B ), // glyphnumber: 386, One and a half sharps with arrow up - std::pair( "accidentalOneQuarterToneFlatFerneyhough", 0xE48F ), // glyphnumber: 387, One-quarter-tone flat (Ferneyhough) - std::pair( "accidentalOneQuarterToneFlatStockhausen", 0xED59 ), // glyphnumber: 388, One-quarter-tone flat (Stockhausen) - std::pair( "accidentalOneQuarterToneSharpFerneyhough", 0xE48E ), // glyphnumber: 389, One-quarter-tone sharp (Ferneyhough) - std::pair( "accidentalOneQuarterToneSharpStockhausen", 0xED58 ), // glyphnumber: 390, One-quarter-tone sharp (Stockhausen) - std::pair( "accidentalOneThirdToneFlatFerneyhough", 0xE48B ), // glyphnumber: 391, One-third-tone flat (Ferneyhough) - std::pair( "accidentalOneThirdToneSharpFerneyhough", 0xE48A ), // glyphnumber: 392, One-third-tone sharp (Ferneyhough) - std::pair( "accidentalParensLeft", 0xE26A ), // glyphnumber: 393, Accidental parenthesis, left - std::pair( "accidentalParensRight", 0xE26B ), // glyphnumber: 394, Accidental parenthesis, right - std::pair( "accidentalQuarterFlatEqualTempered", 0xE2F5 ), // glyphnumber: 395, Lower by one equal tempered quarter-tone - std::pair( "accidentalQuarterSharpEqualTempered", 0xE2F6 ), // glyphnumber: 396, Raise by one equal tempered quarter tone - std::pair( "accidentalQuarterToneFlat4", 0xE47F ), // glyphnumber: 397, Quarter-tone flat - std::pair( "accidentalQuarterToneFlatArabic", 0xED33 ), // glyphnumber: 398, Arabic quarter-tone flat - std::pair( "accidentalQuarterToneFlatArrowUp", 0xE270 ), // glyphnumber: 399, Quarter-tone flat - std::pair( "accidentalQuarterToneFlatFilledReversed", 0xE480 ), // glyphnumber: 400, Filled reversed flat (quarter-tone flat) - std::pair( "accidentalQuarterToneFlatNaturalArrowDown", 0xE273 ), // glyphnumber: 401, Quarter-tone flat - std::pair( "accidentalQuarterToneFlatPenderecki", 0xE478 ), // glyphnumber: 402, Quarter tone flat (Penderecki) - std::pair( "accidentalQuarterToneFlatStein", 0xE280 ), // glyphnumber: 403, Reversed flat (quarter-tone flat) (Stein) - std::pair( "accidentalQuarterToneFlatVanBlankenburg", 0xE488 ), // glyphnumber: 404, Quarter-tone flat (van Blankenburg) - std::pair( "accidentalQuarterToneSharp4", 0xE47E ), // glyphnumber: 405, Quarter-tone sharp - std::pair( "accidentalQuarterToneSharpArabic", 0xED35 ), // glyphnumber: 406, Arabic quarter-tone sharp - std::pair( "accidentalQuarterToneSharpArrowDown", 0xE275 ), // glyphnumber: 407, Quarter-tone sharp - std::pair( "accidentalQuarterToneSharpBusotti", 0xE472 ), // glyphnumber: 408, Quarter tone sharp (Bussotti) - std::pair( "accidentalQuarterToneSharpNaturalArrowUp", 0xE272 ), // glyphnumber: 409, Quarter-tone sharp - std::pair( "accidentalQuarterToneSharpStein", 0xE282 ), // glyphnumber: 410, Half sharp (quarter-tone sharp) (Stein) - std::pair( "accidentalQuarterToneSharpWiggle", 0xE475 ), // glyphnumber: 411, Quarter tone sharp with wiggly tail - std::pair( "accidentalRaiseOneSeptimalComma", 0xE2DF ), // glyphnumber: 412, Raise by one septimal comma - std::pair( "accidentalRaiseOneTridecimalQuartertone", 0xE2E5 ), // glyphnumber: 413, Raise by one tridecimal quartertone - std::pair( "accidentalRaiseOneUndecimalQuartertone", 0xE2E3 ), // glyphnumber: 414, Raise by one undecimal quartertone - std::pair( "accidentalRaiseTwoSeptimalCommas", 0xE2E1 ), // glyphnumber: 415, Raise by two septimal commas - std::pair( "accidentalRaisedStockhausen", 0xED50 ), // glyphnumber: 416, Raised (Stockhausen) - std::pair( "accidentalReversedFlatAndFlatArrowDown", 0xE295 ), // glyphnumber: 417, Reversed flat and flat with arrow down - std::pair( "accidentalReversedFlatAndFlatArrowUp", 0xE294 ), // glyphnumber: 418, Reversed flat and flat with arrow up - std::pair( "accidentalReversedFlatArrowDown", 0xE291 ), // glyphnumber: 419, Reversed flat with arrow down - std::pair( "accidentalReversedFlatArrowUp", 0xE290 ), // glyphnumber: 420, Reversed flat with arrow up - std::pair( "accidentalSharp", 0xE262 ), // glyphnumber: 421, Sharp - std::pair( "accidentalSharpArabic", 0xED36 ), // glyphnumber: 422, Arabic half-tone sharp - std::pair( "accidentalSharpEqualTempered", 0xE2F3 ), // glyphnumber: 423, Sharp equal tempered semitone - std::pair( "accidentalSharpLoweredStockhausen", 0xED57 ), // glyphnumber: 424, Lowered sharp (Stockhausen) - std::pair( "accidentalSharpOneArrowDown", 0xE2C3 ), // glyphnumber: 425, Sharp lowered by one syntonic comma - std::pair( "accidentalSharpOneArrowUp", 0xE2C8 ), // glyphnumber: 426, Sharp raised by one syntonic comma - std::pair( "accidentalSharpOneHorizontalStroke", 0xE473 ), // glyphnumber: 427, One or three quarter tones sharp - std::pair( "accidentalSharpRaisedStockhausen", 0xED56 ), // glyphnumber: 428, Raised sharp (Stockhausen) - std::pair( "accidentalSharpRepeatedLineStockhausen", 0xED5E ), // glyphnumber: 429, Repeated sharp, note on line (Stockhausen) - std::pair( "accidentalSharpRepeatedSpaceStockhausen", 0xED5D ), // glyphnumber: 430, Repeated sharp, note in space (Stockhausen) - std::pair( "accidentalSharpReversed", 0xE481 ), // glyphnumber: 431, Reversed sharp - std::pair( "accidentalSharpSharp", 0xE269 ), // glyphnumber: 432, Sharp sharp - std::pair( "accidentalSharpThreeArrowsDown", 0xE2D7 ), // glyphnumber: 433, Sharp lowered by three syntonic commas - std::pair( "accidentalSharpThreeArrowsUp", 0xE2DC ), // glyphnumber: 434, Sharp raised by three syntonic commas - std::pair( "accidentalSharpTwoArrowsDown", 0xE2CD ), // glyphnumber: 435, Sharp lowered by two syntonic commas - std::pair( "accidentalSharpTwoArrowsUp", 0xE2D2 ), // glyphnumber: 436, Sharp raised by two syntonic commas - std::pair( "accidentalSims12Down", 0xE2A0 ), // glyphnumber: 437, 1/12 tone low - std::pair( "accidentalSims12Up", 0xE2A3 ), // glyphnumber: 438, 1/12 tone high - std::pair( "accidentalSims4Down", 0xE2A2 ), // glyphnumber: 439, 1/4 tone low - std::pair( "accidentalSims4Up", 0xE2A5 ), // glyphnumber: 440, 1/4 tone high - std::pair( "accidentalSims6Down", 0xE2A1 ), // glyphnumber: 441, 1/6 tone low - std::pair( "accidentalSims6Up", 0xE2A4 ), // glyphnumber: 442, 1/6 tone high - std::pair( "accidentalSori", 0xE461 ), // glyphnumber: 443, Sori (quarter tone sharp) - std::pair( "accidentalTavenerFlat", 0xE477 ), // glyphnumber: 444, Byzantine-style Bakiye flat (Tavener) - std::pair( "accidentalTavenerSharp", 0xE476 ), // glyphnumber: 445, Byzantine-style Büyük mücenneb sharp (Tavener) - std::pair( "accidentalThreeQuarterTonesFlatArabic", 0xED31 ), // glyphnumber: 446, Arabic three-quarter-tones flat - std::pair( "accidentalThreeQuarterTonesFlatArrowDown", 0xE271 ), // glyphnumber: 447, Three-quarter-tones flat - std::pair( "accidentalThreeQuarterTonesFlatArrowUp", 0xE278 ), // glyphnumber: 448, Three-quarter-tones flat - std::pair( "accidentalThreeQuarterTonesFlatCouper", 0xE489 ), // glyphnumber: 449, Three-quarter-tones flat (Couper) - std::pair( "accidentalThreeQuarterTonesFlatGrisey", 0xE486 ), // glyphnumber: 450, Three-quarter-tones flat (Grisey) - std::pair( "accidentalThreeQuarterTonesFlatTartini", 0xE487 ), // glyphnumber: 451, Three-quarter-tones flat (Tartini) - std::pair( "accidentalThreeQuarterTonesFlatZimmermann", 0xE281 ), // glyphnumber: 452, Reversed flat and flat (three-quarter-tones flat)(Zimmermann) - std::pair( "accidentalThreeQuarterTonesSharpArabic", 0xED37 ), // glyphnumber: 453, Arabic three-quarter-tones sharp - std::pair( "accidentalThreeQuarterTonesSharpArrowDown", 0xE277 ), // glyphnumber: 454, Three-quarter-tones sharp - std::pair( "accidentalThreeQuarterTonesSharpArrowUp", 0xE274 ), // glyphnumber: 455, Three-quarter-tones sharp - std::pair( "accidentalThreeQuarterTonesSharpBusotti", 0xE474 ), // glyphnumber: 456, Three quarter tones sharp (Bussotti) - std::pair( "accidentalThreeQuarterTonesSharpStein", 0xE283 ), // glyphnumber: 457, One and a half sharps (three-quarter-tones sharp) (Stein) - std::pair( "accidentalThreeQuarterTonesSharpStockhausen", 0xED5A ), // glyphnumber: 458, Three-quarter-tones sharp (Stockhausen) - std::pair( "accidentalTripleFlat", 0xE266 ), // glyphnumber: 459, Triple flat - std::pair( "accidentalTripleSharp", 0xE265 ), // glyphnumber: 460, Triple sharp - std::pair( "accidentalTwoThirdTonesFlatFerneyhough", 0xE48D ), // glyphnumber: 461, Two-third-tones flat (Ferneyhough) - std::pair( "accidentalTwoThirdTonesSharpFerneyhough", 0xE48C ), // glyphnumber: 462, Two-third-tones sharp (Ferneyhough) - std::pair( "accidentalWilsonMinus", 0xE47C ), // glyphnumber: 463, Wilson minus (5 comma down) - std::pair( "accidentalWilsonPlus", 0xE47B ), // glyphnumber: 464, Wilson plus (5 comma up) - std::pair( "accidentalWyschnegradsky10TwelfthsFlat", 0xE434 ), // glyphnumber: 465, 5/6 tone flat - std::pair( "accidentalWyschnegradsky10TwelfthsSharp", 0xE429 ), // glyphnumber: 466, 5/6 tone sharp - std::pair( "accidentalWyschnegradsky11TwelfthsFlat", 0xE435 ), // glyphnumber: 467, 11/12 tone flat - std::pair( "accidentalWyschnegradsky11TwelfthsSharp", 0xE42A ), // glyphnumber: 468, 11/12 tone sharp - std::pair( "accidentalWyschnegradsky1TwelfthsFlat", 0xE42B ), // glyphnumber: 469, 1/12 tone flat - std::pair( "accidentalWyschnegradsky1TwelfthsSharp", 0xE420 ), // glyphnumber: 470, 1/12 tone sharp - std::pair( "accidentalWyschnegradsky2TwelfthsFlat", 0xE42C ), // glyphnumber: 471, 1/6 tone flat - std::pair( "accidentalWyschnegradsky2TwelfthsSharp", 0xE421 ), // glyphnumber: 472, 1/6 tone sharp - std::pair( "accidentalWyschnegradsky3TwelfthsFlat", 0xE42D ), // glyphnumber: 473, 1/4 tone flat - std::pair( "accidentalWyschnegradsky3TwelfthsSharp", 0xE422 ), // glyphnumber: 474, 1/4 tone sharp - std::pair( "accidentalWyschnegradsky4TwelfthsFlat", 0xE42E ), // glyphnumber: 475, 1/3 tone flat - std::pair( "accidentalWyschnegradsky4TwelfthsSharp", 0xE423 ), // glyphnumber: 476, 1/3 tone sharp - std::pair( "accidentalWyschnegradsky5TwelfthsFlat", 0xE42F ), // glyphnumber: 477, 5/12 tone flat - std::pair( "accidentalWyschnegradsky5TwelfthsSharp", 0xE424 ), // glyphnumber: 478, 5/12 tone sharp - std::pair( "accidentalWyschnegradsky6TwelfthsFlat", 0xE430 ), // glyphnumber: 479, 1/2 tone flat - std::pair( "accidentalWyschnegradsky6TwelfthsSharp", 0xE425 ), // glyphnumber: 480, 1/2 tone sharp - std::pair( "accidentalWyschnegradsky7TwelfthsFlat", 0xE431 ), // glyphnumber: 481, 7/12 tone flat - std::pair( "accidentalWyschnegradsky7TwelfthsSharp", 0xE426 ), // glyphnumber: 482, 7/12 tone sharp - std::pair( "accidentalWyschnegradsky8TwelfthsFlat", 0xE432 ), // glyphnumber: 483, 2/3 tone flat - std::pair( "accidentalWyschnegradsky8TwelfthsSharp", 0xE427 ), // glyphnumber: 484, 2/3 tone sharp - std::pair( "accidentalWyschnegradsky9TwelfthsFlat", 0xE433 ), // glyphnumber: 485, 3/4 tone flat - std::pair( "accidentalWyschnegradsky9TwelfthsSharp", 0xE428 ), // glyphnumber: 486, 3/4 tone sharp - std::pair( "accidentalXenakisOneThirdToneSharp", 0xE470 ), // glyphnumber: 487, One-third-tone sharp (Xenakis) - std::pair( "accidentalXenakisTwoThirdTonesSharp", 0xE471 ), // glyphnumber: 488, Two-third-tones sharp (Xenakis) - std::pair( "analyticsChoralmelodie", 0xE86A ), // glyphnumber: 489, Choralmelodie (Berg) - std::pair( "analyticsEndStimme", 0xE863 ), // glyphnumber: 490, End of stimme - std::pair( "analyticsHauptrhythmus", 0xE86B ), // glyphnumber: 491, Hauptrhythmus (Berg) - std::pair( "analyticsHauptstimme", 0xE860 ), // glyphnumber: 492, Hauptstimme - std::pair( "analyticsInversion1", 0xE869 ), // glyphnumber: 493, Inversion 1 - std::pair( "analyticsNebenstimme", 0xE861 ), // glyphnumber: 494, Nebenstimme - std::pair( "analyticsStartStimme", 0xE862 ), // glyphnumber: 495, Start of stimme - std::pair( "analyticsTheme", 0xE864 ), // glyphnumber: 496, Theme - std::pair( "analyticsTheme1", 0xE868 ), // glyphnumber: 497, Theme 1 - std::pair( "analyticsThemeInversion", 0xE867 ), // glyphnumber: 498, Inversion of theme - std::pair( "analyticsThemeRetrograde", 0xE865 ), // glyphnumber: 499, Retrograde of theme - std::pair( "analyticsThemeRetrogradeInversion", 0xE866 ), // glyphnumber: 500, Retrograde inversion of theme - std::pair( "arpeggiatoDown", 0xE635 ), // glyphnumber: 501, Arpeggiato down - std::pair( "arpeggiatoUp", 0xE634 ), // glyphnumber: 502, Arpeggiato up - std::pair( "arrowBlackDown", 0xEB64 ), // glyphnumber: 503, Black arrow down (S) - std::pair( "arrowBlackDownLeft", 0xEB65 ), // glyphnumber: 504, Black arrow down-left (SW) - std::pair( "arrowBlackDownRight", 0xEB63 ), // glyphnumber: 505, Black arrow down-right (SE) - std::pair( "arrowBlackLeft", 0xEB66 ), // glyphnumber: 506, Black arrow left (W) - std::pair( "arrowBlackRight", 0xEB62 ), // glyphnumber: 507, Black arrow right (E) - std::pair( "arrowBlackUp", 0xEB60 ), // glyphnumber: 508, Black arrow up (N) - std::pair( "arrowBlackUpLeft", 0xEB67 ), // glyphnumber: 509, Black arrow up-left (NW) - std::pair( "arrowBlackUpRight", 0xEB61 ), // glyphnumber: 510, Black arrow up-right (NE) - std::pair( "arrowOpenDown", 0xEB74 ), // glyphnumber: 511, Open arrow down (S) - std::pair( "arrowOpenDownLeft", 0xEB75 ), // glyphnumber: 512, Open arrow down-left (SW) - std::pair( "arrowOpenDownRight", 0xEB73 ), // glyphnumber: 513, Open arrow down-right (SE) - std::pair( "arrowOpenLeft", 0xEB76 ), // glyphnumber: 514, Open arrow left (W) - std::pair( "arrowOpenRight", 0xEB72 ), // glyphnumber: 515, Open arrow right (E) - std::pair( "arrowOpenUp", 0xEB70 ), // glyphnumber: 516, Open arrow up (N) - std::pair( "arrowOpenUpLeft", 0xEB77 ), // glyphnumber: 517, Open arrow up-left (NW) - std::pair( "arrowOpenUpRight", 0xEB71 ), // glyphnumber: 518, Open arrow up-right (NE) - std::pair( "arrowWhiteDown", 0xEB6C ), // glyphnumber: 519, White arrow down (S) - std::pair( "arrowWhiteDownLeft", 0xEB6D ), // glyphnumber: 520, White arrow down-left (SW) - std::pair( "arrowWhiteDownRight", 0xEB6B ), // glyphnumber: 521, White arrow down-right (SE) - std::pair( "arrowWhiteLeft", 0xEB6E ), // glyphnumber: 522, White arrow left (W) - std::pair( "arrowWhiteRight", 0xEB6A ), // glyphnumber: 523, White arrow right (E) - std::pair( "arrowWhiteUp", 0xEB68 ), // glyphnumber: 524, White arrow up (N) - std::pair( "arrowWhiteUpLeft", 0xEB6F ), // glyphnumber: 525, White arrow up-left (NW) - std::pair( "arrowWhiteUpRight", 0xEB69 ), // glyphnumber: 526, White arrow up-right (NE) - std::pair( "arrowheadBlackDown", 0xEB7C ), // glyphnumber: 527, Black arrowhead down (S) - std::pair( "arrowheadBlackDownLeft", 0xEB7D ), // glyphnumber: 528, Black arrowhead down-left (SW) - std::pair( "arrowheadBlackDownRight", 0xEB7B ), // glyphnumber: 529, Black arrowhead down-right (SE) - std::pair( "arrowheadBlackLeft", 0xEB7E ), // glyphnumber: 530, Black arrowhead left (W) - std::pair( "arrowheadBlackRight", 0xEB7A ), // glyphnumber: 531, Black arrowhead right (E) - std::pair( "arrowheadBlackUp", 0xEB78 ), // glyphnumber: 532, Black arrowhead up (N) - std::pair( "arrowheadBlackUpLeft", 0xEB7F ), // glyphnumber: 533, Black arrowhead up-left (NW) - std::pair( "arrowheadBlackUpRight", 0xEB79 ), // glyphnumber: 534, Black arrowhead up-right (NE) - std::pair( "arrowheadOpenDown", 0xEB8C ), // glyphnumber: 535, Open arrowhead down (S) - std::pair( "arrowheadOpenDownLeft", 0xEB8D ), // glyphnumber: 536, Open arrowhead down-left (SW) - std::pair( "arrowheadOpenDownRight", 0xEB8B ), // glyphnumber: 537, Open arrowhead down-right (SE) - std::pair( "arrowheadOpenLeft", 0xEB8E ), // glyphnumber: 538, Open arrowhead left (W) - std::pair( "arrowheadOpenRight", 0xEB8A ), // glyphnumber: 539, Open arrowhead right (E) - std::pair( "arrowheadOpenUp", 0xEB88 ), // glyphnumber: 540, Open arrowhead up (N) - std::pair( "arrowheadOpenUpLeft", 0xEB8F ), // glyphnumber: 541, Open arrowhead up-left (NW) - std::pair( "arrowheadOpenUpRight", 0xEB89 ), // glyphnumber: 542, Open arrowhead up-right (NE) - std::pair( "arrowheadWhiteDown", 0xEB84 ), // glyphnumber: 543, White arrowhead down (S) - std::pair( "arrowheadWhiteDownLeft", 0xEB85 ), // glyphnumber: 544, White arrowhead down-left (SW) - std::pair( "arrowheadWhiteDownRight", 0xEB83 ), // glyphnumber: 545, White arrowhead down-right (SE) - std::pair( "arrowheadWhiteLeft", 0xEB86 ), // glyphnumber: 546, White arrowhead left (W) - std::pair( "arrowheadWhiteRight", 0xEB82 ), // glyphnumber: 547, White arrowhead right (E) - std::pair( "arrowheadWhiteUp", 0xEB80 ), // glyphnumber: 548, White arrowhead up (N) - std::pair( "arrowheadWhiteUpLeft", 0xEB87 ), // glyphnumber: 549, White arrowhead up-left (NW) - std::pair( "arrowheadWhiteUpRight", 0xEB81 ), // glyphnumber: 550, White arrowhead up-right (NE) - std::pair( "articAccentAbove", 0xE4A0 ), // glyphnumber: 551, Accent above - std::pair( "articAccentBelow", 0xE4A1 ), // glyphnumber: 552, Accent below - std::pair( "articAccentStaccatoAbove", 0xE4B0 ), // glyphnumber: 553, Accent-staccato above - std::pair( "articAccentStaccatoBelow", 0xE4B1 ), // glyphnumber: 554, Accent-staccato below - std::pair( "articLaissezVibrerAbove", 0xE4BA ), // glyphnumber: 555, Laissez vibrer (l.v.) above - std::pair( "articLaissezVibrerBelow", 0xE4BB ), // glyphnumber: 556, Laissez vibrer (l.v.) below - std::pair( "articMarcatoAbove", 0xE4AC ), // glyphnumber: 557, Marcato above - std::pair( "articMarcatoBelow", 0xE4AD ), // glyphnumber: 558, Marcato below - std::pair( "articMarcatoStaccatoAbove", 0xE4AE ), // glyphnumber: 559, Marcato-staccato above - std::pair( "articMarcatoStaccatoBelow", 0xE4AF ), // glyphnumber: 560, Marcato-staccato below - std::pair( "articMarcatoTenutoAbove", 0xE4BC ), // glyphnumber: 561, Marcato-tenuto above - std::pair( "articMarcatoTenutoBelow", 0xE4BD ), // glyphnumber: 562, Marcato-tenuto below - std::pair( "articSoftAccentAbove", 0xED40 ), // glyphnumber: 563, Soft accent above - std::pair( "articSoftAccentBelow", 0xED41 ), // glyphnumber: 564, Soft accent below - std::pair( "articSoftAccentStaccatoAbove", 0xED42 ), // glyphnumber: 565, Soft accent-staccato above - std::pair( "articSoftAccentStaccatoBelow", 0xED43 ), // glyphnumber: 566, Soft accent-staccato below - std::pair( "articSoftAccentTenutoAbove", 0xED44 ), // glyphnumber: 567, Soft accent-tenuto above - std::pair( "articSoftAccentTenutoBelow", 0xED45 ), // glyphnumber: 568, Soft accent-tenuto below - std::pair( "articSoftAccentTenutoStaccatoAbove", 0xED46 ), // glyphnumber: 569, Soft accent-tenuto-staccato above - std::pair( "articSoftAccentTenutoStaccatoBelow", 0xED47 ), // glyphnumber: 570, Soft accent-tenuto-staccato below - std::pair( "articStaccatissimoAbove", 0xE4A6 ), // glyphnumber: 571, Staccatissimo above - std::pair( "articStaccatissimoBelow", 0xE4A7 ), // glyphnumber: 572, Staccatissimo below - std::pair( "articStaccatissimoStrokeAbove", 0xE4AA ), // glyphnumber: 573, Staccatissimo stroke above - std::pair( "articStaccatissimoStrokeBelow", 0xE4AB ), // glyphnumber: 574, Staccatissimo stroke below - std::pair( "articStaccatissimoWedgeAbove", 0xE4A8 ), // glyphnumber: 575, Staccatissimo wedge above - std::pair( "articStaccatissimoWedgeBelow", 0xE4A9 ), // glyphnumber: 576, Staccatissimo wedge below - std::pair( "articStaccatoAbove", 0xE4A2 ), // glyphnumber: 577, Staccato above - std::pair( "articStaccatoBelow", 0xE4A3 ), // glyphnumber: 578, Staccato below - std::pair( "articStressAbove", 0xE4B6 ), // glyphnumber: 579, Stress above - std::pair( "articStressBelow", 0xE4B7 ), // glyphnumber: 580, Stress below - std::pair( "articTenutoAbove", 0xE4A4 ), // glyphnumber: 581, Tenuto above - std::pair( "articTenutoAccentAbove", 0xE4B4 ), // glyphnumber: 582, Tenuto-accent above - std::pair( "articTenutoAccentBelow", 0xE4B5 ), // glyphnumber: 583, Tenuto-accent below - std::pair( "articTenutoBelow", 0xE4A5 ), // glyphnumber: 584, Tenuto below - std::pair( "articTenutoStaccatoAbove", 0xE4B2 ), // glyphnumber: 585, Louré (tenuto-staccato) above - std::pair( "articTenutoStaccatoBelow", 0xE4B3 ), // glyphnumber: 586, Louré (tenuto-staccato) below - std::pair( "articUnstressAbove", 0xE4B8 ), // glyphnumber: 587, Unstress above - std::pair( "articUnstressBelow", 0xE4B9 ), // glyphnumber: 588, Unstress below - std::pair( "augmentationDot", 0xE1E7 ), // glyphnumber: 589, Augmentation dot - std::pair( "barlineDashed", 0xE036 ), // glyphnumber: 590, Dashed barline - std::pair( "barlineDotted", 0xE037 ), // glyphnumber: 591, Dotted barline - std::pair( "barlineDouble", 0xE031 ), // glyphnumber: 592, Double barline - std::pair( "barlineFinal", 0xE032 ), // glyphnumber: 593, Final barline - std::pair( "barlineHeavy", 0xE034 ), // glyphnumber: 594, Heavy barline - std::pair( "barlineHeavyHeavy", 0xE035 ), // glyphnumber: 595, Heavy double barline - std::pair( "barlineReverseFinal", 0xE033 ), // glyphnumber: 596, Reverse final barline - std::pair( "barlineShort", 0xE038 ), // glyphnumber: 597, Short barline - std::pair( "barlineSingle", 0xE030 ), // glyphnumber: 598, Single barline - std::pair( "barlineTick", 0xE039 ), // glyphnumber: 599, Tick barline - std::pair( "beamAccelRit1", 0xEAF4 ), // glyphnumber: 600, Accel./rit. beam 1 (widest) - std::pair( "beamAccelRit10", 0xEAFD ), // glyphnumber: 601, Accel./rit. beam 10 - std::pair( "beamAccelRit11", 0xEAFE ), // glyphnumber: 602, Accel./rit. beam 11 - std::pair( "beamAccelRit12", 0xEAFF ), // glyphnumber: 603, Accel./rit. beam 12 - std::pair( "beamAccelRit13", 0xEB00 ), // glyphnumber: 604, Accel./rit. beam 13 - std::pair( "beamAccelRit14", 0xEB01 ), // glyphnumber: 605, Accel./rit. beam 14 - std::pair( "beamAccelRit15", 0xEB02 ), // glyphnumber: 606, Accel./rit. beam 15 (narrowest) - std::pair( "beamAccelRit2", 0xEAF5 ), // glyphnumber: 607, Accel./rit. beam 2 - std::pair( "beamAccelRit3", 0xEAF6 ), // glyphnumber: 608, Accel./rit. beam 3 - std::pair( "beamAccelRit4", 0xEAF7 ), // glyphnumber: 609, Accel./rit. beam 4 - std::pair( "beamAccelRit5", 0xEAF8 ), // glyphnumber: 610, Accel./rit. beam 5 - std::pair( "beamAccelRit6", 0xEAF9 ), // glyphnumber: 611, Accel./rit. beam 6 - std::pair( "beamAccelRit7", 0xEAFA ), // glyphnumber: 612, Accel./rit. beam 7 - std::pair( "beamAccelRit8", 0xEAFB ), // glyphnumber: 613, Accel./rit. beam 8 - std::pair( "beamAccelRit9", 0xEAFC ), // glyphnumber: 614, Accel./rit. beam 9 - std::pair( "beamAccelRitFinal", 0xEB03 ), // glyphnumber: 615, Accel./rit. beam terminating line - std::pair( "brace", 0xE000 ), // glyphnumber: 616, Brace - std::pair( "bracket", 0xE002 ), // glyphnumber: 617, Bracket - std::pair( "bracketBottom", 0xE004 ), // glyphnumber: 618, Bracket bottom - std::pair( "bracketTop", 0xE003 ), // glyphnumber: 619, Bracket top - std::pair( "brassBend", 0xE5E3 ), // glyphnumber: 620, Bend - std::pair( "brassDoitLong", 0xE5D6 ), // glyphnumber: 621, Doit, long - std::pair( "brassDoitMedium", 0xE5D5 ), // glyphnumber: 622, Doit, medium - std::pair( "brassDoitShort", 0xE5D4 ), // glyphnumber: 623, Doit, short - std::pair( "brassFallLipLong", 0xE5D9 ), // glyphnumber: 624, Lip fall, long - std::pair( "brassFallLipMedium", 0xE5D8 ), // glyphnumber: 625, Lip fall, medium - std::pair( "brassFallLipShort", 0xE5D7 ), // glyphnumber: 626, Lip fall, short - std::pair( "brassFallRoughLong", 0xE5DF ), // glyphnumber: 627, Rough fall, long - std::pair( "brassFallRoughMedium", 0xE5DE ), // glyphnumber: 628, Rough fall, medium - std::pair( "brassFallRoughShort", 0xE5DD ), // glyphnumber: 629, Rough fall, short - std::pair( "brassFallSmoothLong", 0xE5DC ), // glyphnumber: 630, Smooth fall, long - std::pair( "brassFallSmoothMedium", 0xE5DB ), // glyphnumber: 631, Smooth fall, medium - std::pair( "brassFallSmoothShort", 0xE5DA ), // glyphnumber: 632, Smooth fall, short - std::pair( "brassFlip", 0xE5E1 ), // glyphnumber: 633, Flip - std::pair( "brassHarmonMuteClosed", 0xE5E8 ), // glyphnumber: 634, Harmon mute, stem in - std::pair( "brassHarmonMuteStemHalfLeft", 0xE5E9 ), // glyphnumber: 635, Harmon mute, stem extended, left - std::pair( "brassHarmonMuteStemHalfRight", 0xE5EA ), // glyphnumber: 636, Harmon mute, stem extended, right - std::pair( "brassHarmonMuteStemOpen", 0xE5EB ), // glyphnumber: 637, Harmon mute, stem out - std::pair( "brassJazzTurn", 0xE5E4 ), // glyphnumber: 638, Jazz turn - std::pair( "brassLiftLong", 0xE5D3 ), // glyphnumber: 639, Lift, long - std::pair( "brassLiftMedium", 0xE5D2 ), // glyphnumber: 640, Lift, medium - std::pair( "brassLiftShort", 0xE5D1 ), // glyphnumber: 641, Lift, short - std::pair( "brassLiftSmoothLong", 0xE5EE ), // glyphnumber: 642, Smooth lift, long - std::pair( "brassLiftSmoothMedium", 0xE5ED ), // glyphnumber: 643, Smooth lift, medium - std::pair( "brassLiftSmoothShort", 0xE5EC ), // glyphnumber: 644, Smooth lift, short - std::pair( "brassMuteClosed", 0xE5E5 ), // glyphnumber: 645, Muted (closed) - std::pair( "brassMuteHalfClosed", 0xE5E6 ), // glyphnumber: 646, Half-muted (half-closed) - std::pair( "brassMuteOpen", 0xE5E7 ), // glyphnumber: 647, Open - std::pair( "brassPlop", 0xE5E0 ), // glyphnumber: 648, Plop - std::pair( "brassScoop", 0xE5D0 ), // glyphnumber: 649, Scoop - std::pair( "brassSmear", 0xE5E2 ), // glyphnumber: 650, Smear - std::pair( "brassValveTrill", 0xE5EF ), // glyphnumber: 651, Valve trill - std::pair( "breathMarkComma", 0xE4CE ), // glyphnumber: 652, Breath mark (comma) - std::pair( "breathMarkSalzedo", 0xE4D5 ), // glyphnumber: 653, Breath mark (Salzedo) - std::pair( "breathMarkTick", 0xE4CF ), // glyphnumber: 654, Breath mark (tick-like) - std::pair( "breathMarkUpbow", 0xE4D0 ), // glyphnumber: 655, Breath mark (upbow-like) - std::pair( "bridgeClef", 0xE078 ), // glyphnumber: 656, Bridge clef - std::pair( "buzzRoll", 0xE22A ), // glyphnumber: 657, Buzz roll - std::pair( "cClef", 0xE05C ), // glyphnumber: 658, C clef - std::pair( "cClef8vb", 0xE05D ), // glyphnumber: 659, C clef ottava bassa - std::pair( "cClefArrowDown", 0xE05F ), // glyphnumber: 660, C clef, arrow down - std::pair( "cClefArrowUp", 0xE05E ), // glyphnumber: 661, C clef, arrow up - std::pair( "cClefChange", 0xE07B ), // glyphnumber: 662, C clef change - std::pair( "cClefCombining", 0xE061 ), // glyphnumber: 663, Combining C clef - std::pair( "cClefReversed", 0xE075 ), // glyphnumber: 664, Reversed C clef - std::pair( "cClefSquare", 0xE060 ), // glyphnumber: 665, C clef (19th century) - std::pair( "caesura", 0xE4D1 ), // glyphnumber: 666, Caesura - std::pair( "caesuraCurved", 0xE4D4 ), // glyphnumber: 667, Curved caesura - std::pair( "caesuraShort", 0xE4D3 ), // glyphnumber: 668, Short caesura - std::pair( "caesuraThick", 0xE4D2 ), // glyphnumber: 669, Thick caesura - std::pair( "chantAccentusAbove", 0xE9D6 ), // glyphnumber: 670, Accentus above - std::pair( "chantAccentusBelow", 0xE9D7 ), // glyphnumber: 671, Accentus below - std::pair( "chantAuctumAsc", 0xE994 ), // glyphnumber: 672, Punctum auctum, ascending - std::pair( "chantAuctumDesc", 0xE995 ), // glyphnumber: 673, Punctum auctum, descending - std::pair( "chantAugmentum", 0xE9D9 ), // glyphnumber: 674, Augmentum (mora) - std::pair( "chantCaesura", 0xE8F8 ), // glyphnumber: 675, Caesura - std::pair( "chantCclef", 0xE906 ), // glyphnumber: 676, Plainchant C clef - std::pair( "chantCirculusAbove", 0xE9D2 ), // glyphnumber: 677, Circulus above - std::pair( "chantCirculusBelow", 0xE9D3 ), // glyphnumber: 678, Circulus below - std::pair( "chantConnectingLineAsc2nd", 0xE9BD ), // glyphnumber: 679, Connecting line, ascending 2nd - std::pair( "chantConnectingLineAsc3rd", 0xE9BE ), // glyphnumber: 680, Connecting line, ascending 3rd - std::pair( "chantConnectingLineAsc4th", 0xE9BF ), // glyphnumber: 681, Connecting line, ascending 4th - std::pair( "chantConnectingLineAsc5th", 0xE9C0 ), // glyphnumber: 682, Connecting line, ascending 5th - std::pair( "chantConnectingLineAsc6th", 0xE9C1 ), // glyphnumber: 683, Connecting line, ascending 6th - std::pair( "chantCustosStemDownPosHigh", 0xEA08 ), // glyphnumber: 684, Plainchant custos, stem down, high position - std::pair( "chantCustosStemDownPosHighest", 0xEA09 ), // glyphnumber: 685, Plainchant custos, stem down, highest position - std::pair( "chantCustosStemDownPosMiddle", 0xEA07 ), // glyphnumber: 686, Plainchant custos, stem down, middle position - std::pair( "chantCustosStemUpPosLow", 0xEA05 ), // glyphnumber: 687, Plainchant custos, stem up, low position - std::pair( "chantCustosStemUpPosLowest", 0xEA04 ), // glyphnumber: 688, Plainchant custos, stem up, lowest position - std::pair( "chantCustosStemUpPosMiddle", 0xEA06 ), // glyphnumber: 689, Plainchant custos, stem up, middle position - std::pair( "chantDeminutumLower", 0xE9B3 ), // glyphnumber: 690, Punctum deminutum, lower - std::pair( "chantDeminutumUpper", 0xE9B2 ), // glyphnumber: 691, Punctum deminutum, upper - std::pair( "chantDivisioFinalis", 0xE8F6 ), // glyphnumber: 692, Divisio finalis - std::pair( "chantDivisioMaior", 0xE8F4 ), // glyphnumber: 693, Divisio maior - std::pair( "chantDivisioMaxima", 0xE8F5 ), // glyphnumber: 694, Divisio maxima - std::pair( "chantDivisioMinima", 0xE8F3 ), // glyphnumber: 695, Divisio minima - std::pair( "chantEntryLineAsc2nd", 0xE9B4 ), // glyphnumber: 696, Entry line, ascending 2nd - std::pair( "chantEntryLineAsc3rd", 0xE9B5 ), // glyphnumber: 697, Entry line, ascending 3rd - std::pair( "chantEntryLineAsc4th", 0xE9B6 ), // glyphnumber: 698, Entry line, ascending 4th - std::pair( "chantEntryLineAsc5th", 0xE9B7 ), // glyphnumber: 699, Entry line, ascending 5th - std::pair( "chantEntryLineAsc6th", 0xE9B8 ), // glyphnumber: 700, Entry line, ascending 6th - std::pair( "chantEpisema", 0xE9D8 ), // glyphnumber: 701, Episema - std::pair( "chantFclef", 0xE902 ), // glyphnumber: 702, Plainchant F clef - std::pair( "chantIctusAbove", 0xE9D0 ), // glyphnumber: 703, Ictus above - std::pair( "chantIctusBelow", 0xE9D1 ), // glyphnumber: 704, Ictus below - std::pair( "chantLigaturaDesc2nd", 0xE9B9 ), // glyphnumber: 705, Ligated stroke, descending 2nd - std::pair( "chantLigaturaDesc3rd", 0xE9BA ), // glyphnumber: 706, Ligated stroke, descending 3rd - std::pair( "chantLigaturaDesc4th", 0xE9BB ), // glyphnumber: 707, Ligated stroke, descending 4th - std::pair( "chantLigaturaDesc5th", 0xE9BC ), // glyphnumber: 708, Ligated stroke, descending 5th - std::pair( "chantOriscusAscending", 0xE99C ), // glyphnumber: 709, Oriscus ascending - std::pair( "chantOriscusDescending", 0xE99D ), // glyphnumber: 710, Oriscus descending - std::pair( "chantOriscusLiquescens", 0xE99E ), // glyphnumber: 711, Oriscus liquescens - std::pair( "chantPodatusLower", 0xE9B0 ), // glyphnumber: 712, Podatus, lower - std::pair( "chantPodatusUpper", 0xE9B1 ), // glyphnumber: 713, Podatus, upper - std::pair( "chantPunctum", 0xE990 ), // glyphnumber: 714, Punctum - std::pair( "chantPunctumCavum", 0xE998 ), // glyphnumber: 715, Punctum cavum - std::pair( "chantPunctumDeminutum", 0xE9A1 ), // glyphnumber: 716, Punctum deminutum - std::pair( "chantPunctumInclinatum", 0xE991 ), // glyphnumber: 717, Punctum inclinatum - std::pair( "chantPunctumInclinatumAuctum", 0xE992 ), // glyphnumber: 718, Punctum inclinatum auctum - std::pair( "chantPunctumInclinatumDeminutum", 0xE993 ), // glyphnumber: 719, Punctum inclinatum deminutum - std::pair( "chantPunctumLinea", 0xE999 ), // glyphnumber: 720, Punctum linea - std::pair( "chantPunctumLineaCavum", 0xE99A ), // glyphnumber: 721, Punctum linea cavum - std::pair( "chantPunctumVirga", 0xE996 ), // glyphnumber: 722, Punctum virga - std::pair( "chantPunctumVirgaReversed", 0xE997 ), // glyphnumber: 723, Punctum virga, reversed - std::pair( "chantQuilisma", 0xE99B ), // glyphnumber: 724, Quilisma - std::pair( "chantSemicirculusAbove", 0xE9D4 ), // glyphnumber: 725, Semicirculus above - std::pair( "chantSemicirculusBelow", 0xE9D5 ), // glyphnumber: 726, Semicirculus below - std::pair( "chantStaff", 0xE8F0 ), // glyphnumber: 727, Plainchant staff - std::pair( "chantStaffNarrow", 0xE8F2 ), // glyphnumber: 728, Plainchant staff (narrow) - std::pair( "chantStaffWide", 0xE8F1 ), // glyphnumber: 729, Plainchant staff (wide) - std::pair( "chantStrophicus", 0xE99F ), // glyphnumber: 730, Strophicus - std::pair( "chantStrophicusAuctus", 0xE9A0 ), // glyphnumber: 731, Strophicus auctus - std::pair( "chantStrophicusLiquescens2nd", 0xE9C2 ), // glyphnumber: 732, Strophicus liquescens, 2nd - std::pair( "chantStrophicusLiquescens3rd", 0xE9C3 ), // glyphnumber: 733, Strophicus liquescens, 3rd - std::pair( "chantStrophicusLiquescens4th", 0xE9C4 ), // glyphnumber: 734, Strophicus liquescens, 4th - std::pair( "chantStrophicusLiquescens5th", 0xE9C5 ), // glyphnumber: 735, Strophicus liquescens, 5th - std::pair( "chantVirgula", 0xE8F7 ), // glyphnumber: 736, Virgula - std::pair( "clef15", 0xE07E ), // glyphnumber: 737, 15 for clefs - std::pair( "clef8", 0xE07D ), // glyphnumber: 738, 8 for clefs - std::pair( "clefChangeCombining", 0xE07F ), // glyphnumber: 739, Combining clef change - std::pair( "coda", 0xE048 ), // glyphnumber: 740, Coda - std::pair( "codaSquare", 0xE049 ), // glyphnumber: 741, Square coda - std::pair( "conductorBeat2Compound", 0xE897 ), // glyphnumber: 742, Beat 2, compound time - std::pair( "conductorBeat2Simple", 0xE894 ), // glyphnumber: 743, Beat 2, simple time - std::pair( "conductorBeat3Compound", 0xE898 ), // glyphnumber: 744, Beat 3, compound time - std::pair( "conductorBeat3Simple", 0xE895 ), // glyphnumber: 745, Beat 3, simple time - std::pair( "conductorBeat4Compound", 0xE899 ), // glyphnumber: 746, Beat 4, compound time - std::pair( "conductorBeat4Simple", 0xE896 ), // glyphnumber: 747, Beat 4, simple time - std::pair( "conductorLeftBeat", 0xE891 ), // glyphnumber: 748, Left-hand beat or cue - std::pair( "conductorRightBeat", 0xE892 ), // glyphnumber: 749, Right-hand beat or cue - std::pair( "conductorStrongBeat", 0xE890 ), // glyphnumber: 750, Strong beat or cue - std::pair( "conductorUnconducted", 0xE89A ), // glyphnumber: 751, Unconducted/free passages - std::pair( "conductorWeakBeat", 0xE893 ), // glyphnumber: 752, Weak beat or cue - std::pair( "controlBeginBeam", 0xE8E0 ), // glyphnumber: 753, Begin beam - std::pair( "controlBeginPhrase", 0xE8E6 ), // glyphnumber: 754, Begin phrase - std::pair( "controlBeginSlur", 0xE8E4 ), // glyphnumber: 755, Begin slur - std::pair( "controlBeginTie", 0xE8E2 ), // glyphnumber: 756, Begin tie - std::pair( "controlEndBeam", 0xE8E1 ), // glyphnumber: 757, End beam - std::pair( "controlEndPhrase", 0xE8E7 ), // glyphnumber: 758, End phrase - std::pair( "controlEndSlur", 0xE8E5 ), // glyphnumber: 759, End slur - std::pair( "controlEndTie", 0xE8E3 ), // glyphnumber: 760, End tie - std::pair( "csymAugmented", 0xE872 ), // glyphnumber: 761, Augmented - std::pair( "csymBracketLeftTall", 0xE877 ), // glyphnumber: 762, Double-height left bracket - std::pair( "csymBracketRightTall", 0xE878 ), // glyphnumber: 763, Double-height right bracket - std::pair( "csymDiminished", 0xE870 ), // glyphnumber: 764, Diminished - std::pair( "csymHalfDiminished", 0xE871 ), // glyphnumber: 765, Half-diminished - std::pair( "csymMajorSeventh", 0xE873 ), // glyphnumber: 766, Major seventh - std::pair( "csymMinor", 0xE874 ), // glyphnumber: 767, Minor - std::pair( "csymParensLeftTall", 0xE875 ), // glyphnumber: 768, Double-height left parenthesis - std::pair( "csymParensRightTall", 0xE876 ), // glyphnumber: 769, Double-height right parenthesis - std::pair( "curlewSign", 0xE4D6 ), // glyphnumber: 770, Curlew (Britten) - std::pair( "daCapo", 0xE046 ), // glyphnumber: 771, Da capo - std::pair( "dalSegno", 0xE045 ), // glyphnumber: 772, Dal segno - std::pair( "daseianExcellentes1", 0xEA3C ), // glyphnumber: 773, Daseian excellentes 1 - std::pair( "daseianExcellentes2", 0xEA3D ), // glyphnumber: 774, Daseian excellentes 2 - std::pair( "daseianExcellentes3", 0xEA3E ), // glyphnumber: 775, Daseian excellentes 3 - std::pair( "daseianExcellentes4", 0xEA3F ), // glyphnumber: 776, Daseian excellentes 4 - std::pair( "daseianFinales1", 0xEA34 ), // glyphnumber: 777, Daseian finales 1 - std::pair( "daseianFinales2", 0xEA35 ), // glyphnumber: 778, Daseian finales 2 - std::pair( "daseianFinales3", 0xEA36 ), // glyphnumber: 779, Daseian finales 3 - std::pair( "daseianFinales4", 0xEA37 ), // glyphnumber: 780, Daseian finales 4 - std::pair( "daseianGraves1", 0xEA30 ), // glyphnumber: 781, Daseian graves 1 - std::pair( "daseianGraves2", 0xEA31 ), // glyphnumber: 782, Daseian graves 2 - std::pair( "daseianGraves3", 0xEA32 ), // glyphnumber: 783, Daseian graves 3 - std::pair( "daseianGraves4", 0xEA33 ), // glyphnumber: 784, Daseian graves 4 - std::pair( "daseianResidua1", 0xEA40 ), // glyphnumber: 785, Daseian residua 1 - std::pair( "daseianResidua2", 0xEA41 ), // glyphnumber: 786, Daseian residua 2 - std::pair( "daseianSuperiores1", 0xEA38 ), // glyphnumber: 787, Daseian superiores 1 - std::pair( "daseianSuperiores2", 0xEA39 ), // glyphnumber: 788, Daseian superiores 2 - std::pair( "daseianSuperiores3", 0xEA3A ), // glyphnumber: 789, Daseian superiores 3 - std::pair( "daseianSuperiores4", 0xEA3B ), // glyphnumber: 790, Daseian superiores 4 - std::pair( "doubleTongueAbove", 0xE5F0 ), // glyphnumber: 791, Double-tongue above - std::pair( "doubleTongueBelow", 0xE5F1 ), // glyphnumber: 792, Double-tongue below - std::pair( "dynamicCombinedSeparatorColon", 0xE546 ), // glyphnumber: 793, Colon separator for combined dynamics - std::pair( "dynamicCombinedSeparatorHyphen", 0xE547 ), // glyphnumber: 794, Hyphen separator for combined dynamics - std::pair( "dynamicCombinedSeparatorSpace", 0xE548 ), // glyphnumber: 795, Space separator for combined dynamics - std::pair( "dynamicCrescendoHairpin", 0xE53E ), // glyphnumber: 796, Crescendo - std::pair( "dynamicDiminuendoHairpin", 0xE53F ), // glyphnumber: 797, Diminuendo - std::pair( "dynamicFF", 0xE52F ), // glyphnumber: 798, ff - std::pair( "dynamicFFF", 0xE530 ), // glyphnumber: 799, fff - std::pair( "dynamicFFFF", 0xE531 ), // glyphnumber: 800, ffff - std::pair( "dynamicFFFFF", 0xE532 ), // glyphnumber: 801, fffff - std::pair( "dynamicFFFFFF", 0xE533 ), // glyphnumber: 802, ffffff - std::pair( "dynamicForte", 0xE522 ), // glyphnumber: 803, Forte - std::pair( "dynamicFortePiano", 0xE534 ), // glyphnumber: 804, Forte-piano - std::pair( "dynamicForzando", 0xE535 ), // glyphnumber: 805, Forzando - std::pair( "dynamicHairpinBracketLeft", 0xE544 ), // glyphnumber: 806, Left bracket (for hairpins) - std::pair( "dynamicHairpinBracketRight", 0xE545 ), // glyphnumber: 807, Right bracket (for hairpins) - std::pair( "dynamicHairpinParenthesisLeft", 0xE542 ), // glyphnumber: 808, Left parenthesis (for hairpins) - std::pair( "dynamicHairpinParenthesisRight", 0xE543 ), // glyphnumber: 809, Right parenthesis (for hairpins) - std::pair( "dynamicMF", 0xE52D ), // glyphnumber: 810, mf - std::pair( "dynamicMP", 0xE52C ), // glyphnumber: 811, mp - std::pair( "dynamicMessaDiVoce", 0xE540 ), // glyphnumber: 812, Messa di voce - std::pair( "dynamicMezzo", 0xE521 ), // glyphnumber: 813, Mezzo - std::pair( "dynamicNiente", 0xE526 ), // glyphnumber: 814, Niente - std::pair( "dynamicNienteForHairpin", 0xE541 ), // glyphnumber: 815, Niente (for hairpins) - std::pair( "dynamicPF", 0xE52E ), // glyphnumber: 816, pf - std::pair( "dynamicPP", 0xE52B ), // glyphnumber: 817, pp - std::pair( "dynamicPPP", 0xE52A ), // glyphnumber: 818, ppp - std::pair( "dynamicPPPP", 0xE529 ), // glyphnumber: 819, pppp - std::pair( "dynamicPPPPP", 0xE528 ), // glyphnumber: 820, ppppp - std::pair( "dynamicPPPPPP", 0xE527 ), // glyphnumber: 821, pppppp - std::pair( "dynamicPiano", 0xE520 ), // glyphnumber: 822, Piano - std::pair( "dynamicRinforzando", 0xE523 ), // glyphnumber: 823, Rinforzando - std::pair( "dynamicRinforzando1", 0xE53C ), // glyphnumber: 824, Rinforzando 1 - std::pair( "dynamicRinforzando2", 0xE53D ), // glyphnumber: 825, Rinforzando 2 - std::pair( "dynamicSforzando", 0xE524 ), // glyphnumber: 826, Sforzando - std::pair( "dynamicSforzando1", 0xE536 ), // glyphnumber: 827, Sforzando 1 - std::pair( "dynamicSforzandoPianissimo", 0xE538 ), // glyphnumber: 828, Sforzando-pianissimo - std::pair( "dynamicSforzandoPiano", 0xE537 ), // glyphnumber: 829, Sforzando-piano - std::pair( "dynamicSforzato", 0xE539 ), // glyphnumber: 830, Sforzato - std::pair( "dynamicSforzatoFF", 0xE53B ), // glyphnumber: 831, Sforzatissimo - std::pair( "dynamicSforzatoPiano", 0xE53A ), // glyphnumber: 832, Sforzato-piano - std::pair( "dynamicZ", 0xE525 ), // glyphnumber: 833, Z - std::pair( "elecAudioChannelsEight", 0xEB46 ), // glyphnumber: 834, Eight channels (7.1 surround) - std::pair( "elecAudioChannelsFive", 0xEB43 ), // glyphnumber: 835, Five channels - std::pair( "elecAudioChannelsFour", 0xEB42 ), // glyphnumber: 836, Four channels - std::pair( "elecAudioChannelsOne", 0xEB3E ), // glyphnumber: 837, One channel (mono) - std::pair( "elecAudioChannelsSeven", 0xEB45 ), // glyphnumber: 838, Seven channels - std::pair( "elecAudioChannelsSix", 0xEB44 ), // glyphnumber: 839, Six channels (5.1 surround) - std::pair( "elecAudioChannelsThreeFrontal", 0xEB40 ), // glyphnumber: 840, Three channels (frontal) - std::pair( "elecAudioChannelsThreeSurround", 0xEB41 ), // glyphnumber: 841, Three channels (surround) - std::pair( "elecAudioChannelsTwo", 0xEB3F ), // glyphnumber: 842, Two channels (stereo) - std::pair( "elecAudioIn", 0xEB49 ), // glyphnumber: 843, Audio in - std::pair( "elecAudioMono", 0xEB3C ), // glyphnumber: 844, Mono audio setup - std::pair( "elecAudioOut", 0xEB4A ), // glyphnumber: 845, Audio out - std::pair( "elecAudioStereo", 0xEB3D ), // glyphnumber: 846, Stereo audio setup - std::pair( "elecCamera", 0xEB1B ), // glyphnumber: 847, Camera - std::pair( "elecDataIn", 0xEB4D ), // glyphnumber: 848, Data in - std::pair( "elecDataOut", 0xEB4E ), // glyphnumber: 849, Data out - std::pair( "elecDisc", 0xEB13 ), // glyphnumber: 850, Disc - std::pair( "elecDownload", 0xEB4F ), // glyphnumber: 851, Download - std::pair( "elecEject", 0xEB2B ), // glyphnumber: 852, Eject - std::pair( "elecFastForward", 0xEB1F ), // glyphnumber: 853, Fast-forward - std::pair( "elecHeadphones", 0xEB11 ), // glyphnumber: 854, Headphones - std::pair( "elecHeadset", 0xEB12 ), // glyphnumber: 855, Headset - std::pair( "elecLineIn", 0xEB47 ), // glyphnumber: 856, Line in - std::pair( "elecLineOut", 0xEB48 ), // glyphnumber: 857, Line out - std::pair( "elecLoop", 0xEB23 ), // glyphnumber: 858, Loop - std::pair( "elecLoudspeaker", 0xEB1A ), // glyphnumber: 859, Loudspeaker - std::pair( "elecMIDIController0", 0xEB36 ), // glyphnumber: 860, MIDI controller 0% - std::pair( "elecMIDIController100", 0xEB3B ), // glyphnumber: 861, MIDI controller 100% - std::pair( "elecMIDIController20", 0xEB37 ), // glyphnumber: 862, MIDI controller 20% - std::pair( "elecMIDIController40", 0xEB38 ), // glyphnumber: 863, MIDI controller 40% - std::pair( "elecMIDIController60", 0xEB39 ), // glyphnumber: 864, MIDI controller 60% - std::pair( "elecMIDIController80", 0xEB3A ), // glyphnumber: 865, MIDI controller 80% - std::pair( "elecMIDIIn", 0xEB34 ), // glyphnumber: 866, MIDI in - std::pair( "elecMIDIOut", 0xEB35 ), // glyphnumber: 867, MIDI out - std::pair( "elecMicrophone", 0xEB10 ), // glyphnumber: 868, Microphone - std::pair( "elecMicrophoneMute", 0xEB28 ), // glyphnumber: 869, Mute microphone - std::pair( "elecMicrophoneUnmute", 0xEB29 ), // glyphnumber: 870, Unmute microphone - std::pair( "elecMixingConsole", 0xEB15 ), // glyphnumber: 871, Mixing console - std::pair( "elecMonitor", 0xEB18 ), // glyphnumber: 872, Monitor - std::pair( "elecMute", 0xEB26 ), // glyphnumber: 873, Mute - std::pair( "elecPause", 0xEB1E ), // glyphnumber: 874, Pause - std::pair( "elecPlay", 0xEB1C ), // glyphnumber: 875, Play - std::pair( "elecPowerOnOff", 0xEB2A ), // glyphnumber: 876, Power on/off - std::pair( "elecProjector", 0xEB19 ), // glyphnumber: 877, Projector - std::pair( "elecReplay", 0xEB24 ), // glyphnumber: 878, Replay - std::pair( "elecRewind", 0xEB20 ), // glyphnumber: 879, Rewind - std::pair( "elecShuffle", 0xEB25 ), // glyphnumber: 880, Shuffle - std::pair( "elecSkipBackwards", 0xEB22 ), // glyphnumber: 881, Skip backwards - std::pair( "elecSkipForwards", 0xEB21 ), // glyphnumber: 882, Skip forwards - std::pair( "elecStop", 0xEB1D ), // glyphnumber: 883, Stop - std::pair( "elecTape", 0xEB14 ), // glyphnumber: 884, Tape - std::pair( "elecUSB", 0xEB16 ), // glyphnumber: 885, USB connection - std::pair( "elecUnmute", 0xEB27 ), // glyphnumber: 886, Unmute - std::pair( "elecUpload", 0xEB50 ), // glyphnumber: 887, Upload - std::pair( "elecVideoCamera", 0xEB17 ), // glyphnumber: 888, Video camera - std::pair( "elecVideoIn", 0xEB4B ), // glyphnumber: 889, Video in - std::pair( "elecVideoOut", 0xEB4C ), // glyphnumber: 890, Video out - std::pair( "elecVolumeFader", 0xEB2C ), // glyphnumber: 891, Combining volume fader - std::pair( "elecVolumeFaderThumb", 0xEB2D ), // glyphnumber: 892, Combining volume fader thumb - std::pair( "elecVolumeLevel0", 0xEB2E ), // glyphnumber: 893, Volume level 0% - std::pair( "elecVolumeLevel100", 0xEB33 ), // glyphnumber: 894, Volume level 100% - std::pair( "elecVolumeLevel20", 0xEB2F ), // glyphnumber: 895, Volume level 20% - std::pair( "elecVolumeLevel40", 0xEB30 ), // glyphnumber: 896, Volume level 40% - std::pair( "elecVolumeLevel60", 0xEB31 ), // glyphnumber: 897, Volume level 60% - std::pair( "elecVolumeLevel80", 0xEB32 ), // glyphnumber: 898, Volume level 80% - std::pair( "fClef", 0xE062 ), // glyphnumber: 899, F clef - std::pair( "fClef15ma", 0xE066 ), // glyphnumber: 900, F clef quindicesima alta - std::pair( "fClef15mb", 0xE063 ), // glyphnumber: 901, F clef quindicesima bassa - std::pair( "fClef8va", 0xE065 ), // glyphnumber: 902, F clef ottava alta - std::pair( "fClef8vb", 0xE064 ), // glyphnumber: 903, F clef ottava bassa - std::pair( "fClefArrowDown", 0xE068 ), // glyphnumber: 904, F clef, arrow down - std::pair( "fClefArrowUp", 0xE067 ), // glyphnumber: 905, F clef, arrow up - std::pair( "fClefChange", 0xE07C ), // glyphnumber: 906, F clef change - std::pair( "fClefReversed", 0xE076 ), // glyphnumber: 907, Reversed F clef - std::pair( "fClefTurned", 0xE077 ), // glyphnumber: 908, Turned F clef - std::pair( "fermataAbove", 0xE4C0 ), // glyphnumber: 909, Fermata above - std::pair( "fermataBelow", 0xE4C1 ), // glyphnumber: 910, Fermata below - std::pair( "fermataLongAbove", 0xE4C6 ), // glyphnumber: 911, Long fermata above - std::pair( "fermataLongBelow", 0xE4C7 ), // glyphnumber: 912, Long fermata below - std::pair( "fermataLongHenzeAbove", 0xE4CA ), // glyphnumber: 913, Long fermata (Henze) above - std::pair( "fermataLongHenzeBelow", 0xE4CB ), // glyphnumber: 914, Long fermata (Henze) below - std::pair( "fermataShortAbove", 0xE4C4 ), // glyphnumber: 915, Short fermata above - std::pair( "fermataShortBelow", 0xE4C5 ), // glyphnumber: 916, Short fermata below - std::pair( "fermataShortHenzeAbove", 0xE4CC ), // glyphnumber: 917, Short fermata (Henze) above - std::pair( "fermataShortHenzeBelow", 0xE4CD ), // glyphnumber: 918, Short fermata (Henze) below - std::pair( "fermataVeryLongAbove", 0xE4C8 ), // glyphnumber: 919, Very long fermata above - std::pair( "fermataVeryLongBelow", 0xE4C9 ), // glyphnumber: 920, Very long fermata below - std::pair( "fermataVeryShortAbove", 0xE4C2 ), // glyphnumber: 921, Very short fermata above - std::pair( "fermataVeryShortBelow", 0xE4C3 ), // glyphnumber: 922, Very short fermata below - std::pair( "figbass0", 0xEA50 ), // glyphnumber: 923, Figured bass 0 - std::pair( "figbass1", 0xEA51 ), // glyphnumber: 924, Figured bass 1 - std::pair( "figbass2", 0xEA52 ), // glyphnumber: 925, Figured bass 2 - std::pair( "figbass2Raised", 0xEA53 ), // glyphnumber: 926, Figured bass 2 raised by half-step - std::pair( "figbass3", 0xEA54 ), // glyphnumber: 927, Figured bass 3 - std::pair( "figbass4", 0xEA55 ), // glyphnumber: 928, Figured bass 4 - std::pair( "figbass4Raised", 0xEA56 ), // glyphnumber: 929, Figured bass 4 raised by half-step - std::pair( "figbass5", 0xEA57 ), // glyphnumber: 930, Figured bass 5 - std::pair( "figbass5Raised1", 0xEA58 ), // glyphnumber: 931, Figured bass 5 raised by half-step - std::pair( "figbass5Raised2", 0xEA59 ), // glyphnumber: 932, Figured bass 5 raised by half-step 2 - std::pair( "figbass5Raised3", 0xEA5A ), // glyphnumber: 933, Figured bass diminished 5 - std::pair( "figbass6", 0xEA5B ), // glyphnumber: 934, Figured bass 6 - std::pair( "figbass6Raised", 0xEA5C ), // glyphnumber: 935, Figured bass 6 raised by half-step - std::pair( "figbass6Raised2", 0xEA6F ), // glyphnumber: 936, Figured bass 6 raised by half-step 2 - std::pair( "figbass7", 0xEA5D ), // glyphnumber: 937, Figured bass 7 - std::pair( "figbass7Diminished", 0xECC0 ), // glyphnumber: 938, Figured bass 7 diminished - std::pair( "figbass7Raised1", 0xEA5E ), // glyphnumber: 939, Figured bass 7 raised by half-step - std::pair( "figbass7Raised2", 0xEA5F ), // glyphnumber: 940, Figured bass 7 raised by a half-step 2 - std::pair( "figbass8", 0xEA60 ), // glyphnumber: 941, Figured bass 8 - std::pair( "figbass9", 0xEA61 ), // glyphnumber: 942, Figured bass 9 - std::pair( "figbass9Raised", 0xEA62 ), // glyphnumber: 943, Figured bass 9 raised by half-step - std::pair( "figbassBracketLeft", 0xEA68 ), // glyphnumber: 944, Figured bass [ - std::pair( "figbassBracketRight", 0xEA69 ), // glyphnumber: 945, Figured bass ] - std::pair( "figbassCombiningLowering", 0xEA6E ), // glyphnumber: 946, Combining lower - std::pair( "figbassCombiningRaising", 0xEA6D ), // glyphnumber: 947, Combining raise - std::pair( "figbassDoubleFlat", 0xEA63 ), // glyphnumber: 948, Figured bass double flat - std::pair( "figbassDoubleSharp", 0xEA67 ), // glyphnumber: 949, Figured bass double sharp - std::pair( "figbassFlat", 0xEA64 ), // glyphnumber: 950, Figured bass flat - std::pair( "figbassNatural", 0xEA65 ), // glyphnumber: 951, Figured bass natural - std::pair( "figbassParensLeft", 0xEA6A ), // glyphnumber: 952, Figured bass ( - std::pair( "figbassParensRight", 0xEA6B ), // glyphnumber: 953, Figured bass ) - std::pair( "figbassPlus", 0xEA6C ), // glyphnumber: 954, Figured bass + - std::pair( "figbassSharp", 0xEA66 ), // glyphnumber: 955, Figured bass sharp - std::pair( "fingering0", 0xED10 ), // glyphnumber: 956, Fingering 0 (open string) - std::pair( "fingering1", 0xED11 ), // glyphnumber: 957, Fingering 1 (thumb) - std::pair( "fingering2", 0xED12 ), // glyphnumber: 958, Fingering 2 (index finger) - std::pair( "fingering3", 0xED13 ), // glyphnumber: 959, Fingering 3 (middle finger) - std::pair( "fingering4", 0xED14 ), // glyphnumber: 960, Fingering 4 (ring finger) - std::pair( "fingering5", 0xED15 ), // glyphnumber: 961, Fingering 5 (little finger) - std::pair( "fingeringALower", 0xED1B ), // glyphnumber: 962, Fingering a (anular; right-hand ring finger for guitar) - std::pair( "fingeringCLower", 0xED1C ), // glyphnumber: 963, Fingering c (right-hand little finger for guitar) - std::pair( "fingeringELower", 0xED1E ), // glyphnumber: 964, Fingering e (right-hand little finger for guitar) - std::pair( "fingeringILower", 0xED19 ), // glyphnumber: 965, Fingering i (indicio; right-hand index finger for guitar) - std::pair( "fingeringMLower", 0xED1A ), // glyphnumber: 966, Fingering m (medio; right-hand middle finger for guitar) - std::pair( "fingeringMultipleNotes", 0xED23 ), // glyphnumber: 967, Multiple notes played by thumb or single finger - std::pair( "fingeringOLower", 0xED1F ), // glyphnumber: 968, Fingering o (right-hand little finger for guitar) - std::pair( "fingeringPLower", 0xED17 ), // glyphnumber: 969, Fingering p (pulgar; right-hand thumb for guitar) - std::pair( "fingeringSubstitutionAbove", 0xED20 ), // glyphnumber: 970, Finger substitution above - std::pair( "fingeringSubstitutionBelow", 0xED21 ), // glyphnumber: 971, Finger substitution below - std::pair( "fingeringSubstitutionDash", 0xED22 ), // glyphnumber: 972, Finger substitution dash - std::pair( "fingeringTLower", 0xED18 ), // glyphnumber: 973, Fingering t (right-hand thumb for guitar) - std::pair( "fingeringTUpper", 0xED16 ), // glyphnumber: 974, Fingering T (left-hand thumb for guitar) - std::pair( "fingeringXLower", 0xED1D ), // glyphnumber: 975, Fingering x (right-hand little finger for guitar) - std::pair( "flag1024thDown", 0xE24F ), // glyphnumber: 976, Combining flag 8 (1024th) below - std::pair( "flag1024thUp", 0xE24E ), // glyphnumber: 977, Combining flag 8 (1024th) above - std::pair( "flag128thDown", 0xE249 ), // glyphnumber: 978, Combining flag 5 (128th) below - std::pair( "flag128thUp", 0xE248 ), // glyphnumber: 979, Combining flag 5 (128th) above - std::pair( "flag16thDown", 0xE243 ), // glyphnumber: 980, Combining flag 2 (16th) below - std::pair( "flag16thUp", 0xE242 ), // glyphnumber: 981, Combining flag 2 (16th) above - std::pair( "flag256thDown", 0xE24B ), // glyphnumber: 982, Combining flag 6 (256th) below - std::pair( "flag256thUp", 0xE24A ), // glyphnumber: 983, Combining flag 6 (256th) above - std::pair( "flag32ndDown", 0xE245 ), // glyphnumber: 984, Combining flag 3 (32nd) below - std::pair( "flag32ndUp", 0xE244 ), // glyphnumber: 985, Combining flag 3 (32nd) above - std::pair( "flag512thDown", 0xE24D ), // glyphnumber: 986, Combining flag 7 (512th) below - std::pair( "flag512thUp", 0xE24C ), // glyphnumber: 987, Combining flag 7 (512th) above - std::pair( "flag64thDown", 0xE247 ), // glyphnumber: 988, Combining flag 4 (64th) below - std::pair( "flag64thUp", 0xE246 ), // glyphnumber: 989, Combining flag 4 (64th) above - std::pair( "flag8thDown", 0xE241 ), // glyphnumber: 990, Combining flag 1 (8th) below - std::pair( "flag8thUp", 0xE240 ), // glyphnumber: 991, Combining flag 1 (8th) above - std::pair( "flagInternalDown", 0xE251 ), // glyphnumber: 992, Internal combining flag below - std::pair( "flagInternalUp", 0xE250 ), // glyphnumber: 993, Internal combining flag above - std::pair( "fretboard3String", 0xE850 ), // glyphnumber: 994, 3-string fretboard - std::pair( "fretboard3StringNut", 0xE851 ), // glyphnumber: 995, 3-string fretboard at nut - std::pair( "fretboard4String", 0xE852 ), // glyphnumber: 996, 4-string fretboard - std::pair( "fretboard4StringNut", 0xE853 ), // glyphnumber: 997, 4-string fretboard at nut - std::pair( "fretboard5String", 0xE854 ), // glyphnumber: 998, 5-string fretboard - std::pair( "fretboard5StringNut", 0xE855 ), // glyphnumber: 999, 5-string fretboard at nut - std::pair( "fretboard6String", 0xE856 ), // glyphnumber: 1000, 6-string fretboard - std::pair( "fretboard6StringNut", 0xE857 ), // glyphnumber: 1001, 6-string fretboard at nut - std::pair( "fretboardFilledCircle", 0xE858 ), // glyphnumber: 1002, Fingered fret (filled circle) - std::pair( "fretboardO", 0xE85A ), // glyphnumber: 1003, Open string (O) - std::pair( "fretboardX", 0xE859 ), // glyphnumber: 1004, String not played (X) - std::pair( "functionAngleLeft", 0xEA93 ), // glyphnumber: 1005, Function theory angle bracket left - std::pair( "functionAngleRight", 0xEA94 ), // glyphnumber: 1006, Function theory angle bracket right - std::pair( "functionBracketLeft", 0xEA8F ), // glyphnumber: 1007, Function theory bracket left - std::pair( "functionBracketRight", 0xEA90 ), // glyphnumber: 1008, Function theory bracket right - std::pair( "functionDD", 0xEA81 ), // glyphnumber: 1009, Function theory dominant of dominant - std::pair( "functionDLower", 0xEA80 ), // glyphnumber: 1010, Function theory minor dominant - std::pair( "functionDUpper", 0xEA7F ), // glyphnumber: 1011, Function theory major dominant - std::pair( "functionEight", 0xEA78 ), // glyphnumber: 1012, Function theory 8 - std::pair( "functionFUpper", 0xEA99 ), // glyphnumber: 1013, Function theory F - std::pair( "functionFive", 0xEA75 ), // glyphnumber: 1014, Function theory 5 - std::pair( "functionFour", 0xEA74 ), // glyphnumber: 1015, Function theory 4 - std::pair( "functionGLower", 0xEA84 ), // glyphnumber: 1016, Function theory g - std::pair( "functionGUpper", 0xEA83 ), // glyphnumber: 1017, Function theory G - std::pair( "functionGreaterThan", 0xEA7C ), // glyphnumber: 1018, Function theory greater than - std::pair( "functionILower", 0xEA9B ), // glyphnumber: 1019, Function theory i - std::pair( "functionIUpper", 0xEA9A ), // glyphnumber: 1020, Function theory I - std::pair( "functionKLower", 0xEA9D ), // glyphnumber: 1021, Function theory k - std::pair( "functionKUpper", 0xEA9C ), // glyphnumber: 1022, Function theory K - std::pair( "functionLLower", 0xEA9F ), // glyphnumber: 1023, Function theory l - std::pair( "functionLUpper", 0xEA9E ), // glyphnumber: 1024, Function theory L - std::pair( "functionLessThan", 0xEA7A ), // glyphnumber: 1025, Function theory less than - std::pair( "functionMLower", 0xED01 ), // glyphnumber: 1026, Function theory m - std::pair( "functionMUpper", 0xED00 ), // glyphnumber: 1027, Function theory M - std::pair( "functionMinus", 0xEA7B ), // glyphnumber: 1028, Function theory minus - std::pair( "functionNLower", 0xEA86 ), // glyphnumber: 1029, Function theory n - std::pair( "functionNUpper", 0xEA85 ), // glyphnumber: 1030, Function theory N - std::pair( "functionNUpperSuperscript", 0xED02 ), // glyphnumber: 1031, Function theory superscript N - std::pair( "functionNine", 0xEA79 ), // glyphnumber: 1032, Function theory 9 - std::pair( "functionOne", 0xEA71 ), // glyphnumber: 1033, Function theory 1 - std::pair( "functionPLower", 0xEA88 ), // glyphnumber: 1034, Function theory p - std::pair( "functionPUpper", 0xEA87 ), // glyphnumber: 1035, Function theory P - std::pair( "functionParensLeft", 0xEA91 ), // glyphnumber: 1036, Function theory parenthesis left - std::pair( "functionParensRight", 0xEA92 ), // glyphnumber: 1037, Function theory parenthesis right - std::pair( "functionPlus", 0xEA98 ), // glyphnumber: 1038, Function theory prefix plus - std::pair( "functionRLower", 0xED03 ), // glyphnumber: 1039, Function theory r - std::pair( "functionRepetition1", 0xEA95 ), // glyphnumber: 1040, Function theory repetition 1 - std::pair( "functionRepetition2", 0xEA96 ), // glyphnumber: 1041, Function theory repetition 2 - std::pair( "functionRing", 0xEA97 ), // glyphnumber: 1042, Function theory prefix ring - std::pair( "functionSLower", 0xEA8A ), // glyphnumber: 1043, Function theory minor subdominant - std::pair( "functionSSLower", 0xEA7E ), // glyphnumber: 1044, Function theory minor subdominant of subdominant - std::pair( "functionSSUpper", 0xEA7D ), // glyphnumber: 1045, Function theory major subdominant of subdominant - std::pair( "functionSUpper", 0xEA89 ), // glyphnumber: 1046, Function theory major subdominant - std::pair( "functionSeven", 0xEA77 ), // glyphnumber: 1047, Function theory 7 - std::pair( "functionSix", 0xEA76 ), // glyphnumber: 1048, Function theory 6 - std::pair( "functionSlashedDD", 0xEA82 ), // glyphnumber: 1049, Function theory double dominant seventh - std::pair( "functionTLower", 0xEA8C ), // glyphnumber: 1050, Function theory minor tonic - std::pair( "functionTUpper", 0xEA8B ), // glyphnumber: 1051, Function theory tonic - std::pair( "functionThree", 0xEA73 ), // glyphnumber: 1052, Function theory 3 - std::pair( "functionTwo", 0xEA72 ), // glyphnumber: 1053, Function theory 2 - std::pair( "functionVLower", 0xEA8E ), // glyphnumber: 1054, Function theory v - std::pair( "functionVUpper", 0xEA8D ), // glyphnumber: 1055, Function theory V - std::pair( "functionZero", 0xEA70 ), // glyphnumber: 1056, Function theory 0 - std::pair( "gClef", 0xE050 ), // glyphnumber: 1057, G clef - std::pair( "gClef15ma", 0xE054 ), // glyphnumber: 1058, G clef quindicesima alta - std::pair( "gClef15mb", 0xE051 ), // glyphnumber: 1059, G clef quindicesima bassa - std::pair( "gClef8va", 0xE053 ), // glyphnumber: 1060, G clef ottava alta - std::pair( "gClef8vb", 0xE052 ), // glyphnumber: 1061, G clef ottava bassa - std::pair( "gClef8vbCClef", 0xE056 ), // glyphnumber: 1062, G clef ottava bassa with C clef - std::pair( "gClef8vbOld", 0xE055 ), // glyphnumber: 1063, G clef ottava bassa (old style) - std::pair( "gClef8vbParens", 0xE057 ), // glyphnumber: 1064, G clef, optionally ottava bassa - std::pair( "gClefArrowDown", 0xE05B ), // glyphnumber: 1065, G clef, arrow down - std::pair( "gClefArrowUp", 0xE05A ), // glyphnumber: 1066, G clef, arrow up - std::pair( "gClefChange", 0xE07A ), // glyphnumber: 1067, G clef change - std::pair( "gClefLigatedNumberAbove", 0xE059 ), // glyphnumber: 1068, Combining G clef, number above - std::pair( "gClefLigatedNumberBelow", 0xE058 ), // glyphnumber: 1069, Combining G clef, number below - std::pair( "gClefReversed", 0xE073 ), // glyphnumber: 1070, Reversed G clef - std::pair( "gClefTurned", 0xE074 ), // glyphnumber: 1071, Turned G clef - std::pair( "glissandoDown", 0xE586 ), // glyphnumber: 1072, Glissando down - std::pair( "glissandoUp", 0xE585 ), // glyphnumber: 1073, Glissando up - std::pair( "graceNoteAcciaccaturaStemDown", 0xE561 ), // glyphnumber: 1074, Slashed grace note stem down - std::pair( "graceNoteAcciaccaturaStemUp", 0xE560 ), // glyphnumber: 1075, Slashed grace note stem up - std::pair( "graceNoteAppoggiaturaStemDown", 0xE563 ), // glyphnumber: 1076, Grace note stem down - std::pair( "graceNoteAppoggiaturaStemUp", 0xE562 ), // glyphnumber: 1077, Grace note stem up - std::pair( "graceNoteSlashStemDown", 0xE565 ), // glyphnumber: 1078, Slash for stem down grace note - std::pair( "graceNoteSlashStemUp", 0xE564 ), // glyphnumber: 1079, Slash for stem up grace note - std::pair( "guitarBarreFull", 0xE848 ), // glyphnumber: 1080, Full barré - std::pair( "guitarBarreHalf", 0xE849 ), // glyphnumber: 1081, Half barré - std::pair( "guitarClosePedal", 0xE83F ), // glyphnumber: 1082, Closed wah/volume pedal - std::pair( "guitarFadeIn", 0xE843 ), // glyphnumber: 1083, Fade in - std::pair( "guitarFadeOut", 0xE844 ), // glyphnumber: 1084, Fade out - std::pair( "guitarGolpe", 0xE842 ), // glyphnumber: 1085, Golpe (tapping the pick guard) - std::pair( "guitarHalfOpenPedal", 0xE83E ), // glyphnumber: 1086, Half-open wah/volume pedal - std::pair( "guitarLeftHandTapping", 0xE840 ), // glyphnumber: 1087, Left-hand tapping - std::pair( "guitarOpenPedal", 0xE83D ), // glyphnumber: 1088, Open wah/volume pedal - std::pair( "guitarRightHandTapping", 0xE841 ), // glyphnumber: 1089, Right-hand tapping - std::pair( "guitarShake", 0xE832 ), // glyphnumber: 1090, Guitar shake - std::pair( "guitarString0", 0xE833 ), // glyphnumber: 1091, String number 0 - std::pair( "guitarString1", 0xE834 ), // glyphnumber: 1092, String number 1 - std::pair( "guitarString2", 0xE835 ), // glyphnumber: 1093, String number 2 - std::pair( "guitarString3", 0xE836 ), // glyphnumber: 1094, String number 3 - std::pair( "guitarString4", 0xE837 ), // glyphnumber: 1095, String number 4 - std::pair( "guitarString5", 0xE838 ), // glyphnumber: 1096, String number 5 - std::pair( "guitarString6", 0xE839 ), // glyphnumber: 1097, String number 6 - std::pair( "guitarString7", 0xE83A ), // glyphnumber: 1098, String number 7 - std::pair( "guitarString8", 0xE83B ), // glyphnumber: 1099, String number 8 - std::pair( "guitarString9", 0xE83C ), // glyphnumber: 1100, String number 9 - std::pair( "guitarStrumDown", 0xE847 ), // glyphnumber: 1101, Strum direction down - std::pair( "guitarStrumUp", 0xE846 ), // glyphnumber: 1102, Strum direction up - std::pair( "guitarVibratoBarDip", 0xE831 ), // glyphnumber: 1103, Guitar vibrato bar dip - std::pair( "guitarVibratoBarScoop", 0xE830 ), // glyphnumber: 1104, Guitar vibrato bar scoop - std::pair( "guitarVibratoStroke", 0xEAB2 ), // glyphnumber: 1105, Vibrato wiggle segment - std::pair( "guitarVolumeSwell", 0xE845 ), // glyphnumber: 1106, Volume swell - std::pair( "guitarWideVibratoStroke", 0xEAB3 ), // glyphnumber: 1107, Wide vibrato wiggle segment - std::pair( "handbellsBelltree", 0xE81F ), // glyphnumber: 1108, Belltree - std::pair( "handbellsDamp3", 0xE81E ), // glyphnumber: 1109, Damp 3 - std::pair( "handbellsEcho1", 0xE81B ), // glyphnumber: 1110, Echo - std::pair( "handbellsEcho2", 0xE81C ), // glyphnumber: 1111, Echo 2 - std::pair( "handbellsGyro", 0xE81D ), // glyphnumber: 1112, Gyro - std::pair( "handbellsHandMartellato", 0xE812 ), // glyphnumber: 1113, Hand martellato - std::pair( "handbellsMalletBellOnTable", 0xE815 ), // glyphnumber: 1114, Mallet, bell on table - std::pair( "handbellsMalletBellSuspended", 0xE814 ), // glyphnumber: 1115, Mallet, bell suspended - std::pair( "handbellsMalletLft", 0xE816 ), // glyphnumber: 1116, Mallet lift - std::pair( "handbellsMartellato", 0xE810 ), // glyphnumber: 1117, Martellato - std::pair( "handbellsMartellatoLift", 0xE811 ), // glyphnumber: 1118, Martellato lift - std::pair( "handbellsMutedMartellato", 0xE813 ), // glyphnumber: 1119, Muted martellato - std::pair( "handbellsPluckLift", 0xE817 ), // glyphnumber: 1120, Pluck lift - std::pair( "handbellsSwing", 0xE81A ), // glyphnumber: 1121, Swing - std::pair( "handbellsSwingDown", 0xE819 ), // glyphnumber: 1122, Swing down - std::pair( "handbellsSwingUp", 0xE818 ), // glyphnumber: 1123, Swing up - std::pair( "handbellsTablePairBells", 0xE821 ), // glyphnumber: 1124, Table pair of handbells - std::pair( "handbellsTableSingleBell", 0xE820 ), // glyphnumber: 1125, Table single handbell - std::pair( "harpMetalRod", 0xE68F ), // glyphnumber: 1126, Metal rod pictogram - std::pair( "harpPedalCentered", 0xE681 ), // glyphnumber: 1127, Harp pedal centered (natural) - std::pair( "harpPedalDivider", 0xE683 ), // glyphnumber: 1128, Harp pedal divider - std::pair( "harpPedalLowered", 0xE682 ), // glyphnumber: 1129, Harp pedal lowered (sharp) - std::pair( "harpPedalRaised", 0xE680 ), // glyphnumber: 1130, Harp pedal raised (flat) - std::pair( "harpSalzedoAeolianAscending", 0xE695 ), // glyphnumber: 1131, Ascending aeolian chords (Salzedo) - std::pair( "harpSalzedoAeolianDescending", 0xE696 ), // glyphnumber: 1132, Descending aeolian chords (Salzedo) - std::pair( "harpSalzedoDampAbove", 0xE69A ), // glyphnumber: 1133, Damp above (Salzedo) - std::pair( "harpSalzedoDampBelow", 0xE699 ), // glyphnumber: 1134, Damp below (Salzedo) - std::pair( "harpSalzedoDampBothHands", 0xE698 ), // glyphnumber: 1135, Damp with both hands (Salzedo) - std::pair( "harpSalzedoDampLowStrings", 0xE697 ), // glyphnumber: 1136, Damp only low strings (Salzedo) - std::pair( "harpSalzedoFluidicSoundsLeft", 0xE68D ), // glyphnumber: 1137, Fluidic sounds, left hand (Salzedo) - std::pair( "harpSalzedoFluidicSoundsRight", 0xE68E ), // glyphnumber: 1138, Fluidic sounds, right hand (Salzedo) - std::pair( "harpSalzedoIsolatedSounds", 0xE69C ), // glyphnumber: 1139, Isolated sounds (Salzedo) - std::pair( "harpSalzedoMetallicSounds", 0xE688 ), // glyphnumber: 1140, Metallic sounds (Salzedo) - std::pair( "harpSalzedoMetallicSoundsOneString", 0xE69B ), // glyphnumber: 1141, Metallic sounds, one string (Salzedo) - std::pair( "harpSalzedoMuffleTotally", 0xE68C ), // glyphnumber: 1142, Muffle totally (Salzedo) - std::pair( "harpSalzedoOboicFlux", 0xE685 ), // glyphnumber: 1143, Oboic flux (Salzedo) - std::pair( "harpSalzedoPlayUpperEnd", 0xE68A ), // glyphnumber: 1144, Play at upper end of strings (Salzedo) - std::pair( "harpSalzedoSlideWithSuppleness", 0xE684 ), // glyphnumber: 1145, Slide with suppleness (Salzedo) - std::pair( "harpSalzedoSnareDrum", 0xE69D ), // glyphnumber: 1146, Snare drum effect (Salzedo) - std::pair( "harpSalzedoTamTamSounds", 0xE689 ), // glyphnumber: 1147, Tam-tam sounds (Salzedo) - std::pair( "harpSalzedoThunderEffect", 0xE686 ), // glyphnumber: 1148, Thunder effect (Salzedo) - std::pair( "harpSalzedoTimpanicSounds", 0xE68B ), // glyphnumber: 1149, Timpanic sounds (Salzedo) - std::pair( "harpSalzedoWhistlingSounds", 0xE687 ), // glyphnumber: 1150, Whistling sounds (Salzedo) - std::pair( "harpStringNoiseStem", 0xE694 ), // glyphnumber: 1151, Combining string noise for stem - std::pair( "harpTuningKey", 0xE690 ), // glyphnumber: 1152, Tuning key pictogram - std::pair( "harpTuningKeyGlissando", 0xE693 ), // glyphnumber: 1153, Retune strings for glissando - std::pair( "harpTuningKeyHandle", 0xE691 ), // glyphnumber: 1154, Use handle of tuning key pictogram - std::pair( "harpTuningKeyShank", 0xE692 ), // glyphnumber: 1155, Use shank of tuning key pictogram - std::pair( "keyboardBebung2DotsAbove", 0xE668 ), // glyphnumber: 1156, Clavichord bebung, 2 finger movements (above) - std::pair( "keyboardBebung2DotsBelow", 0xE669 ), // glyphnumber: 1157, Clavichord bebung, 2 finger movements (below) - std::pair( "keyboardBebung3DotsAbove", 0xE66A ), // glyphnumber: 1158, Clavichord bebung, 3 finger movements (above) - std::pair( "keyboardBebung3DotsBelow", 0xE66B ), // glyphnumber: 1159, Clavichord bebung, 3 finger movements (below) - std::pair( "keyboardBebung4DotsAbove", 0xE66C ), // glyphnumber: 1160, Clavichord bebung, 4 finger movements (above) - std::pair( "keyboardBebung4DotsBelow", 0xE66D ), // glyphnumber: 1161, Clavichord bebung, 4 finger movements (below) - std::pair( "keyboardLeftPedalPictogram", 0xE65E ), // glyphnumber: 1162, Left pedal pictogram - std::pair( "keyboardMiddlePedalPictogram", 0xE65F ), // glyphnumber: 1163, Middle pedal pictogram - std::pair( "keyboardPedalD", 0xE653 ), // glyphnumber: 1164, Pedal d - std::pair( "keyboardPedalDot", 0xE654 ), // glyphnumber: 1165, Pedal dot - std::pair( "keyboardPedalE", 0xE652 ), // glyphnumber: 1166, Pedal e - std::pair( "keyboardPedalHalf", 0xE656 ), // glyphnumber: 1167, Half-pedal mark - std::pair( "keyboardPedalHalf2", 0xE65B ), // glyphnumber: 1168, Half pedal mark 1 - std::pair( "keyboardPedalHalf3", 0xE65C ), // glyphnumber: 1169, Half pedal mark 2 - std::pair( "keyboardPedalHeel1", 0xE661 ), // glyphnumber: 1170, Pedal heel 1 - std::pair( "keyboardPedalHeel2", 0xE662 ), // glyphnumber: 1171, Pedal heel 2 - std::pair( "keyboardPedalHeel3", 0xE663 ), // glyphnumber: 1172, Pedal heel 3 (Davis) - std::pair( "keyboardPedalHeelToToe", 0xE674 ), // glyphnumber: 1173, Pedal heel to toe - std::pair( "keyboardPedalHeelToe", 0xE666 ), // glyphnumber: 1174, Pedal heel or toe - std::pair( "keyboardPedalHookEnd", 0xE673 ), // glyphnumber: 1175, Pedal hook end - std::pair( "keyboardPedalHookStart", 0xE672 ), // glyphnumber: 1176, Pedal hook start - std::pair( "keyboardPedalHyphen", 0xE658 ), // glyphnumber: 1177, Pedal hyphen - std::pair( "keyboardPedalP", 0xE651 ), // glyphnumber: 1178, Pedal P - std::pair( "keyboardPedalPed", 0xE650 ), // glyphnumber: 1179, Pedal mark - std::pair( "keyboardPedalS", 0xE65A ), // glyphnumber: 1180, Pedal S - std::pair( "keyboardPedalSost", 0xE659 ), // glyphnumber: 1181, Sostenuto pedal mark - std::pair( "keyboardPedalToe1", 0xE664 ), // glyphnumber: 1182, Pedal toe 1 - std::pair( "keyboardPedalToe2", 0xE665 ), // glyphnumber: 1183, Pedal toe 2 - std::pair( "keyboardPedalToeToHeel", 0xE675 ), // glyphnumber: 1184, Pedal toe to heel - std::pair( "keyboardPedalUp", 0xE655 ), // glyphnumber: 1185, Pedal up mark - std::pair( "keyboardPedalUpNotch", 0xE657 ), // glyphnumber: 1186, Pedal up notch - std::pair( "keyboardPedalUpSpecial", 0xE65D ), // glyphnumber: 1187, Pedal up special - std::pair( "keyboardPlayWithLH", 0xE670 ), // glyphnumber: 1188, Play with left hand - std::pair( "keyboardPlayWithLHEnd", 0xE671 ), // glyphnumber: 1189, Play with left hand (end) - std::pair( "keyboardPlayWithRH", 0xE66E ), // glyphnumber: 1190, Play with right hand - std::pair( "keyboardPlayWithRHEnd", 0xE66F ), // glyphnumber: 1191, Play with right hand (end) - std::pair( "keyboardPluckInside", 0xE667 ), // glyphnumber: 1192, Pluck strings inside piano (Maderna) - std::pair( "keyboardRightPedalPictogram", 0xE660 ), // glyphnumber: 1193, Right pedal pictogram - std::pair( "kievanAccidentalFlat", 0xEC3E ), // glyphnumber: 1194, Kievan flat - std::pair( "kievanAccidentalSharp", 0xEC3D ), // glyphnumber: 1195, Kievan sharp - std::pair( "kievanAugmentationDot", 0xEC3C ), // glyphnumber: 1196, Kievan augmentation dot - std::pair( "kievanCClef", 0xEC30 ), // glyphnumber: 1197, Kievan C clef (tse-fa-ut) - std::pair( "kievanEndingSymbol", 0xEC31 ), // glyphnumber: 1198, Kievan ending symbol - std::pair( "kievanNote8thStemDown", 0xEC3A ), // glyphnumber: 1199, Kievan eighth note, stem down - std::pair( "kievanNote8thStemUp", 0xEC39 ), // glyphnumber: 1200, Kievan eighth note, stem up - std::pair( "kievanNoteBeam", 0xEC3B ), // glyphnumber: 1201, Kievan beam - std::pair( "kievanNoteHalfStaffLine", 0xEC35 ), // glyphnumber: 1202, Kievan half note (on staff line) - std::pair( "kievanNoteHalfStaffSpace", 0xEC36 ), // glyphnumber: 1203, Kievan half note (in staff space) - std::pair( "kievanNoteQuarterStemDown", 0xEC38 ), // glyphnumber: 1204, Kievan quarter note, stem down - std::pair( "kievanNoteQuarterStemUp", 0xEC37 ), // glyphnumber: 1205, Kievan quarter note, stem up - std::pair( "kievanNoteReciting", 0xEC32 ), // glyphnumber: 1206, Kievan reciting note - std::pair( "kievanNoteWhole", 0xEC33 ), // glyphnumber: 1207, Kievan whole note - std::pair( "kievanNoteWholeFinal", 0xEC34 ), // glyphnumber: 1208, Kievan final whole note - std::pair( "kodalyHandDo", 0xEC40 ), // glyphnumber: 1209, Do hand sign - std::pair( "kodalyHandFa", 0xEC43 ), // glyphnumber: 1210, Fa hand sign - std::pair( "kodalyHandLa", 0xEC45 ), // glyphnumber: 1211, La hand sign - std::pair( "kodalyHandMi", 0xEC42 ), // glyphnumber: 1212, Mi hand sign - std::pair( "kodalyHandRe", 0xEC41 ), // glyphnumber: 1213, Re hand sign - std::pair( "kodalyHandSo", 0xEC44 ), // glyphnumber: 1214, So hand sign - std::pair( "kodalyHandTi", 0xEC46 ), // glyphnumber: 1215, Ti hand sign - std::pair( "leftRepeatSmall", 0xE04C ), // glyphnumber: 1216, Left repeat sign within bar - std::pair( "legerLine", 0xE022 ), // glyphnumber: 1217, Leger line - std::pair( "legerLineNarrow", 0xE024 ), // glyphnumber: 1218, Leger line (narrow) - std::pair( "legerLineWide", 0xE023 ), // glyphnumber: 1219, Leger line (wide) - std::pair( "luteBarlineEndRepeat", 0xEBA4 ), // glyphnumber: 1220, Lute tablature end repeat barline - std::pair( "luteBarlineFinal", 0xEBA5 ), // glyphnumber: 1221, Lute tablature final barline - std::pair( "luteBarlineStartRepeat", 0xEBA3 ), // glyphnumber: 1222, Lute tablature start repeat barline - std::pair( "luteDuration16th", 0xEBAB ), // glyphnumber: 1223, 16th note (semiquaver) duration sign - std::pair( "luteDuration32nd", 0xEBAC ), // glyphnumber: 1224, 32nd note (demisemiquaver) duration sign - std::pair( "luteDuration8th", 0xEBAA ), // glyphnumber: 1225, Eighth note (quaver) duration sign - std::pair( "luteDurationDoubleWhole", 0xEBA6 ), // glyphnumber: 1226, Double whole note (breve) duration sign - std::pair( "luteDurationHalf", 0xEBA8 ), // glyphnumber: 1227, Half note (minim) duration sign - std::pair( "luteDurationQuarter", 0xEBA9 ), // glyphnumber: 1228, Quarter note (crotchet) duration sign - std::pair( "luteDurationWhole", 0xEBA7 ), // glyphnumber: 1229, Whole note (semibreve) duration sign - std::pair( "luteFingeringRHFirst", 0xEBAE ), // glyphnumber: 1230, Right-hand fingering, first finger - std::pair( "luteFingeringRHSecond", 0xEBAF ), // glyphnumber: 1231, Right-hand fingering, second finger - std::pair( "luteFingeringRHThird", 0xEBB0 ), // glyphnumber: 1232, Right-hand fingering, third finger - std::pair( "luteFingeringRHThumb", 0xEBAD ), // glyphnumber: 1233, Right-hand fingering, thumb - std::pair( "luteFrench10thCourse", 0xEBD0 ), // glyphnumber: 1234, 10th course (diapason) - std::pair( "luteFrench7thCourse", 0xEBCD ), // glyphnumber: 1235, Seventh course (diapason) - std::pair( "luteFrench8thCourse", 0xEBCE ), // glyphnumber: 1236, Eighth course (diapason) - std::pair( "luteFrench9thCourse", 0xEBCF ), // glyphnumber: 1237, Ninth course (diapason) - std::pair( "luteFrenchAppoggiaturaAbove", 0xEBD5 ), // glyphnumber: 1238, Appoggiatura from above - std::pair( "luteFrenchAppoggiaturaBelow", 0xEBD4 ), // glyphnumber: 1239, Appoggiatura from below - std::pair( "luteFrenchFretA", 0xEBC0 ), // glyphnumber: 1240, Open string (a) - std::pair( "luteFrenchFretB", 0xEBC1 ), // glyphnumber: 1241, First fret (b) - std::pair( "luteFrenchFretC", 0xEBC2 ), // glyphnumber: 1242, Second fret (c) - std::pair( "luteFrenchFretD", 0xEBC3 ), // glyphnumber: 1243, Third fret (d) - std::pair( "luteFrenchFretE", 0xEBC4 ), // glyphnumber: 1244, Fourth fret (e) - std::pair( "luteFrenchFretF", 0xEBC5 ), // glyphnumber: 1245, Fifth fret (f) - std::pair( "luteFrenchFretG", 0xEBC6 ), // glyphnumber: 1246, Sixth fret (g) - std::pair( "luteFrenchFretH", 0xEBC7 ), // glyphnumber: 1247, Seventh fret (h) - std::pair( "luteFrenchFretI", 0xEBC8 ), // glyphnumber: 1248, Eighth fret (i) - std::pair( "luteFrenchFretK", 0xEBC9 ), // glyphnumber: 1249, Ninth fret (k) - std::pair( "luteFrenchFretL", 0xEBCA ), // glyphnumber: 1250, 10th fret (l) - std::pair( "luteFrenchFretM", 0xEBCB ), // glyphnumber: 1251, 11th fret (m) - std::pair( "luteFrenchFretN", 0xEBCC ), // glyphnumber: 1252, 12th fret (n) - std::pair( "luteFrenchMordentInverted", 0xEBD3 ), // glyphnumber: 1253, Inverted mordent - std::pair( "luteFrenchMordentLower", 0xEBD2 ), // glyphnumber: 1254, Mordent with lower auxiliary - std::pair( "luteFrenchMordentUpper", 0xEBD1 ), // glyphnumber: 1255, Mordent with upper auxiliary - std::pair( "luteGermanALower", 0xEC00 ), // glyphnumber: 1256, 5th course, 1st fret (a) - std::pair( "luteGermanAUpper", 0xEC17 ), // glyphnumber: 1257, 6th course, 1st fret (A) - std::pair( "luteGermanBLower", 0xEC01 ), // glyphnumber: 1258, 4th course, 1st fret (b) - std::pair( "luteGermanBUpper", 0xEC18 ), // glyphnumber: 1259, 6th course, 2nd fret (B) - std::pair( "luteGermanCLower", 0xEC02 ), // glyphnumber: 1260, 3rd course, 1st fret (c) - std::pair( "luteGermanCUpper", 0xEC19 ), // glyphnumber: 1261, 6th course, 3rd fret (C) - std::pair( "luteGermanDLower", 0xEC03 ), // glyphnumber: 1262, 2nd course, 1st fret (d) - std::pair( "luteGermanDUpper", 0xEC1A ), // glyphnumber: 1263, 6th course, 4th fret (D) - std::pair( "luteGermanELower", 0xEC04 ), // glyphnumber: 1264, 1st course, 1st fret (e) - std::pair( "luteGermanEUpper", 0xEC1B ), // glyphnumber: 1265, 6th course, 5th fret (E) - std::pair( "luteGermanFLower", 0xEC05 ), // glyphnumber: 1266, 5th course, 2nd fret (f) - std::pair( "luteGermanFUpper", 0xEC1C ), // glyphnumber: 1267, 6th course, 6th fret (F) - std::pair( "luteGermanGLower", 0xEC06 ), // glyphnumber: 1268, 4th course, 2nd fret (g) - std::pair( "luteGermanGUpper", 0xEC1D ), // glyphnumber: 1269, 6th course, 7th fret (G) - std::pair( "luteGermanHLower", 0xEC07 ), // glyphnumber: 1270, 3rd course, 2nd fret (h) - std::pair( "luteGermanHUpper", 0xEC1E ), // glyphnumber: 1271, 6th course, 8th fret (H) - std::pair( "luteGermanILower", 0xEC08 ), // glyphnumber: 1272, 2nd course, 2nd fret (i) - std::pair( "luteGermanIUpper", 0xEC1F ), // glyphnumber: 1273, 6th course, 9th fret (I) - std::pair( "luteGermanKLower", 0xEC09 ), // glyphnumber: 1274, 1st course, 2nd fret (k) - std::pair( "luteGermanKUpper", 0xEC20 ), // glyphnumber: 1275, 6th course, 10th fret (K) - std::pair( "luteGermanLLower", 0xEC0A ), // glyphnumber: 1276, 5th course, 3rd fret (l) - std::pair( "luteGermanLUpper", 0xEC21 ), // glyphnumber: 1277, 6th course, 11th fret (L) - std::pair( "luteGermanMLower", 0xEC0B ), // glyphnumber: 1278, 4th course, 3rd fret (m) - std::pair( "luteGermanMUpper", 0xEC22 ), // glyphnumber: 1279, 6th course, 12th fret (M) - std::pair( "luteGermanNLower", 0xEC0C ), // glyphnumber: 1280, 3rd course, 3rd fret (n) - std::pair( "luteGermanNUpper", 0xEC23 ), // glyphnumber: 1281, 6th course, 13th fret (N) - std::pair( "luteGermanOLower", 0xEC0D ), // glyphnumber: 1282, 2nd course, 3rd fret (o) - std::pair( "luteGermanPLower", 0xEC0E ), // glyphnumber: 1283, 1st course, 3rd fret (p) - std::pair( "luteGermanQLower", 0xEC0F ), // glyphnumber: 1284, 5th course, 4th fret (q) - std::pair( "luteGermanRLower", 0xEC10 ), // glyphnumber: 1285, 4th course, 4th fret (r) - std::pair( "luteGermanSLower", 0xEC11 ), // glyphnumber: 1286, 3rd course, 4th fret (s) - std::pair( "luteGermanTLower", 0xEC12 ), // glyphnumber: 1287, 2nd course, 4th fret (t) - std::pair( "luteGermanVLower", 0xEC13 ), // glyphnumber: 1288, 1st course, 4th fret (v) - std::pair( "luteGermanXLower", 0xEC14 ), // glyphnumber: 1289, 5th course, 5th fret (x) - std::pair( "luteGermanYLower", 0xEC15 ), // glyphnumber: 1290, 4th course, 5th fret (y) - std::pair( "luteGermanZLower", 0xEC16 ), // glyphnumber: 1291, 3rd course, 5th fret (z) - std::pair( "luteItalianClefCSolFaUt", 0xEBF1 ), // glyphnumber: 1292, C sol fa ut clef - std::pair( "luteItalianClefFFaUt", 0xEBF0 ), // glyphnumber: 1293, F fa ut clef - std::pair( "luteItalianFret0", 0xEBE0 ), // glyphnumber: 1294, Open string (0) - std::pair( "luteItalianFret1", 0xEBE1 ), // glyphnumber: 1295, First fret (1) - std::pair( "luteItalianFret2", 0xEBE2 ), // glyphnumber: 1296, Second fret (2) - std::pair( "luteItalianFret3", 0xEBE3 ), // glyphnumber: 1297, Third fret (3) - std::pair( "luteItalianFret4", 0xEBE4 ), // glyphnumber: 1298, Fourth fret (4) - std::pair( "luteItalianFret5", 0xEBE5 ), // glyphnumber: 1299, Fifth fret (5) - std::pair( "luteItalianFret6", 0xEBE6 ), // glyphnumber: 1300, Sixth fret (6) - std::pair( "luteItalianFret7", 0xEBE7 ), // glyphnumber: 1301, Seventh fret (7) - std::pair( "luteItalianFret8", 0xEBE8 ), // glyphnumber: 1302, Eighth fret (8) - std::pair( "luteItalianFret9", 0xEBE9 ), // glyphnumber: 1303, Ninth fret (9) - std::pair( "luteItalianHoldFinger", 0xEBF4 ), // glyphnumber: 1304, Hold finger in place - std::pair( "luteItalianHoldNote", 0xEBF3 ), // glyphnumber: 1305, Hold note - std::pair( "luteItalianReleaseFinger", 0xEBF5 ), // glyphnumber: 1306, Release finger - std::pair( "luteItalianTempoFast", 0xEBEA ), // glyphnumber: 1307, Fast tempo indication (de Mudarra) - std::pair( "luteItalianTempoNeitherFastNorSlow", 0xEBEC ), // glyphnumber: 1308, Neither fast nor slow tempo indication (de Mudarra) - std::pair( "luteItalianTempoSlow", 0xEBED ), // glyphnumber: 1309, Slow tempo indication (de Mudarra) - std::pair( "luteItalianTempoSomewhatFast", 0xEBEB ), // glyphnumber: 1310, Somewhat fast tempo indication (de Narvaez) - std::pair( "luteItalianTempoVerySlow", 0xEBEE ), // glyphnumber: 1311, Very slow indication (de Narvaez) - std::pair( "luteItalianTimeTriple", 0xEBEF ), // glyphnumber: 1312, Triple time indication - std::pair( "luteItalianTremolo", 0xEBF2 ), // glyphnumber: 1313, Single-finger tremolo or mordent - std::pair( "luteItalianVibrato", 0xEBF6 ), // glyphnumber: 1314, Vibrato (verre cassé) - std::pair( "luteStaff6Lines", 0xEBA0 ), // glyphnumber: 1315, Lute tablature staff, 6 courses - std::pair( "luteStaff6LinesNarrow", 0xEBA2 ), // glyphnumber: 1316, Lute tablature staff, 6 courses (narrow) - std::pair( "luteStaff6LinesWide", 0xEBA1 ), // glyphnumber: 1317, Lute tablature staff, 6 courses (wide) - std::pair( "lyricsElision", 0xE551 ), // glyphnumber: 1318, Elision - std::pair( "lyricsElisionNarrow", 0xE550 ), // glyphnumber: 1319, Narrow elision - std::pair( "lyricsElisionWide", 0xE552 ), // glyphnumber: 1320, Wide elision - std::pair( "lyricsHyphenBaseline", 0xE553 ), // glyphnumber: 1321, Baseline hyphen - std::pair( "lyricsHyphenBaselineNonBreaking", 0xE554 ), // glyphnumber: 1322, Non-breaking baseline hyphen - std::pair( "medRenFlatHardB", 0xE9E1 ), // glyphnumber: 1323, Flat, hard b (mi) - std::pair( "medRenFlatSoftB", 0xE9E0 ), // glyphnumber: 1324, Flat, soft b (fa) - std::pair( "medRenFlatWithDot", 0xE9E4 ), // glyphnumber: 1325, Flat with dot - std::pair( "medRenGClefCMN", 0xEA24 ), // glyphnumber: 1326, G clef (Corpus Monodicum) - std::pair( "medRenLiquescenceCMN", 0xEA22 ), // glyphnumber: 1327, Liquescence - std::pair( "medRenLiquescentAscCMN", 0xEA26 ), // glyphnumber: 1328, Liquescent ascending (Corpus Monodicum) - std::pair( "medRenLiquescentDescCMN", 0xEA27 ), // glyphnumber: 1329, Liquescent descending (Corpus Monodicum) - std::pair( "medRenNatural", 0xE9E2 ), // glyphnumber: 1330, Natural - std::pair( "medRenNaturalWithCross", 0xE9E5 ), // glyphnumber: 1331, Natural with interrupted cross - std::pair( "medRenOriscusCMN", 0xEA2A ), // glyphnumber: 1332, Oriscus (Corpus Monodicum) - std::pair( "medRenPlicaCMN", 0xEA23 ), // glyphnumber: 1333, Plica - std::pair( "medRenPunctumCMN", 0xEA25 ), // glyphnumber: 1334, Punctum (Corpus Monodicum) - std::pair( "medRenQuilismaCMN", 0xEA28 ), // glyphnumber: 1335, Quilisma (Corpus Monodicum) - std::pair( "medRenSharpCroix", 0xE9E3 ), // glyphnumber: 1336, Croix - std::pair( "medRenStrophicusCMN", 0xEA29 ), // glyphnumber: 1337, Strophicus (Corpus Monodicum) - std::pair( "mensuralAlterationSign", 0xEA10 ), // glyphnumber: 1338, Alteration sign - std::pair( "mensuralBlackBrevis", 0xE952 ), // glyphnumber: 1339, Black mensural brevis - std::pair( "mensuralBlackBrevisVoid", 0xE956 ), // glyphnumber: 1340, Black mensural void brevis - std::pair( "mensuralBlackDragma", 0xE95A ), // glyphnumber: 1341, Black mensural dragma - std::pair( "mensuralBlackLonga", 0xE951 ), // glyphnumber: 1342, Black mensural longa - std::pair( "mensuralBlackMaxima", 0xE950 ), // glyphnumber: 1343, Black mensural maxima - std::pair( "mensuralBlackMinima", 0xE954 ), // glyphnumber: 1344, Black mensural minima - std::pair( "mensuralBlackMinimaVoid", 0xE958 ), // glyphnumber: 1345, Black mensural void minima - std::pair( "mensuralBlackSemibrevis", 0xE953 ), // glyphnumber: 1346, Black mensural semibrevis - std::pair( "mensuralBlackSemibrevisCaudata", 0xE959 ), // glyphnumber: 1347, Black mensural semibrevis caudata - std::pair( "mensuralBlackSemibrevisOblique", 0xE95B ), // glyphnumber: 1348, Black mensural oblique semibrevis - std::pair( "mensuralBlackSemibrevisVoid", 0xE957 ), // glyphnumber: 1349, Black mensural void semibrevis - std::pair( "mensuralBlackSemiminima", 0xE955 ), // glyphnumber: 1350, Black mensural semiminima - std::pair( "mensuralCclef", 0xE905 ), // glyphnumber: 1351, Mensural C clef - std::pair( "mensuralCclefPetrucciPosHigh", 0xE90A ), // glyphnumber: 1352, Petrucci C clef, high position - std::pair( "mensuralCclefPetrucciPosHighest", 0xE90B ), // glyphnumber: 1353, Petrucci C clef, highest position - std::pair( "mensuralCclefPetrucciPosLow", 0xE908 ), // glyphnumber: 1354, Petrucci C clef, low position - std::pair( "mensuralCclefPetrucciPosLowest", 0xE907 ), // glyphnumber: 1355, Petrucci C clef, lowest position - std::pair( "mensuralCclefPetrucciPosMiddle", 0xE909 ), // glyphnumber: 1356, Petrucci C clef, middle position - std::pair( "mensuralColorationEndRound", 0xEA0F ), // glyphnumber: 1357, Coloration end, round - std::pair( "mensuralColorationEndSquare", 0xEA0D ), // glyphnumber: 1358, Coloration end, square - std::pair( "mensuralColorationStartRound", 0xEA0E ), // glyphnumber: 1359, Coloration start, round - std::pair( "mensuralColorationStartSquare", 0xEA0C ), // glyphnumber: 1360, Coloration start, square - std::pair( "mensuralCombStemDiagonal", 0xE940 ), // glyphnumber: 1361, Combining stem diagonal - std::pair( "mensuralCombStemDown", 0xE93F ), // glyphnumber: 1362, Combining stem down - std::pair( "mensuralCombStemDownFlagExtended", 0xE948 ), // glyphnumber: 1363, Combining stem with extended flag down - std::pair( "mensuralCombStemDownFlagFlared", 0xE946 ), // glyphnumber: 1364, Combining stem with flared flag down - std::pair( "mensuralCombStemDownFlagFusa", 0xE94C ), // glyphnumber: 1365, Combining stem with fusa flag down - std::pair( "mensuralCombStemDownFlagLeft", 0xE944 ), // glyphnumber: 1366, Combining stem with flag left down - std::pair( "mensuralCombStemDownFlagRight", 0xE942 ), // glyphnumber: 1367, Combining stem with flag right down - std::pair( "mensuralCombStemDownFlagSemiminima", 0xE94A ), // glyphnumber: 1368, Combining stem with semiminima flag down - std::pair( "mensuralCombStemUp", 0xE93E ), // glyphnumber: 1369, Combining stem up - std::pair( "mensuralCombStemUpFlagExtended", 0xE947 ), // glyphnumber: 1370, Combining stem with extended flag up - std::pair( "mensuralCombStemUpFlagFlared", 0xE945 ), // glyphnumber: 1371, Combining stem with flared flag up - std::pair( "mensuralCombStemUpFlagFusa", 0xE94B ), // glyphnumber: 1372, Combining stem with fusa flag up - std::pair( "mensuralCombStemUpFlagLeft", 0xE943 ), // glyphnumber: 1373, Combining stem with flag left up - std::pair( "mensuralCombStemUpFlagRight", 0xE941 ), // glyphnumber: 1374, Combining stem with flag right up - std::pair( "mensuralCombStemUpFlagSemiminima", 0xE949 ), // glyphnumber: 1375, Combining stem with semiminima flag up - std::pair( "mensuralCustosCheckmark", 0xEA0A ), // glyphnumber: 1376, Checkmark custos - std::pair( "mensuralCustosDown", 0xEA03 ), // glyphnumber: 1377, Mensural custos down - std::pair( "mensuralCustosTurn", 0xEA0B ), // glyphnumber: 1378, Turn-like custos - std::pair( "mensuralCustosUp", 0xEA02 ), // glyphnumber: 1379, Mensural custos up - std::pair( "mensuralFclef", 0xE903 ), // glyphnumber: 1380, Mensural F clef - std::pair( "mensuralFclefPetrucci", 0xE904 ), // glyphnumber: 1381, Petrucci F clef - std::pair( "mensuralGclef", 0xE900 ), // glyphnumber: 1382, Mensural G clef - std::pair( "mensuralGclefPetrucci", 0xE901 ), // glyphnumber: 1383, Petrucci G clef - std::pair( "mensuralModusImperfectumVert", 0xE92D ), // glyphnumber: 1384, Modus imperfectum, vertical - std::pair( "mensuralModusPerfectumVert", 0xE92C ), // glyphnumber: 1385, Modus perfectum, vertical - std::pair( "mensuralNoteheadLongaBlack", 0xE934 ), // glyphnumber: 1386, Longa/brevis notehead, black - std::pair( "mensuralNoteheadLongaBlackVoid", 0xE936 ), // glyphnumber: 1387, Longa/brevis notehead, black and void - std::pair( "mensuralNoteheadLongaVoid", 0xE935 ), // glyphnumber: 1388, Longa/brevis notehead, void - std::pair( "mensuralNoteheadLongaWhite", 0xE937 ), // glyphnumber: 1389, Longa/brevis notehead, white - std::pair( "mensuralNoteheadMaximaBlack", 0xE930 ), // glyphnumber: 1390, Maxima notehead, black - std::pair( "mensuralNoteheadMaximaBlackVoid", 0xE932 ), // glyphnumber: 1391, Maxima notehead, black and void - std::pair( "mensuralNoteheadMaximaVoid", 0xE931 ), // glyphnumber: 1392, Maxima notehead, void - std::pair( "mensuralNoteheadMaximaWhite", 0xE933 ), // glyphnumber: 1393, Maxima notehead, white - std::pair( "mensuralNoteheadMinimaWhite", 0xE93C ), // glyphnumber: 1394, Minima notehead, white - std::pair( "mensuralNoteheadSemibrevisBlack", 0xE938 ), // glyphnumber: 1395, Semibrevis notehead, black - std::pair( "mensuralNoteheadSemibrevisBlackVoid", 0xE93A ), // glyphnumber: 1396, Semibrevis notehead, black and void - std::pair( "mensuralNoteheadSemibrevisBlackVoidTurned", 0xE93B ), // glyphnumber: 1397, Semibrevis notehead, black and void (turned) - std::pair( "mensuralNoteheadSemibrevisVoid", 0xE939 ), // glyphnumber: 1398, Semibrevis notehead, void - std::pair( "mensuralNoteheadSemiminimaWhite", 0xE93D ), // glyphnumber: 1399, Semiminima/fusa notehead, white - std::pair( "mensuralObliqueAsc2ndBlack", 0xE970 ), // glyphnumber: 1400, Oblique form, ascending 2nd, black - std::pair( "mensuralObliqueAsc2ndBlackVoid", 0xE972 ), // glyphnumber: 1401, Oblique form, ascending 2nd, black and void - std::pair( "mensuralObliqueAsc2ndVoid", 0xE971 ), // glyphnumber: 1402, Oblique form, ascending 2nd, void - std::pair( "mensuralObliqueAsc2ndWhite", 0xE973 ), // glyphnumber: 1403, Oblique form, ascending 2nd, white - std::pair( "mensuralObliqueAsc3rdBlack", 0xE974 ), // glyphnumber: 1404, Oblique form, ascending 3rd, black - std::pair( "mensuralObliqueAsc3rdBlackVoid", 0xE976 ), // glyphnumber: 1405, Oblique form, ascending 3rd, black and void - std::pair( "mensuralObliqueAsc3rdVoid", 0xE975 ), // glyphnumber: 1406, Oblique form, ascending 3rd, void - std::pair( "mensuralObliqueAsc3rdWhite", 0xE977 ), // glyphnumber: 1407, Oblique form, ascending 3rd, white - std::pair( "mensuralObliqueAsc4thBlack", 0xE978 ), // glyphnumber: 1408, Oblique form, ascending 4th, black - std::pair( "mensuralObliqueAsc4thBlackVoid", 0xE97A ), // glyphnumber: 1409, Oblique form, ascending 4th, black and void - std::pair( "mensuralObliqueAsc4thVoid", 0xE979 ), // glyphnumber: 1410, Oblique form, ascending 4th, void - std::pair( "mensuralObliqueAsc4thWhite", 0xE97B ), // glyphnumber: 1411, Oblique form, ascending 4th, white - std::pair( "mensuralObliqueAsc5thBlack", 0xE97C ), // glyphnumber: 1412, Oblique form, ascending 5th, black - std::pair( "mensuralObliqueAsc5thBlackVoid", 0xE97E ), // glyphnumber: 1413, Oblique form, ascending 5th, black and void - std::pair( "mensuralObliqueAsc5thVoid", 0xE97D ), // glyphnumber: 1414, Oblique form, ascending 5th, void - std::pair( "mensuralObliqueAsc5thWhite", 0xE97F ), // glyphnumber: 1415, Oblique form, ascending 5th, white - std::pair( "mensuralObliqueDesc2ndBlack", 0xE980 ), // glyphnumber: 1416, Oblique form, descending 2nd, black - std::pair( "mensuralObliqueDesc2ndBlackVoid", 0xE982 ), // glyphnumber: 1417, Oblique form, descending 2nd, black and void - std::pair( "mensuralObliqueDesc2ndVoid", 0xE981 ), // glyphnumber: 1418, Oblique form, descending 2nd, void - std::pair( "mensuralObliqueDesc2ndWhite", 0xE983 ), // glyphnumber: 1419, Oblique form, descending 2nd, white - std::pair( "mensuralObliqueDesc3rdBlack", 0xE984 ), // glyphnumber: 1420, Oblique form, descending 3rd, black - std::pair( "mensuralObliqueDesc3rdBlackVoid", 0xE986 ), // glyphnumber: 1421, Oblique form, descending 3rd, black and void - std::pair( "mensuralObliqueDesc3rdVoid", 0xE985 ), // glyphnumber: 1422, Oblique form, descending 3rd, void - std::pair( "mensuralObliqueDesc3rdWhite", 0xE987 ), // glyphnumber: 1423, Oblique form, descending 3rd, white - std::pair( "mensuralObliqueDesc4thBlack", 0xE988 ), // glyphnumber: 1424, Oblique form, descending 4th, black - std::pair( "mensuralObliqueDesc4thBlackVoid", 0xE98A ), // glyphnumber: 1425, Oblique form, descending 4th, black and void - std::pair( "mensuralObliqueDesc4thVoid", 0xE989 ), // glyphnumber: 1426, Oblique form, descending 4th, void - std::pair( "mensuralObliqueDesc4thWhite", 0xE98B ), // glyphnumber: 1427, Oblique form, descending 4th, white - std::pair( "mensuralObliqueDesc5thBlack", 0xE98C ), // glyphnumber: 1428, Oblique form, descending 5th, black - std::pair( "mensuralObliqueDesc5thBlackVoid", 0xE98E ), // glyphnumber: 1429, Oblique form, descending 5th, black and void - std::pair( "mensuralObliqueDesc5thVoid", 0xE98D ), // glyphnumber: 1430, Oblique form, descending 5th, void - std::pair( "mensuralObliqueDesc5thWhite", 0xE98F ), // glyphnumber: 1431, Oblique form, descending 5th, white - std::pair( "mensuralProlation1", 0xE910 ), // glyphnumber: 1432, Tempus perfectum cum prolatione perfecta (9/8) - std::pair( "mensuralProlation10", 0xE919 ), // glyphnumber: 1433, Tempus imperfectum cum prolatione imperfecta diminution 4 - std::pair( "mensuralProlation11", 0xE91A ), // glyphnumber: 1434, Tempus imperfectum cum prolatione imperfecta diminution 5 - std::pair( "mensuralProlation2", 0xE911 ), // glyphnumber: 1435, Tempus perfectum cum prolatione imperfecta (3/4) - std::pair( "mensuralProlation3", 0xE912 ), // glyphnumber: 1436, Tempus perfectum cum prolatione imperfecta diminution 1 (3/8) - std::pair( "mensuralProlation4", 0xE913 ), // glyphnumber: 1437, Tempus perfectum cum prolatione perfecta diminution 2 (9/16) - std::pair( "mensuralProlation5", 0xE914 ), // glyphnumber: 1438, Tempus imperfectum cum prolatione perfecta (6/8) - std::pair( "mensuralProlation6", 0xE915 ), // glyphnumber: 1439, Tempus imperfectum cum prolatione imperfecta (2/4) - std::pair( "mensuralProlation7", 0xE916 ), // glyphnumber: 1440, Tempus imperfectum cum prolatione imperfecta diminution 1 (2/2) - std::pair( "mensuralProlation8", 0xE917 ), // glyphnumber: 1441, Tempus imperfectum cum prolatione imperfecta diminution 2 (6/16) - std::pair( "mensuralProlation9", 0xE918 ), // glyphnumber: 1442, Tempus imperfectum cum prolatione imperfecta diminution 3 (2/2) - std::pair( "mensuralProlationCombiningDot", 0xE920 ), // glyphnumber: 1443, Combining dot - std::pair( "mensuralProlationCombiningDotVoid", 0xE924 ), // glyphnumber: 1444, Combining void dot - std::pair( "mensuralProlationCombiningStroke", 0xE925 ), // glyphnumber: 1445, Combining vertical stroke - std::pair( "mensuralProlationCombiningThreeDots", 0xE922 ), // glyphnumber: 1446, Combining three dots horizontal - std::pair( "mensuralProlationCombiningThreeDotsTri", 0xE923 ), // glyphnumber: 1447, Combining three dots triangular - std::pair( "mensuralProlationCombiningTwoDots", 0xE921 ), // glyphnumber: 1448, Combining two dots - std::pair( "mensuralProportion1", 0xE926 ), // glyphnumber: 1449, Mensural proportion 1 - std::pair( "mensuralProportion2", 0xE927 ), // glyphnumber: 1450, Mensural proportion 2 - std::pair( "mensuralProportion3", 0xE928 ), // glyphnumber: 1451, Mensural proportion 3 - std::pair( "mensuralProportion4", 0xE929 ), // glyphnumber: 1452, Mensural proportion 4 - std::pair( "mensuralProportionMajor", 0xE92B ), // glyphnumber: 1453, Mensural proportion major - std::pair( "mensuralProportionMinor", 0xE92A ), // glyphnumber: 1454, Mensural proportion minor - std::pair( "mensuralProportionProportioDupla1", 0xE91C ), // glyphnumber: 1455, Proportio dupla 1 - std::pair( "mensuralProportionProportioDupla2", 0xE91D ), // glyphnumber: 1456, Proportio dupla 2 - std::pair( "mensuralProportionProportioQuadrupla", 0xE91F ), // glyphnumber: 1457, Proportio quadrupla - std::pair( "mensuralProportionProportioTripla", 0xE91E ), // glyphnumber: 1458, Proportio tripla - std::pair( "mensuralProportionTempusPerfectum", 0xE91B ), // glyphnumber: 1459, Tempus perfectum - std::pair( "mensuralRestBrevis", 0xE9F3 ), // glyphnumber: 1460, Brevis rest - std::pair( "mensuralRestFusa", 0xE9F7 ), // glyphnumber: 1461, Fusa rest - std::pair( "mensuralRestLongaImperfecta", 0xE9F2 ), // glyphnumber: 1462, Longa imperfecta rest - std::pair( "mensuralRestLongaPerfecta", 0xE9F1 ), // glyphnumber: 1463, Longa perfecta rest - std::pair( "mensuralRestMaxima", 0xE9F0 ), // glyphnumber: 1464, Maxima rest - std::pair( "mensuralRestMinima", 0xE9F5 ), // glyphnumber: 1465, Minima rest - std::pair( "mensuralRestSemibrevis", 0xE9F4 ), // glyphnumber: 1466, Semibrevis rest - std::pair( "mensuralRestSemifusa", 0xE9F8 ), // glyphnumber: 1467, Semifusa rest - std::pair( "mensuralRestSemiminima", 0xE9F6 ), // glyphnumber: 1468, Semiminima rest - std::pair( "mensuralSignumDown", 0xEA01 ), // glyphnumber: 1469, Signum congruentiae down - std::pair( "mensuralSignumUp", 0xEA00 ), // glyphnumber: 1470, Signum congruentiae up - std::pair( "mensuralTempusImperfectumHoriz", 0xE92F ), // glyphnumber: 1471, Tempus imperfectum, horizontal - std::pair( "mensuralTempusPerfectumHoriz", 0xE92E ), // glyphnumber: 1472, Tempus perfectum, horizontal - std::pair( "mensuralWhiteBrevis", 0xE95E ), // glyphnumber: 1473, White mensural brevis - std::pair( "mensuralWhiteFusa", 0xE961 ), // glyphnumber: 1474, White mensural fusa - std::pair( "mensuralWhiteLonga", 0xE95D ), // glyphnumber: 1475, White mensural longa - std::pair( "mensuralWhiteMaxima", 0xE95C ), // glyphnumber: 1476, White mensural maxima - std::pair( "mensuralWhiteMinima", 0xE95F ), // glyphnumber: 1477, White mensural minima - std::pair( "mensuralWhiteSemiminima", 0xE960 ), // glyphnumber: 1478, White mensural semiminima - std::pair( "metAugmentationDot", 0xECB7 ), // glyphnumber: 1479, Augmentation dot - std::pair( "metNote1024thDown", 0xECB6 ), // glyphnumber: 1480, 1024th note (semihemidemisemihemidemisemiquaver) stem down - std::pair( "metNote1024thUp", 0xECB5 ), // glyphnumber: 1481, 1024th note (semihemidemisemihemidemisemiquaver) stem up - std::pair( "metNote128thDown", 0xECB0 ), // glyphnumber: 1482, 128th note (semihemidemisemiquaver) stem down - std::pair( "metNote128thUp", 0xECAF ), // glyphnumber: 1483, 128th note (semihemidemisemiquaver) stem up - std::pair( "metNote16thDown", 0xECAA ), // glyphnumber: 1484, 16th note (semiquaver) stem down - std::pair( "metNote16thUp", 0xECA9 ), // glyphnumber: 1485, 16th note (semiquaver) stem up - std::pair( "metNote256thDown", 0xECB2 ), // glyphnumber: 1486, 256th note (demisemihemidemisemiquaver) stem down - std::pair( "metNote256thUp", 0xECB1 ), // glyphnumber: 1487, 256th note (demisemihemidemisemiquaver) stem up - std::pair( "metNote32ndDown", 0xECAC ), // glyphnumber: 1488, 32nd note (demisemiquaver) stem down - std::pair( "metNote32ndUp", 0xECAB ), // glyphnumber: 1489, 32nd note (demisemiquaver) stem up - std::pair( "metNote512thDown", 0xECB4 ), // glyphnumber: 1490, 512th note (hemidemisemihemidemisemiquaver) stem down - std::pair( "metNote512thUp", 0xECB3 ), // glyphnumber: 1491, 512th note (hemidemisemihemidemisemiquaver) stem up - std::pair( "metNote64thDown", 0xECAE ), // glyphnumber: 1492, 64th note (hemidemisemiquaver) stem down - std::pair( "metNote64thUp", 0xECAD ), // glyphnumber: 1493, 64th note (hemidemisemiquaver) stem up - std::pair( "metNote8thDown", 0xECA8 ), // glyphnumber: 1494, Eighth note (quaver) stem down - std::pair( "metNote8thUp", 0xECA7 ), // glyphnumber: 1495, Eighth note (quaver) stem up - std::pair( "metNoteDoubleWhole", 0xECA0 ), // glyphnumber: 1496, Double whole note (breve) - std::pair( "metNoteDoubleWholeSquare", 0xECA1 ), // glyphnumber: 1497, Double whole note (square) - std::pair( "metNoteHalfDown", 0xECA4 ), // glyphnumber: 1498, Half note (minim) stem down - std::pair( "metNoteHalfUp", 0xECA3 ), // glyphnumber: 1499, Half note (minim) stem up - std::pair( "metNoteQuarterDown", 0xECA6 ), // glyphnumber: 1500, Quarter note (crotchet) stem down - std::pair( "metNoteQuarterUp", 0xECA5 ), // glyphnumber: 1501, Quarter note (crotchet) stem up - std::pair( "metNoteWhole", 0xECA2 ), // glyphnumber: 1502, Whole note (semibreve) - std::pair( "metricModulationArrowLeft", 0xEC63 ), // glyphnumber: 1503, Left-pointing arrow for metric modulation - std::pair( "metricModulationArrowRight", 0xEC64 ), // glyphnumber: 1504, Right-pointing arrow for metric modulation - std::pair( "miscDoNotCopy", 0xEC61 ), // glyphnumber: 1505, Do not copy - std::pair( "miscDoNotPhotocopy", 0xEC60 ), // glyphnumber: 1506, Do not photocopy - std::pair( "miscEyeglasses", 0xEC62 ), // glyphnumber: 1507, Eyeglasses - std::pair( "note1024thDown", 0xE1E6 ), // glyphnumber: 1508, 1024th note (semihemidemisemihemidemisemiquaver) stem down - std::pair( "note1024thUp", 0xE1E5 ), // glyphnumber: 1509, 1024th note (semihemidemisemihemidemisemiquaver) stem up - std::pair( "note128thDown", 0xE1E0 ), // glyphnumber: 1510, 128th note (semihemidemisemiquaver) stem down - std::pair( "note128thUp", 0xE1DF ), // glyphnumber: 1511, 128th note (semihemidemisemiquaver) stem up - std::pair( "note16thDown", 0xE1DA ), // glyphnumber: 1512, 16th note (semiquaver) stem down - std::pair( "note16thUp", 0xE1D9 ), // glyphnumber: 1513, 16th note (semiquaver) stem up - std::pair( "note256thDown", 0xE1E2 ), // glyphnumber: 1514, 256th note (demisemihemidemisemiquaver) stem down - std::pair( "note256thUp", 0xE1E1 ), // glyphnumber: 1515, 256th note (demisemihemidemisemiquaver) stem up - std::pair( "note32ndDown", 0xE1DC ), // glyphnumber: 1516, 32nd note (demisemiquaver) stem down - std::pair( "note32ndUp", 0xE1DB ), // glyphnumber: 1517, 32nd note (demisemiquaver) stem up - std::pair( "note512thDown", 0xE1E4 ), // glyphnumber: 1518, 512th note (hemidemisemihemidemisemiquaver) stem down - std::pair( "note512thUp", 0xE1E3 ), // glyphnumber: 1519, 512th note (hemidemisemihemidemisemiquaver) stem up - std::pair( "note64thDown", 0xE1DE ), // glyphnumber: 1520, 64th note (hemidemisemiquaver) stem down - std::pair( "note64thUp", 0xE1DD ), // glyphnumber: 1521, 64th note (hemidemisemiquaver) stem up - std::pair( "note8thDown", 0xE1D8 ), // glyphnumber: 1522, Eighth note (quaver) stem down - std::pair( "note8thUp", 0xE1D7 ), // glyphnumber: 1523, Eighth note (quaver) stem up - std::pair( "noteABlack", 0xE197 ), // glyphnumber: 1524, A (black note) - std::pair( "noteAFlatBlack", 0xE196 ), // glyphnumber: 1525, A flat (black note) - std::pair( "noteAFlatHalf", 0xE17F ), // glyphnumber: 1526, A flat (half note) - std::pair( "noteAFlatWhole", 0xE168 ), // glyphnumber: 1527, A flat (whole note) - std::pair( "noteAHalf", 0xE180 ), // glyphnumber: 1528, A (half note) - std::pair( "noteASharpBlack", 0xE198 ), // glyphnumber: 1529, A sharp (black note) - std::pair( "noteASharpHalf", 0xE181 ), // glyphnumber: 1530, A sharp (half note) - std::pair( "noteASharpWhole", 0xE16A ), // glyphnumber: 1531, A sharp (whole note) - std::pair( "noteAWhole", 0xE169 ), // glyphnumber: 1532, A (whole note) - std::pair( "noteBBlack", 0xE19A ), // glyphnumber: 1533, B (black note) - std::pair( "noteBFlatBlack", 0xE199 ), // glyphnumber: 1534, B flat (black note) - std::pair( "noteBFlatHalf", 0xE182 ), // glyphnumber: 1535, B flat (half note) - std::pair( "noteBFlatWhole", 0xE16B ), // glyphnumber: 1536, B flat (whole note) - std::pair( "noteBHalf", 0xE183 ), // glyphnumber: 1537, B (half note) - std::pair( "noteBSharpBlack", 0xE19B ), // glyphnumber: 1538, B sharp (black note) - std::pair( "noteBSharpHalf", 0xE184 ), // glyphnumber: 1539, B sharp (half note) - std::pair( "noteBSharpWhole", 0xE16D ), // glyphnumber: 1540, B sharp (whole note) - std::pair( "noteBWhole", 0xE16C ), // glyphnumber: 1541, B (whole note) - std::pair( "noteCBlack", 0xE19D ), // glyphnumber: 1542, C (black note) - std::pair( "noteCFlatBlack", 0xE19C ), // glyphnumber: 1543, C flat (black note) - std::pair( "noteCFlatHalf", 0xE185 ), // glyphnumber: 1544, C flat (half note) - std::pair( "noteCFlatWhole", 0xE16E ), // glyphnumber: 1545, C flat (whole note) - std::pair( "noteCHalf", 0xE186 ), // glyphnumber: 1546, C (half note) - std::pair( "noteCSharpBlack", 0xE19E ), // glyphnumber: 1547, C sharp (black note) - std::pair( "noteCSharpHalf", 0xE187 ), // glyphnumber: 1548, C sharp (half note) - std::pair( "noteCSharpWhole", 0xE170 ), // glyphnumber: 1549, C sharp (whole note) - std::pair( "noteCWhole", 0xE16F ), // glyphnumber: 1550, C (whole note) - std::pair( "noteDBlack", 0xE1A0 ), // glyphnumber: 1551, D (black note) - std::pair( "noteDFlatBlack", 0xE19F ), // glyphnumber: 1552, D flat (black note) - std::pair( "noteDFlatHalf", 0xE188 ), // glyphnumber: 1553, D flat (half note) - std::pair( "noteDFlatWhole", 0xE171 ), // glyphnumber: 1554, D flat (whole note) - std::pair( "noteDHalf", 0xE189 ), // glyphnumber: 1555, D (half note) - std::pair( "noteDSharpBlack", 0xE1A1 ), // glyphnumber: 1556, D sharp (black note) - std::pair( "noteDSharpHalf", 0xE18A ), // glyphnumber: 1557, D sharp (half note) - std::pair( "noteDSharpWhole", 0xE173 ), // glyphnumber: 1558, D sharp (whole note) - std::pair( "noteDWhole", 0xE172 ), // glyphnumber: 1559, D (whole note) - std::pair( "noteDoBlack", 0xE160 ), // glyphnumber: 1560, Do (black note) - std::pair( "noteDoHalf", 0xE158 ), // glyphnumber: 1561, Do (half note) - std::pair( "noteDoWhole", 0xE150 ), // glyphnumber: 1562, Do (whole note) - std::pair( "noteDoubleWhole", 0xE1D0 ), // glyphnumber: 1563, Double whole note (breve) - std::pair( "noteDoubleWholeSquare", 0xE1D1 ), // glyphnumber: 1564, Double whole note (square) - std::pair( "noteEBlack", 0xE1A3 ), // glyphnumber: 1565, E (black note) - std::pair( "noteEFlatBlack", 0xE1A2 ), // glyphnumber: 1566, E flat (black note) - std::pair( "noteEFlatHalf", 0xE18B ), // glyphnumber: 1567, E flat (half note) - std::pair( "noteEFlatWhole", 0xE174 ), // glyphnumber: 1568, E flat (whole note) - std::pair( "noteEHalf", 0xE18C ), // glyphnumber: 1569, E (half note) - std::pair( "noteESharpBlack", 0xE1A4 ), // glyphnumber: 1570, E sharp (black note) - std::pair( "noteESharpHalf", 0xE18D ), // glyphnumber: 1571, E sharp (half note) - std::pair( "noteESharpWhole", 0xE176 ), // glyphnumber: 1572, E sharp (whole note) - std::pair( "noteEWhole", 0xE175 ), // glyphnumber: 1573, E (whole note) - std::pair( "noteEmptyBlack", 0xE1AF ), // glyphnumber: 1574, Empty black note - std::pair( "noteEmptyHalf", 0xE1AE ), // glyphnumber: 1575, Empty half note - std::pair( "noteEmptyWhole", 0xE1AD ), // glyphnumber: 1576, Empty whole note - std::pair( "noteFBlack", 0xE1A6 ), // glyphnumber: 1577, F (black note) - std::pair( "noteFFlatBlack", 0xE1A5 ), // glyphnumber: 1578, F flat (black note) - std::pair( "noteFFlatHalf", 0xE18E ), // glyphnumber: 1579, F flat (half note) - std::pair( "noteFFlatWhole", 0xE177 ), // glyphnumber: 1580, F flat (whole note) - std::pair( "noteFHalf", 0xE18F ), // glyphnumber: 1581, F (half note) - std::pair( "noteFSharpBlack", 0xE1A7 ), // glyphnumber: 1582, F sharp (black note) - std::pair( "noteFSharpHalf", 0xE190 ), // glyphnumber: 1583, F sharp (half note) - std::pair( "noteFSharpWhole", 0xE179 ), // glyphnumber: 1584, F sharp (whole note) - std::pair( "noteFWhole", 0xE178 ), // glyphnumber: 1585, F (whole note) - std::pair( "noteFaBlack", 0xE163 ), // glyphnumber: 1586, Fa (black note) - std::pair( "noteFaHalf", 0xE15B ), // glyphnumber: 1587, Fa (half note) - std::pair( "noteFaWhole", 0xE153 ), // glyphnumber: 1588, Fa (whole note) - std::pair( "noteGBlack", 0xE1A9 ), // glyphnumber: 1589, G (black note) - std::pair( "noteGFlatBlack", 0xE1A8 ), // glyphnumber: 1590, G flat (black note) - std::pair( "noteGFlatHalf", 0xE191 ), // glyphnumber: 1591, G flat (half note) - std::pair( "noteGFlatWhole", 0xE17A ), // glyphnumber: 1592, G flat (whole note) - std::pair( "noteGHalf", 0xE192 ), // glyphnumber: 1593, G (half note) - std::pair( "noteGSharpBlack", 0xE1AA ), // glyphnumber: 1594, G sharp (black note) - std::pair( "noteGSharpHalf", 0xE193 ), // glyphnumber: 1595, G sharp (half note) - std::pair( "noteGSharpWhole", 0xE17C ), // glyphnumber: 1596, G sharp (whole note) - std::pair( "noteGWhole", 0xE17B ), // glyphnumber: 1597, G (whole note) - std::pair( "noteHBlack", 0xE1AB ), // glyphnumber: 1598, H (black note) - std::pair( "noteHHalf", 0xE194 ), // glyphnumber: 1599, H (half note) - std::pair( "noteHSharpBlack", 0xE1AC ), // glyphnumber: 1600, H sharp (black note) - std::pair( "noteHSharpHalf", 0xE195 ), // glyphnumber: 1601, H sharp (half note) - std::pair( "noteHSharpWhole", 0xE17E ), // glyphnumber: 1602, H sharp (whole note) - std::pair( "noteHWhole", 0xE17D ), // glyphnumber: 1603, H (whole note) - std::pair( "noteHalfDown", 0xE1D4 ), // glyphnumber: 1604, Half note (minim) stem down - std::pair( "noteHalfUp", 0xE1D3 ), // glyphnumber: 1605, Half note (minim) stem up - std::pair( "noteLaBlack", 0xE165 ), // glyphnumber: 1606, La (black note) - std::pair( "noteLaHalf", 0xE15D ), // glyphnumber: 1607, La (half note) - std::pair( "noteLaWhole", 0xE155 ), // glyphnumber: 1608, La (whole note) - std::pair( "noteMiBlack", 0xE162 ), // glyphnumber: 1609, Mi (black note) - std::pair( "noteMiHalf", 0xE15A ), // glyphnumber: 1610, Mi (half note) - std::pair( "noteMiWhole", 0xE152 ), // glyphnumber: 1611, Mi (whole note) - std::pair( "noteQuarterDown", 0xE1D6 ), // glyphnumber: 1612, Quarter note (crotchet) stem down - std::pair( "noteQuarterUp", 0xE1D5 ), // glyphnumber: 1613, Quarter note (crotchet) stem up - std::pair( "noteReBlack", 0xE161 ), // glyphnumber: 1614, Re (black note) - std::pair( "noteReHalf", 0xE159 ), // glyphnumber: 1615, Re (half note) - std::pair( "noteReWhole", 0xE151 ), // glyphnumber: 1616, Re (whole note) - std::pair( "noteShapeArrowheadLeftBlack", 0xE1C9 ), // glyphnumber: 1617, Arrowhead left black (Funk 7-shape re) - std::pair( "noteShapeArrowheadLeftDoubleWhole", 0xECDC ), // glyphnumber: 1618, Arrowhead left double whole (Funk 7-shape re) - std::pair( "noteShapeArrowheadLeftWhite", 0xE1C8 ), // glyphnumber: 1619, Arrowhead left white (Funk 7-shape re) - std::pair( "noteShapeDiamondBlack", 0xE1B9 ), // glyphnumber: 1620, Diamond black (4-shape mi; 7-shape mi) - std::pair( "noteShapeDiamondDoubleWhole", 0xECD4 ), // glyphnumber: 1621, Diamond double whole (4-shape mi; 7-shape mi) - std::pair( "noteShapeDiamondWhite", 0xE1B8 ), // glyphnumber: 1622, Diamond white (4-shape mi; 7-shape mi) - std::pair( "noteShapeIsoscelesTriangleBlack", 0xE1C5 ), // glyphnumber: 1623, Isosceles triangle black (Walker 7-shape ti) - std::pair( "noteShapeIsoscelesTriangleDoubleWhole", 0xECDA ), // glyphnumber: 1624, Isosceles triangle double whole (Walker 7-shape ti) - std::pair( "noteShapeIsoscelesTriangleWhite", 0xE1C4 ), // glyphnumber: 1625, Isosceles triangle white (Walker 7-shape ti) - std::pair( "noteShapeKeystoneBlack", 0xE1C1 ), // glyphnumber: 1626, Inverted keystone black (Walker 7-shape do) - std::pair( "noteShapeKeystoneDoubleWhole", 0xECD8 ), // glyphnumber: 1627, Inverted keystone double whole (Walker 7-shape do) - std::pair( "noteShapeKeystoneWhite", 0xE1C0 ), // glyphnumber: 1628, Inverted keystone white (Walker 7-shape do) - std::pair( "noteShapeMoonBlack", 0xE1BD ), // glyphnumber: 1629, Moon black (Aikin 7-shape re) - std::pair( "noteShapeMoonDoubleWhole", 0xECD6 ), // glyphnumber: 1630, Moon double whole (Aikin 7-shape re) - std::pair( "noteShapeMoonLeftBlack", 0xE1C7 ), // glyphnumber: 1631, Moon left black (Funk 7-shape do) - std::pair( "noteShapeMoonLeftDoubleWhole", 0xECDB ), // glyphnumber: 1632, Moon left double whole (Funk 7-shape do) - std::pair( "noteShapeMoonLeftWhite", 0xE1C6 ), // glyphnumber: 1633, Moon left white (Funk 7-shape do) - std::pair( "noteShapeMoonWhite", 0xE1BC ), // glyphnumber: 1634, Moon white (Aikin 7-shape re) - std::pair( "noteShapeQuarterMoonBlack", 0xE1C3 ), // glyphnumber: 1635, Quarter moon black (Walker 7-shape re) - std::pair( "noteShapeQuarterMoonDoubleWhole", 0xECD9 ), // glyphnumber: 1636, Quarter moon double whole (Walker 7-shape re) - std::pair( "noteShapeQuarterMoonWhite", 0xE1C2 ), // glyphnumber: 1637, Quarter moon white (Walker 7-shape re) - std::pair( "noteShapeRoundBlack", 0xE1B1 ), // glyphnumber: 1638, Round black (4-shape sol; 7-shape so) - std::pair( "noteShapeRoundDoubleWhole", 0xECD0 ), // glyphnumber: 1639, Round double whole (4-shape sol; 7-shape so) - std::pair( "noteShapeRoundWhite", 0xE1B0 ), // glyphnumber: 1640, Round white (4-shape sol; 7-shape so) - std::pair( "noteShapeSquareBlack", 0xE1B3 ), // glyphnumber: 1641, Square black (4-shape la; Aikin 7-shape la) - std::pair( "noteShapeSquareDoubleWhole", 0xECD1 ), // glyphnumber: 1642, Square double whole (4-shape la; Aikin 7-shape la) - std::pair( "noteShapeSquareWhite", 0xE1B2 ), // glyphnumber: 1643, Square white (4-shape la; Aikin 7-shape la) - std::pair( "noteShapeTriangleLeftBlack", 0xE1B7 ), // glyphnumber: 1644, Triangle left black (stem up; 4-shape fa; 7-shape fa) - std::pair( "noteShapeTriangleLeftDoubleWhole", 0xECD3 ), // glyphnumber: 1645, Triangle left double whole (stem up; 4-shape fa; 7-shape fa) - std::pair( "noteShapeTriangleLeftWhite", 0xE1B6 ), // glyphnumber: 1646, Triangle left white (stem up; 4-shape fa; 7-shape fa) - std::pair( "noteShapeTriangleRightBlack", 0xE1B5 ), // glyphnumber: 1647, Triangle right black (stem down; 4-shape fa; 7-shape fa) - std::pair( "noteShapeTriangleRightDoubleWhole", 0xECD2 ), // glyphnumber: 1648, Triangle right double whole (stem down; 4-shape fa; 7-shape fa) - std::pair( "noteShapeTriangleRightWhite", 0xE1B4 ), // glyphnumber: 1649, Triangle right white (stem down; 4-shape fa; 7-shape fa) - std::pair( "noteShapeTriangleRoundBlack", 0xE1BF ), // glyphnumber: 1650, Triangle-round black (Aikin 7-shape ti) - std::pair( "noteShapeTriangleRoundDoubleWhole", 0xECD7 ), // glyphnumber: 1651, Triangle-round white (Aikin 7-shape ti) - std::pair( "noteShapeTriangleRoundLeftBlack", 0xE1CB ), // glyphnumber: 1652, Triangle-round left black (Funk 7-shape ti) - std::pair( "noteShapeTriangleRoundLeftDoubleWhole", 0xECDD ), // glyphnumber: 1653, Triangle-round left double whole (Funk 7-shape ti) - std::pair( "noteShapeTriangleRoundLeftWhite", 0xE1CA ), // glyphnumber: 1654, Triangle-round left white (Funk 7-shape ti) - std::pair( "noteShapeTriangleRoundWhite", 0xE1BE ), // glyphnumber: 1655, Triangle-round white (Aikin 7-shape ti) - std::pair( "noteShapeTriangleUpBlack", 0xE1BB ), // glyphnumber: 1656, Triangle up black (Aikin 7-shape do) - std::pair( "noteShapeTriangleUpDoubleWhole", 0xECD5 ), // glyphnumber: 1657, Triangle up double whole (Aikin 7-shape do) - std::pair( "noteShapeTriangleUpWhite", 0xE1BA ), // glyphnumber: 1658, Triangle up white (Aikin 7-shape do) - std::pair( "noteSiBlack", 0xE167 ), // glyphnumber: 1659, Si (black note) - std::pair( "noteSiHalf", 0xE15F ), // glyphnumber: 1660, Si (half note) - std::pair( "noteSiWhole", 0xE157 ), // glyphnumber: 1661, Si (whole note) - std::pair( "noteSoBlack", 0xE164 ), // glyphnumber: 1662, So (black note) - std::pair( "noteSoHalf", 0xE15C ), // glyphnumber: 1663, So (half note) - - std::pair( "noteSoWhole", 0xE154 ), // glyphnumber: 1664, So (whole note) - - std::pair( "noteSoWhole", 0xE154 ), // glyphnumber: 1664, So (whole note) - std::pair( "noteTiBlack", 0xE166 ), // glyphnumber: 1665, Ti (black note) - std::pair( "noteTiHalf", 0xE15E ), // glyphnumber: 1666, Ti (half note) - std::pair( "noteTiWhole", 0xE156 ), // glyphnumber: 1667, Ti (whole note) - std::pair( "noteWhole", 0xE1D2 ), // glyphnumber: 1668, Whole note (semibreve) - std::pair( "noteheadBlack", 0xE0A4 ), // glyphnumber: 1669, Black notehead - std::pair( "noteheadCircleSlash", 0xE0F7 ), // glyphnumber: 1670, Circle slash notehead - std::pair( "noteheadCircleX", 0xE0B3 ), // glyphnumber: 1671, Circle X notehead - std::pair( "noteheadCircleXDoubleWhole", 0xE0B0 ), // glyphnumber: 1672, Circle X double whole - std::pair( "noteheadCircleXHalf", 0xE0B2 ), // glyphnumber: 1673, Circle X half - std::pair( "noteheadCircleXWhole", 0xE0B1 ), // glyphnumber: 1674, Circle X whole - std::pair( "noteheadCircledBlack", 0xE0E4 ), // glyphnumber: 1675, Circled black notehead - std::pair( "noteheadCircledBlackLarge", 0xE0E8 ), // glyphnumber: 1676, Black notehead in large circle - std::pair( "noteheadCircledDoubleWhole", 0xE0E7 ), // glyphnumber: 1677, Circled double whole notehead - std::pair( "noteheadCircledDoubleWholeLarge", 0xE0EB ), // glyphnumber: 1678, Double whole notehead in large circle - std::pair( "noteheadCircledHalf", 0xE0E5 ), // glyphnumber: 1679, Circled half notehead - std::pair( "noteheadCircledHalfLarge", 0xE0E9 ), // glyphnumber: 1680, Half notehead in large circle - std::pair( "noteheadCircledWhole", 0xE0E6 ), // glyphnumber: 1681, Circled whole notehead - std::pair( "noteheadCircledWholeLarge", 0xE0EA ), // glyphnumber: 1682, Whole notehead in large circle - std::pair( "noteheadCircledXLarge", 0xE0EC ), // glyphnumber: 1683, Cross notehead in large circle - std::pair( "noteheadClusterDoubleWhole2nd", 0xE124 ), // glyphnumber: 1684, Double whole note cluster, 2nd - std::pair( "noteheadClusterDoubleWhole3rd", 0xE128 ), // glyphnumber: 1685, Double whole note cluster, 3rd - std::pair( "noteheadClusterDoubleWholeBottom", 0xE12E ), // glyphnumber: 1686, Combining double whole note cluster, bottom - std::pair( "noteheadClusterDoubleWholeMiddle", 0xE12D ), // glyphnumber: 1687, Combining double whole note cluster, middle - std::pair( "noteheadClusterDoubleWholeTop", 0xE12C ), // glyphnumber: 1688, Combining double whole note cluster, top - std::pair( "noteheadClusterHalf2nd", 0xE126 ), // glyphnumber: 1689, Half note cluster, 2nd - std::pair( "noteheadClusterHalf3rd", 0xE12A ), // glyphnumber: 1690, Half note cluster, 3rd - std::pair( "noteheadClusterHalfBottom", 0xE134 ), // glyphnumber: 1691, Combining half note cluster, bottom - std::pair( "noteheadClusterHalfMiddle", 0xE133 ), // glyphnumber: 1692, Combining half note cluster, middle - std::pair( "noteheadClusterHalfTop", 0xE132 ), // glyphnumber: 1693, Combining half note cluster, top - std::pair( "noteheadClusterQuarter2nd", 0xE127 ), // glyphnumber: 1694, Quarter note cluster, 2nd - std::pair( "noteheadClusterQuarter3rd", 0xE12B ), // glyphnumber: 1695, Quarter note cluster, 3rd - std::pair( "noteheadClusterQuarterBottom", 0xE137 ), // glyphnumber: 1696, Combining quarter note cluster, bottom - std::pair( "noteheadClusterQuarterMiddle", 0xE136 ), // glyphnumber: 1697, Combining quarter note cluster, middle - std::pair( "noteheadClusterQuarterTop", 0xE135 ), // glyphnumber: 1698, Combining quarter note cluster, top - std::pair( "noteheadClusterRoundBlack", 0xE123 ), // glyphnumber: 1699, Cluster notehead black (round) - std::pair( "noteheadClusterRoundWhite", 0xE122 ), // glyphnumber: 1700, Cluster notehead white (round) - std::pair( "noteheadClusterSquareBlack", 0xE121 ), // glyphnumber: 1701, Cluster notehead black (square) - std::pair( "noteheadClusterSquareWhite", 0xE120 ), // glyphnumber: 1702, Cluster notehead white (square) - std::pair( "noteheadClusterWhole2nd", 0xE125 ), // glyphnumber: 1703, Whole note cluster, 2nd - std::pair( "noteheadClusterWhole3rd", 0xE129 ), // glyphnumber: 1704, Whole note cluster, 3rd - std::pair( "noteheadClusterWholeBottom", 0xE131 ), // glyphnumber: 1705, Combining whole note cluster, bottom - std::pair( "noteheadClusterWholeMiddle", 0xE130 ), // glyphnumber: 1706, Combining whole note cluster, middle - std::pair( "noteheadClusterWholeTop", 0xE12F ), // glyphnumber: 1707, Combining whole note cluster, top - std::pair( "noteheadDiamondBlack", 0xE0DB ), // glyphnumber: 1708, Diamond black notehead - std::pair( "noteheadDiamondBlackOld", 0xE0E2 ), // glyphnumber: 1709, Diamond black notehead (old) - std::pair( "noteheadDiamondBlackWide", 0xE0DC ), // glyphnumber: 1710, Diamond black notehead (wide) - std::pair( "noteheadDiamondClusterBlack2nd", 0xE139 ), // glyphnumber: 1711, Black diamond cluster, 2nd - std::pair( "noteheadDiamondClusterBlack3rd", 0xE13B ), // glyphnumber: 1712, Black diamond cluster, 3rd - std::pair( "noteheadDiamondClusterBlackBottom", 0xE141 ), // glyphnumber: 1713, Combining black diamond cluster, bottom - std::pair( "noteheadDiamondClusterBlackMiddle", 0xE140 ), // glyphnumber: 1714, Combining black diamond cluster, middle - std::pair( "noteheadDiamondClusterBlackTop", 0xE13F ), // glyphnumber: 1715, Combining black diamond cluster, top - std::pair( "noteheadDiamondClusterWhite2nd", 0xE138 ), // glyphnumber: 1716, White diamond cluster, 2nd - std::pair( "noteheadDiamondClusterWhite3rd", 0xE13A ), // glyphnumber: 1717, White diamond cluster, 3rd - std::pair( "noteheadDiamondClusterWhiteBottom", 0xE13E ), // glyphnumber: 1718, Combining white diamond cluster, bottom - std::pair( "noteheadDiamondClusterWhiteMiddle", 0xE13D ), // glyphnumber: 1719, Combining white diamond cluster, middle - std::pair( "noteheadDiamondClusterWhiteTop", 0xE13C ), // glyphnumber: 1720, Combining white diamond cluster, top - std::pair( "noteheadDiamondDoubleWhole", 0xE0D7 ), // glyphnumber: 1721, Diamond double whole notehead - std::pair( "noteheadDiamondDoubleWholeOld", 0xE0DF ), // glyphnumber: 1722, Diamond double whole notehead (old) - std::pair( "noteheadDiamondHalf", 0xE0D9 ), // glyphnumber: 1723, Diamond half notehead - std::pair( "noteheadDiamondHalfFilled", 0xE0E3 ), // glyphnumber: 1724, Half-filled diamond notehead - std::pair( "noteheadDiamondHalfOld", 0xE0E1 ), // glyphnumber: 1725, Diamond half notehead (old) - std::pair( "noteheadDiamondHalfWide", 0xE0DA ), // glyphnumber: 1726, Diamond half notehead (wide) - std::pair( "noteheadDiamondOpen", 0xE0FC ), // glyphnumber: 1727, Open diamond notehead - std::pair( "noteheadDiamondWhite", 0xE0DD ), // glyphnumber: 1728, Diamond white notehead - std::pair( "noteheadDiamondWhiteWide", 0xE0DE ), // glyphnumber: 1729, Diamond white notehead (wide) - std::pair( "noteheadDiamondWhole", 0xE0D8 ), // glyphnumber: 1730, Diamond whole notehead - std::pair( "noteheadDiamondWholeOld", 0xE0E0 ), // glyphnumber: 1731, Diamond whole notehead (old) - std::pair( "noteheadDoubleWhole", 0xE0A0 ), // glyphnumber: 1732, Double whole (breve) notehead - std::pair( "noteheadDoubleWholeSquare", 0xE0A1 ), // glyphnumber: 1733, Double whole (breve) notehead (square) - std::pair( "noteheadDoubleWholeWithX", 0xE0B4 ), // glyphnumber: 1734, Double whole notehead with X - std::pair( "noteheadHalf", 0xE0A3 ), // glyphnumber: 1735, Half (minim) notehead - std::pair( "noteheadHalfFilled", 0xE0FB ), // glyphnumber: 1736, Filled half (minim) notehead - std::pair( "noteheadHalfWithX", 0xE0B6 ), // glyphnumber: 1737, Half notehead with X - std::pair( "noteheadHeavyX", 0xE0F8 ), // glyphnumber: 1738, Heavy X notehead - std::pair( "noteheadHeavyXHat", 0xE0F9 ), // glyphnumber: 1739, Heavy X with hat notehead - std::pair( "noteheadLargeArrowDownBlack", 0xE0F4 ), // glyphnumber: 1740, Large arrow down (lowest pitch) black notehead - std::pair( "noteheadLargeArrowDownDoubleWhole", 0xE0F1 ), // glyphnumber: 1741, Large arrow down (lowest pitch) double whole notehead - - std::pair( "noteheadLargeArrowDownHalf", 0xE0F3 ), // glyphnumber: 1742, Large arrow down (lowest pitch) half notehead - std::pair( "noteheadLargeArrowDownWhole", 0xE0F2 ), // glyphnumber: 1743, Large arrow down (lowest pitch) whole notehead - std::pair( "noteheadLargeArrowUpBlack", 0xE0F0 ), // glyphnumber: 1744, Large arrow up (highest pitch) black notehead - std::pair( "noteheadLargeArrowUpDoubleWhole", 0xE0ED ), // glyphnumber: 1745, Large arrow up (highest pitch) double whole notehead - std::pair( "noteheadLargeArrowUpHalf", 0xE0EF ), // glyphnumber: 1746, Large arrow up (highest pitch) half notehead - std::pair( "noteheadLargeArrowUpWhole", 0xE0EE ), // glyphnumber: 1747, Large arrow up (highest pitch) whole notehead - std::pair( "noteheadMoonBlack", 0xE0CB ), // glyphnumber: 1748, Moon notehead black - std::pair( "noteheadMoonWhite", 0xE0CA ), // glyphnumber: 1749, Moon notehead white - std::pair( "noteheadNull", 0xE0A5 ), // glyphnumber: 1750, Null notehead - std::pair( "noteheadParenthesis", 0xE0CE ), // glyphnumber: 1751, Parenthesis notehead - std::pair( "noteheadParenthesisLeft", 0xE0F5 ), // glyphnumber: 1752, Opening parenthesis - std::pair( "noteheadParenthesisRight", 0xE0F6 ), // glyphnumber: 1753, Closing parenthesis - std::pair( "noteheadPlusBlack", 0xE0AF ), // glyphnumber: 1754, Plus notehead black - std::pair( "noteheadPlusDoubleWhole", 0xE0AC ), // glyphnumber: 1755, Plus notehead double whole - std::pair( "noteheadPlusHalf", 0xE0AE ), // glyphnumber: 1756, Plus notehead half - std::pair( "noteheadPlusWhole", 0xE0AD ), // glyphnumber: 1757, Plus notehead whole - std::pair( "noteheadRectangularClusterBlackBottom", 0xE144 ), // glyphnumber: 1758, Combining black rectangular cluster, bottom - std::pair( "noteheadRectangularClusterBlackMiddle", 0xE143 ), // glyphnumber: 1759, Combining black rectangular cluster, middle - std::pair( "noteheadRectangularClusterBlackTop", 0xE142 ), // glyphnumber: 1760, Combining black rectangular cluster, top - std::pair( "noteheadRectangularClusterWhiteBottom", 0xE147 ), // glyphnumber: 1761, Combining white rectangular cluster, bottom - std::pair( "noteheadRectangularClusterWhiteMiddle", 0xE146 ), // glyphnumber: 1762, Combining white rectangular cluster, middle - std::pair( "noteheadRectangularClusterWhiteTop", 0xE145 ), // glyphnumber: 1763, Combining white rectangular cluster, top - std::pair( "noteheadRoundBlack", 0xE113 ), // glyphnumber: 1764, Round black notehead - std::pair( "noteheadRoundBlackDoubleSlashed", 0xE11C ), // glyphnumber: 1765, Round black notehead, double slashed - std::pair( "noteheadRoundBlackLarge", 0xE110 ), // glyphnumber: 1766, Large round black notehead - std::pair( "noteheadRoundBlackSlashed", 0xE118 ), // glyphnumber: 1767, Round black notehead, slashed - std::pair( "noteheadRoundBlackSlashedLarge", 0xE116 ), // glyphnumber: 1768, Large round black notehead, slashed - std::pair( "noteheadRoundWhite", 0xE114 ), // glyphnumber: 1769, Round white notehead - std::pair( "noteheadRoundWhiteDoubleSlashed", 0xE11D ), // glyphnumber: 1770, Round white notehead, double slashed - std::pair( "noteheadRoundWhiteLarge", 0xE111 ), // glyphnumber: 1771, Large round white notehead - std::pair( "noteheadRoundWhiteSlashed", 0xE119 ), // glyphnumber: 1772, Round white notehead, slashed - std::pair( "noteheadRoundWhiteSlashedLarge", 0xE117 ), // glyphnumber: 1773, Large round white notehead, slashed - std::pair( "noteheadRoundWhiteWithDot", 0xE115 ), // glyphnumber: 1774, Round white notehead with dot - std::pair( "noteheadRoundWhiteWithDotLarge", 0xE112 ), // glyphnumber: 1775, Large round white notehead with dot - std::pair( "noteheadSlashDiamondWhite", 0xE104 ), // glyphnumber: 1776, Large white diamond - std::pair( "noteheadSlashHorizontalEnds", 0xE101 ), // glyphnumber: 1777, Slash with horizontal ends - std::pair( "noteheadSlashHorizontalEndsMuted", 0xE108 ), // glyphnumber: 1778, Muted slash with horizontal ends - std::pair( "noteheadSlashVerticalEnds", 0xE100 ), // glyphnumber: 1779, Slash with vertical ends - std::pair( "noteheadSlashVerticalEndsMuted", 0xE107 ), // glyphnumber: 1780, Muted slash with vertical ends - std::pair( "noteheadSlashVerticalEndsSmall", 0xE105 ), // glyphnumber: 1781, Small slash with vertical ends - std::pair( "noteheadSlashWhiteDoubleWhole", 0xE10A ), // glyphnumber: 1782, White slash double whole - std::pair( "noteheadSlashWhiteHalf", 0xE103 ), // glyphnumber: 1783, White slash half - std::pair( "noteheadSlashWhiteMuted", 0xE109 ), // glyphnumber: 1784, Muted white slash - std::pair( "noteheadSlashWhiteWhole", 0xE102 ), // glyphnumber: 1785, White slash whole - std::pair( "noteheadSlashX", 0xE106 ), // glyphnumber: 1786, Large X notehead - std::pair( "noteheadSlashedBlack1", 0xE0CF ), // glyphnumber: 1787, Slashed black notehead (bottom left to top right) - std::pair( "noteheadSlashedBlack2", 0xE0D0 ), // glyphnumber: 1788, Slashed black notehead (top left to bottom right) - std::pair( "noteheadSlashedDoubleWhole1", 0xE0D5 ), // glyphnumber: 1789, Slashed double whole notehead (bottom left to top right) - std::pair( "noteheadSlashedDoubleWhole2", 0xE0D6 ), // glyphnumber: 1790, Slashed double whole notehead (top left to bottom right) - std::pair( "noteheadSlashedHalf1", 0xE0D1 ), // glyphnumber: 1791, Slashed half notehead (bottom left to top right) - std::pair( "noteheadSlashedHalf2", 0xE0D2 ), // glyphnumber: 1792, Slashed half notehead (top left to bottom right) - std::pair( "noteheadSlashedWhole1", 0xE0D3 ), // glyphnumber: 1793, Slashed whole notehead (bottom left to top right) - std::pair( "noteheadSlashedWhole2", 0xE0D4 ), // glyphnumber: 1794, Slashed whole notehead (top left to bottom right) - std::pair( "noteheadSquareBlack", 0xE0B9 ), // glyphnumber: 1795, Square notehead black - std::pair( "noteheadSquareBlackLarge", 0xE11A ), // glyphnumber: 1796, Large square black notehead - std::pair( "noteheadSquareBlackWhite", 0xE11B ), // glyphnumber: 1797, Large square white notehead - std::pair( "noteheadSquareWhite", 0xE0B8 ), // glyphnumber: 1798, Square notehead white - std::pair( "noteheadTriangleDownBlack", 0xE0C7 ), // glyphnumber: 1799, Triangle notehead down black - std::pair( "noteheadTriangleDownDoubleWhole", 0xE0C3 ), // glyphnumber: 1800, Triangle notehead down double whole - std::pair( "noteheadTriangleDownHalf", 0xE0C5 ), // glyphnumber: 1801, Triangle notehead down half - std::pair( "noteheadTriangleDownWhite", 0xE0C6 ), // glyphnumber: 1802, Triangle notehead down white - std::pair( "noteheadTriangleDownWhole", 0xE0C4 ), // glyphnumber: 1803, Triangle notehead down whole - std::pair( "noteheadTriangleLeftBlack", 0xE0C0 ), // glyphnumber: 1804, Triangle notehead left black - std::pair( "noteheadTriangleLeftWhite", 0xE0BF ), // glyphnumber: 1805, Triangle notehead left white - std::pair( "noteheadTriangleRightBlack", 0xE0C2 ), // glyphnumber: 1806, Triangle notehead right black - std::pair( "noteheadTriangleRightWhite", 0xE0C1 ), // glyphnumber: 1807, Triangle notehead right white - std::pair( "noteheadTriangleRoundDownBlack", 0xE0CD ), // glyphnumber: 1808, Triangle-round notehead down black - std::pair( "noteheadTriangleRoundDownWhite", 0xE0CC ), // glyphnumber: 1809, Triangle-round notehead down white - std::pair( "noteheadTriangleUpBlack", 0xE0BE ), // glyphnumber: 1810, Triangle notehead up black - std::pair( "noteheadTriangleUpDoubleWhole", 0xE0BA ), // glyphnumber: 1811, Triangle notehead up double whole - std::pair( "noteheadTriangleUpHalf", 0xE0BC ), // glyphnumber: 1812, Triangle notehead up half - std::pair( "noteheadTriangleUpRightBlack", 0xE0C9 ), // glyphnumber: 1813, Triangle notehead up right black - std::pair( "noteheadTriangleUpRightWhite", 0xE0C8 ), // glyphnumber: 1814, Triangle notehead up right white - std::pair( "noteheadTriangleUpWhite", 0xE0BD ), // glyphnumber: 1815, Triangle notehead up white - std::pair( "noteheadTriangleUpWhole", 0xE0BB ), // glyphnumber: 1816, Triangle notehead up whole - std::pair( "noteheadVoidWithX", 0xE0B7 ), // glyphnumber: 1817, Void notehead with X - std::pair( "noteheadWhole", 0xE0A2 ), // glyphnumber: 1818, Whole (semibreve) notehead - std::pair( "noteheadWholeFilled", 0xE0FA ), // glyphnumber: 1819, Filled whole (semibreve) notehead - std::pair( "noteheadWholeWithX", 0xE0B5 ), // glyphnumber: 1820, Whole notehead with X - std::pair( "noteheadXBlack", 0xE0A9 ), // glyphnumber: 1821, X notehead black - std::pair( "noteheadXDoubleWhole", 0xE0A6 ), // glyphnumber: 1822, X notehead double whole - std::pair( "noteheadXHalf", 0xE0A8 ), // glyphnumber: 1823, X notehead half - std::pair( "noteheadXOrnate", 0xE0AA ), // glyphnumber: 1824, Ornate X notehead - std::pair( "noteheadXOrnateEllipse", 0xE0AB ), // glyphnumber: 1825, Ornate X notehead in ellipse - std::pair( "noteheadXWhole", 0xE0A7 ), // glyphnumber: 1826, X notehead whole - std::pair( "octaveBaselineA", 0xEC91 ), // glyphnumber: 1827, a (baseline) - std::pair( "octaveBaselineB", 0xEC93 ), // glyphnumber: 1828, b (baseline) - std::pair( "octaveBaselineM", 0xEC95 ), // glyphnumber: 1829, m (baseline) - std::pair( "octaveBaselineV", 0xEC97 ), // glyphnumber: 1830, v (baseline) - std::pair( "octaveBassa", 0xE51F ), // glyphnumber: 1831, Bassa - std::pair( "octaveLoco", 0xEC90 ), // glyphnumber: 1832, Loco - std::pair( "octaveParensLeft", 0xE51A ), // glyphnumber: 1833, Left parenthesis for octave signs - std::pair( "octaveParensRight", 0xE51B ), // glyphnumber: 1834, Right parenthesis for octave signs - std::pair( "octaveSuperscriptA", 0xEC92 ), // glyphnumber: 1835, a (superscript) - std::pair( "octaveSuperscriptB", 0xEC94 ), // glyphnumber: 1836, b (superscript) - std::pair( "octaveSuperscriptM", 0xEC96 ), // glyphnumber: 1837, m (superscript) - std::pair( "octaveSuperscriptV", 0xEC98 ), // glyphnumber: 1838, v (superscript) - std::pair( "ornamentBottomLeftConcaveStroke", 0xE59A ), // glyphnumber: 1839, Ornament bottom left concave stroke - std::pair( "ornamentBottomLeftConcaveStrokeLarge", 0xE59B ), // glyphnumber: 1840, Ornament bottom left concave stroke, large - std::pair( "ornamentBottomLeftConvexStroke", 0xE59C ), // glyphnumber: 1841, Ornament bottom left convex stroke - std::pair( "ornamentBottomRightConcaveStroke", 0xE5A7 ), // glyphnumber: 1842, Ornament bottom right concave stroke - std::pair( "ornamentBottomRightConvexStroke", 0xE5A8 ), // glyphnumber: 1843, Ornament bottom right convex stroke - std::pair( "ornamentComma", 0xE581 ), // glyphnumber: 1844, Comma - std::pair( "ornamentDoubleObliqueLinesAfterNote", 0xE57E ), // glyphnumber: 1845, Double oblique straight lines NW-SE - std::pair( "ornamentDoubleObliqueLinesBeforeNote", 0xE57D ), // glyphnumber: 1846, Double oblique straight lines SW-NE - std::pair( "ornamentDownCurve", 0xE578 ), // glyphnumber: 1847, Curve below - std::pair( "ornamentHaydn", 0xE56F ), // glyphnumber: 1848, Haydn ornament - std::pair( "ornamentHighLeftConcaveStroke", 0xE592 ), // glyphnumber: 1849, Ornament high left concave stroke - std::pair( "ornamentHighLeftConvexStroke", 0xE593 ), // glyphnumber: 1850, Ornament high left convex stroke - std::pair( "ornamentHighRightConcaveStroke", 0xE5A2 ), // glyphnumber: 1851, Ornament high right concave stroke - std::pair( "ornamentHighRightConvexStroke", 0xE5A3 ), // glyphnumber: 1852, Ornament high right convex stroke - std::pair( "ornamentHookAfterNote", 0xE576 ), // glyphnumber: 1853, Hook after note - std::pair( "ornamentHookBeforeNote", 0xE575 ), // glyphnumber: 1854, Hook before note - std::pair( "ornamentLeftFacingHalfCircle", 0xE572 ), // glyphnumber: 1855, Left-facing half circle - std::pair( "ornamentLeftFacingHook", 0xE574 ), // glyphnumber: 1856, Left-facing hook - std::pair( "ornamentLeftPlus", 0xE597 ), // glyphnumber: 1857, Ornament left + - std::pair( "ornamentLeftShakeT", 0xE596 ), // glyphnumber: 1858, Ornament left shake t - std::pair( "ornamentLeftVerticalStroke", 0xE594 ), // glyphnumber: 1859, Ornament left vertical stroke - std::pair( "ornamentLeftVerticalStrokeWithCross", 0xE595 ), // glyphnumber: 1860, Ornament left vertical stroke with cross (+) - std::pair( "ornamentLowLeftConcaveStroke", 0xE598 ), // glyphnumber: 1861, Ornament low left concave stroke - std::pair( "ornamentLowLeftConvexStroke", 0xE599 ), // glyphnumber: 1862, Ornament low left convex stroke - std::pair( "ornamentLowRightConcaveStroke", 0xE5A5 ), // glyphnumber: 1863, Ornament low right concave stroke - std::pair( "ornamentLowRightConvexStroke", 0xE5A6 ), // glyphnumber: 1864, Ornament low right convex stroke - std::pair( "ornamentMiddleVerticalStroke", 0xE59F ), // glyphnumber: 1865, Ornament middle vertical stroke - std::pair( "ornamentMordent", 0xE56C ), // glyphnumber: 1866, Mordent - std::pair( "ornamentMordentInverted", 0xE56D ), // glyphnumber: 1867, Inverted mordent - std::pair( "ornamentObliqueLineAfterNote", 0xE57C ), // glyphnumber: 1868, Oblique straight line NW-SE - std::pair( "ornamentObliqueLineBeforeNote", 0xE57B ), // glyphnumber: 1869, Oblique straight line SW-NE - std::pair( "ornamentObliqueLineHorizAfterNote", 0xE580 ), // glyphnumber: 1870, Oblique straight line tilted NW-SE - std::pair( "ornamentObliqueLineHorizBeforeNote", 0xE57F ), // glyphnumber: 1871, Oblique straight line tilted SW-NE - std::pair( "ornamentOriscus", 0xEA21 ), // glyphnumber: 1872, Oriscus - std::pair( "ornamentPinceCouperin", 0xE588 ), // glyphnumber: 1873, Pincé (Couperin) - std::pair( "ornamentPortDeVoixV", 0xE570 ), // glyphnumber: 1874, Port de voix - std::pair( "ornamentPrecompAppoggTrill", 0xE5B2 ), // glyphnumber: 1875, Supported appoggiatura trill - std::pair( "ornamentPrecompAppoggTrillSuffix", 0xE5B3 ), // glyphnumber: 1876, Supported appoggiatura trill with two-note suffix - std::pair( "ornamentPrecompCadence", 0xE5BE ), // glyphnumber: 1877, Cadence - std::pair( "ornamentPrecompCadenceUpperPrefix", 0xE5C1 ), // glyphnumber: 1878, Cadence with upper prefix - std::pair( "ornamentPrecompCadenceUpperPrefixTurn", 0xE5C2 ), // glyphnumber: 1879, Cadence with upper prefix and turn - std::pair( "ornamentPrecompCadenceWithTurn", 0xE5BF ), // glyphnumber: 1880, Cadence with turn - std::pair( "ornamentPrecompDescendingSlide", 0xE5B1 ), // glyphnumber: 1881, Descending slide - std::pair( "ornamentPrecompDoubleCadenceLowerPrefix", 0xE5C0 ), // glyphnumber: 1882, Double cadence with lower prefix - std::pair( "ornamentPrecompDoubleCadenceUpperPrefix", 0xE5C3 ), // glyphnumber: 1883, Double cadence with upper prefix - std::pair( "ornamentPrecompDoubleCadenceUpperPrefixTurn", 0xE5C4 ), // glyphnumber: 1884, Double cadence with upper prefix and turn - std::pair( "ornamentPrecompInvertedMordentUpperPrefix", 0xE5C7 ), // glyphnumber: 1885, Inverted mordent with upper prefix - std::pair( "ornamentPrecompMordentRelease", 0xE5C5 ), // glyphnumber: 1886, Mordent with release - std::pair( "ornamentPrecompMordentUpperPrefix", 0xE5C6 ), // glyphnumber: 1887, Mordent with upper prefix - std::pair( "ornamentPrecompPortDeVoixMordent", 0xE5BC ), // glyphnumber: 1888, Pre-beat port de voix follwed by multiple mordent (Dandrieu) - std::pair( "ornamentPrecompSlide", 0xE5B0 ), // glyphnumber: 1889, Slide - std::pair( "ornamentPrecompSlideTrillBach", 0xE5B8 ), // glyphnumber: 1890, Slide-trill with two-note suffix (J.S. Bach) - std::pair( "ornamentPrecompSlideTrillDAnglebert", 0xE5B5 ), // glyphnumber: 1891, Slide-trill (D'Anglebert) - std::pair( "ornamentPrecompSlideTrillMarpurg", 0xE5B6 ), // glyphnumber: 1892, Slide-trill with one-note suffix (Marpurg) - std::pair( "ornamentPrecompSlideTrillMuffat", 0xE5B9 ), // glyphnumber: 1893, Slide-trill (Muffat) - std::pair( "ornamentPrecompSlideTrillSuffixMuffat", 0xE5BA ), // glyphnumber: 1894, Slide-trill with two-note suffix (Muffat) - std::pair( "ornamentPrecompTrillLowerSuffix", 0xE5C8 ), // glyphnumber: 1895, Trill with lower suffix - std::pair( "ornamentPrecompTrillSuffixDandrieu", 0xE5BB ), // glyphnumber: 1896, Trill with two-note suffix (Dandrieu) - std::pair( "ornamentPrecompTrillWithMordent", 0xE5BD ), // glyphnumber: 1897, Trill with mordent - std::pair( "ornamentPrecompTurnTrillBach", 0xE5B7 ), // glyphnumber: 1898, Turn-trill with two-note suffix (J.S. Bach) - std::pair( "ornamentPrecompTurnTrillDAnglebert", 0xE5B4 ), // glyphnumber: 1899, Turn-trill (D'Anglebert) - std::pair( "ornamentQuilisma", 0xEA20 ), // glyphnumber: 1900, Quilisma - std::pair( "ornamentRightFacingHalfCircle", 0xE571 ), // glyphnumber: 1901, Right-facing half circle - std::pair( "ornamentRightFacingHook", 0xE573 ), // glyphnumber: 1902, Right-facing hook - std::pair( "ornamentRightVerticalStroke", 0xE5A4 ), // glyphnumber: 1903, Ornament right vertical stroke - std::pair( "ornamentSchleifer", 0xE587 ), // glyphnumber: 1904, Schleifer (long mordent) - std::pair( "ornamentShake3", 0xE582 ), // glyphnumber: 1905, Shake - std::pair( "ornamentShakeMuffat1", 0xE584 ), // glyphnumber: 1906, Shake (Muffat) - std::pair( "ornamentShortObliqueLineAfterNote", 0xE57A ), // glyphnumber: 1907, Short oblique straight line NW-SE - std::pair( "ornamentShortObliqueLineBeforeNote", 0xE579 ), // glyphnumber: 1908, Short oblique straight line SW-NE - std::pair( "ornamentTopLeftConcaveStroke", 0xE590 ), // glyphnumber: 1909, Ornament top left concave stroke - std::pair( "ornamentTopLeftConvexStroke", 0xE591 ), // glyphnumber: 1910, Ornament top left convex stroke - std::pair( "ornamentTopRightConcaveStroke", 0xE5A0 ), // glyphnumber: 1911, Ornament top right concave stroke - std::pair( "ornamentTopRightConvexStroke", 0xE5A1 ), // glyphnumber: 1912, Ornament top right convex stroke - std::pair( "ornamentTremblement", 0xE56E ), // glyphnumber: 1913, Tremblement - std::pair( "ornamentTremblementCouperin", 0xE589 ), // glyphnumber: 1914, Tremblement appuyé (Couperin) - std::pair( "ornamentTrill", 0xE566 ), // glyphnumber: 1915, Trill - std::pair( "ornamentTurn", 0xE567 ), // glyphnumber: 1916, Turn - std::pair( "ornamentTurnInverted", 0xE568 ), // glyphnumber: 1917, Inverted turn - std::pair( "ornamentTurnSlash", 0xE569 ), // glyphnumber: 1918, Turn with slash - std::pair( "ornamentTurnUp", 0xE56A ), // glyphnumber: 1919, Turn up - std::pair( "ornamentTurnUpS", 0xE56B ), // glyphnumber: 1920, Inverted turn up - std::pair( "ornamentUpCurve", 0xE577 ), // glyphnumber: 1921, Curve above - std::pair( "ornamentVerticalLine", 0xE583 ), // glyphnumber: 1922, Vertical line - std::pair( "ornamentZigZagLineNoRightEnd", 0xE59D ), // glyphnumber: 1923, Ornament zig-zag line without right-hand end - std::pair( "ornamentZigZagLineWithRightEnd", 0xE59E ), // glyphnumber: 1924, Ornament zig-zag line with right-hand end - std::pair( "ottava", 0xE510 ), // glyphnumber: 1925, Ottava - std::pair( "ottavaAlta", 0xE511 ), // glyphnumber: 1926, Ottava alta - std::pair( "ottavaBassa", 0xE512 ), // glyphnumber: 1927, Ottava bassa - std::pair( "ottavaBassaBa", 0xE513 ), // glyphnumber: 1928, Ottava bassa (ba) - std::pair( "ottavaBassaVb", 0xE51C ), // glyphnumber: 1929, Ottava bassa (8vb) - std::pair( "pendereckiTremolo", 0xE22B ), // glyphnumber: 1930, Penderecki unmeasured tremolo - std::pair( "pictAgogo", 0xE717 ), // glyphnumber: 1931, Agogo - std::pair( "pictAlmglocken", 0xE712 ), // glyphnumber: 1932, Almglocken - std::pair( "pictAnvil", 0xE701 ), // glyphnumber: 1933, Anvil - std::pair( "pictBambooChimes", 0xE6C3 ), // glyphnumber: 1934, Bamboo tube chimes - std::pair( "pictBambooScraper", 0xE6FB ), // glyphnumber: 1935, Bamboo scraper - std::pair( "pictBassDrum", 0xE6D4 ), // glyphnumber: 1936, Bass drum - std::pair( "pictBassDrumOnSide", 0xE6D5 ), // glyphnumber: 1937, Bass drum on side - std::pair( "pictBeaterBow", 0xE7DE ), // glyphnumber: 1938, Bow - std::pair( "pictBeaterBox", 0xE7EB ), // glyphnumber: 1939, Box for percussion beater - std::pair( "pictBeaterBrassMalletsDown", 0xE7DA ), // glyphnumber: 1940, Brass mallets down - std::pair( "pictBeaterBrassMalletsUp", 0xE7D9 ), // glyphnumber: 1941, Brass mallets up - std::pair( "pictBeaterCombiningDashedCircle", 0xE7EA ), // glyphnumber: 1942, Combining dashed circle for round beaters (plated) - std::pair( "pictBeaterCombiningParentheses", 0xE7E9 ), // glyphnumber: 1943, Combining parentheses for round beaters (padded) - std::pair( "pictBeaterDoubleBassDrumDown", 0xE7A1 ), // glyphnumber: 1944, Double bass drum stick down - std::pair( "pictBeaterDoubleBassDrumUp", 0xE7A0 ), // glyphnumber: 1945, Double bass drum stick up - std::pair( "pictBeaterFinger", 0xE7E4 ), // glyphnumber: 1946, Finger - std::pair( "pictBeaterFingernails", 0xE7E6 ), // glyphnumber: 1947, Fingernails - std::pair( "pictBeaterFist", 0xE7E5 ), // glyphnumber: 1948, Fist - std::pair( "pictBeaterGuiroScraper", 0xE7DD ), // glyphnumber: 1949, Guiro scraper - std::pair( "pictBeaterHammer", 0xE7E1 ), // glyphnumber: 1950, Hammer - std::pair( "pictBeaterHammerMetalDown", 0xE7D0 ), // glyphnumber: 1951, Metal hammer, down - std::pair( "pictBeaterHammerMetalUp", 0xE7CF ), // glyphnumber: 1952, Metal hammer, up - std::pair( "pictBeaterHammerPlasticDown", 0xE7CE ), // glyphnumber: 1953, Plastic hammer, down - std::pair( "pictBeaterHammerPlasticUp", 0xE7CD ), // glyphnumber: 1954, Plastic hammer, up - std::pair( "pictBeaterHammerWoodDown", 0xE7CC ), // glyphnumber: 1955, Wooden hammer, down - std::pair( "pictBeaterHammerWoodUp", 0xE7CB ), // glyphnumber: 1956, Wooden hammer, up - std::pair( "pictBeaterHand", 0xE7E3 ), // glyphnumber: 1957, Hand - std::pair( "pictBeaterHardBassDrumDown", 0xE79D ), // glyphnumber: 1958, Hard bass drum stick down - std::pair( "pictBeaterHardBassDrumUp", 0xE79C ), // glyphnumber: 1959, Hard bass drum stick up - std::pair( "pictBeaterHardGlockenspielDown", 0xE785 ), // glyphnumber: 1960, Hard glockenspiel stick down - std::pair( "pictBeaterHardGlockenspielLeft", 0xE787 ), // glyphnumber: 1961, Hard glockenspiel stick left - std::pair( "pictBeaterHardGlockenspielRight", 0xE786 ), // glyphnumber: 1962, Hard glockenspiel stick right - std::pair( "pictBeaterHardGlockenspielUp", 0xE784 ), // glyphnumber: 1963, Hard glockenspiel stick up - std::pair( "pictBeaterHardTimpaniDown", 0xE791 ), // glyphnumber: 1964, Hard timpani stick down - std::pair( "pictBeaterHardTimpaniLeft", 0xE793 ), // glyphnumber: 1965, Hard timpani stick left - std::pair( "pictBeaterHardTimpaniRight", 0xE792 ), // glyphnumber: 1966, Hard timpani stick right - std::pair( "pictBeaterHardTimpaniUp", 0xE790 ), // glyphnumber: 1967, Hard timpani stick up - std::pair( "pictBeaterHardXylophoneDown", 0xE779 ), // glyphnumber: 1968, Hard xylophone stick down - std::pair( "pictBeaterHardXylophoneLeft", 0xE77B ), // glyphnumber: 1969, Hard xylophone stick left - std::pair( "pictBeaterHardXylophoneRight", 0xE77A ), // glyphnumber: 1970, Hard xylophone stick right - std::pair( "pictBeaterHardXylophoneUp", 0xE778 ), // glyphnumber: 1971, Hard xylophone stick up - std::pair( "pictBeaterHardYarnDown", 0xE7AB ), // glyphnumber: 1972, Hard yarn beater down - std::pair( "pictBeaterHardYarnLeft", 0xE7AD ), // glyphnumber: 1973, Hard yarn beater left - std::pair( "pictBeaterHardYarnRight", 0xE7AC ), // glyphnumber: 1974, Hard yarn beater right - std::pair( "pictBeaterHardYarnUp", 0xE7AA ), // glyphnumber: 1975, Hard yarn beater up - std::pair( "pictBeaterJazzSticksDown", 0xE7D4 ), // glyphnumber: 1976, Jazz sticks down - std::pair( "pictBeaterJazzSticksUp", 0xE7D3 ), // glyphnumber: 1977, Jazz sticks up - std::pair( "pictBeaterKnittingNeedle", 0xE7E2 ), // glyphnumber: 1978, Knitting needle - std::pair( "pictBeaterMallet", 0xE7DF ), // glyphnumber: 1979, Chime hammer - std::pair( "pictBeaterMediumBassDrumDown", 0xE79B ), // glyphnumber: 1980, Medium bass drum stick down - std::pair( "pictBeaterMediumBassDrumUp", 0xE79A ), // glyphnumber: 1981, Medium bass drum stick up - std::pair( "pictBeaterMediumTimpaniDown", 0xE78D ), // glyphnumber: 1982, Medium timpani stick down - std::pair( "pictBeaterMediumTimpaniLeft", 0xE78F ), // glyphnumber: 1983, Medium timpani stick left - std::pair( "pictBeaterMediumTimpaniRight", 0xE78E ), // glyphnumber: 1984, Medium timpani stick right - std::pair( "pictBeaterMediumTimpaniUp", 0xE78C ), // glyphnumber: 1985, Medium timpani stick up - std::pair( "pictBeaterMediumXylophoneDown", 0xE775 ), // glyphnumber: 1986, Medium xylophone stick down - std::pair( "pictBeaterMediumXylophoneLeft", 0xE777 ), // glyphnumber: 1987, Medium xylophone stick left - std::pair( "pictBeaterMediumXylophoneRight", 0xE776 ), // glyphnumber: 1988, Medium xylophone stick right - std::pair( "pictBeaterMediumXylophoneUp", 0xE774 ), // glyphnumber: 1989, Medium xylophone stick up - std::pair( "pictBeaterMediumYarnDown", 0xE7A7 ), // glyphnumber: 1990, Medium yarn beater down - std::pair( "pictBeaterMediumYarnLeft", 0xE7A9 ), // glyphnumber: 1991, Medium yarn beater left - std::pair( "pictBeaterMediumYarnRight", 0xE7A8 ), // glyphnumber: 1992, Medium yarn beater right - std::pair( "pictBeaterMediumYarnUp", 0xE7A6 ), // glyphnumber: 1993, Medium yarn beater up - std::pair( "pictBeaterMetalBassDrumDown", 0xE79F ), // glyphnumber: 1994, Metal bass drum stick down - std::pair( "pictBeaterMetalBassDrumUp", 0xE79E ), // glyphnumber: 1995, Metal bass drum stick up - std::pair( "pictBeaterMetalDown", 0xE7C8 ), // glyphnumber: 1996, Metal beater down - std::pair( "pictBeaterMetalHammer", 0xE7E0 ), // glyphnumber: 1997, Metal hammer - std::pair( "pictBeaterMetalLeft", 0xE7CA ), // glyphnumber: 1998, Metal beater, left - std::pair( "pictBeaterMetalRight", 0xE7C9 ), // glyphnumber: 1999, Metal beater, right - std::pair( "pictBeaterMetalUp", 0xE7C7 ), // glyphnumber: 2000, Metal beater, up - std::pair( "pictBeaterSnareSticksDown", 0xE7D2 ), // glyphnumber: 2001, Snare sticks down - std::pair( "pictBeaterSnareSticksUp", 0xE7D1 ), // glyphnumber: 2002, Snare sticks up - std::pair( "pictBeaterSoftBassDrumDown", 0xE799 ), // glyphnumber: 2003, Soft bass drum stick down - std::pair( "pictBeaterSoftBassDrumUp", 0xE798 ), // glyphnumber: 2004, Soft bass drum stick up - std::pair( "pictBeaterSoftGlockenspielDown", 0xE781 ), // glyphnumber: 2005, Soft glockenspiel stick down - std::pair( "pictBeaterSoftGlockenspielLeft", 0xE783 ), // glyphnumber: 2006, Soft glockenspiel stick left - std::pair( "pictBeaterSoftGlockenspielRight", 0xE782 ), // glyphnumber: 2007, Soft glockenspiel stick right - std::pair( "pictBeaterSoftGlockenspielUp", 0xE780 ), // glyphnumber: 2008, Soft glockenspiel stick up - std::pair( "pictBeaterSoftTimpaniDown", 0xE789 ), // glyphnumber: 2009, Soft timpani stick down - std::pair( "pictBeaterSoftTimpaniLeft", 0xE78B ), // glyphnumber: 2010, Soft timpani stick left - std::pair( "pictBeaterSoftTimpaniRight", 0xE78A ), // glyphnumber: 2011, Soft timpani stick right - std::pair( "pictBeaterSoftTimpaniUp", 0xE788 ), // glyphnumber: 2012, Soft timpani stick up - std::pair( "pictBeaterSoftXylophone", 0xE7DB ), // glyphnumber: 2013, Soft xylophone beaters - std::pair( "pictBeaterSoftXylophoneDown", 0xE771 ), // glyphnumber: 2014, Soft xylophone stick down - std::pair( "pictBeaterSoftXylophoneLeft", 0xE773 ), // glyphnumber: 2015, Soft xylophone stick left - std::pair( "pictBeaterSoftXylophoneRight", 0xE772 ), // glyphnumber: 2016, Soft xylophone stick right - std::pair( "pictBeaterSoftXylophoneUp", 0xE770 ), // glyphnumber: 2017, Soft xylophone stick up - std::pair( "pictBeaterSoftYarnDown", 0xE7A3 ), // glyphnumber: 2018, Soft yarn beater down - std::pair( "pictBeaterSoftYarnLeft", 0xE7A5 ), // glyphnumber: 2019, Soft yarn beater left - std::pair( "pictBeaterSoftYarnRight", 0xE7A4 ), // glyphnumber: 2020, Soft yarn beater right - std::pair( "pictBeaterSoftYarnUp", 0xE7A2 ), // glyphnumber: 2021, Soft yarn beater up - std::pair( "pictBeaterSpoonWoodenMallet", 0xE7DC ), // glyphnumber: 2022, Spoon-shaped wooden mallet - std::pair( "pictBeaterSuperballDown", 0xE7AF ), // glyphnumber: 2023, Superball beater down - std::pair( "pictBeaterSuperballLeft", 0xE7B1 ), // glyphnumber: 2024, Superball beater left - std::pair( "pictBeaterSuperballRight", 0xE7B0 ), // glyphnumber: 2025, Superball beater right - std::pair( "pictBeaterSuperballUp", 0xE7AE ), // glyphnumber: 2026, Superball beater up - std::pair( "pictBeaterTriangleDown", 0xE7D6 ), // glyphnumber: 2027, Triangle beater down - std::pair( "pictBeaterTriangleUp", 0xE7D5 ), // glyphnumber: 2028, Triangle beater up - std::pair( "pictBeaterWireBrushesDown", 0xE7D8 ), // glyphnumber: 2029, Wire brushes down - std::pair( "pictBeaterWireBrushesUp", 0xE7D7 ), // glyphnumber: 2030, Wire brushes up - std::pair( "pictBeaterWoodTimpaniDown", 0xE795 ), // glyphnumber: 2031, Wood timpani stick down - std::pair( "pictBeaterWoodTimpaniLeft", 0xE797 ), // glyphnumber: 2032, Wood timpani stick left - std::pair( "pictBeaterWoodTimpaniRight", 0xE796 ), // glyphnumber: 2033, Wood timpani stick right - std::pair( "pictBeaterWoodTimpaniUp", 0xE794 ), // glyphnumber: 2034, Wood timpani stick up - std::pair( "pictBeaterWoodXylophoneDown", 0xE77D ), // glyphnumber: 2035, Wood xylophone stick down - std::pair( "pictBeaterWoodXylophoneLeft", 0xE77F ), // glyphnumber: 2036, Wood xylophone stick left - std::pair( "pictBeaterWoodXylophoneRight", 0xE77E ), // glyphnumber: 2037, Wood xylophone stick right - std::pair( "pictBeaterWoodXylophoneUp", 0xE77C ), // glyphnumber: 2038, Wood xylophone stick up - std::pair( "pictBell", 0xE714 ), // glyphnumber: 2039, Bell - std::pair( "pictBellOfCymbal", 0xE72A ), // glyphnumber: 2040, Bell of cymbal - std::pair( "pictBellPlate", 0xE713 ), // glyphnumber: 2041, Bell plate - std::pair( "pictBellTree", 0xE71A ), // glyphnumber: 2042, Bell tree - std::pair( "pictBirdWhistle", 0xE751 ), // glyphnumber: 2043, Bird whistle - std::pair( "pictBoardClapper", 0xE6F7 ), // glyphnumber: 2044, Board clapper - std::pair( "pictBongos", 0xE6DD ), // glyphnumber: 2045, Bongos - std::pair( "pictBrakeDrum", 0xE6E1 ), // glyphnumber: 2046, Brake drum - std::pair( "pictCabasa", 0xE743 ), // glyphnumber: 2047, Cabasa - std::pair( "pictCannon", 0xE761 ), // glyphnumber: 2048, Cannon - std::pair( "pictCarHorn", 0xE755 ), // glyphnumber: 2049, Car horn - std::pair( "pictCastanets", 0xE6F8 ), // glyphnumber: 2050, Castanets - std::pair( "pictCastanetsWithHandle", 0xE6F9 ), // glyphnumber: 2051, Castanets with handle - std::pair( "pictCelesta", 0xE6B0 ), // glyphnumber: 2052, Celesta - std::pair( "pictCencerro", 0xE716 ), // glyphnumber: 2053, Cencerro - std::pair( "pictCenter1", 0xE7FE ), // glyphnumber: 2054, Center (Weinberg) - std::pair( "pictCenter2", 0xE7FF ), // glyphnumber: 2055, Center (Ghent) - std::pair( "pictCenter3", 0xE800 ), // glyphnumber: 2056, Center (Caltabiano) - std::pair( "pictChainRattle", 0xE748 ), // glyphnumber: 2057, Chain rattle - std::pair( "pictChimes", 0xE6C2 ), // glyphnumber: 2058, Chimes - std::pair( "pictChineseCymbal", 0xE726 ), // glyphnumber: 2059, Chinese cymbal - std::pair( "pictChokeCymbal", 0xE805 ), // glyphnumber: 2060, Choke (Weinberg) - std::pair( "pictClaves", 0xE6F2 ), // glyphnumber: 2061, Claves - std::pair( "pictCoins", 0xE7E7 ), // glyphnumber: 2062, Coins - std::pair( "pictConga", 0xE6DE ), // glyphnumber: 2063, Conga - std::pair( "pictCowBell", 0xE711 ), // glyphnumber: 2064, Cow bell - std::pair( "pictCrashCymbals", 0xE720 ), // glyphnumber: 2065, Crash cymbals - std::pair( "pictCrotales", 0xE6AE ), // glyphnumber: 2066, Crotales - std::pair( "pictCrushStem", 0xE80C ), // glyphnumber: 2067, Combining crush for stem - std::pair( "pictCuica", 0xE6E4 ), // glyphnumber: 2068, Cuica - std::pair( "pictCymbalTongs", 0xE728 ), // glyphnumber: 2069, Cymbal tongs - std::pair( "pictDamp1", 0xE7F9 ), // glyphnumber: 2070, Damp - std::pair( "pictDamp2", 0xE7FA ), // glyphnumber: 2071, Damp 2 - std::pair( "pictDamp3", 0xE7FB ), // glyphnumber: 2072, Damp 3 - std::pair( "pictDamp4", 0xE7FC ), // glyphnumber: 2073, Damp 4 - std::pair( "pictDeadNoteStem", 0xE80D ), // glyphnumber: 2074, Combining X for stem (dead note) - std::pair( "pictDrumStick", 0xE7E8 ), // glyphnumber: 2075, Drum stick - std::pair( "pictDuckCall", 0xE757 ), // glyphnumber: 2076, Duck call - std::pair( "pictEdgeOfCymbal", 0xE729 ), // glyphnumber: 2077, Edge of cymbal - std::pair( "pictEmptyTrap", 0xE6A9 ), // glyphnumber: 2078, Empty trapezoid - std::pair( "pictFingerCymbals", 0xE727 ), // glyphnumber: 2079, Finger cymbals - std::pair( "pictFlexatone", 0xE740 ), // glyphnumber: 2080, Flexatone - std::pair( "pictFootballRatchet", 0xE6F5 ), // glyphnumber: 2081, Football rattle - std::pair( "pictGlassHarmonica", 0xE765 ), // glyphnumber: 2082, Glass harmonica - std::pair( "pictGlassHarp", 0xE764 ), // glyphnumber: 2083, Glass harp - std::pair( "pictGlassPlateChimes", 0xE6C6 ), // glyphnumber: 2084, Glass plate chimes - std::pair( "pictGlassTubeChimes", 0xE6C5 ), // glyphnumber: 2085, Glass tube chimes - std::pair( "pictGlsp", 0xE6A0 ), // glyphnumber: 2086, Glockenspiel - std::pair( "pictGlspSmithBrindle", 0xE6AA ), // glyphnumber: 2087, Glockenspiel (Smith Brindle) - std::pair( "pictGobletDrum", 0xE6E2 ), // glyphnumber: 2088, Goblet drum (djembe, dumbek) - std::pair( "pictGong", 0xE732 ), // glyphnumber: 2089, Gong - std::pair( "pictGongWithButton", 0xE733 ), // glyphnumber: 2090, Gong with button (nipple) - std::pair( "pictGuiro", 0xE6F3 ), // glyphnumber: 2091, Guiro - std::pair( "pictGumHardDown", 0xE7C4 ), // glyphnumber: 2092, Hard gum beater, down - std::pair( "pictGumHardLeft", 0xE7C6 ), // glyphnumber: 2093, Hard gum beater, left - std::pair( "pictGumHardRight", 0xE7C5 ), // glyphnumber: 2094, Hard gum beater, right - std::pair( "pictGumHardUp", 0xE7C3 ), // glyphnumber: 2095, Hard gum beater, up - std::pair( "pictGumMediumDown", 0xE7C0 ), // glyphnumber: 2096, Medium gum beater, down - std::pair( "pictGumMediumLeft", 0xE7C2 ), // glyphnumber: 2097, Medium gum beater, left - std::pair( "pictGumMediumRight", 0xE7C1 ), // glyphnumber: 2098, Medium gum beater, right - std::pair( "pictGumMediumUp", 0xE7BF ), // glyphnumber: 2099, Medium gum beater, up - std::pair( "pictGumSoftDown", 0xE7BC ), // glyphnumber: 2100, Soft gum beater, down - std::pair( "pictGumSoftLeft", 0xE7BE ), // glyphnumber: 2101, Soft gum beater, left - std::pair( "pictGumSoftRight", 0xE7BD ), // glyphnumber: 2102, Soft gum beater, right - std::pair( "pictGumSoftUp", 0xE7BB ), // glyphnumber: 2103, Soft gum beater, up - std::pair( "pictHalfOpen1", 0xE7F6 ), // glyphnumber: 2104, Half-open - std::pair( "pictHalfOpen2", 0xE7F7 ), // glyphnumber: 2105, Half-open 2 (Weinberg) - std::pair( "pictHandbell", 0xE715 ), // glyphnumber: 2106, Handbell - std::pair( "pictHiHat", 0xE722 ), // glyphnumber: 2107, Hi-hat - std::pair( "pictHiHatOnStand", 0xE723 ), // glyphnumber: 2108, Hi-hat cymbals on stand - std::pair( "pictJawHarp", 0xE767 ), // glyphnumber: 2109, Jaw harp - std::pair( "pictJingleBells", 0xE719 ), // glyphnumber: 2110, Jingle bells - std::pair( "pictKlaxonHorn", 0xE756 ), // glyphnumber: 2111, Klaxon horn - std::pair( "pictLeftHandCircle", 0xE807 ), // glyphnumber: 2112, Right hand (Agostini) - std::pair( "pictLionsRoar", 0xE763 ), // glyphnumber: 2113, Lion's roar - std::pair( "pictLithophone", 0xE6B1 ), // glyphnumber: 2114, Lithophone - std::pair( "pictLogDrum", 0xE6DF ), // glyphnumber: 2115, Log drum - std::pair( "pictLotusFlute", 0xE75A ), // glyphnumber: 2116, Lotus flute - std::pair( "pictMar", 0xE6A6 ), // glyphnumber: 2117, Marimba - std::pair( "pictMarSmithBrindle", 0xE6AC ), // glyphnumber: 2118, Marimba (Smith Brindle) - std::pair( "pictMaraca", 0xE741 ), // glyphnumber: 2119, Maraca - std::pair( "pictMaracas", 0xE742 ), // glyphnumber: 2120, Maracas - std::pair( "pictMegaphone", 0xE759 ), // glyphnumber: 2121, Megaphone - std::pair( "pictMetalPlateChimes", 0xE6C8 ), // glyphnumber: 2122, Metal plate chimes - std::pair( "pictMetalTubeChimes", 0xE6C7 ), // glyphnumber: 2123, Metal tube chimes - std::pair( "pictMusicalSaw", 0xE766 ), // glyphnumber: 2124, Musical saw - std::pair( "pictNormalPosition", 0xE804 ), // glyphnumber: 2125, Normal position (Caltabiano) - std::pair( "pictOnRim", 0xE7F4 ), // glyphnumber: 2126, On rim - std::pair( "pictOpen", 0xE7F8 ), // glyphnumber: 2127, Open - std::pair( "pictOpenRimShot", 0xE7F5 ), // glyphnumber: 2128, Closed / rim shot - std::pair( "pictPistolShot", 0xE760 ), // glyphnumber: 2129, Pistol shot - std::pair( "pictPoliceWhistle", 0xE752 ), // glyphnumber: 2130, Police whistle - std::pair( "pictQuijada", 0xE6FA ), // glyphnumber: 2131, Quijada (jawbone) - std::pair( "pictRainstick", 0xE747 ), // glyphnumber: 2132, Rainstick - std::pair( "pictRatchet", 0xE6F4 ), // glyphnumber: 2133, Ratchet - std::pair( "pictRecoReco", 0xE6FC ), // glyphnumber: 2134, Reco-reco - std::pair( "pictRightHandSquare", 0xE806 ), // glyphnumber: 2135, Left hand (Agostini) - std::pair( "pictRim1", 0xE801 ), // glyphnumber: 2136, Rim or edge (Weinberg) - std::pair( "pictRim2", 0xE802 ), // glyphnumber: 2137, Rim (Ghent) - std::pair( "pictRim3", 0xE803 ), // glyphnumber: 2138, Rim (Caltabiano) - std::pair( "pictRimShotOnStem", 0xE7FD ), // glyphnumber: 2139, Rim shot for stem - std::pair( "pictSandpaperBlocks", 0xE762 ), // glyphnumber: 2140, Sandpaper blocks - std::pair( "pictScrapeAroundRim", 0xE7F3 ), // glyphnumber: 2141, Scrape around rim (counter-clockwise) - std::pair( "pictScrapeAroundRimClockwise", 0xE80E ), // glyphnumber: 2142, Scrape around rim (clockwise) - std::pair( "pictScrapeCenterToEdge", 0xE7F1 ), // glyphnumber: 2143, Scrape from center to edge - std::pair( "pictScrapeEdgeToCenter", 0xE7F2 ), // glyphnumber: 2144, Scrape from edge to center - std::pair( "pictShellBells", 0xE718 ), // glyphnumber: 2145, Shell bells - std::pair( "pictShellChimes", 0xE6C4 ), // glyphnumber: 2146, Shell chimes - std::pair( "pictSiren", 0xE753 ), // glyphnumber: 2147, Siren - std::pair( "pictSistrum", 0xE746 ), // glyphnumber: 2148, Sistrum - std::pair( "pictSizzleCymbal", 0xE724 ), // glyphnumber: 2149, Sizzle cymbal - std::pair( "pictSleighBell", 0xE710 ), // glyphnumber: 2150, Sleigh bell - std::pair( "pictSlideBrushOnGong", 0xE734 ), // glyphnumber: 2151, Slide brush on gong - std::pair( "pictSlideWhistle", 0xE750 ), // glyphnumber: 2152, Slide whistle - std::pair( "pictSlitDrum", 0xE6E0 ), // glyphnumber: 2153, Slit drum - std::pair( "pictSnareDrum", 0xE6D1 ), // glyphnumber: 2154, Snare drum - std::pair( "pictSnareDrumMilitary", 0xE6D3 ), // glyphnumber: 2155, Military snare drum - std::pair( "pictSnareDrumSnaresOff", 0xE6D2 ), // glyphnumber: 2156, Snare drum, snares off - std::pair( "pictSteelDrums", 0xE6AF ), // glyphnumber: 2157, Steel drums - std::pair( "pictStickShot", 0xE7F0 ), // glyphnumber: 2158, Stick shot - std::pair( "pictSuperball", 0xE7B2 ), // glyphnumber: 2159, Superball - std::pair( "pictSuspendedCymbal", 0xE721 ), // glyphnumber: 2160, Suspended cymbal - std::pair( "pictSwishStem", 0xE808 ), // glyphnumber: 2161, Combining swish for stem - std::pair( "pictTabla", 0xE6E3 ), // glyphnumber: 2162, Indian tabla - std::pair( "pictTamTam", 0xE730 ), // glyphnumber: 2163, Tam-tam - std::pair( "pictTamTamWithBeater", 0xE731 ), // glyphnumber: 2164, Tam-tam with beater (Smith Brindle) - std::pair( "pictTambourine", 0xE6DB ), // glyphnumber: 2165, Tambourine - std::pair( "pictTempleBlocks", 0xE6F1 ), // glyphnumber: 2166, Temple blocks - std::pair( "pictTenorDrum", 0xE6D6 ), // glyphnumber: 2167, Tenor drum - std::pair( "pictThundersheet", 0xE744 ), // glyphnumber: 2168, Thundersheet - std::pair( "pictTimbales", 0xE6DC ), // glyphnumber: 2169, Timbales - std::pair( "pictTimpani", 0xE6D0 ), // glyphnumber: 2170, Timpani - std::pair( "pictTomTom", 0xE6D7 ), // glyphnumber: 2171, Tom-tom - std::pair( "pictTomTomChinese", 0xE6D8 ), // glyphnumber: 2172, Chinese tom-tom - std::pair( "pictTomTomIndoAmerican", 0xE6DA ), // glyphnumber: 2173, Indo-American tom tom - std::pair( "pictTomTomJapanese", 0xE6D9 ), // glyphnumber: 2174, Japanese tom-tom - std::pair( "pictTriangle", 0xE700 ), // glyphnumber: 2175, Triangle - std::pair( "pictTubaphone", 0xE6B2 ), // glyphnumber: 2176, Tubaphone - std::pair( "pictTubularBells", 0xE6C0 ), // glyphnumber: 2177, Tubular bells - std::pair( "pictTurnLeftStem", 0xE80A ), // glyphnumber: 2178, Combining turn left for stem - std::pair( "pictTurnRightLeftStem", 0xE80B ), // glyphnumber: 2179, Combining turn left or right for stem - std::pair( "pictTurnRightStem", 0xE809 ), // glyphnumber: 2180, Combining turn right for stem - std::pair( "pictVib", 0xE6A7 ), // glyphnumber: 2181, Vibraphone - std::pair( "pictVibMotorOff", 0xE6A8 ), // glyphnumber: 2182, Metallophone (vibraphone motor off) - std::pair( "pictVibSmithBrindle", 0xE6AD ), // glyphnumber: 2183, Vibraphone (Smith Brindle) - std::pair( "pictVibraslap", 0xE745 ), // glyphnumber: 2184, Vibraslap - std::pair( "pictVietnameseHat", 0xE725 ), // glyphnumber: 2185, Vietnamese hat cymbal - std::pair( "pictWhip", 0xE6F6 ), // glyphnumber: 2186, Whip - std::pair( "pictWindChimesGlass", 0xE6C1 ), // glyphnumber: 2187, Wind chimes (glass) - std::pair( "pictWindMachine", 0xE754 ), // glyphnumber: 2188, Wind machine - std::pair( "pictWindWhistle", 0xE758 ), // glyphnumber: 2189, Wind whistle (or mouth siren) - std::pair( "pictWoodBlock", 0xE6F0 ), // glyphnumber: 2190, Wood block - std::pair( "pictWoundHardDown", 0xE7B4 ), // glyphnumber: 2191, Wound beater, hard core down - std::pair( "pictWoundHardLeft", 0xE7B6 ), // glyphnumber: 2192, Wound beater, hard core left - std::pair( "pictWoundHardRight", 0xE7B5 ), // glyphnumber: 2193, Wound beater, hard core right - std::pair( "pictWoundHardUp", 0xE7B3 ), // glyphnumber: 2194, Wound beater, hard core up - std::pair( "pictWoundSoftDown", 0xE7B8 ), // glyphnumber: 2195, Wound beater, soft core down - std::pair( "pictWoundSoftLeft", 0xE7BA ), // glyphnumber: 2196, Wound beater, soft core left - std::pair( "pictWoundSoftRight", 0xE7B9 ), // glyphnumber: 2197, Wound beater, soft core right - std::pair( "pictWoundSoftUp", 0xE7B7 ), // glyphnumber: 2198, Wound beater, soft core up - std::pair( "pictXyl", 0xE6A1 ), // glyphnumber: 2199, Xylophone - std::pair( "pictXylBass", 0xE6A3 ), // glyphnumber: 2200, Bass xylophone - std::pair( "pictXylSmithBrindle", 0xE6AB ), // glyphnumber: 2201, Xylophone (Smith Brindle) - std::pair( "pictXylTenor", 0xE6A2 ), // glyphnumber: 2202, Tenor xylophone - std::pair( "pictXylTenorTrough", 0xE6A5 ), // glyphnumber: 2203, Trough tenor xylophone - std::pair( "pictXylTrough", 0xE6A4 ), // glyphnumber: 2204, Trough xylophone - std::pair( "pluckedBuzzPizzicato", 0xE632 ), // glyphnumber: 2205, Buzz pizzicato - std::pair( "pluckedDamp", 0xE638 ), // glyphnumber: 2206, Damp - std::pair( "pluckedDampAll", 0xE639 ), // glyphnumber: 2207, Damp all - std::pair( "pluckedDampOnStem", 0xE63B ), // glyphnumber: 2208, Damp for stem - std::pair( "pluckedFingernailFlick", 0xE637 ), // glyphnumber: 2209, Fingernail flick - std::pair( "pluckedLeftHandPizzicato", 0xE633 ), // glyphnumber: 2210, Left-hand pizzicato - std::pair( "pluckedPlectrum", 0xE63A ), // glyphnumber: 2211, Plectrum - std::pair( "pluckedSnapPizzicatoAbove", 0xE631 ), // glyphnumber: 2212, Snap pizzicato above - std::pair( "pluckedSnapPizzicatoBelow", 0xE630 ), // glyphnumber: 2213, Snap pizzicato below - std::pair( "pluckedWithFingernails", 0xE636 ), // glyphnumber: 2214, With fingernails - std::pair( "quindicesima", 0xE514 ), // glyphnumber: 2215, Quindicesima - std::pair( "quindicesimaAlta", 0xE515 ), // glyphnumber: 2216, Quindicesima alta - std::pair( "quindicesimaBassa", 0xE516 ), // glyphnumber: 2217, Quindicesima bassa - std::pair( "quindicesimaBassaMb", 0xE51D ), // glyphnumber: 2218, Quindicesima bassa (mb) - std::pair( "repeat1Bar", 0xE500 ), // glyphnumber: 2219, Repeat last bar - std::pair( "repeat2Bars", 0xE501 ), // glyphnumber: 2220, Repeat last two bars - std::pair( "repeat4Bars", 0xE502 ), // glyphnumber: 2221, Repeat last four bars - std::pair( "repeatDot", 0xE044 ), // glyphnumber: 2222, Single repeat dot - std::pair( "repeatDots", 0xE043 ), // glyphnumber: 2223, Repeat dots - std::pair( "repeatLeft", 0xE040 ), // glyphnumber: 2224, Left (start) repeat sign - std::pair( "repeatRight", 0xE041 ), // glyphnumber: 2225, Right (end) repeat sign - std::pair( "repeatRightLeft", 0xE042 ), // glyphnumber: 2226, Right and left repeat sign - std::pair( "rest1024th", 0xE4ED ), // glyphnumber: 2227, 1024th rest - std::pair( "rest128th", 0xE4EA ), // glyphnumber: 2228, 128th (semihemidemisemiquaver) rest - std::pair( "rest16th", 0xE4E7 ), // glyphnumber: 2229, 16th (semiquaver) rest - std::pair( "rest256th", 0xE4EB ), // glyphnumber: 2230, 256th rest - std::pair( "rest32nd", 0xE4E8 ), // glyphnumber: 2231, 32nd (demisemiquaver) rest - std::pair( "rest512th", 0xE4EC ), // glyphnumber: 2232, 512th rest - std::pair( "rest64th", 0xE4E9 ), // glyphnumber: 2233, 64th (hemidemisemiquaver) rest - std::pair( "rest8th", 0xE4E6 ), // glyphnumber: 2234, Eighth (quaver) rest - std::pair( "restDoubleWhole", 0xE4E2 ), // glyphnumber: 2235, Double whole (breve) rest - std::pair( "restDoubleWholeLegerLine", 0xE4F3 ), // glyphnumber: 2236, Double whole rest on leger lines - std::pair( "restHBar", 0xE4EE ), // glyphnumber: 2237, Multiple measure rest - std::pair( "restHBarLeft", 0xE4EF ), // glyphnumber: 2238, H-bar, left half - std::pair( "restHBarMiddle", 0xE4F0 ), // glyphnumber: 2239, H-bar, middle - std::pair( "restHBarRight", 0xE4F1 ), // glyphnumber: 2240, H-bar, right half - std::pair( "restHalf", 0xE4E4 ), // glyphnumber: 2241, Half (minim) rest - std::pair( "restHalfLegerLine", 0xE4F5 ), // glyphnumber: 2242, Half rest on leger line - std::pair( "restLonga", 0xE4E1 ), // glyphnumber: 2243, Longa rest - std::pair( "restMaxima", 0xE4E0 ), // glyphnumber: 2244, Maxima rest - std::pair( "restQuarter", 0xE4E5 ), // glyphnumber: 2245, Quarter (crotchet) rest - std::pair( "restQuarterOld", 0xE4F2 ), // glyphnumber: 2246, Old-style quarter (crotchet) rest - std::pair( "restQuarterZ", 0xE4F6 ), // glyphnumber: 2247, Z-style quarter (crotchet) rest - std::pair( "restWhole", 0xE4E3 ), // glyphnumber: 2248, Whole (semibreve) rest - std::pair( "restWholeLegerLine", 0xE4F4 ), // glyphnumber: 2249, Whole rest on leger line - std::pair( "reversedBrace", 0xE001 ), // glyphnumber: 2250, Reversed brace - std::pair( "reversedBracketBottom", 0xE006 ), // glyphnumber: 2251, Reversed bracket bottom - std::pair( "reversedBracketTop", 0xE005 ), // glyphnumber: 2252, Reversed bracket top - std::pair( "rightRepeatSmall", 0xE04D ), // glyphnumber: 2253, Right repeat sign within bar - std::pair( "schaefferClef", 0xE06F ), // glyphnumber: 2254, Schäffer clef - std::pair( "schaefferFClefToGClef", 0xE072 ), // glyphnumber: 2255, Schäffer F clef to G clef change - std::pair( "schaefferGClefToFClef", 0xE071 ), // glyphnumber: 2256, Schäffer G clef to F clef change - std::pair( "schaefferPreviousClef", 0xE070 ), // glyphnumber: 2257, Schäffer previous clef - std::pair( "segno", 0xE047 ), // glyphnumber: 2258, Segno - std::pair( "segnoSerpent1", 0xE04A ), // glyphnumber: 2259, Segno (serpent) - std::pair( "segnoSerpent2", 0xE04B ), // glyphnumber: 2260, Segno (serpent with vertical lines) - std::pair( "semipitchedPercussionClef1", 0xE06B ), // glyphnumber: 2261, Semi-pitched percussion clef 1 - std::pair( "semipitchedPercussionClef2", 0xE06C ), // glyphnumber: 2262, Semi-pitched percussion clef 2 - std::pair( "smnFlat", 0xEC52 ), // glyphnumber: 2263, Flat - std::pair( "smnFlatWhite", 0xEC53 ), // glyphnumber: 2264, Flat (white) - std::pair( "smnHistoryDoubleFlat", 0xEC57 ), // glyphnumber: 2265, Double flat history sign - std::pair( "smnHistoryDoubleSharp", 0xEC55 ), // glyphnumber: 2266, Double sharp history sign - std::pair( "smnHistoryFlat", 0xEC56 ), // glyphnumber: 2267, Flat history sign - std::pair( "smnHistorySharp", 0xEC54 ), // glyphnumber: 2268, Sharp history sign - std::pair( "smnNatural", 0xEC58 ), // glyphnumber: 2269, Natural (N) - std::pair( "smnSharp", 0xEC50 ), // glyphnumber: 2270, Sharp stem up - std::pair( "smnSharpDown", 0xEC59 ), // glyphnumber: 2271, Sharp stem down - std::pair( "smnSharpWhite", 0xEC51 ), // glyphnumber: 2272, Sharp (white) stem up - std::pair( "smnSharpWhiteDown", 0xEC5A ), // glyphnumber: 2273, Sharp (white) stem down - std::pair( "splitBarDivider", 0xE00A ), // glyphnumber: 2274, Split bar divider (bar spans a system break) - std::pair( "staff1Line", 0xE010 ), // glyphnumber: 2275, 1-line staff - std::pair( "staff1LineNarrow", 0xE01C ), // glyphnumber: 2276, 1-line staff (narrow) - std::pair( "staff1LineWide", 0xE016 ), // glyphnumber: 2277, 1-line staff (wide) - std::pair( "staff2Lines", 0xE011 ), // glyphnumber: 2278, 2-line staff - std::pair( "staff2LinesNarrow", 0xE01D ), // glyphnumber: 2279, 2-line staff (narrow) - std::pair( "staff2LinesWide", 0xE017 ), // glyphnumber: 2280, 2-line staff (wide) - std::pair( "staff3Lines", 0xE012 ), // glyphnumber: 2281, 3-line staff - std::pair( "staff3LinesNarrow", 0xE01E ), // glyphnumber: 2282, 3-line staff (narrow) - std::pair( "staff3LinesWide", 0xE018 ), // glyphnumber: 2283, 3-line staff (wide) - std::pair( "staff4Lines", 0xE013 ), // glyphnumber: 2284, 4-line staff - std::pair( "staff4LinesNarrow", 0xE01F ), // glyphnumber: 2285, 4-line staff (narrow) - std::pair( "staff4LinesWide", 0xE019 ), // glyphnumber: 2286, 4-line staff (wide) - std::pair( "staff5Lines", 0xE014 ), // glyphnumber: 2287, 5-line staff - std::pair( "staff5LinesNarrow", 0xE020 ), // glyphnumber: 2288, 5-line staff (narrow) - std::pair( "staff5LinesWide", 0xE01A ), // glyphnumber: 2289, 5-line staff (wide) - std::pair( "staff6Lines", 0xE015 ), // glyphnumber: 2290, 6-line staff - std::pair( "staff6LinesNarrow", 0xE021 ), // glyphnumber: 2291, 6-line staff (narrow) - std::pair( "staff6LinesWide", 0xE01B ), // glyphnumber: 2292, 6-line staff (wide) - std::pair( "staffDivideArrowDown", 0xE00B ), // glyphnumber: 2293, Staff divide arrow down - std::pair( "staffDivideArrowUp", 0xE00C ), // glyphnumber: 2294, Staff divide arrow up - std::pair( "staffDivideArrowUpDown", 0xE00D ), // glyphnumber: 2295, Staff divide arrows - std::pair( "staffPosLower1", 0xEB98 ), // glyphnumber: 2296, Lower 1 staff position - std::pair( "staffPosLower2", 0xEB99 ), // glyphnumber: 2297, Lower 2 staff positions - std::pair( "staffPosLower3", 0xEB9A ), // glyphnumber: 2298, Lower 3 staff positions - std::pair( "staffPosLower4", 0xEB9B ), // glyphnumber: 2299, Lower 4 staff positions - std::pair( "staffPosLower5", 0xEB9C ), // glyphnumber: 2300, Lower 5 staff positions - std::pair( "staffPosLower6", 0xEB9D ), // glyphnumber: 2301, Lower 6 staff positions - std::pair( "staffPosLower7", 0xEB9E ), // glyphnumber: 2302, Lower 7 staff positions - std::pair( "staffPosLower8", 0xEB9F ), // glyphnumber: 2303, Lower 8 staff positions - std::pair( "staffPosRaise1", 0xEB90 ), // glyphnumber: 2304, Raise 1 staff position - std::pair( "staffPosRaise2", 0xEB91 ), // glyphnumber: 2305, Raise 2 staff positions - std::pair( "staffPosRaise3", 0xEB92 ), // glyphnumber: 2306, Raise 3 staff positions - std::pair( "staffPosRaise4", 0xEB93 ), // glyphnumber: 2307, Raise 4 staff positions - std::pair( "staffPosRaise5", 0xEB94 ), // glyphnumber: 2308, Raise 5 staff positions - std::pair( "staffPosRaise6", 0xEB95 ), // glyphnumber: 2309, Raise 6 staff positions - std::pair( "staffPosRaise7", 0xEB96 ), // glyphnumber: 2310, Raise 7 staff positions - std::pair( "staffPosRaise8", 0xEB97 ), // glyphnumber: 2311, Raise 8 staff positions - std::pair( "stem", 0xE210 ), // glyphnumber: 2312, Combining stem - std::pair( "stemBowOnBridge", 0xE215 ), // glyphnumber: 2313, Combining bow on bridge stem - std::pair( "stemBowOnTailpiece", 0xE216 ), // glyphnumber: 2314, Combining bow on tailpiece stem - std::pair( "stemBuzzRoll", 0xE217 ), // glyphnumber: 2315, Combining buzz roll stem - std::pair( "stemDamp", 0xE218 ), // glyphnumber: 2316, Combining damp stem - std::pair( "stemHarpStringNoise", 0xE21F ), // glyphnumber: 2317, Combining harp string noise stem - std::pair( "stemMultiphonicsBlack", 0xE21A ), // glyphnumber: 2318, Combining multiphonics (black) stem - std::pair( "stemMultiphonicsBlackWhite", 0xE21C ), // glyphnumber: 2319, Combining multiphonics (black and white) stem - std::pair( "stemMultiphonicsWhite", 0xE21B ), // glyphnumber: 2320, Combining multiphonics (white) stem - std::pair( "stemPendereckiTremolo", 0xE213 ), // glyphnumber: 2321, Combining Penderecki unmeasured tremolo stem - std::pair( "stemRimShot", 0xE21E ), // glyphnumber: 2322, Combining rim shot stem - std::pair( "stemSprechgesang", 0xE211 ), // glyphnumber: 2323, Combining sprechgesang stem - std::pair( "stemSulPonticello", 0xE214 ), // glyphnumber: 2324, Combining sul ponticello (bow behind bridge) stem - std::pair( "stemSussurando", 0xE21D ), // glyphnumber: 2325, Combining sussurando stem - std::pair( "stemSwished", 0xE212 ), // glyphnumber: 2326, Combining swished stem - std::pair( "stemVibratoPulse", 0xE219 ), // glyphnumber: 2327, Combining vibrato pulse accent (Saunders) stem - std::pair( "stockhausenTremolo", 0xE232 ), // glyphnumber: 2328, Stockhausen irregular tremolo ("Morsen", like Morse code) - std::pair( "stringsBowBehindBridge", 0xE618 ), // glyphnumber: 2329, Bow behind bridge (sul ponticello) - std::pair( "stringsBowBehindBridgeFourStrings", 0xE62A ), // glyphnumber: 2330, Bow behind bridge on four strings - std::pair( "stringsBowBehindBridgeOneString", 0xE627 ), // glyphnumber: 2331, Bow behind bridge on one string - std::pair( "stringsBowBehindBridgeThreeStrings", 0xE629 ), // glyphnumber: 2332, Bow behind bridge on three strings - std::pair( "stringsBowBehindBridgeTwoStrings", 0xE628 ), // glyphnumber: 2333, Bow behind bridge on two strings - std::pair( "stringsBowOnBridge", 0xE619 ), // glyphnumber: 2334, Bow on top of bridge - std::pair( "stringsBowOnTailpiece", 0xE61A ), // glyphnumber: 2335, Bow on tailpiece - std::pair( "stringsChangeBowDirection", 0xE626 ), // glyphnumber: 2336, Change bow direction, indeterminate - std::pair( "stringsDownBow", 0xE610 ), // glyphnumber: 2337, Down bow - std::pair( "stringsDownBowTurned", 0xE611 ), // glyphnumber: 2338, Turned down bow - std::pair( "stringsFouette", 0xE622 ), // glyphnumber: 2339, Fouetté - std::pair( "stringsHalfHarmonic", 0xE615 ), // glyphnumber: 2340, Half-harmonic - std::pair( "stringsHarmonic", 0xE614 ), // glyphnumber: 2341, Harmonic - std::pair( "stringsJeteAbove", 0xE620 ), // glyphnumber: 2342, Jeté (gettato) above - std::pair( "stringsJeteBelow", 0xE621 ), // glyphnumber: 2343, Jeté (gettato) below - std::pair( "stringsMuteOff", 0xE617 ), // glyphnumber: 2344, Mute off - std::pair( "stringsMuteOn", 0xE616 ), // glyphnumber: 2345, Mute on - std::pair( "stringsOverpressureDownBow", 0xE61B ), // glyphnumber: 2346, Overpressure, down bow - std::pair( "stringsOverpressureNoDirection", 0xE61F ), // glyphnumber: 2347, Overpressure, no bow direction - std::pair( "stringsOverpressurePossibileDownBow", 0xE61D ), // glyphnumber: 2348, Overpressure possibile, down bow - std::pair( "stringsOverpressurePossibileUpBow", 0xE61E ), // glyphnumber: 2349, Overpressure possibile, up bow - std::pair( "stringsOverpressureUpBow", 0xE61C ), // glyphnumber: 2350, Overpressure, up bow - std::pair( "stringsThumbPosition", 0xE624 ), // glyphnumber: 2351, Thumb position - std::pair( "stringsThumbPositionTurned", 0xE625 ), // glyphnumber: 2352, Turned thumb position - std::pair( "stringsUpBow", 0xE612 ), // glyphnumber: 2353, Up bow - std::pair( "stringsUpBowTurned", 0xE613 ), // glyphnumber: 2354, Turned up bow - std::pair( "stringsVibratoPulse", 0xE623 ), // glyphnumber: 2355, Vibrato pulse accent (Saunders) for stem - std::pair( "systemDivider", 0xE007 ), // glyphnumber: 2356, System divider - std::pair( "systemDividerExtraLong", 0xE009 ), // glyphnumber: 2357, Extra long system divider - std::pair( "systemDividerLong", 0xE008 ), // glyphnumber: 2358, Long system divider - std::pair( "textAugmentationDot", 0xE1FC ), // glyphnumber: 2359, Augmentation dot - std::pair( "textBlackNoteFrac16thLongStem", 0xE1F5 ), // glyphnumber: 2360, Black note, fractional 16th beam, long stem - std::pair( "textBlackNoteFrac16thShortStem", 0xE1F4 ), // glyphnumber: 2361, Black note, fractional 16th beam, short stem - std::pair( "textBlackNoteFrac32ndLongStem", 0xE1F6 ), // glyphnumber: 2362, Black note, fractional 32nd beam, long stem - std::pair( "textBlackNoteFrac8thLongStem", 0xE1F3 ), // glyphnumber: 2363, Black note, fractional 8th beam, long stem - std::pair( "textBlackNoteFrac8thShortStem", 0xE1F2 ), // glyphnumber: 2364, Black note, fractional 8th beam, short stem - std::pair( "textBlackNoteLongStem", 0xE1F1 ), // glyphnumber: 2365, Black note, long stem - std::pair( "textBlackNoteShortStem", 0xE1F0 ), // glyphnumber: 2366, Black note, short stem - std::pair( "textCont16thBeamLongStem", 0xE1FA ), // glyphnumber: 2367, Continuing 16th beam for long stem - std::pair( "textCont16thBeamShortStem", 0xE1F9 ), // glyphnumber: 2368, Continuing 16th beam for short stem - std::pair( "textCont32ndBeamLongStem", 0xE1FB ), // glyphnumber: 2369, Continuing 32nd beam for long stem - std::pair( "textCont8thBeamLongStem", 0xE1F8 ), // glyphnumber: 2370, Continuing 8th beam for long stem - std::pair( "textCont8thBeamShortStem", 0xE1F7 ), // glyphnumber: 2371, Continuing 8th beam for short stem - std::pair( "textTie", 0xE1FD ), // glyphnumber: 2372, Tie - std::pair( "textTuplet3LongStem", 0xE202 ), // glyphnumber: 2373, Tuplet number 3 for long stem - std::pair( "textTuplet3ShortStem", 0xE1FF ), // glyphnumber: 2374, Tuplet number 3 for short stem - std::pair( "textTupletBracketEndLongStem", 0xE203 ), // glyphnumber: 2375, Tuplet bracket end for long stem - std::pair( "textTupletBracketEndShortStem", 0xE200 ), // glyphnumber: 2376, Tuplet bracket end for short stem - std::pair( "textTupletBracketStartLongStem", 0xE201 ), // glyphnumber: 2377, Tuplet bracket start for long stem - std::pair( "textTupletBracketStartShortStem", 0xE1FE ), // glyphnumber: 2378, Tuplet bracket start for short stem - std::pair( "timeSig0", 0xE080 ), // glyphnumber: 2379, Time signature 0 - std::pair( "timeSig0Reversed", 0xECF0 ), // glyphnumber: 2380, Reversed time signature 0 - std::pair( "timeSig0Turned", 0xECE0 ), // glyphnumber: 2381, Turned time signature 0 - std::pair( "timeSig1", 0xE081 ), // glyphnumber: 2382, Time signature 1 - std::pair( "timeSig1Reversed", 0xECF1 ), // glyphnumber: 2383, Reversed time signature 1 - std::pair( "timeSig1Turned", 0xECE1 ), // glyphnumber: 2384, Turned time signature 1 - std::pair( "timeSig2", 0xE082 ), // glyphnumber: 2385, Time signature 2 - std::pair( "timeSig2Reversed", 0xECF2 ), // glyphnumber: 2386, Reversed time signature 2 - std::pair( "timeSig2Turned", 0xECE2 ), // glyphnumber: 2387, Turned time signature 2 - std::pair( "timeSig3", 0xE083 ), // glyphnumber: 2388, Time signature 3 - std::pair( "timeSig3Reversed", 0xECF3 ), // glyphnumber: 2389, Reversed time signature 3 - std::pair( "timeSig3Turned", 0xECE3 ), // glyphnumber: 2390, Turned time signature 3 - std::pair( "timeSig4", 0xE084 ), // glyphnumber: 2391, Time signature 4 - std::pair( "timeSig4Reversed", 0xECF4 ), // glyphnumber: 2392, Reversed time signature 4 - std::pair( "timeSig4Turned", 0xECE4 ), // glyphnumber: 2393, Turned time signature 4 - std::pair( "timeSig5", 0xE085 ), // glyphnumber: 2394, Time signature 5 - std::pair( "timeSig5Reversed", 0xECF5 ), // glyphnumber: 2395, Reversed time signature 5 - std::pair( "timeSig5Turned", 0xECE5 ), // glyphnumber: 2396, Turned time signature 5 - std::pair( "timeSig6", 0xE086 ), // glyphnumber: 2397, Time signature 6 - std::pair( "timeSig6Reversed", 0xECF6 ), // glyphnumber: 2398, Reversed time signature 6 - std::pair( "timeSig6Turned", 0xECE6 ), // glyphnumber: 2399, Turned time signature 6 - std::pair( "timeSig7", 0xE087 ), // glyphnumber: 2400, Time signature 7 - std::pair( "timeSig7Reversed", 0xECF7 ), // glyphnumber: 2401, Reversed time signature 7 - std::pair( "timeSig7Turned", 0xECE7 ), // glyphnumber: 2402, Turned time signature 7 - std::pair( "timeSig8", 0xE088 ), // glyphnumber: 2403, Time signature 8 - std::pair( "timeSig8Reversed", 0xECF8 ), // glyphnumber: 2404, Reversed time signature 8 - std::pair( "timeSig8Turned", 0xECE8 ), // glyphnumber: 2405, Turned time signature 8 - std::pair( "timeSig9", 0xE089 ), // glyphnumber: 2406, Time signature 9 - std::pair( "timeSig9Reversed", 0xECF9 ), // glyphnumber: 2407, Reversed time signature 9 - std::pair( "timeSig9Turned", 0xECE9 ), // glyphnumber: 2408, Turned time signature 9 - std::pair( "timeSigBracketLeft", 0xEC80 ), // glyphnumber: 2409, Left bracket for whole time signature - std::pair( "timeSigBracketLeftSmall", 0xEC82 ), // glyphnumber: 2410, Left bracket for numerator only - std::pair( "timeSigBracketRight", 0xEC81 ), // glyphnumber: 2411, Right bracket for whole time signature - std::pair( "timeSigBracketRightSmall", 0xEC83 ), // glyphnumber: 2412, Right bracket for numerator only - std::pair( "timeSigCombDenominator", 0xE09F ), // glyphnumber: 2413, Control character for denominator digit - std::pair( "timeSigCombNumerator", 0xE09E ), // glyphnumber: 2414, Control character for numerator digit - std::pair( "timeSigComma", 0xE096 ), // glyphnumber: 2415, Time signature comma - std::pair( "timeSigCommon", 0xE08A ), // glyphnumber: 2416, Common time - std::pair( "timeSigCommonReversed", 0xECFA ), // glyphnumber: 2417, Reversed common time - std::pair( "timeSigCommonTurned", 0xECEA ), // glyphnumber: 2418, Turned common time - std::pair( "timeSigCut2", 0xEC85 ), // glyphnumber: 2419, Cut time (Bach) - std::pair( "timeSigCut3", 0xEC86 ), // glyphnumber: 2420, Cut triple time (9/8) - std::pair( "timeSigCutCommon", 0xE08B ), // glyphnumber: 2421, Cut time - std::pair( "timeSigCutCommonReversed", 0xECFB ), // glyphnumber: 2422, Reversed cut time - std::pair( "timeSigCutCommonTurned", 0xECEB ), // glyphnumber: 2423, Turned cut time - std::pair( "timeSigEquals", 0xE08F ), // glyphnumber: 2424, Time signature equals - std::pair( "timeSigFractionHalf", 0xE098 ), // glyphnumber: 2425, Time signature fraction ½ - std::pair( "timeSigFractionOneThird", 0xE09A ), // glyphnumber: 2426, Time signature fraction ⅓ - std::pair( "timeSigFractionQuarter", 0xE097 ), // glyphnumber: 2427, Time signature fraction ¼ - std::pair( "timeSigFractionThreeQuarters", 0xE099 ), // glyphnumber: 2428, Time signature fraction ¾ - std::pair( "timeSigFractionTwoThirds", 0xE09B ), // glyphnumber: 2429, Time signature fraction ⅔ - std::pair( "timeSigFractionalSlash", 0xE08E ), // glyphnumber: 2430, Time signature fraction slash - std::pair( "timeSigMinus", 0xE090 ), // glyphnumber: 2431, Time signature minus - std::pair( "timeSigMultiply", 0xE091 ), // glyphnumber: 2432, Time signature multiply - std::pair( "timeSigOpenPenderecki", 0xE09D ), // glyphnumber: 2433, Open time signature (Penderecki) - std::pair( "timeSigParensLeft", 0xE094 ), // glyphnumber: 2434, Left parenthesis for whole time signature - std::pair( "timeSigParensLeftSmall", 0xE092 ), // glyphnumber: 2435, Left parenthesis for numerator only - std::pair( "timeSigParensRight", 0xE095 ), // glyphnumber: 2436, Right parenthesis for whole time signature - std::pair( "timeSigParensRightSmall", 0xE093 ), // glyphnumber: 2437, Right parenthesis for numerator only - std::pair( "timeSigPlus", 0xE08C ), // glyphnumber: 2438, Time signature + - std::pair( "timeSigPlusSmall", 0xE08D ), // glyphnumber: 2439, Time signature + (for numerators) - std::pair( "timeSigSlash", 0xEC84 ), // glyphnumber: 2440, Time signature slash separator - std::pair( "timeSigX", 0xE09C ), // glyphnumber: 2441, Open time signature - std::pair( "tremolo1", 0xE220 ), // glyphnumber: 2442, Combining tremolo 1 - std::pair( "tremolo2", 0xE221 ), // glyphnumber: 2443, Combining tremolo 2 - std::pair( "tremolo3", 0xE222 ), // glyphnumber: 2444, Combining tremolo 3 - std::pair( "tremolo4", 0xE223 ), // glyphnumber: 2445, Combining tremolo 4 - std::pair( "tremolo5", 0xE224 ), // glyphnumber: 2446, Combining tremolo 5 - std::pair( "tremoloDivisiDots2", 0xE22E ), // glyphnumber: 2447, Divide measured tremolo by 2 - std::pair( "tremoloDivisiDots3", 0xE22F ), // glyphnumber: 2448, Divide measured tremolo by 3 - std::pair( "tremoloDivisiDots4", 0xE230 ), // glyphnumber: 2449, Divide measured tremolo by 4 - std::pair( "tremoloDivisiDots6", 0xE231 ), // glyphnumber: 2450, Divide measured tremolo by 6 - std::pair( "tremoloFingered1", 0xE225 ), // glyphnumber: 2451, Fingered tremolo 1 - std::pair( "tremoloFingered2", 0xE226 ), // glyphnumber: 2452, Fingered tremolo 2 - std::pair( "tremoloFingered3", 0xE227 ), // glyphnumber: 2453, Fingered tremolo 3 - std::pair( "tremoloFingered4", 0xE228 ), // glyphnumber: 2454, Fingered tremolo 4 - std::pair( "tremoloFingered5", 0xE229 ), // glyphnumber: 2455, Fingered tremolo 5 - std::pair( "tripleTongueAbove", 0xE5F2 ), // glyphnumber: 2456, Triple-tongue above - std::pair( "tripleTongueBelow", 0xE5F3 ), // glyphnumber: 2457, Triple-tongue below - std::pair( "tuplet0", 0xE880 ), // glyphnumber: 2458, Tuplet 0 - std::pair( "tuplet1", 0xE881 ), // glyphnumber: 2459, Tuplet 1 - std::pair( "tuplet2", 0xE882 ), // glyphnumber: 2460, Tuplet 2 - std::pair( "tuplet3", 0xE883 ), // glyphnumber: 2461, Tuplet 3 - std::pair( "tuplet4", 0xE884 ), // glyphnumber: 2462, Tuplet 4 - std::pair( "tuplet5", 0xE885 ), // glyphnumber: 2463, Tuplet 5 - std::pair( "tuplet6", 0xE886 ), // glyphnumber: 2464, Tuplet 6 - std::pair( "tuplet7", 0xE887 ), // glyphnumber: 2465, Tuplet 7 - std::pair( "tuplet8", 0xE888 ), // glyphnumber: 2466, Tuplet 8 - std::pair( "tuplet9", 0xE889 ), // glyphnumber: 2467, Tuplet 9 - std::pair( "tupletColon", 0xE88A ), // glyphnumber: 2468, Tuplet colon - std::pair( "unmeasuredTremolo", 0xE22C ), // glyphnumber: 2469, Wieniawski unmeasured tremolo - std::pair( "unmeasuredTremoloSimple", 0xE22D ), // glyphnumber: 2470, Wieniawski unmeasured tremolo (simpler) - std::pair( "unpitchedPercussionClef1", 0xE069 ), // glyphnumber: 2471, Unpitched percussion clef 1 - std::pair( "unpitchedPercussionClef2", 0xE06A ), // glyphnumber: 2472, Unpitched percussion clef 2 - std::pair( "ventiduesima", 0xE517 ), // glyphnumber: 2473, Ventiduesima - std::pair( "ventiduesimaAlta", 0xE518 ), // glyphnumber: 2474, Ventiduesima alta - std::pair( "ventiduesimaBassa", 0xE519 ), // glyphnumber: 2475, Ventiduesima bassa - std::pair( "ventiduesimaBassaMb", 0xE51E ), // glyphnumber: 2476, Ventiduesima bassa (mb) - std::pair( "vocalFingerClickStockhausen", 0xE649 ), // glyphnumber: 2477, Finger click (Stockhausen) - std::pair( "vocalMouthClosed", 0xE640 ), // glyphnumber: 2478, Mouth closed - std::pair( "vocalMouthOpen", 0xE642 ), // glyphnumber: 2479, Mouth open - std::pair( "vocalMouthPursed", 0xE644 ), // glyphnumber: 2480, Mouth pursed - std::pair( "vocalMouthSlightlyOpen", 0xE641 ), // glyphnumber: 2481, Mouth slightly open - std::pair( "vocalMouthWideOpen", 0xE643 ), // glyphnumber: 2482, Mouth wide open - std::pair( "vocalNasalVoice", 0xE647 ), // glyphnumber: 2483, Nasal voice - std::pair( "vocalSprechgesang", 0xE645 ), // glyphnumber: 2484, Sprechgesang - std::pair( "vocalTongueClickStockhausen", 0xE648 ), // glyphnumber: 2485, Tongue click (Stockhausen) - std::pair( "vocalTongueFingerClickStockhausen", 0xE64A ), // glyphnumber: 2486, Tongue and finger click (Stockhausen) - std::pair( "vocalsSussurando", 0xE646 ), // glyphnumber: 2487, Combining sussurando for stem - std::pair( "wiggleArpeggiatoDown", 0xEAAA ), // glyphnumber: 2488, Arpeggiato wiggle segment, downwards - std::pair( "wiggleArpeggiatoDownArrow", 0xEAAE ), // glyphnumber: 2489, Arpeggiato arrowhead down - std::pair( "wiggleArpeggiatoDownSwash", 0xEAAC ), // glyphnumber: 2490, Arpeggiato downward swash - std::pair( "wiggleArpeggiatoUp", 0xEAA9 ), // glyphnumber: 2491, Arpeggiato wiggle segment, upwards - std::pair( "wiggleArpeggiatoUpArrow", 0xEAAD ), // glyphnumber: 2492, Arpeggiato arrowhead up - std::pair( "wiggleArpeggiatoUpSwash", 0xEAAB ), // glyphnumber: 2493, Arpeggiato upward swash - std::pair( "wiggleCircular", 0xEAC9 ), // glyphnumber: 2494, Circular motion segment - std::pair( "wiggleCircularConstant", 0xEAC0 ), // glyphnumber: 2495, Constant circular motion segment - std::pair( "wiggleCircularConstantFlipped", 0xEAC1 ), // glyphnumber: 2496, Constant circular motion segment (flipped) - std::pair( "wiggleCircularConstantFlippedLarge", 0xEAC3 ), // glyphnumber: 2497, Constant circular motion segment (flipped, large) - std::pair( "wiggleCircularConstantLarge", 0xEAC2 ), // glyphnumber: 2498, Constant circular motion segment (large) - std::pair( "wiggleCircularEnd", 0xEACB ), // glyphnumber: 2499, Circular motion end - std::pair( "wiggleCircularLarge", 0xEAC8 ), // glyphnumber: 2500, Circular motion segment, large - std::pair( "wiggleCircularLarger", 0xEAC7 ), // glyphnumber: 2501, Circular motion segment, larger - std::pair( "wiggleCircularLargerStill", 0xEAC6 ), // glyphnumber: 2502, Circular motion segment, larger still - std::pair( "wiggleCircularLargest", 0xEAC5 ), // glyphnumber: 2503, Circular motion segment, largest - std::pair( "wiggleCircularSmall", 0xEACA ), // glyphnumber: 2504, Circular motion segment, small - std::pair( "wiggleCircularStart", 0xEAC4 ), // glyphnumber: 2505, Circular motion start - std::pair( "wiggleGlissando", 0xEAAF ), // glyphnumber: 2506, Glissando wiggle segment - std::pair( "wiggleGlissandoGroup1", 0xEABD ), // glyphnumber: 2507, Group glissando 1 - std::pair( "wiggleGlissandoGroup2", 0xEABE ), // glyphnumber: 2508, Group glissando 2 - std::pair( "wiggleGlissandoGroup3", 0xEABF ), // glyphnumber: 2509, Group glissando 3 - std::pair( "wiggleRandom1", 0xEAF0 ), // glyphnumber: 2510, Quasi-random squiggle 1 - std::pair( "wiggleRandom2", 0xEAF1 ), // glyphnumber: 2511, Quasi-random squiggle 2 - std::pair( "wiggleRandom3", 0xEAF2 ), // glyphnumber: 2512, Quasi-random squiggle 3 - std::pair( "wiggleRandom4", 0xEAF3 ), // glyphnumber: 2513, Quasi-random squiggle 4 - std::pair( "wiggleSawtooth", 0xEABB ), // glyphnumber: 2514, Sawtooth line segment - std::pair( "wiggleSawtoothNarrow", 0xEABA ), // glyphnumber: 2515, Narrow sawtooth line segment - std::pair( "wiggleSawtoothWide", 0xEABC ), // glyphnumber: 2516, Wide sawtooth line segment - std::pair( "wiggleSquareWave", 0xEAB8 ), // glyphnumber: 2517, Square wave line segment - std::pair( "wiggleSquareWaveNarrow", 0xEAB7 ), // glyphnumber: 2518, Narrow square wave line segment - std::pair( "wiggleSquareWaveWide", 0xEAB9 ), // glyphnumber: 2519, Wide square wave line segment - std::pair( "wiggleTrill", 0xEAA4 ), // glyphnumber: 2520, Trill wiggle segment - std::pair( "wiggleTrillFast", 0xEAA3 ), // glyphnumber: 2521, Trill wiggle segment, fast - std::pair( "wiggleTrillFaster", 0xEAA2 ), // glyphnumber: 2522, Trill wiggle segment, faster - std::pair( "wiggleTrillFasterStill", 0xEAA1 ), // glyphnumber: 2523, Trill wiggle segment, faster still - std::pair( "wiggleTrillFastest", 0xEAA0 ), // glyphnumber: 2524, Trill wiggle segment, fastest - std::pair( "wiggleTrillSlow", 0xEAA5 ), // glyphnumber: 2525, Trill wiggle segment, slow - std::pair( "wiggleTrillSlower", 0xEAA6 ), // glyphnumber: 2526, Trill wiggle segment, slower - std::pair( "wiggleTrillSlowerStill", 0xEAA7 ), // glyphnumber: 2527, Trill wiggle segment, slower still - std::pair( "wiggleTrillSlowest", 0xEAA8 ), // glyphnumber: 2528, Trill wiggle segment, slowest - std::pair( "wiggleVIbratoLargestSlower", 0xEAEE ), // glyphnumber: 2529, Vibrato largest, slower - std::pair( "wiggleVIbratoMediumSlower", 0xEAE0 ), // glyphnumber: 2530, Vibrato medium, slower - std::pair( "wiggleVibrato", 0xEAB0 ), // glyphnumber: 2531, Vibrato / shake wiggle segment - std::pair( "wiggleVibratoLargeFast", 0xEAE5 ), // glyphnumber: 2532, Vibrato large, fast - std::pair( "wiggleVibratoLargeFaster", 0xEAE4 ), // glyphnumber: 2533, Vibrato large, faster - std::pair( "wiggleVibratoLargeFasterStill", 0xEAE3 ), // glyphnumber: 2534, Vibrato large, faster still - std::pair( "wiggleVibratoLargeFastest", 0xEAE2 ), // glyphnumber: 2535, Vibrato large, fastest - std::pair( "wiggleVibratoLargeSlow", 0xEAE6 ), // glyphnumber: 2536, Vibrato large, slow - std::pair( "wiggleVibratoLargeSlower", 0xEAE7 ), // glyphnumber: 2537, Vibrato large, slower - std::pair( "wiggleVibratoLargeSlowest", 0xEAE8 ), // glyphnumber: 2538, Vibrato large, slowest - std::pair( "wiggleVibratoLargestFast", 0xEAEC ), // glyphnumber: 2539, Vibrato largest, fast - std::pair( "wiggleVibratoLargestFaster", 0xEAEB ), // glyphnumber: 2540, Vibrato largest, faster - std::pair( "wiggleVibratoLargestFasterStill", 0xEAEA ), // glyphnumber: 2541, Vibrato largest, faster still - std::pair( "wiggleVibratoLargestFastest", 0xEAE9 ), // glyphnumber: 2542, Vibrato largest, fastest - std::pair( "wiggleVibratoLargestSlow", 0xEAED ), // glyphnumber: 2543, Vibrato largest, slow - std::pair( "wiggleVibratoLargestSlowest", 0xEAEF ), // glyphnumber: 2544, Vibrato largest, slowest - std::pair( "wiggleVibratoMediumFast", 0xEADE ), // glyphnumber: 2545, Vibrato medium, fast - std::pair( "wiggleVibratoMediumFaster", 0xEADD ), // glyphnumber: 2546, Vibrato medium, faster - std::pair( "wiggleVibratoMediumFasterStill", 0xEADC ), // glyphnumber: 2547, Vibrato medium, faster still - std::pair( "wiggleVibratoMediumFastest", 0xEADB ), // glyphnumber: 2548, Vibrato medium, fastest - std::pair( "wiggleVibratoMediumSlow", 0xEADF ), // glyphnumber: 2549, Vibrato medium, slow - std::pair( "wiggleVibratoMediumSlowest", 0xEAE1 ), // glyphnumber: 2550, Vibrato medium, slowest - std::pair( "wiggleVibratoSmallFast", 0xEAD7 ), // glyphnumber: 2551, Vibrato small, fast - std::pair( "wiggleVibratoSmallFaster", 0xEAD6 ), // glyphnumber: 2552, Vibrato small, faster - std::pair( "wiggleVibratoSmallFasterStill", 0xEAD5 ), // glyphnumber: 2553, Vibrato small, faster still - std::pair( "wiggleVibratoSmallFastest", 0xEAD4 ), // glyphnumber: 2554, Vibrato small, fastest - std::pair( "wiggleVibratoSmallSlow", 0xEAD8 ), // glyphnumber: 2555, Vibrato small, slow - std::pair( "wiggleVibratoSmallSlower", 0xEAD9 ), // glyphnumber: 2556, Vibrato small, slower - std::pair( "wiggleVibratoSmallSlowest", 0xEADA ), // glyphnumber: 2557, Vibrato small, slowest - std::pair( "wiggleVibratoSmallestFast", 0xEAD0 ), // glyphnumber: 2558, Vibrato smallest, fast - std::pair( "wiggleVibratoSmallestFaster", 0xEACF ), // glyphnumber: 2559, Vibrato smallest, faster - std::pair( "wiggleVibratoSmallestFasterStill", 0xEACE ), // glyphnumber: 2560, Vibrato smallest, faster still - std::pair( "wiggleVibratoSmallestFastest", 0xEACD ), // glyphnumber: 2561, Vibrato smallest, fastest - std::pair( "wiggleVibratoSmallestSlow", 0xEAD1 ), // glyphnumber: 2562, Vibrato smallest, slow - std::pair( "wiggleVibratoSmallestSlower", 0xEAD2 ), // glyphnumber: 2563, Vibrato smallest, slower - std::pair( "wiggleVibratoSmallestSlowest", 0xEAD3 ), // glyphnumber: 2564, Vibrato smallest, slowest - std::pair( "wiggleVibratoStart", 0xEACC ), // glyphnumber: 2565, Vibrato start - std::pair( "wiggleVibratoWide", 0xEAB1 ), // glyphnumber: 2566, Wide vibrato / shake wiggle segment - std::pair( "wiggleWavy", 0xEAB5 ), // glyphnumber: 2567, Wavy line segment - std::pair( "wiggleWavyNarrow", 0xEAB4 ), // glyphnumber: 2568, Narrow wavy line segment - std::pair( "wiggleWavyWide", 0xEAB6 ), // glyphnumber: 2569, Wide wavy line segment - std::pair( "windClosedHole", 0xE5F4 ), // glyphnumber: 2570, Closed hole - std::pair( "windFlatEmbouchure", 0xE5FB ), // glyphnumber: 2571, Flatter embouchure - std::pair( "windHalfClosedHole1", 0xE5F6 ), // glyphnumber: 2572, Half-closed hole - std::pair( "windHalfClosedHole2", 0xE5F7 ), // glyphnumber: 2573, Half-closed hole 2 - std::pair( "windHalfClosedHole3", 0xE5F8 ), // glyphnumber: 2574, Half-open hole - std::pair( "windLessRelaxedEmbouchure", 0xE5FE ), // glyphnumber: 2575, Somewhat relaxed embouchure - std::pair( "windLessTightEmbouchure", 0xE600 ), // glyphnumber: 2576, Somewhat tight embouchure - std::pair( "windMouthpiecePop", 0xE60A ), // glyphnumber: 2577, Mouthpiece or hand pop - std::pair( "windMultiphonicsBlackStem", 0xE607 ), // glyphnumber: 2578, Combining multiphonics (black) for stem - std::pair( "windMultiphonicsBlackWhiteStem", 0xE609 ), // glyphnumber: 2579, Combining multiphonics (black and white) for stem - std::pair( "windMultiphonicsWhiteStem", 0xE608 ), // glyphnumber: 2580, Combining multiphonics (white) for stem - std::pair( "windOpenHole", 0xE5F9 ), // glyphnumber: 2581, Open hole - std::pair( "windReedPositionIn", 0xE606 ), // glyphnumber: 2582, Much more reed (push inwards) - std::pair( "windReedPositionNormal", 0xE604 ), // glyphnumber: 2583, Normal reed position - std::pair( "windReedPositionOut", 0xE605 ), // glyphnumber: 2584, Very little reed (pull outwards) - std::pair( "windRelaxedEmbouchure", 0xE5FD ), // glyphnumber: 2585, Relaxed embouchure - std::pair( "windRimOnly", 0xE60B ), // glyphnumber: 2586, Rim only - std::pair( "windSharpEmbouchure", 0xE5FC ), // glyphnumber: 2587, Sharper embouchure - std::pair( "windStrongAirPressure", 0xE603 ), // glyphnumber: 2588, Very tight embouchure / strong air pressure - std::pair( "windThreeQuartersClosedHole", 0xE5F5 ), // glyphnumber: 2589, Three-quarters closed hole - std::pair( "windTightEmbouchure", 0xE5FF ), // glyphnumber: 2590, Tight embouchure - std::pair( "windTrillKey", 0xE5FA ), // glyphnumber: 2591, Trill key - std::pair( "windVeryTightEmbouchure", 0xE601 ), // glyphnumber: 2592, Very tight embouchure - std::pair( "windWeakAirPressure", 0xE602 ), // glyphnumber: 2593, Very relaxed embouchure / weak air-pressure - }; - - SmuflGlyphname::SmuflGlyphname( std::string inNameAbove, - std::string inNameBelow, - std::string inNameUnspecified ) - : above{ inNameAbove } - , below{ inNameBelow } - , unspecified{ inNameUnspecified } - { - - } - - - const std::string& SmuflGlyphname::getName() const - { - return unspecified; - } - - - const std::string& SmuflGlyphname::getName( Placement placement ) const - { - switch ( placement ) - { - case Placement::above: return above; - case Placement::below: return below; - case Placement::unspecified: return unspecified; - default: break; - } - return unspecified; - } - - Smufl& Smufl::getInstance() - { - static Smufl instance; - return instance; - - } - - Smufl::Smufl() - { - } - - char16_t Smufl::findCodepoint(const std::string& inName) - { - const SmuflIter iter = sMap.find( inName ); - if( iter == sMap.cend() ) - { - std::cout << "WARN: findCodepoint missing: " << inName << std::endl; - return 0; - } - return iter->second; - } - - - const std::string& Smufl::findName( char16_t codepoint ) - { - static std::string empty = ""; - - auto lambda = [&codepoint](const SmuflPair item) - { - return item.second == codepoint; - }; - - const SmuflIter iter = std::find_if( sMap.cbegin(), sMap.cend(), lambda ); - - if( iter == sMap.cend() ) - { - std::cout << "WARN: findName missing: " << codepoint << std::endl; - return empty; - } - - return iter->first; - } - } -} diff --git a/Sourcecode/mx/api/Smufl.h b/Sourcecode/mx/api/Smufl.h deleted file mode 100644 index b72d27bae..000000000 --- a/Sourcecode/mx/api/Smufl.h +++ /dev/null @@ -1,50 +0,0 @@ -// MusicXML Class Library -// Copyright (c) by Matthew James Briggs -// Distributed under the MIT License - -#pragma once - -#include "mx/api/ApiCommon.h" - -#include -#include - -namespace mx -{ - namespace api - { - struct SmuflGlyphname - { - SmuflGlyphname( std::string inNameAbove, - std::string inNameBelow, - std::string inNameUnspecified ); - - const std::string above; - const std::string below; - const std::string unspecified; - - const std::string& getName() const; - const std::string& getName( api::Placement placement ) const; - }; - - - class Smufl - { - - public: - - static Smufl& getInstance(); - - // returns the SMuFL codepoint value for the given name - // returns 0 (i.e. '\0';) if not found - static char16_t findCodepoint(const std::string& inName); - - // finds the SMuFL glyphname for the given codepoint - // returns empty string if codepoint is not found - static const std::string& findName( char16_t codepoint ); - - private: - Smufl(); - }; - } -} diff --git a/Sourcecode/mx/impl/AccidentalMarkFunctions.cpp b/Sourcecode/mx/impl/AccidentalMarkFunctions.cpp index 85237ce65..ef3d82f9c 100644 --- a/Sourcecode/mx/impl/AccidentalMarkFunctions.cpp +++ b/Sourcecode/mx/impl/AccidentalMarkFunctions.cpp @@ -30,8 +30,6 @@ namespace mx markData.name = core::toString( accidentalValue ); markData.positionData = impl::getPositionData( *myAccidentalMark.getAttributes() ); - markData.smuflName = api::MarkSmufl::getName( markType, markData.positionData.placement ); - markData.smuflCodepoint = api::MarkSmufl::getCodepoint( markType, markData.positionData.placement ); return markData; } } diff --git a/Sourcecode/mx/impl/ArticulationsFunctions.cpp b/Sourcecode/mx/impl/ArticulationsFunctions.cpp index 28ce157ab..56836a28a 100644 --- a/Sourcecode/mx/impl/ArticulationsFunctions.cpp +++ b/Sourcecode/mx/impl/ArticulationsFunctions.cpp @@ -52,13 +52,6 @@ namespace mx markData.tickTimePosition = myCursor.tickTimePosition; parseArticulation( *articulation, markData ); - - if( markType != api::MarkType::otherArticulation ) - { - markData.smuflName = api::MarkSmufl::getName( markType, markData.positionData.placement ); - markData.smuflCodepoint = api::MarkSmufl::getCodepoint( markType, markData.positionData.placement ); - } - outMarks.emplace_back( std::move( markData ) ); } } @@ -162,8 +155,14 @@ namespace mx { parseMarkDataAttributes( *inArticulation.getOtherArticulation()->getAttributes(), outMark ); outMark.name = inArticulation.getOtherArticulation()->getValue().getValue(); - outMark.smuflName = outMark.name; - outMark.smuflCodepoint = api::Smufl::findCodepoint( outMark.smuflName ); + + const auto possibleCustomMarkType = mx::api::getMarkTypeFromCustomString( outMark.name ); + + if( possibleCustomMarkType != mx::api::MarkType::customErrorUnknown ) + { + outMark.markType = possibleCustomMarkType; + } + break; } default: diff --git a/Sourcecode/mx/impl/Converter.cpp b/Sourcecode/mx/impl/Converter.cpp index e255848bd..49d481cd3 100644 --- a/Sourcecode/mx/impl/Converter.cpp +++ b/Sourcecode/mx/impl/Converter.cpp @@ -171,7 +171,7 @@ namespace mx std::pair{ core::CssFontSize::xxLarge, api::CssSize::xxLarge }, }; - + // TODO - SMUFLKILL const std::map Converter::articulationsMap = { std::pair{ core::ArticulationsChoice::Choice::accent, api::MarkType::accent }, diff --git a/Sourcecode/mx/impl/DirectionReader.cpp b/Sourcecode/mx/impl/DirectionReader.cpp index 475496a1d..9341e9792 100644 --- a/Sourcecode/mx/impl/DirectionReader.cpp +++ b/Sourcecode/mx/impl/DirectionReader.cpp @@ -425,20 +425,7 @@ namespace mx placement = myOutDirectionData.placement; } - if( valueObject.getValue() == core::DynamicsEnum::otherDynamics ) - { - auto codePoint = api::Smufl::findCodepoint( mark.name ); - if( codePoint > 0 ) - { - mark.smuflCodepoint = codePoint; - mark.smuflName = mark.name; - } - } - else - { - mark.smuflName = api::MarkSmufl::getName( mark.markType, placement ); - mark.smuflCodepoint = api::MarkSmufl::getCodepoint( mark.markType, placement ); - } + mark.name = valueObject.getValueString(); myOutDirectionData.marks.emplace_back( std::move( mark ) ); } diff --git a/Sourcecode/mx/impl/DynamicsReader.cpp b/Sourcecode/mx/impl/DynamicsReader.cpp index 40bdcc0d4..6cfb3c174 100644 --- a/Sourcecode/mx/impl/DynamicsReader.cpp +++ b/Sourcecode/mx/impl/DynamicsReader.cpp @@ -3,7 +3,6 @@ // Distributed under the MIT License #include "mx/impl/DynamicsReader.h" -#include "mx/api/Smufl.h" #include "mx/core/elements/Dynamics.h" #include "mx/core/Enums.h" #include "mx/impl/Converter.h" @@ -33,22 +32,6 @@ namespace mx markData.tickTimePosition = myCursor.tickTimePosition; markData.name = myDynamic.getValue().getValueString(); markData.positionData = impl::getPositionData( *myDynamic.getAttributes() ); - - if( dynamicType == core::DynamicsEnum::otherDynamics ) - { - const auto value = myDynamic.getValue().getValueString(); - const auto tempChar = api::Smufl::findCodepoint( value ); - if( tempChar != 0 ) - { - markData.smuflName = value; - markData.smuflCodepoint = tempChar; - } - } - else - { - markData.smuflName = api::MarkSmufl::getName( markType, markData.positionData.placement ); - markData.smuflCodepoint = api::MarkSmufl::getCodepoint( markType, markData.positionData.placement ); - } outMarks.emplace_back( std::move( markData ) ); } } diff --git a/Sourcecode/mx/impl/DynamicsWriter.cpp b/Sourcecode/mx/impl/DynamicsWriter.cpp index 0be982948..a35564169 100644 --- a/Sourcecode/mx/impl/DynamicsWriter.cpp +++ b/Sourcecode/mx/impl/DynamicsWriter.cpp @@ -33,21 +33,12 @@ namespace mx { auto dyn = core::makeDynamics(); - // if( myMarkData.positionData.placement != api::Placement::unspecified ) - // { - // dyn->getAttributes()->hasPlacement = true; - // dyn->getAttributes()->placement = myConverter.convert( myMarkData.positionData.placement ); - // } const auto value = myConverter.convertDynamic( myMarkData.markType ); core::DynamicsValue dynamicsValue; dynamicsValue.setValue( value ); const bool isOther = value == core::DynamicsEnum::otherDynamics; - if( isOther && !myMarkData.smuflName.empty() ) - { - dynamicsValue.setValue( myMarkData.smuflName ); - } - else if ( isOther && !myMarkData.name.empty() ) + if ( isOther && !myMarkData.name.empty() ) { dynamicsValue.setValue( myMarkData.name ); } diff --git a/Sourcecode/mx/impl/MeasureReader.cpp b/Sourcecode/mx/impl/MeasureReader.cpp index 8e7ef3481..dc9e3fab3 100644 --- a/Sourcecode/mx/impl/MeasureReader.cpp +++ b/Sourcecode/mx/impl/MeasureReader.cpp @@ -6,7 +6,6 @@ #include "mx/api/ClefData.h" #include "mx/api/KeyData.h" #include "mx/api/NoteData.h" -#include "mx/api/Smufl.h" #include "mx/core/elements/Alter.h" #include "mx/core/elements/Backup.h" #include "mx/core/elements/Barline.h" diff --git a/Sourcecode/mx/impl/MxVersionDefines.h b/Sourcecode/mx/impl/MxVersionDefines.h index 6c6c1f780..b75cef2d3 100644 --- a/Sourcecode/mx/impl/MxVersionDefines.h +++ b/Sourcecode/mx/impl/MxVersionDefines.h @@ -1,4 +1,4 @@ #define MX_VERSION_MAJOR 0 #define MX_VERSION_MINOR 3 #define MX_VERSION_PATCH 1 -#define MX_VERSION_BUILD 32 +#define MX_VERSION_BUILD 37 diff --git a/Sourcecode/mx/impl/NotationsWriter.cpp b/Sourcecode/mx/impl/NotationsWriter.cpp index 54fd24238..6289e328d 100644 --- a/Sourcecode/mx/impl/NotationsWriter.cpp +++ b/Sourcecode/mx/impl/NotationsWriter.cpp @@ -252,7 +252,7 @@ namespace mx for( const auto& mark : myNoteData.noteAttachmentData.marks ) { - if( isMarkArticulation( mark.markType ) ) + if( isMarkArticulation( mark.markType ) || isMarkCustom( mark.markType ) ) { this->addArticulation( mark, articulations ); } @@ -397,7 +397,7 @@ namespace mx void NotationsWriter::addArticulation( const api::MarkData& mark, const core::ArticulationsPtr& outArticulationsPtr ) const { - if( !myConverter.isArticulation( mark.markType ) ) + if( !myConverter.isArticulation( mark.markType ) && !api::isMarkCustom( mark.markType ) ) { return; } @@ -497,6 +497,14 @@ namespace mx auto attributes = element->getAttributes(); setAttributesFromPositionData( mark.positionData, *attributes); } + else if( api::isMarkCustom( mark.markType ) ) + { + const auto customName = api::getCustomMarkName( mark.markType ); + auto element = articulationsChoice->getOtherArticulation(); + element->setValue( core::XsString{ customName } ); + auto attributes = element->getAttributes(); + setAttributesFromPositionData( mark.positionData, *attributes); + } else if( mark.markType == api::MarkType::otherArticulation ) { auto element = articulationsChoice->getOtherArticulation(); @@ -594,9 +602,14 @@ namespace mx attributes->type = mx::core::StartStopSingle::single; setAttributesFromPositionData( mark.positionData, *attributes); element->setValue( mx::core::TremoloMarks{ api::numTremoloSlashes( mark.markType ) } ); + } + else if( api::isMarkCustom( mark.markType ) ) + { + } else if( ( mark.markType == api::MarkType::unknownOrnament ) || ( mark.markType == api::MarkType::otherOrnament ) ) + // TODO - SMUFLKILL - handle custom enum values? { auto element = ornamentsChoice->getOtherOrnament(); auto attributes = element->getAttributes(); @@ -606,10 +619,6 @@ namespace mx { element->setValue( core::XsString{ mark.name } ); } - else if ( !mark.smuflName.empty() ) - { - element->setValue( core::XsString{ mark.smuflName } ); - } } } @@ -708,10 +717,6 @@ namespace mx { element->setValue( core::XsString{ mark.name } ); } - else if ( !mark.smuflName.empty() ) - { - element->setValue( core::XsString{ mark.smuflName } ); - } } } } diff --git a/Sourcecode/mx/impl/OrnamentsFunctions.cpp b/Sourcecode/mx/impl/OrnamentsFunctions.cpp index d9a84772e..e82d12c82 100644 --- a/Sourcecode/mx/impl/OrnamentsFunctions.cpp +++ b/Sourcecode/mx/impl/OrnamentsFunctions.cpp @@ -51,11 +51,10 @@ namespace mx parseOrnament( *ornament, markData ); markData.tickTimePosition = myCursor.tickTimePosition; - if( ( markData.markType != api::MarkType::otherOrnament ) && - ( markData.markType != api::MarkType::unknownOrnament ) ) + if( ( markData.markType == api::MarkType::otherOrnament ) || + ( markData.markType == api::MarkType::unknownOrnament ) ) { - markData.smuflName = api::MarkSmufl::getName( markType, markData.positionData.placement ); - markData.smuflCodepoint = api::MarkSmufl::getCodepoint( markType, markData.positionData.placement ); + // TODO - SMUFLKILL - use the name to see if we have a custom enum value } if( markData.markType != api::MarkType::unknownOrnament ) @@ -203,14 +202,6 @@ namespace mx outMark.name = value; } - const auto tempChar = api::Smufl::findCodepoint( value ); - - if( tempChar != 0 ) - { - outMark.smuflName = value; - outMark.smuflCodepoint = tempChar; - } - break; } default: diff --git a/Sourcecode/mx/impl/PartReader.h b/Sourcecode/mx/impl/PartReader.h index bb8b9c301..5911503a4 100644 --- a/Sourcecode/mx/impl/PartReader.h +++ b/Sourcecode/mx/impl/PartReader.h @@ -8,6 +8,7 @@ #include "mx/impl/MeasureCursor.h" #include +#include namespace mx { diff --git a/Sourcecode/mx/impl/PartWriter.h b/Sourcecode/mx/impl/PartWriter.h index 21cbef2b0..cc6de18e3 100644 --- a/Sourcecode/mx/impl/PartWriter.h +++ b/Sourcecode/mx/impl/PartWriter.h @@ -6,6 +6,7 @@ #include "mx/api/PartData.h" #include +#include namespace mx { diff --git a/Sourcecode/mx/impl/ScoreReader.h b/Sourcecode/mx/impl/ScoreReader.h index 8c269fdca..09a917c65 100644 --- a/Sourcecode/mx/impl/ScoreReader.h +++ b/Sourcecode/mx/impl/ScoreReader.h @@ -9,6 +9,7 @@ #include #include #include +#include namespace mx { diff --git a/Sourcecode/mx/impl/SmuflGlyphMap.h b/Sourcecode/mx/impl/SmuflGlyphMap.h deleted file mode 100644 index d164d0691..000000000 --- a/Sourcecode/mx/impl/SmuflGlyphMap.h +++ /dev/null @@ -1,2612 +0,0 @@ -// MusicXML Class Library -// Copyright (c) by Matthew James Briggs -// Distributed under the MIT License - -#pragma once - -#include -#include - -namespace mx -{ - namespace impl - { - inline void createSmuflMap(std::map& outMap) - { - outMap.emplace(std::make_pair( "4stringTabClef", 0xE06E )); // glyphnumber: 0, 4-string tab clef - outMap.emplace(std::make_pair( "6stringTabClef", 0xE06D )); // glyphnumber: 1, 6-string tab clef - outMap.emplace(std::make_pair( "accSagittal11LargeDiesisDown", 0xE30D )); // glyphnumber: 2, 11 large diesis down, 3° down [46 EDO] - outMap.emplace(std::make_pair( "accSagittal11LargeDiesisUp", 0xE30C )); // glyphnumber: 3, 11 large diesis up, (11L), (sharp less 11M), 3° up [46 EDO] - outMap.emplace(std::make_pair( "accSagittal11MediumDiesisDown", 0xE30B )); // glyphnumber: 4, 11 medium diesis down, 1°[17 31] 2°46 down, 1/4-tone down - outMap.emplace(std::make_pair( "accSagittal11MediumDiesisUp", 0xE30A )); // glyphnumber: 5, 11 medium diesis up, (11M), 1°[17 31] 2°46 up, 1/4-tone up - outMap.emplace(std::make_pair( "accSagittal11v19LargeDiesisDown", 0xE3AB )); // glyphnumber: 6, 11:19 large diesis down - outMap.emplace(std::make_pair( "accSagittal11v19LargeDiesisUp", 0xE3AA )); // glyphnumber: 7, 11:19 large diesis up, (11:19L, apotome less 11:19M) - outMap.emplace(std::make_pair( "accSagittal11v19MediumDiesisDown", 0xE3A3 )); // glyphnumber: 8, 11:19 medium diesis down - outMap.emplace(std::make_pair( "accSagittal11v19MediumDiesisUp", 0xE3A2 )); // glyphnumber: 9, 11:19 medium diesis up, (11:19M, 11M plus 19s) - outMap.emplace(std::make_pair( "accSagittal11v49CommaDown", 0xE397 )); // glyphnumber: 10, 11:49 comma down - outMap.emplace(std::make_pair( "accSagittal11v49CommaUp", 0xE396 )); // glyphnumber: 11, 11:49 comma up, (11:49C, 11M less 49C) - outMap.emplace(std::make_pair( "accSagittal143CommaDown", 0xE395 )); // glyphnumber: 12, 143 comma down - outMap.emplace(std::make_pair( "accSagittal143CommaUp", 0xE394 )); // glyphnumber: 13, 143 comma up, (143C, 13L less 11M) - outMap.emplace(std::make_pair( "accSagittal17CommaDown", 0xE343 )); // glyphnumber: 14, 17 comma down - outMap.emplace(std::make_pair( "accSagittal17CommaUp", 0xE342 )); // glyphnumber: 15, 17 comma up, (17C) - outMap.emplace(std::make_pair( "accSagittal17KleismaDown", 0xE393 )); // glyphnumber: 16, 17 kleisma down - outMap.emplace(std::make_pair( "accSagittal17KleismaUp", 0xE392 )); // glyphnumber: 17, 17 kleisma up, (17k) - outMap.emplace(std::make_pair( "accSagittal19CommaDown", 0xE399 )); // glyphnumber: 18, 19 comma down - outMap.emplace(std::make_pair( "accSagittal19CommaUp", 0xE398 )); // glyphnumber: 19, 19 comma up, (19C) - outMap.emplace(std::make_pair( "accSagittal19SchismaDown", 0xE391 )); // glyphnumber: 20, 19 schisma down - outMap.emplace(std::make_pair( "accSagittal19SchismaUp", 0xE390 )); // glyphnumber: 21, 19 schisma up, (19s) - outMap.emplace(std::make_pair( "accSagittal23CommaDown", 0xE371 )); // glyphnumber: 22, 23 comma down, 2° down [96 EDO], 1/8-tone down - outMap.emplace(std::make_pair( "accSagittal23CommaUp", 0xE370 )); // glyphnumber: 23, 23 comma up, (23C), 2° up [96 EDO], 1/8-tone up - outMap.emplace(std::make_pair( "accSagittal23SmallDiesisDown", 0xE39F )); // glyphnumber: 24, 23 small diesis down - outMap.emplace(std::make_pair( "accSagittal23SmallDiesisUp", 0xE39E )); // glyphnumber: 25, 23 small diesis up, (23S) - outMap.emplace(std::make_pair( "accSagittal25SmallDiesisDown", 0xE307 )); // glyphnumber: 26, 25 small diesis down, 2° down [53 EDO] - outMap.emplace(std::make_pair( "accSagittal25SmallDiesisUp", 0xE306 )); // glyphnumber: 27, 25 small diesis up, (25S, ~5:13S, ~37S, 5C plus 5C), 2° up [53 EDO] - outMap.emplace(std::make_pair( "accSagittal35LargeDiesisDown", 0xE30F )); // glyphnumber: 28, 35 large diesis down, 2° down [50 EDO], 5/18-tone down - outMap.emplace(std::make_pair( "accSagittal35LargeDiesisUp", 0xE30E )); // glyphnumber: 29, 35 large diesis up, (35L, ~13L, ~125L, sharp less 35M), 2°50 up - outMap.emplace(std::make_pair( "accSagittal35MediumDiesisDown", 0xE309 )); // glyphnumber: 30, 35 medium diesis down, 1°[50] 2°[27] down, 2/9-tone down - outMap.emplace(std::make_pair( "accSagittal35MediumDiesisUp", 0xE308 )); // glyphnumber: 31, 35 medium diesis up, (35M, ~13M, ~125M, 5C plus 7C), 2/9-tone up - outMap.emplace(std::make_pair( "accSagittal49LargeDiesisDown", 0xE3A9 )); // glyphnumber: 32, 49 large diesis down - outMap.emplace(std::make_pair( "accSagittal49LargeDiesisUp", 0xE3A8 )); // glyphnumber: 33, 49 large diesis up, (49L, ~31L, apotome less 49M) - outMap.emplace(std::make_pair( "accSagittal49MediumDiesisDown", 0xE3A5 )); // glyphnumber: 34, 49 medium diesis down - outMap.emplace(std::make_pair( "accSagittal49MediumDiesisUp", 0xE3A4 )); // glyphnumber: 35, 49 medium diesis up, (49M, ~31M, 7C plus 7C) - outMap.emplace(std::make_pair( "accSagittal49SmallDiesisDown", 0xE39D )); // glyphnumber: 36, 49 small diesis down - outMap.emplace(std::make_pair( "accSagittal49SmallDiesisUp", 0xE39C )); // glyphnumber: 37, 49 small diesis up, (49S, ~31S) - outMap.emplace(std::make_pair( "accSagittal55CommaDown", 0xE345 )); // glyphnumber: 38, 55 comma down, 3° down [96 EDO], 3/16-tone down - outMap.emplace(std::make_pair( "accSagittal55CommaUp", 0xE344 )); // glyphnumber: 39, 55 comma up, (55C, 11M less 5C), 3°up [96 EDO], 3/16-tone up - outMap.emplace(std::make_pair( "accSagittal5CommaDown", 0xE303 )); // glyphnumber: 40, 5 comma down, 1° down [22 27 29 34 41 46 53 96 EDOs], 1/12-tone down - outMap.emplace(std::make_pair( "accSagittal5CommaUp", 0xE302 )); // glyphnumber: 41, 5 comma up, (5C), 1° up [22 27 29 34 41 46 53 96 EDOs], 1/12-tone up - outMap.emplace(std::make_pair( "accSagittal5v11SmallDiesisDown", 0xE349 )); // glyphnumber: 42, 5:11 small diesis down - outMap.emplace(std::make_pair( "accSagittal5v11SmallDiesisUp", 0xE348 )); // glyphnumber: 43, 5:11 small diesis up, (5:11S, ~7:13S, ~11:17S, 5:7k plus 7:11C) - outMap.emplace(std::make_pair( "accSagittal5v13LargeDiesisDown", 0xE3AD )); // glyphnumber: 44, 5:13 large diesis down - outMap.emplace(std::make_pair( "accSagittal5v13LargeDiesisUp", 0xE3AC )); // glyphnumber: 45, 5:13 large diesis up, (5:13L, ~37L, apotome less 5:13M) - outMap.emplace(std::make_pair( "accSagittal5v13MediumDiesisDown", 0xE3A1 )); // glyphnumber: 46, 5:13 medium diesis down - outMap.emplace(std::make_pair( "accSagittal5v13MediumDiesisUp", 0xE3A0 )); // glyphnumber: 47, 5:13 medium diesis up, (5:13M, ~37M, 5C plus 13C) - outMap.emplace(std::make_pair( "accSagittal5v19CommaDown", 0xE373 )); // glyphnumber: 48, 5:19 comma down, 1/20-tone down - outMap.emplace(std::make_pair( "accSagittal5v19CommaUp", 0xE372 )); // glyphnumber: 49, 5:19 comma up, (5:19C, 5C plus 19s), 1/20-tone up - outMap.emplace(std::make_pair( "accSagittal5v23SmallDiesisDown", 0xE375 )); // glyphnumber: 50, 5:23 small diesis down, 2° down [60 EDO], 1/5-tone down - outMap.emplace(std::make_pair( "accSagittal5v23SmallDiesisUp", 0xE374 )); // glyphnumber: 51, 5:23 small diesis up, (5:23S, 5C plus 23C), 2° up [60 EDO], 1/5-tone up - outMap.emplace(std::make_pair( "accSagittal5v49MediumDiesisDown", 0xE3A7 )); // glyphnumber: 52, 5:49 medium diesis down - outMap.emplace(std::make_pair( "accSagittal5v49MediumDiesisUp", 0xE3A6 )); // glyphnumber: 53, 5:49 medium diesis up, (5:49M, half apotome) - outMap.emplace(std::make_pair( "accSagittal5v7KleismaDown", 0xE301 )); // glyphnumber: 54, 5:7 kleisma down - outMap.emplace(std::make_pair( "accSagittal5v7KleismaUp", 0xE300 )); // glyphnumber: 55, 5:7 kleisma up, (5:7k, ~11:13k, 7C less 5C) - outMap.emplace(std::make_pair( "accSagittal7CommaDown", 0xE305 )); // glyphnumber: 56, 7 comma down, 1° down [43 EDO], 2° down [72 EDO], 1/6-tone down - outMap.emplace(std::make_pair( "accSagittal7CommaUp", 0xE304 )); // glyphnumber: 57, 7 comma up, (7C), 1° up [43 EDO], 2° up [72 EDO], 1/6-tone up - outMap.emplace(std::make_pair( "accSagittal7v11CommaDown", 0xE347 )); // glyphnumber: 58, 7:11 comma down, 1° down [60 EDO], 1/10-tone down - outMap.emplace(std::make_pair( "accSagittal7v11CommaUp", 0xE346 )); // glyphnumber: 59, 7:11 comma up, (7:11C, ~13:17S, ~29S, 11L less 7C), 1° up [60 EDO] - outMap.emplace(std::make_pair( "accSagittal7v11KleismaDown", 0xE341 )); // glyphnumber: 60, 7:11 kleisma down - outMap.emplace(std::make_pair( "accSagittal7v11KleismaUp", 0xE340 )); // glyphnumber: 61, 7:11 kleisma up, (7:11k, ~29k) - outMap.emplace(std::make_pair( "accSagittal7v19CommaDown", 0xE39B )); // glyphnumber: 62, 7:19 comma down - outMap.emplace(std::make_pair( "accSagittal7v19CommaUp", 0xE39A )); // glyphnumber: 63, 7:19 comma up, (7:19C, 7C less 19s) - outMap.emplace(std::make_pair( "accSagittalAcute", 0xE3F2 )); // glyphnumber: 64, Acute, 5 schisma up (5s), 2 cents up - outMap.emplace(std::make_pair( "accSagittalDoubleFlat", 0xE335 )); // glyphnumber: 65, Double flat, (2 apotomes down)[almost all EDOs], whole-tone down - outMap.emplace(std::make_pair( "accSagittalDoubleFlat11v49CUp", 0xE3E9 )); // glyphnumber: 66, Double flat 11:49C-up - outMap.emplace(std::make_pair( "accSagittalDoubleFlat143CUp", 0xE3EB )); // glyphnumber: 67, Double flat 143C-up - outMap.emplace(std::make_pair( "accSagittalDoubleFlat17CUp", 0xE365 )); // glyphnumber: 68, Double flat 17C-up - outMap.emplace(std::make_pair( "accSagittalDoubleFlat17kUp", 0xE3ED )); // glyphnumber: 69, Double flat 17k-up - outMap.emplace(std::make_pair( "accSagittalDoubleFlat19CUp", 0xE3E7 )); // glyphnumber: 70, Double flat 19C-up - outMap.emplace(std::make_pair( "accSagittalDoubleFlat19sUp", 0xE3EF )); // glyphnumber: 71, Double flat 19s-up - outMap.emplace(std::make_pair( "accSagittalDoubleFlat23CUp", 0xE387 )); // glyphnumber: 72, Double flat 23C-up, 14° down [96 EDO], 7/8-tone down - outMap.emplace(std::make_pair( "accSagittalDoubleFlat23SUp", 0xE3E1 )); // glyphnumber: 73, Double flat 23S-up - outMap.emplace(std::make_pair( "accSagittalDoubleFlat25SUp", 0xE32D )); // glyphnumber: 74, Double flat 25S-up, 8°down [53 EDO] - outMap.emplace(std::make_pair( "accSagittalDoubleFlat49SUp", 0xE3E3 )); // glyphnumber: 75, Double flat 49S-up - outMap.emplace(std::make_pair( "accSagittalDoubleFlat55CUp", 0xE363 )); // glyphnumber: 76, Double flat 55C-up, 13° down [96 EDO], 13/16-tone down - outMap.emplace(std::make_pair( "accSagittalDoubleFlat5CUp", 0xE331 )); // glyphnumber: 77, Double flat 5C-up, 5°[22 29] 7°[34 41] 9°53 down, 11/12 tone down - outMap.emplace(std::make_pair( "accSagittalDoubleFlat5v11SUp", 0xE35F )); // glyphnumber: 78, Double flat 5:11S-up - outMap.emplace(std::make_pair( "accSagittalDoubleFlat5v19CUp", 0xE385 )); // glyphnumber: 79, Double flat 5:19C-up, 19/20-tone down - outMap.emplace(std::make_pair( "accSagittalDoubleFlat5v23SUp", 0xE383 )); // glyphnumber: 80, Double flat 5:23S-up, 8° down [60 EDO], 4/5-tone down - outMap.emplace(std::make_pair( "accSagittalDoubleFlat5v7kUp", 0xE333 )); // glyphnumber: 81, Double flat 5:7k-up - outMap.emplace(std::make_pair( "accSagittalDoubleFlat7CUp", 0xE32F )); // glyphnumber: 82, Double flat 7C-up, 5° down [43 EDO], 10° down [72 EDO], 5/6-tone down - outMap.emplace(std::make_pair( "accSagittalDoubleFlat7v11CUp", 0xE361 )); // glyphnumber: 83, Double flat 7:11C-up, 9° down [60 EDO], 9/10-tone down - outMap.emplace(std::make_pair( "accSagittalDoubleFlat7v11kUp", 0xE367 )); // glyphnumber: 84, Double flat 7:11k-up - outMap.emplace(std::make_pair( "accSagittalDoubleFlat7v19CUp", 0xE3E5 )); // glyphnumber: 85, Double flat 7:19C-up - outMap.emplace(std::make_pair( "accSagittalDoubleSharp", 0xE334 )); // glyphnumber: 86, Double sharp, (2 apotomes up)[almost all EDOs], whole-tone up - outMap.emplace(std::make_pair( "accSagittalDoubleSharp11v49CDown", 0xE3E8 )); // glyphnumber: 87, Double sharp 11:49C-down - outMap.emplace(std::make_pair( "accSagittalDoubleSharp143CDown", 0xE3EA )); // glyphnumber: 88, Double sharp 143C-down - outMap.emplace(std::make_pair( "accSagittalDoubleSharp17CDown", 0xE364 )); // glyphnumber: 89, Double sharp 17C-down - outMap.emplace(std::make_pair( "accSagittalDoubleSharp17kDown", 0xE3EC )); // glyphnumber: 90, Double sharp 17k-down - outMap.emplace(std::make_pair( "accSagittalDoubleSharp19CDown", 0xE3E6 )); // glyphnumber: 91, Double sharp 19C-down - outMap.emplace(std::make_pair( "accSagittalDoubleSharp19sDown", 0xE3EE )); // glyphnumber: 92, Double sharp 19s-down - outMap.emplace(std::make_pair( "accSagittalDoubleSharp23CDown", 0xE386 )); // glyphnumber: 93, Double sharp 23C-down, 14°up [96 EDO], 7/8-tone up - outMap.emplace(std::make_pair( "accSagittalDoubleSharp23SDown", 0xE3E0 )); // glyphnumber: 94, Double sharp 23S-down - outMap.emplace(std::make_pair( "accSagittalDoubleSharp25SDown", 0xE32C )); // glyphnumber: 95, Double sharp 25S-down, 8°up [53 EDO] - outMap.emplace(std::make_pair( "accSagittalDoubleSharp49SDown", 0xE3E2 )); // glyphnumber: 96, Double sharp 49S-down - outMap.emplace(std::make_pair( "accSagittalDoubleSharp55CDown", 0xE362 )); // glyphnumber: 97, Double sharp 55C-down, 13° up [96 EDO], 13/16-tone up - outMap.emplace(std::make_pair( "accSagittalDoubleSharp5CDown", 0xE330 )); // glyphnumber: 98, Double sharp 5C-down, 5°[22 29] 7°[34 41] 9°53 up, 11/12 tone up - outMap.emplace(std::make_pair( "accSagittalDoubleSharp5v11SDown", 0xE35E )); // glyphnumber: 99, Double sharp 5:11S-down - outMap.emplace(std::make_pair( "accSagittalDoubleSharp5v19CDown", 0xE384 )); // glyphnumber: 100, Double sharp 5:19C-down, 19/20-tone up - outMap.emplace(std::make_pair( "accSagittalDoubleSharp5v23SDown", 0xE382 )); // glyphnumber: 101, Double sharp 5:23S-down, 8° up [60 EDO], 4/5-tone up - outMap.emplace(std::make_pair( "accSagittalDoubleSharp5v7kDown", 0xE332 )); // glyphnumber: 102, Double sharp 5:7k-down - outMap.emplace(std::make_pair( "accSagittalDoubleSharp7CDown", 0xE32E )); // glyphnumber: 103, Double sharp 7C-down, 5°[43] 10°[72] up, 5/6-tone up - outMap.emplace(std::make_pair( "accSagittalDoubleSharp7v11CDown", 0xE360 )); // glyphnumber: 104, Double sharp 7:11C-down, 9° up [60 EDO], 9/10-tone up - outMap.emplace(std::make_pair( "accSagittalDoubleSharp7v11kDown", 0xE366 )); // glyphnumber: 105, Double sharp 7:11k-down - outMap.emplace(std::make_pair( "accSagittalDoubleSharp7v19CDown", 0xE3E4 )); // glyphnumber: 106, Double sharp 7:19C-down - outMap.emplace(std::make_pair( "accSagittalFlat", 0xE319 )); // glyphnumber: 107, Flat, (apotome down)[almost all EDOs], 1/2-tone down - outMap.emplace(std::make_pair( "accSagittalFlat11LDown", 0xE329 )); // glyphnumber: 108, Flat 11L-down, 8° up [46 EDO] - outMap.emplace(std::make_pair( "accSagittalFlat11MDown", 0xE327 )); // glyphnumber: 109, Flat 11M-down, 3° down [17 31 EDOs], 7° down [46 EDO], 3/4-tone down - outMap.emplace(std::make_pair( "accSagittalFlat11v19LDown", 0xE3DB )); // glyphnumber: 110, Flat 11:19L-down - outMap.emplace(std::make_pair( "accSagittalFlat11v19MDown", 0xE3D3 )); // glyphnumber: 111, Flat 11:19M-down - outMap.emplace(std::make_pair( "accSagittalFlat11v49CDown", 0xE3C7 )); // glyphnumber: 112, Flat 11:49C-down - outMap.emplace(std::make_pair( "accSagittalFlat11v49CUp", 0xE3B9 )); // glyphnumber: 113, Flat 11:49C-up - outMap.emplace(std::make_pair( "accSagittalFlat143CDown", 0xE3C5 )); // glyphnumber: 114, Flat 143C-down - outMap.emplace(std::make_pair( "accSagittalFlat143CUp", 0xE3BB )); // glyphnumber: 115, Flat 143C-up - outMap.emplace(std::make_pair( "accSagittalFlat17CDown", 0xE357 )); // glyphnumber: 116, Flat 17C-down - outMap.emplace(std::make_pair( "accSagittalFlat17CUp", 0xE351 )); // glyphnumber: 117, Flat 17C-up - outMap.emplace(std::make_pair( "accSagittalFlat17kDown", 0xE3C3 )); // glyphnumber: 118, Flat 17k-down - outMap.emplace(std::make_pair( "accSagittalFlat17kUp", 0xE3BD )); // glyphnumber: 119, Flat 17k-up - outMap.emplace(std::make_pair( "accSagittalFlat19CDown", 0xE3C9 )); // glyphnumber: 120, Flat 19C-down - outMap.emplace(std::make_pair( "accSagittalFlat19CUp", 0xE3B7 )); // glyphnumber: 121, Flat 19C-up - outMap.emplace(std::make_pair( "accSagittalFlat19sDown", 0xE3C1 )); // glyphnumber: 122, Flat 19s-down - outMap.emplace(std::make_pair( "accSagittalFlat19sUp", 0xE3BF )); // glyphnumber: 123, Flat 19s-up - outMap.emplace(std::make_pair( "accSagittalFlat23CDown", 0xE37D )); // glyphnumber: 124, Flat 23C-down, 10° down [96 EDO], 5/8-tone down - outMap.emplace(std::make_pair( "accSagittalFlat23CUp", 0xE37B )); // glyphnumber: 125, Flat 23C-up, 6° down [96 EDO], 3/8-tone down - outMap.emplace(std::make_pair( "accSagittalFlat23SDown", 0xE3CF )); // glyphnumber: 126, Flat 23S-down - outMap.emplace(std::make_pair( "accSagittalFlat23SUp", 0xE3B1 )); // glyphnumber: 127, Flat 23S-up - outMap.emplace(std::make_pair( "accSagittalFlat25SDown", 0xE323 )); // glyphnumber: 128, Flat 25S-down, 7° down [53 EDO] - outMap.emplace(std::make_pair( "accSagittalFlat25SUp", 0xE311 )); // glyphnumber: 129, Flat 25S-up, 3° down [53 EDO] - outMap.emplace(std::make_pair( "accSagittalFlat35LDown", 0xE32B )); // glyphnumber: 130, Flat 35L-down, 5° down [50 EDO] - outMap.emplace(std::make_pair( "accSagittalFlat35MDown", 0xE325 )); // glyphnumber: 131, Flat 35M-down, 4° down [50 EDO], 6° down [27 EDO], 13/18-tone down - outMap.emplace(std::make_pair( "accSagittalFlat49LDown", 0xE3D9 )); // glyphnumber: 132, Flat 49L-down - outMap.emplace(std::make_pair( "accSagittalFlat49MDown", 0xE3D5 )); // glyphnumber: 133, Flat 49M-down - outMap.emplace(std::make_pair( "accSagittalFlat49SDown", 0xE3CD )); // glyphnumber: 134, Flat 49S-down - outMap.emplace(std::make_pair( "accSagittalFlat49SUp", 0xE3B3 )); // glyphnumber: 135, Flat 49S-up - outMap.emplace(std::make_pair( "accSagittalFlat55CDown", 0xE359 )); // glyphnumber: 136, Flat 55C-down, 11° down [96 EDO], 11/16-tone down - outMap.emplace(std::make_pair( "accSagittalFlat55CUp", 0xE34F )); // glyphnumber: 137, Flat 55C-up, 5° down [96 EDO], 5/16-tone down - outMap.emplace(std::make_pair( "accSagittalFlat5CDown", 0xE31F )); // glyphnumber: 138, Flat 5C-down, 4°[22 29] 5°[27 34 41] 6°[39 46 53] down, 7/12-tone down - outMap.emplace(std::make_pair( "accSagittalFlat5CUp", 0xE315 )); // glyphnumber: 139, Flat 5C-up, 2°[22,29] 3°[34 41] 4°[46 53 60] down, 5/12-tone down - outMap.emplace(std::make_pair( "accSagittalFlat5v11SDown", 0xE35D )); // glyphnumber: 140, Flat 5:11S-down - outMap.emplace(std::make_pair( "accSagittalFlat5v11SUp", 0xE34B )); // glyphnumber: 141, Flat 5:11S-up - outMap.emplace(std::make_pair( "accSagittalFlat5v13LDown", 0xE3DD )); // glyphnumber: 142, Flat 5:13L-down - outMap.emplace(std::make_pair( "accSagittalFlat5v13MDown", 0xE3D1 )); // glyphnumber: 143, Flat 5:13M-down - outMap.emplace(std::make_pair( "accSagittalFlat5v19CDown", 0xE37F )); // glyphnumber: 144, Flat 5:19C-down, 11/20-tone down - outMap.emplace(std::make_pair( "accSagittalFlat5v19CUp", 0xE379 )); // glyphnumber: 145, Flat 5:19C-up, 9/20-tone down - outMap.emplace(std::make_pair( "accSagittalFlat5v23SDown", 0xE381 )); // glyphnumber: 146, Flat 5:23S-down, 7° down [60 EDO], 7/10-tone down - outMap.emplace(std::make_pair( "accSagittalFlat5v23SUp", 0xE377 )); // glyphnumber: 147, Flat 5:23S-up, 3° down [60 EDO], 3/10-tone down - outMap.emplace(std::make_pair( "accSagittalFlat5v49MDown", 0xE3D7 )); // glyphnumber: 148, Flat 5:49M-down - outMap.emplace(std::make_pair( "accSagittalFlat5v7kDown", 0xE31D )); // glyphnumber: 149, Flat 5:7k-down - outMap.emplace(std::make_pair( "accSagittalFlat5v7kUp", 0xE317 )); // glyphnumber: 150, Flat 5:7k-up - outMap.emplace(std::make_pair( "accSagittalFlat7CDown", 0xE321 )); // glyphnumber: 151, Flat 7C-down, 4° down [43 EDO], 8° down [72 EDO], 2/3-tone down - outMap.emplace(std::make_pair( "accSagittalFlat7CUp", 0xE313 )); // glyphnumber: 152, Flat 7C-up, 2° down [43 EDO], 4° down [72 EDO], 1/3-tone down - outMap.emplace(std::make_pair( "accSagittalFlat7v11CDown", 0xE35B )); // glyphnumber: 153, Flat 7:11C-down, 6° down [60 EDO], 3/5- tone down - outMap.emplace(std::make_pair( "accSagittalFlat7v11CUp", 0xE34D )); // glyphnumber: 154, Flat 7:11C-up, 4° down [60 EDO], 2/5-tone down - outMap.emplace(std::make_pair( "accSagittalFlat7v11kDown", 0xE355 )); // glyphnumber: 155, Flat 7:11k-down - outMap.emplace(std::make_pair( "accSagittalFlat7v11kUp", 0xE353 )); // glyphnumber: 156, Flat 7:11k-up - outMap.emplace(std::make_pair( "accSagittalFlat7v19CDown", 0xE3CB )); // glyphnumber: 157, Flat 7:19C-down - outMap.emplace(std::make_pair( "accSagittalFlat7v19CUp", 0xE3B5 )); // glyphnumber: 158, Flat 7:19C-up - outMap.emplace(std::make_pair( "accSagittalGrave", 0xE3F3 )); // glyphnumber: 159, Grave, 5 schisma down, 2 cents down - outMap.emplace(std::make_pair( "accSagittalShaftDown", 0xE3F1 )); // glyphnumber: 160, Shaft down, (natural for use with only diacritics down) - outMap.emplace(std::make_pair( "accSagittalShaftUp", 0xE3F0 )); // glyphnumber: 161, Shaft up, (natural for use with only diacritics up) - outMap.emplace(std::make_pair( "accSagittalSharp", 0xE318 )); // glyphnumber: 162, Sharp, (apotome up)[almost all EDOs], 1/2-tone up - outMap.emplace(std::make_pair( "accSagittalSharp11LUp", 0xE328 )); // glyphnumber: 163, Sharp 11L-up, 8° up [46 EDO] - outMap.emplace(std::make_pair( "accSagittalSharp11MUp", 0xE326 )); // glyphnumber: 164, Sharp 11M-up, 3° up [17 31 EDOs], 7° up [46 EDO], 3/4-tone up - outMap.emplace(std::make_pair( "accSagittalSharp11v19LUp", 0xE3DA )); // glyphnumber: 165, Sharp 11:19L-up - outMap.emplace(std::make_pair( "accSagittalSharp11v19MUp", 0xE3D2 )); // glyphnumber: 166, Sharp 11:19M-up - outMap.emplace(std::make_pair( "accSagittalSharp11v49CDown", 0xE3B8 )); // glyphnumber: 167, Sharp 11:49C-down - outMap.emplace(std::make_pair( "accSagittalSharp11v49CUp", 0xE3C6 )); // glyphnumber: 168, Sharp 11:49C-up - outMap.emplace(std::make_pair( "accSagittalSharp143CDown", 0xE3BA )); // glyphnumber: 169, Sharp 143C-down - outMap.emplace(std::make_pair( "accSagittalSharp143CUp", 0xE3C4 )); // glyphnumber: 170, Sharp 143C-up - outMap.emplace(std::make_pair( "accSagittalSharp17CDown", 0xE350 )); // glyphnumber: 171, Sharp 17C-down - outMap.emplace(std::make_pair( "accSagittalSharp17CUp", 0xE356 )); // glyphnumber: 172, Sharp 17C-up - outMap.emplace(std::make_pair( "accSagittalSharp17kDown", 0xE3BC )); // glyphnumber: 173, Sharp 17k-down - outMap.emplace(std::make_pair( "accSagittalSharp17kUp", 0xE3C2 )); // glyphnumber: 174, Sharp 17k-up - outMap.emplace(std::make_pair( "accSagittalSharp19CDown", 0xE3B6 )); // glyphnumber: 175, Sharp 19C-down - outMap.emplace(std::make_pair( "accSagittalSharp19CUp", 0xE3C8 )); // glyphnumber: 176, Sharp 19C-up - outMap.emplace(std::make_pair( "accSagittalSharp19sDown", 0xE3BE )); // glyphnumber: 177, Sharp 19s-down - outMap.emplace(std::make_pair( "accSagittalSharp19sUp", 0xE3C0 )); // glyphnumber: 178, Sharp 19s-up - outMap.emplace(std::make_pair( "accSagittalSharp23CDown", 0xE37A )); // glyphnumber: 179, Sharp 23C-down, 6° up [96 EDO], 3/8-tone up - outMap.emplace(std::make_pair( "accSagittalSharp23CUp", 0xE37C )); // glyphnumber: 180, Sharp 23C-up, 10° up [96 EDO], 5/8-tone up - outMap.emplace(std::make_pair( "accSagittalSharp23SDown", 0xE3B0 )); // glyphnumber: 181, Sharp 23S-down - outMap.emplace(std::make_pair( "accSagittalSharp23SUp", 0xE3CE )); // glyphnumber: 182, Sharp 23S-up - outMap.emplace(std::make_pair( "accSagittalSharp25SDown", 0xE310 )); // glyphnumber: 183, Sharp 25S-down, 3° up [53 EDO] - outMap.emplace(std::make_pair( "accSagittalSharp25SUp", 0xE322 )); // glyphnumber: 184, Sharp 25S-up, 7° up [53 EDO] - outMap.emplace(std::make_pair( "accSagittalSharp35LUp", 0xE32A )); // glyphnumber: 185, Sharp 35L-up, 5° up [50 EDO] - outMap.emplace(std::make_pair( "accSagittalSharp35MUp", 0xE324 )); // glyphnumber: 186, Sharp 35M-up, 4° up [50 EDO], 6° up [27 EDO], 13/18-tone up - outMap.emplace(std::make_pair( "accSagittalSharp49LUp", 0xE3D8 )); // glyphnumber: 187, Sharp 49L-up - outMap.emplace(std::make_pair( "accSagittalSharp49MUp", 0xE3D4 )); // glyphnumber: 188, Sharp 49M-up - outMap.emplace(std::make_pair( "accSagittalSharp49SDown", 0xE3B2 )); // glyphnumber: 189, Sharp 49S-down - outMap.emplace(std::make_pair( "accSagittalSharp49SUp", 0xE3CC )); // glyphnumber: 190, Sharp 49S-up - outMap.emplace(std::make_pair( "accSagittalSharp55CDown", 0xE34E )); // glyphnumber: 191, Sharp 55C-down, 5° up [96 EDO], 5/16-tone up - outMap.emplace(std::make_pair( "accSagittalSharp55CUp", 0xE358 )); // glyphnumber: 192, Sharp 55C-up, 11° up [96 EDO], 11/16-tone up - outMap.emplace(std::make_pair( "accSagittalSharp5CDown", 0xE314 )); // glyphnumber: 193, Sharp 5C-down, 2°[22 29] 3°[34 41] 4°[46 53 60] up, 5/12-tone up - outMap.emplace(std::make_pair( "accSagittalSharp5CUp", 0xE31E )); // glyphnumber: 194, Sharp 5C-up, 4°[22 29] 5°[27 34 41] 6°[39 46 53] up, 7/12-tone up - outMap.emplace(std::make_pair( "accSagittalSharp5v11SDown", 0xE34A )); // glyphnumber: 195, Sharp 5:11S-down - outMap.emplace(std::make_pair( "accSagittalSharp5v11SUp", 0xE35C )); // glyphnumber: 196, Sharp 5:11S-up - outMap.emplace(std::make_pair( "accSagittalSharp5v13LUp", 0xE3DC )); // glyphnumber: 197, Sharp 5:13L-up - outMap.emplace(std::make_pair( "accSagittalSharp5v13MUp", 0xE3D0 )); // glyphnumber: 198, Sharp 5:13M-up - outMap.emplace(std::make_pair( "accSagittalSharp5v19CDown", 0xE378 )); // glyphnumber: 199, Sharp 5:19C-down, 9/20-tone up - outMap.emplace(std::make_pair( "accSagittalSharp5v19CUp", 0xE37E )); // glyphnumber: 200, Sharp 5:19C-up, 11/20-tone up - outMap.emplace(std::make_pair( "accSagittalSharp5v23SDown", 0xE376 )); // glyphnumber: 201, Sharp 5:23S-down, 3° up [60 EDO], 3/10-tone up - outMap.emplace(std::make_pair( "accSagittalSharp5v23SUp", 0xE380 )); // glyphnumber: 202, Sharp 5:23S-up, 7° up [60 EDO], 7/10-tone up - outMap.emplace(std::make_pair( "accSagittalSharp5v49MUp", 0xE3D6 )); // glyphnumber: 203, Sharp 5:49M-up, (one and a half apotomes) - outMap.emplace(std::make_pair( "accSagittalSharp5v7kDown", 0xE316 )); // glyphnumber: 204, Sharp 5:7k-down - outMap.emplace(std::make_pair( "accSagittalSharp5v7kUp", 0xE31C )); // glyphnumber: 205, Sharp 5:7k-up - outMap.emplace(std::make_pair( "accSagittalSharp7CDown", 0xE312 )); // glyphnumber: 206, Sharp 7C-down, 2° up [43 EDO], 4° up [72 EDO], 1/3-tone up - outMap.emplace(std::make_pair( "accSagittalSharp7CUp", 0xE320 )); // glyphnumber: 207, Sharp 7C-up, 4° up [43 EDO], 8° up [72 EDO], 2/3-tone up - outMap.emplace(std::make_pair( "accSagittalSharp7v11CDown", 0xE34C )); // glyphnumber: 208, Sharp 7:11C-down, 4° up [60 EDO], 2/5-tone up - outMap.emplace(std::make_pair( "accSagittalSharp7v11CUp", 0xE35A )); // glyphnumber: 209, Sharp 7:11C-up, 6° up [60 EDO], 3/5- tone up - outMap.emplace(std::make_pair( "accSagittalSharp7v11kDown", 0xE352 )); // glyphnumber: 210, Sharp 7:11k-down - outMap.emplace(std::make_pair( "accSagittalSharp7v11kUp", 0xE354 )); // glyphnumber: 211, Sharp 7:11k-up - outMap.emplace(std::make_pair( "accSagittalSharp7v19CDown", 0xE3B4 )); // glyphnumber: 212, Sharp 7:19C-down - outMap.emplace(std::make_pair( "accSagittalSharp7v19CUp", 0xE3CA )); // glyphnumber: 213, Sharp 7:19C-up - outMap.emplace(std::make_pair( "accSagittalUnused1", 0xE31A )); // glyphnumber: 214, Unused - outMap.emplace(std::make_pair( "accSagittalUnused2", 0xE31B )); // glyphnumber: 215, Unused - outMap.emplace(std::make_pair( "accSagittalUnused3", 0xE3DE )); // glyphnumber: 216, Unused - outMap.emplace(std::make_pair( "accSagittalUnused4", 0xE3DF )); // glyphnumber: 217, Unused - outMap.emplace(std::make_pair( "accdnCombDot", 0xE8CA )); // glyphnumber: 218, Combining accordion coupler dot - outMap.emplace(std::make_pair( "accdnCombLH2RanksEmpty", 0xE8C8 )); // glyphnumber: 219, Combining left hand, 2 ranks, empty - outMap.emplace(std::make_pair( "accdnCombLH3RanksEmptySquare", 0xE8C9 )); // glyphnumber: 220, Combining left hand, 3 ranks, empty (square) - outMap.emplace(std::make_pair( "accdnCombRH3RanksEmpty", 0xE8C6 )); // glyphnumber: 221, Combining right hand, 3 ranks, empty - outMap.emplace(std::make_pair( "accdnCombRH4RanksEmpty", 0xE8C7 )); // glyphnumber: 222, Combining right hand, 4 ranks, empty - outMap.emplace(std::make_pair( "accdnDiatonicClef", 0xE079 )); // glyphnumber: 223, Diatonic accordion clef - outMap.emplace(std::make_pair( "accdnLH2Ranks16Round", 0xE8BC )); // glyphnumber: 224, Left hand, 2 ranks, 16' stop (round) - outMap.emplace(std::make_pair( "accdnLH2Ranks8Plus16Round", 0xE8BD )); // glyphnumber: 225, Left hand, 2 ranks, 8' stop + 16' stop (round) - outMap.emplace(std::make_pair( "accdnLH2Ranks8Round", 0xE8BB )); // glyphnumber: 226, Left hand, 2 ranks, 8' stop (round) - outMap.emplace(std::make_pair( "accdnLH2RanksFullMasterRound", 0xE8C0 )); // glyphnumber: 227, Left hand, 2 ranks, full master (round) - outMap.emplace(std::make_pair( "accdnLH2RanksMasterPlus16Round", 0xE8BF )); // glyphnumber: 228, Left hand, 2 ranks, master + 16' stop (round) - outMap.emplace(std::make_pair( "accdnLH2RanksMasterRound", 0xE8BE )); // glyphnumber: 229, Left hand, 2 ranks, master (round) - outMap.emplace(std::make_pair( "accdnLH3Ranks2Plus8Square", 0xE8C4 )); // glyphnumber: 230, Left hand, 3 ranks, 2' stop + 8' stop (square) - outMap.emplace(std::make_pair( "accdnLH3Ranks2Square", 0xE8C2 )); // glyphnumber: 231, Left hand, 3 ranks, 2' stop (square) - outMap.emplace(std::make_pair( "accdnLH3Ranks8Square", 0xE8C1 )); // glyphnumber: 232, Left hand, 3 ranks, 8' stop (square) - outMap.emplace(std::make_pair( "accdnLH3RanksDouble8Square", 0xE8C3 )); // glyphnumber: 233, Left hand, 3 ranks, double 8' stop (square) - outMap.emplace(std::make_pair( "accdnLH3RanksTuttiSquare", 0xE8C5 )); // glyphnumber: 234, Left hand, 3 ranks, 2' stop + double 8' stop (tutti) (square) - outMap.emplace(std::make_pair( "accdnPull", 0xE8CC )); // glyphnumber: 235, Pull - outMap.emplace(std::make_pair( "accdnPush", 0xE8CB )); // glyphnumber: 236, Push - outMap.emplace(std::make_pair( "accdnRH3RanksAccordion", 0xE8AC )); // glyphnumber: 237, Right hand, 3 ranks, 8' stop + upper tremolo 8' stop + 16' stop (accordion) - outMap.emplace(std::make_pair( "accdnRH3RanksAuthenticMusette", 0xE8A8 )); // glyphnumber: 238, Right hand, 3 ranks, lower tremolo 8' stop + 8' stop + upper tremolo 8' stop (authentic musette) - outMap.emplace(std::make_pair( "accdnRH3RanksBandoneon", 0xE8AB )); // glyphnumber: 239, Right hand, 3 ranks, 8' stop + 16' stop (bandoneón) - outMap.emplace(std::make_pair( "accdnRH3RanksBassoon", 0xE8A4 )); // glyphnumber: 240, Right hand, 3 ranks, 16' stop (bassoon) - outMap.emplace(std::make_pair( "accdnRH3RanksClarinet", 0xE8A1 )); // glyphnumber: 241, Right hand, 3 ranks, 8' stop (clarinet) - outMap.emplace(std::make_pair( "accdnRH3RanksDoubleTremoloLower8ve", 0xE8B1 )); // glyphnumber: 242, Right hand, 3 ranks, lower tremolo 8' stop + 8' stop + upper tremolo 8' stop + 16' stop - outMap.emplace(std::make_pair( "accdnRH3RanksDoubleTremoloUpper8ve", 0xE8B2 )); // glyphnumber: 243, Right hand, 3 ranks, 4' stop + lower tremolo 8' stop + 8' stop + upper tremolo 8' stop - outMap.emplace(std::make_pair( "accdnRH3RanksFullFactory", 0xE8B3 )); // glyphnumber: 244, Right hand, 3 ranks, 4' stop + lower tremolo 8' stop + 8' stop + upper tremolo 8' stop + 16' stop - outMap.emplace(std::make_pair( "accdnRH3RanksHarmonium", 0xE8AA )); // glyphnumber: 245, Right hand, 3 ranks, 4' stop + 8' stop + 16' stop (harmonium) - outMap.emplace(std::make_pair( "accdnRH3RanksImitationMusette", 0xE8A7 )); // glyphnumber: 246, Right hand, 3 ranks, 4' stop + 8' stop + upper tremolo 8' stop (imitation musette) - outMap.emplace(std::make_pair( "accdnRH3RanksLowerTremolo8", 0xE8A3 )); // glyphnumber: 247, Right hand, 3 ranks, lower tremolo 8' stop - outMap.emplace(std::make_pair( "accdnRH3RanksMaster", 0xE8AD )); // glyphnumber: 248, Right hand, 3 ranks, 4' stop + lower tremolo 8' stop + upper tremolo 8' stop + 16' stop (master) - outMap.emplace(std::make_pair( "accdnRH3RanksOboe", 0xE8A5 )); // glyphnumber: 249, Right hand, 3 ranks, 4' stop + 8' stop (oboe) - outMap.emplace(std::make_pair( "accdnRH3RanksOrgan", 0xE8A9 )); // glyphnumber: 250, Right hand, 3 ranks, 4' stop + 16' stop (organ) - outMap.emplace(std::make_pair( "accdnRH3RanksPiccolo", 0xE8A0 )); // glyphnumber: 251, Right hand, 3 ranks, 4' stop (piccolo) - outMap.emplace(std::make_pair( "accdnRH3RanksTremoloLower8ve", 0xE8AF )); // glyphnumber: 252, Right hand, 3 ranks, lower tremolo 8' stop + upper tremolo 8' stop + 16' stop - outMap.emplace(std::make_pair( "accdnRH3RanksTremoloUpper8ve", 0xE8B0 )); // glyphnumber: 253, Right hand, 3 ranks, 4' stop + lower tremolo 8' stop + upper tremolo 8' stop - outMap.emplace(std::make_pair( "accdnRH3RanksTwoChoirs", 0xE8AE )); // glyphnumber: 254, Right hand, 3 ranks, lower tremolo 8' stop + upper tremolo 8' stop - outMap.emplace(std::make_pair( "accdnRH3RanksUpperTremolo8", 0xE8A2 )); // glyphnumber: 255, Right hand, 3 ranks, upper tremolo 8' stop - outMap.emplace(std::make_pair( "accdnRH3RanksViolin", 0xE8A6 )); // glyphnumber: 256, Right hand, 3 ranks, 8' stop + upper tremolo 8' stop (violin) - outMap.emplace(std::make_pair( "accdnRH4RanksAlto", 0xE8B5 )); // glyphnumber: 257, Right hand, 4 ranks, alto - outMap.emplace(std::make_pair( "accdnRH4RanksBassAlto", 0xE8BA )); // glyphnumber: 258, Right hand, 4 ranks, bass/alto - outMap.emplace(std::make_pair( "accdnRH4RanksMaster", 0xE8B7 )); // glyphnumber: 259, Right hand, 4 ranks, master - outMap.emplace(std::make_pair( "accdnRH4RanksSoftBass", 0xE8B8 )); // glyphnumber: 260, Right hand, 4 ranks, soft bass - outMap.emplace(std::make_pair( "accdnRH4RanksSoftTenor", 0xE8B9 )); // glyphnumber: 261, Right hand, 4 ranks, soft tenor - outMap.emplace(std::make_pair( "accdnRH4RanksSoprano", 0xE8B4 )); // glyphnumber: 262, Right hand, 4 ranks, soprano - outMap.emplace(std::make_pair( "accdnRH4RanksTenor", 0xE8B6 )); // glyphnumber: 263, Right hand, 4 ranks, tenor - outMap.emplace(std::make_pair( "accdnRicochet2", 0xE8CD )); // glyphnumber: 264, Ricochet (2 tones) - outMap.emplace(std::make_pair( "accdnRicochet3", 0xE8CE )); // glyphnumber: 265, Ricochet (3 tones) - outMap.emplace(std::make_pair( "accdnRicochet4", 0xE8CF )); // glyphnumber: 266, Ricochet (4 tones) - outMap.emplace(std::make_pair( "accdnRicochet5", 0xE8D0 )); // glyphnumber: 267, Ricochet (5 tones) - outMap.emplace(std::make_pair( "accdnRicochet6", 0xE8D1 )); // glyphnumber: 268, Ricochet (6 tones) - outMap.emplace(std::make_pair( "accdnRicochetStem2", 0xE8D2 )); // glyphnumber: 269, Combining ricochet for stem (2 tones) - outMap.emplace(std::make_pair( "accdnRicochetStem3", 0xE8D3 )); // glyphnumber: 270, Combining ricochet for stem (3 tones) - outMap.emplace(std::make_pair( "accdnRicochetStem4", 0xE8D4 )); // glyphnumber: 271, Combining ricochet for stem (4 tones) - outMap.emplace(std::make_pair( "accdnRicochetStem5", 0xE8D5 )); // glyphnumber: 272, Combining ricochet for stem (5 tones) - outMap.emplace(std::make_pair( "accdnRicochetStem6", 0xE8D6 )); // glyphnumber: 273, Combining ricochet for stem (6 tones) - outMap.emplace(std::make_pair( "accidental1CommaFlat", 0xE454 )); // glyphnumber: 274, 1-comma flat - outMap.emplace(std::make_pair( "accidental1CommaSharp", 0xE450 )); // glyphnumber: 275, 1-comma sharp - outMap.emplace(std::make_pair( "accidental2CommaFlat", 0xE455 )); // glyphnumber: 276, 2-comma flat - outMap.emplace(std::make_pair( "accidental2CommaSharp", 0xE451 )); // glyphnumber: 277, 2-comma sharp - outMap.emplace(std::make_pair( "accidental3CommaFlat", 0xE456 )); // glyphnumber: 278, 3-comma flat - outMap.emplace(std::make_pair( "accidental3CommaSharp", 0xE452 )); // glyphnumber: 279, 3-comma sharp - outMap.emplace(std::make_pair( "accidental4CommaFlat", 0xE457 )); // glyphnumber: 280, 4-comma flat - outMap.emplace(std::make_pair( "accidental5CommaSharp", 0xE453 )); // glyphnumber: 281, 5-comma sharp - outMap.emplace(std::make_pair( "accidentalArrowDown", 0xE27B )); // glyphnumber: 282, Arrow down (lower by one quarter-tone) - outMap.emplace(std::make_pair( "accidentalArrowUp", 0xE27A )); // glyphnumber: 283, Arrow up (raise by one quarter-tone) - outMap.emplace(std::make_pair( "accidentalBakiyeFlat", 0xE442 )); // glyphnumber: 284, Bakiye (flat) - outMap.emplace(std::make_pair( "accidentalBakiyeSharp", 0xE445 )); // glyphnumber: 285, Bakiye (sharp) - outMap.emplace(std::make_pair( "accidentalBracketLeft", 0xE26C )); // glyphnumber: 286, Accidental bracket, left - outMap.emplace(std::make_pair( "accidentalBracketRight", 0xE26D )); // glyphnumber: 287, Accidental bracket, right - outMap.emplace(std::make_pair( "accidentalBuyukMucennebFlat", 0xE440 )); // glyphnumber: 288, Büyük mücenneb (flat) - outMap.emplace(std::make_pair( "accidentalBuyukMucennebSharp", 0xE447 )); // glyphnumber: 289, Büyük mücenneb (sharp) - outMap.emplace(std::make_pair( "accidentalCombiningCloseCurlyBrace", 0xE2EF )); // glyphnumber: 290, Combining close curly brace - outMap.emplace(std::make_pair( "accidentalCombiningLower17Schisma", 0xE2E6 )); // glyphnumber: 291, Combining lower by one 17-limit schisma - outMap.emplace(std::make_pair( "accidentalCombiningLower19Schisma", 0xE2E8 )); // glyphnumber: 292, Combining lower by one 19-limit schisma - outMap.emplace(std::make_pair( "accidentalCombiningLower23Limit29LimitComma", 0xE2EA )); // glyphnumber: 293, Combining lower by one 23-limit comma or 29-limit comma - outMap.emplace(std::make_pair( "accidentalCombiningLower31Schisma", 0xE2EC )); // glyphnumber: 294, Combining lower by one 31-limit schisma - outMap.emplace(std::make_pair( "accidentalCombiningLower53LimitComma", 0xE2F7 )); // glyphnumber: 295, Combining lower by one 53-limit comma - outMap.emplace(std::make_pair( "accidentalCombiningOpenCurlyBrace", 0xE2EE )); // glyphnumber: 296, Combining open curly brace - outMap.emplace(std::make_pair( "accidentalCombiningRaise17Schisma", 0xE2E7 )); // glyphnumber: 297, Combining raise by one 17-limit schisma - outMap.emplace(std::make_pair( "accidentalCombiningRaise19Schisma", 0xE2E9 )); // glyphnumber: 298, Combining raise by one 19-limit schisma - outMap.emplace(std::make_pair( "accidentalCombiningRaise23Limit29LimitComma", 0xE2EB )); // glyphnumber: 299, Combining raise by one 23-limit comma or 29-limit comma - outMap.emplace(std::make_pair( "accidentalCombiningRaise31Schisma", 0xE2ED )); // glyphnumber: 300, Combining raise by one 31-limit schisma - outMap.emplace(std::make_pair( "accidentalCombiningRaise53LimitComma", 0xE2F8 )); // glyphnumber: 301, Combining raise by one 53-limit comma - outMap.emplace(std::make_pair( "accidentalCommaSlashDown", 0xE47A )); // glyphnumber: 302, Syntonic/Didymus comma (80:81) down (Bosanquet) - outMap.emplace(std::make_pair( "accidentalCommaSlashUp", 0xE479 )); // glyphnumber: 303, Syntonic/Didymus comma (80:81) up (Bosanquet) - outMap.emplace(std::make_pair( "accidentalDoubleFlat", 0xE264 )); // glyphnumber: 304, Double flat - outMap.emplace(std::make_pair( "accidentalDoubleFlatArabic", 0xED30 )); // glyphnumber: 305, Arabic double flat - outMap.emplace(std::make_pair( "accidentalDoubleFlatEqualTempered", 0xE2F0 )); // glyphnumber: 306, Double flat equal tempered semitone - outMap.emplace(std::make_pair( "accidentalDoubleFlatOneArrowDown", 0xE2C0 )); // glyphnumber: 307, Double flat lowered by one syntonic comma - outMap.emplace(std::make_pair( "accidentalDoubleFlatOneArrowUp", 0xE2C5 )); // glyphnumber: 308, Double flat raised by one syntonic comma - outMap.emplace(std::make_pair( "accidentalDoubleFlatReversed", 0xE483 )); // glyphnumber: 309, Reversed double flat - outMap.emplace(std::make_pair( "accidentalDoubleFlatThreeArrowsDown", 0xE2D4 )); // glyphnumber: 310, Double flat lowered by three syntonic commas - outMap.emplace(std::make_pair( "accidentalDoubleFlatThreeArrowsUp", 0xE2D9 )); // glyphnumber: 311, Double flat raised by three syntonic commas - outMap.emplace(std::make_pair( "accidentalDoubleFlatTurned", 0xE485 )); // glyphnumber: 312, Turned double flat - outMap.emplace(std::make_pair( "accidentalDoubleFlatTwoArrowsDown", 0xE2CA )); // glyphnumber: 313, Double flat lowered by two syntonic commas - outMap.emplace(std::make_pair( "accidentalDoubleFlatTwoArrowsUp", 0xE2CF )); // glyphnumber: 314, Double flat raised by two syntonic commas - outMap.emplace(std::make_pair( "accidentalDoubleSharp", 0xE263 )); // glyphnumber: 315, Double sharp - outMap.emplace(std::make_pair( "accidentalDoubleSharpArabic", 0xED38 )); // glyphnumber: 316, Arabic double sharp - outMap.emplace(std::make_pair( "accidentalDoubleSharpEqualTempered", 0xE2F4 )); // glyphnumber: 317, Double sharp equal tempered semitone - outMap.emplace(std::make_pair( "accidentalDoubleSharpOneArrowDown", 0xE2C4 )); // glyphnumber: 318, Double sharp lowered by one syntonic comma - outMap.emplace(std::make_pair( "accidentalDoubleSharpOneArrowUp", 0xE2C9 )); // glyphnumber: 319, Double sharp raised by one syntonic comma - outMap.emplace(std::make_pair( "accidentalDoubleSharpThreeArrowsDown", 0xE2D8 )); // glyphnumber: 320, Double sharp lowered by three syntonic commas - outMap.emplace(std::make_pair( "accidentalDoubleSharpThreeArrowsUp", 0xE2DD )); // glyphnumber: 321, Double sharp raised by three syntonic commas - outMap.emplace(std::make_pair( "accidentalDoubleSharpTwoArrowsDown", 0xE2CE )); // glyphnumber: 322, Double sharp lowered by two syntonic commas - outMap.emplace(std::make_pair( "accidentalDoubleSharpTwoArrowsUp", 0xE2D3 )); // glyphnumber: 323, Double sharp raised by two syntonic commas - outMap.emplace(std::make_pair( "accidentalEnharmonicAlmostEqualTo", 0xE2FA )); // glyphnumber: 324, Enharmonically reinterpret accidental almost equal to - outMap.emplace(std::make_pair( "accidentalEnharmonicEquals", 0xE2FB )); // glyphnumber: 325, Enharmonically reinterpret accidental equals - outMap.emplace(std::make_pair( "accidentalEnharmonicTilde", 0xE2F9 )); // glyphnumber: 326, Enharmonically reinterpret accidental tilde - outMap.emplace(std::make_pair( "accidentalFilledReversedFlatAndFlat", 0xE296 )); // glyphnumber: 327, Filled reversed flat and flat - outMap.emplace(std::make_pair( "accidentalFilledReversedFlatAndFlatArrowDown", 0xE298 )); // glyphnumber: 328, Filled reversed flat and flat with arrow down - outMap.emplace(std::make_pair( "accidentalFilledReversedFlatAndFlatArrowUp", 0xE297 )); // glyphnumber: 329, Filled reversed flat and flat with arrow up - outMap.emplace(std::make_pair( "accidentalFilledReversedFlatArrowDown", 0xE293 )); // glyphnumber: 330, Filled reversed flat with arrow down - outMap.emplace(std::make_pair( "accidentalFilledReversedFlatArrowUp", 0xE292 )); // glyphnumber: 331, Filled reversed flat with arrow up - outMap.emplace(std::make_pair( "accidentalFiveQuarterTonesFlatArrowDown", 0xE279 )); // glyphnumber: 332, Five-quarter-tones flat - outMap.emplace(std::make_pair( "accidentalFiveQuarterTonesSharpArrowUp", 0xE276 )); // glyphnumber: 333, Five-quarter-tones sharp - outMap.emplace(std::make_pair( "accidentalFlat", 0xE260 )); // glyphnumber: 334, Flat - outMap.emplace(std::make_pair( "accidentalFlatArabic", 0xED32 )); // glyphnumber: 335, Arabic half-tone flat - outMap.emplace(std::make_pair( "accidentalFlatEqualTempered", 0xE2F1 )); // glyphnumber: 336, Flat equal tempered semitone - outMap.emplace(std::make_pair( "accidentalFlatLoweredStockhausen", 0xED53 )); // glyphnumber: 337, Lowered flat (Stockhausen) - outMap.emplace(std::make_pair( "accidentalFlatOneArrowDown", 0xE2C1 )); // glyphnumber: 338, Flat lowered by one syntonic comma - outMap.emplace(std::make_pair( "accidentalFlatOneArrowUp", 0xE2C6 )); // glyphnumber: 339, Flat raised by one syntonic comma - outMap.emplace(std::make_pair( "accidentalFlatRaisedStockhausen", 0xED52 )); // glyphnumber: 340, Raised flat (Stockhausen) - outMap.emplace(std::make_pair( "accidentalFlatRepeatedLineStockhausen", 0xED5C )); // glyphnumber: 341, Repeated flat, note on line (Stockhausen) - outMap.emplace(std::make_pair( "accidentalFlatRepeatedSpaceStockhausen", 0xED5B )); // glyphnumber: 342, Repeated flat, note in space (Stockhausen) - outMap.emplace(std::make_pair( "accidentalFlatThreeArrowsDown", 0xE2D5 )); // glyphnumber: 343, Flat lowered by three syntonic commas - outMap.emplace(std::make_pair( "accidentalFlatThreeArrowsUp", 0xE2DA )); // glyphnumber: 344, Flat raised by three syntonic commas - outMap.emplace(std::make_pair( "accidentalFlatTurned", 0xE484 )); // glyphnumber: 345, Turned flat - outMap.emplace(std::make_pair( "accidentalFlatTwoArrowsDown", 0xE2CB )); // glyphnumber: 346, Flat lowered by two syntonic commas - outMap.emplace(std::make_pair( "accidentalFlatTwoArrowsUp", 0xE2D0 )); // glyphnumber: 347, Flat raised by two syntonic commas - outMap.emplace(std::make_pair( "accidentalHalfSharpArrowDown", 0xE29A )); // glyphnumber: 348, Half sharp with arrow down - outMap.emplace(std::make_pair( "accidentalHalfSharpArrowUp", 0xE299 )); // glyphnumber: 349, Half sharp with arrow up - outMap.emplace(std::make_pair( "accidentalJohnston13", 0xE2B6 )); // glyphnumber: 350, Thirteen (raise by 65:64) - outMap.emplace(std::make_pair( "accidentalJohnston31", 0xE2B7 )); // glyphnumber: 351, Inverted 13 (lower by 65:64) - outMap.emplace(std::make_pair( "accidentalJohnstonDown", 0xE2B5 )); // glyphnumber: 352, Down arrow (lower by 33:32) - outMap.emplace(std::make_pair( "accidentalJohnstonEl", 0xE2B2 )); // glyphnumber: 353, Inverted seven (raise by 36:35) - outMap.emplace(std::make_pair( "accidentalJohnstonMinus", 0xE2B1 )); // glyphnumber: 354, Minus (lower by 81:80) - outMap.emplace(std::make_pair( "accidentalJohnstonPlus", 0xE2B0 )); // glyphnumber: 355, Plus (raise by 81:80) - outMap.emplace(std::make_pair( "accidentalJohnstonSeven", 0xE2B3 )); // glyphnumber: 356, Seven (lower by 36:35) - outMap.emplace(std::make_pair( "accidentalJohnstonUp", 0xE2B4 )); // glyphnumber: 357, Up arrow (raise by 33:32) - outMap.emplace(std::make_pair( "accidentalKomaFlat", 0xE443 )); // glyphnumber: 358, Koma (flat) - outMap.emplace(std::make_pair( "accidentalKomaSharp", 0xE444 )); // glyphnumber: 359, Koma (sharp) - outMap.emplace(std::make_pair( "accidentalKoron", 0xE460 )); // glyphnumber: 360, Koron (quarter tone flat) - outMap.emplace(std::make_pair( "accidentalKucukMucennebFlat", 0xE441 )); // glyphnumber: 361, Küçük mücenneb (flat) - outMap.emplace(std::make_pair( "accidentalKucukMucennebSharp", 0xE446 )); // glyphnumber: 362, Küçük mücenneb (sharp) - outMap.emplace(std::make_pair( "accidentalLargeDoubleSharp", 0xE47D )); // glyphnumber: 363, Large double sharp - outMap.emplace(std::make_pair( "accidentalLowerOneSeptimalComma", 0xE2DE )); // glyphnumber: 364, Lower by one septimal comma - outMap.emplace(std::make_pair( "accidentalLowerOneTridecimalQuartertone", 0xE2E4 )); // glyphnumber: 365, Lower by one tridecimal quartertone - outMap.emplace(std::make_pair( "accidentalLowerOneUndecimalQuartertone", 0xE2E2 )); // glyphnumber: 366, Lower by one undecimal quartertone - outMap.emplace(std::make_pair( "accidentalLowerTwoSeptimalCommas", 0xE2E0 )); // glyphnumber: 367, Lower by two septimal commas - outMap.emplace(std::make_pair( "accidentalLoweredStockhausen", 0xED51 )); // glyphnumber: 368, Lowered (Stockhausen) - outMap.emplace(std::make_pair( "accidentalNarrowReversedFlat", 0xE284 )); // glyphnumber: 369, Narrow reversed flat(quarter-tone flat) - outMap.emplace(std::make_pair( "accidentalNarrowReversedFlatAndFlat", 0xE285 )); // glyphnumber: 370, Narrow reversed flat and flat(three-quarter-tones flat) - outMap.emplace(std::make_pair( "accidentalNatural", 0xE261 )); // glyphnumber: 371, Natural - outMap.emplace(std::make_pair( "accidentalNaturalArabic", 0xED34 )); // glyphnumber: 372, Arabic natural - outMap.emplace(std::make_pair( "accidentalNaturalEqualTempered", 0xE2F2 )); // glyphnumber: 373, Natural equal tempered semitone - outMap.emplace(std::make_pair( "accidentalNaturalFlat", 0xE267 )); // glyphnumber: 374, Natural flat - outMap.emplace(std::make_pair( "accidentalNaturalLoweredStockhausen", 0xED55 )); // glyphnumber: 375, Lowered natural (Stockhausen) - outMap.emplace(std::make_pair( "accidentalNaturalOneArrowDown", 0xE2C2 )); // glyphnumber: 376, Natural lowered by one syntonic comma - outMap.emplace(std::make_pair( "accidentalNaturalOneArrowUp", 0xE2C7 )); // glyphnumber: 377, Natural raised by one syntonic comma - outMap.emplace(std::make_pair( "accidentalNaturalRaisedStockhausen", 0xED54 )); // glyphnumber: 378, Raised natural (Stockhausen) - outMap.emplace(std::make_pair( "accidentalNaturalReversed", 0xE482 )); // glyphnumber: 379, Reversed natural - outMap.emplace(std::make_pair( "accidentalNaturalSharp", 0xE268 )); // glyphnumber: 380, Natural sharp - outMap.emplace(std::make_pair( "accidentalNaturalThreeArrowsDown", 0xE2D6 )); // glyphnumber: 381, Natural lowered by three syntonic commas - outMap.emplace(std::make_pair( "accidentalNaturalThreeArrowsUp", 0xE2DB )); // glyphnumber: 382, Natural raised by three syntonic commas - outMap.emplace(std::make_pair( "accidentalNaturalTwoArrowsDown", 0xE2CC )); // glyphnumber: 383, Natural lowered by two syntonic commas - outMap.emplace(std::make_pair( "accidentalNaturalTwoArrowsUp", 0xE2D1 )); // glyphnumber: 384, Natural raised by two syntonic commas - outMap.emplace(std::make_pair( "accidentalOneAndAHalfSharpsArrowDown", 0xE29C )); // glyphnumber: 385, One and a half sharps with arrow down - outMap.emplace(std::make_pair( "accidentalOneAndAHalfSharpsArrowUp", 0xE29B )); // glyphnumber: 386, One and a half sharps with arrow up - outMap.emplace(std::make_pair( "accidentalOneQuarterToneFlatFerneyhough", 0xE48F )); // glyphnumber: 387, One-quarter-tone flat (Ferneyhough) - outMap.emplace(std::make_pair( "accidentalOneQuarterToneFlatStockhausen", 0xED59 )); // glyphnumber: 388, One-quarter-tone flat (Stockhausen) - outMap.emplace(std::make_pair( "accidentalOneQuarterToneSharpFerneyhough", 0xE48E )); // glyphnumber: 389, One-quarter-tone sharp (Ferneyhough) - outMap.emplace(std::make_pair( "accidentalOneQuarterToneSharpStockhausen", 0xED58 )); // glyphnumber: 390, One-quarter-tone sharp (Stockhausen) - outMap.emplace(std::make_pair( "accidentalOneThirdToneFlatFerneyhough", 0xE48B )); // glyphnumber: 391, One-third-tone flat (Ferneyhough) - outMap.emplace(std::make_pair( "accidentalOneThirdToneSharpFerneyhough", 0xE48A )); // glyphnumber: 392, One-third-tone sharp (Ferneyhough) - outMap.emplace(std::make_pair( "accidentalParensLeft", 0xE26A )); // glyphnumber: 393, Accidental parenthesis, left - outMap.emplace(std::make_pair( "accidentalParensRight", 0xE26B )); // glyphnumber: 394, Accidental parenthesis, right - outMap.emplace(std::make_pair( "accidentalQuarterFlatEqualTempered", 0xE2F5 )); // glyphnumber: 395, Lower by one equal tempered quarter-tone - outMap.emplace(std::make_pair( "accidentalQuarterSharpEqualTempered", 0xE2F6 )); // glyphnumber: 396, Raise by one equal tempered quarter tone - outMap.emplace(std::make_pair( "accidentalQuarterToneFlat4", 0xE47F )); // glyphnumber: 397, Quarter-tone flat - outMap.emplace(std::make_pair( "accidentalQuarterToneFlatArabic", 0xED33 )); // glyphnumber: 398, Arabic quarter-tone flat - outMap.emplace(std::make_pair( "accidentalQuarterToneFlatArrowUp", 0xE270 )); // glyphnumber: 399, Quarter-tone flat - outMap.emplace(std::make_pair( "accidentalQuarterToneFlatFilledReversed", 0xE480 )); // glyphnumber: 400, Filled reversed flat (quarter-tone flat) - outMap.emplace(std::make_pair( "accidentalQuarterToneFlatNaturalArrowDown", 0xE273 )); // glyphnumber: 401, Quarter-tone flat - outMap.emplace(std::make_pair( "accidentalQuarterToneFlatPenderecki", 0xE478 )); // glyphnumber: 402, Quarter tone flat (Penderecki) - outMap.emplace(std::make_pair( "accidentalQuarterToneFlatStein", 0xE280 )); // glyphnumber: 403, Reversed flat (quarter-tone flat) (Stein) - outMap.emplace(std::make_pair( "accidentalQuarterToneFlatVanBlankenburg", 0xE488 )); // glyphnumber: 404, Quarter-tone flat (van Blankenburg) - outMap.emplace(std::make_pair( "accidentalQuarterToneSharp4", 0xE47E )); // glyphnumber: 405, Quarter-tone sharp - outMap.emplace(std::make_pair( "accidentalQuarterToneSharpArabic", 0xED35 )); // glyphnumber: 406, Arabic quarter-tone sharp - outMap.emplace(std::make_pair( "accidentalQuarterToneSharpArrowDown", 0xE275 )); // glyphnumber: 407, Quarter-tone sharp - outMap.emplace(std::make_pair( "accidentalQuarterToneSharpBusotti", 0xE472 )); // glyphnumber: 408, Quarter tone sharp (Bussotti) - outMap.emplace(std::make_pair( "accidentalQuarterToneSharpNaturalArrowUp", 0xE272 )); // glyphnumber: 409, Quarter-tone sharp - outMap.emplace(std::make_pair( "accidentalQuarterToneSharpStein", 0xE282 )); // glyphnumber: 410, Half sharp (quarter-tone sharp) (Stein) - outMap.emplace(std::make_pair( "accidentalQuarterToneSharpWiggle", 0xE475 )); // glyphnumber: 411, Quarter tone sharp with wiggly tail - outMap.emplace(std::make_pair( "accidentalRaiseOneSeptimalComma", 0xE2DF )); // glyphnumber: 412, Raise by one septimal comma - outMap.emplace(std::make_pair( "accidentalRaiseOneTridecimalQuartertone", 0xE2E5 )); // glyphnumber: 413, Raise by one tridecimal quartertone - outMap.emplace(std::make_pair( "accidentalRaiseOneUndecimalQuartertone", 0xE2E3 )); // glyphnumber: 414, Raise by one undecimal quartertone - outMap.emplace(std::make_pair( "accidentalRaiseTwoSeptimalCommas", 0xE2E1 )); // glyphnumber: 415, Raise by two septimal commas - outMap.emplace(std::make_pair( "accidentalRaisedStockhausen", 0xED50 )); // glyphnumber: 416, Raised (Stockhausen) - outMap.emplace(std::make_pair( "accidentalReversedFlatAndFlatArrowDown", 0xE295 )); // glyphnumber: 417, Reversed flat and flat with arrow down - outMap.emplace(std::make_pair( "accidentalReversedFlatAndFlatArrowUp", 0xE294 )); // glyphnumber: 418, Reversed flat and flat with arrow up - outMap.emplace(std::make_pair( "accidentalReversedFlatArrowDown", 0xE291 )); // glyphnumber: 419, Reversed flat with arrow down - outMap.emplace(std::make_pair( "accidentalReversedFlatArrowUp", 0xE290 )); // glyphnumber: 420, Reversed flat with arrow up - outMap.emplace(std::make_pair( "accidentalSharp", 0xE262 )); // glyphnumber: 421, Sharp - outMap.emplace(std::make_pair( "accidentalSharpArabic", 0xED36 )); // glyphnumber: 422, Arabic half-tone sharp - outMap.emplace(std::make_pair( "accidentalSharpEqualTempered", 0xE2F3 )); // glyphnumber: 423, Sharp equal tempered semitone - outMap.emplace(std::make_pair( "accidentalSharpLoweredStockhausen", 0xED57 )); // glyphnumber: 424, Lowered sharp (Stockhausen) - outMap.emplace(std::make_pair( "accidentalSharpOneArrowDown", 0xE2C3 )); // glyphnumber: 425, Sharp lowered by one syntonic comma - outMap.emplace(std::make_pair( "accidentalSharpOneArrowUp", 0xE2C8 )); // glyphnumber: 426, Sharp raised by one syntonic comma - outMap.emplace(std::make_pair( "accidentalSharpOneHorizontalStroke", 0xE473 )); // glyphnumber: 427, One or three quarter tones sharp - outMap.emplace(std::make_pair( "accidentalSharpRaisedStockhausen", 0xED56 )); // glyphnumber: 428, Raised sharp (Stockhausen) - outMap.emplace(std::make_pair( "accidentalSharpRepeatedLineStockhausen", 0xED5E )); // glyphnumber: 429, Repeated sharp, note on line (Stockhausen) - outMap.emplace(std::make_pair( "accidentalSharpRepeatedSpaceStockhausen", 0xED5D )); // glyphnumber: 430, Repeated sharp, note in space (Stockhausen) - outMap.emplace(std::make_pair( "accidentalSharpReversed", 0xE481 )); // glyphnumber: 431, Reversed sharp - outMap.emplace(std::make_pair( "accidentalSharpSharp", 0xE269 )); // glyphnumber: 432, Sharp sharp - outMap.emplace(std::make_pair( "accidentalSharpThreeArrowsDown", 0xE2D7 )); // glyphnumber: 433, Sharp lowered by three syntonic commas - outMap.emplace(std::make_pair( "accidentalSharpThreeArrowsUp", 0xE2DC )); // glyphnumber: 434, Sharp raised by three syntonic commas - outMap.emplace(std::make_pair( "accidentalSharpTwoArrowsDown", 0xE2CD )); // glyphnumber: 435, Sharp lowered by two syntonic commas - outMap.emplace(std::make_pair( "accidentalSharpTwoArrowsUp", 0xE2D2 )); // glyphnumber: 436, Sharp raised by two syntonic commas - outMap.emplace(std::make_pair( "accidentalSims12Down", 0xE2A0 )); // glyphnumber: 437, 1/12 tone low - outMap.emplace(std::make_pair( "accidentalSims12Up", 0xE2A3 )); // glyphnumber: 438, 1/12 tone high - outMap.emplace(std::make_pair( "accidentalSims4Down", 0xE2A2 )); // glyphnumber: 439, 1/4 tone low - outMap.emplace(std::make_pair( "accidentalSims4Up", 0xE2A5 )); // glyphnumber: 440, 1/4 tone high - outMap.emplace(std::make_pair( "accidentalSims6Down", 0xE2A1 )); // glyphnumber: 441, 1/6 tone low - outMap.emplace(std::make_pair( "accidentalSims6Up", 0xE2A4 )); // glyphnumber: 442, 1/6 tone high - outMap.emplace(std::make_pair( "accidentalSori", 0xE461 )); // glyphnumber: 443, Sori (quarter tone sharp) - outMap.emplace(std::make_pair( "accidentalTavenerFlat", 0xE477 )); // glyphnumber: 444, Byzantine-style Bakiye flat (Tavener) - outMap.emplace(std::make_pair( "accidentalTavenerSharp", 0xE476 )); // glyphnumber: 445, Byzantine-style Büyük mücenneb sharp (Tavener) - outMap.emplace(std::make_pair( "accidentalThreeQuarterTonesFlatArabic", 0xED31 )); // glyphnumber: 446, Arabic three-quarter-tones flat - outMap.emplace(std::make_pair( "accidentalThreeQuarterTonesFlatArrowDown", 0xE271 )); // glyphnumber: 447, Three-quarter-tones flat - outMap.emplace(std::make_pair( "accidentalThreeQuarterTonesFlatArrowUp", 0xE278 )); // glyphnumber: 448, Three-quarter-tones flat - outMap.emplace(std::make_pair( "accidentalThreeQuarterTonesFlatCouper", 0xE489 )); // glyphnumber: 449, Three-quarter-tones flat (Couper) - outMap.emplace(std::make_pair( "accidentalThreeQuarterTonesFlatGrisey", 0xE486 )); // glyphnumber: 450, Three-quarter-tones flat (Grisey) - outMap.emplace(std::make_pair( "accidentalThreeQuarterTonesFlatTartini", 0xE487 )); // glyphnumber: 451, Three-quarter-tones flat (Tartini) - outMap.emplace(std::make_pair( "accidentalThreeQuarterTonesFlatZimmermann", 0xE281 )); // glyphnumber: 452, Reversed flat and flat (three-quarter-tones flat) (Zimmermann) - outMap.emplace(std::make_pair( "accidentalThreeQuarterTonesSharpArabic", 0xED37 )); // glyphnumber: 453, Arabic three-quarter-tones sharp - outMap.emplace(std::make_pair( "accidentalThreeQuarterTonesSharpArrowDown", 0xE277 )); // glyphnumber: 454, Three-quarter-tones sharp - outMap.emplace(std::make_pair( "accidentalThreeQuarterTonesSharpArrowUp", 0xE274 )); // glyphnumber: 455, Three-quarter-tones sharp - outMap.emplace(std::make_pair( "accidentalThreeQuarterTonesSharpBusotti", 0xE474 )); // glyphnumber: 456, Three quarter tones sharp (Bussotti) - outMap.emplace(std::make_pair( "accidentalThreeQuarterTonesSharpStein", 0xE283 )); // glyphnumber: 457, One and a half sharps (three-quarter-tones sharp) (Stein) - outMap.emplace(std::make_pair( "accidentalThreeQuarterTonesSharpStockhausen", 0xED5A )); // glyphnumber: 458, Three-quarter-tones sharp (Stockhausen) - outMap.emplace(std::make_pair( "accidentalTripleFlat", 0xE266 )); // glyphnumber: 459, Triple flat - outMap.emplace(std::make_pair( "accidentalTripleSharp", 0xE265 )); // glyphnumber: 460, Triple sharp - outMap.emplace(std::make_pair( "accidentalTwoThirdTonesFlatFerneyhough", 0xE48D )); // glyphnumber: 461, Two-third-tones flat (Ferneyhough) - outMap.emplace(std::make_pair( "accidentalTwoThirdTonesSharpFerneyhough", 0xE48C )); // glyphnumber: 462, Two-third-tones sharp (Ferneyhough) - outMap.emplace(std::make_pair( "accidentalWilsonMinus", 0xE47C )); // glyphnumber: 463, Wilson minus (5 comma down) - outMap.emplace(std::make_pair( "accidentalWilsonPlus", 0xE47B )); // glyphnumber: 464, Wilson plus (5 comma up) - outMap.emplace(std::make_pair( "accidentalWyschnegradsky10TwelfthsFlat", 0xE434 )); // glyphnumber: 465, 5/6 tone flat - outMap.emplace(std::make_pair( "accidentalWyschnegradsky10TwelfthsSharp", 0xE429 )); // glyphnumber: 466, 5/6 tone sharp - outMap.emplace(std::make_pair( "accidentalWyschnegradsky11TwelfthsFlat", 0xE435 )); // glyphnumber: 467, 11/12 tone flat - outMap.emplace(std::make_pair( "accidentalWyschnegradsky11TwelfthsSharp", 0xE42A )); // glyphnumber: 468, 11/12 tone sharp - outMap.emplace(std::make_pair( "accidentalWyschnegradsky1TwelfthsFlat", 0xE42B )); // glyphnumber: 469, 1/12 tone flat - outMap.emplace(std::make_pair( "accidentalWyschnegradsky1TwelfthsSharp", 0xE420 )); // glyphnumber: 470, 1/12 tone sharp - outMap.emplace(std::make_pair( "accidentalWyschnegradsky2TwelfthsFlat", 0xE42C )); // glyphnumber: 471, 1/6 tone flat - outMap.emplace(std::make_pair( "accidentalWyschnegradsky2TwelfthsSharp", 0xE421 )); // glyphnumber: 472, 1/6 tone sharp - outMap.emplace(std::make_pair( "accidentalWyschnegradsky3TwelfthsFlat", 0xE42D )); // glyphnumber: 473, 1/4 tone flat - outMap.emplace(std::make_pair( "accidentalWyschnegradsky3TwelfthsSharp", 0xE422 )); // glyphnumber: 474, 1/4 tone sharp - outMap.emplace(std::make_pair( "accidentalWyschnegradsky4TwelfthsFlat", 0xE42E )); // glyphnumber: 475, 1/3 tone flat - outMap.emplace(std::make_pair( "accidentalWyschnegradsky4TwelfthsSharp", 0xE423 )); // glyphnumber: 476, 1/3 tone sharp - outMap.emplace(std::make_pair( "accidentalWyschnegradsky5TwelfthsFlat", 0xE42F )); // glyphnumber: 477, 5/12 tone flat - outMap.emplace(std::make_pair( "accidentalWyschnegradsky5TwelfthsSharp", 0xE424 )); // glyphnumber: 478, 5/12 tone sharp - outMap.emplace(std::make_pair( "accidentalWyschnegradsky6TwelfthsFlat", 0xE430 )); // glyphnumber: 479, 1/2 tone flat - outMap.emplace(std::make_pair( "accidentalWyschnegradsky6TwelfthsSharp", 0xE425 )); // glyphnumber: 480, 1/2 tone sharp - outMap.emplace(std::make_pair( "accidentalWyschnegradsky7TwelfthsFlat", 0xE431 )); // glyphnumber: 481, 7/12 tone flat - outMap.emplace(std::make_pair( "accidentalWyschnegradsky7TwelfthsSharp", 0xE426 )); // glyphnumber: 482, 7/12 tone sharp - outMap.emplace(std::make_pair( "accidentalWyschnegradsky8TwelfthsFlat", 0xE432 )); // glyphnumber: 483, 2/3 tone flat - outMap.emplace(std::make_pair( "accidentalWyschnegradsky8TwelfthsSharp", 0xE427 )); // glyphnumber: 484, 2/3 tone sharp - outMap.emplace(std::make_pair( "accidentalWyschnegradsky9TwelfthsFlat", 0xE433 )); // glyphnumber: 485, 3/4 tone flat - outMap.emplace(std::make_pair( "accidentalWyschnegradsky9TwelfthsSharp", 0xE428 )); // glyphnumber: 486, 3/4 tone sharp - outMap.emplace(std::make_pair( "accidentalXenakisOneThirdToneSharp", 0xE470 )); // glyphnumber: 487, One-third-tone sharp (Xenakis) - outMap.emplace(std::make_pair( "accidentalXenakisTwoThirdTonesSharp", 0xE471 )); // glyphnumber: 488, Two-third-tones sharp (Xenakis) - outMap.emplace(std::make_pair( "analyticsChoralmelodie", 0xE86A )); // glyphnumber: 489, Choralmelodie (Berg) - outMap.emplace(std::make_pair( "analyticsEndStimme", 0xE863 )); // glyphnumber: 490, End of stimme - outMap.emplace(std::make_pair( "analyticsHauptrhythmus", 0xE86B )); // glyphnumber: 491, Hauptrhythmus (Berg) - outMap.emplace(std::make_pair( "analyticsHauptstimme", 0xE860 )); // glyphnumber: 492, Hauptstimme - outMap.emplace(std::make_pair( "analyticsInversion1", 0xE869 )); // glyphnumber: 493, Inversion 1 - outMap.emplace(std::make_pair( "analyticsNebenstimme", 0xE861 )); // glyphnumber: 494, Nebenstimme - outMap.emplace(std::make_pair( "analyticsStartStimme", 0xE862 )); // glyphnumber: 495, Start of stimme - outMap.emplace(std::make_pair( "analyticsTheme", 0xE864 )); // glyphnumber: 496, Theme - outMap.emplace(std::make_pair( "analyticsTheme1", 0xE868 )); // glyphnumber: 497, Theme 1 - outMap.emplace(std::make_pair( "analyticsThemeInversion", 0xE867 )); // glyphnumber: 498, Inversion of theme - outMap.emplace(std::make_pair( "analyticsThemeRetrograde", 0xE865 )); // glyphnumber: 499, Retrograde of theme - outMap.emplace(std::make_pair( "analyticsThemeRetrogradeInversion", 0xE866 )); // glyphnumber: 500, Retrograde inversion of theme - outMap.emplace(std::make_pair( "arpeggiatoDown", 0xE635 )); // glyphnumber: 501, Arpeggiato down - outMap.emplace(std::make_pair( "arpeggiatoUp", 0xE634 )); // glyphnumber: 502, Arpeggiato up - outMap.emplace(std::make_pair( "arrowBlackDown", 0xEB64 )); // glyphnumber: 503, Black arrow down (S) - outMap.emplace(std::make_pair( "arrowBlackDownLeft", 0xEB65 )); // glyphnumber: 504, Black arrow down-left (SW) - outMap.emplace(std::make_pair( "arrowBlackDownRight", 0xEB63 )); // glyphnumber: 505, Black arrow down-right (SE) - outMap.emplace(std::make_pair( "arrowBlackLeft", 0xEB66 )); // glyphnumber: 506, Black arrow left (W) - outMap.emplace(std::make_pair( "arrowBlackRight", 0xEB62 )); // glyphnumber: 507, Black arrow right (E) - outMap.emplace(std::make_pair( "arrowBlackUp", 0xEB60 )); // glyphnumber: 508, Black arrow up (N) - outMap.emplace(std::make_pair( "arrowBlackUpLeft", 0xEB67 )); // glyphnumber: 509, Black arrow up-left (NW) - outMap.emplace(std::make_pair( "arrowBlackUpRight", 0xEB61 )); // glyphnumber: 510, Black arrow up-right (NE) - outMap.emplace(std::make_pair( "arrowOpenDown", 0xEB74 )); // glyphnumber: 511, Open arrow down (S) - outMap.emplace(std::make_pair( "arrowOpenDownLeft", 0xEB75 )); // glyphnumber: 512, Open arrow down-left (SW) - outMap.emplace(std::make_pair( "arrowOpenDownRight", 0xEB73 )); // glyphnumber: 513, Open arrow down-right (SE) - outMap.emplace(std::make_pair( "arrowOpenLeft", 0xEB76 )); // glyphnumber: 514, Open arrow left (W) - outMap.emplace(std::make_pair( "arrowOpenRight", 0xEB72 )); // glyphnumber: 515, Open arrow right (E) - outMap.emplace(std::make_pair( "arrowOpenUp", 0xEB70 )); // glyphnumber: 516, Open arrow up (N) - outMap.emplace(std::make_pair( "arrowOpenUpLeft", 0xEB77 )); // glyphnumber: 517, Open arrow up-left (NW) - outMap.emplace(std::make_pair( "arrowOpenUpRight", 0xEB71 )); // glyphnumber: 518, Open arrow up-right (NE) - outMap.emplace(std::make_pair( "arrowWhiteDown", 0xEB6C )); // glyphnumber: 519, White arrow down (S) - outMap.emplace(std::make_pair( "arrowWhiteDownLeft", 0xEB6D )); // glyphnumber: 520, White arrow down-left (SW) - outMap.emplace(std::make_pair( "arrowWhiteDownRight", 0xEB6B )); // glyphnumber: 521, White arrow down-right (SE) - outMap.emplace(std::make_pair( "arrowWhiteLeft", 0xEB6E )); // glyphnumber: 522, White arrow left (W) - outMap.emplace(std::make_pair( "arrowWhiteRight", 0xEB6A )); // glyphnumber: 523, White arrow right (E) - outMap.emplace(std::make_pair( "arrowWhiteUp", 0xEB68 )); // glyphnumber: 524, White arrow up (N) - outMap.emplace(std::make_pair( "arrowWhiteUpLeft", 0xEB6F )); // glyphnumber: 525, White arrow up-left (NW) - outMap.emplace(std::make_pair( "arrowWhiteUpRight", 0xEB69 )); // glyphnumber: 526, White arrow up-right (NE) - outMap.emplace(std::make_pair( "arrowheadBlackDown", 0xEB7C )); // glyphnumber: 527, Black arrowhead down (S) - outMap.emplace(std::make_pair( "arrowheadBlackDownLeft", 0xEB7D )); // glyphnumber: 528, Black arrowhead down-left (SW) - outMap.emplace(std::make_pair( "arrowheadBlackDownRight", 0xEB7B )); // glyphnumber: 529, Black arrowhead down-right (SE) - outMap.emplace(std::make_pair( "arrowheadBlackLeft", 0xEB7E )); // glyphnumber: 530, Black arrowhead left (W) - outMap.emplace(std::make_pair( "arrowheadBlackRight", 0xEB7A )); // glyphnumber: 531, Black arrowhead right (E) - outMap.emplace(std::make_pair( "arrowheadBlackUp", 0xEB78 )); // glyphnumber: 532, Black arrowhead up (N) - outMap.emplace(std::make_pair( "arrowheadBlackUpLeft", 0xEB7F )); // glyphnumber: 533, Black arrowhead up-left (NW) - outMap.emplace(std::make_pair( "arrowheadBlackUpRight", 0xEB79 )); // glyphnumber: 534, Black arrowhead up-right (NE) - outMap.emplace(std::make_pair( "arrowheadOpenDown", 0xEB8C )); // glyphnumber: 535, Open arrowhead down (S) - outMap.emplace(std::make_pair( "arrowheadOpenDownLeft", 0xEB8D )); // glyphnumber: 536, Open arrowhead down-left (SW) - outMap.emplace(std::make_pair( "arrowheadOpenDownRight", 0xEB8B )); // glyphnumber: 537, Open arrowhead down-right (SE) - outMap.emplace(std::make_pair( "arrowheadOpenLeft", 0xEB8E )); // glyphnumber: 538, Open arrowhead left (W) - outMap.emplace(std::make_pair( "arrowheadOpenRight", 0xEB8A )); // glyphnumber: 539, Open arrowhead right (E) - outMap.emplace(std::make_pair( "arrowheadOpenUp", 0xEB88 )); // glyphnumber: 540, Open arrowhead up (N) - outMap.emplace(std::make_pair( "arrowheadOpenUpLeft", 0xEB8F )); // glyphnumber: 541, Open arrowhead up-left (NW) - outMap.emplace(std::make_pair( "arrowheadOpenUpRight", 0xEB89 )); // glyphnumber: 542, Open arrowhead up-right (NE) - outMap.emplace(std::make_pair( "arrowheadWhiteDown", 0xEB84 )); // glyphnumber: 543, White arrowhead down (S) - outMap.emplace(std::make_pair( "arrowheadWhiteDownLeft", 0xEB85 )); // glyphnumber: 544, White arrowhead down-left (SW) - outMap.emplace(std::make_pair( "arrowheadWhiteDownRight", 0xEB83 )); // glyphnumber: 545, White arrowhead down-right (SE) - outMap.emplace(std::make_pair( "arrowheadWhiteLeft", 0xEB86 )); // glyphnumber: 546, White arrowhead left (W) - outMap.emplace(std::make_pair( "arrowheadWhiteRight", 0xEB82 )); // glyphnumber: 547, White arrowhead right (E) - outMap.emplace(std::make_pair( "arrowheadWhiteUp", 0xEB80 )); // glyphnumber: 548, White arrowhead up (N) - outMap.emplace(std::make_pair( "arrowheadWhiteUpLeft", 0xEB87 )); // glyphnumber: 549, White arrowhead up-left (NW) - outMap.emplace(std::make_pair( "arrowheadWhiteUpRight", 0xEB81 )); // glyphnumber: 550, White arrowhead up-right (NE) - outMap.emplace(std::make_pair( "articAccentAbove", 0xE4A0 )); // glyphnumber: 551, Accent above - outMap.emplace(std::make_pair( "articAccentBelow", 0xE4A1 )); // glyphnumber: 552, Accent below - outMap.emplace(std::make_pair( "articAccentStaccatoAbove", 0xE4B0 )); // glyphnumber: 553, Accent-staccato above - outMap.emplace(std::make_pair( "articAccentStaccatoBelow", 0xE4B1 )); // glyphnumber: 554, Accent-staccato below - outMap.emplace(std::make_pair( "articLaissezVibrerAbove", 0xE4BA )); // glyphnumber: 555, Laissez vibrer (l.v.) above - outMap.emplace(std::make_pair( "articLaissezVibrerBelow", 0xE4BB )); // glyphnumber: 556, Laissez vibrer (l.v.) below - outMap.emplace(std::make_pair( "articMarcatoAbove", 0xE4AC )); // glyphnumber: 557, Marcato above - outMap.emplace(std::make_pair( "articMarcatoBelow", 0xE4AD )); // glyphnumber: 558, Marcato below - outMap.emplace(std::make_pair( "articMarcatoStaccatoAbove", 0xE4AE )); // glyphnumber: 559, Marcato-staccato above - outMap.emplace(std::make_pair( "articMarcatoStaccatoBelow", 0xE4AF )); // glyphnumber: 560, Marcato-staccato below - outMap.emplace(std::make_pair( "articMarcatoTenutoAbove", 0xE4BC )); // glyphnumber: 561, Marcato-tenuto above - outMap.emplace(std::make_pair( "articMarcatoTenutoBelow", 0xE4BD )); // glyphnumber: 562, Marcato-tenuto below - outMap.emplace(std::make_pair( "articSoftAccentAbove", 0xED40 )); // glyphnumber: 563, Soft accent above - outMap.emplace(std::make_pair( "articSoftAccentBelow", 0xED41 )); // glyphnumber: 564, Soft accent below - outMap.emplace(std::make_pair( "articSoftAccentStaccatoAbove", 0xED42 )); // glyphnumber: 565, Soft accent-staccato above - outMap.emplace(std::make_pair( "articSoftAccentStaccatoBelow", 0xED43 )); // glyphnumber: 566, Soft accent-staccato below - outMap.emplace(std::make_pair( "articSoftAccentTenutoAbove", 0xED44 )); // glyphnumber: 567, Soft accent-tenuto above - outMap.emplace(std::make_pair( "articSoftAccentTenutoBelow", 0xED45 )); // glyphnumber: 568, Soft accent-tenuto below - outMap.emplace(std::make_pair( "articSoftAccentTenutoStaccatoAbove", 0xED46 )); // glyphnumber: 569, Soft accent-tenuto-staccato above - outMap.emplace(std::make_pair( "articSoftAccentTenutoStaccatoBelow", 0xED47 )); // glyphnumber: 570, Soft accent-tenuto-staccato below - outMap.emplace(std::make_pair( "articStaccatissimoAbove", 0xE4A6 )); // glyphnumber: 571, Staccatissimo above - outMap.emplace(std::make_pair( "articStaccatissimoBelow", 0xE4A7 )); // glyphnumber: 572, Staccatissimo below - outMap.emplace(std::make_pair( "articStaccatissimoStrokeAbove", 0xE4AA )); // glyphnumber: 573, Staccatissimo stroke above - outMap.emplace(std::make_pair( "articStaccatissimoStrokeBelow", 0xE4AB )); // glyphnumber: 574, Staccatissimo stroke below - outMap.emplace(std::make_pair( "articStaccatissimoWedgeAbove", 0xE4A8 )); // glyphnumber: 575, Staccatissimo wedge above - outMap.emplace(std::make_pair( "articStaccatissimoWedgeBelow", 0xE4A9 )); // glyphnumber: 576, Staccatissimo wedge below - outMap.emplace(std::make_pair( "articStaccatoAbove", 0xE4A2 )); // glyphnumber: 577, Staccato above - outMap.emplace(std::make_pair( "articStaccatoBelow", 0xE4A3 )); // glyphnumber: 578, Staccato below - outMap.emplace(std::make_pair( "articStressAbove", 0xE4B6 )); // glyphnumber: 579, Stress above - outMap.emplace(std::make_pair( "articStressBelow", 0xE4B7 )); // glyphnumber: 580, Stress below - outMap.emplace(std::make_pair( "articTenutoAbove", 0xE4A4 )); // glyphnumber: 581, Tenuto above - outMap.emplace(std::make_pair( "articTenutoAccentAbove", 0xE4B4 )); // glyphnumber: 582, Tenuto-accent above - outMap.emplace(std::make_pair( "articTenutoAccentBelow", 0xE4B5 )); // glyphnumber: 583, Tenuto-accent below - outMap.emplace(std::make_pair( "articTenutoBelow", 0xE4A5 )); // glyphnumber: 584, Tenuto below - outMap.emplace(std::make_pair( "articTenutoStaccatoAbove", 0xE4B2 )); // glyphnumber: 585, Louré (tenuto-staccato) above - outMap.emplace(std::make_pair( "articTenutoStaccatoBelow", 0xE4B3 )); // glyphnumber: 586, Louré (tenuto-staccato) below - outMap.emplace(std::make_pair( "articUnstressAbove", 0xE4B8 )); // glyphnumber: 587, Unstress above - outMap.emplace(std::make_pair( "articUnstressBelow", 0xE4B9 )); // glyphnumber: 588, Unstress below - outMap.emplace(std::make_pair( "augmentationDot", 0xE1E7 )); // glyphnumber: 589, Augmentation dot - outMap.emplace(std::make_pair( "barlineDashed", 0xE036 )); // glyphnumber: 590, Dashed barline - outMap.emplace(std::make_pair( "barlineDotted", 0xE037 )); // glyphnumber: 591, Dotted barline - outMap.emplace(std::make_pair( "barlineDouble", 0xE031 )); // glyphnumber: 592, Double barline - outMap.emplace(std::make_pair( "barlineFinal", 0xE032 )); // glyphnumber: 593, Final barline - outMap.emplace(std::make_pair( "barlineHeavy", 0xE034 )); // glyphnumber: 594, Heavy barline - outMap.emplace(std::make_pair( "barlineHeavyHeavy", 0xE035 )); // glyphnumber: 595, Heavy double barline - outMap.emplace(std::make_pair( "barlineReverseFinal", 0xE033 )); // glyphnumber: 596, Reverse final barline - outMap.emplace(std::make_pair( "barlineShort", 0xE038 )); // glyphnumber: 597, Short barline - outMap.emplace(std::make_pair( "barlineSingle", 0xE030 )); // glyphnumber: 598, Single barline - outMap.emplace(std::make_pair( "barlineTick", 0xE039 )); // glyphnumber: 599, Tick barline - outMap.emplace(std::make_pair( "beamAccelRit1", 0xEAF4 )); // glyphnumber: 600, Accel./rit. beam 1 (widest) - outMap.emplace(std::make_pair( "beamAccelRit10", 0xEAFD )); // glyphnumber: 601, Accel./rit. beam 10 - outMap.emplace(std::make_pair( "beamAccelRit11", 0xEAFE )); // glyphnumber: 602, Accel./rit. beam 11 - outMap.emplace(std::make_pair( "beamAccelRit12", 0xEAFF )); // glyphnumber: 603, Accel./rit. beam 12 - outMap.emplace(std::make_pair( "beamAccelRit13", 0xEB00 )); // glyphnumber: 604, Accel./rit. beam 13 - outMap.emplace(std::make_pair( "beamAccelRit14", 0xEB01 )); // glyphnumber: 605, Accel./rit. beam 14 - outMap.emplace(std::make_pair( "beamAccelRit15", 0xEB02 )); // glyphnumber: 606, Accel./rit. beam 15 (narrowest) - outMap.emplace(std::make_pair( "beamAccelRit2", 0xEAF5 )); // glyphnumber: 607, Accel./rit. beam 2 - outMap.emplace(std::make_pair( "beamAccelRit3", 0xEAF6 )); // glyphnumber: 608, Accel./rit. beam 3 - outMap.emplace(std::make_pair( "beamAccelRit4", 0xEAF7 )); // glyphnumber: 609, Accel./rit. beam 4 - outMap.emplace(std::make_pair( "beamAccelRit5", 0xEAF8 )); // glyphnumber: 610, Accel./rit. beam 5 - outMap.emplace(std::make_pair( "beamAccelRit6", 0xEAF9 )); // glyphnumber: 611, Accel./rit. beam 6 - outMap.emplace(std::make_pair( "beamAccelRit7", 0xEAFA )); // glyphnumber: 612, Accel./rit. beam 7 - outMap.emplace(std::make_pair( "beamAccelRit8", 0xEAFB )); // glyphnumber: 613, Accel./rit. beam 8 - outMap.emplace(std::make_pair( "beamAccelRit9", 0xEAFC )); // glyphnumber: 614, Accel./rit. beam 9 - outMap.emplace(std::make_pair( "beamAccelRitFinal", 0xEB03 )); // glyphnumber: 615, Accel./rit. beam terminating line - outMap.emplace(std::make_pair( "brace", 0xE000 )); // glyphnumber: 616, Brace - outMap.emplace(std::make_pair( "bracket", 0xE002 )); // glyphnumber: 617, Bracket - outMap.emplace(std::make_pair( "bracketBottom", 0xE004 )); // glyphnumber: 618, Bracket bottom - outMap.emplace(std::make_pair( "bracketTop", 0xE003 )); // glyphnumber: 619, Bracket top - outMap.emplace(std::make_pair( "brassBend", 0xE5E3 )); // glyphnumber: 620, Bend - outMap.emplace(std::make_pair( "brassDoitLong", 0xE5D6 )); // glyphnumber: 621, Doit, long - outMap.emplace(std::make_pair( "brassDoitMedium", 0xE5D5 )); // glyphnumber: 622, Doit, medium - outMap.emplace(std::make_pair( "brassDoitShort", 0xE5D4 )); // glyphnumber: 623, Doit, short - outMap.emplace(std::make_pair( "brassFallLipLong", 0xE5D9 )); // glyphnumber: 624, Lip fall, long - outMap.emplace(std::make_pair( "brassFallLipMedium", 0xE5D8 )); // glyphnumber: 625, Lip fall, medium - outMap.emplace(std::make_pair( "brassFallLipShort", 0xE5D7 )); // glyphnumber: 626, Lip fall, short - outMap.emplace(std::make_pair( "brassFallRoughLong", 0xE5DF )); // glyphnumber: 627, Rough fall, long - outMap.emplace(std::make_pair( "brassFallRoughMedium", 0xE5DE )); // glyphnumber: 628, Rough fall, medium - outMap.emplace(std::make_pair( "brassFallRoughShort", 0xE5DD )); // glyphnumber: 629, Rough fall, short - outMap.emplace(std::make_pair( "brassFallSmoothLong", 0xE5DC )); // glyphnumber: 630, Smooth fall, long - outMap.emplace(std::make_pair( "brassFallSmoothMedium", 0xE5DB )); // glyphnumber: 631, Smooth fall, medium - outMap.emplace(std::make_pair( "brassFallSmoothShort", 0xE5DA )); // glyphnumber: 632, Smooth fall, short - outMap.emplace(std::make_pair( "brassFlip", 0xE5E1 )); // glyphnumber: 633, Flip - outMap.emplace(std::make_pair( "brassHarmonMuteClosed", 0xE5E8 )); // glyphnumber: 634, Harmon mute, stem in - outMap.emplace(std::make_pair( "brassHarmonMuteStemHalfLeft", 0xE5E9 )); // glyphnumber: 635, Harmon mute, stem extended, left - outMap.emplace(std::make_pair( "brassHarmonMuteStemHalfRight", 0xE5EA )); // glyphnumber: 636, Harmon mute, stem extended, right - outMap.emplace(std::make_pair( "brassHarmonMuteStemOpen", 0xE5EB )); // glyphnumber: 637, Harmon mute, stem out - outMap.emplace(std::make_pair( "brassJazzTurn", 0xE5E4 )); // glyphnumber: 638, Jazz turn - outMap.emplace(std::make_pair( "brassLiftLong", 0xE5D3 )); // glyphnumber: 639, Lift, long - outMap.emplace(std::make_pair( "brassLiftMedium", 0xE5D2 )); // glyphnumber: 640, Lift, medium - outMap.emplace(std::make_pair( "brassLiftShort", 0xE5D1 )); // glyphnumber: 641, Lift, short - outMap.emplace(std::make_pair( "brassLiftSmoothLong", 0xE5EE )); // glyphnumber: 642, Smooth lift, long - outMap.emplace(std::make_pair( "brassLiftSmoothMedium", 0xE5ED )); // glyphnumber: 643, Smooth lift, medium - outMap.emplace(std::make_pair( "brassLiftSmoothShort", 0xE5EC )); // glyphnumber: 644, Smooth lift, short - outMap.emplace(std::make_pair( "brassMuteClosed", 0xE5E5 )); // glyphnumber: 645, Muted (closed) - outMap.emplace(std::make_pair( "brassMuteHalfClosed", 0xE5E6 )); // glyphnumber: 646, Half-muted (half-closed) - outMap.emplace(std::make_pair( "brassMuteOpen", 0xE5E7 )); // glyphnumber: 647, Open - outMap.emplace(std::make_pair( "brassPlop", 0xE5E0 )); // glyphnumber: 648, Plop - outMap.emplace(std::make_pair( "brassScoop", 0xE5D0 )); // glyphnumber: 649, Scoop - outMap.emplace(std::make_pair( "brassSmear", 0xE5E2 )); // glyphnumber: 650, Smear - outMap.emplace(std::make_pair( "brassValveTrill", 0xE5EF )); // glyphnumber: 651, Valve trill - outMap.emplace(std::make_pair( "breathMarkComma", 0xE4CE )); // glyphnumber: 652, Breath mark (comma) - outMap.emplace(std::make_pair( "breathMarkSalzedo", 0xE4D5 )); // glyphnumber: 653, Breath mark (Salzedo) - outMap.emplace(std::make_pair( "breathMarkTick", 0xE4CF )); // glyphnumber: 654, Breath mark (tick-like) - outMap.emplace(std::make_pair( "breathMarkUpbow", 0xE4D0 )); // glyphnumber: 655, Breath mark (upbow-like) - outMap.emplace(std::make_pair( "bridgeClef", 0xE078 )); // glyphnumber: 656, Bridge clef - outMap.emplace(std::make_pair( "buzzRoll", 0xE22A )); // glyphnumber: 657, Buzz roll - outMap.emplace(std::make_pair( "cClef", 0xE05C )); // glyphnumber: 658, C clef - outMap.emplace(std::make_pair( "cClef8vb", 0xE05D )); // glyphnumber: 659, C clef ottava bassa - outMap.emplace(std::make_pair( "cClefArrowDown", 0xE05F )); // glyphnumber: 660, C clef, arrow down - outMap.emplace(std::make_pair( "cClefArrowUp", 0xE05E )); // glyphnumber: 661, C clef, arrow up - outMap.emplace(std::make_pair( "cClefChange", 0xE07B )); // glyphnumber: 662, C clef change - outMap.emplace(std::make_pair( "cClefCombining", 0xE061 )); // glyphnumber: 663, Combining C clef - outMap.emplace(std::make_pair( "cClefReversed", 0xE075 )); // glyphnumber: 664, Reversed C clef - outMap.emplace(std::make_pair( "cClefSquare", 0xE060 )); // glyphnumber: 665, C clef (19th century) - outMap.emplace(std::make_pair( "caesura", 0xE4D1 )); // glyphnumber: 666, Caesura - outMap.emplace(std::make_pair( "caesuraCurved", 0xE4D4 )); // glyphnumber: 667, Curved caesura - outMap.emplace(std::make_pair( "caesuraShort", 0xE4D3 )); // glyphnumber: 668, Short caesura - outMap.emplace(std::make_pair( "caesuraThick", 0xE4D2 )); // glyphnumber: 669, Thick caesura - outMap.emplace(std::make_pair( "chantAccentusAbove", 0xE9D6 )); // glyphnumber: 670, Accentus above - outMap.emplace(std::make_pair( "chantAccentusBelow", 0xE9D7 )); // glyphnumber: 671, Accentus below - outMap.emplace(std::make_pair( "chantAuctumAsc", 0xE994 )); // glyphnumber: 672, Punctum auctum, ascending - outMap.emplace(std::make_pair( "chantAuctumDesc", 0xE995 )); // glyphnumber: 673, Punctum auctum, descending - outMap.emplace(std::make_pair( "chantAugmentum", 0xE9D9 )); // glyphnumber: 674, Augmentum (mora) - outMap.emplace(std::make_pair( "chantCaesura", 0xE8F8 )); // glyphnumber: 675, Caesura - outMap.emplace(std::make_pair( "chantCclef", 0xE906 )); // glyphnumber: 676, Plainchant C clef - outMap.emplace(std::make_pair( "chantCirculusAbove", 0xE9D2 )); // glyphnumber: 677, Circulus above - outMap.emplace(std::make_pair( "chantCirculusBelow", 0xE9D3 )); // glyphnumber: 678, Circulus below - outMap.emplace(std::make_pair( "chantConnectingLineAsc2nd", 0xE9BD )); // glyphnumber: 679, Connecting line, ascending 2nd - outMap.emplace(std::make_pair( "chantConnectingLineAsc3rd", 0xE9BE )); // glyphnumber: 680, Connecting line, ascending 3rd - outMap.emplace(std::make_pair( "chantConnectingLineAsc4th", 0xE9BF )); // glyphnumber: 681, Connecting line, ascending 4th - outMap.emplace(std::make_pair( "chantConnectingLineAsc5th", 0xE9C0 )); // glyphnumber: 682, Connecting line, ascending 5th - outMap.emplace(std::make_pair( "chantConnectingLineAsc6th", 0xE9C1 )); // glyphnumber: 683, Connecting line, ascending 6th - outMap.emplace(std::make_pair( "chantCustosStemDownPosHigh", 0xEA08 )); // glyphnumber: 684, Plainchant custos, stem down, high position - outMap.emplace(std::make_pair( "chantCustosStemDownPosHighest", 0xEA09 )); // glyphnumber: 685, Plainchant custos, stem down, highest position - outMap.emplace(std::make_pair( "chantCustosStemDownPosMiddle", 0xEA07 )); // glyphnumber: 686, Plainchant custos, stem down, middle position - outMap.emplace(std::make_pair( "chantCustosStemUpPosLow", 0xEA05 )); // glyphnumber: 687, Plainchant custos, stem up, low position - outMap.emplace(std::make_pair( "chantCustosStemUpPosLowest", 0xEA04 )); // glyphnumber: 688, Plainchant custos, stem up, lowest position - outMap.emplace(std::make_pair( "chantCustosStemUpPosMiddle", 0xEA06 )); // glyphnumber: 689, Plainchant custos, stem up, middle position - outMap.emplace(std::make_pair( "chantDeminutumLower", 0xE9B3 )); // glyphnumber: 690, Punctum deminutum, lower - outMap.emplace(std::make_pair( "chantDeminutumUpper", 0xE9B2 )); // glyphnumber: 691, Punctum deminutum, upper - outMap.emplace(std::make_pair( "chantDivisioFinalis", 0xE8F6 )); // glyphnumber: 692, Divisio finalis - outMap.emplace(std::make_pair( "chantDivisioMaior", 0xE8F4 )); // glyphnumber: 693, Divisio maior - outMap.emplace(std::make_pair( "chantDivisioMaxima", 0xE8F5 )); // glyphnumber: 694, Divisio maxima - outMap.emplace(std::make_pair( "chantDivisioMinima", 0xE8F3 )); // glyphnumber: 695, Divisio minima - outMap.emplace(std::make_pair( "chantEntryLineAsc2nd", 0xE9B4 )); // glyphnumber: 696, Entry line, ascending 2nd - outMap.emplace(std::make_pair( "chantEntryLineAsc3rd", 0xE9B5 )); // glyphnumber: 697, Entry line, ascending 3rd - outMap.emplace(std::make_pair( "chantEntryLineAsc4th", 0xE9B6 )); // glyphnumber: 698, Entry line, ascending 4th - outMap.emplace(std::make_pair( "chantEntryLineAsc5th", 0xE9B7 )); // glyphnumber: 699, Entry line, ascending 5th - outMap.emplace(std::make_pair( "chantEntryLineAsc6th", 0xE9B8 )); // glyphnumber: 700, Entry line, ascending 6th - outMap.emplace(std::make_pair( "chantEpisema", 0xE9D8 )); // glyphnumber: 701, Episema - outMap.emplace(std::make_pair( "chantFclef", 0xE902 )); // glyphnumber: 702, Plainchant F clef - outMap.emplace(std::make_pair( "chantIctusAbove", 0xE9D0 )); // glyphnumber: 703, Ictus above - outMap.emplace(std::make_pair( "chantIctusBelow", 0xE9D1 )); // glyphnumber: 704, Ictus below - outMap.emplace(std::make_pair( "chantLigaturaDesc2nd", 0xE9B9 )); // glyphnumber: 705, Ligated stroke, descending 2nd - outMap.emplace(std::make_pair( "chantLigaturaDesc3rd", 0xE9BA )); // glyphnumber: 706, Ligated stroke, descending 3rd - outMap.emplace(std::make_pair( "chantLigaturaDesc4th", 0xE9BB )); // glyphnumber: 707, Ligated stroke, descending 4th - outMap.emplace(std::make_pair( "chantLigaturaDesc5th", 0xE9BC )); // glyphnumber: 708, Ligated stroke, descending 5th - outMap.emplace(std::make_pair( "chantOriscusAscending", 0xE99C )); // glyphnumber: 709, Oriscus ascending - outMap.emplace(std::make_pair( "chantOriscusDescending", 0xE99D )); // glyphnumber: 710, Oriscus descending - outMap.emplace(std::make_pair( "chantOriscusLiquescens", 0xE99E )); // glyphnumber: 711, Oriscus liquescens - outMap.emplace(std::make_pair( "chantPodatusLower", 0xE9B0 )); // glyphnumber: 712, Podatus, lower - outMap.emplace(std::make_pair( "chantPodatusUpper", 0xE9B1 )); // glyphnumber: 713, Podatus, upper - outMap.emplace(std::make_pair( "chantPunctum", 0xE990 )); // glyphnumber: 714, Punctum - outMap.emplace(std::make_pair( "chantPunctumCavum", 0xE998 )); // glyphnumber: 715, Punctum cavum - outMap.emplace(std::make_pair( "chantPunctumDeminutum", 0xE9A1 )); // glyphnumber: 716, Punctum deminutum - outMap.emplace(std::make_pair( "chantPunctumInclinatum", 0xE991 )); // glyphnumber: 717, Punctum inclinatum - outMap.emplace(std::make_pair( "chantPunctumInclinatumAuctum", 0xE992 )); // glyphnumber: 718, Punctum inclinatum auctum - outMap.emplace(std::make_pair( "chantPunctumInclinatumDeminutum", 0xE993 )); // glyphnumber: 719, Punctum inclinatum deminutum - outMap.emplace(std::make_pair( "chantPunctumLinea", 0xE999 )); // glyphnumber: 720, Punctum linea - outMap.emplace(std::make_pair( "chantPunctumLineaCavum", 0xE99A )); // glyphnumber: 721, Punctum linea cavum - outMap.emplace(std::make_pair( "chantPunctumVirga", 0xE996 )); // glyphnumber: 722, Punctum virga - outMap.emplace(std::make_pair( "chantPunctumVirgaReversed", 0xE997 )); // glyphnumber: 723, Punctum virga, reversed - outMap.emplace(std::make_pair( "chantQuilisma", 0xE99B )); // glyphnumber: 724, Quilisma - outMap.emplace(std::make_pair( "chantSemicirculusAbove", 0xE9D4 )); // glyphnumber: 725, Semicirculus above - outMap.emplace(std::make_pair( "chantSemicirculusBelow", 0xE9D5 )); // glyphnumber: 726, Semicirculus below - outMap.emplace(std::make_pair( "chantStaff", 0xE8F0 )); // glyphnumber: 727, Plainchant staff - outMap.emplace(std::make_pair( "chantStaffNarrow", 0xE8F2 )); // glyphnumber: 728, Plainchant staff (narrow) - outMap.emplace(std::make_pair( "chantStaffWide", 0xE8F1 )); // glyphnumber: 729, Plainchant staff (wide) - outMap.emplace(std::make_pair( "chantStrophicus", 0xE99F )); // glyphnumber: 730, Strophicus - outMap.emplace(std::make_pair( "chantStrophicusAuctus", 0xE9A0 )); // glyphnumber: 731, Strophicus auctus - outMap.emplace(std::make_pair( "chantStrophicusLiquescens2nd", 0xE9C2 )); // glyphnumber: 732, Strophicus liquescens, 2nd - outMap.emplace(std::make_pair( "chantStrophicusLiquescens3rd", 0xE9C3 )); // glyphnumber: 733, Strophicus liquescens, 3rd - outMap.emplace(std::make_pair( "chantStrophicusLiquescens4th", 0xE9C4 )); // glyphnumber: 734, Strophicus liquescens, 4th - outMap.emplace(std::make_pair( "chantStrophicusLiquescens5th", 0xE9C5 )); // glyphnumber: 735, Strophicus liquescens, 5th - outMap.emplace(std::make_pair( "chantVirgula", 0xE8F7 )); // glyphnumber: 736, Virgula - outMap.emplace(std::make_pair( "clef15", 0xE07E )); // glyphnumber: 737, 15 for clefs - outMap.emplace(std::make_pair( "clef8", 0xE07D )); // glyphnumber: 738, 8 for clefs - outMap.emplace(std::make_pair( "clefChangeCombining", 0xE07F )); // glyphnumber: 739, Combining clef change - outMap.emplace(std::make_pair( "coda", 0xE048 )); // glyphnumber: 740, Coda - outMap.emplace(std::make_pair( "codaSquare", 0xE049 )); // glyphnumber: 741, Square coda - outMap.emplace(std::make_pair( "conductorBeat2Compound", 0xE897 )); // glyphnumber: 742, Beat 2, compound time - outMap.emplace(std::make_pair( "conductorBeat2Simple", 0xE894 )); // glyphnumber: 743, Beat 2, simple time - outMap.emplace(std::make_pair( "conductorBeat3Compound", 0xE898 )); // glyphnumber: 744, Beat 3, compound time - outMap.emplace(std::make_pair( "conductorBeat3Simple", 0xE895 )); // glyphnumber: 745, Beat 3, simple time - outMap.emplace(std::make_pair( "conductorBeat4Compound", 0xE899 )); // glyphnumber: 746, Beat 4, compound time - outMap.emplace(std::make_pair( "conductorBeat4Simple", 0xE896 )); // glyphnumber: 747, Beat 4, simple time - outMap.emplace(std::make_pair( "conductorLeftBeat", 0xE891 )); // glyphnumber: 748, Left-hand beat or cue - outMap.emplace(std::make_pair( "conductorRightBeat", 0xE892 )); // glyphnumber: 749, Right-hand beat or cue - outMap.emplace(std::make_pair( "conductorStrongBeat", 0xE890 )); // glyphnumber: 750, Strong beat or cue - outMap.emplace(std::make_pair( "conductorUnconducted", 0xE89A )); // glyphnumber: 751, Unconducted/free passages - outMap.emplace(std::make_pair( "conductorWeakBeat", 0xE893 )); // glyphnumber: 752, Weak beat or cue - outMap.emplace(std::make_pair( "controlBeginBeam", 0xE8E0 )); // glyphnumber: 753, Begin beam - outMap.emplace(std::make_pair( "controlBeginPhrase", 0xE8E6 )); // glyphnumber: 754, Begin phrase - outMap.emplace(std::make_pair( "controlBeginSlur", 0xE8E4 )); // glyphnumber: 755, Begin slur - outMap.emplace(std::make_pair( "controlBeginTie", 0xE8E2 )); // glyphnumber: 756, Begin tie - outMap.emplace(std::make_pair( "controlEndBeam", 0xE8E1 )); // glyphnumber: 757, End beam - outMap.emplace(std::make_pair( "controlEndPhrase", 0xE8E7 )); // glyphnumber: 758, End phrase - outMap.emplace(std::make_pair( "controlEndSlur", 0xE8E5 )); // glyphnumber: 759, End slur - outMap.emplace(std::make_pair( "controlEndTie", 0xE8E3 )); // glyphnumber: 760, End tie - outMap.emplace(std::make_pair( "csymAugmented", 0xE872 )); // glyphnumber: 761, Augmented - outMap.emplace(std::make_pair( "csymBracketLeftTall", 0xE877 )); // glyphnumber: 762, Double-height left bracket - outMap.emplace(std::make_pair( "csymBracketRightTall", 0xE878 )); // glyphnumber: 763, Double-height right bracket - outMap.emplace(std::make_pair( "csymDiminished", 0xE870 )); // glyphnumber: 764, Diminished - outMap.emplace(std::make_pair( "csymHalfDiminished", 0xE871 )); // glyphnumber: 765, Half-diminished - outMap.emplace(std::make_pair( "csymMajorSeventh", 0xE873 )); // glyphnumber: 766, Major seventh - outMap.emplace(std::make_pair( "csymMinor", 0xE874 )); // glyphnumber: 767, Minor - outMap.emplace(std::make_pair( "csymParensLeftTall", 0xE875 )); // glyphnumber: 768, Double-height left parenthesis - outMap.emplace(std::make_pair( "csymParensRightTall", 0xE876 )); // glyphnumber: 769, Double-height right parenthesis - outMap.emplace(std::make_pair( "curlewSign", 0xE4D6 )); // glyphnumber: 770, Curlew (Britten) - outMap.emplace(std::make_pair( "daCapo", 0xE046 )); // glyphnumber: 771, Da capo - outMap.emplace(std::make_pair( "dalSegno", 0xE045 )); // glyphnumber: 772, Dal segno - outMap.emplace(std::make_pair( "daseianExcellentes1", 0xEA3C )); // glyphnumber: 773, Daseian excellentes 1 - outMap.emplace(std::make_pair( "daseianExcellentes2", 0xEA3D )); // glyphnumber: 774, Daseian excellentes 2 - outMap.emplace(std::make_pair( "daseianExcellentes3", 0xEA3E )); // glyphnumber: 775, Daseian excellentes 3 - outMap.emplace(std::make_pair( "daseianExcellentes4", 0xEA3F )); // glyphnumber: 776, Daseian excellentes 4 - outMap.emplace(std::make_pair( "daseianFinales1", 0xEA34 )); // glyphnumber: 777, Daseian finales 1 - outMap.emplace(std::make_pair( "daseianFinales2", 0xEA35 )); // glyphnumber: 778, Daseian finales 2 - outMap.emplace(std::make_pair( "daseianFinales3", 0xEA36 )); // glyphnumber: 779, Daseian finales 3 - outMap.emplace(std::make_pair( "daseianFinales4", 0xEA37 )); // glyphnumber: 780, Daseian finales 4 - outMap.emplace(std::make_pair( "daseianGraves1", 0xEA30 )); // glyphnumber: 781, Daseian graves 1 - outMap.emplace(std::make_pair( "daseianGraves2", 0xEA31 )); // glyphnumber: 782, Daseian graves 2 - outMap.emplace(std::make_pair( "daseianGraves3", 0xEA32 )); // glyphnumber: 783, Daseian graves 3 - outMap.emplace(std::make_pair( "daseianGraves4", 0xEA33 )); // glyphnumber: 784, Daseian graves 4 - outMap.emplace(std::make_pair( "daseianResidua1", 0xEA40 )); // glyphnumber: 785, Daseian residua 1 - outMap.emplace(std::make_pair( "daseianResidua2", 0xEA41 )); // glyphnumber: 786, Daseian residua 2 - outMap.emplace(std::make_pair( "daseianSuperiores1", 0xEA38 )); // glyphnumber: 787, Daseian superiores 1 - outMap.emplace(std::make_pair( "daseianSuperiores2", 0xEA39 )); // glyphnumber: 788, Daseian superiores 2 - outMap.emplace(std::make_pair( "daseianSuperiores3", 0xEA3A )); // glyphnumber: 789, Daseian superiores 3 - outMap.emplace(std::make_pair( "daseianSuperiores4", 0xEA3B )); // glyphnumber: 790, Daseian superiores 4 - outMap.emplace(std::make_pair( "doubleTongueAbove", 0xE5F0 )); // glyphnumber: 791, Double-tongue above - outMap.emplace(std::make_pair( "doubleTongueBelow", 0xE5F1 )); // glyphnumber: 792, Double-tongue below - outMap.emplace(std::make_pair( "dynamicCombinedSeparatorColon", 0xE546 )); // glyphnumber: 793, Colon separator for combined dynamics - outMap.emplace(std::make_pair( "dynamicCombinedSeparatorHyphen", 0xE547 )); // glyphnumber: 794, Hyphen separator for combined dynamics - outMap.emplace(std::make_pair( "dynamicCombinedSeparatorSpace", 0xE548 )); // glyphnumber: 795, Space separator for combined dynamics - outMap.emplace(std::make_pair( "dynamicCrescendoHairpin", 0xE53E )); // glyphnumber: 796, Crescendo - outMap.emplace(std::make_pair( "dynamicDiminuendoHairpin", 0xE53F )); // glyphnumber: 797, Diminuendo - outMap.emplace(std::make_pair( "dynamicFF", 0xE52F )); // glyphnumber: 798, ff - outMap.emplace(std::make_pair( "dynamicFFF", 0xE530 )); // glyphnumber: 799, fff - outMap.emplace(std::make_pair( "dynamicFFFF", 0xE531 )); // glyphnumber: 800, ffff - outMap.emplace(std::make_pair( "dynamicFFFFF", 0xE532 )); // glyphnumber: 801, fffff - outMap.emplace(std::make_pair( "dynamicFFFFFF", 0xE533 )); // glyphnumber: 802, ffffff - outMap.emplace(std::make_pair( "dynamicForte", 0xE522 )); // glyphnumber: 803, Forte - outMap.emplace(std::make_pair( "dynamicFortePiano", 0xE534 )); // glyphnumber: 804, Forte-piano - outMap.emplace(std::make_pair( "dynamicForzando", 0xE535 )); // glyphnumber: 805, Forzando - outMap.emplace(std::make_pair( "dynamicHairpinBracketLeft", 0xE544 )); // glyphnumber: 806, Left bracket (for hairpins) - outMap.emplace(std::make_pair( "dynamicHairpinBracketRight", 0xE545 )); // glyphnumber: 807, Right bracket (for hairpins) - outMap.emplace(std::make_pair( "dynamicHairpinParenthesisLeft", 0xE542 )); // glyphnumber: 808, Left parenthesis (for hairpins) - outMap.emplace(std::make_pair( "dynamicHairpinParenthesisRight", 0xE543 )); // glyphnumber: 809, Right parenthesis (for hairpins) - outMap.emplace(std::make_pair( "dynamicMF", 0xE52D )); // glyphnumber: 810, mf - outMap.emplace(std::make_pair( "dynamicMP", 0xE52C )); // glyphnumber: 811, mp - outMap.emplace(std::make_pair( "dynamicMessaDiVoce", 0xE540 )); // glyphnumber: 812, Messa di voce - outMap.emplace(std::make_pair( "dynamicMezzo", 0xE521 )); // glyphnumber: 813, Mezzo - outMap.emplace(std::make_pair( "dynamicNiente", 0xE526 )); // glyphnumber: 814, Niente - outMap.emplace(std::make_pair( "dynamicNienteForHairpin", 0xE541 )); // glyphnumber: 815, Niente (for hairpins) - outMap.emplace(std::make_pair( "dynamicPF", 0xE52E )); // glyphnumber: 816, pf - outMap.emplace(std::make_pair( "dynamicPP", 0xE52B )); // glyphnumber: 817, pp - outMap.emplace(std::make_pair( "dynamicPPP", 0xE52A )); // glyphnumber: 818, ppp - outMap.emplace(std::make_pair( "dynamicPPPP", 0xE529 )); // glyphnumber: 819, pppp - outMap.emplace(std::make_pair( "dynamicPPPPP", 0xE528 )); // glyphnumber: 820, ppppp - outMap.emplace(std::make_pair( "dynamicPPPPPP", 0xE527 )); // glyphnumber: 821, pppppp - outMap.emplace(std::make_pair( "dynamicPiano", 0xE520 )); // glyphnumber: 822, Piano - outMap.emplace(std::make_pair( "dynamicRinforzando", 0xE523 )); // glyphnumber: 823, Rinforzando - outMap.emplace(std::make_pair( "dynamicRinforzando1", 0xE53C )); // glyphnumber: 824, Rinforzando 1 - outMap.emplace(std::make_pair( "dynamicRinforzando2", 0xE53D )); // glyphnumber: 825, Rinforzando 2 - outMap.emplace(std::make_pair( "dynamicSforzando", 0xE524 )); // glyphnumber: 826, Sforzando - outMap.emplace(std::make_pair( "dynamicSforzando1", 0xE536 )); // glyphnumber: 827, Sforzando 1 - outMap.emplace(std::make_pair( "dynamicSforzandoPianissimo", 0xE538 )); // glyphnumber: 828, Sforzando-pianissimo - outMap.emplace(std::make_pair( "dynamicSforzandoPiano", 0xE537 )); // glyphnumber: 829, Sforzando-piano - outMap.emplace(std::make_pair( "dynamicSforzato", 0xE539 )); // glyphnumber: 830, Sforzato - outMap.emplace(std::make_pair( "dynamicSforzatoFF", 0xE53B )); // glyphnumber: 831, Sforzatissimo - outMap.emplace(std::make_pair( "dynamicSforzatoPiano", 0xE53A )); // glyphnumber: 832, Sforzato-piano - outMap.emplace(std::make_pair( "dynamicZ", 0xE525 )); // glyphnumber: 833, Z - outMap.emplace(std::make_pair( "elecAudioChannelsEight", 0xEB46 )); // glyphnumber: 834, Eight channels (7.1 surround) - outMap.emplace(std::make_pair( "elecAudioChannelsFive", 0xEB43 )); // glyphnumber: 835, Five channels - outMap.emplace(std::make_pair( "elecAudioChannelsFour", 0xEB42 )); // glyphnumber: 836, Four channels - outMap.emplace(std::make_pair( "elecAudioChannelsOne", 0xEB3E )); // glyphnumber: 837, One channel (mono) - outMap.emplace(std::make_pair( "elecAudioChannelsSeven", 0xEB45 )); // glyphnumber: 838, Seven channels - outMap.emplace(std::make_pair( "elecAudioChannelsSix", 0xEB44 )); // glyphnumber: 839, Six channels (5.1 surround) - outMap.emplace(std::make_pair( "elecAudioChannelsThreeFrontal", 0xEB40 )); // glyphnumber: 840, Three channels (frontal) - outMap.emplace(std::make_pair( "elecAudioChannelsThreeSurround", 0xEB41 )); // glyphnumber: 841, Three channels (surround) - outMap.emplace(std::make_pair( "elecAudioChannelsTwo", 0xEB3F )); // glyphnumber: 842, Two channels (stereo) - outMap.emplace(std::make_pair( "elecAudioIn", 0xEB49 )); // glyphnumber: 843, Audio in - outMap.emplace(std::make_pair( "elecAudioMono", 0xEB3C )); // glyphnumber: 844, Mono audio setup - outMap.emplace(std::make_pair( "elecAudioOut", 0xEB4A )); // glyphnumber: 845, Audio out - outMap.emplace(std::make_pair( "elecAudioStereo", 0xEB3D )); // glyphnumber: 846, Stereo audio setup - outMap.emplace(std::make_pair( "elecCamera", 0xEB1B )); // glyphnumber: 847, Camera - outMap.emplace(std::make_pair( "elecDataIn", 0xEB4D )); // glyphnumber: 848, Data in - outMap.emplace(std::make_pair( "elecDataOut", 0xEB4E )); // glyphnumber: 849, Data out - outMap.emplace(std::make_pair( "elecDisc", 0xEB13 )); // glyphnumber: 850, Disc - outMap.emplace(std::make_pair( "elecDownload", 0xEB4F )); // glyphnumber: 851, Download - outMap.emplace(std::make_pair( "elecEject", 0xEB2B )); // glyphnumber: 852, Eject - outMap.emplace(std::make_pair( "elecFastForward", 0xEB1F )); // glyphnumber: 853, Fast-forward - outMap.emplace(std::make_pair( "elecHeadphones", 0xEB11 )); // glyphnumber: 854, Headphones - outMap.emplace(std::make_pair( "elecHeadset", 0xEB12 )); // glyphnumber: 855, Headset - outMap.emplace(std::make_pair( "elecLineIn", 0xEB47 )); // glyphnumber: 856, Line in - outMap.emplace(std::make_pair( "elecLineOut", 0xEB48 )); // glyphnumber: 857, Line out - outMap.emplace(std::make_pair( "elecLoop", 0xEB23 )); // glyphnumber: 858, Loop - outMap.emplace(std::make_pair( "elecLoudspeaker", 0xEB1A )); // glyphnumber: 859, Loudspeaker - outMap.emplace(std::make_pair( "elecMIDIController0", 0xEB36 )); // glyphnumber: 860, MIDI controller 0% - outMap.emplace(std::make_pair( "elecMIDIController100", 0xEB3B )); // glyphnumber: 861, MIDI controller 100% - outMap.emplace(std::make_pair( "elecMIDIController20", 0xEB37 )); // glyphnumber: 862, MIDI controller 20% - outMap.emplace(std::make_pair( "elecMIDIController40", 0xEB38 )); // glyphnumber: 863, MIDI controller 40% - outMap.emplace(std::make_pair( "elecMIDIController60", 0xEB39 )); // glyphnumber: 864, MIDI controller 60% - outMap.emplace(std::make_pair( "elecMIDIController80", 0xEB3A )); // glyphnumber: 865, MIDI controller 80% - outMap.emplace(std::make_pair( "elecMIDIIn", 0xEB34 )); // glyphnumber: 866, MIDI in - outMap.emplace(std::make_pair( "elecMIDIOut", 0xEB35 )); // glyphnumber: 867, MIDI out - outMap.emplace(std::make_pair( "elecMicrophone", 0xEB10 )); // glyphnumber: 868, Microphone - outMap.emplace(std::make_pair( "elecMicrophoneMute", 0xEB28 )); // glyphnumber: 869, Mute microphone - outMap.emplace(std::make_pair( "elecMicrophoneUnmute", 0xEB29 )); // glyphnumber: 870, Unmute microphone - outMap.emplace(std::make_pair( "elecMixingConsole", 0xEB15 )); // glyphnumber: 871, Mixing console - outMap.emplace(std::make_pair( "elecMonitor", 0xEB18 )); // glyphnumber: 872, Monitor - outMap.emplace(std::make_pair( "elecMute", 0xEB26 )); // glyphnumber: 873, Mute - outMap.emplace(std::make_pair( "elecPause", 0xEB1E )); // glyphnumber: 874, Pause - outMap.emplace(std::make_pair( "elecPlay", 0xEB1C )); // glyphnumber: 875, Play - outMap.emplace(std::make_pair( "elecPowerOnOff", 0xEB2A )); // glyphnumber: 876, Power on/off - outMap.emplace(std::make_pair( "elecProjector", 0xEB19 )); // glyphnumber: 877, Projector - outMap.emplace(std::make_pair( "elecReplay", 0xEB24 )); // glyphnumber: 878, Replay - outMap.emplace(std::make_pair( "elecRewind", 0xEB20 )); // glyphnumber: 879, Rewind - outMap.emplace(std::make_pair( "elecShuffle", 0xEB25 )); // glyphnumber: 880, Shuffle - outMap.emplace(std::make_pair( "elecSkipBackwards", 0xEB22 )); // glyphnumber: 881, Skip backwards - outMap.emplace(std::make_pair( "elecSkipForwards", 0xEB21 )); // glyphnumber: 882, Skip forwards - outMap.emplace(std::make_pair( "elecStop", 0xEB1D )); // glyphnumber: 883, Stop - outMap.emplace(std::make_pair( "elecTape", 0xEB14 )); // glyphnumber: 884, Tape - outMap.emplace(std::make_pair( "elecUSB", 0xEB16 )); // glyphnumber: 885, USB connection - outMap.emplace(std::make_pair( "elecUnmute", 0xEB27 )); // glyphnumber: 886, Unmute - outMap.emplace(std::make_pair( "elecUpload", 0xEB50 )); // glyphnumber: 887, Upload - outMap.emplace(std::make_pair( "elecVideoCamera", 0xEB17 )); // glyphnumber: 888, Video camera - outMap.emplace(std::make_pair( "elecVideoIn", 0xEB4B )); // glyphnumber: 889, Video in - outMap.emplace(std::make_pair( "elecVideoOut", 0xEB4C )); // glyphnumber: 890, Video out - outMap.emplace(std::make_pair( "elecVolumeFader", 0xEB2C )); // glyphnumber: 891, Combining volume fader - outMap.emplace(std::make_pair( "elecVolumeFaderThumb", 0xEB2D )); // glyphnumber: 892, Combining volume fader thumb - outMap.emplace(std::make_pair( "elecVolumeLevel0", 0xEB2E )); // glyphnumber: 893, Volume level 0% - outMap.emplace(std::make_pair( "elecVolumeLevel100", 0xEB33 )); // glyphnumber: 894, Volume level 100% - outMap.emplace(std::make_pair( "elecVolumeLevel20", 0xEB2F )); // glyphnumber: 895, Volume level 20% - outMap.emplace(std::make_pair( "elecVolumeLevel40", 0xEB30 )); // glyphnumber: 896, Volume level 40% - outMap.emplace(std::make_pair( "elecVolumeLevel60", 0xEB31 )); // glyphnumber: 897, Volume level 60% - outMap.emplace(std::make_pair( "elecVolumeLevel80", 0xEB32 )); // glyphnumber: 898, Volume level 80% - outMap.emplace(std::make_pair( "fClef", 0xE062 )); // glyphnumber: 899, F clef - outMap.emplace(std::make_pair( "fClef15ma", 0xE066 )); // glyphnumber: 900, F clef quindicesima alta - outMap.emplace(std::make_pair( "fClef15mb", 0xE063 )); // glyphnumber: 901, F clef quindicesima bassa - outMap.emplace(std::make_pair( "fClef8va", 0xE065 )); // glyphnumber: 902, F clef ottava alta - outMap.emplace(std::make_pair( "fClef8vb", 0xE064 )); // glyphnumber: 903, F clef ottava bassa - outMap.emplace(std::make_pair( "fClefArrowDown", 0xE068 )); // glyphnumber: 904, F clef, arrow down - outMap.emplace(std::make_pair( "fClefArrowUp", 0xE067 )); // glyphnumber: 905, F clef, arrow up - outMap.emplace(std::make_pair( "fClefChange", 0xE07C )); // glyphnumber: 906, F clef change - outMap.emplace(std::make_pair( "fClefReversed", 0xE076 )); // glyphnumber: 907, Reversed F clef - outMap.emplace(std::make_pair( "fClefTurned", 0xE077 )); // glyphnumber: 908, Turned F clef - outMap.emplace(std::make_pair( "fermataAbove", 0xE4C0 )); // glyphnumber: 909, Fermata above - outMap.emplace(std::make_pair( "fermataBelow", 0xE4C1 )); // glyphnumber: 910, Fermata below - outMap.emplace(std::make_pair( "fermataLongAbove", 0xE4C6 )); // glyphnumber: 911, Long fermata above - outMap.emplace(std::make_pair( "fermataLongBelow", 0xE4C7 )); // glyphnumber: 912, Long fermata below - outMap.emplace(std::make_pair( "fermataLongHenzeAbove", 0xE4CA )); // glyphnumber: 913, Long fermata (Henze) above - outMap.emplace(std::make_pair( "fermataLongHenzeBelow", 0xE4CB )); // glyphnumber: 914, Long fermata (Henze) below - outMap.emplace(std::make_pair( "fermataShortAbove", 0xE4C4 )); // glyphnumber: 915, Short fermata above - outMap.emplace(std::make_pair( "fermataShortBelow", 0xE4C5 )); // glyphnumber: 916, Short fermata below - outMap.emplace(std::make_pair( "fermataShortHenzeAbove", 0xE4CC )); // glyphnumber: 917, Short fermata (Henze) above - outMap.emplace(std::make_pair( "fermataShortHenzeBelow", 0xE4CD )); // glyphnumber: 918, Short fermata (Henze) below - outMap.emplace(std::make_pair( "fermataVeryLongAbove", 0xE4C8 )); // glyphnumber: 919, Very long fermata above - outMap.emplace(std::make_pair( "fermataVeryLongBelow", 0xE4C9 )); // glyphnumber: 920, Very long fermata below - outMap.emplace(std::make_pair( "fermataVeryShortAbove", 0xE4C2 )); // glyphnumber: 921, Very short fermata above - outMap.emplace(std::make_pair( "fermataVeryShortBelow", 0xE4C3 )); // glyphnumber: 922, Very short fermata below - outMap.emplace(std::make_pair( "figbass0", 0xEA50 )); // glyphnumber: 923, Figured bass 0 - outMap.emplace(std::make_pair( "figbass1", 0xEA51 )); // glyphnumber: 924, Figured bass 1 - outMap.emplace(std::make_pair( "figbass2", 0xEA52 )); // glyphnumber: 925, Figured bass 2 - outMap.emplace(std::make_pair( "figbass2Raised", 0xEA53 )); // glyphnumber: 926, Figured bass 2 raised by half-step - outMap.emplace(std::make_pair( "figbass3", 0xEA54 )); // glyphnumber: 927, Figured bass 3 - outMap.emplace(std::make_pair( "figbass4", 0xEA55 )); // glyphnumber: 928, Figured bass 4 - outMap.emplace(std::make_pair( "figbass4Raised", 0xEA56 )); // glyphnumber: 929, Figured bass 4 raised by half-step - outMap.emplace(std::make_pair( "figbass5", 0xEA57 )); // glyphnumber: 930, Figured bass 5 - outMap.emplace(std::make_pair( "figbass5Raised1", 0xEA58 )); // glyphnumber: 931, Figured bass 5 raised by half-step - outMap.emplace(std::make_pair( "figbass5Raised2", 0xEA59 )); // glyphnumber: 932, Figured bass 5 raised by half-step 2 - outMap.emplace(std::make_pair( "figbass5Raised3", 0xEA5A )); // glyphnumber: 933, Figured bass diminished 5 - outMap.emplace(std::make_pair( "figbass6", 0xEA5B )); // glyphnumber: 934, Figured bass 6 - outMap.emplace(std::make_pair( "figbass6Raised", 0xEA5C )); // glyphnumber: 935, Figured bass 6 raised by half-step - outMap.emplace(std::make_pair( "figbass6Raised2", 0xEA6F )); // glyphnumber: 936, Figured bass 6 raised by half-step 2 - outMap.emplace(std::make_pair( "figbass7", 0xEA5D )); // glyphnumber: 937, Figured bass 7 - outMap.emplace(std::make_pair( "figbass7Diminished", 0xECC0 )); // glyphnumber: 938, Figured bass 7 diminished - outMap.emplace(std::make_pair( "figbass7Raised1", 0xEA5E )); // glyphnumber: 939, Figured bass 7 raised by half-step - outMap.emplace(std::make_pair( "figbass7Raised2", 0xEA5F )); // glyphnumber: 940, Figured bass 7 raised by a half-step 2 - outMap.emplace(std::make_pair( "figbass8", 0xEA60 )); // glyphnumber: 941, Figured bass 8 - outMap.emplace(std::make_pair( "figbass9", 0xEA61 )); // glyphnumber: 942, Figured bass 9 - outMap.emplace(std::make_pair( "figbass9Raised", 0xEA62 )); // glyphnumber: 943, Figured bass 9 raised by half-step - outMap.emplace(std::make_pair( "figbassBracketLeft", 0xEA68 )); // glyphnumber: 944, Figured bass [ - outMap.emplace(std::make_pair( "figbassBracketRight", 0xEA69 )); // glyphnumber: 945, Figured bass ] - outMap.emplace(std::make_pair( "figbassCombiningLowering", 0xEA6E )); // glyphnumber: 946, Combining lower - outMap.emplace(std::make_pair( "figbassCombiningRaising", 0xEA6D )); // glyphnumber: 947, Combining raise - outMap.emplace(std::make_pair( "figbassDoubleFlat", 0xEA63 )); // glyphnumber: 948, Figured bass double flat - outMap.emplace(std::make_pair( "figbassDoubleSharp", 0xEA67 )); // glyphnumber: 949, Figured bass double sharp - outMap.emplace(std::make_pair( "figbassFlat", 0xEA64 )); // glyphnumber: 950, Figured bass flat - outMap.emplace(std::make_pair( "figbassNatural", 0xEA65 )); // glyphnumber: 951, Figured bass natural - outMap.emplace(std::make_pair( "figbassParensLeft", 0xEA6A )); // glyphnumber: 952, Figured bass ( - outMap.emplace(std::make_pair( "figbassParensRight", 0xEA6B )); // glyphnumber: 953, Figured bass ) - outMap.emplace(std::make_pair( "figbassPlus", 0xEA6C )); // glyphnumber: 954, Figured bass + - outMap.emplace(std::make_pair( "figbassSharp", 0xEA66 )); // glyphnumber: 955, Figured bass sharp - outMap.emplace(std::make_pair( "fingering0", 0xED10 )); // glyphnumber: 956, Fingering 0 (open string) - outMap.emplace(std::make_pair( "fingering1", 0xED11 )); // glyphnumber: 957, Fingering 1 (thumb) - outMap.emplace(std::make_pair( "fingering2", 0xED12 )); // glyphnumber: 958, Fingering 2 (index finger) - outMap.emplace(std::make_pair( "fingering3", 0xED13 )); // glyphnumber: 959, Fingering 3 (middle finger) - outMap.emplace(std::make_pair( "fingering4", 0xED14 )); // glyphnumber: 960, Fingering 4 (ring finger) - outMap.emplace(std::make_pair( "fingering5", 0xED15 )); // glyphnumber: 961, Fingering 5 (little finger) - outMap.emplace(std::make_pair( "fingeringALower", 0xED1B )); // glyphnumber: 962, Fingering a (anular; right-hand ring finger for guitar) - outMap.emplace(std::make_pair( "fingeringCLower", 0xED1C )); // glyphnumber: 963, Fingering c (right-hand little finger for guitar) - outMap.emplace(std::make_pair( "fingeringELower", 0xED1E )); // glyphnumber: 964, Fingering e (right-hand little finger for guitar) - outMap.emplace(std::make_pair( "fingeringILower", 0xED19 )); // glyphnumber: 965, Fingering i (indicio; right-hand index finger for guitar) - outMap.emplace(std::make_pair( "fingeringMLower", 0xED1A )); // glyphnumber: 966, Fingering m (medio; right-hand middle finger for guitar) - outMap.emplace(std::make_pair( "fingeringMultipleNotes", 0xED23 )); // glyphnumber: 967, Multiple notes played by thumb or single finger - outMap.emplace(std::make_pair( "fingeringOLower", 0xED1F )); // glyphnumber: 968, Fingering o (right-hand little finger for guitar) - outMap.emplace(std::make_pair( "fingeringPLower", 0xED17 )); // glyphnumber: 969, Fingering p (pulgar; right-hand thumb for guitar) - outMap.emplace(std::make_pair( "fingeringSubstitutionAbove", 0xED20 )); // glyphnumber: 970, Finger substitution above - outMap.emplace(std::make_pair( "fingeringSubstitutionBelow", 0xED21 )); // glyphnumber: 971, Finger substitution below - outMap.emplace(std::make_pair( "fingeringSubstitutionDash", 0xED22 )); // glyphnumber: 972, Finger substitution dash - outMap.emplace(std::make_pair( "fingeringTLower", 0xED18 )); // glyphnumber: 973, Fingering t (right-hand thumb for guitar) - outMap.emplace(std::make_pair( "fingeringTUpper", 0xED16 )); // glyphnumber: 974, Fingering T (left-hand thumb for guitar) - outMap.emplace(std::make_pair( "fingeringXLower", 0xED1D )); // glyphnumber: 975, Fingering x (right-hand little finger for guitar) - outMap.emplace(std::make_pair( "flag1024thDown", 0xE24F )); // glyphnumber: 976, Combining flag 8 (1024th) below - outMap.emplace(std::make_pair( "flag1024thUp", 0xE24E )); // glyphnumber: 977, Combining flag 8 (1024th) above - outMap.emplace(std::make_pair( "flag128thDown", 0xE249 )); // glyphnumber: 978, Combining flag 5 (128th) below - outMap.emplace(std::make_pair( "flag128thUp", 0xE248 )); // glyphnumber: 979, Combining flag 5 (128th) above - outMap.emplace(std::make_pair( "flag16thDown", 0xE243 )); // glyphnumber: 980, Combining flag 2 (16th) below - outMap.emplace(std::make_pair( "flag16thUp", 0xE242 )); // glyphnumber: 981, Combining flag 2 (16th) above - outMap.emplace(std::make_pair( "flag256thDown", 0xE24B )); // glyphnumber: 982, Combining flag 6 (256th) below - outMap.emplace(std::make_pair( "flag256thUp", 0xE24A )); // glyphnumber: 983, Combining flag 6 (256th) above - outMap.emplace(std::make_pair( "flag32ndDown", 0xE245 )); // glyphnumber: 984, Combining flag 3 (32nd) below - outMap.emplace(std::make_pair( "flag32ndUp", 0xE244 )); // glyphnumber: 985, Combining flag 3 (32nd) above - outMap.emplace(std::make_pair( "flag512thDown", 0xE24D )); // glyphnumber: 986, Combining flag 7 (512th) below - outMap.emplace(std::make_pair( "flag512thUp", 0xE24C )); // glyphnumber: 987, Combining flag 7 (512th) above - outMap.emplace(std::make_pair( "flag64thDown", 0xE247 )); // glyphnumber: 988, Combining flag 4 (64th) below - outMap.emplace(std::make_pair( "flag64thUp", 0xE246 )); // glyphnumber: 989, Combining flag 4 (64th) above - outMap.emplace(std::make_pair( "flag8thDown", 0xE241 )); // glyphnumber: 990, Combining flag 1 (8th) below - outMap.emplace(std::make_pair( "flag8thUp", 0xE240 )); // glyphnumber: 991, Combining flag 1 (8th) above - outMap.emplace(std::make_pair( "flagInternalDown", 0xE251 )); // glyphnumber: 992, Internal combining flag below - outMap.emplace(std::make_pair( "flagInternalUp", 0xE250 )); // glyphnumber: 993, Internal combining flag above - outMap.emplace(std::make_pair( "fretboard3String", 0xE850 )); // glyphnumber: 994, 3-string fretboard - outMap.emplace(std::make_pair( "fretboard3StringNut", 0xE851 )); // glyphnumber: 995, 3-string fretboard at nut - outMap.emplace(std::make_pair( "fretboard4String", 0xE852 )); // glyphnumber: 996, 4-string fretboard - outMap.emplace(std::make_pair( "fretboard4StringNut", 0xE853 )); // glyphnumber: 997, 4-string fretboard at nut - outMap.emplace(std::make_pair( "fretboard5String", 0xE854 )); // glyphnumber: 998, 5-string fretboard - outMap.emplace(std::make_pair( "fretboard5StringNut", 0xE855 )); // glyphnumber: 999, 5-string fretboard at nut - outMap.emplace(std::make_pair( "fretboard6String", 0xE856 )); // glyphnumber: 1000, 6-string fretboard - outMap.emplace(std::make_pair( "fretboard6StringNut", 0xE857 )); // glyphnumber: 1001, 6-string fretboard at nut - outMap.emplace(std::make_pair( "fretboardFilledCircle", 0xE858 )); // glyphnumber: 1002, Fingered fret (filled circle) - outMap.emplace(std::make_pair( "fretboardO", 0xE85A )); // glyphnumber: 1003, Open string (O) - outMap.emplace(std::make_pair( "fretboardX", 0xE859 )); // glyphnumber: 1004, String not played (X) - outMap.emplace(std::make_pair( "functionAngleLeft", 0xEA93 )); // glyphnumber: 1005, Function theory angle bracket left - outMap.emplace(std::make_pair( "functionAngleRight", 0xEA94 )); // glyphnumber: 1006, Function theory angle bracket right - outMap.emplace(std::make_pair( "functionBracketLeft", 0xEA8F )); // glyphnumber: 1007, Function theory bracket left - outMap.emplace(std::make_pair( "functionBracketRight", 0xEA90 )); // glyphnumber: 1008, Function theory bracket right - outMap.emplace(std::make_pair( "functionDD", 0xEA81 )); // glyphnumber: 1009, Function theory dominant of dominant - outMap.emplace(std::make_pair( "functionDLower", 0xEA80 )); // glyphnumber: 1010, Function theory minor dominant - outMap.emplace(std::make_pair( "functionDUpper", 0xEA7F )); // glyphnumber: 1011, Function theory major dominant - outMap.emplace(std::make_pair( "functionEight", 0xEA78 )); // glyphnumber: 1012, Function theory 8 - outMap.emplace(std::make_pair( "functionFUpper", 0xEA99 )); // glyphnumber: 1013, Function theory F - outMap.emplace(std::make_pair( "functionFive", 0xEA75 )); // glyphnumber: 1014, Function theory 5 - outMap.emplace(std::make_pair( "functionFour", 0xEA74 )); // glyphnumber: 1015, Function theory 4 - outMap.emplace(std::make_pair( "functionGLower", 0xEA84 )); // glyphnumber: 1016, Function theory g - outMap.emplace(std::make_pair( "functionGUpper", 0xEA83 )); // glyphnumber: 1017, Function theory G - outMap.emplace(std::make_pair( "functionGreaterThan", 0xEA7C )); // glyphnumber: 1018, Function theory greater than - outMap.emplace(std::make_pair( "functionILower", 0xEA9B )); // glyphnumber: 1019, Function theory i - outMap.emplace(std::make_pair( "functionIUpper", 0xEA9A )); // glyphnumber: 1020, Function theory I - outMap.emplace(std::make_pair( "functionKLower", 0xEA9D )); // glyphnumber: 1021, Function theory k - outMap.emplace(std::make_pair( "functionKUpper", 0xEA9C )); // glyphnumber: 1022, Function theory K - outMap.emplace(std::make_pair( "functionLLower", 0xEA9F )); // glyphnumber: 1023, Function theory l - outMap.emplace(std::make_pair( "functionLUpper", 0xEA9E )); // glyphnumber: 1024, Function theory L - outMap.emplace(std::make_pair( "functionLessThan", 0xEA7A )); // glyphnumber: 1025, Function theory less than - outMap.emplace(std::make_pair( "functionMLower", 0xED01 )); // glyphnumber: 1026, Function theory m - outMap.emplace(std::make_pair( "functionMUpper", 0xED00 )); // glyphnumber: 1027, Function theory M - outMap.emplace(std::make_pair( "functionMinus", 0xEA7B )); // glyphnumber: 1028, Function theory minus - outMap.emplace(std::make_pair( "functionNLower", 0xEA86 )); // glyphnumber: 1029, Function theory n - outMap.emplace(std::make_pair( "functionNUpper", 0xEA85 )); // glyphnumber: 1030, Function theory N - outMap.emplace(std::make_pair( "functionNUpperSuperscript", 0xED02 )); // glyphnumber: 1031, Function theory superscript N - outMap.emplace(std::make_pair( "functionNine", 0xEA79 )); // glyphnumber: 1032, Function theory 9 - outMap.emplace(std::make_pair( "functionOne", 0xEA71 )); // glyphnumber: 1033, Function theory 1 - outMap.emplace(std::make_pair( "functionPLower", 0xEA88 )); // glyphnumber: 1034, Function theory p - outMap.emplace(std::make_pair( "functionPUpper", 0xEA87 )); // glyphnumber: 1035, Function theory P - outMap.emplace(std::make_pair( "functionParensLeft", 0xEA91 )); // glyphnumber: 1036, Function theory parenthesis left - outMap.emplace(std::make_pair( "functionParensRight", 0xEA92 )); // glyphnumber: 1037, Function theory parenthesis right - outMap.emplace(std::make_pair( "functionPlus", 0xEA98 )); // glyphnumber: 1038, Function theory prefix plus - outMap.emplace(std::make_pair( "functionRLower", 0xED03 )); // glyphnumber: 1039, Function theory r - outMap.emplace(std::make_pair( "functionRepetition1", 0xEA95 )); // glyphnumber: 1040, Function theory repetition 1 - outMap.emplace(std::make_pair( "functionRepetition2", 0xEA96 )); // glyphnumber: 1041, Function theory repetition 2 - outMap.emplace(std::make_pair( "functionRing", 0xEA97 )); // glyphnumber: 1042, Function theory prefix ring - outMap.emplace(std::make_pair( "functionSLower", 0xEA8A )); // glyphnumber: 1043, Function theory minor subdominant - outMap.emplace(std::make_pair( "functionSSLower", 0xEA7E )); // glyphnumber: 1044, Function theory minor subdominant of subdominant - outMap.emplace(std::make_pair( "functionSSUpper", 0xEA7D )); // glyphnumber: 1045, Function theory major subdominant of subdominant - outMap.emplace(std::make_pair( "functionSUpper", 0xEA89 )); // glyphnumber: 1046, Function theory major subdominant - outMap.emplace(std::make_pair( "functionSeven", 0xEA77 )); // glyphnumber: 1047, Function theory 7 - outMap.emplace(std::make_pair( "functionSix", 0xEA76 )); // glyphnumber: 1048, Function theory 6 - outMap.emplace(std::make_pair( "functionSlashedDD", 0xEA82 )); // glyphnumber: 1049, Function theory double dominant seventh - outMap.emplace(std::make_pair( "functionTLower", 0xEA8C )); // glyphnumber: 1050, Function theory minor tonic - outMap.emplace(std::make_pair( "functionTUpper", 0xEA8B )); // glyphnumber: 1051, Function theory tonic - outMap.emplace(std::make_pair( "functionThree", 0xEA73 )); // glyphnumber: 1052, Function theory 3 - outMap.emplace(std::make_pair( "functionTwo", 0xEA72 )); // glyphnumber: 1053, Function theory 2 - outMap.emplace(std::make_pair( "functionVLower", 0xEA8E )); // glyphnumber: 1054, Function theory v - outMap.emplace(std::make_pair( "functionVUpper", 0xEA8D )); // glyphnumber: 1055, Function theory V - outMap.emplace(std::make_pair( "functionZero", 0xEA70 )); // glyphnumber: 1056, Function theory 0 - outMap.emplace(std::make_pair( "gClef", 0xE050 )); // glyphnumber: 1057, G clef - outMap.emplace(std::make_pair( "gClef15ma", 0xE054 )); // glyphnumber: 1058, G clef quindicesima alta - outMap.emplace(std::make_pair( "gClef15mb", 0xE051 )); // glyphnumber: 1059, G clef quindicesima bassa - outMap.emplace(std::make_pair( "gClef8va", 0xE053 )); // glyphnumber: 1060, G clef ottava alta - outMap.emplace(std::make_pair( "gClef8vb", 0xE052 )); // glyphnumber: 1061, G clef ottava bassa - outMap.emplace(std::make_pair( "gClef8vbCClef", 0xE056 )); // glyphnumber: 1062, G clef ottava bassa with C clef - outMap.emplace(std::make_pair( "gClef8vbOld", 0xE055 )); // glyphnumber: 1063, G clef ottava bassa (old style) - outMap.emplace(std::make_pair( "gClef8vbParens", 0xE057 )); // glyphnumber: 1064, G clef, optionally ottava bassa - outMap.emplace(std::make_pair( "gClefArrowDown", 0xE05B )); // glyphnumber: 1065, G clef, arrow down - outMap.emplace(std::make_pair( "gClefArrowUp", 0xE05A )); // glyphnumber: 1066, G clef, arrow up - outMap.emplace(std::make_pair( "gClefChange", 0xE07A )); // glyphnumber: 1067, G clef change - outMap.emplace(std::make_pair( "gClefLigatedNumberAbove", 0xE059 )); // glyphnumber: 1068, Combining G clef, number above - outMap.emplace(std::make_pair( "gClefLigatedNumberBelow", 0xE058 )); // glyphnumber: 1069, Combining G clef, number below - outMap.emplace(std::make_pair( "gClefReversed", 0xE073 )); // glyphnumber: 1070, Reversed G clef - outMap.emplace(std::make_pair( "gClefTurned", 0xE074 )); // glyphnumber: 1071, Turned G clef - outMap.emplace(std::make_pair( "glissandoDown", 0xE586 )); // glyphnumber: 1072, Glissando down - outMap.emplace(std::make_pair( "glissandoUp", 0xE585 )); // glyphnumber: 1073, Glissando up - outMap.emplace(std::make_pair( "graceNoteAcciaccaturaStemDown", 0xE561 )); // glyphnumber: 1074, Slashed grace note stem down - outMap.emplace(std::make_pair( "graceNoteAcciaccaturaStemUp", 0xE560 )); // glyphnumber: 1075, Slashed grace note stem up - outMap.emplace(std::make_pair( "graceNoteAppoggiaturaStemDown", 0xE563 )); // glyphnumber: 1076, Grace note stem down - outMap.emplace(std::make_pair( "graceNoteAppoggiaturaStemUp", 0xE562 )); // glyphnumber: 1077, Grace note stem up - outMap.emplace(std::make_pair( "graceNoteSlashStemDown", 0xE565 )); // glyphnumber: 1078, Slash for stem down grace note - outMap.emplace(std::make_pair( "graceNoteSlashStemUp", 0xE564 )); // glyphnumber: 1079, Slash for stem up grace note - outMap.emplace(std::make_pair( "guitarBarreFull", 0xE848 )); // glyphnumber: 1080, Full barré - outMap.emplace(std::make_pair( "guitarBarreHalf", 0xE849 )); // glyphnumber: 1081, Half barré - outMap.emplace(std::make_pair( "guitarClosePedal", 0xE83F )); // glyphnumber: 1082, Closed wah/volume pedal - outMap.emplace(std::make_pair( "guitarFadeIn", 0xE843 )); // glyphnumber: 1083, Fade in - outMap.emplace(std::make_pair( "guitarFadeOut", 0xE844 )); // glyphnumber: 1084, Fade out - outMap.emplace(std::make_pair( "guitarGolpe", 0xE842 )); // glyphnumber: 1085, Golpe (tapping the pick guard) - outMap.emplace(std::make_pair( "guitarHalfOpenPedal", 0xE83E )); // glyphnumber: 1086, Half-open wah/volume pedal - outMap.emplace(std::make_pair( "guitarLeftHandTapping", 0xE840 )); // glyphnumber: 1087, Left-hand tapping - outMap.emplace(std::make_pair( "guitarOpenPedal", 0xE83D )); // glyphnumber: 1088, Open wah/volume pedal - outMap.emplace(std::make_pair( "guitarRightHandTapping", 0xE841 )); // glyphnumber: 1089, Right-hand tapping - outMap.emplace(std::make_pair( "guitarShake", 0xE832 )); // glyphnumber: 1090, Guitar shake - outMap.emplace(std::make_pair( "guitarString0", 0xE833 )); // glyphnumber: 1091, String number 0 - outMap.emplace(std::make_pair( "guitarString1", 0xE834 )); // glyphnumber: 1092, String number 1 - outMap.emplace(std::make_pair( "guitarString2", 0xE835 )); // glyphnumber: 1093, String number 2 - outMap.emplace(std::make_pair( "guitarString3", 0xE836 )); // glyphnumber: 1094, String number 3 - outMap.emplace(std::make_pair( "guitarString4", 0xE837 )); // glyphnumber: 1095, String number 4 - outMap.emplace(std::make_pair( "guitarString5", 0xE838 )); // glyphnumber: 1096, String number 5 - outMap.emplace(std::make_pair( "guitarString6", 0xE839 )); // glyphnumber: 1097, String number 6 - outMap.emplace(std::make_pair( "guitarString7", 0xE83A )); // glyphnumber: 1098, String number 7 - outMap.emplace(std::make_pair( "guitarString8", 0xE83B )); // glyphnumber: 1099, String number 8 - outMap.emplace(std::make_pair( "guitarString9", 0xE83C )); // glyphnumber: 1100, String number 9 - outMap.emplace(std::make_pair( "guitarStrumDown", 0xE847 )); // glyphnumber: 1101, Strum direction down - outMap.emplace(std::make_pair( "guitarStrumUp", 0xE846 )); // glyphnumber: 1102, Strum direction up - outMap.emplace(std::make_pair( "guitarVibratoBarDip", 0xE831 )); // glyphnumber: 1103, Guitar vibrato bar dip - outMap.emplace(std::make_pair( "guitarVibratoBarScoop", 0xE830 )); // glyphnumber: 1104, Guitar vibrato bar scoop - outMap.emplace(std::make_pair( "guitarVibratoStroke", 0xEAB2 )); // glyphnumber: 1105, Vibrato wiggle segment - outMap.emplace(std::make_pair( "guitarVolumeSwell", 0xE845 )); // glyphnumber: 1106, Volume swell - outMap.emplace(std::make_pair( "guitarWideVibratoStroke", 0xEAB3 )); // glyphnumber: 1107, Wide vibrato wiggle segment - outMap.emplace(std::make_pair( "handbellsBelltree", 0xE81F )); // glyphnumber: 1108, Belltree - outMap.emplace(std::make_pair( "handbellsDamp3", 0xE81E )); // glyphnumber: 1109, Damp 3 - outMap.emplace(std::make_pair( "handbellsEcho1", 0xE81B )); // glyphnumber: 1110, Echo - outMap.emplace(std::make_pair( "handbellsEcho2", 0xE81C )); // glyphnumber: 1111, Echo 2 - outMap.emplace(std::make_pair( "handbellsGyro", 0xE81D )); // glyphnumber: 1112, Gyro - outMap.emplace(std::make_pair( "handbellsHandMartellato", 0xE812 )); // glyphnumber: 1113, Hand martellato - outMap.emplace(std::make_pair( "handbellsMalletBellOnTable", 0xE815 )); // glyphnumber: 1114, Mallet, bell on table - outMap.emplace(std::make_pair( "handbellsMalletBellSuspended", 0xE814 )); // glyphnumber: 1115, Mallet, bell suspended - outMap.emplace(std::make_pair( "handbellsMalletLft", 0xE816 )); // glyphnumber: 1116, Mallet lift - outMap.emplace(std::make_pair( "handbellsMartellato", 0xE810 )); // glyphnumber: 1117, Martellato - outMap.emplace(std::make_pair( "handbellsMartellatoLift", 0xE811 )); // glyphnumber: 1118, Martellato lift - outMap.emplace(std::make_pair( "handbellsMutedMartellato", 0xE813 )); // glyphnumber: 1119, Muted martellato - outMap.emplace(std::make_pair( "handbellsPluckLift", 0xE817 )); // glyphnumber: 1120, Pluck lift - outMap.emplace(std::make_pair( "handbellsSwing", 0xE81A )); // glyphnumber: 1121, Swing - outMap.emplace(std::make_pair( "handbellsSwingDown", 0xE819 )); // glyphnumber: 1122, Swing down - outMap.emplace(std::make_pair( "handbellsSwingUp", 0xE818 )); // glyphnumber: 1123, Swing up - outMap.emplace(std::make_pair( "handbellsTablePairBells", 0xE821 )); // glyphnumber: 1124, Table pair of handbells - outMap.emplace(std::make_pair( "handbellsTableSingleBell", 0xE820 )); // glyphnumber: 1125, Table single handbell - outMap.emplace(std::make_pair( "harpMetalRod", 0xE68F )); // glyphnumber: 1126, Metal rod pictogram - outMap.emplace(std::make_pair( "harpPedalCentered", 0xE681 )); // glyphnumber: 1127, Harp pedal centered (natural) - outMap.emplace(std::make_pair( "harpPedalDivider", 0xE683 )); // glyphnumber: 1128, Harp pedal divider - outMap.emplace(std::make_pair( "harpPedalLowered", 0xE682 )); // glyphnumber: 1129, Harp pedal lowered (sharp) - outMap.emplace(std::make_pair( "harpPedalRaised", 0xE680 )); // glyphnumber: 1130, Harp pedal raised (flat) - outMap.emplace(std::make_pair( "harpSalzedoAeolianAscending", 0xE695 )); // glyphnumber: 1131, Ascending aeolian chords (Salzedo) - outMap.emplace(std::make_pair( "harpSalzedoAeolianDescending", 0xE696 )); // glyphnumber: 1132, Descending aeolian chords (Salzedo) - outMap.emplace(std::make_pair( "harpSalzedoDampAbove", 0xE69A )); // glyphnumber: 1133, Damp above (Salzedo) - outMap.emplace(std::make_pair( "harpSalzedoDampBelow", 0xE699 )); // glyphnumber: 1134, Damp below (Salzedo) - outMap.emplace(std::make_pair( "harpSalzedoDampBothHands", 0xE698 )); // glyphnumber: 1135, Damp with both hands (Salzedo) - outMap.emplace(std::make_pair( "harpSalzedoDampLowStrings", 0xE697 )); // glyphnumber: 1136, Damp only low strings (Salzedo) - outMap.emplace(std::make_pair( "harpSalzedoFluidicSoundsLeft", 0xE68D )); // glyphnumber: 1137, Fluidic sounds, left hand (Salzedo) - outMap.emplace(std::make_pair( "harpSalzedoFluidicSoundsRight", 0xE68E )); // glyphnumber: 1138, Fluidic sounds, right hand (Salzedo) - outMap.emplace(std::make_pair( "harpSalzedoIsolatedSounds", 0xE69C )); // glyphnumber: 1139, Isolated sounds (Salzedo) - outMap.emplace(std::make_pair( "harpSalzedoMetallicSounds", 0xE688 )); // glyphnumber: 1140, Metallic sounds (Salzedo) - outMap.emplace(std::make_pair( "harpSalzedoMetallicSoundsOneString", 0xE69B )); // glyphnumber: 1141, Metallic sounds, one string (Salzedo) - outMap.emplace(std::make_pair( "harpSalzedoMuffleTotally", 0xE68C )); // glyphnumber: 1142, Muffle totally (Salzedo) - outMap.emplace(std::make_pair( "harpSalzedoOboicFlux", 0xE685 )); // glyphnumber: 1143, Oboic flux (Salzedo) - outMap.emplace(std::make_pair( "harpSalzedoPlayUpperEnd", 0xE68A )); // glyphnumber: 1144, Play at upper end of strings (Salzedo) - outMap.emplace(std::make_pair( "harpSalzedoSlideWithSuppleness", 0xE684 )); // glyphnumber: 1145, Slide with suppleness (Salzedo) - outMap.emplace(std::make_pair( "harpSalzedoSnareDrum", 0xE69D )); // glyphnumber: 1146, Snare drum effect (Salzedo) - outMap.emplace(std::make_pair( "harpSalzedoTamTamSounds", 0xE689 )); // glyphnumber: 1147, Tam-tam sounds (Salzedo) - outMap.emplace(std::make_pair( "harpSalzedoThunderEffect", 0xE686 )); // glyphnumber: 1148, Thunder effect (Salzedo) - outMap.emplace(std::make_pair( "harpSalzedoTimpanicSounds", 0xE68B )); // glyphnumber: 1149, Timpanic sounds (Salzedo) - outMap.emplace(std::make_pair( "harpSalzedoWhistlingSounds", 0xE687 )); // glyphnumber: 1150, Whistling sounds (Salzedo) - outMap.emplace(std::make_pair( "harpStringNoiseStem", 0xE694 )); // glyphnumber: 1151, Combining string noise for stem - outMap.emplace(std::make_pair( "harpTuningKey", 0xE690 )); // glyphnumber: 1152, Tuning key pictogram - outMap.emplace(std::make_pair( "harpTuningKeyGlissando", 0xE693 )); // glyphnumber: 1153, Retune strings for glissando - outMap.emplace(std::make_pair( "harpTuningKeyHandle", 0xE691 )); // glyphnumber: 1154, Use handle of tuning key pictogram - outMap.emplace(std::make_pair( "harpTuningKeyShank", 0xE692 )); // glyphnumber: 1155, Use shank of tuning key pictogram - outMap.emplace(std::make_pair( "keyboardBebung2DotsAbove", 0xE668 )); // glyphnumber: 1156, Clavichord bebung, 2 finger movements (above) - outMap.emplace(std::make_pair( "keyboardBebung2DotsBelow", 0xE669 )); // glyphnumber: 1157, Clavichord bebung, 2 finger movements (below) - outMap.emplace(std::make_pair( "keyboardBebung3DotsAbove", 0xE66A )); // glyphnumber: 1158, Clavichord bebung, 3 finger movements (above) - outMap.emplace(std::make_pair( "keyboardBebung3DotsBelow", 0xE66B )); // glyphnumber: 1159, Clavichord bebung, 3 finger movements (below) - outMap.emplace(std::make_pair( "keyboardBebung4DotsAbove", 0xE66C )); // glyphnumber: 1160, Clavichord bebung, 4 finger movements (above) - outMap.emplace(std::make_pair( "keyboardBebung4DotsBelow", 0xE66D )); // glyphnumber: 1161, Clavichord bebung, 4 finger movements (below) - outMap.emplace(std::make_pair( "keyboardLeftPedalPictogram", 0xE65E )); // glyphnumber: 1162, Left pedal pictogram - outMap.emplace(std::make_pair( "keyboardMiddlePedalPictogram", 0xE65F )); // glyphnumber: 1163, Middle pedal pictogram - outMap.emplace(std::make_pair( "keyboardPedalD", 0xE653 )); // glyphnumber: 1164, Pedal d - outMap.emplace(std::make_pair( "keyboardPedalDot", 0xE654 )); // glyphnumber: 1165, Pedal dot - outMap.emplace(std::make_pair( "keyboardPedalE", 0xE652 )); // glyphnumber: 1166, Pedal e - outMap.emplace(std::make_pair( "keyboardPedalHalf", 0xE656 )); // glyphnumber: 1167, Half-pedal mark - outMap.emplace(std::make_pair( "keyboardPedalHalf2", 0xE65B )); // glyphnumber: 1168, Half pedal mark 1 - outMap.emplace(std::make_pair( "keyboardPedalHalf3", 0xE65C )); // glyphnumber: 1169, Half pedal mark 2 - outMap.emplace(std::make_pair( "keyboardPedalHeel1", 0xE661 )); // glyphnumber: 1170, Pedal heel 1 - outMap.emplace(std::make_pair( "keyboardPedalHeel2", 0xE662 )); // glyphnumber: 1171, Pedal heel 2 - outMap.emplace(std::make_pair( "keyboardPedalHeel3", 0xE663 )); // glyphnumber: 1172, Pedal heel 3 (Davis) - outMap.emplace(std::make_pair( "keyboardPedalHeelToToe", 0xE674 )); // glyphnumber: 1173, Pedal heel to toe - outMap.emplace(std::make_pair( "keyboardPedalHeelToe", 0xE666 )); // glyphnumber: 1174, Pedal heel or toe - outMap.emplace(std::make_pair( "keyboardPedalHookEnd", 0xE673 )); // glyphnumber: 1175, Pedal hook end - outMap.emplace(std::make_pair( "keyboardPedalHookStart", 0xE672 )); // glyphnumber: 1176, Pedal hook start - outMap.emplace(std::make_pair( "keyboardPedalHyphen", 0xE658 )); // glyphnumber: 1177, Pedal hyphen - outMap.emplace(std::make_pair( "keyboardPedalP", 0xE651 )); // glyphnumber: 1178, Pedal P - outMap.emplace(std::make_pair( "keyboardPedalPed", 0xE650 )); // glyphnumber: 1179, Pedal mark - outMap.emplace(std::make_pair( "keyboardPedalS", 0xE65A )); // glyphnumber: 1180, Pedal S - outMap.emplace(std::make_pair( "keyboardPedalSost", 0xE659 )); // glyphnumber: 1181, Sostenuto pedal mark - outMap.emplace(std::make_pair( "keyboardPedalToe1", 0xE664 )); // glyphnumber: 1182, Pedal toe 1 - outMap.emplace(std::make_pair( "keyboardPedalToe2", 0xE665 )); // glyphnumber: 1183, Pedal toe 2 - outMap.emplace(std::make_pair( "keyboardPedalToeToHeel", 0xE675 )); // glyphnumber: 1184, Pedal toe to heel - outMap.emplace(std::make_pair( "keyboardPedalUp", 0xE655 )); // glyphnumber: 1185, Pedal up mark - outMap.emplace(std::make_pair( "keyboardPedalUpNotch", 0xE657 )); // glyphnumber: 1186, Pedal up notch - outMap.emplace(std::make_pair( "keyboardPedalUpSpecial", 0xE65D )); // glyphnumber: 1187, Pedal up special - outMap.emplace(std::make_pair( "keyboardPlayWithLH", 0xE670 )); // glyphnumber: 1188, Play with left hand - outMap.emplace(std::make_pair( "keyboardPlayWithLHEnd", 0xE671 )); // glyphnumber: 1189, Play with left hand (end) - outMap.emplace(std::make_pair( "keyboardPlayWithRH", 0xE66E )); // glyphnumber: 1190, Play with right hand - outMap.emplace(std::make_pair( "keyboardPlayWithRHEnd", 0xE66F )); // glyphnumber: 1191, Play with right hand (end) - outMap.emplace(std::make_pair( "keyboardPluckInside", 0xE667 )); // glyphnumber: 1192, Pluck strings inside piano (Maderna) - outMap.emplace(std::make_pair( "keyboardRightPedalPictogram", 0xE660 )); // glyphnumber: 1193, Right pedal pictogram - outMap.emplace(std::make_pair( "kievanAccidentalFlat", 0xEC3E )); // glyphnumber: 1194, Kievan flat - outMap.emplace(std::make_pair( "kievanAccidentalSharp", 0xEC3D )); // glyphnumber: 1195, Kievan sharp - outMap.emplace(std::make_pair( "kievanAugmentationDot", 0xEC3C )); // glyphnumber: 1196, Kievan augmentation dot - outMap.emplace(std::make_pair( "kievanCClef", 0xEC30 )); // glyphnumber: 1197, Kievan C clef (tse-fa-ut) - outMap.emplace(std::make_pair( "kievanEndingSymbol", 0xEC31 )); // glyphnumber: 1198, Kievan ending symbol - outMap.emplace(std::make_pair( "kievanNote8thStemDown", 0xEC3A )); // glyphnumber: 1199, Kievan eighth note, stem down - outMap.emplace(std::make_pair( "kievanNote8thStemUp", 0xEC39 )); // glyphnumber: 1200, Kievan eighth note, stem up - outMap.emplace(std::make_pair( "kievanNoteBeam", 0xEC3B )); // glyphnumber: 1201, Kievan beam - outMap.emplace(std::make_pair( "kievanNoteHalfStaffLine", 0xEC35 )); // glyphnumber: 1202, Kievan half note (on staff line) - outMap.emplace(std::make_pair( "kievanNoteHalfStaffSpace", 0xEC36 )); // glyphnumber: 1203, Kievan half note (in staff space) - outMap.emplace(std::make_pair( "kievanNoteQuarterStemDown", 0xEC38 )); // glyphnumber: 1204, Kievan quarter note, stem down - outMap.emplace(std::make_pair( "kievanNoteQuarterStemUp", 0xEC37 )); // glyphnumber: 1205, Kievan quarter note, stem up - outMap.emplace(std::make_pair( "kievanNoteReciting", 0xEC32 )); // glyphnumber: 1206, Kievan reciting note - outMap.emplace(std::make_pair( "kievanNoteWhole", 0xEC33 )); // glyphnumber: 1207, Kievan whole note - outMap.emplace(std::make_pair( "kievanNoteWholeFinal", 0xEC34 )); // glyphnumber: 1208, Kievan final whole note - outMap.emplace(std::make_pair( "kodalyHandDo", 0xEC40 )); // glyphnumber: 1209, Do hand sign - outMap.emplace(std::make_pair( "kodalyHandFa", 0xEC43 )); // glyphnumber: 1210, Fa hand sign - outMap.emplace(std::make_pair( "kodalyHandLa", 0xEC45 )); // glyphnumber: 1211, La hand sign - outMap.emplace(std::make_pair( "kodalyHandMi", 0xEC42 )); // glyphnumber: 1212, Mi hand sign - outMap.emplace(std::make_pair( "kodalyHandRe", 0xEC41 )); // glyphnumber: 1213, Re hand sign - outMap.emplace(std::make_pair( "kodalyHandSo", 0xEC44 )); // glyphnumber: 1214, So hand sign - outMap.emplace(std::make_pair( "kodalyHandTi", 0xEC46 )); // glyphnumber: 1215, Ti hand sign - outMap.emplace(std::make_pair( "leftRepeatSmall", 0xE04C )); // glyphnumber: 1216, Left repeat sign within bar - outMap.emplace(std::make_pair( "legerLine", 0xE022 )); // glyphnumber: 1217, Leger line - outMap.emplace(std::make_pair( "legerLineNarrow", 0xE024 )); // glyphnumber: 1218, Leger line (narrow) - outMap.emplace(std::make_pair( "legerLineWide", 0xE023 )); // glyphnumber: 1219, Leger line (wide) - outMap.emplace(std::make_pair( "luteBarlineEndRepeat", 0xEBA4 )); // glyphnumber: 1220, Lute tablature end repeat barline - outMap.emplace(std::make_pair( "luteBarlineFinal", 0xEBA5 )); // glyphnumber: 1221, Lute tablature final barline - outMap.emplace(std::make_pair( "luteBarlineStartRepeat", 0xEBA3 )); // glyphnumber: 1222, Lute tablature start repeat barline - outMap.emplace(std::make_pair( "luteDuration16th", 0xEBAB )); // glyphnumber: 1223, 16th note (semiquaver) duration sign - outMap.emplace(std::make_pair( "luteDuration32nd", 0xEBAC )); // glyphnumber: 1224, 32nd note (demisemiquaver) duration sign - outMap.emplace(std::make_pair( "luteDuration8th", 0xEBAA )); // glyphnumber: 1225, Eighth note (quaver) duration sign - outMap.emplace(std::make_pair( "luteDurationDoubleWhole", 0xEBA6 )); // glyphnumber: 1226, Double whole note (breve) duration sign - outMap.emplace(std::make_pair( "luteDurationHalf", 0xEBA8 )); // glyphnumber: 1227, Half note (minim) duration sign - outMap.emplace(std::make_pair( "luteDurationQuarter", 0xEBA9 )); // glyphnumber: 1228, Quarter note (crotchet) duration sign - outMap.emplace(std::make_pair( "luteDurationWhole", 0xEBA7 )); // glyphnumber: 1229, Whole note (semibreve) duration sign - outMap.emplace(std::make_pair( "luteFingeringRHFirst", 0xEBAE )); // glyphnumber: 1230, Right-hand fingering, first finger - outMap.emplace(std::make_pair( "luteFingeringRHSecond", 0xEBAF )); // glyphnumber: 1231, Right-hand fingering, second finger - outMap.emplace(std::make_pair( "luteFingeringRHThird", 0xEBB0 )); // glyphnumber: 1232, Right-hand fingering, third finger - outMap.emplace(std::make_pair( "luteFingeringRHThumb", 0xEBAD )); // glyphnumber: 1233, Right-hand fingering, thumb - outMap.emplace(std::make_pair( "luteFrench10thCourse", 0xEBD0 )); // glyphnumber: 1234, 10th course (diapason) - outMap.emplace(std::make_pair( "luteFrench7thCourse", 0xEBCD )); // glyphnumber: 1235, Seventh course (diapason) - outMap.emplace(std::make_pair( "luteFrench8thCourse", 0xEBCE )); // glyphnumber: 1236, Eighth course (diapason) - outMap.emplace(std::make_pair( "luteFrench9thCourse", 0xEBCF )); // glyphnumber: 1237, Ninth course (diapason) - outMap.emplace(std::make_pair( "luteFrenchAppoggiaturaAbove", 0xEBD5 )); // glyphnumber: 1238, Appoggiatura from above - outMap.emplace(std::make_pair( "luteFrenchAppoggiaturaBelow", 0xEBD4 )); // glyphnumber: 1239, Appoggiatura from below - outMap.emplace(std::make_pair( "luteFrenchFretA", 0xEBC0 )); // glyphnumber: 1240, Open string (a) - outMap.emplace(std::make_pair( "luteFrenchFretB", 0xEBC1 )); // glyphnumber: 1241, First fret (b) - outMap.emplace(std::make_pair( "luteFrenchFretC", 0xEBC2 )); // glyphnumber: 1242, Second fret (c) - outMap.emplace(std::make_pair( "luteFrenchFretD", 0xEBC3 )); // glyphnumber: 1243, Third fret (d) - outMap.emplace(std::make_pair( "luteFrenchFretE", 0xEBC4 )); // glyphnumber: 1244, Fourth fret (e) - outMap.emplace(std::make_pair( "luteFrenchFretF", 0xEBC5 )); // glyphnumber: 1245, Fifth fret (f) - outMap.emplace(std::make_pair( "luteFrenchFretG", 0xEBC6 )); // glyphnumber: 1246, Sixth fret (g) - outMap.emplace(std::make_pair( "luteFrenchFretH", 0xEBC7 )); // glyphnumber: 1247, Seventh fret (h) - outMap.emplace(std::make_pair( "luteFrenchFretI", 0xEBC8 )); // glyphnumber: 1248, Eighth fret (i) - outMap.emplace(std::make_pair( "luteFrenchFretK", 0xEBC9 )); // glyphnumber: 1249, Ninth fret (k) - outMap.emplace(std::make_pair( "luteFrenchFretL", 0xEBCA )); // glyphnumber: 1250, 10th fret (l) - outMap.emplace(std::make_pair( "luteFrenchFretM", 0xEBCB )); // glyphnumber: 1251, 11th fret (m) - outMap.emplace(std::make_pair( "luteFrenchFretN", 0xEBCC )); // glyphnumber: 1252, 12th fret (n) - outMap.emplace(std::make_pair( "luteFrenchMordentInverted", 0xEBD3 )); // glyphnumber: 1253, Inverted mordent - outMap.emplace(std::make_pair( "luteFrenchMordentLower", 0xEBD2 )); // glyphnumber: 1254, Mordent with lower auxiliary - outMap.emplace(std::make_pair( "luteFrenchMordentUpper", 0xEBD1 )); // glyphnumber: 1255, Mordent with upper auxiliary - outMap.emplace(std::make_pair( "luteGermanALower", 0xEC00 )); // glyphnumber: 1256, 5th course, 1st fret (a) - outMap.emplace(std::make_pair( "luteGermanAUpper", 0xEC17 )); // glyphnumber: 1257, 6th course, 1st fret (A) - outMap.emplace(std::make_pair( "luteGermanBLower", 0xEC01 )); // glyphnumber: 1258, 4th course, 1st fret (b) - outMap.emplace(std::make_pair( "luteGermanBUpper", 0xEC18 )); // glyphnumber: 1259, 6th course, 2nd fret (B) - outMap.emplace(std::make_pair( "luteGermanCLower", 0xEC02 )); // glyphnumber: 1260, 3rd course, 1st fret (c) - outMap.emplace(std::make_pair( "luteGermanCUpper", 0xEC19 )); // glyphnumber: 1261, 6th course, 3rd fret (C) - outMap.emplace(std::make_pair( "luteGermanDLower", 0xEC03 )); // glyphnumber: 1262, 2nd course, 1st fret (d) - outMap.emplace(std::make_pair( "luteGermanDUpper", 0xEC1A )); // glyphnumber: 1263, 6th course, 4th fret (D) - outMap.emplace(std::make_pair( "luteGermanELower", 0xEC04 )); // glyphnumber: 1264, 1st course, 1st fret (e) - outMap.emplace(std::make_pair( "luteGermanEUpper", 0xEC1B )); // glyphnumber: 1265, 6th course, 5th fret (E) - outMap.emplace(std::make_pair( "luteGermanFLower", 0xEC05 )); // glyphnumber: 1266, 5th course, 2nd fret (f) - outMap.emplace(std::make_pair( "luteGermanFUpper", 0xEC1C )); // glyphnumber: 1267, 6th course, 6th fret (F) - outMap.emplace(std::make_pair( "luteGermanGLower", 0xEC06 )); // glyphnumber: 1268, 4th course, 2nd fret (g) - outMap.emplace(std::make_pair( "luteGermanGUpper", 0xEC1D )); // glyphnumber: 1269, 6th course, 7th fret (G) - outMap.emplace(std::make_pair( "luteGermanHLower", 0xEC07 )); // glyphnumber: 1270, 3rd course, 2nd fret (h) - outMap.emplace(std::make_pair( "luteGermanHUpper", 0xEC1E )); // glyphnumber: 1271, 6th course, 8th fret (H) - outMap.emplace(std::make_pair( "luteGermanILower", 0xEC08 )); // glyphnumber: 1272, 2nd course, 2nd fret (i) - outMap.emplace(std::make_pair( "luteGermanIUpper", 0xEC1F )); // glyphnumber: 1273, 6th course, 9th fret (I) - outMap.emplace(std::make_pair( "luteGermanKLower", 0xEC09 )); // glyphnumber: 1274, 1st course, 2nd fret (k) - outMap.emplace(std::make_pair( "luteGermanKUpper", 0xEC20 )); // glyphnumber: 1275, 6th course, 10th fret (K) - outMap.emplace(std::make_pair( "luteGermanLLower", 0xEC0A )); // glyphnumber: 1276, 5th course, 3rd fret (l) - outMap.emplace(std::make_pair( "luteGermanLUpper", 0xEC21 )); // glyphnumber: 1277, 6th course, 11th fret (L) - outMap.emplace(std::make_pair( "luteGermanMLower", 0xEC0B )); // glyphnumber: 1278, 4th course, 3rd fret (m) - outMap.emplace(std::make_pair( "luteGermanMUpper", 0xEC22 )); // glyphnumber: 1279, 6th course, 12th fret (M) - outMap.emplace(std::make_pair( "luteGermanNLower", 0xEC0C )); // glyphnumber: 1280, 3rd course, 3rd fret (n) - outMap.emplace(std::make_pair( "luteGermanNUpper", 0xEC23 )); // glyphnumber: 1281, 6th course, 13th fret (N) - outMap.emplace(std::make_pair( "luteGermanOLower", 0xEC0D )); // glyphnumber: 1282, 2nd course, 3rd fret (o) - outMap.emplace(std::make_pair( "luteGermanPLower", 0xEC0E )); // glyphnumber: 1283, 1st course, 3rd fret (p) - outMap.emplace(std::make_pair( "luteGermanQLower", 0xEC0F )); // glyphnumber: 1284, 5th course, 4th fret (q) - outMap.emplace(std::make_pair( "luteGermanRLower", 0xEC10 )); // glyphnumber: 1285, 4th course, 4th fret (r) - outMap.emplace(std::make_pair( "luteGermanSLower", 0xEC11 )); // glyphnumber: 1286, 3rd course, 4th fret (s) - outMap.emplace(std::make_pair( "luteGermanTLower", 0xEC12 )); // glyphnumber: 1287, 2nd course, 4th fret (t) - outMap.emplace(std::make_pair( "luteGermanVLower", 0xEC13 )); // glyphnumber: 1288, 1st course, 4th fret (v) - outMap.emplace(std::make_pair( "luteGermanXLower", 0xEC14 )); // glyphnumber: 1289, 5th course, 5th fret (x) - outMap.emplace(std::make_pair( "luteGermanYLower", 0xEC15 )); // glyphnumber: 1290, 4th course, 5th fret (y) - outMap.emplace(std::make_pair( "luteGermanZLower", 0xEC16 )); // glyphnumber: 1291, 3rd course, 5th fret (z) - outMap.emplace(std::make_pair( "luteItalianClefCSolFaUt", 0xEBF1 )); // glyphnumber: 1292, C sol fa ut clef - outMap.emplace(std::make_pair( "luteItalianClefFFaUt", 0xEBF0 )); // glyphnumber: 1293, F fa ut clef - outMap.emplace(std::make_pair( "luteItalianFret0", 0xEBE0 )); // glyphnumber: 1294, Open string (0) - outMap.emplace(std::make_pair( "luteItalianFret1", 0xEBE1 )); // glyphnumber: 1295, First fret (1) - outMap.emplace(std::make_pair( "luteItalianFret2", 0xEBE2 )); // glyphnumber: 1296, Second fret (2) - outMap.emplace(std::make_pair( "luteItalianFret3", 0xEBE3 )); // glyphnumber: 1297, Third fret (3) - outMap.emplace(std::make_pair( "luteItalianFret4", 0xEBE4 )); // glyphnumber: 1298, Fourth fret (4) - outMap.emplace(std::make_pair( "luteItalianFret5", 0xEBE5 )); // glyphnumber: 1299, Fifth fret (5) - outMap.emplace(std::make_pair( "luteItalianFret6", 0xEBE6 )); // glyphnumber: 1300, Sixth fret (6) - outMap.emplace(std::make_pair( "luteItalianFret7", 0xEBE7 )); // glyphnumber: 1301, Seventh fret (7) - outMap.emplace(std::make_pair( "luteItalianFret8", 0xEBE8 )); // glyphnumber: 1302, Eighth fret (8) - outMap.emplace(std::make_pair( "luteItalianFret9", 0xEBE9 )); // glyphnumber: 1303, Ninth fret (9) - outMap.emplace(std::make_pair( "luteItalianHoldFinger", 0xEBF4 )); // glyphnumber: 1304, Hold finger in place - outMap.emplace(std::make_pair( "luteItalianHoldNote", 0xEBF3 )); // glyphnumber: 1305, Hold note - outMap.emplace(std::make_pair( "luteItalianReleaseFinger", 0xEBF5 )); // glyphnumber: 1306, Release finger - outMap.emplace(std::make_pair( "luteItalianTempoFast", 0xEBEA )); // glyphnumber: 1307, Fast tempo indication (de Mudarra) - outMap.emplace(std::make_pair( "luteItalianTempoNeitherFastNorSlow", 0xEBEC )); // glyphnumber: 1308, Neither fast nor slow tempo indication (de Mudarra) - outMap.emplace(std::make_pair( "luteItalianTempoSlow", 0xEBED )); // glyphnumber: 1309, Slow tempo indication (de Mudarra) - outMap.emplace(std::make_pair( "luteItalianTempoSomewhatFast", 0xEBEB )); // glyphnumber: 1310, Somewhat fast tempo indication (de Narvaez) - outMap.emplace(std::make_pair( "luteItalianTempoVerySlow", 0xEBEE )); // glyphnumber: 1311, Very slow indication (de Narvaez) - outMap.emplace(std::make_pair( "luteItalianTimeTriple", 0xEBEF )); // glyphnumber: 1312, Triple time indication - outMap.emplace(std::make_pair( "luteItalianTremolo", 0xEBF2 )); // glyphnumber: 1313, Single-finger tremolo or mordent - outMap.emplace(std::make_pair( "luteItalianVibrato", 0xEBF6 )); // glyphnumber: 1314, Vibrato (verre cassé) - outMap.emplace(std::make_pair( "luteStaff6Lines", 0xEBA0 )); // glyphnumber: 1315, Lute tablature staff, 6 courses - outMap.emplace(std::make_pair( "luteStaff6LinesNarrow", 0xEBA2 )); // glyphnumber: 1316, Lute tablature staff, 6 courses (narrow) - outMap.emplace(std::make_pair( "luteStaff6LinesWide", 0xEBA1 )); // glyphnumber: 1317, Lute tablature staff, 6 courses (wide) - outMap.emplace(std::make_pair( "lyricsElision", 0xE551 )); // glyphnumber: 1318, Elision - outMap.emplace(std::make_pair( "lyricsElisionNarrow", 0xE550 )); // glyphnumber: 1319, Narrow elision - outMap.emplace(std::make_pair( "lyricsElisionWide", 0xE552 )); // glyphnumber: 1320, Wide elision - outMap.emplace(std::make_pair( "lyricsHyphenBaseline", 0xE553 )); // glyphnumber: 1321, Baseline hyphen - outMap.emplace(std::make_pair( "lyricsHyphenBaselineNonBreaking", 0xE554 )); // glyphnumber: 1322, Non-breaking baseline hyphen - outMap.emplace(std::make_pair( "medRenFlatHardB", 0xE9E1 )); // glyphnumber: 1323, Flat, hard b (mi) - outMap.emplace(std::make_pair( "medRenFlatSoftB", 0xE9E0 )); // glyphnumber: 1324, Flat, soft b (fa) - outMap.emplace(std::make_pair( "medRenFlatWithDot", 0xE9E4 )); // glyphnumber: 1325, Flat with dot - outMap.emplace(std::make_pair( "medRenGClefCMN", 0xEA24 )); // glyphnumber: 1326, G clef (Corpus Monodicum) - outMap.emplace(std::make_pair( "medRenLiquescenceCMN", 0xEA22 )); // glyphnumber: 1327, Liquescence - outMap.emplace(std::make_pair( "medRenLiquescentAscCMN", 0xEA26 )); // glyphnumber: 1328, Liquescent ascending (Corpus Monodicum) - outMap.emplace(std::make_pair( "medRenLiquescentDescCMN", 0xEA27 )); // glyphnumber: 1329, Liquescent descending (Corpus Monodicum) - outMap.emplace(std::make_pair( "medRenNatural", 0xE9E2 )); // glyphnumber: 1330, Natural - outMap.emplace(std::make_pair( "medRenNaturalWithCross", 0xE9E5 )); // glyphnumber: 1331, Natural with interrupted cross - outMap.emplace(std::make_pair( "medRenOriscusCMN", 0xEA2A )); // glyphnumber: 1332, Oriscus (Corpus Monodicum) - outMap.emplace(std::make_pair( "medRenPlicaCMN", 0xEA23 )); // glyphnumber: 1333, Plica - outMap.emplace(std::make_pair( "medRenPunctumCMN", 0xEA25 )); // glyphnumber: 1334, Punctum (Corpus Monodicum) - outMap.emplace(std::make_pair( "medRenQuilismaCMN", 0xEA28 )); // glyphnumber: 1335, Quilisma (Corpus Monodicum) - outMap.emplace(std::make_pair( "medRenSharpCroix", 0xE9E3 )); // glyphnumber: 1336, Croix - outMap.emplace(std::make_pair( "medRenStrophicusCMN", 0xEA29 )); // glyphnumber: 1337, Strophicus (Corpus Monodicum) - outMap.emplace(std::make_pair( "mensuralAlterationSign", 0xEA10 )); // glyphnumber: 1338, Alteration sign - outMap.emplace(std::make_pair( "mensuralBlackBrevis", 0xE952 )); // glyphnumber: 1339, Black mensural brevis - outMap.emplace(std::make_pair( "mensuralBlackBrevisVoid", 0xE956 )); // glyphnumber: 1340, Black mensural void brevis - outMap.emplace(std::make_pair( "mensuralBlackDragma", 0xE95A )); // glyphnumber: 1341, Black mensural dragma - outMap.emplace(std::make_pair( "mensuralBlackLonga", 0xE951 )); // glyphnumber: 1342, Black mensural longa - outMap.emplace(std::make_pair( "mensuralBlackMaxima", 0xE950 )); // glyphnumber: 1343, Black mensural maxima - outMap.emplace(std::make_pair( "mensuralBlackMinima", 0xE954 )); // glyphnumber: 1344, Black mensural minima - outMap.emplace(std::make_pair( "mensuralBlackMinimaVoid", 0xE958 )); // glyphnumber: 1345, Black mensural void minima - outMap.emplace(std::make_pair( "mensuralBlackSemibrevis", 0xE953 )); // glyphnumber: 1346, Black mensural semibrevis - outMap.emplace(std::make_pair( "mensuralBlackSemibrevisCaudata", 0xE959 )); // glyphnumber: 1347, Black mensural semibrevis caudata - outMap.emplace(std::make_pair( "mensuralBlackSemibrevisOblique", 0xE95B )); // glyphnumber: 1348, Black mensural oblique semibrevis - outMap.emplace(std::make_pair( "mensuralBlackSemibrevisVoid", 0xE957 )); // glyphnumber: 1349, Black mensural void semibrevis - outMap.emplace(std::make_pair( "mensuralBlackSemiminima", 0xE955 )); // glyphnumber: 1350, Black mensural semiminima - outMap.emplace(std::make_pair( "mensuralCclef", 0xE905 )); // glyphnumber: 1351, Mensural C clef - outMap.emplace(std::make_pair( "mensuralCclefPetrucciPosHigh", 0xE90A )); // glyphnumber: 1352, Petrucci C clef, high position - outMap.emplace(std::make_pair( "mensuralCclefPetrucciPosHighest", 0xE90B )); // glyphnumber: 1353, Petrucci C clef, highest position - outMap.emplace(std::make_pair( "mensuralCclefPetrucciPosLow", 0xE908 )); // glyphnumber: 1354, Petrucci C clef, low position - outMap.emplace(std::make_pair( "mensuralCclefPetrucciPosLowest", 0xE907 )); // glyphnumber: 1355, Petrucci C clef, lowest position - outMap.emplace(std::make_pair( "mensuralCclefPetrucciPosMiddle", 0xE909 )); // glyphnumber: 1356, Petrucci C clef, middle position - outMap.emplace(std::make_pair( "mensuralColorationEndRound", 0xEA0F )); // glyphnumber: 1357, Coloration end, round - outMap.emplace(std::make_pair( "mensuralColorationEndSquare", 0xEA0D )); // glyphnumber: 1358, Coloration end, square - outMap.emplace(std::make_pair( "mensuralColorationStartRound", 0xEA0E )); // glyphnumber: 1359, Coloration start, round - outMap.emplace(std::make_pair( "mensuralColorationStartSquare", 0xEA0C )); // glyphnumber: 1360, Coloration start, square - outMap.emplace(std::make_pair( "mensuralCombStemDiagonal", 0xE940 )); // glyphnumber: 1361, Combining stem diagonal - outMap.emplace(std::make_pair( "mensuralCombStemDown", 0xE93F )); // glyphnumber: 1362, Combining stem down - outMap.emplace(std::make_pair( "mensuralCombStemDownFlagExtended", 0xE948 )); // glyphnumber: 1363, Combining stem with extended flag down - outMap.emplace(std::make_pair( "mensuralCombStemDownFlagFlared", 0xE946 )); // glyphnumber: 1364, Combining stem with flared flag down - outMap.emplace(std::make_pair( "mensuralCombStemDownFlagFusa", 0xE94C )); // glyphnumber: 1365, Combining stem with fusa flag down - outMap.emplace(std::make_pair( "mensuralCombStemDownFlagLeft", 0xE944 )); // glyphnumber: 1366, Combining stem with flag left down - outMap.emplace(std::make_pair( "mensuralCombStemDownFlagRight", 0xE942 )); // glyphnumber: 1367, Combining stem with flag right down - outMap.emplace(std::make_pair( "mensuralCombStemDownFlagSemiminima", 0xE94A )); // glyphnumber: 1368, Combining stem with semiminima flag down - outMap.emplace(std::make_pair( "mensuralCombStemUp", 0xE93E )); // glyphnumber: 1369, Combining stem up - outMap.emplace(std::make_pair( "mensuralCombStemUpFlagExtended", 0xE947 )); // glyphnumber: 1370, Combining stem with extended flag up - outMap.emplace(std::make_pair( "mensuralCombStemUpFlagFlared", 0xE945 )); // glyphnumber: 1371, Combining stem with flared flag up - outMap.emplace(std::make_pair( "mensuralCombStemUpFlagFusa", 0xE94B )); // glyphnumber: 1372, Combining stem with fusa flag up - outMap.emplace(std::make_pair( "mensuralCombStemUpFlagLeft", 0xE943 )); // glyphnumber: 1373, Combining stem with flag left up - outMap.emplace(std::make_pair( "mensuralCombStemUpFlagRight", 0xE941 )); // glyphnumber: 1374, Combining stem with flag right up - outMap.emplace(std::make_pair( "mensuralCombStemUpFlagSemiminima", 0xE949 )); // glyphnumber: 1375, Combining stem with semiminima flag up - outMap.emplace(std::make_pair( "mensuralCustosCheckmark", 0xEA0A )); // glyphnumber: 1376, Checkmark custos - outMap.emplace(std::make_pair( "mensuralCustosDown", 0xEA03 )); // glyphnumber: 1377, Mensural custos down - outMap.emplace(std::make_pair( "mensuralCustosTurn", 0xEA0B )); // glyphnumber: 1378, Turn-like custos - outMap.emplace(std::make_pair( "mensuralCustosUp", 0xEA02 )); // glyphnumber: 1379, Mensural custos up - outMap.emplace(std::make_pair( "mensuralFclef", 0xE903 )); // glyphnumber: 1380, Mensural F clef - outMap.emplace(std::make_pair( "mensuralFclefPetrucci", 0xE904 )); // glyphnumber: 1381, Petrucci F clef - outMap.emplace(std::make_pair( "mensuralGclef", 0xE900 )); // glyphnumber: 1382, Mensural G clef - outMap.emplace(std::make_pair( "mensuralGclefPetrucci", 0xE901 )); // glyphnumber: 1383, Petrucci G clef - outMap.emplace(std::make_pair( "mensuralModusImperfectumVert", 0xE92D )); // glyphnumber: 1384, Modus imperfectum, vertical - outMap.emplace(std::make_pair( "mensuralModusPerfectumVert", 0xE92C )); // glyphnumber: 1385, Modus perfectum, vertical - outMap.emplace(std::make_pair( "mensuralNoteheadLongaBlack", 0xE934 )); // glyphnumber: 1386, Longa/brevis notehead, black - outMap.emplace(std::make_pair( "mensuralNoteheadLongaBlackVoid", 0xE936 )); // glyphnumber: 1387, Longa/brevis notehead, black and void - outMap.emplace(std::make_pair( "mensuralNoteheadLongaVoid", 0xE935 )); // glyphnumber: 1388, Longa/brevis notehead, void - outMap.emplace(std::make_pair( "mensuralNoteheadLongaWhite", 0xE937 )); // glyphnumber: 1389, Longa/brevis notehead, white - outMap.emplace(std::make_pair( "mensuralNoteheadMaximaBlack", 0xE930 )); // glyphnumber: 1390, Maxima notehead, black - outMap.emplace(std::make_pair( "mensuralNoteheadMaximaBlackVoid", 0xE932 )); // glyphnumber: 1391, Maxima notehead, black and void - outMap.emplace(std::make_pair( "mensuralNoteheadMaximaVoid", 0xE931 )); // glyphnumber: 1392, Maxima notehead, void - outMap.emplace(std::make_pair( "mensuralNoteheadMaximaWhite", 0xE933 )); // glyphnumber: 1393, Maxima notehead, white - outMap.emplace(std::make_pair( "mensuralNoteheadMinimaWhite", 0xE93C )); // glyphnumber: 1394, Minima notehead, white - outMap.emplace(std::make_pair( "mensuralNoteheadSemibrevisBlack", 0xE938 )); // glyphnumber: 1395, Semibrevis notehead, black - outMap.emplace(std::make_pair( "mensuralNoteheadSemibrevisBlackVoid", 0xE93A )); // glyphnumber: 1396, Semibrevis notehead, black and void - outMap.emplace(std::make_pair( "mensuralNoteheadSemibrevisBlackVoidTurned", 0xE93B )); // glyphnumber: 1397, Semibrevis notehead, black and void (turned) - outMap.emplace(std::make_pair( "mensuralNoteheadSemibrevisVoid", 0xE939 )); // glyphnumber: 1398, Semibrevis notehead, void - outMap.emplace(std::make_pair( "mensuralNoteheadSemiminimaWhite", 0xE93D )); // glyphnumber: 1399, Semiminima/fusa notehead, white - outMap.emplace(std::make_pair( "mensuralObliqueAsc2ndBlack", 0xE970 )); // glyphnumber: 1400, Oblique form, ascending 2nd, black - outMap.emplace(std::make_pair( "mensuralObliqueAsc2ndBlackVoid", 0xE972 )); // glyphnumber: 1401, Oblique form, ascending 2nd, black and void - outMap.emplace(std::make_pair( "mensuralObliqueAsc2ndVoid", 0xE971 )); // glyphnumber: 1402, Oblique form, ascending 2nd, void - outMap.emplace(std::make_pair( "mensuralObliqueAsc2ndWhite", 0xE973 )); // glyphnumber: 1403, Oblique form, ascending 2nd, white - outMap.emplace(std::make_pair( "mensuralObliqueAsc3rdBlack", 0xE974 )); // glyphnumber: 1404, Oblique form, ascending 3rd, black - outMap.emplace(std::make_pair( "mensuralObliqueAsc3rdBlackVoid", 0xE976 )); // glyphnumber: 1405, Oblique form, ascending 3rd, black and void - outMap.emplace(std::make_pair( "mensuralObliqueAsc3rdVoid", 0xE975 )); // glyphnumber: 1406, Oblique form, ascending 3rd, void - outMap.emplace(std::make_pair( "mensuralObliqueAsc3rdWhite", 0xE977 )); // glyphnumber: 1407, Oblique form, ascending 3rd, white - outMap.emplace(std::make_pair( "mensuralObliqueAsc4thBlack", 0xE978 )); // glyphnumber: 1408, Oblique form, ascending 4th, black - outMap.emplace(std::make_pair( "mensuralObliqueAsc4thBlackVoid", 0xE97A )); // glyphnumber: 1409, Oblique form, ascending 4th, black and void - outMap.emplace(std::make_pair( "mensuralObliqueAsc4thVoid", 0xE979 )); // glyphnumber: 1410, Oblique form, ascending 4th, void - outMap.emplace(std::make_pair( "mensuralObliqueAsc4thWhite", 0xE97B )); // glyphnumber: 1411, Oblique form, ascending 4th, white - outMap.emplace(std::make_pair( "mensuralObliqueAsc5thBlack", 0xE97C )); // glyphnumber: 1412, Oblique form, ascending 5th, black - outMap.emplace(std::make_pair( "mensuralObliqueAsc5thBlackVoid", 0xE97E )); // glyphnumber: 1413, Oblique form, ascending 5th, black and void - outMap.emplace(std::make_pair( "mensuralObliqueAsc5thVoid", 0xE97D )); // glyphnumber: 1414, Oblique form, ascending 5th, void - outMap.emplace(std::make_pair( "mensuralObliqueAsc5thWhite", 0xE97F )); // glyphnumber: 1415, Oblique form, ascending 5th, white - outMap.emplace(std::make_pair( "mensuralObliqueDesc2ndBlack", 0xE980 )); // glyphnumber: 1416, Oblique form, descending 2nd, black - outMap.emplace(std::make_pair( "mensuralObliqueDesc2ndBlackVoid", 0xE982 )); // glyphnumber: 1417, Oblique form, descending 2nd, black and void - outMap.emplace(std::make_pair( "mensuralObliqueDesc2ndVoid", 0xE981 )); // glyphnumber: 1418, Oblique form, descending 2nd, void - outMap.emplace(std::make_pair( "mensuralObliqueDesc2ndWhite", 0xE983 )); // glyphnumber: 1419, Oblique form, descending 2nd, white - outMap.emplace(std::make_pair( "mensuralObliqueDesc3rdBlack", 0xE984 )); // glyphnumber: 1420, Oblique form, descending 3rd, black - outMap.emplace(std::make_pair( "mensuralObliqueDesc3rdBlackVoid", 0xE986 )); // glyphnumber: 1421, Oblique form, descending 3rd, black and void - outMap.emplace(std::make_pair( "mensuralObliqueDesc3rdVoid", 0xE985 )); // glyphnumber: 1422, Oblique form, descending 3rd, void - outMap.emplace(std::make_pair( "mensuralObliqueDesc3rdWhite", 0xE987 )); // glyphnumber: 1423, Oblique form, descending 3rd, white - outMap.emplace(std::make_pair( "mensuralObliqueDesc4thBlack", 0xE988 )); // glyphnumber: 1424, Oblique form, descending 4th, black - outMap.emplace(std::make_pair( "mensuralObliqueDesc4thBlackVoid", 0xE98A )); // glyphnumber: 1425, Oblique form, descending 4th, black and void - outMap.emplace(std::make_pair( "mensuralObliqueDesc4thVoid", 0xE989 )); // glyphnumber: 1426, Oblique form, descending 4th, void - outMap.emplace(std::make_pair( "mensuralObliqueDesc4thWhite", 0xE98B )); // glyphnumber: 1427, Oblique form, descending 4th, white - outMap.emplace(std::make_pair( "mensuralObliqueDesc5thBlack", 0xE98C )); // glyphnumber: 1428, Oblique form, descending 5th, black - outMap.emplace(std::make_pair( "mensuralObliqueDesc5thBlackVoid", 0xE98E )); // glyphnumber: 1429, Oblique form, descending 5th, black and void - outMap.emplace(std::make_pair( "mensuralObliqueDesc5thVoid", 0xE98D )); // glyphnumber: 1430, Oblique form, descending 5th, void - outMap.emplace(std::make_pair( "mensuralObliqueDesc5thWhite", 0xE98F )); // glyphnumber: 1431, Oblique form, descending 5th, white - outMap.emplace(std::make_pair( "mensuralProlation1", 0xE910 )); // glyphnumber: 1432, Tempus perfectum cum prolatione perfecta (9/8) - outMap.emplace(std::make_pair( "mensuralProlation10", 0xE919 )); // glyphnumber: 1433, Tempus imperfectum cum prolatione imperfecta diminution 4 - outMap.emplace(std::make_pair( "mensuralProlation11", 0xE91A )); // glyphnumber: 1434, Tempus imperfectum cum prolatione imperfecta diminution 5 - outMap.emplace(std::make_pair( "mensuralProlation2", 0xE911 )); // glyphnumber: 1435, Tempus perfectum cum prolatione imperfecta (3/4) - outMap.emplace(std::make_pair( "mensuralProlation3", 0xE912 )); // glyphnumber: 1436, Tempus perfectum cum prolatione imperfecta diminution 1 (3/8) - outMap.emplace(std::make_pair( "mensuralProlation4", 0xE913 )); // glyphnumber: 1437, Tempus perfectum cum prolatione perfecta diminution 2 (9/16) - outMap.emplace(std::make_pair( "mensuralProlation5", 0xE914 )); // glyphnumber: 1438, Tempus imperfectum cum prolatione perfecta (6/8) - outMap.emplace(std::make_pair( "mensuralProlation6", 0xE915 )); // glyphnumber: 1439, Tempus imperfectum cum prolatione imperfecta (2/4) - outMap.emplace(std::make_pair( "mensuralProlation7", 0xE916 )); // glyphnumber: 1440, Tempus imperfectum cum prolatione imperfecta diminution 1 (2/2) - outMap.emplace(std::make_pair( "mensuralProlation8", 0xE917 )); // glyphnumber: 1441, Tempus imperfectum cum prolatione imperfecta diminution 2 (6/16) - outMap.emplace(std::make_pair( "mensuralProlation9", 0xE918 )); // glyphnumber: 1442, Tempus imperfectum cum prolatione imperfecta diminution 3 (2/2) - outMap.emplace(std::make_pair( "mensuralProlationCombiningDot", 0xE920 )); // glyphnumber: 1443, Combining dot - outMap.emplace(std::make_pair( "mensuralProlationCombiningDotVoid", 0xE924 )); // glyphnumber: 1444, Combining void dot - outMap.emplace(std::make_pair( "mensuralProlationCombiningStroke", 0xE925 )); // glyphnumber: 1445, Combining vertical stroke - outMap.emplace(std::make_pair( "mensuralProlationCombiningThreeDots", 0xE922 )); // glyphnumber: 1446, Combining three dots horizontal - outMap.emplace(std::make_pair( "mensuralProlationCombiningThreeDotsTri", 0xE923 )); // glyphnumber: 1447, Combining three dots triangular - outMap.emplace(std::make_pair( "mensuralProlationCombiningTwoDots", 0xE921 )); // glyphnumber: 1448, Combining two dots - outMap.emplace(std::make_pair( "mensuralProportion1", 0xE926 )); // glyphnumber: 1449, Mensural proportion 1 - outMap.emplace(std::make_pair( "mensuralProportion2", 0xE927 )); // glyphnumber: 1450, Mensural proportion 2 - outMap.emplace(std::make_pair( "mensuralProportion3", 0xE928 )); // glyphnumber: 1451, Mensural proportion 3 - outMap.emplace(std::make_pair( "mensuralProportion4", 0xE929 )); // glyphnumber: 1452, Mensural proportion 4 - outMap.emplace(std::make_pair( "mensuralProportionMajor", 0xE92B )); // glyphnumber: 1453, Mensural proportion major - outMap.emplace(std::make_pair( "mensuralProportionMinor", 0xE92A )); // glyphnumber: 1454, Mensural proportion minor - outMap.emplace(std::make_pair( "mensuralProportionProportioDupla1", 0xE91C )); // glyphnumber: 1455, Proportio dupla 1 - outMap.emplace(std::make_pair( "mensuralProportionProportioDupla2", 0xE91D )); // glyphnumber: 1456, Proportio dupla 2 - outMap.emplace(std::make_pair( "mensuralProportionProportioQuadrupla", 0xE91F )); // glyphnumber: 1457, Proportio quadrupla - outMap.emplace(std::make_pair( "mensuralProportionProportioTripla", 0xE91E )); // glyphnumber: 1458, Proportio tripla - outMap.emplace(std::make_pair( "mensuralProportionTempusPerfectum", 0xE91B )); // glyphnumber: 1459, Tempus perfectum - outMap.emplace(std::make_pair( "mensuralRestBrevis", 0xE9F3 )); // glyphnumber: 1460, Brevis rest - outMap.emplace(std::make_pair( "mensuralRestFusa", 0xE9F7 )); // glyphnumber: 1461, Fusa rest - outMap.emplace(std::make_pair( "mensuralRestLongaImperfecta", 0xE9F2 )); // glyphnumber: 1462, Longa imperfecta rest - outMap.emplace(std::make_pair( "mensuralRestLongaPerfecta", 0xE9F1 )); // glyphnumber: 1463, Longa perfecta rest - outMap.emplace(std::make_pair( "mensuralRestMaxima", 0xE9F0 )); // glyphnumber: 1464, Maxima rest - outMap.emplace(std::make_pair( "mensuralRestMinima", 0xE9F5 )); // glyphnumber: 1465, Minima rest - outMap.emplace(std::make_pair( "mensuralRestSemibrevis", 0xE9F4 )); // glyphnumber: 1466, Semibrevis rest - outMap.emplace(std::make_pair( "mensuralRestSemifusa", 0xE9F8 )); // glyphnumber: 1467, Semifusa rest - outMap.emplace(std::make_pair( "mensuralRestSemiminima", 0xE9F6 )); // glyphnumber: 1468, Semiminima rest - outMap.emplace(std::make_pair( "mensuralSignumDown", 0xEA01 )); // glyphnumber: 1469, Signum congruentiae down - outMap.emplace(std::make_pair( "mensuralSignumUp", 0xEA00 )); // glyphnumber: 1470, Signum congruentiae up - outMap.emplace(std::make_pair( "mensuralTempusImperfectumHoriz", 0xE92F )); // glyphnumber: 1471, Tempus imperfectum, horizontal - outMap.emplace(std::make_pair( "mensuralTempusPerfectumHoriz", 0xE92E )); // glyphnumber: 1472, Tempus perfectum, horizontal - outMap.emplace(std::make_pair( "mensuralWhiteBrevis", 0xE95E )); // glyphnumber: 1473, White mensural brevis - outMap.emplace(std::make_pair( "mensuralWhiteFusa", 0xE961 )); // glyphnumber: 1474, White mensural fusa - outMap.emplace(std::make_pair( "mensuralWhiteLonga", 0xE95D )); // glyphnumber: 1475, White mensural longa - outMap.emplace(std::make_pair( "mensuralWhiteMaxima", 0xE95C )); // glyphnumber: 1476, White mensural maxima - outMap.emplace(std::make_pair( "mensuralWhiteMinima", 0xE95F )); // glyphnumber: 1477, White mensural minima - outMap.emplace(std::make_pair( "mensuralWhiteSemiminima", 0xE960 )); // glyphnumber: 1478, White mensural semiminima - outMap.emplace(std::make_pair( "metAugmentationDot", 0xECB7 )); // glyphnumber: 1479, Augmentation dot - outMap.emplace(std::make_pair( "metNote1024thDown", 0xECB6 )); // glyphnumber: 1480, 1024th note (semihemidemisemihemidemisemiquaver) stem down - outMap.emplace(std::make_pair( "metNote1024thUp", 0xECB5 )); // glyphnumber: 1481, 1024th note (semihemidemisemihemidemisemiquaver) stem up - outMap.emplace(std::make_pair( "metNote128thDown", 0xECB0 )); // glyphnumber: 1482, 128th note (semihemidemisemiquaver) stem down - outMap.emplace(std::make_pair( "metNote128thUp", 0xECAF )); // glyphnumber: 1483, 128th note (semihemidemisemiquaver) stem up - outMap.emplace(std::make_pair( "metNote16thDown", 0xECAA )); // glyphnumber: 1484, 16th note (semiquaver) stem down - outMap.emplace(std::make_pair( "metNote16thUp", 0xECA9 )); // glyphnumber: 1485, 16th note (semiquaver) stem up - outMap.emplace(std::make_pair( "metNote256thDown", 0xECB2 )); // glyphnumber: 1486, 256th note (demisemihemidemisemiquaver) stem down - outMap.emplace(std::make_pair( "metNote256thUp", 0xECB1 )); // glyphnumber: 1487, 256th note (demisemihemidemisemiquaver) stem up - outMap.emplace(std::make_pair( "metNote32ndDown", 0xECAC )); // glyphnumber: 1488, 32nd note (demisemiquaver) stem down - outMap.emplace(std::make_pair( "metNote32ndUp", 0xECAB )); // glyphnumber: 1489, 32nd note (demisemiquaver) stem up - outMap.emplace(std::make_pair( "metNote512thDown", 0xECB4 )); // glyphnumber: 1490, 512th note (hemidemisemihemidemisemiquaver) stem down - outMap.emplace(std::make_pair( "metNote512thUp", 0xECB3 )); // glyphnumber: 1491, 512th note (hemidemisemihemidemisemiquaver) stem up - outMap.emplace(std::make_pair( "metNote64thDown", 0xECAE )); // glyphnumber: 1492, 64th note (hemidemisemiquaver) stem down - outMap.emplace(std::make_pair( "metNote64thUp", 0xECAD )); // glyphnumber: 1493, 64th note (hemidemisemiquaver) stem up - outMap.emplace(std::make_pair( "metNote8thDown", 0xECA8 )); // glyphnumber: 1494, Eighth note (quaver) stem down - outMap.emplace(std::make_pair( "metNote8thUp", 0xECA7 )); // glyphnumber: 1495, Eighth note (quaver) stem up - outMap.emplace(std::make_pair( "metNoteDoubleWhole", 0xECA0 )); // glyphnumber: 1496, Double whole note (breve) - outMap.emplace(std::make_pair( "metNoteDoubleWholeSquare", 0xECA1 )); // glyphnumber: 1497, Double whole note (square) - outMap.emplace(std::make_pair( "metNoteHalfDown", 0xECA4 )); // glyphnumber: 1498, Half note (minim) stem down - outMap.emplace(std::make_pair( "metNoteHalfUp", 0xECA3 )); // glyphnumber: 1499, Half note (minim) stem up - outMap.emplace(std::make_pair( "metNoteQuarterDown", 0xECA6 )); // glyphnumber: 1500, Quarter note (crotchet) stem down - outMap.emplace(std::make_pair( "metNoteQuarterUp", 0xECA5 )); // glyphnumber: 1501, Quarter note (crotchet) stem up - outMap.emplace(std::make_pair( "metNoteWhole", 0xECA2 )); // glyphnumber: 1502, Whole note (semibreve) - outMap.emplace(std::make_pair( "metricModulationArrowLeft", 0xEC63 )); // glyphnumber: 1503, Left-pointing arrow for metric modulation - outMap.emplace(std::make_pair( "metricModulationArrowRight", 0xEC64 )); // glyphnumber: 1504, Right-pointing arrow for metric modulation - outMap.emplace(std::make_pair( "miscDoNotCopy", 0xEC61 )); // glyphnumber: 1505, Do not copy - outMap.emplace(std::make_pair( "miscDoNotPhotocopy", 0xEC60 )); // glyphnumber: 1506, Do not photocopy - outMap.emplace(std::make_pair( "miscEyeglasses", 0xEC62 )); // glyphnumber: 1507, Eyeglasses - outMap.emplace(std::make_pair( "note1024thDown", 0xE1E6 )); // glyphnumber: 1508, 1024th note (semihemidemisemihemidemisemiquaver) stem down - outMap.emplace(std::make_pair( "note1024thUp", 0xE1E5 )); // glyphnumber: 1509, 1024th note (semihemidemisemihemidemisemiquaver) stem up - outMap.emplace(std::make_pair( "note128thDown", 0xE1E0 )); // glyphnumber: 1510, 128th note (semihemidemisemiquaver) stem down - outMap.emplace(std::make_pair( "note128thUp", 0xE1DF )); // glyphnumber: 1511, 128th note (semihemidemisemiquaver) stem up - outMap.emplace(std::make_pair( "note16thDown", 0xE1DA )); // glyphnumber: 1512, 16th note (semiquaver) stem down - outMap.emplace(std::make_pair( "note16thUp", 0xE1D9 )); // glyphnumber: 1513, 16th note (semiquaver) stem up - outMap.emplace(std::make_pair( "note256thDown", 0xE1E2 )); // glyphnumber: 1514, 256th note (demisemihemidemisemiquaver) stem down - outMap.emplace(std::make_pair( "note256thUp", 0xE1E1 )); // glyphnumber: 1515, 256th note (demisemihemidemisemiquaver) stem up - outMap.emplace(std::make_pair( "note32ndDown", 0xE1DC )); // glyphnumber: 1516, 32nd note (demisemiquaver) stem down - outMap.emplace(std::make_pair( "note32ndUp", 0xE1DB )); // glyphnumber: 1517, 32nd note (demisemiquaver) stem up - outMap.emplace(std::make_pair( "note512thDown", 0xE1E4 )); // glyphnumber: 1518, 512th note (hemidemisemihemidemisemiquaver) stem down - outMap.emplace(std::make_pair( "note512thUp", 0xE1E3 )); // glyphnumber: 1519, 512th note (hemidemisemihemidemisemiquaver) stem up - outMap.emplace(std::make_pair( "note64thDown", 0xE1DE )); // glyphnumber: 1520, 64th note (hemidemisemiquaver) stem down - outMap.emplace(std::make_pair( "note64thUp", 0xE1DD )); // glyphnumber: 1521, 64th note (hemidemisemiquaver) stem up - outMap.emplace(std::make_pair( "note8thDown", 0xE1D8 )); // glyphnumber: 1522, Eighth note (quaver) stem down - outMap.emplace(std::make_pair( "note8thUp", 0xE1D7 )); // glyphnumber: 1523, Eighth note (quaver) stem up - outMap.emplace(std::make_pair( "noteABlack", 0xE197 )); // glyphnumber: 1524, A (black note) - outMap.emplace(std::make_pair( "noteAFlatBlack", 0xE196 )); // glyphnumber: 1525, A flat (black note) - outMap.emplace(std::make_pair( "noteAFlatHalf", 0xE17F )); // glyphnumber: 1526, A flat (half note) - outMap.emplace(std::make_pair( "noteAFlatWhole", 0xE168 )); // glyphnumber: 1527, A flat (whole note) - outMap.emplace(std::make_pair( "noteAHalf", 0xE180 )); // glyphnumber: 1528, A (half note) - outMap.emplace(std::make_pair( "noteASharpBlack", 0xE198 )); // glyphnumber: 1529, A sharp (black note) - outMap.emplace(std::make_pair( "noteASharpHalf", 0xE181 )); // glyphnumber: 1530, A sharp (half note) - outMap.emplace(std::make_pair( "noteASharpWhole", 0xE16A )); // glyphnumber: 1531, A sharp (whole note) - outMap.emplace(std::make_pair( "noteAWhole", 0xE169 )); // glyphnumber: 1532, A (whole note) - outMap.emplace(std::make_pair( "noteBBlack", 0xE19A )); // glyphnumber: 1533, B (black note) - outMap.emplace(std::make_pair( "noteBFlatBlack", 0xE199 )); // glyphnumber: 1534, B flat (black note) - outMap.emplace(std::make_pair( "noteBFlatHalf", 0xE182 )); // glyphnumber: 1535, B flat (half note) - outMap.emplace(std::make_pair( "noteBFlatWhole", 0xE16B )); // glyphnumber: 1536, B flat (whole note) - outMap.emplace(std::make_pair( "noteBHalf", 0xE183 )); // glyphnumber: 1537, B (half note) - outMap.emplace(std::make_pair( "noteBSharpBlack", 0xE19B )); // glyphnumber: 1538, B sharp (black note) - outMap.emplace(std::make_pair( "noteBSharpHalf", 0xE184 )); // glyphnumber: 1539, B sharp (half note) - outMap.emplace(std::make_pair( "noteBSharpWhole", 0xE16D )); // glyphnumber: 1540, B sharp (whole note) - outMap.emplace(std::make_pair( "noteBWhole", 0xE16C )); // glyphnumber: 1541, B (whole note) - outMap.emplace(std::make_pair( "noteCBlack", 0xE19D )); // glyphnumber: 1542, C (black note) - outMap.emplace(std::make_pair( "noteCFlatBlack", 0xE19C )); // glyphnumber: 1543, C flat (black note) - outMap.emplace(std::make_pair( "noteCFlatHalf", 0xE185 )); // glyphnumber: 1544, C flat (half note) - outMap.emplace(std::make_pair( "noteCFlatWhole", 0xE16E )); // glyphnumber: 1545, C flat (whole note) - outMap.emplace(std::make_pair( "noteCHalf", 0xE186 )); // glyphnumber: 1546, C (half note) - outMap.emplace(std::make_pair( "noteCSharpBlack", 0xE19E )); // glyphnumber: 1547, C sharp (black note) - outMap.emplace(std::make_pair( "noteCSharpHalf", 0xE187 )); // glyphnumber: 1548, C sharp (half note) - outMap.emplace(std::make_pair( "noteCSharpWhole", 0xE170 )); // glyphnumber: 1549, C sharp (whole note) - outMap.emplace(std::make_pair( "noteCWhole", 0xE16F )); // glyphnumber: 1550, C (whole note) - outMap.emplace(std::make_pair( "noteDBlack", 0xE1A0 )); // glyphnumber: 1551, D (black note) - outMap.emplace(std::make_pair( "noteDFlatBlack", 0xE19F )); // glyphnumber: 1552, D flat (black note) - outMap.emplace(std::make_pair( "noteDFlatHalf", 0xE188 )); // glyphnumber: 1553, D flat (half note) - outMap.emplace(std::make_pair( "noteDFlatWhole", 0xE171 )); // glyphnumber: 1554, D flat (whole note) - outMap.emplace(std::make_pair( "noteDHalf", 0xE189 )); // glyphnumber: 1555, D (half note) - outMap.emplace(std::make_pair( "noteDSharpBlack", 0xE1A1 )); // glyphnumber: 1556, D sharp (black note) - outMap.emplace(std::make_pair( "noteDSharpHalf", 0xE18A )); // glyphnumber: 1557, D sharp (half note) - outMap.emplace(std::make_pair( "noteDSharpWhole", 0xE173 )); // glyphnumber: 1558, D sharp (whole note) - outMap.emplace(std::make_pair( "noteDWhole", 0xE172 )); // glyphnumber: 1559, D (whole note) - outMap.emplace(std::make_pair( "noteDoBlack", 0xE160 )); // glyphnumber: 1560, Do (black note) - outMap.emplace(std::make_pair( "noteDoHalf", 0xE158 )); // glyphnumber: 1561, Do (half note) - outMap.emplace(std::make_pair( "noteDoWhole", 0xE150 )); // glyphnumber: 1562, Do (whole note) - outMap.emplace(std::make_pair( "noteDoubleWhole", 0xE1D0 )); // glyphnumber: 1563, Double whole note (breve) - outMap.emplace(std::make_pair( "noteDoubleWholeSquare", 0xE1D1 )); // glyphnumber: 1564, Double whole note (square) - outMap.emplace(std::make_pair( "noteEBlack", 0xE1A3 )); // glyphnumber: 1565, E (black note) - outMap.emplace(std::make_pair( "noteEFlatBlack", 0xE1A2 )); // glyphnumber: 1566, E flat (black note) - outMap.emplace(std::make_pair( "noteEFlatHalf", 0xE18B )); // glyphnumber: 1567, E flat (half note) - outMap.emplace(std::make_pair( "noteEFlatWhole", 0xE174 )); // glyphnumber: 1568, E flat (whole note) - outMap.emplace(std::make_pair( "noteEHalf", 0xE18C )); // glyphnumber: 1569, E (half note) - outMap.emplace(std::make_pair( "noteESharpBlack", 0xE1A4 )); // glyphnumber: 1570, E sharp (black note) - outMap.emplace(std::make_pair( "noteESharpHalf", 0xE18D )); // glyphnumber: 1571, E sharp (half note) - outMap.emplace(std::make_pair( "noteESharpWhole", 0xE176 )); // glyphnumber: 1572, E sharp (whole note) - outMap.emplace(std::make_pair( "noteEWhole", 0xE175 )); // glyphnumber: 1573, E (whole note) - outMap.emplace(std::make_pair( "noteEmptyBlack", 0xE1AF )); // glyphnumber: 1574, Empty black note - outMap.emplace(std::make_pair( "noteEmptyHalf", 0xE1AE )); // glyphnumber: 1575, Empty half note - outMap.emplace(std::make_pair( "noteEmptyWhole", 0xE1AD )); // glyphnumber: 1576, Empty whole note - outMap.emplace(std::make_pair( "noteFBlack", 0xE1A6 )); // glyphnumber: 1577, F (black note) - outMap.emplace(std::make_pair( "noteFFlatBlack", 0xE1A5 )); // glyphnumber: 1578, F flat (black note) - outMap.emplace(std::make_pair( "noteFFlatHalf", 0xE18E )); // glyphnumber: 1579, F flat (half note) - outMap.emplace(std::make_pair( "noteFFlatWhole", 0xE177 )); // glyphnumber: 1580, F flat (whole note) - outMap.emplace(std::make_pair( "noteFHalf", 0xE18F )); // glyphnumber: 1581, F (half note) - outMap.emplace(std::make_pair( "noteFSharpBlack", 0xE1A7 )); // glyphnumber: 1582, F sharp (black note) - outMap.emplace(std::make_pair( "noteFSharpHalf", 0xE190 )); // glyphnumber: 1583, F sharp (half note) - outMap.emplace(std::make_pair( "noteFSharpWhole", 0xE179 )); // glyphnumber: 1584, F sharp (whole note) - outMap.emplace(std::make_pair( "noteFWhole", 0xE178 )); // glyphnumber: 1585, F (whole note) - outMap.emplace(std::make_pair( "noteFaBlack", 0xE163 )); // glyphnumber: 1586, Fa (black note) - outMap.emplace(std::make_pair( "noteFaHalf", 0xE15B )); // glyphnumber: 1587, Fa (half note) - outMap.emplace(std::make_pair( "noteFaWhole", 0xE153 )); // glyphnumber: 1588, Fa (whole note) - outMap.emplace(std::make_pair( "noteGBlack", 0xE1A9 )); // glyphnumber: 1589, G (black note) - outMap.emplace(std::make_pair( "noteGFlatBlack", 0xE1A8 )); // glyphnumber: 1590, G flat (black note) - outMap.emplace(std::make_pair( "noteGFlatHalf", 0xE191 )); // glyphnumber: 1591, G flat (half note) - outMap.emplace(std::make_pair( "noteGFlatWhole", 0xE17A )); // glyphnumber: 1592, G flat (whole note) - outMap.emplace(std::make_pair( "noteGHalf", 0xE192 )); // glyphnumber: 1593, G (half note) - outMap.emplace(std::make_pair( "noteGSharpBlack", 0xE1AA )); // glyphnumber: 1594, G sharp (black note) - outMap.emplace(std::make_pair( "noteGSharpHalf", 0xE193 )); // glyphnumber: 1595, G sharp (half note) - outMap.emplace(std::make_pair( "noteGSharpWhole", 0xE17C )); // glyphnumber: 1596, G sharp (whole note) - outMap.emplace(std::make_pair( "noteGWhole", 0xE17B )); // glyphnumber: 1597, G (whole note) - outMap.emplace(std::make_pair( "noteHBlack", 0xE1AB )); // glyphnumber: 1598, H (black note) - outMap.emplace(std::make_pair( "noteHHalf", 0xE194 )); // glyphnumber: 1599, H (half note) - outMap.emplace(std::make_pair( "noteHSharpBlack", 0xE1AC )); // glyphnumber: 1600, H sharp (black note) - outMap.emplace(std::make_pair( "noteHSharpHalf", 0xE195 )); // glyphnumber: 1601, H sharp (half note) - outMap.emplace(std::make_pair( "noteHSharpWhole", 0xE17E )); // glyphnumber: 1602, H sharp (whole note) - outMap.emplace(std::make_pair( "noteHWhole", 0xE17D )); // glyphnumber: 1603, H (whole note) - outMap.emplace(std::make_pair( "noteHalfDown", 0xE1D4 )); // glyphnumber: 1604, Half note (minim) stem down - outMap.emplace(std::make_pair( "noteHalfUp", 0xE1D3 )); // glyphnumber: 1605, Half note (minim) stem up - outMap.emplace(std::make_pair( "noteLaBlack", 0xE165 )); // glyphnumber: 1606, La (black note) - outMap.emplace(std::make_pair( "noteLaHalf", 0xE15D )); // glyphnumber: 1607, La (half note) - outMap.emplace(std::make_pair( "noteLaWhole", 0xE155 )); // glyphnumber: 1608, La (whole note) - outMap.emplace(std::make_pair( "noteMiBlack", 0xE162 )); // glyphnumber: 1609, Mi (black note) - outMap.emplace(std::make_pair( "noteMiHalf", 0xE15A )); // glyphnumber: 1610, Mi (half note) - outMap.emplace(std::make_pair( "noteMiWhole", 0xE152 )); // glyphnumber: 1611, Mi (whole note) - outMap.emplace(std::make_pair( "noteQuarterDown", 0xE1D6 )); // glyphnumber: 1612, Quarter note (crotchet) stem down - outMap.emplace(std::make_pair( "noteQuarterUp", 0xE1D5 )); // glyphnumber: 1613, Quarter note (crotchet) stem up - outMap.emplace(std::make_pair( "noteReBlack", 0xE161 )); // glyphnumber: 1614, Re (black note) - outMap.emplace(std::make_pair( "noteReHalf", 0xE159 )); // glyphnumber: 1615, Re (half note) - outMap.emplace(std::make_pair( "noteReWhole", 0xE151 )); // glyphnumber: 1616, Re (whole note) - outMap.emplace(std::make_pair( "noteShapeArrowheadLeftBlack", 0xE1C9 )); // glyphnumber: 1617, Arrowhead left black (Funk 7-shape re) - outMap.emplace(std::make_pair( "noteShapeArrowheadLeftDoubleWhole", 0xECDC )); // glyphnumber: 1618, Arrowhead left double whole (Funk 7-shape re) - outMap.emplace(std::make_pair( "noteShapeArrowheadLeftWhite", 0xE1C8 )); // glyphnumber: 1619, Arrowhead left white (Funk 7-shape re) - outMap.emplace(std::make_pair( "noteShapeDiamondBlack", 0xE1B9 )); // glyphnumber: 1620, Diamond black (4-shape mi; 7-shape mi) - outMap.emplace(std::make_pair( "noteShapeDiamondDoubleWhole", 0xECD4 )); // glyphnumber: 1621, Diamond double whole (4-shape mi; 7-shape mi) - outMap.emplace(std::make_pair( "noteShapeDiamondWhite", 0xE1B8 )); // glyphnumber: 1622, Diamond white (4-shape mi; 7-shape mi) - outMap.emplace(std::make_pair( "noteShapeIsoscelesTriangleBlack", 0xE1C5 )); // glyphnumber: 1623, Isosceles triangle black (Walker 7-shape ti) - outMap.emplace(std::make_pair( "noteShapeIsoscelesTriangleDoubleWhole", 0xECDA )); // glyphnumber: 1624, Isosceles triangle double whole (Walker 7-shape ti) - outMap.emplace(std::make_pair( "noteShapeIsoscelesTriangleWhite", 0xE1C4 )); // glyphnumber: 1625, Isosceles triangle white (Walker 7-shape ti) - outMap.emplace(std::make_pair( "noteShapeKeystoneBlack", 0xE1C1 )); // glyphnumber: 1626, Inverted keystone black (Walker 7-shape do) - outMap.emplace(std::make_pair( "noteShapeKeystoneDoubleWhole", 0xECD8 )); // glyphnumber: 1627, Inverted keystone double whole (Walker 7-shape do) - outMap.emplace(std::make_pair( "noteShapeKeystoneWhite", 0xE1C0 )); // glyphnumber: 1628, Inverted keystone white (Walker 7-shape do) - outMap.emplace(std::make_pair( "noteShapeMoonBlack", 0xE1BD )); // glyphnumber: 1629, Moon black (Aikin 7-shape re) - outMap.emplace(std::make_pair( "noteShapeMoonDoubleWhole", 0xECD6 )); // glyphnumber: 1630, Moon double whole (Aikin 7-shape re) - outMap.emplace(std::make_pair( "noteShapeMoonLeftBlack", 0xE1C7 )); // glyphnumber: 1631, Moon left black (Funk 7-shape do) - outMap.emplace(std::make_pair( "noteShapeMoonLeftDoubleWhole", 0xECDB )); // glyphnumber: 1632, Moon left double whole (Funk 7-shape do) - outMap.emplace(std::make_pair( "noteShapeMoonLeftWhite", 0xE1C6 )); // glyphnumber: 1633, Moon left white (Funk 7-shape do) - outMap.emplace(std::make_pair( "noteShapeMoonWhite", 0xE1BC )); // glyphnumber: 1634, Moon white (Aikin 7-shape re) - outMap.emplace(std::make_pair( "noteShapeQuarterMoonBlack", 0xE1C3 )); // glyphnumber: 1635, Quarter moon black (Walker 7-shape re) - outMap.emplace(std::make_pair( "noteShapeQuarterMoonDoubleWhole", 0xECD9 )); // glyphnumber: 1636, Quarter moon double whole (Walker 7-shape re) - outMap.emplace(std::make_pair( "noteShapeQuarterMoonWhite", 0xE1C2 )); // glyphnumber: 1637, Quarter moon white (Walker 7-shape re) - outMap.emplace(std::make_pair( "noteShapeRoundBlack", 0xE1B1 )); // glyphnumber: 1638, Round black (4-shape sol; 7-shape so) - outMap.emplace(std::make_pair( "noteShapeRoundDoubleWhole", 0xECD0 )); // glyphnumber: 1639, Round double whole (4-shape sol; 7-shape so) - outMap.emplace(std::make_pair( "noteShapeRoundWhite", 0xE1B0 )); // glyphnumber: 1640, Round white (4-shape sol; 7-shape so) - outMap.emplace(std::make_pair( "noteShapeSquareBlack", 0xE1B3 )); // glyphnumber: 1641, Square black (4-shape la; Aikin 7-shape la) - outMap.emplace(std::make_pair( "noteShapeSquareDoubleWhole", 0xECD1 )); // glyphnumber: 1642, Square double whole (4-shape la; Aikin 7-shape la) - outMap.emplace(std::make_pair( "noteShapeSquareWhite", 0xE1B2 )); // glyphnumber: 1643, Square white (4-shape la; Aikin 7-shape la) - outMap.emplace(std::make_pair( "noteShapeTriangleLeftBlack", 0xE1B7 )); // glyphnumber: 1644, Triangle left black (stem up; 4-shape fa; 7-shape fa) - outMap.emplace(std::make_pair( "noteShapeTriangleLeftDoubleWhole", 0xECD3 )); // glyphnumber: 1645, Triangle left double whole (stem up; 4-shape fa; 7-shape fa) - outMap.emplace(std::make_pair( "noteShapeTriangleLeftWhite", 0xE1B6 )); // glyphnumber: 1646, Triangle left white (stem up; 4-shape fa; 7-shape fa) - outMap.emplace(std::make_pair( "noteShapeTriangleRightBlack", 0xE1B5 )); // glyphnumber: 1647, Triangle right black (stem down; 4-shape fa; 7-shape fa) - outMap.emplace(std::make_pair( "noteShapeTriangleRightDoubleWhole", 0xECD2 )); // glyphnumber: 1648, Triangle right double whole (stem down; 4-shape fa; 7-shape fa) - outMap.emplace(std::make_pair( "noteShapeTriangleRightWhite", 0xE1B4 )); // glyphnumber: 1649, Triangle right white (stem down; 4-shape fa; 7-shape fa) - outMap.emplace(std::make_pair( "noteShapeTriangleRoundBlack", 0xE1BF )); // glyphnumber: 1650, Triangle-round black (Aikin 7-shape ti) - outMap.emplace(std::make_pair( "noteShapeTriangleRoundDoubleWhole", 0xECD7 )); // glyphnumber: 1651, Triangle-round white (Aikin 7-shape ti) - outMap.emplace(std::make_pair( "noteShapeTriangleRoundLeftBlack", 0xE1CB )); // glyphnumber: 1652, Triangle-round left black (Funk 7-shape ti) - outMap.emplace(std::make_pair( "noteShapeTriangleRoundLeftDoubleWhole", 0xECDD )); // glyphnumber: 1653, Triangle-round left double whole (Funk 7-shape ti) - outMap.emplace(std::make_pair( "noteShapeTriangleRoundLeftWhite", 0xE1CA )); // glyphnumber: 1654, Triangle-round left white (Funk 7-shape ti) - outMap.emplace(std::make_pair( "noteShapeTriangleRoundWhite", 0xE1BE )); // glyphnumber: 1655, Triangle-round white (Aikin 7-shape ti) - outMap.emplace(std::make_pair( "noteShapeTriangleUpBlack", 0xE1BB )); // glyphnumber: 1656, Triangle up black (Aikin 7-shape do) - outMap.emplace(std::make_pair( "noteShapeTriangleUpDoubleWhole", 0xECD5 )); // glyphnumber: 1657, Triangle up double whole (Aikin 7-shape do) - outMap.emplace(std::make_pair( "noteShapeTriangleUpWhite", 0xE1BA )); // glyphnumber: 1658, Triangle up white (Aikin 7-shape do) - outMap.emplace(std::make_pair( "noteSiBlack", 0xE167 )); // glyphnumber: 1659, Si (black note) - outMap.emplace(std::make_pair( "noteSiHalf", 0xE15F )); // glyphnumber: 1660, Si (half note) - outMap.emplace(std::make_pair( "noteSiWhole", 0xE157 )); // glyphnumber: 1661, Si (whole note) - outMap.emplace(std::make_pair( "noteSoBlack", 0xE164 )); // glyphnumber: 1662, So (black note) - outMap.emplace(std::make_pair( "noteSoHalf", 0xE15C )); // glyphnumber: 1663, So (half note) - outMap.emplace(std::make_pair( "noteSoWhole", 0xE154 )); // glyphnumber: 1664, So (whole note) - outMap.emplace(std::make_pair( "noteTiBlack", 0xE166 )); // glyphnumber: 1665, Ti (black note) - outMap.emplace(std::make_pair( "noteTiHalf", 0xE15E )); // glyphnumber: 1666, Ti (half note) - outMap.emplace(std::make_pair( "noteTiWhole", 0xE156 )); // glyphnumber: 1667, Ti (whole note) - outMap.emplace(std::make_pair( "noteWhole", 0xE1D2 )); // glyphnumber: 1668, Whole note (semibreve) - outMap.emplace(std::make_pair( "noteheadBlack", 0xE0A4 )); // glyphnumber: 1669, Black notehead - outMap.emplace(std::make_pair( "noteheadCircleSlash", 0xE0F7 )); // glyphnumber: 1670, Circle slash notehead - outMap.emplace(std::make_pair( "noteheadCircleX", 0xE0B3 )); // glyphnumber: 1671, Circle X notehead - outMap.emplace(std::make_pair( "noteheadCircleXDoubleWhole", 0xE0B0 )); // glyphnumber: 1672, Circle X double whole - outMap.emplace(std::make_pair( "noteheadCircleXHalf", 0xE0B2 )); // glyphnumber: 1673, Circle X half - outMap.emplace(std::make_pair( "noteheadCircleXWhole", 0xE0B1 )); // glyphnumber: 1674, Circle X whole - outMap.emplace(std::make_pair( "noteheadCircledBlack", 0xE0E4 )); // glyphnumber: 1675, Circled black notehead - outMap.emplace(std::make_pair( "noteheadCircledBlackLarge", 0xE0E8 )); // glyphnumber: 1676, Black notehead in large circle - outMap.emplace(std::make_pair( "noteheadCircledDoubleWhole", 0xE0E7 )); // glyphnumber: 1677, Circled double whole notehead - outMap.emplace(std::make_pair( "noteheadCircledDoubleWholeLarge", 0xE0EB )); // glyphnumber: 1678, Double whole notehead in large circle - outMap.emplace(std::make_pair( "noteheadCircledHalf", 0xE0E5 )); // glyphnumber: 1679, Circled half notehead - outMap.emplace(std::make_pair( "noteheadCircledHalfLarge", 0xE0E9 )); // glyphnumber: 1680, Half notehead in large circle - outMap.emplace(std::make_pair( "noteheadCircledWhole", 0xE0E6 )); // glyphnumber: 1681, Circled whole notehead - outMap.emplace(std::make_pair( "noteheadCircledWholeLarge", 0xE0EA )); // glyphnumber: 1682, Whole notehead in large circle - outMap.emplace(std::make_pair( "noteheadCircledXLarge", 0xE0EC )); // glyphnumber: 1683, Cross notehead in large circle - outMap.emplace(std::make_pair( "noteheadClusterDoubleWhole2nd", 0xE124 )); // glyphnumber: 1684, Double whole note cluster, 2nd - outMap.emplace(std::make_pair( "noteheadClusterDoubleWhole3rd", 0xE128 )); // glyphnumber: 1685, Double whole note cluster, 3rd - outMap.emplace(std::make_pair( "noteheadClusterDoubleWholeBottom", 0xE12E )); // glyphnumber: 1686, Combining double whole note cluster, bottom - outMap.emplace(std::make_pair( "noteheadClusterDoubleWholeMiddle", 0xE12D )); // glyphnumber: 1687, Combining double whole note cluster, middle - outMap.emplace(std::make_pair( "noteheadClusterDoubleWholeTop", 0xE12C )); // glyphnumber: 1688, Combining double whole note cluster, top - outMap.emplace(std::make_pair( "noteheadClusterHalf2nd", 0xE126 )); // glyphnumber: 1689, Half note cluster, 2nd - outMap.emplace(std::make_pair( "noteheadClusterHalf3rd", 0xE12A )); // glyphnumber: 1690, Half note cluster, 3rd - outMap.emplace(std::make_pair( "noteheadClusterHalfBottom", 0xE134 )); // glyphnumber: 1691, Combining half note cluster, bottom - outMap.emplace(std::make_pair( "noteheadClusterHalfMiddle", 0xE133 )); // glyphnumber: 1692, Combining half note cluster, middle - outMap.emplace(std::make_pair( "noteheadClusterHalfTop", 0xE132 )); // glyphnumber: 1693, Combining half note cluster, top - outMap.emplace(std::make_pair( "noteheadClusterQuarter2nd", 0xE127 )); // glyphnumber: 1694, Quarter note cluster, 2nd - outMap.emplace(std::make_pair( "noteheadClusterQuarter3rd", 0xE12B )); // glyphnumber: 1695, Quarter note cluster, 3rd - outMap.emplace(std::make_pair( "noteheadClusterQuarterBottom", 0xE137 )); // glyphnumber: 1696, Combining quarter note cluster, bottom - outMap.emplace(std::make_pair( "noteheadClusterQuarterMiddle", 0xE136 )); // glyphnumber: 1697, Combining quarter note cluster, middle - outMap.emplace(std::make_pair( "noteheadClusterQuarterTop", 0xE135 )); // glyphnumber: 1698, Combining quarter note cluster, top - outMap.emplace(std::make_pair( "noteheadClusterRoundBlack", 0xE123 )); // glyphnumber: 1699, Cluster notehead black (round) - outMap.emplace(std::make_pair( "noteheadClusterRoundWhite", 0xE122 )); // glyphnumber: 1700, Cluster notehead white (round) - outMap.emplace(std::make_pair( "noteheadClusterSquareBlack", 0xE121 )); // glyphnumber: 1701, Cluster notehead black (square) - outMap.emplace(std::make_pair( "noteheadClusterSquareWhite", 0xE120 )); // glyphnumber: 1702, Cluster notehead white (square) - outMap.emplace(std::make_pair( "noteheadClusterWhole2nd", 0xE125 )); // glyphnumber: 1703, Whole note cluster, 2nd - outMap.emplace(std::make_pair( "noteheadClusterWhole3rd", 0xE129 )); // glyphnumber: 1704, Whole note cluster, 3rd - outMap.emplace(std::make_pair( "noteheadClusterWholeBottom", 0xE131 )); // glyphnumber: 1705, Combining whole note cluster, bottom - outMap.emplace(std::make_pair( "noteheadClusterWholeMiddle", 0xE130 )); // glyphnumber: 1706, Combining whole note cluster, middle - outMap.emplace(std::make_pair( "noteheadClusterWholeTop", 0xE12F )); // glyphnumber: 1707, Combining whole note cluster, top - outMap.emplace(std::make_pair( "noteheadDiamondBlack", 0xE0DB )); // glyphnumber: 1708, Diamond black notehead - outMap.emplace(std::make_pair( "noteheadDiamondBlackOld", 0xE0E2 )); // glyphnumber: 1709, Diamond black notehead (old) - outMap.emplace(std::make_pair( "noteheadDiamondBlackWide", 0xE0DC )); // glyphnumber: 1710, Diamond black notehead (wide) - outMap.emplace(std::make_pair( "noteheadDiamondClusterBlack2nd", 0xE139 )); // glyphnumber: 1711, Black diamond cluster, 2nd - outMap.emplace(std::make_pair( "noteheadDiamondClusterBlack3rd", 0xE13B )); // glyphnumber: 1712, Black diamond cluster, 3rd - outMap.emplace(std::make_pair( "noteheadDiamondClusterBlackBottom", 0xE141 )); // glyphnumber: 1713, Combining black diamond cluster, bottom - outMap.emplace(std::make_pair( "noteheadDiamondClusterBlackMiddle", 0xE140 )); // glyphnumber: 1714, Combining black diamond cluster, middle - outMap.emplace(std::make_pair( "noteheadDiamondClusterBlackTop", 0xE13F )); // glyphnumber: 1715, Combining black diamond cluster, top - outMap.emplace(std::make_pair( "noteheadDiamondClusterWhite2nd", 0xE138 )); // glyphnumber: 1716, White diamond cluster, 2nd - outMap.emplace(std::make_pair( "noteheadDiamondClusterWhite3rd", 0xE13A )); // glyphnumber: 1717, White diamond cluster, 3rd - outMap.emplace(std::make_pair( "noteheadDiamondClusterWhiteBottom", 0xE13E )); // glyphnumber: 1718, Combining white diamond cluster, bottom - outMap.emplace(std::make_pair( "noteheadDiamondClusterWhiteMiddle", 0xE13D )); // glyphnumber: 1719, Combining white diamond cluster, middle - outMap.emplace(std::make_pair( "noteheadDiamondClusterWhiteTop", 0xE13C )); // glyphnumber: 1720, Combining white diamond cluster, top - outMap.emplace(std::make_pair( "noteheadDiamondDoubleWhole", 0xE0D7 )); // glyphnumber: 1721, Diamond double whole notehead - outMap.emplace(std::make_pair( "noteheadDiamondDoubleWholeOld", 0xE0DF )); // glyphnumber: 1722, Diamond double whole notehead (old) - outMap.emplace(std::make_pair( "noteheadDiamondHalf", 0xE0D9 )); // glyphnumber: 1723, Diamond half notehead - outMap.emplace(std::make_pair( "noteheadDiamondHalfFilled", 0xE0E3 )); // glyphnumber: 1724, Half-filled diamond notehead - outMap.emplace(std::make_pair( "noteheadDiamondHalfOld", 0xE0E1 )); // glyphnumber: 1725, Diamond half notehead (old) - outMap.emplace(std::make_pair( "noteheadDiamondHalfWide", 0xE0DA )); // glyphnumber: 1726, Diamond half notehead (wide) - outMap.emplace(std::make_pair( "noteheadDiamondOpen", 0xE0FC )); // glyphnumber: 1727, Open diamond notehead - outMap.emplace(std::make_pair( "noteheadDiamondWhite", 0xE0DD )); // glyphnumber: 1728, Diamond white notehead - outMap.emplace(std::make_pair( "noteheadDiamondWhiteWide", 0xE0DE )); // glyphnumber: 1729, Diamond white notehead (wide) - outMap.emplace(std::make_pair( "noteheadDiamondWhole", 0xE0D8 )); // glyphnumber: 1730, Diamond whole notehead - outMap.emplace(std::make_pair( "noteheadDiamondWholeOld", 0xE0E0 )); // glyphnumber: 1731, Diamond whole notehead (old) - outMap.emplace(std::make_pair( "noteheadDoubleWhole", 0xE0A0 )); // glyphnumber: 1732, Double whole (breve) notehead - outMap.emplace(std::make_pair( "noteheadDoubleWholeSquare", 0xE0A1 )); // glyphnumber: 1733, Double whole (breve) notehead (square) - outMap.emplace(std::make_pair( "noteheadDoubleWholeWithX", 0xE0B4 )); // glyphnumber: 1734, Double whole notehead with X - outMap.emplace(std::make_pair( "noteheadHalf", 0xE0A3 )); // glyphnumber: 1735, Half (minim) notehead - outMap.emplace(std::make_pair( "noteheadHalfFilled", 0xE0FB )); // glyphnumber: 1736, Filled half (minim) notehead - outMap.emplace(std::make_pair( "noteheadHalfWithX", 0xE0B6 )); // glyphnumber: 1737, Half notehead with X - outMap.emplace(std::make_pair( "noteheadHeavyX", 0xE0F8 )); // glyphnumber: 1738, Heavy X notehead - outMap.emplace(std::make_pair( "noteheadHeavyXHat", 0xE0F9 )); // glyphnumber: 1739, Heavy X with hat notehead - outMap.emplace(std::make_pair( "noteheadLargeArrowDownBlack", 0xE0F4 )); // glyphnumber: 1740, Large arrow down (lowest pitch) black notehead - outMap.emplace(std::make_pair( "noteheadLargeArrowDownDoubleWhole", 0xE0F1 )); // glyphnumber: 1741, Large arrow down (lowest pitch) double whole notehead - outMap.emplace(std::make_pair( "noteheadLargeArrowDownHalf", 0xE0F3 )); // glyphnumber: 1742, Large arrow down (lowest pitch) half notehead - outMap.emplace(std::make_pair( "noteheadLargeArrowDownWhole", 0xE0F2 )); // glyphnumber: 1743, Large arrow down (lowest pitch) whole notehead - outMap.emplace(std::make_pair( "noteheadLargeArrowUpBlack", 0xE0F0 )); // glyphnumber: 1744, Large arrow up (highest pitch) black notehead - outMap.emplace(std::make_pair( "noteheadLargeArrowUpDoubleWhole", 0xE0ED )); // glyphnumber: 1745, Large arrow up (highest pitch) double whole notehead - outMap.emplace(std::make_pair( "noteheadLargeArrowUpHalf", 0xE0EF )); // glyphnumber: 1746, Large arrow up (highest pitch) half notehead - outMap.emplace(std::make_pair( "noteheadLargeArrowUpWhole", 0xE0EE )); // glyphnumber: 1747, Large arrow up (highest pitch) whole notehead - outMap.emplace(std::make_pair( "noteheadMoonBlack", 0xE0CB )); // glyphnumber: 1748, Moon notehead black - outMap.emplace(std::make_pair( "noteheadMoonWhite", 0xE0CA )); // glyphnumber: 1749, Moon notehead white - outMap.emplace(std::make_pair( "noteheadNull", 0xE0A5 )); // glyphnumber: 1750, Null notehead - outMap.emplace(std::make_pair( "noteheadParenthesis", 0xE0CE )); // glyphnumber: 1751, Parenthesis notehead - outMap.emplace(std::make_pair( "noteheadParenthesisLeft", 0xE0F5 )); // glyphnumber: 1752, Opening parenthesis - outMap.emplace(std::make_pair( "noteheadParenthesisRight", 0xE0F6 )); // glyphnumber: 1753, Closing parenthesis - outMap.emplace(std::make_pair( "noteheadPlusBlack", 0xE0AF )); // glyphnumber: 1754, Plus notehead black - outMap.emplace(std::make_pair( "noteheadPlusDoubleWhole", 0xE0AC )); // glyphnumber: 1755, Plus notehead double whole - outMap.emplace(std::make_pair( "noteheadPlusHalf", 0xE0AE )); // glyphnumber: 1756, Plus notehead half - outMap.emplace(std::make_pair( "noteheadPlusWhole", 0xE0AD )); // glyphnumber: 1757, Plus notehead whole - outMap.emplace(std::make_pair( "noteheadRectangularClusterBlackBottom", 0xE144 )); // glyphnumber: 1758, Combining black rectangular cluster, bottom - outMap.emplace(std::make_pair( "noteheadRectangularClusterBlackMiddle", 0xE143 )); // glyphnumber: 1759, Combining black rectangular cluster, middle - outMap.emplace(std::make_pair( "noteheadRectangularClusterBlackTop", 0xE142 )); // glyphnumber: 1760, Combining black rectangular cluster, top - outMap.emplace(std::make_pair( "noteheadRectangularClusterWhiteBottom", 0xE147 )); // glyphnumber: 1761, Combining white rectangular cluster, bottom - outMap.emplace(std::make_pair( "noteheadRectangularClusterWhiteMiddle", 0xE146 )); // glyphnumber: 1762, Combining white rectangular cluster, middle - outMap.emplace(std::make_pair( "noteheadRectangularClusterWhiteTop", 0xE145 )); // glyphnumber: 1763, Combining white rectangular cluster, top - outMap.emplace(std::make_pair( "noteheadRoundBlack", 0xE113 )); // glyphnumber: 1764, Round black notehead - outMap.emplace(std::make_pair( "noteheadRoundBlackDoubleSlashed", 0xE11C )); // glyphnumber: 1765, Round black notehead, double slashed - outMap.emplace(std::make_pair( "noteheadRoundBlackLarge", 0xE110 )); // glyphnumber: 1766, Large round black notehead - outMap.emplace(std::make_pair( "noteheadRoundBlackSlashed", 0xE118 )); // glyphnumber: 1767, Round black notehead, slashed - outMap.emplace(std::make_pair( "noteheadRoundBlackSlashedLarge", 0xE116 )); // glyphnumber: 1768, Large round black notehead, slashed - outMap.emplace(std::make_pair( "noteheadRoundWhite", 0xE114 )); // glyphnumber: 1769, Round white notehead - outMap.emplace(std::make_pair( "noteheadRoundWhiteDoubleSlashed", 0xE11D )); // glyphnumber: 1770, Round white notehead, double slashed - outMap.emplace(std::make_pair( "noteheadRoundWhiteLarge", 0xE111 )); // glyphnumber: 1771, Large round white notehead - outMap.emplace(std::make_pair( "noteheadRoundWhiteSlashed", 0xE119 )); // glyphnumber: 1772, Round white notehead, slashed - outMap.emplace(std::make_pair( "noteheadRoundWhiteSlashedLarge", 0xE117 )); // glyphnumber: 1773, Large round white notehead, slashed - outMap.emplace(std::make_pair( "noteheadRoundWhiteWithDot", 0xE115 )); // glyphnumber: 1774, Round white notehead with dot - outMap.emplace(std::make_pair( "noteheadRoundWhiteWithDotLarge", 0xE112 )); // glyphnumber: 1775, Large round white notehead with dot - outMap.emplace(std::make_pair( "noteheadSlashDiamondWhite", 0xE104 )); // glyphnumber: 1776, Large white diamond - outMap.emplace(std::make_pair( "noteheadSlashHorizontalEnds", 0xE101 )); // glyphnumber: 1777, Slash with horizontal ends - outMap.emplace(std::make_pair( "noteheadSlashHorizontalEndsMuted", 0xE108 )); // glyphnumber: 1778, Muted slash with horizontal ends - outMap.emplace(std::make_pair( "noteheadSlashVerticalEnds", 0xE100 )); // glyphnumber: 1779, Slash with vertical ends - outMap.emplace(std::make_pair( "noteheadSlashVerticalEndsMuted", 0xE107 )); // glyphnumber: 1780, Muted slash with vertical ends - outMap.emplace(std::make_pair( "noteheadSlashVerticalEndsSmall", 0xE105 )); // glyphnumber: 1781, Small slash with vertical ends - outMap.emplace(std::make_pair( "noteheadSlashWhiteDoubleWhole", 0xE10A )); // glyphnumber: 1782, White slash double whole - outMap.emplace(std::make_pair( "noteheadSlashWhiteHalf", 0xE103 )); // glyphnumber: 1783, White slash half - outMap.emplace(std::make_pair( "noteheadSlashWhiteMuted", 0xE109 )); // glyphnumber: 1784, Muted white slash - outMap.emplace(std::make_pair( "noteheadSlashWhiteWhole", 0xE102 )); // glyphnumber: 1785, White slash whole - outMap.emplace(std::make_pair( "noteheadSlashX", 0xE106 )); // glyphnumber: 1786, Large X notehead - outMap.emplace(std::make_pair( "noteheadSlashedBlack1", 0xE0CF )); // glyphnumber: 1787, Slashed black notehead (bottom left to top right) - outMap.emplace(std::make_pair( "noteheadSlashedBlack2", 0xE0D0 )); // glyphnumber: 1788, Slashed black notehead (top left to bottom right) - outMap.emplace(std::make_pair( "noteheadSlashedDoubleWhole1", 0xE0D5 )); // glyphnumber: 1789, Slashed double whole notehead (bottom left to top right) - outMap.emplace(std::make_pair( "noteheadSlashedDoubleWhole2", 0xE0D6 )); // glyphnumber: 1790, Slashed double whole notehead (top left to bottom right) - outMap.emplace(std::make_pair( "noteheadSlashedHalf1", 0xE0D1 )); // glyphnumber: 1791, Slashed half notehead (bottom left to top right) - outMap.emplace(std::make_pair( "noteheadSlashedHalf2", 0xE0D2 )); // glyphnumber: 1792, Slashed half notehead (top left to bottom right) - outMap.emplace(std::make_pair( "noteheadSlashedWhole1", 0xE0D3 )); // glyphnumber: 1793, Slashed whole notehead (bottom left to top right) - outMap.emplace(std::make_pair( "noteheadSlashedWhole2", 0xE0D4 )); // glyphnumber: 1794, Slashed whole notehead (top left to bottom right) - outMap.emplace(std::make_pair( "noteheadSquareBlack", 0xE0B9 )); // glyphnumber: 1795, Square notehead black - outMap.emplace(std::make_pair( "noteheadSquareBlackLarge", 0xE11A )); // glyphnumber: 1796, Large square black notehead - outMap.emplace(std::make_pair( "noteheadSquareBlackWhite", 0xE11B )); // glyphnumber: 1797, Large square white notehead - outMap.emplace(std::make_pair( "noteheadSquareWhite", 0xE0B8 )); // glyphnumber: 1798, Square notehead white - outMap.emplace(std::make_pair( "noteheadTriangleDownBlack", 0xE0C7 )); // glyphnumber: 1799, Triangle notehead down black - outMap.emplace(std::make_pair( "noteheadTriangleDownDoubleWhole", 0xE0C3 )); // glyphnumber: 1800, Triangle notehead down double whole - outMap.emplace(std::make_pair( "noteheadTriangleDownHalf", 0xE0C5 )); // glyphnumber: 1801, Triangle notehead down half - outMap.emplace(std::make_pair( "noteheadTriangleDownWhite", 0xE0C6 )); // glyphnumber: 1802, Triangle notehead down white - outMap.emplace(std::make_pair( "noteheadTriangleDownWhole", 0xE0C4 )); // glyphnumber: 1803, Triangle notehead down whole - outMap.emplace(std::make_pair( "noteheadTriangleLeftBlack", 0xE0C0 )); // glyphnumber: 1804, Triangle notehead left black - outMap.emplace(std::make_pair( "noteheadTriangleLeftWhite", 0xE0BF )); // glyphnumber: 1805, Triangle notehead left white - outMap.emplace(std::make_pair( "noteheadTriangleRightBlack", 0xE0C2 )); // glyphnumber: 1806, Triangle notehead right black - outMap.emplace(std::make_pair( "noteheadTriangleRightWhite", 0xE0C1 )); // glyphnumber: 1807, Triangle notehead right white - outMap.emplace(std::make_pair( "noteheadTriangleRoundDownBlack", 0xE0CD )); // glyphnumber: 1808, Triangle-round notehead down black - outMap.emplace(std::make_pair( "noteheadTriangleRoundDownWhite", 0xE0CC )); // glyphnumber: 1809, Triangle-round notehead down white - outMap.emplace(std::make_pair( "noteheadTriangleUpBlack", 0xE0BE )); // glyphnumber: 1810, Triangle notehead up black - outMap.emplace(std::make_pair( "noteheadTriangleUpDoubleWhole", 0xE0BA )); // glyphnumber: 1811, Triangle notehead up double whole - outMap.emplace(std::make_pair( "noteheadTriangleUpHalf", 0xE0BC )); // glyphnumber: 1812, Triangle notehead up half - outMap.emplace(std::make_pair( "noteheadTriangleUpRightBlack", 0xE0C9 )); // glyphnumber: 1813, Triangle notehead up right black - outMap.emplace(std::make_pair( "noteheadTriangleUpRightWhite", 0xE0C8 )); // glyphnumber: 1814, Triangle notehead up right white - outMap.emplace(std::make_pair( "noteheadTriangleUpWhite", 0xE0BD )); // glyphnumber: 1815, Triangle notehead up white - outMap.emplace(std::make_pair( "noteheadTriangleUpWhole", 0xE0BB )); // glyphnumber: 1816, Triangle notehead up whole - outMap.emplace(std::make_pair( "noteheadVoidWithX", 0xE0B7 )); // glyphnumber: 1817, Void notehead with X - outMap.emplace(std::make_pair( "noteheadWhole", 0xE0A2 )); // glyphnumber: 1818, Whole (semibreve) notehead - outMap.emplace(std::make_pair( "noteheadWholeFilled", 0xE0FA )); // glyphnumber: 1819, Filled whole (semibreve) notehead - outMap.emplace(std::make_pair( "noteheadWholeWithX", 0xE0B5 )); // glyphnumber: 1820, Whole notehead with X - outMap.emplace(std::make_pair( "noteheadXBlack", 0xE0A9 )); // glyphnumber: 1821, X notehead black - outMap.emplace(std::make_pair( "noteheadXDoubleWhole", 0xE0A6 )); // glyphnumber: 1822, X notehead double whole - outMap.emplace(std::make_pair( "noteheadXHalf", 0xE0A8 )); // glyphnumber: 1823, X notehead half - outMap.emplace(std::make_pair( "noteheadXOrnate", 0xE0AA )); // glyphnumber: 1824, Ornate X notehead - outMap.emplace(std::make_pair( "noteheadXOrnateEllipse", 0xE0AB )); // glyphnumber: 1825, Ornate X notehead in ellipse - outMap.emplace(std::make_pair( "noteheadXWhole", 0xE0A7 )); // glyphnumber: 1826, X notehead whole - outMap.emplace(std::make_pair( "octaveBaselineA", 0xEC91 )); // glyphnumber: 1827, a (baseline) - outMap.emplace(std::make_pair( "octaveBaselineB", 0xEC93 )); // glyphnumber: 1828, b (baseline) - outMap.emplace(std::make_pair( "octaveBaselineM", 0xEC95 )); // glyphnumber: 1829, m (baseline) - outMap.emplace(std::make_pair( "octaveBaselineV", 0xEC97 )); // glyphnumber: 1830, v (baseline) - outMap.emplace(std::make_pair( "octaveBassa", 0xE51F )); // glyphnumber: 1831, Bassa - outMap.emplace(std::make_pair( "octaveLoco", 0xEC90 )); // glyphnumber: 1832, Loco - outMap.emplace(std::make_pair( "octaveParensLeft", 0xE51A )); // glyphnumber: 1833, Left parenthesis for octave signs - outMap.emplace(std::make_pair( "octaveParensRight", 0xE51B )); // glyphnumber: 1834, Right parenthesis for octave signs - outMap.emplace(std::make_pair( "octaveSuperscriptA", 0xEC92 )); // glyphnumber: 1835, a (superscript) - outMap.emplace(std::make_pair( "octaveSuperscriptB", 0xEC94 )); // glyphnumber: 1836, b (superscript) - outMap.emplace(std::make_pair( "octaveSuperscriptM", 0xEC96 )); // glyphnumber: 1837, m (superscript) - outMap.emplace(std::make_pair( "octaveSuperscriptV", 0xEC98 )); // glyphnumber: 1838, v (superscript) - outMap.emplace(std::make_pair( "ornamentBottomLeftConcaveStroke", 0xE59A )); // glyphnumber: 1839, Ornament bottom left concave stroke - outMap.emplace(std::make_pair( "ornamentBottomLeftConcaveStrokeLarge", 0xE59B )); // glyphnumber: 1840, Ornament bottom left concave stroke, large - outMap.emplace(std::make_pair( "ornamentBottomLeftConvexStroke", 0xE59C )); // glyphnumber: 1841, Ornament bottom left convex stroke - outMap.emplace(std::make_pair( "ornamentBottomRightConcaveStroke", 0xE5A7 )); // glyphnumber: 1842, Ornament bottom right concave stroke - outMap.emplace(std::make_pair( "ornamentBottomRightConvexStroke", 0xE5A8 )); // glyphnumber: 1843, Ornament bottom right convex stroke - outMap.emplace(std::make_pair( "ornamentComma", 0xE581 )); // glyphnumber: 1844, Comma - outMap.emplace(std::make_pair( "ornamentDoubleObliqueLinesAfterNote", 0xE57E )); // glyphnumber: 1845, Double oblique straight lines NW-SE - outMap.emplace(std::make_pair( "ornamentDoubleObliqueLinesBeforeNote", 0xE57D )); // glyphnumber: 1846, Double oblique straight lines SW-NE - outMap.emplace(std::make_pair( "ornamentDownCurve", 0xE578 )); // glyphnumber: 1847, Curve below - outMap.emplace(std::make_pair( "ornamentHaydn", 0xE56F )); // glyphnumber: 1848, Haydn ornament - outMap.emplace(std::make_pair( "ornamentHighLeftConcaveStroke", 0xE592 )); // glyphnumber: 1849, Ornament high left concave stroke - outMap.emplace(std::make_pair( "ornamentHighLeftConvexStroke", 0xE593 )); // glyphnumber: 1850, Ornament high left convex stroke - outMap.emplace(std::make_pair( "ornamentHighRightConcaveStroke", 0xE5A2 )); // glyphnumber: 1851, Ornament high right concave stroke - outMap.emplace(std::make_pair( "ornamentHighRightConvexStroke", 0xE5A3 )); // glyphnumber: 1852, Ornament high right convex stroke - outMap.emplace(std::make_pair( "ornamentHookAfterNote", 0xE576 )); // glyphnumber: 1853, Hook after note - outMap.emplace(std::make_pair( "ornamentHookBeforeNote", 0xE575 )); // glyphnumber: 1854, Hook before note - outMap.emplace(std::make_pair( "ornamentLeftFacingHalfCircle", 0xE572 )); // glyphnumber: 1855, Left-facing half circle - outMap.emplace(std::make_pair( "ornamentLeftFacingHook", 0xE574 )); // glyphnumber: 1856, Left-facing hook - outMap.emplace(std::make_pair( "ornamentLeftPlus", 0xE597 )); // glyphnumber: 1857, Ornament left + - outMap.emplace(std::make_pair( "ornamentLeftShakeT", 0xE596 )); // glyphnumber: 1858, Ornament left shake t - outMap.emplace(std::make_pair( "ornamentLeftVerticalStroke", 0xE594 )); // glyphnumber: 1859, Ornament left vertical stroke - outMap.emplace(std::make_pair( "ornamentLeftVerticalStrokeWithCross", 0xE595 )); // glyphnumber: 1860, Ornament left vertical stroke with cross (+) - outMap.emplace(std::make_pair( "ornamentLowLeftConcaveStroke", 0xE598 )); // glyphnumber: 1861, Ornament low left concave stroke - outMap.emplace(std::make_pair( "ornamentLowLeftConvexStroke", 0xE599 )); // glyphnumber: 1862, Ornament low left convex stroke - outMap.emplace(std::make_pair( "ornamentLowRightConcaveStroke", 0xE5A5 )); // glyphnumber: 1863, Ornament low right concave stroke - outMap.emplace(std::make_pair( "ornamentLowRightConvexStroke", 0xE5A6 )); // glyphnumber: 1864, Ornament low right convex stroke - outMap.emplace(std::make_pair( "ornamentMiddleVerticalStroke", 0xE59F )); // glyphnumber: 1865, Ornament middle vertical stroke - outMap.emplace(std::make_pair( "ornamentMordent", 0xE56C )); // glyphnumber: 1866, Mordent - outMap.emplace(std::make_pair( "ornamentMordentInverted", 0xE56D )); // glyphnumber: 1867, Inverted mordent - outMap.emplace(std::make_pair( "ornamentObliqueLineAfterNote", 0xE57C )); // glyphnumber: 1868, Oblique straight line NW-SE - outMap.emplace(std::make_pair( "ornamentObliqueLineBeforeNote", 0xE57B )); // glyphnumber: 1869, Oblique straight line SW-NE - outMap.emplace(std::make_pair( "ornamentObliqueLineHorizAfterNote", 0xE580 )); // glyphnumber: 1870, Oblique straight line tilted NW-SE - outMap.emplace(std::make_pair( "ornamentObliqueLineHorizBeforeNote", 0xE57F )); // glyphnumber: 1871, Oblique straight line tilted SW-NE - outMap.emplace(std::make_pair( "ornamentOriscus", 0xEA21 )); // glyphnumber: 1872, Oriscus - outMap.emplace(std::make_pair( "ornamentPinceCouperin", 0xE588 )); // glyphnumber: 1873, Pincé (Couperin) - outMap.emplace(std::make_pair( "ornamentPortDeVoixV", 0xE570 )); // glyphnumber: 1874, Port de voix - outMap.emplace(std::make_pair( "ornamentPrecompAppoggTrill", 0xE5B2 )); // glyphnumber: 1875, Supported appoggiatura trill - outMap.emplace(std::make_pair( "ornamentPrecompAppoggTrillSuffix", 0xE5B3 )); // glyphnumber: 1876, Supported appoggiatura trill with two-note suffix - outMap.emplace(std::make_pair( "ornamentPrecompCadence", 0xE5BE )); // glyphnumber: 1877, Cadence - outMap.emplace(std::make_pair( "ornamentPrecompCadenceUpperPrefix", 0xE5C1 )); // glyphnumber: 1878, Cadence with upper prefix - outMap.emplace(std::make_pair( "ornamentPrecompCadenceUpperPrefixTurn", 0xE5C2 )); // glyphnumber: 1879, Cadence with upper prefix and turn - outMap.emplace(std::make_pair( "ornamentPrecompCadenceWithTurn", 0xE5BF )); // glyphnumber: 1880, Cadence with turn - outMap.emplace(std::make_pair( "ornamentPrecompDescendingSlide", 0xE5B1 )); // glyphnumber: 1881, Descending slide - outMap.emplace(std::make_pair( "ornamentPrecompDoubleCadenceLowerPrefix", 0xE5C0 )); // glyphnumber: 1882, Double cadence with lower prefix - outMap.emplace(std::make_pair( "ornamentPrecompDoubleCadenceUpperPrefix", 0xE5C3 )); // glyphnumber: 1883, Double cadence with upper prefix - outMap.emplace(std::make_pair( "ornamentPrecompDoubleCadenceUpperPrefixTurn", 0xE5C4 )); // glyphnumber: 1884, Double cadence with upper prefix and turn - outMap.emplace(std::make_pair( "ornamentPrecompInvertedMordentUpperPrefix", 0xE5C7 )); // glyphnumber: 1885, Inverted mordent with upper prefix - outMap.emplace(std::make_pair( "ornamentPrecompMordentRelease", 0xE5C5 )); // glyphnumber: 1886, Mordent with release - outMap.emplace(std::make_pair( "ornamentPrecompMordentUpperPrefix", 0xE5C6 )); // glyphnumber: 1887, Mordent with upper prefix - outMap.emplace(std::make_pair( "ornamentPrecompPortDeVoixMordent", 0xE5BC )); // glyphnumber: 1888, Pre-beat port de voix follwed by multiple mordent (Dandrieu) - outMap.emplace(std::make_pair( "ornamentPrecompSlide", 0xE5B0 )); // glyphnumber: 1889, Slide - outMap.emplace(std::make_pair( "ornamentPrecompSlideTrillBach", 0xE5B8 )); // glyphnumber: 1890, Slide-trill with two-note suffix (J.S. Bach) - outMap.emplace(std::make_pair( "ornamentPrecompSlideTrillDAnglebert", 0xE5B5 )); // glyphnumber: 1891, Slide-trill (D'Anglebert) - outMap.emplace(std::make_pair( "ornamentPrecompSlideTrillMarpurg", 0xE5B6 )); // glyphnumber: 1892, Slide-trill with one-note suffix (Marpurg) - outMap.emplace(std::make_pair( "ornamentPrecompSlideTrillMuffat", 0xE5B9 )); // glyphnumber: 1893, Slide-trill (Muffat) - outMap.emplace(std::make_pair( "ornamentPrecompSlideTrillSuffixMuffat", 0xE5BA )); // glyphnumber: 1894, Slide-trill with two-note suffix (Muffat) - outMap.emplace(std::make_pair( "ornamentPrecompTrillLowerSuffix", 0xE5C8 )); // glyphnumber: 1895, Trill with lower suffix - outMap.emplace(std::make_pair( "ornamentPrecompTrillSuffixDandrieu", 0xE5BB )); // glyphnumber: 1896, Trill with two-note suffix (Dandrieu) - outMap.emplace(std::make_pair( "ornamentPrecompTrillWithMordent", 0xE5BD )); // glyphnumber: 1897, Trill with mordent - outMap.emplace(std::make_pair( "ornamentPrecompTurnTrillBach", 0xE5B7 )); // glyphnumber: 1898, Turn-trill with two-note suffix (J.S. Bach) - outMap.emplace(std::make_pair( "ornamentPrecompTurnTrillDAnglebert", 0xE5B4 )); // glyphnumber: 1899, Turn-trill (D'Anglebert) - outMap.emplace(std::make_pair( "ornamentQuilisma", 0xEA20 )); // glyphnumber: 1900, Quilisma - outMap.emplace(std::make_pair( "ornamentRightFacingHalfCircle", 0xE571 )); // glyphnumber: 1901, Right-facing half circle - outMap.emplace(std::make_pair( "ornamentRightFacingHook", 0xE573 )); // glyphnumber: 1902, Right-facing hook - outMap.emplace(std::make_pair( "ornamentRightVerticalStroke", 0xE5A4 )); // glyphnumber: 1903, Ornament right vertical stroke - outMap.emplace(std::make_pair( "ornamentSchleifer", 0xE587 )); // glyphnumber: 1904, Schleifer (long mordent) - outMap.emplace(std::make_pair( "ornamentShake3", 0xE582 )); // glyphnumber: 1905, Shake - outMap.emplace(std::make_pair( "ornamentShakeMuffat1", 0xE584 )); // glyphnumber: 1906, Shake (Muffat) - outMap.emplace(std::make_pair( "ornamentShortObliqueLineAfterNote", 0xE57A )); // glyphnumber: 1907, Short oblique straight line NW-SE - outMap.emplace(std::make_pair( "ornamentShortObliqueLineBeforeNote", 0xE579 )); // glyphnumber: 1908, Short oblique straight line SW-NE - outMap.emplace(std::make_pair( "ornamentTopLeftConcaveStroke", 0xE590 )); // glyphnumber: 1909, Ornament top left concave stroke - outMap.emplace(std::make_pair( "ornamentTopLeftConvexStroke", 0xE591 )); // glyphnumber: 1910, Ornament top left convex stroke - outMap.emplace(std::make_pair( "ornamentTopRightConcaveStroke", 0xE5A0 )); // glyphnumber: 1911, Ornament top right concave stroke - outMap.emplace(std::make_pair( "ornamentTopRightConvexStroke", 0xE5A1 )); // glyphnumber: 1912, Ornament top right convex stroke - outMap.emplace(std::make_pair( "ornamentTremblement", 0xE56E )); // glyphnumber: 1913, Tremblement - outMap.emplace(std::make_pair( "ornamentTremblementCouperin", 0xE589 )); // glyphnumber: 1914, Tremblement appuyé (Couperin) - outMap.emplace(std::make_pair( "ornamentTrill", 0xE566 )); // glyphnumber: 1915, Trill - outMap.emplace(std::make_pair( "ornamentTurn", 0xE567 )); // glyphnumber: 1916, Turn - outMap.emplace(std::make_pair( "ornamentTurnInverted", 0xE568 )); // glyphnumber: 1917, Inverted turn - outMap.emplace(std::make_pair( "ornamentTurnSlash", 0xE569 )); // glyphnumber: 1918, Turn with slash - outMap.emplace(std::make_pair( "ornamentTurnUp", 0xE56A )); // glyphnumber: 1919, Turn up - outMap.emplace(std::make_pair( "ornamentTurnUpS", 0xE56B )); // glyphnumber: 1920, Inverted turn up - outMap.emplace(std::make_pair( "ornamentUpCurve", 0xE577 )); // glyphnumber: 1921, Curve above - outMap.emplace(std::make_pair( "ornamentVerticalLine", 0xE583 )); // glyphnumber: 1922, Vertical line - outMap.emplace(std::make_pair( "ornamentZigZagLineNoRightEnd", 0xE59D )); // glyphnumber: 1923, Ornament zig-zag line without right-hand end - outMap.emplace(std::make_pair( "ornamentZigZagLineWithRightEnd", 0xE59E )); // glyphnumber: 1924, Ornament zig-zag line with right-hand end - outMap.emplace(std::make_pair( "ottava", 0xE510 )); // glyphnumber: 1925, Ottava - outMap.emplace(std::make_pair( "ottavaAlta", 0xE511 )); // glyphnumber: 1926, Ottava alta - outMap.emplace(std::make_pair( "ottavaBassa", 0xE512 )); // glyphnumber: 1927, Ottava bassa - outMap.emplace(std::make_pair( "ottavaBassaBa", 0xE513 )); // glyphnumber: 1928, Ottava bassa (ba) - outMap.emplace(std::make_pair( "ottavaBassaVb", 0xE51C )); // glyphnumber: 1929, Ottava bassa (8vb) - outMap.emplace(std::make_pair( "pendereckiTremolo", 0xE22B )); // glyphnumber: 1930, Penderecki unmeasured tremolo - outMap.emplace(std::make_pair( "pictAgogo", 0xE717 )); // glyphnumber: 1931, Agogo - outMap.emplace(std::make_pair( "pictAlmglocken", 0xE712 )); // glyphnumber: 1932, Almglocken - outMap.emplace(std::make_pair( "pictAnvil", 0xE701 )); // glyphnumber: 1933, Anvil - outMap.emplace(std::make_pair( "pictBambooChimes", 0xE6C3 )); // glyphnumber: 1934, Bamboo tube chimes - outMap.emplace(std::make_pair( "pictBambooScraper", 0xE6FB )); // glyphnumber: 1935, Bamboo scraper - outMap.emplace(std::make_pair( "pictBassDrum", 0xE6D4 )); // glyphnumber: 1936, Bass drum - outMap.emplace(std::make_pair( "pictBassDrumOnSide", 0xE6D5 )); // glyphnumber: 1937, Bass drum on side - outMap.emplace(std::make_pair( "pictBeaterBow", 0xE7DE )); // glyphnumber: 1938, Bow - outMap.emplace(std::make_pair( "pictBeaterBox", 0xE7EB )); // glyphnumber: 1939, Box for percussion beater - outMap.emplace(std::make_pair( "pictBeaterBrassMalletsDown", 0xE7DA )); // glyphnumber: 1940, Brass mallets down - outMap.emplace(std::make_pair( "pictBeaterBrassMalletsUp", 0xE7D9 )); // glyphnumber: 1941, Brass mallets up - outMap.emplace(std::make_pair( "pictBeaterCombiningDashedCircle", 0xE7EA )); // glyphnumber: 1942, Combining dashed circle for round beaters (plated) - outMap.emplace(std::make_pair( "pictBeaterCombiningParentheses", 0xE7E9 )); // glyphnumber: 1943, Combining parentheses for round beaters (padded) - outMap.emplace(std::make_pair( "pictBeaterDoubleBassDrumDown", 0xE7A1 )); // glyphnumber: 1944, Double bass drum stick down - outMap.emplace(std::make_pair( "pictBeaterDoubleBassDrumUp", 0xE7A0 )); // glyphnumber: 1945, Double bass drum stick up - outMap.emplace(std::make_pair( "pictBeaterFinger", 0xE7E4 )); // glyphnumber: 1946, Finger - outMap.emplace(std::make_pair( "pictBeaterFingernails", 0xE7E6 )); // glyphnumber: 1947, Fingernails - outMap.emplace(std::make_pair( "pictBeaterFist", 0xE7E5 )); // glyphnumber: 1948, Fist - outMap.emplace(std::make_pair( "pictBeaterGuiroScraper", 0xE7DD )); // glyphnumber: 1949, Guiro scraper - outMap.emplace(std::make_pair( "pictBeaterHammer", 0xE7E1 )); // glyphnumber: 1950, Hammer - outMap.emplace(std::make_pair( "pictBeaterHammerMetalDown", 0xE7D0 )); // glyphnumber: 1951, Metal hammer, down - outMap.emplace(std::make_pair( "pictBeaterHammerMetalUp", 0xE7CF )); // glyphnumber: 1952, Metal hammer, up - outMap.emplace(std::make_pair( "pictBeaterHammerPlasticDown", 0xE7CE )); // glyphnumber: 1953, Plastic hammer, down - outMap.emplace(std::make_pair( "pictBeaterHammerPlasticUp", 0xE7CD )); // glyphnumber: 1954, Plastic hammer, up - outMap.emplace(std::make_pair( "pictBeaterHammerWoodDown", 0xE7CC )); // glyphnumber: 1955, Wooden hammer, down - outMap.emplace(std::make_pair( "pictBeaterHammerWoodUp", 0xE7CB )); // glyphnumber: 1956, Wooden hammer, up - outMap.emplace(std::make_pair( "pictBeaterHand", 0xE7E3 )); // glyphnumber: 1957, Hand - outMap.emplace(std::make_pair( "pictBeaterHardBassDrumDown", 0xE79D )); // glyphnumber: 1958, Hard bass drum stick down - outMap.emplace(std::make_pair( "pictBeaterHardBassDrumUp", 0xE79C )); // glyphnumber: 1959, Hard bass drum stick up - outMap.emplace(std::make_pair( "pictBeaterHardGlockenspielDown", 0xE785 )); // glyphnumber: 1960, Hard glockenspiel stick down - outMap.emplace(std::make_pair( "pictBeaterHardGlockenspielLeft", 0xE787 )); // glyphnumber: 1961, Hard glockenspiel stick left - outMap.emplace(std::make_pair( "pictBeaterHardGlockenspielRight", 0xE786 )); // glyphnumber: 1962, Hard glockenspiel stick right - outMap.emplace(std::make_pair( "pictBeaterHardGlockenspielUp", 0xE784 )); // glyphnumber: 1963, Hard glockenspiel stick up - outMap.emplace(std::make_pair( "pictBeaterHardTimpaniDown", 0xE791 )); // glyphnumber: 1964, Hard timpani stick down - outMap.emplace(std::make_pair( "pictBeaterHardTimpaniLeft", 0xE793 )); // glyphnumber: 1965, Hard timpani stick left - outMap.emplace(std::make_pair( "pictBeaterHardTimpaniRight", 0xE792 )); // glyphnumber: 1966, Hard timpani stick right - outMap.emplace(std::make_pair( "pictBeaterHardTimpaniUp", 0xE790 )); // glyphnumber: 1967, Hard timpani stick up - outMap.emplace(std::make_pair( "pictBeaterHardXylophoneDown", 0xE779 )); // glyphnumber: 1968, Hard xylophone stick down - outMap.emplace(std::make_pair( "pictBeaterHardXylophoneLeft", 0xE77B )); // glyphnumber: 1969, Hard xylophone stick left - outMap.emplace(std::make_pair( "pictBeaterHardXylophoneRight", 0xE77A )); // glyphnumber: 1970, Hard xylophone stick right - outMap.emplace(std::make_pair( "pictBeaterHardXylophoneUp", 0xE778 )); // glyphnumber: 1971, Hard xylophone stick up - outMap.emplace(std::make_pair( "pictBeaterHardYarnDown", 0xE7AB )); // glyphnumber: 1972, Hard yarn beater down - outMap.emplace(std::make_pair( "pictBeaterHardYarnLeft", 0xE7AD )); // glyphnumber: 1973, Hard yarn beater left - outMap.emplace(std::make_pair( "pictBeaterHardYarnRight", 0xE7AC )); // glyphnumber: 1974, Hard yarn beater right - outMap.emplace(std::make_pair( "pictBeaterHardYarnUp", 0xE7AA )); // glyphnumber: 1975, Hard yarn beater up - outMap.emplace(std::make_pair( "pictBeaterJazzSticksDown", 0xE7D4 )); // glyphnumber: 1976, Jazz sticks down - outMap.emplace(std::make_pair( "pictBeaterJazzSticksUp", 0xE7D3 )); // glyphnumber: 1977, Jazz sticks up - outMap.emplace(std::make_pair( "pictBeaterKnittingNeedle", 0xE7E2 )); // glyphnumber: 1978, Knitting needle - outMap.emplace(std::make_pair( "pictBeaterMallet", 0xE7DF )); // glyphnumber: 1979, Chime hammer - outMap.emplace(std::make_pair( "pictBeaterMediumBassDrumDown", 0xE79B )); // glyphnumber: 1980, Medium bass drum stick down - outMap.emplace(std::make_pair( "pictBeaterMediumBassDrumUp", 0xE79A )); // glyphnumber: 1981, Medium bass drum stick up - outMap.emplace(std::make_pair( "pictBeaterMediumTimpaniDown", 0xE78D )); // glyphnumber: 1982, Medium timpani stick down - outMap.emplace(std::make_pair( "pictBeaterMediumTimpaniLeft", 0xE78F )); // glyphnumber: 1983, Medium timpani stick left - outMap.emplace(std::make_pair( "pictBeaterMediumTimpaniRight", 0xE78E )); // glyphnumber: 1984, Medium timpani stick right - outMap.emplace(std::make_pair( "pictBeaterMediumTimpaniUp", 0xE78C )); // glyphnumber: 1985, Medium timpani stick up - outMap.emplace(std::make_pair( "pictBeaterMediumXylophoneDown", 0xE775 )); // glyphnumber: 1986, Medium xylophone stick down - outMap.emplace(std::make_pair( "pictBeaterMediumXylophoneLeft", 0xE777 )); // glyphnumber: 1987, Medium xylophone stick left - outMap.emplace(std::make_pair( "pictBeaterMediumXylophoneRight", 0xE776 )); // glyphnumber: 1988, Medium xylophone stick right - outMap.emplace(std::make_pair( "pictBeaterMediumXylophoneUp", 0xE774 )); // glyphnumber: 1989, Medium xylophone stick up - outMap.emplace(std::make_pair( "pictBeaterMediumYarnDown", 0xE7A7 )); // glyphnumber: 1990, Medium yarn beater down - outMap.emplace(std::make_pair( "pictBeaterMediumYarnLeft", 0xE7A9 )); // glyphnumber: 1991, Medium yarn beater left - outMap.emplace(std::make_pair( "pictBeaterMediumYarnRight", 0xE7A8 )); // glyphnumber: 1992, Medium yarn beater right - outMap.emplace(std::make_pair( "pictBeaterMediumYarnUp", 0xE7A6 )); // glyphnumber: 1993, Medium yarn beater up - outMap.emplace(std::make_pair( "pictBeaterMetalBassDrumDown", 0xE79F )); // glyphnumber: 1994, Metal bass drum stick down - outMap.emplace(std::make_pair( "pictBeaterMetalBassDrumUp", 0xE79E )); // glyphnumber: 1995, Metal bass drum stick up - outMap.emplace(std::make_pair( "pictBeaterMetalDown", 0xE7C8 )); // glyphnumber: 1996, Metal beater down - outMap.emplace(std::make_pair( "pictBeaterMetalHammer", 0xE7E0 )); // glyphnumber: 1997, Metal hammer - outMap.emplace(std::make_pair( "pictBeaterMetalLeft", 0xE7CA )); // glyphnumber: 1998, Metal beater, left - outMap.emplace(std::make_pair( "pictBeaterMetalRight", 0xE7C9 )); // glyphnumber: 1999, Metal beater, right - outMap.emplace(std::make_pair( "pictBeaterMetalUp", 0xE7C7 )); // glyphnumber: 2000, Metal beater, up - outMap.emplace(std::make_pair( "pictBeaterSnareSticksDown", 0xE7D2 )); // glyphnumber: 2001, Snare sticks down - outMap.emplace(std::make_pair( "pictBeaterSnareSticksUp", 0xE7D1 )); // glyphnumber: 2002, Snare sticks up - outMap.emplace(std::make_pair( "pictBeaterSoftBassDrumDown", 0xE799 )); // glyphnumber: 2003, Soft bass drum stick down - outMap.emplace(std::make_pair( "pictBeaterSoftBassDrumUp", 0xE798 )); // glyphnumber: 2004, Soft bass drum stick up - outMap.emplace(std::make_pair( "pictBeaterSoftGlockenspielDown", 0xE781 )); // glyphnumber: 2005, Soft glockenspiel stick down - outMap.emplace(std::make_pair( "pictBeaterSoftGlockenspielLeft", 0xE783 )); // glyphnumber: 2006, Soft glockenspiel stick left - outMap.emplace(std::make_pair( "pictBeaterSoftGlockenspielRight", 0xE782 )); // glyphnumber: 2007, Soft glockenspiel stick right - outMap.emplace(std::make_pair( "pictBeaterSoftGlockenspielUp", 0xE780 )); // glyphnumber: 2008, Soft glockenspiel stick up - outMap.emplace(std::make_pair( "pictBeaterSoftTimpaniDown", 0xE789 )); // glyphnumber: 2009, Soft timpani stick down - outMap.emplace(std::make_pair( "pictBeaterSoftTimpaniLeft", 0xE78B )); // glyphnumber: 2010, Soft timpani stick left - outMap.emplace(std::make_pair( "pictBeaterSoftTimpaniRight", 0xE78A )); // glyphnumber: 2011, Soft timpani stick right - outMap.emplace(std::make_pair( "pictBeaterSoftTimpaniUp", 0xE788 )); // glyphnumber: 2012, Soft timpani stick up - outMap.emplace(std::make_pair( "pictBeaterSoftXylophone", 0xE7DB )); // glyphnumber: 2013, Soft xylophone beaters - outMap.emplace(std::make_pair( "pictBeaterSoftXylophoneDown", 0xE771 )); // glyphnumber: 2014, Soft xylophone stick down - outMap.emplace(std::make_pair( "pictBeaterSoftXylophoneLeft", 0xE773 )); // glyphnumber: 2015, Soft xylophone stick left - outMap.emplace(std::make_pair( "pictBeaterSoftXylophoneRight", 0xE772 )); // glyphnumber: 2016, Soft xylophone stick right - outMap.emplace(std::make_pair( "pictBeaterSoftXylophoneUp", 0xE770 )); // glyphnumber: 2017, Soft xylophone stick up - outMap.emplace(std::make_pair( "pictBeaterSoftYarnDown", 0xE7A3 )); // glyphnumber: 2018, Soft yarn beater down - outMap.emplace(std::make_pair( "pictBeaterSoftYarnLeft", 0xE7A5 )); // glyphnumber: 2019, Soft yarn beater left - outMap.emplace(std::make_pair( "pictBeaterSoftYarnRight", 0xE7A4 )); // glyphnumber: 2020, Soft yarn beater right - outMap.emplace(std::make_pair( "pictBeaterSoftYarnUp", 0xE7A2 )); // glyphnumber: 2021, Soft yarn beater up - outMap.emplace(std::make_pair( "pictBeaterSpoonWoodenMallet", 0xE7DC )); // glyphnumber: 2022, Spoon-shaped wooden mallet - outMap.emplace(std::make_pair( "pictBeaterSuperballDown", 0xE7AF )); // glyphnumber: 2023, Superball beater down - outMap.emplace(std::make_pair( "pictBeaterSuperballLeft", 0xE7B1 )); // glyphnumber: 2024, Superball beater left - outMap.emplace(std::make_pair( "pictBeaterSuperballRight", 0xE7B0 )); // glyphnumber: 2025, Superball beater right - outMap.emplace(std::make_pair( "pictBeaterSuperballUp", 0xE7AE )); // glyphnumber: 2026, Superball beater up - outMap.emplace(std::make_pair( "pictBeaterTriangleDown", 0xE7D6 )); // glyphnumber: 2027, Triangle beater down - outMap.emplace(std::make_pair( "pictBeaterTriangleUp", 0xE7D5 )); // glyphnumber: 2028, Triangle beater up - outMap.emplace(std::make_pair( "pictBeaterWireBrushesDown", 0xE7D8 )); // glyphnumber: 2029, Wire brushes down - outMap.emplace(std::make_pair( "pictBeaterWireBrushesUp", 0xE7D7 )); // glyphnumber: 2030, Wire brushes up - outMap.emplace(std::make_pair( "pictBeaterWoodTimpaniDown", 0xE795 )); // glyphnumber: 2031, Wood timpani stick down - outMap.emplace(std::make_pair( "pictBeaterWoodTimpaniLeft", 0xE797 )); // glyphnumber: 2032, Wood timpani stick left - outMap.emplace(std::make_pair( "pictBeaterWoodTimpaniRight", 0xE796 )); // glyphnumber: 2033, Wood timpani stick right - outMap.emplace(std::make_pair( "pictBeaterWoodTimpaniUp", 0xE794 )); // glyphnumber: 2034, Wood timpani stick up - outMap.emplace(std::make_pair( "pictBeaterWoodXylophoneDown", 0xE77D )); // glyphnumber: 2035, Wood xylophone stick down - outMap.emplace(std::make_pair( "pictBeaterWoodXylophoneLeft", 0xE77F )); // glyphnumber: 2036, Wood xylophone stick left - outMap.emplace(std::make_pair( "pictBeaterWoodXylophoneRight", 0xE77E )); // glyphnumber: 2037, Wood xylophone stick right - outMap.emplace(std::make_pair( "pictBeaterWoodXylophoneUp", 0xE77C )); // glyphnumber: 2038, Wood xylophone stick up - outMap.emplace(std::make_pair( "pictBell", 0xE714 )); // glyphnumber: 2039, Bell - outMap.emplace(std::make_pair( "pictBellOfCymbal", 0xE72A )); // glyphnumber: 2040, Bell of cymbal - outMap.emplace(std::make_pair( "pictBellPlate", 0xE713 )); // glyphnumber: 2041, Bell plate - outMap.emplace(std::make_pair( "pictBellTree", 0xE71A )); // glyphnumber: 2042, Bell tree - outMap.emplace(std::make_pair( "pictBirdWhistle", 0xE751 )); // glyphnumber: 2043, Bird whistle - outMap.emplace(std::make_pair( "pictBoardClapper", 0xE6F7 )); // glyphnumber: 2044, Board clapper - outMap.emplace(std::make_pair( "pictBongos", 0xE6DD )); // glyphnumber: 2045, Bongos - outMap.emplace(std::make_pair( "pictBrakeDrum", 0xE6E1 )); // glyphnumber: 2046, Brake drum - outMap.emplace(std::make_pair( "pictCabasa", 0xE743 )); // glyphnumber: 2047, Cabasa - outMap.emplace(std::make_pair( "pictCannon", 0xE761 )); // glyphnumber: 2048, Cannon - outMap.emplace(std::make_pair( "pictCarHorn", 0xE755 )); // glyphnumber: 2049, Car horn - outMap.emplace(std::make_pair( "pictCastanets", 0xE6F8 )); // glyphnumber: 2050, Castanets - outMap.emplace(std::make_pair( "pictCastanetsWithHandle", 0xE6F9 )); // glyphnumber: 2051, Castanets with handle - outMap.emplace(std::make_pair( "pictCelesta", 0xE6B0 )); // glyphnumber: 2052, Celesta - outMap.emplace(std::make_pair( "pictCencerro", 0xE716 )); // glyphnumber: 2053, Cencerro - outMap.emplace(std::make_pair( "pictCenter1", 0xE7FE )); // glyphnumber: 2054, Center (Weinberg) - outMap.emplace(std::make_pair( "pictCenter2", 0xE7FF )); // glyphnumber: 2055, Center (Ghent) - outMap.emplace(std::make_pair( "pictCenter3", 0xE800 )); // glyphnumber: 2056, Center (Caltabiano) - outMap.emplace(std::make_pair( "pictChainRattle", 0xE748 )); // glyphnumber: 2057, Chain rattle - outMap.emplace(std::make_pair( "pictChimes", 0xE6C2 )); // glyphnumber: 2058, Chimes - outMap.emplace(std::make_pair( "pictChineseCymbal", 0xE726 )); // glyphnumber: 2059, Chinese cymbal - outMap.emplace(std::make_pair( "pictChokeCymbal", 0xE805 )); // glyphnumber: 2060, Choke (Weinberg) - outMap.emplace(std::make_pair( "pictClaves", 0xE6F2 )); // glyphnumber: 2061, Claves - outMap.emplace(std::make_pair( "pictCoins", 0xE7E7 )); // glyphnumber: 2062, Coins - outMap.emplace(std::make_pair( "pictConga", 0xE6DE )); // glyphnumber: 2063, Conga - outMap.emplace(std::make_pair( "pictCowBell", 0xE711 )); // glyphnumber: 2064, Cow bell - outMap.emplace(std::make_pair( "pictCrashCymbals", 0xE720 )); // glyphnumber: 2065, Crash cymbals - outMap.emplace(std::make_pair( "pictCrotales", 0xE6AE )); // glyphnumber: 2066, Crotales - outMap.emplace(std::make_pair( "pictCrushStem", 0xE80C )); // glyphnumber: 2067, Combining crush for stem - outMap.emplace(std::make_pair( "pictCuica", 0xE6E4 )); // glyphnumber: 2068, Cuica - outMap.emplace(std::make_pair( "pictCymbalTongs", 0xE728 )); // glyphnumber: 2069, Cymbal tongs - outMap.emplace(std::make_pair( "pictDamp1", 0xE7F9 )); // glyphnumber: 2070, Damp - outMap.emplace(std::make_pair( "pictDamp2", 0xE7FA )); // glyphnumber: 2071, Damp 2 - outMap.emplace(std::make_pair( "pictDamp3", 0xE7FB )); // glyphnumber: 2072, Damp 3 - outMap.emplace(std::make_pair( "pictDamp4", 0xE7FC )); // glyphnumber: 2073, Damp 4 - outMap.emplace(std::make_pair( "pictDeadNoteStem", 0xE80D )); // glyphnumber: 2074, Combining X for stem (dead note) - outMap.emplace(std::make_pair( "pictDrumStick", 0xE7E8 )); // glyphnumber: 2075, Drum stick - outMap.emplace(std::make_pair( "pictDuckCall", 0xE757 )); // glyphnumber: 2076, Duck call - outMap.emplace(std::make_pair( "pictEdgeOfCymbal", 0xE729 )); // glyphnumber: 2077, Edge of cymbal - outMap.emplace(std::make_pair( "pictEmptyTrap", 0xE6A9 )); // glyphnumber: 2078, Empty trapezoid - outMap.emplace(std::make_pair( "pictFingerCymbals", 0xE727 )); // glyphnumber: 2079, Finger cymbals - outMap.emplace(std::make_pair( "pictFlexatone", 0xE740 )); // glyphnumber: 2080, Flexatone - outMap.emplace(std::make_pair( "pictFootballRatchet", 0xE6F5 )); // glyphnumber: 2081, Football rattle - outMap.emplace(std::make_pair( "pictGlassHarmonica", 0xE765 )); // glyphnumber: 2082, Glass harmonica - outMap.emplace(std::make_pair( "pictGlassHarp", 0xE764 )); // glyphnumber: 2083, Glass harp - outMap.emplace(std::make_pair( "pictGlassPlateChimes", 0xE6C6 )); // glyphnumber: 2084, Glass plate chimes - outMap.emplace(std::make_pair( "pictGlassTubeChimes", 0xE6C5 )); // glyphnumber: 2085, Glass tube chimes - outMap.emplace(std::make_pair( "pictGlsp", 0xE6A0 )); // glyphnumber: 2086, Glockenspiel - outMap.emplace(std::make_pair( "pictGlspSmithBrindle", 0xE6AA )); // glyphnumber: 2087, Glockenspiel (Smith Brindle) - outMap.emplace(std::make_pair( "pictGobletDrum", 0xE6E2 )); // glyphnumber: 2088, Goblet drum (djembe, dumbek) - outMap.emplace(std::make_pair( "pictGong", 0xE732 )); // glyphnumber: 2089, Gong - outMap.emplace(std::make_pair( "pictGongWithButton", 0xE733 )); // glyphnumber: 2090, Gong with button (nipple) - outMap.emplace(std::make_pair( "pictGuiro", 0xE6F3 )); // glyphnumber: 2091, Guiro - outMap.emplace(std::make_pair( "pictGumHardDown", 0xE7C4 )); // glyphnumber: 2092, Hard gum beater, down - outMap.emplace(std::make_pair( "pictGumHardLeft", 0xE7C6 )); // glyphnumber: 2093, Hard gum beater, left - outMap.emplace(std::make_pair( "pictGumHardRight", 0xE7C5 )); // glyphnumber: 2094, Hard gum beater, right - outMap.emplace(std::make_pair( "pictGumHardUp", 0xE7C3 )); // glyphnumber: 2095, Hard gum beater, up - outMap.emplace(std::make_pair( "pictGumMediumDown", 0xE7C0 )); // glyphnumber: 2096, Medium gum beater, down - outMap.emplace(std::make_pair( "pictGumMediumLeft", 0xE7C2 )); // glyphnumber: 2097, Medium gum beater, left - outMap.emplace(std::make_pair( "pictGumMediumRight", 0xE7C1 )); // glyphnumber: 2098, Medium gum beater, right - outMap.emplace(std::make_pair( "pictGumMediumUp", 0xE7BF )); // glyphnumber: 2099, Medium gum beater, up - outMap.emplace(std::make_pair( "pictGumSoftDown", 0xE7BC )); // glyphnumber: 2100, Soft gum beater, down - outMap.emplace(std::make_pair( "pictGumSoftLeft", 0xE7BE )); // glyphnumber: 2101, Soft gum beater, left - outMap.emplace(std::make_pair( "pictGumSoftRight", 0xE7BD )); // glyphnumber: 2102, Soft gum beater, right - outMap.emplace(std::make_pair( "pictGumSoftUp", 0xE7BB )); // glyphnumber: 2103, Soft gum beater, up - outMap.emplace(std::make_pair( "pictHalfOpen1", 0xE7F6 )); // glyphnumber: 2104, Half-open - outMap.emplace(std::make_pair( "pictHalfOpen2", 0xE7F7 )); // glyphnumber: 2105, Half-open 2 (Weinberg) - outMap.emplace(std::make_pair( "pictHandbell", 0xE715 )); // glyphnumber: 2106, Handbell - outMap.emplace(std::make_pair( "pictHiHat", 0xE722 )); // glyphnumber: 2107, Hi-hat - outMap.emplace(std::make_pair( "pictHiHatOnStand", 0xE723 )); // glyphnumber: 2108, Hi-hat cymbals on stand - outMap.emplace(std::make_pair( "pictJawHarp", 0xE767 )); // glyphnumber: 2109, Jaw harp - outMap.emplace(std::make_pair( "pictJingleBells", 0xE719 )); // glyphnumber: 2110, Jingle bells - outMap.emplace(std::make_pair( "pictKlaxonHorn", 0xE756 )); // glyphnumber: 2111, Klaxon horn - outMap.emplace(std::make_pair( "pictLeftHandCircle", 0xE807 )); // glyphnumber: 2112, Right hand (Agostini) - outMap.emplace(std::make_pair( "pictLionsRoar", 0xE763 )); // glyphnumber: 2113, Lion's roar - outMap.emplace(std::make_pair( "pictLithophone", 0xE6B1 )); // glyphnumber: 2114, Lithophone - outMap.emplace(std::make_pair( "pictLogDrum", 0xE6DF )); // glyphnumber: 2115, Log drum - outMap.emplace(std::make_pair( "pictLotusFlute", 0xE75A )); // glyphnumber: 2116, Lotus flute - outMap.emplace(std::make_pair( "pictMar", 0xE6A6 )); // glyphnumber: 2117, Marimba - outMap.emplace(std::make_pair( "pictMarSmithBrindle", 0xE6AC )); // glyphnumber: 2118, Marimba (Smith Brindle) - outMap.emplace(std::make_pair( "pictMaraca", 0xE741 )); // glyphnumber: 2119, Maraca - outMap.emplace(std::make_pair( "pictMaracas", 0xE742 )); // glyphnumber: 2120, Maracas - outMap.emplace(std::make_pair( "pictMegaphone", 0xE759 )); // glyphnumber: 2121, Megaphone - outMap.emplace(std::make_pair( "pictMetalPlateChimes", 0xE6C8 )); // glyphnumber: 2122, Metal plate chimes - outMap.emplace(std::make_pair( "pictMetalTubeChimes", 0xE6C7 )); // glyphnumber: 2123, Metal tube chimes - outMap.emplace(std::make_pair( "pictMusicalSaw", 0xE766 )); // glyphnumber: 2124, Musical saw - outMap.emplace(std::make_pair( "pictNormalPosition", 0xE804 )); // glyphnumber: 2125, Normal position (Caltabiano) - outMap.emplace(std::make_pair( "pictOnRim", 0xE7F4 )); // glyphnumber: 2126, On rim - outMap.emplace(std::make_pair( "pictOpen", 0xE7F8 )); // glyphnumber: 2127, Open - outMap.emplace(std::make_pair( "pictOpenRimShot", 0xE7F5 )); // glyphnumber: 2128, Closed / rim shot - outMap.emplace(std::make_pair( "pictPistolShot", 0xE760 )); // glyphnumber: 2129, Pistol shot - outMap.emplace(std::make_pair( "pictPoliceWhistle", 0xE752 )); // glyphnumber: 2130, Police whistle - outMap.emplace(std::make_pair( "pictQuijada", 0xE6FA )); // glyphnumber: 2131, Quijada (jawbone) - outMap.emplace(std::make_pair( "pictRainstick", 0xE747 )); // glyphnumber: 2132, Rainstick - outMap.emplace(std::make_pair( "pictRatchet", 0xE6F4 )); // glyphnumber: 2133, Ratchet - outMap.emplace(std::make_pair( "pictRecoReco", 0xE6FC )); // glyphnumber: 2134, Reco-reco - outMap.emplace(std::make_pair( "pictRightHandSquare", 0xE806 )); // glyphnumber: 2135, Left hand (Agostini) - outMap.emplace(std::make_pair( "pictRim1", 0xE801 )); // glyphnumber: 2136, Rim or edge (Weinberg) - outMap.emplace(std::make_pair( "pictRim2", 0xE802 )); // glyphnumber: 2137, Rim (Ghent) - outMap.emplace(std::make_pair( "pictRim3", 0xE803 )); // glyphnumber: 2138, Rim (Caltabiano) - outMap.emplace(std::make_pair( "pictRimShotOnStem", 0xE7FD )); // glyphnumber: 2139, Rim shot for stem - outMap.emplace(std::make_pair( "pictSandpaperBlocks", 0xE762 )); // glyphnumber: 2140, Sandpaper blocks - outMap.emplace(std::make_pair( "pictScrapeAroundRim", 0xE7F3 )); // glyphnumber: 2141, Scrape around rim (counter-clockwise) - outMap.emplace(std::make_pair( "pictScrapeAroundRimClockwise", 0xE80E )); // glyphnumber: 2142, Scrape around rim (clockwise) - outMap.emplace(std::make_pair( "pictScrapeCenterToEdge", 0xE7F1 )); // glyphnumber: 2143, Scrape from center to edge - outMap.emplace(std::make_pair( "pictScrapeEdgeToCenter", 0xE7F2 )); // glyphnumber: 2144, Scrape from edge to center - outMap.emplace(std::make_pair( "pictShellBells", 0xE718 )); // glyphnumber: 2145, Shell bells - outMap.emplace(std::make_pair( "pictShellChimes", 0xE6C4 )); // glyphnumber: 2146, Shell chimes - outMap.emplace(std::make_pair( "pictSiren", 0xE753 )); // glyphnumber: 2147, Siren - outMap.emplace(std::make_pair( "pictSistrum", 0xE746 )); // glyphnumber: 2148, Sistrum - outMap.emplace(std::make_pair( "pictSizzleCymbal", 0xE724 )); // glyphnumber: 2149, Sizzle cymbal - outMap.emplace(std::make_pair( "pictSleighBell", 0xE710 )); // glyphnumber: 2150, Sleigh bell - outMap.emplace(std::make_pair( "pictSlideBrushOnGong", 0xE734 )); // glyphnumber: 2151, Slide brush on gong - outMap.emplace(std::make_pair( "pictSlideWhistle", 0xE750 )); // glyphnumber: 2152, Slide whistle - outMap.emplace(std::make_pair( "pictSlitDrum", 0xE6E0 )); // glyphnumber: 2153, Slit drum - outMap.emplace(std::make_pair( "pictSnareDrum", 0xE6D1 )); // glyphnumber: 2154, Snare drum - outMap.emplace(std::make_pair( "pictSnareDrumMilitary", 0xE6D3 )); // glyphnumber: 2155, Military snare drum - outMap.emplace(std::make_pair( "pictSnareDrumSnaresOff", 0xE6D2 )); // glyphnumber: 2156, Snare drum, snares off - outMap.emplace(std::make_pair( "pictSteelDrums", 0xE6AF )); // glyphnumber: 2157, Steel drums - outMap.emplace(std::make_pair( "pictStickShot", 0xE7F0 )); // glyphnumber: 2158, Stick shot - outMap.emplace(std::make_pair( "pictSuperball", 0xE7B2 )); // glyphnumber: 2159, Superball - outMap.emplace(std::make_pair( "pictSuspendedCymbal", 0xE721 )); // glyphnumber: 2160, Suspended cymbal - outMap.emplace(std::make_pair( "pictSwishStem", 0xE808 )); // glyphnumber: 2161, Combining swish for stem - outMap.emplace(std::make_pair( "pictTabla", 0xE6E3 )); // glyphnumber: 2162, Indian tabla - outMap.emplace(std::make_pair( "pictTamTam", 0xE730 )); // glyphnumber: 2163, Tam-tam - outMap.emplace(std::make_pair( "pictTamTamWithBeater", 0xE731 )); // glyphnumber: 2164, Tam-tam with beater (Smith Brindle) - outMap.emplace(std::make_pair( "pictTambourine", 0xE6DB )); // glyphnumber: 2165, Tambourine - outMap.emplace(std::make_pair( "pictTempleBlocks", 0xE6F1 )); // glyphnumber: 2166, Temple blocks - outMap.emplace(std::make_pair( "pictTenorDrum", 0xE6D6 )); // glyphnumber: 2167, Tenor drum - outMap.emplace(std::make_pair( "pictThundersheet", 0xE744 )); // glyphnumber: 2168, Thundersheet - outMap.emplace(std::make_pair( "pictTimbales", 0xE6DC )); // glyphnumber: 2169, Timbales - outMap.emplace(std::make_pair( "pictTimpani", 0xE6D0 )); // glyphnumber: 2170, Timpani - outMap.emplace(std::make_pair( "pictTomTom", 0xE6D7 )); // glyphnumber: 2171, Tom-tom - outMap.emplace(std::make_pair( "pictTomTomChinese", 0xE6D8 )); // glyphnumber: 2172, Chinese tom-tom - outMap.emplace(std::make_pair( "pictTomTomIndoAmerican", 0xE6DA )); // glyphnumber: 2173, Indo-American tom tom - outMap.emplace(std::make_pair( "pictTomTomJapanese", 0xE6D9 )); // glyphnumber: 2174, Japanese tom-tom - outMap.emplace(std::make_pair( "pictTriangle", 0xE700 )); // glyphnumber: 2175, Triangle - outMap.emplace(std::make_pair( "pictTubaphone", 0xE6B2 )); // glyphnumber: 2176, Tubaphone - outMap.emplace(std::make_pair( "pictTubularBells", 0xE6C0 )); // glyphnumber: 2177, Tubular bells - outMap.emplace(std::make_pair( "pictTurnLeftStem", 0xE80A )); // glyphnumber: 2178, Combining turn left for stem - outMap.emplace(std::make_pair( "pictTurnRightLeftStem", 0xE80B )); // glyphnumber: 2179, Combining turn left or right for stem - outMap.emplace(std::make_pair( "pictTurnRightStem", 0xE809 )); // glyphnumber: 2180, Combining turn right for stem - outMap.emplace(std::make_pair( "pictVib", 0xE6A7 )); // glyphnumber: 2181, Vibraphone - outMap.emplace(std::make_pair( "pictVibMotorOff", 0xE6A8 )); // glyphnumber: 2182, Metallophone (vibraphone motor off) - outMap.emplace(std::make_pair( "pictVibSmithBrindle", 0xE6AD )); // glyphnumber: 2183, Vibraphone (Smith Brindle) - outMap.emplace(std::make_pair( "pictVibraslap", 0xE745 )); // glyphnumber: 2184, Vibraslap - outMap.emplace(std::make_pair( "pictVietnameseHat", 0xE725 )); // glyphnumber: 2185, Vietnamese hat cymbal - outMap.emplace(std::make_pair( "pictWhip", 0xE6F6 )); // glyphnumber: 2186, Whip - outMap.emplace(std::make_pair( "pictWindChimesGlass", 0xE6C1 )); // glyphnumber: 2187, Wind chimes (glass) - outMap.emplace(std::make_pair( "pictWindMachine", 0xE754 )); // glyphnumber: 2188, Wind machine - outMap.emplace(std::make_pair( "pictWindWhistle", 0xE758 )); // glyphnumber: 2189, Wind whistle (or mouth siren) - outMap.emplace(std::make_pair( "pictWoodBlock", 0xE6F0 )); // glyphnumber: 2190, Wood block - outMap.emplace(std::make_pair( "pictWoundHardDown", 0xE7B4 )); // glyphnumber: 2191, Wound beater, hard core down - outMap.emplace(std::make_pair( "pictWoundHardLeft", 0xE7B6 )); // glyphnumber: 2192, Wound beater, hard core left - outMap.emplace(std::make_pair( "pictWoundHardRight", 0xE7B5 )); // glyphnumber: 2193, Wound beater, hard core right - outMap.emplace(std::make_pair( "pictWoundHardUp", 0xE7B3 )); // glyphnumber: 2194, Wound beater, hard core up - outMap.emplace(std::make_pair( "pictWoundSoftDown", 0xE7B8 )); // glyphnumber: 2195, Wound beater, soft core down - outMap.emplace(std::make_pair( "pictWoundSoftLeft", 0xE7BA )); // glyphnumber: 2196, Wound beater, soft core left - outMap.emplace(std::make_pair( "pictWoundSoftRight", 0xE7B9 )); // glyphnumber: 2197, Wound beater, soft core right - outMap.emplace(std::make_pair( "pictWoundSoftUp", 0xE7B7 )); // glyphnumber: 2198, Wound beater, soft core up - outMap.emplace(std::make_pair( "pictXyl", 0xE6A1 )); // glyphnumber: 2199, Xylophone - outMap.emplace(std::make_pair( "pictXylBass", 0xE6A3 )); // glyphnumber: 2200, Bass xylophone - outMap.emplace(std::make_pair( "pictXylSmithBrindle", 0xE6AB )); // glyphnumber: 2201, Xylophone (Smith Brindle) - outMap.emplace(std::make_pair( "pictXylTenor", 0xE6A2 )); // glyphnumber: 2202, Tenor xylophone - outMap.emplace(std::make_pair( "pictXylTenorTrough", 0xE6A5 )); // glyphnumber: 2203, Trough tenor xylophone - outMap.emplace(std::make_pair( "pictXylTrough", 0xE6A4 )); // glyphnumber: 2204, Trough xylophone - outMap.emplace(std::make_pair( "pluckedBuzzPizzicato", 0xE632 )); // glyphnumber: 2205, Buzz pizzicato - outMap.emplace(std::make_pair( "pluckedDamp", 0xE638 )); // glyphnumber: 2206, Damp - outMap.emplace(std::make_pair( "pluckedDampAll", 0xE639 )); // glyphnumber: 2207, Damp all - outMap.emplace(std::make_pair( "pluckedDampOnStem", 0xE63B )); // glyphnumber: 2208, Damp for stem - outMap.emplace(std::make_pair( "pluckedFingernailFlick", 0xE637 )); // glyphnumber: 2209, Fingernail flick - outMap.emplace(std::make_pair( "pluckedLeftHandPizzicato", 0xE633 )); // glyphnumber: 2210, Left-hand pizzicato - outMap.emplace(std::make_pair( "pluckedPlectrum", 0xE63A )); // glyphnumber: 2211, Plectrum - outMap.emplace(std::make_pair( "pluckedSnapPizzicatoAbove", 0xE631 )); // glyphnumber: 2212, Snap pizzicato above - outMap.emplace(std::make_pair( "pluckedSnapPizzicatoBelow", 0xE630 )); // glyphnumber: 2213, Snap pizzicato below - outMap.emplace(std::make_pair( "pluckedWithFingernails", 0xE636 )); // glyphnumber: 2214, With fingernails - outMap.emplace(std::make_pair( "quindicesima", 0xE514 )); // glyphnumber: 2215, Quindicesima - outMap.emplace(std::make_pair( "quindicesimaAlta", 0xE515 )); // glyphnumber: 2216, Quindicesima alta - outMap.emplace(std::make_pair( "quindicesimaBassa", 0xE516 )); // glyphnumber: 2217, Quindicesima bassa - outMap.emplace(std::make_pair( "quindicesimaBassaMb", 0xE51D )); // glyphnumber: 2218, Quindicesima bassa (mb) - outMap.emplace(std::make_pair( "repeat1Bar", 0xE500 )); // glyphnumber: 2219, Repeat last bar - outMap.emplace(std::make_pair( "repeat2Bars", 0xE501 )); // glyphnumber: 2220, Repeat last two bars - outMap.emplace(std::make_pair( "repeat4Bars", 0xE502 )); // glyphnumber: 2221, Repeat last four bars - outMap.emplace(std::make_pair( "repeatDot", 0xE044 )); // glyphnumber: 2222, Single repeat dot - outMap.emplace(std::make_pair( "repeatDots", 0xE043 )); // glyphnumber: 2223, Repeat dots - outMap.emplace(std::make_pair( "repeatLeft", 0xE040 )); // glyphnumber: 2224, Left (start) repeat sign - outMap.emplace(std::make_pair( "repeatRight", 0xE041 )); // glyphnumber: 2225, Right (end) repeat sign - outMap.emplace(std::make_pair( "repeatRightLeft", 0xE042 )); // glyphnumber: 2226, Right and left repeat sign - outMap.emplace(std::make_pair( "rest1024th", 0xE4ED )); // glyphnumber: 2227, 1024th rest - outMap.emplace(std::make_pair( "rest128th", 0xE4EA )); // glyphnumber: 2228, 128th (semihemidemisemiquaver) rest - outMap.emplace(std::make_pair( "rest16th", 0xE4E7 )); // glyphnumber: 2229, 16th (semiquaver) rest - outMap.emplace(std::make_pair( "rest256th", 0xE4EB )); // glyphnumber: 2230, 256th rest - outMap.emplace(std::make_pair( "rest32nd", 0xE4E8 )); // glyphnumber: 2231, 32nd (demisemiquaver) rest - outMap.emplace(std::make_pair( "rest512th", 0xE4EC )); // glyphnumber: 2232, 512th rest - outMap.emplace(std::make_pair( "rest64th", 0xE4E9 )); // glyphnumber: 2233, 64th (hemidemisemiquaver) rest - outMap.emplace(std::make_pair( "rest8th", 0xE4E6 )); // glyphnumber: 2234, Eighth (quaver) rest - outMap.emplace(std::make_pair( "restDoubleWhole", 0xE4E2 )); // glyphnumber: 2235, Double whole (breve) rest - outMap.emplace(std::make_pair( "restDoubleWholeLegerLine", 0xE4F3 )); // glyphnumber: 2236, Double whole rest on leger lines - outMap.emplace(std::make_pair( "restHBar", 0xE4EE )); // glyphnumber: 2237, Multiple measure rest - outMap.emplace(std::make_pair( "restHBarLeft", 0xE4EF )); // glyphnumber: 2238, H-bar, left half - outMap.emplace(std::make_pair( "restHBarMiddle", 0xE4F0 )); // glyphnumber: 2239, H-bar, middle - outMap.emplace(std::make_pair( "restHBarRight", 0xE4F1 )); // glyphnumber: 2240, H-bar, right half - outMap.emplace(std::make_pair( "restHalf", 0xE4E4 )); // glyphnumber: 2241, Half (minim) rest - outMap.emplace(std::make_pair( "restHalfLegerLine", 0xE4F5 )); // glyphnumber: 2242, Half rest on leger line - outMap.emplace(std::make_pair( "restLonga", 0xE4E1 )); // glyphnumber: 2243, Longa rest - outMap.emplace(std::make_pair( "restMaxima", 0xE4E0 )); // glyphnumber: 2244, Maxima rest - outMap.emplace(std::make_pair( "restQuarter", 0xE4E5 )); // glyphnumber: 2245, Quarter (crotchet) rest - outMap.emplace(std::make_pair( "restQuarterOld", 0xE4F2 )); // glyphnumber: 2246, Old-style quarter (crotchet) rest - outMap.emplace(std::make_pair( "restQuarterZ", 0xE4F6 )); // glyphnumber: 2247, Z-style quarter (crotchet) rest - outMap.emplace(std::make_pair( "restWhole", 0xE4E3 )); // glyphnumber: 2248, Whole (semibreve) rest - outMap.emplace(std::make_pair( "restWholeLegerLine", 0xE4F4 )); // glyphnumber: 2249, Whole rest on leger line - outMap.emplace(std::make_pair( "reversedBrace", 0xE001 )); // glyphnumber: 2250, Reversed brace - outMap.emplace(std::make_pair( "reversedBracketBottom", 0xE006 )); // glyphnumber: 2251, Reversed bracket bottom - outMap.emplace(std::make_pair( "reversedBracketTop", 0xE005 )); // glyphnumber: 2252, Reversed bracket top - outMap.emplace(std::make_pair( "rightRepeatSmall", 0xE04D )); // glyphnumber: 2253, Right repeat sign within bar - outMap.emplace(std::make_pair( "schaefferClef", 0xE06F )); // glyphnumber: 2254, Schäffer clef - outMap.emplace(std::make_pair( "schaefferFClefToGClef", 0xE072 )); // glyphnumber: 2255, Schäffer F clef to G clef change - outMap.emplace(std::make_pair( "schaefferGClefToFClef", 0xE071 )); // glyphnumber: 2256, Schäffer G clef to F clef change - outMap.emplace(std::make_pair( "schaefferPreviousClef", 0xE070 )); // glyphnumber: 2257, Schäffer previous clef - outMap.emplace(std::make_pair( "segno", 0xE047 )); // glyphnumber: 2258, Segno - outMap.emplace(std::make_pair( "segnoSerpent1", 0xE04A )); // glyphnumber: 2259, Segno (serpent) - outMap.emplace(std::make_pair( "segnoSerpent2", 0xE04B )); // glyphnumber: 2260, Segno (serpent with vertical lines) - outMap.emplace(std::make_pair( "semipitchedPercussionClef1", 0xE06B )); // glyphnumber: 2261, Semi-pitched percussion clef 1 - outMap.emplace(std::make_pair( "semipitchedPercussionClef2", 0xE06C )); // glyphnumber: 2262, Semi-pitched percussion clef 2 - outMap.emplace(std::make_pair( "smnFlat", 0xEC52 )); // glyphnumber: 2263, Flat - outMap.emplace(std::make_pair( "smnFlatWhite", 0xEC53 )); // glyphnumber: 2264, Flat (white) - outMap.emplace(std::make_pair( "smnHistoryDoubleFlat", 0xEC57 )); // glyphnumber: 2265, Double flat history sign - outMap.emplace(std::make_pair( "smnHistoryDoubleSharp", 0xEC55 )); // glyphnumber: 2266, Double sharp history sign - outMap.emplace(std::make_pair( "smnHistoryFlat", 0xEC56 )); // glyphnumber: 2267, Flat history sign - outMap.emplace(std::make_pair( "smnHistorySharp", 0xEC54 )); // glyphnumber: 2268, Sharp history sign - outMap.emplace(std::make_pair( "smnNatural", 0xEC58 )); // glyphnumber: 2269, Natural (N) - outMap.emplace(std::make_pair( "smnSharp", 0xEC50 )); // glyphnumber: 2270, Sharp stem up - outMap.emplace(std::make_pair( "smnSharpDown", 0xEC59 )); // glyphnumber: 2271, Sharp stem down - outMap.emplace(std::make_pair( "smnSharpWhite", 0xEC51 )); // glyphnumber: 2272, Sharp (white) stem up - outMap.emplace(std::make_pair( "smnSharpWhiteDown", 0xEC5A )); // glyphnumber: 2273, Sharp (white) stem down - outMap.emplace(std::make_pair( "splitBarDivider", 0xE00A )); // glyphnumber: 2274, Split bar divider (bar spans a system break) - outMap.emplace(std::make_pair( "staff1Line", 0xE010 )); // glyphnumber: 2275, 1-line staff - outMap.emplace(std::make_pair( "staff1LineNarrow", 0xE01C )); // glyphnumber: 2276, 1-line staff (narrow) - outMap.emplace(std::make_pair( "staff1LineWide", 0xE016 )); // glyphnumber: 2277, 1-line staff (wide) - outMap.emplace(std::make_pair( "staff2Lines", 0xE011 )); // glyphnumber: 2278, 2-line staff - outMap.emplace(std::make_pair( "staff2LinesNarrow", 0xE01D )); // glyphnumber: 2279, 2-line staff (narrow) - outMap.emplace(std::make_pair( "staff2LinesWide", 0xE017 )); // glyphnumber: 2280, 2-line staff (wide) - outMap.emplace(std::make_pair( "staff3Lines", 0xE012 )); // glyphnumber: 2281, 3-line staff - outMap.emplace(std::make_pair( "staff3LinesNarrow", 0xE01E )); // glyphnumber: 2282, 3-line staff (narrow) - outMap.emplace(std::make_pair( "staff3LinesWide", 0xE018 )); // glyphnumber: 2283, 3-line staff (wide) - outMap.emplace(std::make_pair( "staff4Lines", 0xE013 )); // glyphnumber: 2284, 4-line staff - outMap.emplace(std::make_pair( "staff4LinesNarrow", 0xE01F )); // glyphnumber: 2285, 4-line staff (narrow) - outMap.emplace(std::make_pair( "staff4LinesWide", 0xE019 )); // glyphnumber: 2286, 4-line staff (wide) - outMap.emplace(std::make_pair( "staff5Lines", 0xE014 )); // glyphnumber: 2287, 5-line staff - outMap.emplace(std::make_pair( "staff5LinesNarrow", 0xE020 )); // glyphnumber: 2288, 5-line staff (narrow) - outMap.emplace(std::make_pair( "staff5LinesWide", 0xE01A )); // glyphnumber: 2289, 5-line staff (wide) - outMap.emplace(std::make_pair( "staff6Lines", 0xE015 )); // glyphnumber: 2290, 6-line staff - outMap.emplace(std::make_pair( "staff6LinesNarrow", 0xE021 )); // glyphnumber: 2291, 6-line staff (narrow) - outMap.emplace(std::make_pair( "staff6LinesWide", 0xE01B )); // glyphnumber: 2292, 6-line staff (wide) - outMap.emplace(std::make_pair( "staffDivideArrowDown", 0xE00B )); // glyphnumber: 2293, Staff divide arrow down - outMap.emplace(std::make_pair( "staffDivideArrowUp", 0xE00C )); // glyphnumber: 2294, Staff divide arrow up - outMap.emplace(std::make_pair( "staffDivideArrowUpDown", 0xE00D )); // glyphnumber: 2295, Staff divide arrows - outMap.emplace(std::make_pair( "staffPosLower1", 0xEB98 )); // glyphnumber: 2296, Lower 1 staff position - outMap.emplace(std::make_pair( "staffPosLower2", 0xEB99 )); // glyphnumber: 2297, Lower 2 staff positions - outMap.emplace(std::make_pair( "staffPosLower3", 0xEB9A )); // glyphnumber: 2298, Lower 3 staff positions - outMap.emplace(std::make_pair( "staffPosLower4", 0xEB9B )); // glyphnumber: 2299, Lower 4 staff positions - outMap.emplace(std::make_pair( "staffPosLower5", 0xEB9C )); // glyphnumber: 2300, Lower 5 staff positions - outMap.emplace(std::make_pair( "staffPosLower6", 0xEB9D )); // glyphnumber: 2301, Lower 6 staff positions - outMap.emplace(std::make_pair( "staffPosLower7", 0xEB9E )); // glyphnumber: 2302, Lower 7 staff positions - outMap.emplace(std::make_pair( "staffPosLower8", 0xEB9F )); // glyphnumber: 2303, Lower 8 staff positions - outMap.emplace(std::make_pair( "staffPosRaise1", 0xEB90 )); // glyphnumber: 2304, Raise 1 staff position - outMap.emplace(std::make_pair( "staffPosRaise2", 0xEB91 )); // glyphnumber: 2305, Raise 2 staff positions - outMap.emplace(std::make_pair( "staffPosRaise3", 0xEB92 )); // glyphnumber: 2306, Raise 3 staff positions - outMap.emplace(std::make_pair( "staffPosRaise4", 0xEB93 )); // glyphnumber: 2307, Raise 4 staff positions - outMap.emplace(std::make_pair( "staffPosRaise5", 0xEB94 )); // glyphnumber: 2308, Raise 5 staff positions - outMap.emplace(std::make_pair( "staffPosRaise6", 0xEB95 )); // glyphnumber: 2309, Raise 6 staff positions - outMap.emplace(std::make_pair( "staffPosRaise7", 0xEB96 )); // glyphnumber: 2310, Raise 7 staff positions - outMap.emplace(std::make_pair( "staffPosRaise8", 0xEB97 )); // glyphnumber: 2311, Raise 8 staff positions - outMap.emplace(std::make_pair( "stem", 0xE210 )); // glyphnumber: 2312, Combining stem - outMap.emplace(std::make_pair( "stemBowOnBridge", 0xE215 )); // glyphnumber: 2313, Combining bow on bridge stem - outMap.emplace(std::make_pair( "stemBowOnTailpiece", 0xE216 )); // glyphnumber: 2314, Combining bow on tailpiece stem - outMap.emplace(std::make_pair( "stemBuzzRoll", 0xE217 )); // glyphnumber: 2315, Combining buzz roll stem - outMap.emplace(std::make_pair( "stemDamp", 0xE218 )); // glyphnumber: 2316, Combining damp stem - outMap.emplace(std::make_pair( "stemHarpStringNoise", 0xE21F )); // glyphnumber: 2317, Combining harp string noise stem - outMap.emplace(std::make_pair( "stemMultiphonicsBlack", 0xE21A )); // glyphnumber: 2318, Combining multiphonics (black) stem - outMap.emplace(std::make_pair( "stemMultiphonicsBlackWhite", 0xE21C )); // glyphnumber: 2319, Combining multiphonics (black and white) stem - outMap.emplace(std::make_pair( "stemMultiphonicsWhite", 0xE21B )); // glyphnumber: 2320, Combining multiphonics (white) stem - outMap.emplace(std::make_pair( "stemPendereckiTremolo", 0xE213 )); // glyphnumber: 2321, Combining Penderecki unmeasured tremolo stem - outMap.emplace(std::make_pair( "stemRimShot", 0xE21E )); // glyphnumber: 2322, Combining rim shot stem - outMap.emplace(std::make_pair( "stemSprechgesang", 0xE211 )); // glyphnumber: 2323, Combining sprechgesang stem - outMap.emplace(std::make_pair( "stemSulPonticello", 0xE214 )); // glyphnumber: 2324, Combining sul ponticello (bow behind bridge) stem - outMap.emplace(std::make_pair( "stemSussurando", 0xE21D )); // glyphnumber: 2325, Combining sussurando stem - outMap.emplace(std::make_pair( "stemSwished", 0xE212 )); // glyphnumber: 2326, Combining swished stem - outMap.emplace(std::make_pair( "stemVibratoPulse", 0xE219 )); // glyphnumber: 2327, Combining vibrato pulse accent (Saunders) stem - outMap.emplace(std::make_pair( "stockhausenTremolo", 0xE232 )); // glyphnumber: 2328, Stockhausen irregular tremolo ("Morsen", like Morse code) - outMap.emplace(std::make_pair( "stringsBowBehindBridge", 0xE618 )); // glyphnumber: 2329, Bow behind bridge (sul ponticello) - outMap.emplace(std::make_pair( "stringsBowBehindBridgeFourStrings", 0xE62A )); // glyphnumber: 2330, Bow behind bridge on four strings - outMap.emplace(std::make_pair( "stringsBowBehindBridgeOneString", 0xE627 )); // glyphnumber: 2331, Bow behind bridge on one string - outMap.emplace(std::make_pair( "stringsBowBehindBridgeThreeStrings", 0xE629 )); // glyphnumber: 2332, Bow behind bridge on three strings - outMap.emplace(std::make_pair( "stringsBowBehindBridgeTwoStrings", 0xE628 )); // glyphnumber: 2333, Bow behind bridge on two strings - outMap.emplace(std::make_pair( "stringsBowOnBridge", 0xE619 )); // glyphnumber: 2334, Bow on top of bridge - outMap.emplace(std::make_pair( "stringsBowOnTailpiece", 0xE61A )); // glyphnumber: 2335, Bow on tailpiece - outMap.emplace(std::make_pair( "stringsChangeBowDirection", 0xE626 )); // glyphnumber: 2336, Change bow direction, indeterminate - outMap.emplace(std::make_pair( "stringsDownBow", 0xE610 )); // glyphnumber: 2337, Down bow - outMap.emplace(std::make_pair( "stringsDownBowTurned", 0xE611 )); // glyphnumber: 2338, Turned down bow - outMap.emplace(std::make_pair( "stringsFouette", 0xE622 )); // glyphnumber: 2339, Fouetté - outMap.emplace(std::make_pair( "stringsHalfHarmonic", 0xE615 )); // glyphnumber: 2340, Half-harmonic - outMap.emplace(std::make_pair( "stringsHarmonic", 0xE614 )); // glyphnumber: 2341, Harmonic - outMap.emplace(std::make_pair( "stringsJeteAbove", 0xE620 )); // glyphnumber: 2342, Jeté (gettato) above - outMap.emplace(std::make_pair( "stringsJeteBelow", 0xE621 )); // glyphnumber: 2343, Jeté (gettato) below - outMap.emplace(std::make_pair( "stringsMuteOff", 0xE617 )); // glyphnumber: 2344, Mute off - outMap.emplace(std::make_pair( "stringsMuteOn", 0xE616 )); // glyphnumber: 2345, Mute on - outMap.emplace(std::make_pair( "stringsOverpressureDownBow", 0xE61B )); // glyphnumber: 2346, Overpressure, down bow - outMap.emplace(std::make_pair( "stringsOverpressureNoDirection", 0xE61F )); // glyphnumber: 2347, Overpressure, no bow direction - outMap.emplace(std::make_pair( "stringsOverpressurePossibileDownBow", 0xE61D )); // glyphnumber: 2348, Overpressure possibile, down bow - outMap.emplace(std::make_pair( "stringsOverpressurePossibileUpBow", 0xE61E )); // glyphnumber: 2349, Overpressure possibile, up bow - outMap.emplace(std::make_pair( "stringsOverpressureUpBow", 0xE61C )); // glyphnumber: 2350, Overpressure, up bow - outMap.emplace(std::make_pair( "stringsThumbPosition", 0xE624 )); // glyphnumber: 2351, Thumb position - outMap.emplace(std::make_pair( "stringsThumbPositionTurned", 0xE625 )); // glyphnumber: 2352, Turned thumb position - outMap.emplace(std::make_pair( "stringsUpBow", 0xE612 )); // glyphnumber: 2353, Up bow - outMap.emplace(std::make_pair( "stringsUpBowTurned", 0xE613 )); // glyphnumber: 2354, Turned up bow - outMap.emplace(std::make_pair( "stringsVibratoPulse", 0xE623 )); // glyphnumber: 2355, Vibrato pulse accent (Saunders) for stem - outMap.emplace(std::make_pair( "systemDivider", 0xE007 )); // glyphnumber: 2356, System divider - outMap.emplace(std::make_pair( "systemDividerExtraLong", 0xE009 )); // glyphnumber: 2357, Extra long system divider - outMap.emplace(std::make_pair( "systemDividerLong", 0xE008 )); // glyphnumber: 2358, Long system divider - outMap.emplace(std::make_pair( "textAugmentationDot", 0xE1FC )); // glyphnumber: 2359, Augmentation dot - outMap.emplace(std::make_pair( "textBlackNoteFrac16thLongStem", 0xE1F5 )); // glyphnumber: 2360, Black note, fractional 16th beam, long stem - outMap.emplace(std::make_pair( "textBlackNoteFrac16thShortStem", 0xE1F4 )); // glyphnumber: 2361, Black note, fractional 16th beam, short stem - outMap.emplace(std::make_pair( "textBlackNoteFrac32ndLongStem", 0xE1F6 )); // glyphnumber: 2362, Black note, fractional 32nd beam, long stem - outMap.emplace(std::make_pair( "textBlackNoteFrac8thLongStem", 0xE1F3 )); // glyphnumber: 2363, Black note, fractional 8th beam, long stem - outMap.emplace(std::make_pair( "textBlackNoteFrac8thShortStem", 0xE1F2 )); // glyphnumber: 2364, Black note, fractional 8th beam, short stem - outMap.emplace(std::make_pair( "textBlackNoteLongStem", 0xE1F1 )); // glyphnumber: 2365, Black note, long stem - outMap.emplace(std::make_pair( "textBlackNoteShortStem", 0xE1F0 )); // glyphnumber: 2366, Black note, short stem - outMap.emplace(std::make_pair( "textCont16thBeamLongStem", 0xE1FA )); // glyphnumber: 2367, Continuing 16th beam for long stem - outMap.emplace(std::make_pair( "textCont16thBeamShortStem", 0xE1F9 )); // glyphnumber: 2368, Continuing 16th beam for short stem - outMap.emplace(std::make_pair( "textCont32ndBeamLongStem", 0xE1FB )); // glyphnumber: 2369, Continuing 32nd beam for long stem - outMap.emplace(std::make_pair( "textCont8thBeamLongStem", 0xE1F8 )); // glyphnumber: 2370, Continuing 8th beam for long stem - outMap.emplace(std::make_pair( "textCont8thBeamShortStem", 0xE1F7 )); // glyphnumber: 2371, Continuing 8th beam for short stem - outMap.emplace(std::make_pair( "textTie", 0xE1FD )); // glyphnumber: 2372, Tie - outMap.emplace(std::make_pair( "textTuplet3LongStem", 0xE202 )); // glyphnumber: 2373, Tuplet number 3 for long stem - outMap.emplace(std::make_pair( "textTuplet3ShortStem", 0xE1FF )); // glyphnumber: 2374, Tuplet number 3 for short stem - outMap.emplace(std::make_pair( "textTupletBracketEndLongStem", 0xE203 )); // glyphnumber: 2375, Tuplet bracket end for long stem - outMap.emplace(std::make_pair( "textTupletBracketEndShortStem", 0xE200 )); // glyphnumber: 2376, Tuplet bracket end for short stem - outMap.emplace(std::make_pair( "textTupletBracketStartLongStem", 0xE201 )); // glyphnumber: 2377, Tuplet bracket start for long stem - outMap.emplace(std::make_pair( "textTupletBracketStartShortStem", 0xE1FE )); // glyphnumber: 2378, Tuplet bracket start for short stem - outMap.emplace(std::make_pair( "timeSig0", 0xE080 )); // glyphnumber: 2379, Time signature 0 - outMap.emplace(std::make_pair( "timeSig0Reversed", 0xECF0 )); // glyphnumber: 2380, Reversed time signature 0 - outMap.emplace(std::make_pair( "timeSig0Turned", 0xECE0 )); // glyphnumber: 2381, Turned time signature 0 - outMap.emplace(std::make_pair( "timeSig1", 0xE081 )); // glyphnumber: 2382, Time signature 1 - outMap.emplace(std::make_pair( "timeSig1Reversed", 0xECF1 )); // glyphnumber: 2383, Reversed time signature 1 - outMap.emplace(std::make_pair( "timeSig1Turned", 0xECE1 )); // glyphnumber: 2384, Turned time signature 1 - outMap.emplace(std::make_pair( "timeSig2", 0xE082 )); // glyphnumber: 2385, Time signature 2 - outMap.emplace(std::make_pair( "timeSig2Reversed", 0xECF2 )); // glyphnumber: 2386, Reversed time signature 2 - outMap.emplace(std::make_pair( "timeSig2Turned", 0xECE2 )); // glyphnumber: 2387, Turned time signature 2 - outMap.emplace(std::make_pair( "timeSig3", 0xE083 )); // glyphnumber: 2388, Time signature 3 - outMap.emplace(std::make_pair( "timeSig3Reversed", 0xECF3 )); // glyphnumber: 2389, Reversed time signature 3 - outMap.emplace(std::make_pair( "timeSig3Turned", 0xECE3 )); // glyphnumber: 2390, Turned time signature 3 - outMap.emplace(std::make_pair( "timeSig4", 0xE084 )); // glyphnumber: 2391, Time signature 4 - outMap.emplace(std::make_pair( "timeSig4Reversed", 0xECF4 )); // glyphnumber: 2392, Reversed time signature 4 - outMap.emplace(std::make_pair( "timeSig4Turned", 0xECE4 )); // glyphnumber: 2393, Turned time signature 4 - outMap.emplace(std::make_pair( "timeSig5", 0xE085 )); // glyphnumber: 2394, Time signature 5 - outMap.emplace(std::make_pair( "timeSig5Reversed", 0xECF5 )); // glyphnumber: 2395, Reversed time signature 5 - outMap.emplace(std::make_pair( "timeSig5Turned", 0xECE5 )); // glyphnumber: 2396, Turned time signature 5 - outMap.emplace(std::make_pair( "timeSig6", 0xE086 )); // glyphnumber: 2397, Time signature 6 - outMap.emplace(std::make_pair( "timeSig6Reversed", 0xECF6 )); // glyphnumber: 2398, Reversed time signature 6 - outMap.emplace(std::make_pair( "timeSig6Turned", 0xECE6 )); // glyphnumber: 2399, Turned time signature 6 - outMap.emplace(std::make_pair( "timeSig7", 0xE087 )); // glyphnumber: 2400, Time signature 7 - outMap.emplace(std::make_pair( "timeSig7Reversed", 0xECF7 )); // glyphnumber: 2401, Reversed time signature 7 - outMap.emplace(std::make_pair( "timeSig7Turned", 0xECE7 )); // glyphnumber: 2402, Turned time signature 7 - outMap.emplace(std::make_pair( "timeSig8", 0xE088 )); // glyphnumber: 2403, Time signature 8 - outMap.emplace(std::make_pair( "timeSig8Reversed", 0xECF8 )); // glyphnumber: 2404, Reversed time signature 8 - outMap.emplace(std::make_pair( "timeSig8Turned", 0xECE8 )); // glyphnumber: 2405, Turned time signature 8 - outMap.emplace(std::make_pair( "timeSig9", 0xE089 )); // glyphnumber: 2406, Time signature 9 - outMap.emplace(std::make_pair( "timeSig9Reversed", 0xECF9 )); // glyphnumber: 2407, Reversed time signature 9 - outMap.emplace(std::make_pair( "timeSig9Turned", 0xECE9 )); // glyphnumber: 2408, Turned time signature 9 - outMap.emplace(std::make_pair( "timeSigBracketLeft", 0xEC80 )); // glyphnumber: 2409, Left bracket for whole time signature - outMap.emplace(std::make_pair( "timeSigBracketLeftSmall", 0xEC82 )); // glyphnumber: 2410, Left bracket for numerator only - outMap.emplace(std::make_pair( "timeSigBracketRight", 0xEC81 )); // glyphnumber: 2411, Right bracket for whole time signature - outMap.emplace(std::make_pair( "timeSigBracketRightSmall", 0xEC83 )); // glyphnumber: 2412, Right bracket for numerator only - outMap.emplace(std::make_pair( "timeSigCombDenominator", 0xE09F )); // glyphnumber: 2413, Control character for denominator digit - outMap.emplace(std::make_pair( "timeSigCombNumerator", 0xE09E )); // glyphnumber: 2414, Control character for numerator digit - outMap.emplace(std::make_pair( "timeSigComma", 0xE096 )); // glyphnumber: 2415, Time signature comma - outMap.emplace(std::make_pair( "timeSigCommon", 0xE08A )); // glyphnumber: 2416, Common time - outMap.emplace(std::make_pair( "timeSigCommonReversed", 0xECFA )); // glyphnumber: 2417, Reversed common time - outMap.emplace(std::make_pair( "timeSigCommonTurned", 0xECEA )); // glyphnumber: 2418, Turned common time - outMap.emplace(std::make_pair( "timeSigCut2", 0xEC85 )); // glyphnumber: 2419, Cut time (Bach) - outMap.emplace(std::make_pair( "timeSigCut3", 0xEC86 )); // glyphnumber: 2420, Cut triple time (9/8) - outMap.emplace(std::make_pair( "timeSigCutCommon", 0xE08B )); // glyphnumber: 2421, Cut time - outMap.emplace(std::make_pair( "timeSigCutCommonReversed", 0xECFB )); // glyphnumber: 2422, Reversed cut time - outMap.emplace(std::make_pair( "timeSigCutCommonTurned", 0xECEB )); // glyphnumber: 2423, Turned cut time - outMap.emplace(std::make_pair( "timeSigEquals", 0xE08F )); // glyphnumber: 2424, Time signature equals - outMap.emplace(std::make_pair( "timeSigFractionHalf", 0xE098 )); // glyphnumber: 2425, Time signature fraction ½ - outMap.emplace(std::make_pair( "timeSigFractionOneThird", 0xE09A )); // glyphnumber: 2426, Time signature fraction ⅓ - outMap.emplace(std::make_pair( "timeSigFractionQuarter", 0xE097 )); // glyphnumber: 2427, Time signature fraction ¼ - outMap.emplace(std::make_pair( "timeSigFractionThreeQuarters", 0xE099 )); // glyphnumber: 2428, Time signature fraction ¾ - outMap.emplace(std::make_pair( "timeSigFractionTwoThirds", 0xE09B )); // glyphnumber: 2429, Time signature fraction ⅔ - outMap.emplace(std::make_pair( "timeSigFractionalSlash", 0xE08E )); // glyphnumber: 2430, Time signature fraction slash - outMap.emplace(std::make_pair( "timeSigMinus", 0xE090 )); // glyphnumber: 2431, Time signature minus - outMap.emplace(std::make_pair( "timeSigMultiply", 0xE091 )); // glyphnumber: 2432, Time signature multiply - outMap.emplace(std::make_pair( "timeSigOpenPenderecki", 0xE09D )); // glyphnumber: 2433, Open time signature (Penderecki) - outMap.emplace(std::make_pair( "timeSigParensLeft", 0xE094 )); // glyphnumber: 2434, Left parenthesis for whole time signature - outMap.emplace(std::make_pair( "timeSigParensLeftSmall", 0xE092 )); // glyphnumber: 2435, Left parenthesis for numerator only - outMap.emplace(std::make_pair( "timeSigParensRight", 0xE095 )); // glyphnumber: 2436, Right parenthesis for whole time signature - outMap.emplace(std::make_pair( "timeSigParensRightSmall", 0xE093 )); // glyphnumber: 2437, Right parenthesis for numerator only - outMap.emplace(std::make_pair( "timeSigPlus", 0xE08C )); // glyphnumber: 2438, Time signature + - outMap.emplace(std::make_pair( "timeSigPlusSmall", 0xE08D )); // glyphnumber: 2439, Time signature + (for numerators) - outMap.emplace(std::make_pair( "timeSigSlash", 0xEC84 )); // glyphnumber: 2440, Time signature slash separator - outMap.emplace(std::make_pair( "timeSigX", 0xE09C )); // glyphnumber: 2441, Open time signature - outMap.emplace(std::make_pair( "tremolo1", 0xE220 )); // glyphnumber: 2442, Combining tremolo 1 - outMap.emplace(std::make_pair( "tremolo2", 0xE221 )); // glyphnumber: 2443, Combining tremolo 2 - outMap.emplace(std::make_pair( "tremolo3", 0xE222 )); // glyphnumber: 2444, Combining tremolo 3 - outMap.emplace(std::make_pair( "tremolo4", 0xE223 )); // glyphnumber: 2445, Combining tremolo 4 - outMap.emplace(std::make_pair( "tremolo5", 0xE224 )); // glyphnumber: 2446, Combining tremolo 5 - outMap.emplace(std::make_pair( "tremoloDivisiDots2", 0xE22E )); // glyphnumber: 2447, Divide measured tremolo by 2 - outMap.emplace(std::make_pair( "tremoloDivisiDots3", 0xE22F )); // glyphnumber: 2448, Divide measured tremolo by 3 - outMap.emplace(std::make_pair( "tremoloDivisiDots4", 0xE230 )); // glyphnumber: 2449, Divide measured tremolo by 4 - outMap.emplace(std::make_pair( "tremoloDivisiDots6", 0xE231 )); // glyphnumber: 2450, Divide measured tremolo by 6 - outMap.emplace(std::make_pair( "tremoloFingered1", 0xE225 )); // glyphnumber: 2451, Fingered tremolo 1 - outMap.emplace(std::make_pair( "tremoloFingered2", 0xE226 )); // glyphnumber: 2452, Fingered tremolo 2 - outMap.emplace(std::make_pair( "tremoloFingered3", 0xE227 )); // glyphnumber: 2453, Fingered tremolo 3 - outMap.emplace(std::make_pair( "tremoloFingered4", 0xE228 )); // glyphnumber: 2454, Fingered tremolo 4 - outMap.emplace(std::make_pair( "tremoloFingered5", 0xE229 )); // glyphnumber: 2455, Fingered tremolo 5 - outMap.emplace(std::make_pair( "tripleTongueAbove", 0xE5F2 )); // glyphnumber: 2456, Triple-tongue above - outMap.emplace(std::make_pair( "tripleTongueBelow", 0xE5F3 )); // glyphnumber: 2457, Triple-tongue below - outMap.emplace(std::make_pair( "tuplet0", 0xE880 )); // glyphnumber: 2458, Tuplet 0 - outMap.emplace(std::make_pair( "tuplet1", 0xE881 )); // glyphnumber: 2459, Tuplet 1 - outMap.emplace(std::make_pair( "tuplet2", 0xE882 )); // glyphnumber: 2460, Tuplet 2 - outMap.emplace(std::make_pair( "tuplet3", 0xE883 )); // glyphnumber: 2461, Tuplet 3 - outMap.emplace(std::make_pair( "tuplet4", 0xE884 )); // glyphnumber: 2462, Tuplet 4 - outMap.emplace(std::make_pair( "tuplet5", 0xE885 )); // glyphnumber: 2463, Tuplet 5 - outMap.emplace(std::make_pair( "tuplet6", 0xE886 )); // glyphnumber: 2464, Tuplet 6 - outMap.emplace(std::make_pair( "tuplet7", 0xE887 )); // glyphnumber: 2465, Tuplet 7 - outMap.emplace(std::make_pair( "tuplet8", 0xE888 )); // glyphnumber: 2466, Tuplet 8 - outMap.emplace(std::make_pair( "tuplet9", 0xE889 )); // glyphnumber: 2467, Tuplet 9 - outMap.emplace(std::make_pair( "tupletColon", 0xE88A )); // glyphnumber: 2468, Tuplet colon - outMap.emplace(std::make_pair( "unmeasuredTremolo", 0xE22C )); // glyphnumber: 2469, Wieniawski unmeasured tremolo - outMap.emplace(std::make_pair( "unmeasuredTremoloSimple", 0xE22D )); // glyphnumber: 2470, Wieniawski unmeasured tremolo (simpler) - outMap.emplace(std::make_pair( "unpitchedPercussionClef1", 0xE069 )); // glyphnumber: 2471, Unpitched percussion clef 1 - outMap.emplace(std::make_pair( "unpitchedPercussionClef2", 0xE06A )); // glyphnumber: 2472, Unpitched percussion clef 2 - outMap.emplace(std::make_pair( "ventiduesima", 0xE517 )); // glyphnumber: 2473, Ventiduesima - outMap.emplace(std::make_pair( "ventiduesimaAlta", 0xE518 )); // glyphnumber: 2474, Ventiduesima alta - outMap.emplace(std::make_pair( "ventiduesimaBassa", 0xE519 )); // glyphnumber: 2475, Ventiduesima bassa - outMap.emplace(std::make_pair( "ventiduesimaBassaMb", 0xE51E )); // glyphnumber: 2476, Ventiduesima bassa (mb) - outMap.emplace(std::make_pair( "vocalFingerClickStockhausen", 0xE649 )); // glyphnumber: 2477, Finger click (Stockhausen) - outMap.emplace(std::make_pair( "vocalMouthClosed", 0xE640 )); // glyphnumber: 2478, Mouth closed - outMap.emplace(std::make_pair( "vocalMouthOpen", 0xE642 )); // glyphnumber: 2479, Mouth open - outMap.emplace(std::make_pair( "vocalMouthPursed", 0xE644 )); // glyphnumber: 2480, Mouth pursed - outMap.emplace(std::make_pair( "vocalMouthSlightlyOpen", 0xE641 )); // glyphnumber: 2481, Mouth slightly open - outMap.emplace(std::make_pair( "vocalMouthWideOpen", 0xE643 )); // glyphnumber: 2482, Mouth wide open - outMap.emplace(std::make_pair( "vocalNasalVoice", 0xE647 )); // glyphnumber: 2483, Nasal voice - outMap.emplace(std::make_pair( "vocalSprechgesang", 0xE645 )); // glyphnumber: 2484, Sprechgesang - outMap.emplace(std::make_pair( "vocalTongueClickStockhausen", 0xE648 )); // glyphnumber: 2485, Tongue click (Stockhausen) - outMap.emplace(std::make_pair( "vocalTongueFingerClickStockhausen", 0xE64A )); // glyphnumber: 2486, Tongue and finger click (Stockhausen) - outMap.emplace(std::make_pair( "vocalsSussurando", 0xE646 )); // glyphnumber: 2487, Combining sussurando for stem - outMap.emplace(std::make_pair( "wiggleArpeggiatoDown", 0xEAAA )); // glyphnumber: 2488, Arpeggiato wiggle segment, downwards - outMap.emplace(std::make_pair( "wiggleArpeggiatoDownArrow", 0xEAAE )); // glyphnumber: 2489, Arpeggiato arrowhead down - outMap.emplace(std::make_pair( "wiggleArpeggiatoDownSwash", 0xEAAC )); // glyphnumber: 2490, Arpeggiato downward swash - outMap.emplace(std::make_pair( "wiggleArpeggiatoUp", 0xEAA9 )); // glyphnumber: 2491, Arpeggiato wiggle segment, upwards - outMap.emplace(std::make_pair( "wiggleArpeggiatoUpArrow", 0xEAAD )); // glyphnumber: 2492, Arpeggiato arrowhead up - outMap.emplace(std::make_pair( "wiggleArpeggiatoUpSwash", 0xEAAB )); // glyphnumber: 2493, Arpeggiato upward swash - outMap.emplace(std::make_pair( "wiggleCircular", 0xEAC9 )); // glyphnumber: 2494, Circular motion segment - outMap.emplace(std::make_pair( "wiggleCircularConstant", 0xEAC0 )); // glyphnumber: 2495, Constant circular motion segment - outMap.emplace(std::make_pair( "wiggleCircularConstantFlipped", 0xEAC1 )); // glyphnumber: 2496, Constant circular motion segment (flipped) - outMap.emplace(std::make_pair( "wiggleCircularConstantFlippedLarge", 0xEAC3 )); // glyphnumber: 2497, Constant circular motion segment (flipped, large) - outMap.emplace(std::make_pair( "wiggleCircularConstantLarge", 0xEAC2 )); // glyphnumber: 2498, Constant circular motion segment (large) - outMap.emplace(std::make_pair( "wiggleCircularEnd", 0xEACB )); // glyphnumber: 2499, Circular motion end - outMap.emplace(std::make_pair( "wiggleCircularLarge", 0xEAC8 )); // glyphnumber: 2500, Circular motion segment, large - outMap.emplace(std::make_pair( "wiggleCircularLarger", 0xEAC7 )); // glyphnumber: 2501, Circular motion segment, larger - outMap.emplace(std::make_pair( "wiggleCircularLargerStill", 0xEAC6 )); // glyphnumber: 2502, Circular motion segment, larger still - outMap.emplace(std::make_pair( "wiggleCircularLargest", 0xEAC5 )); // glyphnumber: 2503, Circular motion segment, largest - outMap.emplace(std::make_pair( "wiggleCircularSmall", 0xEACA )); // glyphnumber: 2504, Circular motion segment, small - outMap.emplace(std::make_pair( "wiggleCircularStart", 0xEAC4 )); // glyphnumber: 2505, Circular motion start - outMap.emplace(std::make_pair( "wiggleGlissando", 0xEAAF )); // glyphnumber: 2506, Glissando wiggle segment - outMap.emplace(std::make_pair( "wiggleGlissandoGroup1", 0xEABD )); // glyphnumber: 2507, Group glissando 1 - outMap.emplace(std::make_pair( "wiggleGlissandoGroup2", 0xEABE )); // glyphnumber: 2508, Group glissando 2 - outMap.emplace(std::make_pair( "wiggleGlissandoGroup3", 0xEABF )); // glyphnumber: 2509, Group glissando 3 - outMap.emplace(std::make_pair( "wiggleRandom1", 0xEAF0 )); // glyphnumber: 2510, Quasi-random squiggle 1 - outMap.emplace(std::make_pair( "wiggleRandom2", 0xEAF1 )); // glyphnumber: 2511, Quasi-random squiggle 2 - outMap.emplace(std::make_pair( "wiggleRandom3", 0xEAF2 )); // glyphnumber: 2512, Quasi-random squiggle 3 - outMap.emplace(std::make_pair( "wiggleRandom4", 0xEAF3 )); // glyphnumber: 2513, Quasi-random squiggle 4 - outMap.emplace(std::make_pair( "wiggleSawtooth", 0xEABB )); // glyphnumber: 2514, Sawtooth line segment - outMap.emplace(std::make_pair( "wiggleSawtoothNarrow", 0xEABA )); // glyphnumber: 2515, Narrow sawtooth line segment - outMap.emplace(std::make_pair( "wiggleSawtoothWide", 0xEABC )); // glyphnumber: 2516, Wide sawtooth line segment - outMap.emplace(std::make_pair( "wiggleSquareWave", 0xEAB8 )); // glyphnumber: 2517, Square wave line segment - outMap.emplace(std::make_pair( "wiggleSquareWaveNarrow", 0xEAB7 )); // glyphnumber: 2518, Narrow square wave line segment - outMap.emplace(std::make_pair( "wiggleSquareWaveWide", 0xEAB9 )); // glyphnumber: 2519, Wide square wave line segment - outMap.emplace(std::make_pair( "wiggleTrill", 0xEAA4 )); // glyphnumber: 2520, Trill wiggle segment - outMap.emplace(std::make_pair( "wiggleTrillFast", 0xEAA3 )); // glyphnumber: 2521, Trill wiggle segment, fast - outMap.emplace(std::make_pair( "wiggleTrillFaster", 0xEAA2 )); // glyphnumber: 2522, Trill wiggle segment, faster - outMap.emplace(std::make_pair( "wiggleTrillFasterStill", 0xEAA1 )); // glyphnumber: 2523, Trill wiggle segment, faster still - outMap.emplace(std::make_pair( "wiggleTrillFastest", 0xEAA0 )); // glyphnumber: 2524, Trill wiggle segment, fastest - outMap.emplace(std::make_pair( "wiggleTrillSlow", 0xEAA5 )); // glyphnumber: 2525, Trill wiggle segment, slow - outMap.emplace(std::make_pair( "wiggleTrillSlower", 0xEAA6 )); // glyphnumber: 2526, Trill wiggle segment, slower - outMap.emplace(std::make_pair( "wiggleTrillSlowerStill", 0xEAA7 )); // glyphnumber: 2527, Trill wiggle segment, slower still - outMap.emplace(std::make_pair( "wiggleTrillSlowest", 0xEAA8 )); // glyphnumber: 2528, Trill wiggle segment, slowest - outMap.emplace(std::make_pair( "wiggleVIbratoLargestSlower", 0xEAEE )); // glyphnumber: 2529, Vibrato largest, slower - outMap.emplace(std::make_pair( "wiggleVIbratoMediumSlower", 0xEAE0 )); // glyphnumber: 2530, Vibrato medium, slower - outMap.emplace(std::make_pair( "wiggleVibrato", 0xEAB0 )); // glyphnumber: 2531, Vibrato / shake wiggle segment - outMap.emplace(std::make_pair( "wiggleVibratoLargeFast", 0xEAE5 )); // glyphnumber: 2532, Vibrato large, fast - outMap.emplace(std::make_pair( "wiggleVibratoLargeFaster", 0xEAE4 )); // glyphnumber: 2533, Vibrato large, faster - outMap.emplace(std::make_pair( "wiggleVibratoLargeFasterStill", 0xEAE3 )); // glyphnumber: 2534, Vibrato large, faster still - outMap.emplace(std::make_pair( "wiggleVibratoLargeFastest", 0xEAE2 )); // glyphnumber: 2535, Vibrato large, fastest - outMap.emplace(std::make_pair( "wiggleVibratoLargeSlow", 0xEAE6 )); // glyphnumber: 2536, Vibrato large, slow - outMap.emplace(std::make_pair( "wiggleVibratoLargeSlower", 0xEAE7 )); // glyphnumber: 2537, Vibrato large, slower - outMap.emplace(std::make_pair( "wiggleVibratoLargeSlowest", 0xEAE8 )); // glyphnumber: 2538, Vibrato large, slowest - outMap.emplace(std::make_pair( "wiggleVibratoLargestFast", 0xEAEC )); // glyphnumber: 2539, Vibrato largest, fast - outMap.emplace(std::make_pair( "wiggleVibratoLargestFaster", 0xEAEB )); // glyphnumber: 2540, Vibrato largest, faster - outMap.emplace(std::make_pair( "wiggleVibratoLargestFasterStill", 0xEAEA )); // glyphnumber: 2541, Vibrato largest, faster still - outMap.emplace(std::make_pair( "wiggleVibratoLargestFastest", 0xEAE9 )); // glyphnumber: 2542, Vibrato largest, fastest - outMap.emplace(std::make_pair( "wiggleVibratoLargestSlow", 0xEAED )); // glyphnumber: 2543, Vibrato largest, slow - outMap.emplace(std::make_pair( "wiggleVibratoLargestSlowest", 0xEAEF )); // glyphnumber: 2544, Vibrato largest, slowest - outMap.emplace(std::make_pair( "wiggleVibratoMediumFast", 0xEADE )); // glyphnumber: 2545, Vibrato medium, fast - outMap.emplace(std::make_pair( "wiggleVibratoMediumFaster", 0xEADD )); // glyphnumber: 2546, Vibrato medium, faster - outMap.emplace(std::make_pair( "wiggleVibratoMediumFasterStill", 0xEADC )); // glyphnumber: 2547, Vibrato medium, faster still - outMap.emplace(std::make_pair( "wiggleVibratoMediumFastest", 0xEADB )); // glyphnumber: 2548, Vibrato medium, fastest - outMap.emplace(std::make_pair( "wiggleVibratoMediumSlow", 0xEADF )); // glyphnumber: 2549, Vibrato medium, slow - outMap.emplace(std::make_pair( "wiggleVibratoMediumSlowest", 0xEAE1 )); // glyphnumber: 2550, Vibrato medium, slowest - outMap.emplace(std::make_pair( "wiggleVibratoSmallFast", 0xEAD7 )); // glyphnumber: 2551, Vibrato small, fast - outMap.emplace(std::make_pair( "wiggleVibratoSmallFaster", 0xEAD6 )); // glyphnumber: 2552, Vibrato small, faster - outMap.emplace(std::make_pair( "wiggleVibratoSmallFasterStill", 0xEAD5 )); // glyphnumber: 2553, Vibrato small, faster still - outMap.emplace(std::make_pair( "wiggleVibratoSmallFastest", 0xEAD4 )); // glyphnumber: 2554, Vibrato small, fastest - outMap.emplace(std::make_pair( "wiggleVibratoSmallSlow", 0xEAD8 )); // glyphnumber: 2555, Vibrato small, slow - outMap.emplace(std::make_pair( "wiggleVibratoSmallSlower", 0xEAD9 )); // glyphnumber: 2556, Vibrato small, slower - outMap.emplace(std::make_pair( "wiggleVibratoSmallSlowest", 0xEADA )); // glyphnumber: 2557, Vibrato small, slowest - outMap.emplace(std::make_pair( "wiggleVibratoSmallestFast", 0xEAD0 )); // glyphnumber: 2558, Vibrato smallest, fast - outMap.emplace(std::make_pair( "wiggleVibratoSmallestFaster", 0xEACF )); // glyphnumber: 2559, Vibrato smallest, faster - outMap.emplace(std::make_pair( "wiggleVibratoSmallestFasterStill", 0xEACE )); // glyphnumber: 2560, Vibrato smallest, faster still - outMap.emplace(std::make_pair( "wiggleVibratoSmallestFastest", 0xEACD )); // glyphnumber: 2561, Vibrato smallest, fastest - outMap.emplace(std::make_pair( "wiggleVibratoSmallestSlow", 0xEAD1 )); // glyphnumber: 2562, Vibrato smallest, slow - outMap.emplace(std::make_pair( "wiggleVibratoSmallestSlower", 0xEAD2 )); // glyphnumber: 2563, Vibrato smallest, slower - outMap.emplace(std::make_pair( "wiggleVibratoSmallestSlowest", 0xEAD3 )); // glyphnumber: 2564, Vibrato smallest, slowest - outMap.emplace(std::make_pair( "wiggleVibratoStart", 0xEACC )); // glyphnumber: 2565, Vibrato start - outMap.emplace(std::make_pair( "wiggleVibratoWide", 0xEAB1 )); // glyphnumber: 2566, Wide vibrato / shake wiggle segment - outMap.emplace(std::make_pair( "wiggleWavy", 0xEAB5 )); // glyphnumber: 2567, Wavy line segment - outMap.emplace(std::make_pair( "wiggleWavyNarrow", 0xEAB4 )); // glyphnumber: 2568, Narrow wavy line segment - outMap.emplace(std::make_pair( "wiggleWavyWide", 0xEAB6 )); // glyphnumber: 2569, Wide wavy line segment - outMap.emplace(std::make_pair( "windClosedHole", 0xE5F4 )); // glyphnumber: 2570, Closed hole - outMap.emplace(std::make_pair( "windFlatEmbouchure", 0xE5FB )); // glyphnumber: 2571, Flatter embouchure - outMap.emplace(std::make_pair( "windHalfClosedHole1", 0xE5F6 )); // glyphnumber: 2572, Half-closed hole - outMap.emplace(std::make_pair( "windHalfClosedHole2", 0xE5F7 )); // glyphnumber: 2573, Half-closed hole 2 - outMap.emplace(std::make_pair( "windHalfClosedHole3", 0xE5F8 )); // glyphnumber: 2574, Half-open hole - outMap.emplace(std::make_pair( "windLessRelaxedEmbouchure", 0xE5FE )); // glyphnumber: 2575, Somewhat relaxed embouchure - outMap.emplace(std::make_pair( "windLessTightEmbouchure", 0xE600 )); // glyphnumber: 2576, Somewhat tight embouchure - outMap.emplace(std::make_pair( "windMouthpiecePop", 0xE60A )); // glyphnumber: 2577, Mouthpiece or hand pop - outMap.emplace(std::make_pair( "windMultiphonicsBlackStem", 0xE607 )); // glyphnumber: 2578, Combining multiphonics (black) for stem - outMap.emplace(std::make_pair( "windMultiphonicsBlackWhiteStem", 0xE609 )); // glyphnumber: 2579, Combining multiphonics (black and white) for stem - outMap.emplace(std::make_pair( "windMultiphonicsWhiteStem", 0xE608 )); // glyphnumber: 2580, Combining multiphonics (white) for stem - outMap.emplace(std::make_pair( "windOpenHole", 0xE5F9 )); // glyphnumber: 2581, Open hole - outMap.emplace(std::make_pair( "windReedPositionIn", 0xE606 )); // glyphnumber: 2582, Much more reed (push inwards) - outMap.emplace(std::make_pair( "windReedPositionNormal", 0xE604 )); // glyphnumber: 2583, Normal reed position - outMap.emplace(std::make_pair( "windReedPositionOut", 0xE605 )); // glyphnumber: 2584, Very little reed (pull outwards) - outMap.emplace(std::make_pair( "windRelaxedEmbouchure", 0xE5FD )); // glyphnumber: 2585, Relaxed embouchure - outMap.emplace(std::make_pair( "windRimOnly", 0xE60B )); // glyphnumber: 2586, Rim only - outMap.emplace(std::make_pair( "windSharpEmbouchure", 0xE5FC )); // glyphnumber: 2587, Sharper embouchure - outMap.emplace(std::make_pair( "windStrongAirPressure", 0xE603 )); // glyphnumber: 2588, Very tight embouchure / strong air pressure - outMap.emplace(std::make_pair( "windThreeQuartersClosedHole", 0xE5F5 )); // glyphnumber: 2589, Three-quarters closed hole - outMap.emplace(std::make_pair( "windTightEmbouchure", 0xE5FF )); // glyphnumber: 2590, Tight embouchure - outMap.emplace(std::make_pair( "windTrillKey", 0xE5FA )); // glyphnumber: 2591, Trill key - outMap.emplace(std::make_pair( "windVeryTightEmbouchure", 0xE601 )); // glyphnumber: 2592, Very tight embouchure - outMap.emplace(std::make_pair( "windWeakAirPressure", 0xE602 )); // glyphnumber: 2593, Very relaxed embouchure / weak air-pressure - } - } -} diff --git a/Sourcecode/mx/impl/TechnicalFunctions.cpp b/Sourcecode/mx/impl/TechnicalFunctions.cpp index 294acfaae..7c01e73c2 100644 --- a/Sourcecode/mx/impl/TechnicalFunctions.cpp +++ b/Sourcecode/mx/impl/TechnicalFunctions.cpp @@ -65,11 +65,6 @@ namespace mx if( isSuccess ) { - if( markData.smuflName.empty() && markData.smuflCodepoint == 0 ) - { - markData.smuflName = api::MarkSmufl::getName( markType, markData.positionData.placement ); - markData.smuflCodepoint = api::MarkSmufl::getCodepoint( markType, markData.positionData.placement ); - } outMarks.emplace_back( std::move( markData ) ); } } @@ -175,14 +170,7 @@ namespace mx parseMarkDataAttributes( attr, outMarkData ); const auto value = other.getValue().getValue(); - const auto charVal = api::Smufl::findCodepoint( value ); outMarkData.name = value; - - if( charVal != 0 ) - { - outMarkData.smuflName = value; - outMarkData.smuflCodepoint = charVal; - } return true; } diff --git a/Sourcecode/mx/utility/Throw.h b/Sourcecode/mx/utility/Throw.h index 9e1bbfa8c..73aeb6e23 100755 --- a/Sourcecode/mx/utility/Throw.h +++ b/Sourcecode/mx/utility/Throw.h @@ -5,6 +5,9 @@ #pragma once #include +#include +#include +#include #ifndef __FILENAME__ diff --git a/Sourcecode/mx/utility/Utility.h b/Sourcecode/mx/utility/Utility.h index 999d6fd9a..d4c6c10d1 100755 --- a/Sourcecode/mx/utility/Utility.h +++ b/Sourcecode/mx/utility/Utility.h @@ -4,6 +4,7 @@ #pragma once #include "mx/core/Document.h" +#include namespace mx { diff --git a/Sourcecode/mx/xml/XAttribute.h b/Sourcecode/mx/xml/XAttribute.h index 9b308ed29..3d25f2f43 100755 --- a/Sourcecode/mx/xml/XAttribute.h +++ b/Sourcecode/mx/xml/XAttribute.h @@ -6,6 +6,8 @@ #include #include +#include +#include namespace mx { diff --git a/Sourcecode/mx/xml/XElement.h b/Sourcecode/mx/xml/XElement.h index ce16e40fa..df7b9bf0a 100755 --- a/Sourcecode/mx/xml/XElement.h +++ b/Sourcecode/mx/xml/XElement.h @@ -7,6 +7,8 @@ #include #include +#include +#include namespace mx { diff --git a/Sourcecode/mx/xml/XElementIterator.h b/Sourcecode/mx/xml/XElementIterator.h index 91341c115..561826822 100755 --- a/Sourcecode/mx/xml/XElementIterator.h +++ b/Sourcecode/mx/xml/XElementIterator.h @@ -9,6 +9,8 @@ #include #include +#include +#include namespace mx { diff --git a/Sourcecode/mx/xml/XFactory.h b/Sourcecode/mx/xml/XFactory.h index d3942e0e1..efdd9f92c 100755 --- a/Sourcecode/mx/xml/XFactory.h +++ b/Sourcecode/mx/xml/XFactory.h @@ -6,6 +6,8 @@ #include "mx/xml/XDoc.h" #include +#include +#include namespace mx { diff --git a/Sourcecode/mxtest/api/ApiChordSimpleScoreData.h b/Sourcecode/mxtest/api/ApiChordSimpleScoreData.h index ddd6f670c..6e78dfe2b 100644 --- a/Sourcecode/mxtest/api/ApiChordSimpleScoreData.h +++ b/Sourcecode/mxtest/api/ApiChordSimpleScoreData.h @@ -5,7 +5,6 @@ #pragma once #include "mx/api/ScoreData.h" -#include "mx/api/Smufl.h" #include "mx/impl/Converter.h" #include "mx/core/Enums.h" diff --git a/Sourcecode/mxtest/api/ApiK007aScoreData.h b/Sourcecode/mxtest/api/ApiK007aScoreData.h index 0d1e3ab6b..f60225766 100644 --- a/Sourcecode/mxtest/api/ApiK007aScoreData.h +++ b/Sourcecode/mxtest/api/ApiK007aScoreData.h @@ -5,7 +5,6 @@ #pragma once #include "mx/api/ScoreData.h" -#include "mx/api/Smufl.h" #include "mx/impl/Converter.h" #include "mx/core/Enums.h" @@ -31,11 +30,9 @@ namespace noteP->noteAttachmentData.marks.emplace_back( MarkData{} ); auto& markData = noteP->noteAttachmentData.marks.back(); markData.markType = markType; - markData.smuflName = MarkSmufl::getName( markType ); mx::impl::Converter converter; const auto d = converter.convertDynamic( markType ); markData.name = mx::core::toString( d ); - markData.smuflCodepoint = MarkSmufl::getCodepoint( markType ); markData.tickTimePosition = noteP->tickTimePosition; markData.positionData.placement = Placement::below; } @@ -107,9 +104,7 @@ namespace mxtest auto& lastMeasure = part.measures.back(); auto& lastDynamic = lastMeasure.staves.back().voices[0].notes.back().noteAttachmentData.marks.back(); const std::string name = "dynamicNiente"; - lastDynamic.smuflName = name; lastDynamic.name = name; - lastDynamic.smuflCodepoint = Smufl::findCodepoint( name ); return score; } diff --git a/Sourcecode/mxtest/api/ApiK007cScoreData.h b/Sourcecode/mxtest/api/ApiK007cScoreData.h index 4ab71e8c0..70ed7bc2a 100644 --- a/Sourcecode/mxtest/api/ApiK007cScoreData.h +++ b/Sourcecode/mxtest/api/ApiK007cScoreData.h @@ -5,7 +5,6 @@ #pragma once #include "mx/api/ScoreData.h" -#include "mx/api/Smufl.h" #include "mx/impl/Converter.h" #include "mx/core/Enums.h" @@ -33,11 +32,9 @@ namespace auto& mark = direction.marks.back(); mark.markType = markType; - mark.smuflName = MarkSmufl::getName( markType ); mx::impl::Converter converter; const auto d = converter.convertDynamic( markType ); mark.name = mx::core::toString( d ); - mark.smuflCodepoint = MarkSmufl::getCodepoint( markType ); direction.tickTimePosition = noteP->tickTimePosition; direction.isStaffValueSpecified = false; mark.positionData.placement = Placement::below; @@ -110,9 +107,7 @@ namespace mxtest auto& lastMeasure = part.measures.back(); auto& lastDynamic = lastMeasure.staves.back().directions.back().marks.back(); const std::string name = "dynamicNiente"; - lastDynamic.smuflName = name; lastDynamic.name = name; - lastDynamic.smuflCodepoint = Smufl::findCodepoint( name ); return score; } diff --git a/Sourcecode/mxtest/api/ApiK009bSlurScoreData.h b/Sourcecode/mxtest/api/ApiK009bSlurScoreData.h index 992e2b0f3..dadb44889 100644 --- a/Sourcecode/mxtest/api/ApiK009bSlurScoreData.h +++ b/Sourcecode/mxtest/api/ApiK009bSlurScoreData.h @@ -5,7 +5,6 @@ #pragma once #include "mx/api/ScoreData.h" -#include "mx/api/Smufl.h" #include "mx/impl/Converter.h" #include "mx/core/Enums.h" diff --git a/Sourcecode/mxtest/api/ApiK014aFermatasScoreData.h b/Sourcecode/mxtest/api/ApiK014aFermatasScoreData.h index eabc19ab7..6b8b57979 100644 --- a/Sourcecode/mxtest/api/ApiK014aFermatasScoreData.h +++ b/Sourcecode/mxtest/api/ApiK014aFermatasScoreData.h @@ -5,7 +5,6 @@ #pragma once #include "mx/api/ScoreData.h" -#include "mx/api/Smufl.h" #include "mx/impl/Converter.h" #include "mx/core/Enums.h" diff --git a/Sourcecode/mxtest/api/ApiK015aLayoutScoreData.h b/Sourcecode/mxtest/api/ApiK015aLayoutScoreData.h index 64dc5d1d5..794200c8e 100644 --- a/Sourcecode/mxtest/api/ApiK015aLayoutScoreData.h +++ b/Sourcecode/mxtest/api/ApiK015aLayoutScoreData.h @@ -5,7 +5,6 @@ #pragma once #include "mx/api/ScoreData.h" -#include "mx/api/Smufl.h" #include "mx/impl/Converter.h" #include "mx/core/Enums.h" diff --git a/Sourcecode/mxtest/api/ApiK016aMiscScoreData.h b/Sourcecode/mxtest/api/ApiK016aMiscScoreData.h index ffaaf6643..5628bf5d6 100644 --- a/Sourcecode/mxtest/api/ApiK016aMiscScoreData.h +++ b/Sourcecode/mxtest/api/ApiK016aMiscScoreData.h @@ -5,7 +5,6 @@ #pragma once #include "mx/api/ScoreData.h" -#include "mx/api/Smufl.h" #include "mx/impl/Converter.h" #include "mx/core/Enums.h" diff --git a/Sourcecode/mxtest/api/ApiLy43eScoreData.h b/Sourcecode/mxtest/api/ApiLy43eScoreData.h index e835421b6..5af6239bf 100644 --- a/Sourcecode/mxtest/api/ApiLy43eScoreData.h +++ b/Sourcecode/mxtest/api/ApiLy43eScoreData.h @@ -44,9 +44,6 @@ namespace mxtest auto directionMarkP = &directionP->marks.back(); directionMarkP->markType = MarkType::ffff; directionMarkP->name = "ffff"; - auto glyph = &MarkSmufl::getSmuflGlyphname( directionMarkP->markType ); - directionMarkP->smuflName = glyph->below; - directionMarkP->smuflCodepoint = Smufl::findCodepoint( directionMarkP->smuflName ); directionMarkP->tickTimePosition = 0; // measure 1 - music @@ -107,9 +104,6 @@ namespace mxtest directionMarkP->tickTimePosition = directionP->tickTimePosition; directionMarkP->markType = MarkType::p; directionMarkP->name = "p"; - glyph = &MarkSmufl::getSmuflGlyphname( directionMarkP->markType ); - directionMarkP->smuflName = glyph->below; - directionMarkP->smuflCodepoint = Smufl::findCodepoint( directionMarkP->smuflName ); voice = 1; staff2P->voices[voice].notes.emplace_back( NoteData{} ); diff --git a/Sourcecode/mxtest/api/ApiMuAccidentals1ScoreData.h b/Sourcecode/mxtest/api/ApiMuAccidentals1ScoreData.h index 479279f55..e2ef19cef 100644 --- a/Sourcecode/mxtest/api/ApiMuAccidentals1ScoreData.h +++ b/Sourcecode/mxtest/api/ApiMuAccidentals1ScoreData.h @@ -5,7 +5,6 @@ #pragma once #include "mx/api/ScoreData.h" -#include "mx/api/Smufl.h" #include "mx/impl/Converter.h" #include "mx/core/Enums.h" diff --git a/Sourcecode/mxtest/api/FreezingTest.cpp b/Sourcecode/mxtest/api/FreezingTest.cpp index 51a27199c..988e512c7 100644 --- a/Sourcecode/mxtest/api/FreezingTest.cpp +++ b/Sourcecode/mxtest/api/FreezingTest.cpp @@ -13,7 +13,7 @@ using namespace std; using namespace mx::api; using namespace mxtest; - +#if 0 TEST( x, Freezing ) { const int partIndex = 1; // bass clarinet @@ -41,5 +41,5 @@ TEST( x, Freezing ) } T_END - +#endif #endif diff --git a/Sourcecode/mxtest/api/NoteDataTest.cpp b/Sourcecode/mxtest/api/NoteDataTest.cpp index 464e10a65..5d5434190 100644 --- a/Sourcecode/mxtest/api/NoteDataTest.cpp +++ b/Sourcecode/mxtest/api/NoteDataTest.cpp @@ -53,8 +53,7 @@ TEST( otherArticulation, NoteData ) note.noteAttachmentData.marks.emplace_back( Placement::unspecified, MarkType::otherArticulation ); note.noteAttachmentData.marks.back().positionData.isDefaultXSpecified = true; note.noteAttachmentData.marks.back().positionData.defaultX = 333.3; - note.noteAttachmentData.marks.back().name = "name"; - note.noteAttachmentData.marks.back().smuflName = "smuflName"; + note.noteAttachmentData.marks.back().name = "october 2018"; // round trip it through xml auto& mgr = DocumentManager::getInstance(); @@ -82,7 +81,70 @@ TEST( otherArticulation, NoteData ) CHECK( md.positionData.isDefaultXSpecified ); CHECK( !md.positionData.isDefaultYSpecified ); CHECK_DOUBLES_EQUAL( 333.3, md.positionData.defaultX, 0.00001 ); - CHECK_EQUAL( "name", md.name ); + CHECK_EQUAL( "october 2018", md.name ); + CHECK( md.positionData.placement == Placement::unspecified ); +} +T_END; + +TEST( customErrorUnknown, MarkData ) +{ + const auto expectedMark = mx::api::MarkType::customErrorUnknown; + const std::string expectedString = mx::api::markStringCustomErrorUnknown; + + const auto isCustom = mx::api::isMarkCustom( expectedMark ); + CHECK( !isCustom ); + const auto actualString = mx::api::getCustomMarkName( expectedMark ); + CHECK_EQUAL( expectedString, actualString ); + const auto actualMark = mx::api::getMarkTypeFromCustomString( actualString ); + CHECK( expectedMark == actualMark ); +} + +TEST( customArticulation, NoteData ) +{ + ScoreData score; + score.parts.emplace_back(); + auto& part = score.parts.back(); + part.measures.emplace_back(); + auto& measure = part.measures.back(); + measure.staves.emplace_back(); + auto& staff = measure.staves.back(); + auto& voice = staff.voices[0]; + voice.notes.emplace_back(); + auto& note = voice.notes.back(); + + note.noteAttachmentData.marks.emplace_back( Placement::unspecified, MarkType::customAccentTenuto ); + note.noteAttachmentData.marks.back().positionData.isDefaultXSpecified = true; + note.noteAttachmentData.marks.back().positionData.defaultX = 333.3; + + // round trip it through xml + auto& mgr = DocumentManager::getInstance(); + auto docId = mgr.createFromScore( score ); + std::stringstream ss; + mgr.writeToStream(docId, ss); + // TODO - SMUFLKILL - remove + mgr.writeToFile( docId, "./bloop.xml" ); + mgr.destroyDocument(docId); + const std::string xml = ss.str(); + std::istringstream iss{ xml }; + docId = mgr.createFromStream( iss ); + auto oscore = mgr.getData(docId); + + // get the data after the round trip + auto& opart = oscore.parts.back(); + auto& omeasure = opart.measures.back(); + auto& ostaff = omeasure.staves.back(); + auto& ovoice = ostaff.voices[0]; + auto& onote = ovoice.notes.back(); + auto& oattachments = onote.noteAttachmentData; + auto& omarks = oattachments.marks; + auto oIter = omarks.cbegin(); + + auto md = *oIter; + CHECK( md.markType == MarkType::customAccentTenuto ); + CHECK( md.positionData.isDefaultXSpecified ); + CHECK( !md.positionData.isDefaultYSpecified ); + CHECK_DOUBLES_EQUAL( 333.3, md.positionData.defaultX, 0.00001 ); + CHECK_EQUAL( mx::api::markStringCustomAccentTenuto, md.name ); CHECK( md.positionData.placement == Placement::unspecified ); } T_END; @@ -103,8 +165,7 @@ TEST( otherOrnament, NoteData ) note.noteAttachmentData.marks.emplace_back( Placement::unspecified, MarkType::otherOrnament ); note.noteAttachmentData.marks.back().positionData.isDefaultXSpecified = true; note.noteAttachmentData.marks.back().positionData.defaultX = 333.3; - note.noteAttachmentData.marks.back().name = "name"; - note.noteAttachmentData.marks.back().smuflName = "smuflName"; + note.noteAttachmentData.marks.back().name = "**()00))&"; // round trip it through xml auto& mgr = DocumentManager::getInstance(); @@ -132,7 +193,7 @@ TEST( otherOrnament, NoteData ) CHECK( md.positionData.isDefaultXSpecified ); CHECK( !md.positionData.isDefaultYSpecified ); CHECK_DOUBLES_EQUAL( 333.3, md.positionData.defaultX, 0.00001 ); - CHECK_EQUAL( "name", md.name ); + CHECK_EQUAL( "**()00))&", md.name ); CHECK( md.positionData.placement == Placement::unspecified ); } T_END; @@ -155,10 +216,9 @@ TEST( technical, NoteData ) note.noteAttachmentData.marks.back().positionData.defaultX = 123.0; note.noteAttachmentData.marks.emplace_back( Placement::above, MarkType::otherTechnical ); - note.noteAttachmentData.marks.back().name = "Bob"; - note.noteAttachmentData.marks.back().smuflName = "Charlie"; note.noteAttachmentData.marks.back().positionData.isDefaultYSpecified = true; note.noteAttachmentData.marks.back().positionData.defaultY = -456.0; + note.noteAttachmentData.marks.back().name = "Bob"; // round trip it through xml auto& mgr = DocumentManager::getInstance(); diff --git a/Sourcecode/mxtest/control/CompileControl.h b/Sourcecode/mxtest/control/CompileControl.h index 61aad3bac..bacab4ce7 100755 --- a/Sourcecode/mxtest/control/CompileControl.h +++ b/Sourcecode/mxtest/control/CompileControl.h @@ -6,7 +6,7 @@ #define MX_COMPILE_API_TESTS #define MX_COMPILE_API_ROUNDTRIP -//#define MX_COMPILE_CORE_TESTS +#define MX_COMPILE_CORE_TESTS #define MX_COMPILE_IMPL_TESTS #define MX_COMPILE_IMPORT_TESTS #define MX_COMPILE_NEW_DECIMAL_TESTS @@ -16,4 +16,4 @@ // use this to restrict the size of the files that // the test run will open (compile-time constant). // 0 indicates no limit -constexpr const int MX_COMPILE_MAX_FILE_SIZE_BYTES = 1024 * 3; // (1024 * 1024); +constexpr const int MX_COMPILE_MAX_FILE_SIZE_BYTES = 0; // 1024 * 3; // (1024 * 1024); diff --git a/Sublime/mx.sublime-project b/Sublime/mx.sublime-project index 645be1fcf..1d0c0fef8 100644 --- a/Sublime/mx.sublime-project +++ b/Sublime/mx.sublime-project @@ -2,7 +2,7 @@ "folders": [ { - "path": "../../MxRepo" + "path": ".." } ] } diff --git a/Sublime/mx.sublime-workspace b/Sublime/mx.sublime-workspace deleted file mode 100644 index 6da05ec8b..000000000 --- a/Sublime/mx.sublime-workspace +++ /dev/null @@ -1,1409 +0,0 @@ -{ - "auto_complete": - { - "selected_items": - [ - [ - "hours_per_po", - "hours_per_point_high" - ], - [ - "hour", - "hours_per_point_middle" - ], - [ - "start_d", - "project_start_date" - ], - [ - "pro", - "project_start_date" - ], - [ - "unpa", - "unparented_release_codes_temp" - ], - [ - "release", - "release_code" - ], - [ - "active", - "active_record_object" - ], - [ - "act", - "active_record_object" - ], - [ - "st", - "story_points" - ], - [ - "requir", - "requirement" - ], - [ - "tram", - "transformed_lines_2" - ], - [ - "tra", - "transformed_lines_2" - ], - [ - "letter", - "letter_only" - ], - [ - "colum", - "column_name" - ], - [ - "column", - "column_hash" - ], - [ - "colu", - "column_name" - ], - [ - "column_", - "column_hash" - ], - [ - "n", - "number" - ], - [ - "css", - "css_string" - ], - [ - "displ", - "display_image" - ], - [ - "bus", - "business-purpose" - ], - [ - "app", - "app_root" - ], - [ - "Non-Con", - "Non-Contiguous" - ], - [ - "te", - "technical" - ], - [ - "prefi", - "prefix-value" - ], - [ - "img", - "img_classes" - ], - [ - "image_", - "image_width_px" - ], - [ - "is_image", - "is_image_bordered" - ], - [ - "is", - "is_image_bordered" - ], - [ - "width", - "width_string" - ], - [ - "tech", - "tech_text_field" - ], - [ - "child", - "child_xml" - ], - [ - "text", - "text_fields" - ], - [ - "last_", - "last_doc_id" - ], - [ - "last", - "last_doc" - ], - [ - "id", - "id_to_delete" - ], - [ - "re", - "requirement" - ], - [ - "html", - "html_safe" - ], - [ - "is_", - "is_active_int" - ], - [ - "lec", - "legacy_int" - ], - [ - "rand", - "rand_int" - ], - [ - "tel", - "telcowords" - ], - [ - "redi", - "redirect_if_not_admi" - ], - [ - "au", - "authorized_user" - ], - [ - "Extension", - "ExtensionAlter" - ], - [ - "file", - "filepart" - ], - [ - "icon", - "icon_url" - ], - [ - "cmd", - "cmd_commit" - ], - [ - "total", - "merlin_total_tests" - ], - [ - "cmd_", - "cmd_author" - ], - [ - "dir_", - "dir_komp_repo" - ], - [ - "scoreAss", - "scoreAssertions" - ], - [ - "sco", - "scoreAssertions" - ], - [ - "ver", - "version_major" - ], - [ - "data", - "data_notationios_info_plist_result" - ], - [ - "new", - "new_line" - ], - [ - "version", - "version_to_replace" - ], - [ - "isK", - "is_key_found_this_time" - ], - [ - "komp", - "data_komp_info_plist" - ], - [ - "Draw", - "DrawResult" - ], - [ - "DrawRe", - "DrawResultCache" - ], - [ - "inDra", - "inDrawPoint" - ], - [ - "Drawab", - "DrawableUPtr" - ], - [ - "appl", - "applyJustification" - ], - [ - "Dra", - "DrawableLine" - ], - [ - "inUn", - "inUnscaledScoreY" - ], - [ - "unsca", - "unscaledScoreY" - ], - [ - "unscaled", - "unscaledScoreX" - ], - [ - "Spatial", - "SpatialPointIntf" - ], - [ - "Spatia", - "SpatialPointIntf" - ], - [ - "Key", - "KeySignatureType" - ], - [ - "KeySign", - "KeySignatureType" - ], - [ - "It", - "ItemRegistry" - ], - [ - "Harp", - "Harpsichord" - ], - [ - "Vib", - "Vibraphone" - ], - [ - "mBeat", - "mBeatTypeDots" - ], - [ - "BeamAngIn", - "BeamAngleIntfUPtr" - ], - [ - "getBeamedNote", - "getBeamedNoteCount" - ], - [ - "BeamedN", - "BeamedNoteIntfUPtrVec" - ], - [ - "Measure", - "MeasureAttachedDynamicParams" - ], - [ - "Octave", - "OctaveType" - ], - [ - "MxNote", - "MxNoteSpannerStack" - ], - [ - "MxNotre", - "MxNoteSpannerPtr" - ], - [ - "fontFamil", - "fontFamilyData" - ], - [ - "my", - "myScoreDataCreator" - ], - [ - "expected", - "expectedOctave" - ], - [ - "PartwiseMe", - "PartwiseMeasurePtr" - ], - [ - "QUARTER_", - "QUARTER_FLAT" - ], - [ - "SHAR", - "SHARP_SHARP" - ], - [ - "DOUBLE_", - "DOUBLE_SHARP" - ], - [ - "DOUBLE", - "DOUBLE_SHARP" - ], - [ - "Syst", - "SystemLayoutInfo" - ], - [ - "M", - "FileMediatorFactory" - ], - [ - "globa", - "globalTicksPerQuarter" - ], - [ - "Time", - "TimeSignatureSymbol" - ], - [ - "new_", - "new_identifier" - ], - [ - "attribute", - "attributes_classes" - ], - [ - "attrib", - "attributes_classes" - ], - [ - "fro", - "from_xelement_code" - ], - [ - "par", - "parsing_statement" - ], - [ - "hmem", - "hmembers" - ], - [ - "type", - "type_capture" - ], - [ - "name", - "name_capture" - ], - [ - "hlines", - "hlines_last_member" - ], - [ - "elision", - "elisionSyllabicTextGroup" - ], - [ - "XEleme", - "XElementIterator" - ], - [ - "do", - "doDecrementIter" - ], - [ - "eleme", - "element_name" - ], - [ - "element_na", - "element_name_for_cpp" - ], - [ - "Ele", - "ElementInterface" - ], - [ - "line", - "line_instruction" - ], - [ - "line_info", - "line_info_collection" - ], - [ - "all_", - "all_symbols" - ], - [ - "all", - "all_classes" - ], - [ - "require", - "require_relative" - ], - [ - "cpp", - "cpp_functions" - ], - [ - "req", - "require_relative" - ], - [ - "enum", - "enum_list" - ], - [ - "for", - "forwardDeclare" - ], - [ - "decl", - "declaration_line" - ], - [ - "line_in", - "temp_line_instructions" - ], - [ - "end", - "end_line" - ], - [ - "H", - "HDeclarationLine" - ], - [ - "matc", - "matches" - ] - ] - }, - "buffers": - [ - ], - "build_system": "", - "build_system_choices": - [ - ], - "build_varint": "", - "command_palette": - { - "height": 392.0, - "last_filter": "Package Control: Install Package", - "selected_items": - [ - [ - "Package Control: Install Package", - "Package Control: Install Package" - ] - ], - "width": 449.0 - }, - "console": - { - "height": 146.0, - "history": - [ - "import urllib.request,os,hashlib; h = 'df21e130d211cfc94d9b0905775a7c0f' + '1e3d39e33b79698005270310898eea76'; pf = 'Package Control.sublime-package'; ipp = sublime.installed_packages_path(); urllib.request.install_opener( urllib.request.build_opener( urllib.request.ProxyHandler()) ); by = urllib.request.urlopen( 'http://packagecontrol.io/' + pf.replace(' ', '%20')).read(); dh = hashlib.sha256(by).hexdigest(); print('Error validating download (got %s instead of %s), please try manual install' % (dh, h)) if dh != h else open(os.path.join( ipp, pf), 'wb' ).write(by)" - ] - }, - "distraction_free": - { - "menu_visible": true, - "show_minimap": false, - "show_open_files": false, - "show_tabs": false, - "side_bar_visible": false, - "status_bar_visible": false - }, - "expanded_folders": - [ - "/Users/mjb/repos/mx" - ], - "file_history": - [ - "/Users/mjb/Library/Developer/Xcode/DerivedData/mx-bsuewfrvqkwhdoejyflracifumto/Build/Products/Debug/bloop.xml", - "/Users/mjb/repos/mx/Sourcecode/mx/impl/DynamicsReader.cpp", - "/Users/mjb/repos/mx/DevScripts/smuflHeader.rb", - "/Users/mjb/repos/mx/Sourcecode/mx/impl/DynamicsWriter.cpp", - "/Users/mjb/repos/mx/Sourcecode/mx/impl/NotationsWriter.cpp", - "/Users/mjb/repos/mx/Sourcecode/mx/impl/OrnamentsFunctions.cpp", - "/Users/mjb/repos/mx/Sourcecode/mx/impl/TechnicalFunctions.cpp", - "/Users/mjb/repos/mx/Sourcecode/mxtest/api/ApiK007aScoreData.h", - "/Users/mjb/repos/mx/Sourcecode/mxtest/api/ApiK007cScoreData.h", - "/Users/mjb/repos/mx/Sourcecode/mxtest/api/ApiLy43eScoreData.h", - "/Users/mjb/repos/mx/Sourcecode/mxtest/api/NoteDataTest.cpp", - "/Users/mjb/repos/mx/Sourcecode/mx/impl/MeasureReader.cpp", - "/Users/mjb/repos/mx/Sourcecode/mxtest/api/ApiChordSimpleScoreData.h", - "/Users/mjb/repos/mx/Sourcecode/mxtest/api/ApiK009bSlurScoreData.h", - "/Users/mjb/repos/mx/Sourcecode/mxtest/api/ApiK014aFermatasScoreData.h", - "/Users/mjb/repos/mx/Sourcecode/mxtest/api/ApiK015aLayoutScoreData.h", - "/Users/mjb/repos/mx/Sourcecode/mxtest/api/ApiK016aMiscScoreData.h", - "/Users/mjb/repos/mx/Sourcecode/mxtest/api/ApiMuAccidentals1ScoreData.h", - "/Users/mjb/repos/mx/Xcode/mx.xcworkspace/xcuserdata/mjb.xcuserdatad/UserInterfaceState.xcuserstate", - "/Users/mjb/repos/mx/Sourcecode/mx/impl/AccidentalMarkFunctions.cpp", - "/Users/mjb/repos/mx/Sourcecode/mx/impl/DirectionReader.cpp", - "/Users/mjb/repos/mx/Sourcecode/mx/impl/ArticulationsFunctions.cpp", - "/Users/mjb/repos/mx/Sourcecode/mx/api/MarkData.h", - "/Users/mjb/repos/mx/Sourcecode/mx/api/MarkData.cpp", - "/Users/mjb/MxRepo/Documents/musicxml.xsd", - "/Users/mjb/MxRepo/Resources/mjbsuite/freezing-measure-numbers.rb", - "/Users/mjb/MxRepo/Resources/mjbsuite/freezing.xml", - "/Users/mjb/MxRepo/Resources/mjbsuite/freezing.old.xml", - "/Users/mjb/MxRepo/Sourcecode/mx/impl/PartReader.h", - "/Users/mjb/MxRepo/Sourcecode/mx/impl/PartReader.cpp", - "/Users/mjb/MxRepo/Resources/mjbsuite/PreserveTimeModificationNormalType.xml", - "/Users/mjb/MxRepo/Sourcecode/mx/core/elements/NormalType.h", - "/Users/mjb/MxRepo/Sourcecode/mx/core/elements/NormalTypeNormalDotGroup.h", - "/Users/mjb/MxRepo/Sourcecode/mx/core/elements/Note.h", - "/Users/mjb/Desktop/blerp.xml", - "/Users/mjb/MxRepo/Resources/mjbsuite/HasMusicXmlVersionTrue.xml", - "/Users/mjb/MxRepo/Resources/lysuite/ly43e_Multistaff_ClefDynamics.xml", - "/Users/mjb/MxRepo/Resources/ksuite/k014a_Fermatas.xml", - "/Users/mjb/MxRepo/Sourcecode/mx/core/elements/CreditWords.h", - "/Users/mjb/MxRepo/Sourcecode/mx/core/elements/CreditWordsAttributes.h", - "/Users/mjb/MxRepo/Sourcecode/mx/impl/MxVersionDefines.h", - "/Users/mjb/MxRepo/DevScripts/mxdeploy-v01.rb", - "/Users/mjb/MxRepo/Sourcecode/mx/api/ScoreData.h", - "/Users/mjb/MxRepo/Sourcecode/mxtest/file/MxFileTestGroup.cpp", - "/Users/mjb/MxRepo/Resources/mjbsuite/ChordDirectionPlacement.xml", - "/Users/mjb/MxRepo/Sourcecode/mx/core/elements/ScoreHeaderGroup.h", - "/Users/mjb/MxRepo/Sourcecode/mx/core/elements/Appearance.h", - "/Users/mjb/MxRepo/Sourcecode/mx/core/elements/Tenths.h", - "/Users/mjb/MxRepo/Sourcecode/mx/core/elements/OtherAppearance.h", - "/Users/mjb/MxRepo/Sourcecode/mx/api/MarkData.h", - "/Users/mjb/MxRepo/Sublime/mx.sublime-project", - "/Users/mjb/Library/Developer/Xcode/Templates/File Templates/Source/Mx Api C++ File.xctemplate/WithHeader/___FILEBASENAME___.h", - "/Users/mjb/Library/Developer/Xcode/Templates/File Templates/Source/Mx Api C++ File.xctemplate/WithHeader/___FILEBASENAME___.cpp", - "/Users/mjb/Library/Developer/Xcode/Templates/File Templates/Source/Mx Api C++ File.xctemplate/Default/___FILEBASENAME___.cpp", - "/Users/mjb/Bitflip/Clients/Inteliquent/Data/CDRExample.json", - "/Users/mjb/iqreq/data/RoldansFormulas.txt", - "/Users/mjb/iqreq/data/RoldansRules.rb", - "/Users/mjb/iqreq/data/RoldansRules.txt", - "/Users/mjb/iqreq/data/requirements.xml", - "/Users/mjb/iqreq/app/controllers/documents_controller.rb", - "/Users/mjb/iqreq/app/controllers/releases_controller.rb", - "/Users/mjb/iqreq/app/models/document.rb", - "/Users/mjb/iqreq/db/schema.rb", - "/Users/mjb/iqreq/scripts/reqxml.rb", - "/Users/mjb/iqreq/scripts/reqxml-deserialize.rb", - "/Users/mjb/iqreq/app/models/epic.rb", - "/Users/mjb/iqreq/scripts/load-xml.rb", - "/Users/mjb/iqreq/scripts/insert-data.rb", - "/Users/mjb/iqreq/db/migrate/20171115204408_add_hours_per_week_to_documents.rb", - "/Users/mjb/iqreq/app/views/releases/show.html.erb", - "/Users/mjb/Downloads/NpaNxxJur_20171105-20171111_365Wireless.csv", - "/Users/mjb/Downloads/5f2e45e3845c4d59a52fc5326a342e4e (1).csv", - "/Users/mjb/iqreq/app/helpers/documents_helper.rb", - "/Users/mjb/iqreq/app/views/documents/load_xml.html.erb", - "/Users/mjb/iqreq/config/database.yml", - "/Users/mjb/iqreq/config/routes.rb", - "/Users/mjb/iqreq/Gemfile", - "/Users/mjb/iqreq/app/views/documents/simple.html.erb", - "/Users/mjb/iqreq/data/dxcreate/dxcreate/docx-templates/StylesList.txt", - "/Users/mjb/iqreq/.gitignore", - "/Users/mjb/iqreq/data/StylesList.txt", - "/Users/mjb/Desktop/uncompressed.docx", - "/Users/mjb/iqreq/app/views/documents/docx_view.docx.erb", - "/Users/mjb/Library/Application Support/Sublime Text 3/Packages/User/iqreq.sublime-build", - "/Users/mjb/Desktop/silly.txt", - "/Users/mjb/iqreq/data/sql-files/Story Point Select.sql", - "/Users/mjb/iqreq/db/migrate/20171111161927_priority_release.rb", - "/Users/mjb/iqreq/app/models/requirement.rb", - "/Users/mjb/iqreq/app/views/documents/liquid_planner.csv.erb", - "/Users/mjb/iqreq/app/src/liquid_planner_row.rb", - "/Users/mjb/iqreq/app/models/estimate.rb", - "/Users/mjb/iqreq/app/views/documents/show.html.erb", - "/Users/mjb/iqreq/data/Insert INTO PricingTables.sql", - "/Users/mjb/Desktop/Notes from Tim Schneeberger.txt", - "/Users/mjb/Bitflip/Logo Derivatives/bitlip.blue.txt", - "/Users/mjb/Dropbox/Memories.txt", - "/Users/mjb/Desktop/chart1.html", - "/Users/mjb/Desktop/Dads PSA.csv", - "/Users/mjb/Bitflip/Inteliquent/Targets/TWC-SeptemberMou-Targets-inserts.sql", - "/Users/mjb/Bitflip/Inteliquent/Targets/Comcast-September-Mou-Targets-inserts.sql", - "/Users/mjb/Bitflip/Inteliquent/Targets/Cablevision-September-Mou-Targets-inserts.sql", - "/Users/mjb/Bitflip/Inteliquent/Targets/Cablevision-September-Mou-Targets-transformed.csv", - "/Users/mjb/Bitflip/Inteliquent/Targets/TWC-SeptemberMouTargets-Transformed.csv", - "/Users/mjb/komp/Notation/Notation-Sourcecode/Score/ScoreCreationInfo.cc", - "/Users/mjb/iqreq/scripts/clear-db.rb", - "/Users/mjb/iqreq/app/assets/javascripts/noframework.waypoints.js", - "/Users/mjb/iqreq/app/assets/javascripts/anchor_scroll.js", - "/Users/mjb/iqreq/app/views/documents/_waypoints.html.erb", - "/Users/mjb/iqreq/app/models/group.rb", - "/Users/mjb/iqreq/app/views/documents/_req_table.html.erb", - "/Users/mjb/iqreq/app/helpers/application_helper.rb", - "/Users/mjb/iqreq/app/assets/javascripts/application.js", - "/Users/mjb/iqreq/Gemfile.lock", - "/Users/mjb/iqreq/config/initializers/assets.rb", - "/Users/mjb/iqreq/app/assets/stylesheets/req-styles.css", - "/Users/mjb/iqreq/app/views/documents/_leftside_navigation.html.erb", - "/Users/mjb/Desktop/OrigCustMouRevCogs.csv", - "/Users/mjb/iqreq/data/SELECT.sql", - "/Users/mjb/iqreq/app/views/documents/_groups.html.erb", - "/Users/mjb/iqreq/app/views/documents/_group_business_purpose.html.erb", - "/Users/mjb/iqreq/data/RoldansColumns.txt", - "/Users/mjb/iqreq/data/MattsRules.txt", - "/Users/mjb/rtut/simple_cms/app/views/admin_users/delete.html.erb", - "/Users/mjb/Desktop/rails.txt", - "/Users/mjb/iqreq/scripts/xml.rb", - "/Users/mjb/iqreq/scripts/xml-new.rb", - "/Users/mjb/iqreq/app/models/text_field.rb", - "/Users/mjb/iqreq/vendor/bundle/ruby/2.4.0/gems/rails-dom-testing-2.0.3/lib/rails/dom/testing/assertions/selector_assertions/count_describable.rb" - ], - "find": - { - "height": 44.0 - }, - "find_in_files": - { - "height": 281.0, - "where_history": - [ - "/Users/mjb/repos/mx", - "" - ] - }, - "find_state": - { - "case_sensitive": false, - "find_history": - [ - "smufl", - "\n#include \"mx/api/Smufl.h\"", - "smufl", - "Smuf", - "smufl", - "tremolo\"", - "/>", - "", - "\n tickTimePosition = ", - "tickTimePosition = ", - " [", - "\"note\"", - "", - "\n \n \n ", - "\n \n \n \n 60\n 1\n quarter\n \n \n \n 15\n 1\n 16th\n ", - "MX_VERSION", - "MINOR =", - "0.3", - " ", - "\">", - "name=\"print-style-align\"", - "\"print-style-align\"", - "\"direction\"", - "\"directive\"", - "\"direction\"", - "\"measure\"", - "measure number=\"X", - "measure number=\"X7\"", - "", - "distance-type", - "\"line-width-type\"", - "\"line-width\"", - "line-width" - ], - "highlight": true, - "in_selection": false, - "preserve_case": false, - "regex": false, - "replace_history": - [ - "S-M-U-F-L", - "", - " />", - " + + + + CFBundleDevelopmentRegion + en + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + FMWK + CFBundleShortVersionString + 1.0 + CFBundleVersion + $(CURRENT_PROJECT_VERSION) + NSPrincipalClass + + + diff --git a/Xcode/MxiOS/Info.plist~develop b/Xcode/MxiOS/Info.plist~develop new file mode 100644 index 000000000..fbe1e6b31 --- /dev/null +++ b/Xcode/MxiOS/Info.plist~develop @@ -0,0 +1,24 @@ + + + + + CFBundleDevelopmentRegion + en + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + FMWK + CFBundleShortVersionString + 1.0 + CFBundleVersion + $(CURRENT_PROJECT_VERSION) + NSPrincipalClass + + +