Upload 1139 files

.gitattributes

@@ -32,3 +32,10 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+lilypond-2.24.2/bin/libgio-2.0-0.dll filter=lfs diff=lfs merge=lfs -text
+lilypond-2.24.2/bin/libglib-2.0-0.dll filter=lfs diff=lfs merge=lfs -text
+lilypond-2.24.2/bin/lilypond.exe filter=lfs diff=lfs merge=lfs -text
+lilypond-2.24.2/bin/python310.dll filter=lfs diff=lfs merge=lfs -text
+lilypond-2.24.2/lib/guile/2.2/ccache/system/vm/assembler.go filter=lfs diff=lfs merge=lfs -text
+lilypond-2.24.2/lib/guile/2.2/ccache/system/vm/dwarf.go filter=lfs diff=lfs merge=lfs -text
+lilypond-2.24.2/libexec/gs.exe filter=lfs diff=lfs merge=lfs -text

lilypond-2.24.2/bin/abc2ly.py

@@ -0,0 +1,1557 @@
+#!/home/lily/lilypond-2.24.2/release/binaries/dependencies/install/Python-3.10.8/bin/python3.10
+# -*- coding: utf-8 -*-
+
+# once upon a rainy monday afternoon.
+
+#    This file is part of LilyPond, the GNU music typesetter.
+#
+#    Copyright (C) 1999--2022  Han-Wen Nienhuys <[email protected]>
+#                              Jan Nieuwenhuizen <[email protected]>
+#
+#    LilyPond is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    LilyPond is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+
+#
+#   ...
+#
+# (not finished.)
+# ABC standard v1.6:  http://abcnotation.com/
+#
+# Enhancements  (Roy R. Rankin)
+#
+# Header section moved to top of lilypond file
+# handle treble, treble-8, alto, and bass clef
+# Handle voices (V: headers) with clef and part names, multiple voices
+# Handle w: lyrics with multiple verses
+# Handle key mode names for minor, major, phrygian, ionian, locrian, aeolian,
+#     mixolydian, lydian, dorian
+# Handle part names from V: header
+# Tuplets handling fixed up
+# Lines starting with |: not discarded as header lines
+# Multiple T: and C: header entries handled
+# Accidental maintained until next bar check
+# Silent rests supported
+# articulations fermata, upbow, downbow, ltoe, accent, tenuto supported
+# Chord strings([-^]"string") can contain a '#'
+# Header fields enclosed by [] in notes string processed
+# W: words output after tune as abc2ps does it (they failed before)
+
+# Enhancements (Laura Conrad)
+#
+# Barring now preserved between ABC and lilypond
+# the default placement for text in abc is above the staff.
+# %%LY now supported.
+# \breve and \longa supported.
+# M:none doesn't crash lily.
+# lilypond '--' supported.
+
+# Enhancements (Guy Gascoigne-Piggford)
+#
+# Add support for maintaining ABC's notion of beaming, this is selectable
+# from the command line with a -b or --beam option.
+# Fixd a problem where on cygwin empty lines weren't being correctly identifed
+# and so were complaining, but still generating the correct output.
+
+# Limitations
+#
+# Multiple tunes in single file not supported
+# Blank T: header lines should write score and open a new score
+# Not all header fields supported
+# ABC line breaks are ignored
+# Block comments generate error and are ignored
+# Postscript commands are ignored
+# lyrics not resynchronized by line breaks (lyrics must fully match notes)
+# %%LY slyrics can't be directly before a w: line.
+# ???
+
+
+# TODO:
+#
+# * coding style
+# * lilylib
+# * GNU style messages:  warning:FILE:LINE:
+# * l10n
+#
+# Convert to new chord styles.
+#
+# UNDEF -> None
+#
+
+import __main__
+import getopt
+import gettext
+import os
+import re
+import sys
+
+"""
+
+# relocate-preamble.py.in
+#
+# This file is part of LilyPond, the GNU music typesetter.
+#
+# Copyright (C) 2007--2022  Han-Wen Nienhuys <[email protected]>
+#
+# LilyPond is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# LilyPond is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+This is generic code, used for all python scripts.
+
+The quotes are to ensure that the source .py file can still be
+run as a python script, but does not include any sys.path handling.
+Otherwise, the lilypond-book calls inside the build
+might modify installed .pyc files.
+
+"""
+
+# This is needed for installations with a non-default layout, ie where share/
+# is not next to bin/.
+sys.path.insert (0, os.path.join ('/home/lily/lilypond-2.24.2/release/binaries/mingw/lilypond/install/share/lilypond/2.24.2', 'python'))
+
+# Dynamic relocation, for installations with a default layout including GUB,
+# but also for execution from the build directory.
+bindir = os.path.abspath (os.path.dirname (sys.argv[0]))
+topdir = os.path.dirname (bindir)
+if bindir.endswith (r'/scripts/out'):
+    topdir = os.path.join (os.path.dirname (topdir), 'out')
+datadir = os.path.abspath (os.path.join (topdir, 'share', 'lilypond'))
+for v in [ 'current', '2.24.2' ]:
+    sys.path.insert (0, os.path.join (datadir, v, 'python'))
+
+"""
+"""
+
+# Load translation and install _() into Python's builtins namespace.
+gettext.install('lilypond', '/home/lily/lilypond-2.24.2/release/binaries/mingw/lilypond/install/share/locale')
+
+import lilylib as ly
+
+version = '2.24.2'
+if version == '@' + 'TOPLEVEL_VERSION' + '@':
+    version = '(unknown version)'                # uGUHGUHGHGUGH
+
+UNDEF = 255
+state = UNDEF
+voice_idx_dict = {}
+header = {}
+header['footnotes'] = ''
+lyrics = []
+slyrics = []
+voices = []
+state_list = []
+repeat_state = [0] * 8
+current_voice_idx = -1
+current_lyric_idx = -1
+lyric_idx = -1
+part_names = 0
+default_len = 8
+length_specified = 0
+nobarlines = 0
+global_key = [0] * 7                        # UGH
+names = ["One", "Two", "Three"]
+DIGITS = '0123456789'
+HSPACE = ' \t'
+midi_specs = ''
+
+
+def error(msg):
+    sys.stderr.write(msg)
+    if global_options.strict:
+        sys.exit(1)
+
+
+def alphabet(i):
+    return chr(i + ord('A'))
+
+
+def check_clef(s):
+    # the number gives the base_octave
+    clefs = [("treble", "treble", 0),
+             ("treble1", "french", 0),
+             ("bass3", "varbaritone", 0),
+             ("bass", "bass", 0),
+             ("alto4", "tenor", 0),
+             ("alto2", "mezzosoprano", 0),
+             ("alto1", "soprano", 0),
+             ("alto", "alto", 0),
+             ("perc", "percussion", 0)]
+    modifier = [("-8va", "_8", -1),
+                ("-8", "_8", -1),
+                (r"\+8", "^8", +1),
+                ("8", "_8", -1)]
+
+    if not s:
+        return ''
+    clef = None
+    octave = 0
+    for c in clefs:
+        m = re.match('^'+c[0], s)
+        if m:
+            (clef, octave) = (c[1], c[2])
+            s = s[m.end():]
+            break
+    if not clef:
+        return s
+
+    mod = ""
+    for md in modifier:
+        m = re.match('^'+md[0], s)
+        if m:
+            mod = md[1]
+            octave += md[2]
+            s = s[m.end():]
+            break
+
+    state.base_octave = octave
+    voices_append("\\clef \""+clef+mod+"\"\n")
+    return s
+
+
+def select_voice(name, rol):
+    if name not in voice_idx_dict:
+        state_list.append(Parser_state())
+        voices.append('')
+        slyrics.append([])
+        voice_idx_dict[name] = len(voices) - 1
+    __main__.current_voice_idx = voice_idx_dict[name]
+    __main__.state = state_list[current_voice_idx]
+    while rol != '':
+        m = re.match('^([^ \t=]*)=(.*)$', rol)  # find keywork
+        if m:
+            keyword = m.group(1)
+            rol = m.group(2)
+            a = re.match('^("[^"]*"|[^ \t]*) *(.*)$', rol)
+            if a:
+                value = a.group(1)
+                rol = a.group(2)
+                if keyword == 'clef':
+                    check_clef(value)
+                elif keyword == "name":
+                    value = re.sub('\\\\', '\\\\\\\\', value)
+                    # < 2.2
+                    voices_append("\\set Staff.instrument = %s\n" % value)
+
+                    __main__.part_names = 1
+                elif keyword == "sname" or keyword == "snm":
+                    voices_append("\\set Staff.instr = %s\n" % value)
+        else:
+            break
+
+
+def dump_header(outf, hdr):
+    outf.write('\\header {\n')
+    ks = sorted(hdr.keys())
+    for k in ks:
+        hdr[k] = re.sub('"', '\\"', hdr[k])
+        outf.write('\t%s = "%s"\n' % (k, hdr[k]))
+    outf.write('}')
+
+
+def dump_lyrics(outf):
+    if lyrics:
+        outf.write("\n\\markup \\column {\n")
+        for i in range(len(lyrics)):
+            outf.write(lyrics[i])
+            outf.write("\n")
+        outf.write("}\n")
+
+
+def dump_default_bar(outf):
+    """
+    Nowadays abc2ly outputs explicits barlines (?)
+    """
+    # < 2.2
+    outf.write("\n\\set Score.measureBarType = \"\"\n")
+
+
+def dump_slyrics(outf):
+    ks = sorted(voice_idx_dict.keys())
+    for k in ks:
+        if re.match('[1-9]', k):
+            m = alphabet(int(k))
+        else:
+            m = k
+        for i in range(len(slyrics[voice_idx_dict[k]])):
+            l = alphabet(i)
+            outf.write("\nwords%sV%s = \\lyricmode {" % (m, l))
+            outf.write("\n" + slyrics[voice_idx_dict[k]][i])
+            outf.write("\n}")
+
+
+def dump_voices(outf):
+    global doing_alternative, in_repeat
+    ks = sorted(voice_idx_dict.keys())
+    for k in ks:
+        if re.match('[1-9]', k):
+            m = alphabet(int(k))
+        else:
+            m = k
+        outf.write("\nvoice%s =  {" % m)
+        dump_default_bar(outf)
+        if repeat_state[voice_idx_dict[k]]:
+            outf.write("\n\\repeat volta 2 {")
+        outf.write("\n" + voices[voice_idx_dict[k]])
+        if not using_old:
+            if doing_alternative[voice_idx_dict[k]]:
+                outf.write("}")
+            if in_repeat[voice_idx_dict[k]]:
+                outf.write("}")
+        outf.write("\n}")
+
+
+def try_parse_q(a):
+    # assume that Q takes the form "Q:'opt. description' 1/4=120"
+    # There are other possibilities, but they are deprecated
+    r = re.compile(r'^(.*) *([0-9]+) */ *([0-9]+) *=* *([0-9]+)\s*')
+    m = r.match(a)
+    if m:
+        descr = m.group(1)  # possibly empty
+        numerator = int(m.group(2))
+        denominator = int(m.group(3))
+        tempo = m.group(4)
+        dur = duration_to_lilypond_duration((numerator, denominator), 1, 0)
+        voices_append("\\tempo " + descr + " " + dur + "=" + tempo + "\n")
+    else:
+        # Parsing of numeric tempi, as these are fairly
+        # common.  The spec says the number is a "beat" so using
+        # a quarter note as the standard time
+        numericQ = re.compile('[0-9]+')
+        m = numericQ.match(a)
+        if m:
+            voices_append("\\tempo 4=" + m.group(0))
+        else:
+            sys.stderr.write(
+                "abc2ly: Warning, unable to parse Q specification: %s\n" % a)
+
+
+def dump_score(outf):
+    outf.write(r"""
+
+\score{
+    <<
+""")
+
+    ks = sorted(voice_idx_dict.keys())
+    for k in ks:
+        if re.match('[1-9]', k):
+            m = alphabet(int(k))
+        else:
+            m = k
+        if k == 'default' and len(voice_idx_dict) > 1:
+            break
+        outf.write("\n\t\\context Staff=\"%s\"\n\t{\n" % k)
+        if k != 'default':
+            outf.write("\t    \\voicedefault\n")
+        outf.write("\t    \\voice%s " % m)
+        outf.write("\n\t}\n")
+
+        l = ord('A')
+        for lyrics in slyrics[voice_idx_dict[k]]:
+            outf.write("\n\t\\addlyrics {\n")
+            if re.match('[1-9]', k):
+                m = alphabet(int(k))
+            else:
+                m = k
+
+            outf.write(" \\words%sV%s } " % (m, chr(l)))
+            l += 1
+
+    outf.write("\n    >>")
+    outf.write("\n\t\\layout {\n")
+    outf.write("\t}\n\t\\midi {%s}\n}\n" % midi_specs)
+
+
+def set_default_length(s):
+    global length_specified
+    m = re.search('1/([0-9]+)', s)
+    if m:
+        __main__.default_len = int(m.group(1))
+        length_specified = 1
+
+
+def set_default_len_from_time_sig(s):
+    m = re.search('([0-9]+)/([0-9]+)', s)
+    if m:
+        n = int(m.group(1))
+        d = int(m.group(2))
+        if (n * 1.0)/(d * 1.0) < 0.75:
+            __main__.default_len = 16
+        else:
+            __main__.default_len = 8
+
+
+def gulp_file(f):
+    try:
+        i = open(f, encoding="utf8")
+        i.seek(0, 2)
+        n = i.tell()
+        i.seek(0, 0)
+    except FileNotFoundError:
+        sys.stderr.write("cannot open file: `%s'\n" % f)
+        return ''
+    s = i.read(n)
+    if len(s) <= 0:
+        sys.stderr.write("gulped empty file: `%s'\n" % f)
+    i.close()
+    return s
+
+
+# pitch manipulation. Tuples are (name, alteration).
+# 0 is (central) C. Alteration -1 is a flat, Alteration +1 is a sharp
+# pitch in semitones.
+def semitone_pitch(tup):
+    p = 0
+
+    t = tup[0]
+    p = p + 12 * (t // 7)
+    t = t % 7
+
+    if t > 2:
+        p = p - 1
+
+    p = p + t * 2 + tup[1]
+    return p
+
+
+def fifth_above_pitch(tup):
+    (n, a) = (tup[0] + 4, tup[1])
+
+    difference = 7 - (semitone_pitch((n, a)) - semitone_pitch(tup))
+    a = a + difference
+
+    return (n, a)
+
+
+def sharp_keys():
+    p = (0, 0)
+    l = []
+    k = 0
+    while True:
+        l.append(p)
+        (t, a) = fifth_above_pitch(p)
+        if semitone_pitch((t, a)) % 12 == 0:
+            break
+
+        p = (t % 7, a)
+    return l
+
+
+def flat_keys():
+    p = (0, 0)
+    l = []
+    k = 0
+    while True:
+        l.append(p)
+        (t, a) = quart_above_pitch(p)
+        if semitone_pitch((t, a)) % 12 == 0:
+            break
+
+        p = (t % 7, a)
+    return l
+
+
+def quart_above_pitch(tup):
+    (n, a) = (tup[0] + 3, tup[1])
+
+    difference = 5 - (semitone_pitch((n, a)) - semitone_pitch(tup))
+    a = a + difference
+
+    return (n, a)
+
+
+key_lookup = {         # abc to lilypond key mode names
+    'm': 'minor',
+    'min': 'minor',
+    'maj': 'major',
+    'major': 'major',
+    'phr': 'phrygian',
+    'ion': 'ionian',
+    'loc': 'locrian',
+    'aeo': 'aeolian',
+    'mix': 'mixolydian',
+    'mixolydian': 'mixolydian',
+    'lyd': 'lydian',
+    'dor': 'dorian',
+    'dorian': 'dorian'
+}
+
+
+def lily_key(k):
+    if k == 'none':
+        return
+    orig = "" + k
+    # UGR
+    k = k.lower()
+    key = k[0]
+    # UGH
+    k = k[1:]
+    if k and k[0] == '#':
+        key = key + 'is'
+        k = k[1:]
+    elif k and k[0] == 'b':
+        key = key + 'es'
+        k = k[1:]
+    if not k:
+        return '%s \\major' % key
+
+    type = k[0:3]
+    if type not in key_lookup:
+        # ugh, use lilylib, say WARNING:FILE:LINE:
+        sys.stderr.write("abc2ly:warning:")
+        sys.stderr.write("ignoring unknown key: `%s'" % orig)
+        sys.stderr.write('\n')
+        return 0
+    return "%s \\%s" % (key, key_lookup[type])
+
+
+def shift_key(note, acc, shift):
+    s = semitone_pitch((note, acc))
+    s = (s + shift + 12) % 12
+    if s <= 4:
+        n = s // 2
+        a = s % 2
+    else:
+        n = (s + 1) // 2
+        a = (s + 1) % 2
+    if a:
+        n = n + 1
+        a = -1
+    return (n, a)
+
+
+key_shift = {  # semitone shifts for key mode names
+    'm': 3,
+    'min': 3,
+    'minor': 3,
+    'maj': 0,
+    'major': 0,
+    'phr': -4,
+    'phrygian': -4,
+    'ion': 0,
+    'ionian': 0,
+    'loc': 1,
+    'locrian': 1,
+    'aeo': 3,
+    'aeolian': 3,
+    'mix': 5,
+    'mixolydian': 5,
+    'lyd': -5,
+    'lydian': -5,
+    'dor': -2,
+    'dorian': -2
+}
+
+
+def compute_key(k):
+    k = k.lower()
+    intkey = (ord(k[0]) - ord('a') + 5) % 7
+    intkeyacc = 0
+    k = k[1:]
+
+    if k and k[0] == 'b':
+        intkeyacc = -1
+        k = k[1:]
+    elif k and k[0] == '#':
+        intkeyacc = 1
+        k = k[1:]
+    k = k[0:3]
+    if k and k in key_shift:
+        (intkey, intkeyacc) = shift_key(intkey, intkeyacc, key_shift[k])
+    keytup = (intkey, intkeyacc)
+
+    sharp_key_seq = sharp_keys()
+    flat_key_seq = flat_keys()
+
+    accseq = None
+    accsign = 0
+    if keytup in sharp_key_seq:
+        accsign = 1
+        key_count = sharp_key_seq.index(keytup)
+        accseq = [(4*x - 1) % 7 for x in range(1, key_count + 1)]
+
+    elif keytup in flat_key_seq:
+        accsign = -1
+        key_count = flat_key_seq.index(keytup)
+        accseq = [(3*x + 3) % 7 for x in range(1, key_count + 1)]
+    else:
+        error("Huh?")
+        raise Exception("Huh")
+
+    key_table = [0] * 7
+    for a in accseq:
+        key_table[a] = key_table[a] + accsign
+
+    return key_table
+
+
+tup_lookup = {
+    '2': '3/2',
+    '3': '2/3',
+    '4': '4/3',
+    '5': '4/5',
+    '6': '4/6',
+    '7': '6/7',
+    '9': '8/9',
+}
+
+
+def try_parse_tuplet_begin(s, state):
+    if re.match(r'\([2-9]', s):
+        dig = s[1]
+        s = s[2:]
+        prev_tuplet_state = state.parsing_tuplet
+        state.parsing_tuplet = int(dig[0])
+        if prev_tuplet_state:
+            voices_append("}")
+        voices_append("\\times %s {" % tup_lookup[dig])
+    return s
+
+
+def try_parse_group_end(s, state):
+    if s and s[0] in HSPACE:
+        s = s[1:]
+        close_beam_state(state)
+    return s
+
+
+def header_append(key, a):
+    s = ''
+    if key in header:
+        s = header[key] + "\n"
+        header[key] = s + a
+
+
+def wordwrap(a, v):
+    linelen = len(v) - v.rfind('\n')
+    if linelen + len(a) > 80:
+        v = v + '\n'
+    return v + a + ' '
+
+
+def stuff_append(stuff, idx, a):
+    if not stuff:
+        stuff.append(a)
+    else:
+        stuff[idx] = wordwrap(a, stuff[idx])
+
+# ignore wordwrap since we are adding to the previous word
+
+
+def stuff_append_back(stuff, idx, a):
+    if not stuff:
+        stuff.append(a)
+    else:
+        point = len(stuff[idx])-1
+        while stuff[idx][point] == ' ':
+            point = point - 1
+        point = point + 1
+        stuff[idx] = stuff[idx][:point] + a + stuff[idx][point:]
+
+
+def voices_append(a):
+    if current_voice_idx < 0:
+        select_voice('default', '')
+    stuff_append(voices, current_voice_idx, a)
+
+# word wrap really makes it hard to bind beams to the end of notes since it
+# pushes out whitespace on every call. The _back functions do an append
+# prior to the last space, effectively tagging whatever they are given
+# onto the last note
+
+
+def voices_append_back(a):
+    if current_voice_idx < 0:
+        select_voice('default', '')
+    stuff_append_back(voices, current_voice_idx, a)
+
+
+def repeat_prepend():
+    global repeat_state
+    if current_voice_idx < 0:
+        select_voice('default', '')
+    if not using_old:
+        repeat_state[current_voice_idx] = 't'
+
+
+def lyrics_append(a):
+    a = re.sub('#', '\\#', a)        # latex does not like naked #'s
+    a = re.sub('"', '\\"', a)        # latex does not like naked "'s
+    a = '  \\line { "' + a + '" }\n'
+    stuff_append(lyrics, current_lyric_idx, a)
+
+# break lyrics to words and put "'s around words containing numbers and '"'s
+
+
+def fix_lyric(s):
+    ret = ''
+    while s != '':
+        m = re.match('[ \t]*([^ \t]*)[ \t]*(.*$)', s)
+        if m:
+            word = m.group(1)
+            s = m.group(2)
+            word = re.sub('"', '\\"', word)  # escape "
+            if re.match(r'.*[0-9"\(]', word):
+                word = re.sub('_', ' ', word)  # _ causes probs inside ""
+                ret = ret + '\"' + word + '\" '
+            else:
+                ret = ret + word + ' '
+        else:
+            return ret
+    return ret
+
+
+def slyrics_append(a):
+    a = re.sub('_', ' _ ', a)        # _ to ' _ '
+    # split words with "-" unless was originally "--"
+    a = re.sub('([^-])-([^-])', '\\1- \\2', a)
+    a = re.sub('\\\\- ', '-', a)         # unless \-
+    a = re.sub('~', '_', a)        # ~ to space('_')
+    a = re.sub(r'\*', '_ ', a)        # * to to space
+    a = re.sub('#', '\\#', a)        # latex does not like naked #'s
+    if re.match(r'.*[0-9"\(]', a):        # put numbers and " and ( into quoted string
+        a = fix_lyric(a)
+    a = re.sub('$', ' ', a)        # insure space between lines
+    __main__.lyric_idx = lyric_idx + 1
+    if len(slyrics[current_voice_idx]) <= lyric_idx:
+        slyrics[current_voice_idx].append(a)
+    else:
+        v = slyrics[current_voice_idx][lyric_idx]
+        slyrics[current_voice_idx][lyric_idx] = wordwrap(
+            a, slyrics[current_voice_idx][lyric_idx])
+
+
+def try_parse_header_line(ln, state):
+    global length_specified
+    m = re.match('^([A-Za-z]): *(.*)$', ln)
+
+    if m:
+        g = m.group(1)
+        a = m.group(2)
+        if g == 'T':  # title
+            a = re.sub('[ \t]*$', '', a)  # strip trailing blanks
+            if 'title' in header:
+                if a:
+                    if len(header['title']):
+                        # the non-ascii character
+                        # in the string below is a
+                        # punctuation dash. (TeX ---)
+                        header['title'] = header['title'] + ' — ' + a
+                    else:
+                        header['subtitle'] = a
+            else:
+                header['title'] = a
+        if g == 'M':        # Meter
+            if a == 'C':
+                if not state.common_time:
+                    state.common_time = 1
+                    voices_append(
+                        " \\override Staff.TimeSignature.style = #'C\n")
+                a = '4/4'
+            if a == 'C|':
+                if not state.common_time:
+                    state.common_time = 1
+                    voices_append(
+                        "\\override Staff.TimeSignature.style = #'C\n")
+                a = '2/2'
+            if not length_specified:
+                set_default_len_from_time_sig(a)
+            else:
+                length_specified = 0
+            if not a == 'none':
+                voices_append('\\time %s' % a)
+            state.next_bar = ''
+        if g == 'K':  # KEY
+            a = check_clef(a)
+            if a:
+                # separate clef info
+                m = re.match('^([^ \t]*) *([^ ]*)( *)(.*)$', a)
+                if m:
+                    # there may or may not be a space
+                    # between the key letter and the mode
+                    # convert the mode to lower-case before comparing
+                    mode = m.group(2)[0:3].lower()
+                    if mode in key_lookup:
+                        # use the full mode, not only the first three letters
+                        key_info = m.group(1) + m.group(2).lower()
+                        clef_info = a[m.start(4):]
+                    else:
+                        key_info = m.group(1)
+                        clef_info = a[m.start(2):]
+                    __main__.global_key = compute_key(key_info)
+                    k = lily_key(key_info)
+                    if k:
+                        voices_append('\\key %s' % k)
+                    check_clef(clef_info)
+                else:
+                    __main__.global_key = compute_key(a)
+                    k = lily_key(a)
+                    if k:
+                        voices_append('\\key %s \\major' % k)
+        if g == 'N':  # Notes
+            header['footnotes'] = header['footnotes'] + '\\\\\\\\' + a
+        if g == 'O':  # Origin
+            header['origin'] = a
+        if g == 'X':  # Reference Number
+            header['crossRefNumber'] = a
+        if g == 'A':  # Area
+            header['area'] = a
+        if g == 'H':        # History
+            header_append('history', a)
+        if g == 'B':        # Book
+            header['book'] = a
+        if g == 'C':        # Composer
+            if 'composer' in header:
+                if a:
+                    header['composer'] = header['composer'] + '\\\\\\\\' + a
+            else:
+                header['composer'] = a
+        if g == 'S':
+            header['subtitle'] = a
+        if g == 'L':        # Default note length
+            set_default_length(ln)
+        if g == 'V':        # Voice
+            voice = re.sub(' .*$', '', a)
+            rest = re.sub('^[^ \t]*  *', '', a)
+            if state.next_bar:
+                voices_append(state.next_bar)
+                state.next_bar = ''
+            select_voice(voice, rest)
+        if g == 'W':        # Words
+            lyrics_append(a)
+        if g == 'w':        # vocals
+            slyrics_append(a)
+        if g == 'Q':        # tempo
+            try_parse_q(a)
+        if g == 'R':        # Rhythm (e.g. jig, reel, hornpipe)
+            header['meter'] = a
+        if g == 'Z':        # Transcription (e.g. Steve Mansfield 1/2/2000)
+            header['transcription'] = a
+        return ''
+    return ln
+
+# we use in this order specified accidental, active accidental for bar,
+# active accidental for key
+
+
+def pitch_to_lilypond_name(name, acc, bar_acc, key):
+    s = ''
+    if acc == UNDEF:
+        if not nobarlines:
+            acc = bar_acc
+    if acc == UNDEF:
+        acc = key
+    if acc == -1:
+        s = 'es'
+    elif acc == 1:
+        s = 'is'
+
+    if name > 4:
+        name = name - 7
+    return chr(name + ord('c')) + s
+
+
+def octave_to_lilypond_quotes(o):
+    o = o + 2
+    s = ''
+    if o < 0:
+        o = -o
+        s = ','
+    else:
+        s = '\''
+
+    return s * o
+
+
+def parse_num(s):
+    durstr = ''
+    while s and s[0] in DIGITS:
+        durstr = durstr + s[0]
+        s = s[1:]
+
+    n = None
+    if durstr:
+        n = int(durstr)
+    return (s, n)
+
+
+def duration_to_lilypond_duration(multiply_tup, defaultlen, dots):
+    base = 1
+    # (num /  den)  / defaultlen < 1/base
+    while base * multiply_tup[0] < multiply_tup[1]:
+        base = base * 2
+    if base == 1:
+        if (multiply_tup[0] / multiply_tup[1]) == 2:
+            base = '\\breve'
+        if (multiply_tup[0] / multiply_tup[1]) == 3:
+            base = '\\breve'
+            dots = 1
+        if (multiply_tup[0] / multiply_tup[1]) == 4:
+            base = '\\longa'
+    return '%s%s' % (base, '.' * dots)
+
+
+class Parser_state:
+    def __init__(self):
+        self.in_acc = {}
+        self.next_articulation = ''
+        self.next_bar = ''
+        self.next_dots = 0
+        self.next_den = 1
+        self.parsing_tuplet = 0
+        self.plus_chord = 0
+        self.base_octave = 0
+        self.common_time = 0
+        self.parsing_beam = 0
+
+
+# return (str, num,den,dots)
+def parse_duration(s, parser_state):
+    num = 0
+    den = parser_state.next_den
+    parser_state.next_den = 1
+
+    (s, num) = parse_num(s)
+    if not num:
+        num = 1
+    if len(s):
+        if s[0] == '/':
+            if len(s[0]):
+                while s[:1] == '/':
+                    s = s[1:]
+                    d = 2
+                    if s[0] in DIGITS:
+                        (s, d) = parse_num(s)
+
+                    den = den * d
+
+    den = den * default_len
+
+    current_dots = parser_state.next_dots
+    parser_state.next_dots = 0
+    if re.match('[ \t]*[<>]', s):
+        while s[0] in HSPACE:
+            s = s[1:]
+        while s[0] == '>':
+            s = s[1:]
+            current_dots = current_dots + 1
+            parser_state.next_den = parser_state.next_den * 2
+
+        while s[0] == '<':
+            s = s[1:]
+            den = den * 2
+            parser_state.next_dots = parser_state.next_dots + 1
+
+    try_dots = [3, 2, 1]
+    for d in try_dots:
+        f = 1 << d
+        multiplier = (2*f-1)
+        if num % multiplier == 0 and den % f == 0:
+            num = num / multiplier
+            den = den / f
+            current_dots = current_dots + d
+
+    return (s, num, den, current_dots)
+
+
+def try_parse_rest(s, parser_state):
+    if not s or s[0] != 'z' and s[0] != 'x':
+        return s
+
+    __main__.lyric_idx = -1
+
+    if parser_state.next_bar:
+        voices_append(parser_state.next_bar)
+        parser_state.next_bar = ''
+
+    if s[0] == 'z':
+        rest = 'r'
+    else:
+        rest = 's'
+    s = s[1:]
+
+    (s, num, den, d) = parse_duration(s, parser_state)
+    voices_append(
+        '%s%s' % (rest, duration_to_lilypond_duration((num, den), default_len, d)))
+    if parser_state.next_articulation:
+        voices_append(parser_state.next_articulation)
+        parser_state.next_articulation = ''
+
+    return s
+
+
+artic_tbl = {
+    '.': '-.',
+    'T': '^\\trill',
+    'H': '^\\fermata',
+    'u': '^\\upbow',
+    'K': '^\\ltoe',
+    'k': '^\\accent',
+    'M': '^\\tenuto',
+    '~': '^"~" ',
+    'J': '',                # ignore slide
+    'R': '',                # ignore roll
+    'S': '^\\segno',
+    'O': '^\\coda',
+    'v': '^\\downbow'
+}
+
+
+def try_parse_articulation(s, state):
+    while s and s[:1] in artic_tbl:
+        state.next_articulation = state.next_articulation + artic_tbl[s[:1]]
+        if not artic_tbl[s[:1]]:
+            sys.stderr.write("Warning: ignoring `%s'\n" % s[:1])
+
+        s = s[1:]
+
+    # s7m2 input doesn't care about spaces
+    if re.match(r'[ \t]*\(', s):
+        s = s.lstrip()
+
+    slur_begin = 0
+    while s[:1] == '(' and s[1] not in DIGITS:
+        slur_begin = slur_begin + 1
+        state.next_articulation = state.next_articulation + '('
+        s = s[1:]
+
+    return s
+
+#
+# remember accidental for rest of bar
+#
+
+
+def set_bar_acc(note, octave, acc, state):
+    if acc == UNDEF:
+        return
+    n_oct = note + octave * 7
+    state.in_acc[n_oct] = acc
+
+# get accidental set in this bar or UNDEF if not set
+
+
+def get_bar_acc(note, octave, state):
+    n_oct = note + octave * 7
+    if n_oct in state.in_acc:
+        return state.in_acc[n_oct]
+    else:
+        return UNDEF
+
+
+def clear_bar_acc(state):
+    state.in_acc = {}
+
+
+# if we are parsing a beam, close it off
+def close_beam_state(state):
+    if state.parsing_beam and global_options.beams:
+        state.parsing_beam = 0
+        voices_append_back(']')
+
+
+# WAT IS ABC EEN ONTZETTENDE PROGRAMMEERPOEP  !
+def try_parse_note(s, parser_state):
+    mud = ''
+
+    slur_begin = 0
+    if not s:
+        return s
+
+    articulation = ''
+    acc = UNDEF
+    if s[0] in '^=_':
+        c = s[0]
+        s = s[1:]
+        if c == '^':
+            acc = 1
+        if c == '=':
+            acc = 0
+        if c == '_':
+            acc = -1
+
+    octave = parser_state.base_octave
+    if s[0] in "ABCDEFG":
+        s = s[0].lower() + s[1:]
+        octave = octave - 1
+
+    notename = 0
+    if s[0] in "abcdefg":
+        notename = (ord(s[0]) - ord('a') + 5) % 7
+        s = s[1:]
+    else:
+        return s                # failed; not a note!
+
+    __main__.lyric_idx = -1
+
+    if parser_state.next_bar:
+        voices_append(parser_state.next_bar)
+        parser_state.next_bar = ''
+
+    while s[0] == ',':
+        octave = octave - 1
+        s = s[1:]
+    while s[0] == '\'':
+        octave = octave + 1
+        s = s[1:]
+
+    (s, num, den, current_dots) = parse_duration(s, parser_state)
+
+    if re.match(r'[ \t]*\)', s):
+        s = s.lstrip()
+
+    slur_end = 0
+    while s[:1] == ')':
+        slur_end = slur_end + 1
+        s = s[1:]
+
+    bar_acc = get_bar_acc(notename, octave, parser_state)
+    pit = pitch_to_lilypond_name(notename, acc, bar_acc, global_key[notename])
+    oct = octave_to_lilypond_quotes(octave)
+    if acc != UNDEF and (acc == global_key[notename] or acc == bar_acc):
+        mod = '!'
+    else:
+        mod = ''
+    voices_append("%s%s%s%s" %
+                  (pit, oct, mod,
+                   duration_to_lilypond_duration((num, den), default_len, current_dots)))
+
+    set_bar_acc(notename, octave, acc, parser_state)
+    if parser_state.next_articulation:
+        articulation = articulation + parser_state.next_articulation
+        parser_state.next_articulation = ''
+
+    voices_append(articulation)
+
+    if slur_begin:
+        voices_append('-(' * slur_begin)
+    if slur_end:
+        voices_append('-)' * slur_end)
+
+    if parser_state.parsing_tuplet:
+        parser_state.parsing_tuplet = parser_state.parsing_tuplet - 1
+        if not parser_state.parsing_tuplet:
+            voices_append("}")
+
+    if global_options.beams and \
+            s[0] in '^=_ABCDEFGabcdefg' and \
+            not parser_state.parsing_beam and \
+            not parser_state.parsing_tuplet:
+        parser_state.parsing_beam = 1
+        voices_append_back('[')
+
+    return s
+
+
+def junk_space(s, state):
+    while s and s[0] in '\t\n\r ':
+        s = s[1:]
+        close_beam_state(state)
+
+    return s
+
+
+def try_parse_guitar_chord(s, state):
+    if s[:1] == '"':
+        s = s[1:]
+        gc = ''
+        if s[0] == '_' or (s[0] == '^'):
+            position = s[0]
+            s = s[1:]
+        else:
+            position = '^'
+        while s and s[0] != '"':
+            gc = gc + s[0]
+            s = s[1:]
+
+        if s:
+            s = s[1:]
+        gc = re.sub('#', '\\#', gc)        # escape '#'s
+        state.next_articulation = ("%c\"%s\"" % (position, gc)) \
+            + state.next_articulation
+    return s
+
+
+def try_parse_escape(s):
+    if not s or s[0] != '\\':
+        return s
+
+    s = s[1:]
+    if s[:1] == 'K':
+        key_table = compute_key()
+    return s
+
+
+#
+# |] thin-thick double bar line
+# || thin-thin double bar line
+# [| thick-thin double bar line
+# :| left repeat
+# |: right repeat
+# :: left-right repeat
+# |1 volta 1
+# |2 volta 2
+old_bar_dict = {
+    '|]': '|.',
+    '||': '||',
+    '[|': '||',
+    ':|': ':|.',
+    '|:': '|:',
+    '::': ':|.|:',
+    '|1': '|',
+    '|2': '|',
+    ':|2': ':|.',
+    '|':  '|'
+}
+bar_dict = {
+    '|]': '\\bar "|."',
+    '||': '\\bar "||"',
+    '[|': '\\bar "||"',
+    ':|': '}',
+    '|:': '\\repeat volta 2 {',
+    '::': '} \\repeat volta 2 {',
+    '|1': '} \\alternative{{',
+    '|2': '} {',
+    ':|2': '} {',
+    '|':  '\\bar "|"'
+}
+
+
+warn_about = ['|:', '::', ':|', '|1', ':|2', '|2']
+alternative_opener = ['|1', '|2', ':|2']
+repeat_ender = ['::', ':|']
+repeat_opener = ['::', '|:']
+in_repeat = [''] * 8
+doing_alternative = [''] * 8
+using_old = ''
+
+def try_parse_bar(string, state):
+    global in_repeat, doing_alternative, using_old
+    do_curly = ''
+    bs = None
+    if current_voice_idx < 0:
+        select_voice('default', '')
+    # first try the longer one
+    for trylen in [3, 2, 1]:
+        if string[:trylen] and string[:trylen] in bar_dict:
+            s = string[:trylen]
+            if using_old:
+                bs = "\\bar \"%s\"" % old_bar_dict[s]
+            else:
+                bs = "%s" % bar_dict[s]
+            string = string[trylen:]
+            if s in alternative_opener:
+                if not in_repeat[current_voice_idx]:
+                    using_old = 't'
+                    bs = "\\bar \"%s\"" % old_bar_dict[s]
+                else:
+                    doing_alternative[current_voice_idx] = 't'
+
+            if s in repeat_ender:
+                if not in_repeat[current_voice_idx]:
+                    sys.stderr.write(
+                        "Warning: inserting repeat to beginning of notes.\n")
+                    repeat_prepend()
+                    in_repeat[current_voice_idx] = ''
+                else:
+                    if doing_alternative[current_voice_idx]:
+                        do_curly = 't'
+                if using_old:
+                    bs = "\\bar \"%s\"" % old_bar_dict[s]
+                else:
+                    bs = bar_dict[s]
+                doing_alternative[current_voice_idx] = ''
+                in_repeat[current_voice_idx] = ''
+            if s in repeat_opener:
+                in_repeat[current_voice_idx] = 't'
+                if using_old:
+                    bs = "\\bar \"%s\"" % old_bar_dict[s]
+                else:
+                    bs = bar_dict[s]
+            break
+    if string[:1] == '|':
+        state.next_bar = '|\n'
+        string = string[1:]
+        clear_bar_acc(state)
+        close_beam_state(state)
+
+    if string[:1] == '}':
+        close_beam_state(state)
+
+    if bs is not None or state.next_bar != '':
+        if state.parsing_tuplet:
+            state.parsing_tuplet = 0
+            voices_append('} ')
+
+    if bs is not None:
+        clear_bar_acc(state)
+        close_beam_state(state)
+        voices_append(bs)
+        if do_curly != '':
+            voices_append("} ")
+            do_curly = ''
+    return string
+
+
+def try_parse_tie(s):
+    if s[:1] == '-':
+        s = s[1:]
+        voices_append(' ~ ')
+    return s
+
+
+def bracket_escape(s, state):
+    m = re.match(r'^([^\]]*)] *(.*)$', s)
+    if m:
+        cmd = m.group(1)
+        s = m.group(2)
+        try_parse_header_line(cmd, state)
+    return s
+
+
+def try_parse_chord_delims(s, state):
+    if s[:1] == '[':
+        s = s[1:]
+        if re.match('[A-Z]:', s):        # bracket escape
+            return bracket_escape(s, state)
+        if state.next_bar:
+            voices_append(state.next_bar)
+            state.next_bar = ''
+        voices_append('<<')
+
+    if s[:1] == '+':
+        s = s[1:]
+        if state.plus_chord:
+            voices_append('>>')
+            state.plus_chord = 0
+        else:
+            if state.next_bar:
+                voices_append(state.next_bar)
+                state.next_bar = ''
+            voices_append('<<')
+            state.plus_chord = 1
+
+    ch = ''
+    if s[:1] == ']':
+        s = s[1:]
+        ch = '>>'
+
+    end = 0
+    while s[:1] == ')':
+        end = end + 1
+        s = s[1:]
+
+    voices_append("\\spanrequest \\stop \"slur\"" * end)
+    voices_append(ch)
+    return s
+
+
+def try_parse_grace_delims(s, state):
+    if s[:1] == '{':
+        if state.next_bar:
+            voices_append(state.next_bar)
+            state.next_bar = ''
+        s = s[1:]
+        voices_append('\\grace { ')
+
+    if s[:1] == '}':
+        s = s[1:]
+        voices_append('}')
+
+    return s
+
+
+def try_parse_comment(s):
+    global nobarlines
+    if s[0] == '%':
+        if s[0:5] == '%MIDI':
+            # the nobarlines option is necessary for an abc to lilypond translator for
+            # exactly the same reason abc2midi needs it: abc requires the user to enter
+            # the note that will be printed, and MIDI and lilypond expect entry of the
+            # pitch that will be played.
+            #
+            # In standard 19th century musical notation, the algorithm for translating
+            # between printed note and pitch involves using the barlines to determine
+            # the scope of the accidentals.
+            #
+            # Since ABC is frequently used for music in styles that do not use this
+            # convention, such as most music written before 1700, or ethnic music in
+            # non-western scales, it is necessary to be able to tell a translator that
+            # the barlines should not affect its interpretation of the pitch.
+            if 'nobarlines' in s:
+                nobarlines = 1
+        elif s[0:3] == '%LY':
+            p = s.find('voices')
+            if p > -1:
+                voices_append(s[p+7:])
+                voices_append("\n")
+            p = s.find('slyrics')
+            if p > -1:
+                slyrics_append(s[p+8:])
+
+# write other kinds of appending  if we ever need them.
+    return s
+
+
+lineno = 0
+happy_count = 100
+
+
+def parse_file(fn):
+    f = open(fn, encoding='utf-8')
+    ls = f.readlines()
+    ls = [re.sub("\r$", '', x) for x in ls]
+
+    select_voice('default', '')
+    global lineno
+    lineno = 0
+    if not global_options.quiet:
+        sys.stderr.write("Line ... ")
+        sys.stderr.flush()
+    __main__.state = state_list[current_voice_idx]
+
+    for ln in ls:
+        lineno = lineno + 1
+
+        if not lineno % happy_count:
+            sys.stderr.write('[%d]' % lineno)
+            sys.stderr.flush()
+        m = re.match('^([^%]*)%(.*)$', ln)  # add comments to current voice
+        if m:
+            if m.group(2):
+                try_parse_comment(m.group(2))
+                voices_append('%% %s\n' % m.group(2))
+            ln = m.group(1)
+
+        orig_ln = ln
+
+        ln = junk_space(ln, state)
+        ln = try_parse_header_line(ln, state)
+
+        # Try nibbling characters off until the line doesn't change.
+        prev_ln = ''
+        while ln != prev_ln:
+            prev_ln = ln
+            ln = try_parse_chord_delims(ln, state)
+            ln = try_parse_rest(ln, state)
+            ln = try_parse_articulation(ln, state)
+            ln = try_parse_note(ln, state)
+            ln = try_parse_bar(ln, state)
+            ln = try_parse_tie(ln)
+            ln = try_parse_escape(ln)
+            ln = try_parse_guitar_chord(ln, state)
+            ln = try_parse_tuplet_begin(ln, state)
+            ln = try_parse_group_end(ln, state)
+            ln = try_parse_grace_delims(ln, state)
+            ln = junk_space(ln, state)
+
+        if ln:
+            error("%s: %d: Huh?  Don't understand\n" % (fn, lineno))
+            left = orig_ln[0:-len(ln)]
+            sys.stderr.write(left + '\n')
+            sys.stderr.write(' ' * len(left) + ln + '\n')
+
+
+def identify():
+    if not global_options.quiet:
+        sys.stderr.write("%s from LilyPond %s\n" % (ly.program_name, version))
+
+
+authors = """
+Written by Han-Wen Nienhuys <[email protected]>, Laura Conrad
+<[email protected]>, Roy Rankin <Roy.Rankin@@alcatel.com.au>.
+"""
+
+
+def print_version():
+    print(r"""abc2ly (GNU lilypond) %s""" % version)
+
+
+def get_option_parser():
+    p = ly.get_option_parser(usage=_("%s [OPTION]... FILE") % 'abc2ly',
+                             description=_('''abc2ly converts ABC music files (see
+%s) to LilyPond input.
+''') % 'http://abcnotation.com/abc2mtex/abc.txt',
+                             add_help_option=False)
+
+    p.version = "abc2ly (LilyPond) 2.24.2"
+    p.add_option("--version",
+                 action="version",
+                 help=_("show version number and exit"))
+    p.add_option("-h", "--help",
+                 action="help",
+                 help=_("show this help and exit"))
+    p.add_option("-o", "--output", metavar='FILE',
+                 action="store",
+                 help=_("write output to FILE"))
+    p.add_option("-s", "--strict",
+                 action="store_true",
+                 help=_("be strict about success"))
+    p.add_option('-b', '--beams',
+                 action="store_true",
+                 help=_("preserve ABC's notion of beams"))
+    p.add_option('-q', '--quiet',
+                 action="store_true",
+                 help=_("suppress progress messages"))
+    p.add_option_group('',
+                       description=(
+                           _('Report bugs via %s')
+                           % '[email protected]') + '\n')
+    return p
+
+
+option_parser = get_option_parser()
+(global_options, files) = option_parser.parse_args()
+
+
+identify()
+
+header['tagline'] = 'Lily was here %s -- automatically converted from ABC' % version
+for f in files:
+    if f == '-':
+        f = ''
+
+    if not global_options.quiet:
+        sys.stderr.write('Parsing `%s\'...\n' % f)
+    parse_file(f)
+
+    if not global_options.output:
+        global_options.output = os.path.basename(
+            os.path.splitext(f)[0]) + ".ly"
+    if not global_options.quiet:
+        sys.stderr.write('lilypond output to: `%s\'...' %
+                         global_options.output)
+    outf = open(global_options.output, 'w', encoding='utf-8')
+
+# don't substitute @VERSION@. We want this to reflect
+# the last version that was verified to work.
+    outf.write('\\version "2.7.40"\n')
+
+#        dump_global (outf)
+    dump_header(outf, header)
+    dump_slyrics(outf)
+    dump_voices(outf)
+    dump_score(outf)
+    dump_lyrics(outf)
+    if not global_options.quiet:
+        sys.stderr.write('\n')

lilypond-2.24.2/bin/convert-ly.py

@@ -0,0 +1,445 @@
+#!/home/lily/lilypond-2.24.2/release/binaries/dependencies/install/Python-3.10.8/bin/python3.10
+
+# convert-ly.py -- Update old LilyPond input files (fix name?)
+# converting rules are found in python/convertrules.py
+
+# This file is part of LilyPond, the GNU music typesetter.
+#
+# Copyright (C) 1998--2022  Han-Wen Nienhuys <[email protected]>
+#                 Jan Nieuwenhuizen <[email protected]>
+#
+# LilyPond is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# LilyPond is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+
+import gettext
+import io
+import os
+import re
+import shutil
+import sys
+
+"""
+
+# relocate-preamble.py.in
+#
+# This file is part of LilyPond, the GNU music typesetter.
+#
+# Copyright (C) 2007--2022  Han-Wen Nienhuys <[email protected]>
+#
+# LilyPond is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# LilyPond is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+This is generic code, used for all python scripts.
+
+The quotes are to ensure that the source .py file can still be
+run as a python script, but does not include any sys.path handling.
+Otherwise, the lilypond-book calls inside the build
+might modify installed .pyc files.
+
+"""
+
+# This is needed for installations with a non-default layout, ie where share/
+# is not next to bin/.
+sys.path.insert (0, os.path.join ('/home/lily/lilypond-2.24.2/release/binaries/mingw/lilypond/install/share/lilypond/2.24.2', 'python'))
+
+# Dynamic relocation, for installations with a default layout including GUB,
+# but also for execution from the build directory.
+bindir = os.path.abspath (os.path.dirname (sys.argv[0]))
+topdir = os.path.dirname (bindir)
+if bindir.endswith (r'/scripts/out'):
+    topdir = os.path.join (os.path.dirname (topdir), 'out')
+datadir = os.path.abspath (os.path.join (topdir, 'share', 'lilypond'))
+for v in [ 'current', '2.24.2' ]:
+    sys.path.insert (0, os.path.join (datadir, v, 'python'))
+
+"""
+"""
+
+# Load translation and install _() into Python's builtins namespace.
+gettext.install('lilypond', '/home/lily/lilypond-2.24.2/release/binaries/mingw/lilypond/install/share/locale')
+
+import convertrules
+import lilylib as ly
+
+lilypond_version_re_str = '\\\\version *\"([0-9.]+)"'
+lilypond_version_re = re.compile(lilypond_version_re_str)
+
+lilypond_version_strict_re_str = '\\\\version *\"([0-9]+(?:[.]([0-9]+))([.][0-9]+)?)"'
+lilypond_version_strict_re = re.compile(lilypond_version_strict_re_str)
+
+help_summary = (
+    _('''Update LilyPond input to newer version.  By default, update from the
+version taken from the \\version command, to the current LilyPond version.''')
+    + "\n"
+    + _("If FILE is `-', read from standard input.")
+    + "\n\n"
+    + _("Examples:")
+    + '''
+  $ convert-ly -e old.ly
+  $ convert-ly --from=2.3.28 --to=2.5.21 foobar.ly > foobar-new.ly
+''')
+
+copyright = ('Jan Nieuwenhuizen <[email protected]>',
+             'Han-Wen Nienhuys <[email protected]>')
+
+program_version = '2.24.2'
+
+authors = ('Jan Nieuwenhuizen <[email protected]>',
+           'Han-Wen Nienhuys <[email protected]>')
+
+
+def identify():
+    ly.progress('%s (GNU LilyPond) %s\n' % (ly.program_name, program_version))
+
+
+def warranty():
+    identify()
+    sys.stdout.write('''
+%s
+
+%s
+
+%s
+%s
+''' % (_('Copyright (c) %s by') % '2001--2023',
+        ' '.join(authors),
+        _('Distributed under terms of the GNU General Public License.'),
+        _('It comes with NO WARRANTY.')))
+
+
+def get_option_parser():
+    p = ly.get_option_parser(usage=_("%s [OPTION]... FILE") % 'convert-ly',
+                             description=help_summary,
+                             add_help_option=False)
+
+    p.version = "2.24.2"
+    p.add_option("--version",
+                 action="version",
+                 help=_("show version number and exit"))
+
+    p.add_option("-h", "--help",
+                 action="help",
+                 help=_("show this help and exit"))
+
+    p.add_option('-f', '--from',
+                 action="store",
+                 metavar=_("VERSION"),
+                 dest="from_version",
+                 help=_(
+                     "start from VERSION [default: \\version found in file]"),
+                 default='')
+
+    p.add_option('-e', '--edit', help=_("edit in place"),
+                 action='store_true')
+
+    p.add_option("-l", "--loglevel",
+                 help=_("Print log messages according to LOGLEVEL "
+                        "(NONE, ERROR, WARNING, PROGRESS (default), DEBUG)"),
+                 metavar=_("LOGLEVEL"),
+                 action='callback',
+                 callback=ly.handle_loglevel_option,
+                 type='string')
+
+    p.add_option('-n', '--no-version',
+                 help=_("do not add \\version command if missing"),
+                 action='store_true',
+                 dest='skip_version_add',
+                 default=False)
+
+    p.add_option('-c', '--current-version',
+                 help=_("force updating \\version number to %s") % program_version,
+                 action='store_true',
+                 dest='force_current_version',
+                 default=False)
+
+    p.add_option('-d', '--diff-version-update',
+                 help=_("only update \\version number if file is modified"),
+                 action='store_true',
+                 dest='diff_version_update',
+                 default=False)
+
+    p.add_option("-s", '--show-rules',
+                 help=_("show rules [default: -f 0, -t %s]") % program_version,
+                 dest='show_rules',
+                 action='store_true', default=False)
+
+    p.add_option('-t', '--to',
+                 help=_("convert to VERSION [default: %s]") % program_version,
+                 metavar=_('VERSION'),
+                 action='store',
+                 dest="to_version",
+                 default='')
+
+    p.add_option('-b', '--backup-numbered',
+                 help=_("make a numbered backup [default: filename.ext~]"),
+                 action='store_true',
+                 dest="backup_numbered",
+                 default='')
+
+    p.add_option('-w', '--warranty', help=_("show warranty and copyright"),
+                 action='store_true',
+                 ),
+    p.add_option_group('',
+                       description=(
+                           _("Report bugs via %s")
+                           % '[email protected]') + '\n')
+
+    return p
+
+
+def str_to_tuple(s):
+    return tuple([int(n) for n in s.split('.')])
+
+def tup_to_str(t):
+    return '.'.join(['%s' % x for x in t])
+
+def latest_version():
+    return convertrules.conversions[-1][0]
+
+
+def show_rules(file, from_version, to_version):
+    for x in convertrules.conversions:
+        if (not from_version or x[0] > from_version) \
+           and (not to_version or x[0] <= to_version):
+            file.write('%s: %s\n' % (tup_to_str(x[0]), x[2]))
+
+def do_conversion(s, from_version, to_version):
+    """Apply conversions from FROM_VERSION to TO_VERSION.  Return
+tuple (LAST,LASTCHANGED,STR,ERRORS), with the last applied conversion,
+the last conversion resulting in a change, the resulting
+string and the number of errors."""
+    conv_list = [conv for conv in convertrules.conversions if from_version < conv[0] <= to_version]
+
+    ly.progress(_("Applying conversion: "), newline=False)
+
+    last_conversion = None
+    last_change = None
+    errors = 0
+    try:
+        for x in conv_list:
+            if x != conv_list[-1]:
+                ly.progress(tup_to_str(x[0]), newline=False)
+                ly.progress(', ', newline=False)
+            else:
+                ly.progress(tup_to_str(x[0]))
+            newstr = x[1](s)
+            last_conversion = x[0]
+            if newstr != s:
+                last_change = last_conversion
+            s = newstr
+
+    except convertrules.FatalConversionError:
+        ly.error(_("Error while converting")
+                 + '\n'
+                 + _("Stopping at last successful rule"))
+        errors += 1
+
+    return (last_conversion, last_change, s, errors)
+
+
+def guess_lilypond_version(input):
+    m = lilypond_version_strict_re.search(input)
+    # Accept a missing third component if the second component
+    # is even.  That works because we don't have conversion rules
+    # within stable releases, as the syntax doesn't change.
+    if m and (m.group(3) is not None or int(m.group(2))%2 == 0):
+        return m.group(1)
+    m = lilypond_version_re.search(input)
+    if m:
+        raise InvalidVersion(m.group(1))
+    else:
+        return ''
+
+
+class FatalConversionError (Exception):
+    pass
+
+
+class UnknownVersion (Exception):
+    pass
+
+
+class InvalidVersion (Exception):
+    def __init__(self, version):
+        self.version = version
+
+
+def back_up(file, numbered):
+    if numbered:
+        n = 0
+        while True:
+            n = n + 1
+            back_up = file + '.~' + str(n) + '~'
+            if not os.path.exists(back_up):
+                break
+    else:
+        back_up = file + '~'
+    shutil.copy2(file, back_up)
+    return back_up
+
+
+def do_one_file(infile_name):
+    ly.progress(_("Processing `%s\'... ") % infile_name, True)
+
+    if infile_name:
+        infile = open(infile_name, 'rb')
+        original = infile.read()
+        infile.close()
+
+        # Cope early with encoding change in 2.5.13: Try UTF-8 and attempt
+        # conversion from latin1 if that fails.
+        try:
+            input = original.decode('utf-8')
+        except UnicodeError:
+            ly.progress(_("Attempting conversion from `latin1'..."))
+            input = original.decode('latin1')
+
+        # Convert platform-dependent newline character sequences
+        # to `\n`. This is default behaviour when opening files in
+        # text mode, which does not work for us, though, since we do not
+        # know the encoding in advance.
+        input = io.StringIO(input, newline=None).read()
+    else:
+        input = sys.stdin.read()
+
+    to_version = None
+    org_version = None
+    guess = guess_lilypond_version(input)
+    org_version = guess and str_to_tuple(guess)
+    from_version = global_options.from_version or org_version
+    if not from_version:
+        raise UnknownVersion()
+
+    if global_options.to_version:
+        to_version = global_options.to_version
+    else:
+        to_version = latest_version()
+
+    (last, last_change, result, errors) = \
+        do_conversion(input, from_version, to_version)
+
+    if global_options.force_current_version and \
+            (last is None or last == to_version):
+        last = str_to_tuple(program_version)
+    if last:
+        if global_options.diff_version_update:
+            # Note that last_change can be set even if the result is
+            # the same if two conversion rules cancelled out
+            if result == input:
+                # make no (actual) change to the version number
+                last = org_version or from_version
+            else:
+                last = last_change
+                # If the last update was to an unstable version
+                # number, and the final update target is no longer in
+                # the same unstable series, we update to the stable
+                # series following the unstable version.
+                if last[1] % 2:  # unstable
+                    next_stable = (last[0], last[1]+1, 0)
+                    if next_stable <= to_version:
+                        last = next_stable
+
+        newversion = r'\version "%s"' % tup_to_str(last)
+        if lilypond_version_re.search(result):
+            result = re.sub(lilypond_version_re_str,
+                            '\\' + newversion, result)
+        elif not global_options.skip_version_add:
+            result = newversion + '\n' + result
+
+    ly.progress('\n')
+
+    if global_options.edit:
+        backup = back_up(infile_name, global_options.backup_numbered)
+        outfile = open(infile_name, 'w', encoding='utf-8')
+    else:
+        outfile = sys.stdout
+
+    outfile.write(result)
+
+    sys.stderr.flush()
+
+    return errors
+
+
+def do_options():
+    opt_parser = get_option_parser()
+    (options, args) = opt_parser.parse_args()
+
+    if options.warranty:
+        warranty()
+        sys.exit(0)
+
+    if options.from_version:
+        options.from_version = str_to_tuple(options.from_version)
+    if options.to_version:
+        options.to_version = str_to_tuple(options.to_version)
+
+    options.outfile_name = ''
+    global global_options
+    global_options = options
+
+    if not args and not options.show_rules:
+        opt_parser.print_help()
+        sys.exit(2)
+
+    return args
+
+
+def main():
+    files = do_options()
+
+    # should parse files[] to read \version?
+    if global_options.show_rules:
+        show_rules(sys.stdout, global_options.from_version,
+                   global_options.to_version)
+        sys.exit(0)
+
+    identify()
+
+    errors = 0
+    for f in files:
+        if f == '-':
+            f = ''
+        elif not os.path.isfile(f):
+            ly.error(_("%s: Unable to open file") % f)
+            errors += 1
+            continue
+        try:
+            errors += do_one_file(f)
+        except UnknownVersion:
+            ly.error(_("%s: Unable to determine version.  Skipping") % f)
+            errors += 1
+        except InvalidVersion as v:
+            ly.error(_("%s: Invalid version string `%s' \n"
+                       "Valid version strings consist of three numbers, "
+                       "separated by dots, e.g. `2.8.12'") % (f, v.version))
+            errors += 1
+
+    if errors:
+        ly.warning(gettext.ngettext("There was %d error.",
+                                    "There were %d errors.", errors) % errors)
+        sys.exit(1)
+
+
+main()

lilypond-2.24.2/bin/etf2ly.py

@@ -0,0 +1,1326 @@
+#!/home/lily/lilypond-2.24.2/release/binaries/dependencies/install/Python-3.10.8/bin/python3.10
+
+# This file is part of LilyPond, the GNU music typesetter.
+#
+# Copyright (C) 2001--2022  Han-Wen Nienhuys <[email protected]>
+#                           Jan Nieuwenhuizen <[email protected]>
+#
+# LilyPond is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# LilyPond is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+
+# info mostly taken from looking at files. See also
+# https://www.gnu.org/software/lilypond/src/Developers/Details/etfformat.html
+
+# This supports
+#
+#  * notes
+#  * rests
+#  * ties
+#  * slurs
+#  * lyrics
+#  * articulation
+#  * grace notes
+#  * tuplets
+#
+
+# todo:
+#  * slur/stem directions
+#  * voices (2nd half of frame?)
+#  * more intelligent lyrics
+#  * beams (better use autobeam?)
+#  * more robust: try entertainer.etf (freenote)
+#  * dynamics
+#  * empty measures (eg. twopt03.etf from freenote)
+#
+
+
+import __main__
+import getopt
+import gettext
+import os
+import re
+import sys
+
+authors = ('Jan Nieuwenhuizen <[email protected]>',
+           'Han-Wen Nienhuys <[email protected]>')
+
+version = '2.24.2'
+if version == '@' + 'TOPLEVEL_VERSION' + '@':
+    version = '(unknown version)'           # uGUHGUHGHGUGH
+
+"""
+
+# relocate-preamble.py.in
+#
+# This file is part of LilyPond, the GNU music typesetter.
+#
+# Copyright (C) 2007--2022  Han-Wen Nienhuys <[email protected]>
+#
+# LilyPond is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# LilyPond is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+This is generic code, used for all python scripts.
+
+The quotes are to ensure that the source .py file can still be
+run as a python script, but does not include any sys.path handling.
+Otherwise, the lilypond-book calls inside the build
+might modify installed .pyc files.
+
+"""
+
+# This is needed for installations with a non-default layout, ie where share/
+# is not next to bin/.
+sys.path.insert (0, os.path.join ('/home/lily/lilypond-2.24.2/release/binaries/mingw/lilypond/install/share/lilypond/2.24.2', 'python'))
+
+# Dynamic relocation, for installations with a default layout including GUB,
+# but also for execution from the build directory.
+bindir = os.path.abspath (os.path.dirname (sys.argv[0]))
+topdir = os.path.dirname (bindir)
+if bindir.endswith (r'/scripts/out'):
+    topdir = os.path.join (os.path.dirname (topdir), 'out')
+datadir = os.path.abspath (os.path.join (topdir, 'share', 'lilypond'))
+for v in [ 'current', '2.24.2' ]:
+    sys.path.insert (0, os.path.join (datadir, v, 'python'))
+
+"""
+"""
+
+################################################################
+# Load translation and install _() into Python's builtins namespace.
+gettext.install('lilypond', '/home/lily/lilypond-2.24.2/release/binaries/mingw/lilypond/install/share/locale')
+
+import lilylib as ly
+
+finale_clefs = ['treble', 'alto', 'tenor', 'bass',
+                'percussion', 'treble_8', 'bass_8', 'baritone']
+
+
+def lily_clef(fin):
+    try:
+        return finale_clefs[fin]
+    except IndexError:
+        sys.stderr.write('\nHuh? Found clef number %d\n' % fin)
+
+    return 'treble'
+
+
+def gulp_file(f):
+    return open(f, encoding='utf-8').read()
+
+
+# notename 0 == central C
+distances = [0, 2, 4, 5, 7, 9, 11, 12]
+
+
+def semitones(name, acc):
+    return (name / 7) * 12 + distances[name % 7] + acc
+
+# represent pitches as (notename, alteration), relative to C-major scale
+
+
+def transpose(orig, delta):
+    (oname, oacc) = orig
+    (dname, dacc) = delta
+
+    old_pitch = semitones(oname, oacc)
+    delta_pitch = semitones(dname, dacc)
+    nname = (oname + dname)
+    nacc = oacc
+    new_pitch = semitones(nname, nacc)
+
+    nacc = nacc - (new_pitch - old_pitch - delta_pitch)
+
+    return (nname, nacc)
+
+
+def interpret_finale_key_sig(finale_id):
+    """
+find the transposition of C-major scale that belongs here.
+
+we are not going to insert the correct major/minor, we only want to
+have the correct number of accidentals
+"""
+
+    p = (0, 0)
+
+    bank_number = finale_id >> 8
+    accidental_bits = finale_id & 0xff
+
+    if 0 <= accidental_bits < 7:
+        while accidental_bits > 0:
+            p = transpose(p, (4, 0))  # a fifth up
+            accidental_bits = accidental_bits - 1
+    elif 248 < accidental_bits <= 255:
+        while accidental_bits < 256:
+            p = transpose(p, (3, 0))
+            accidental_bits = accidental_bits + 1
+
+    if bank_number == 1:
+        # minor scale
+        p = transpose(p, (5, 0))
+    p = (p[0] % 7, p[1])
+
+    return KeySignature(p, bank_number)
+
+# should cache this.
+
+
+def find_scale(keysig):
+    cscale = [(x, 0) for x in range(0, 7)]
+#        print "cscale: ", cscale
+    ascale = [(x, 0) for x in range(-2, 5)]
+#        print "ascale: ", ascale
+    transposition = keysig.pitch
+    if keysig.sig_type == 1:
+        transposition = transpose(transposition, (2, -1))
+        transposition = (transposition[0] % 7, transposition[1])
+        trscale = list(map(lambda x, k=transposition: transpose(x, k), ascale))
+    else:
+        trscale = list(map(lambda x, k=transposition: transpose(x, k), cscale))
+#        print "trscale: ", trscale
+    return trscale
+
+
+def EDU_to_duration(edu):
+    log = 1
+    d = 4096
+    while d > edu:
+        d = d >> 1
+        log = log << 1
+
+    edu = edu - d
+    dots = 0
+    if edu == d / 2:
+        dots = 1
+    elif edu == d*3/4:
+        dots = 2
+    return (log, dots)
+
+
+def rational_to_lily_skip(rat):
+    (n, d) = rat
+
+    basedur = 1
+    while d and d % 2 == 0:
+        basedur = basedur << 1
+        d = d >> 1
+
+    str = 's%d' % basedur
+    if n != 1:
+        str = str + '*%d' % n
+    if d != 1:
+        str = str + '/%d' % d
+
+    return str
+
+
+def gcd(a, b):
+    if b == 0:
+        return a
+    c = a
+    while c:
+        c = a % b
+        a = b
+        b = c
+    return a
+
+
+def rat_simplify(r):
+    (n, d) = r
+    if d < 0:
+        d = -d
+        n = -n
+    if n == 0:
+        return (0, 1)
+    else:
+        g = gcd(n, d)
+        return (n/g, d/g)
+
+
+def rat_multiply(a, b):
+    (x, y) = a
+    (p, q) = b
+
+    return rat_simplify((x*p, y*q))
+
+
+def rat_add(a, b):
+    (x, y) = a
+    (p, q) = b
+
+    return rat_simplify((x*q + p*y, y*q))
+
+
+def rat_neg(a):
+    (p, q) = a
+    return (-p, q)
+
+
+def rat_subtract(a, b):
+    return rat_add(a, rat_neg(b))
+
+
+def lily_notename(tuple2):
+    (n, a) = tuple2
+    nn = chr((n + 2) % 7 + ord('a'))
+
+    return nn + {-2: 'eses', -1: 'es', 0: '', 1: 'is', 2: 'isis'}[a]
+
+
+class Tuplet:
+    def __init__(self, number):
+        self.start_note = number
+        self.finale = []
+
+    def append_finale(self, fin):
+        self.finale.append(fin)
+
+    def factor(self):
+        n = self.finale[0][2]*self.finale[0][3]
+        d = self.finale[0][0]*self.finale[0][1]
+        return rat_simplify((n, d))
+
+    def dump_start(self):
+        return '\\times %d/%d { ' % self.factor()
+
+    def dump_end(self):
+        return ' }'
+
+    def calculate(self, chords):
+        edu_left = self.finale[0][0] * self.finale[0][1]
+
+        startch = chords[self.start_note]
+        c = startch
+        while c and edu_left:
+            c.tuplet = self
+            if c == startch:
+                c.chord_prefix = self.dump_start() + c.chord_prefix
+
+            if not c.grace:
+                edu_left = edu_left - c.EDU_duration()
+            if edu_left == 0:
+                c.chord_suffix = c.chord_suffix + self.dump_end()
+            c = c.__next__
+
+        if edu_left:
+            sys.stderr.write(
+                "\nHuh? Tuplet starting at entry %d was too short." % self.start_note)
+
+
+class Slur:
+    def __init__(self, number, params):
+        self.number = number
+        self.finale = params
+
+    def append_entry(self, finale_e):
+        self.finale.append(finale_e)
+
+    def calculate(self, chords):
+        startnote = self.finale[5]
+        endnote = self.finale[3*6 + 2]
+        try:
+            cs = chords[startnote]
+            ce = chords[endnote]
+
+            if not cs or not ce:
+                raise IndexError
+
+            cs.note_suffix = '-(' + cs.note_suffix
+            ce.note_suffix = ce.note_suffix + '-)'
+
+        except IndexError:
+            sys.stderr.write("""\nHuh? Slur no %d between (%d,%d), with %d notes""" % (
+                self.number,  startnote, endnote, len(chords)))
+
+
+class Global_measure:
+    def __init__(self, number):
+        self.timesig = ''
+        self.number = number
+        self.key_signature = None
+        self.scale = None
+        self.force_break = 0
+
+        self.repeats = []
+        self.finale = []
+
+    def __str__(self):
+        return repr(self.finale)
+
+    def set_timesig(self, finale):
+        (beats, fdur) = finale
+        (log, dots) = EDU_to_duration(fdur)
+
+        if dots == 1:
+            beats = beats * 3
+            log = log * 2
+            dots = 0
+
+        if dots != 0:
+            sys.stderr.write(
+                "\nHuh? Beat duration has  dots? (EDU Duration = %d)" % fdur)
+        self.timesig = (beats, log)
+
+    def length(self):
+        return self.timesig
+
+    def set_key_sig(self, finale):
+        k = interpret_finale_key_sig(finale)
+        self.key_signature = k
+        self.scale = find_scale(k)
+
+    def set_flags(self, flag1, flag2):
+
+        # flag1 isn't all that interesting.
+        if flag2 & 0x8000:
+            self.force_break = 1
+
+        if flag2 & 0x0008:
+            self.repeats.append('start')
+        if flag2 & 0x0004:
+            self.repeats.append('stop')
+
+        if flag2 & 0x0002:
+            if flag2 & 0x0004:
+                self.repeats.append('bracket')
+
+
+articulation_dict = {
+    94: '^',
+    109: '\\prall',
+    84: '\\turn',
+    62: '\\mordent',
+    85: '\\fermata',
+    46: '.',
+    #        3: '>',
+    #        18: '\arpeggio' ,
+}
+
+
+class Articulation_def:
+    def __init__(self, n, a, b):
+        self.finale_glyph = a & 0xff
+        self.number = n
+
+    def dump(self):
+        try:
+            return articulation_dict[self.finale_glyph]
+        except KeyError:
+            sys.stderr.write("\nUnknown articulation no. %d" %
+                             self.finale_glyph)
+            sys.stderr.write(
+                "\nPlease add an entry to articulation_dict in the Python source")
+            return None
+
+
+class Articulation:
+    def __init__(self, a, b, finale):
+        self.definition = finale[0]
+        self.notenumber = b
+
+    def calculate(self, chords, defs):
+        c = chords[self.notenumber]
+
+        adef = defs[self.definition]
+        lystr = adef.dump()
+        if lystr is None:
+            lystr = '"art"'
+            sys.stderr.write("\nThis happened on note %d" % self.notenumber)
+
+        c.note_suffix = '-' + lystr
+
+
+class Syllable:
+    def __init__(self, a, b, finale):
+        self.chordnum = b
+        self.syllable = finale[1]
+        self.verse = finale[0]
+
+    def calculate(self, chords, lyrics):
+        self.chord = chords[self.chordnum]
+
+
+class Verse:
+    def __init__(self, number, body):
+        self.body = body
+        self.number = number
+        self.split_syllables()
+
+    def split_syllables(self):
+        ss = re.split('(-| +)', self.body)
+
+        sep = 0
+        syls = [None]
+        for s in ss:
+            if sep:
+                septor = re.sub(" +", "", s)
+                septor = re.sub("-", " -- ", septor)
+                syls[-1] = syls[-1] + septor
+            else:
+                syls.append(s)
+
+            sep = not sep
+
+        self.syllables = syls
+
+    def dump(self):
+        str = ''
+        line = ''
+        for s in self.syllables[1:]:
+            line = line + ' ' + s
+            if len(line) > 72:
+                str = str + ' ' * 4 + line + '\n'
+                line = ''
+
+        str = """\nverse%s = \\lyricmode {\n %s }\n""" % (
+            encodeint(self.number - 1), str)
+        return str
+
+
+class KeySignature:
+    def __init__(self, pitch, sig_type=0):
+        self.pitch = pitch
+        self.sig_type = sig_type
+
+    def signature_type(self):
+        if self.sig_type == 1:
+            return "\\minor"
+        else:
+            # really only for 0, but we only know about 0 and 1
+            return "\\major"
+
+    def equal(self, other):
+        if other and other.pitch == self.pitch and other.sig_type == self.sig_type:
+            return 1
+        else:
+            return 0
+
+
+class Measure:
+    def __init__(self, no):
+        self.number = no
+        self.frames = [0] * 4
+        self.flags = 0
+        self.clef = 0
+        self.finale = []
+        self.global_measure = None
+        self.staff = None
+        self.valid = 1
+
+    def valid(self):
+        return self.valid
+
+    def calculate(self):
+        fs = []
+
+        if len(self.finale) < 2:
+            fs = self.finale[0]
+
+            self.clef = fs[1]
+            self.frames = [fs[0]]
+        else:
+            fs = self.finale
+            self.clef = fs[0]
+            self.flags = fs[1]
+            self.frames = fs[2:]
+
+
+class Frame:
+    def __init__(self, finale):
+        self.measure = None
+        self.finale = finale
+        (number, start, end) = finale
+        self.number = number
+        self.start = start
+        self.end = end
+        self.chords = []
+
+    def set_measure(self, m):
+        self.measure = m
+
+    def calculate(self):
+
+        # do grace notes.
+        lastch = None
+        in_grace = 0
+        for c in self.chords:
+            if c.grace and (lastch is None or (not lastch.grace)):
+                c.chord_prefix = r'\grace {' + c.chord_prefix
+                in_grace = 1
+            elif not c.grace and lastch and lastch.grace:
+                lastch.chord_suffix = lastch.chord_suffix + ' } '
+                in_grace = 0
+
+            lastch = c
+
+        if lastch and in_grace:
+            lastch.chord_suffix += '}'
+
+    def dump(self):
+        str = '%% FR(%d)\n' % self.number
+        left = self.measure.global_measure.length()
+
+        ln = ''
+        for c in self.chords:
+            add = c.ly_string() + ' '
+            if len(ln) + len(add) > 72:
+                str = str + ln + '\n'
+                ln = ''
+            ln = ln + add
+            left = rat_subtract(left, c.length())
+
+        str = str + ln
+
+        if left[0] < 0:
+            sys.stderr.write("""\nHuh? Going backwards in frame no %d, start/end (%d,%d)""" %
+                             (self.number, self.start, self.end))
+            left = (0, 1)
+        if left[0]:
+            str = str + rational_to_lily_skip(left)
+
+        str = str + '  |\n'
+        return str
+
+
+def encodeint(i):
+    return chr(i + ord('A'))
+
+
+class Staff:
+    def __init__(self, number):
+        self.number = number
+        self.measures = []
+
+    def get_measure(self, no):
+        fill_list_to(self.measures, no)
+
+        if self.measures[no] is None:
+            m = Measure(no)
+            self.measures[no] = m
+            m.staff = self
+
+        return self.measures[no]
+
+    def staffid(self):
+        return 'staff' + encodeint(self.number - 1)
+
+    def layerid(self, l):
+        return self.staffid() + 'layer%s' % chr(l - 1 + ord('A'))
+
+    def dump_time_key_sigs(self):
+        k = ''
+        last_key = None
+        last_time = None
+        last_clef = None
+        gap = (0, 1)
+        for m in self.measures[1:]:
+            if not m or not m.valid:
+                continue  # ugh.
+
+            g = m.global_measure
+            e = ''
+
+            if g:
+                if g.key_signature and not g.key_signature.equal(last_key):
+                    pitch = g.key_signature.pitch
+                    e = e + "\\key %s %s " % (lily_notename(pitch),
+                                              g.key_signature.signature_type())
+
+                    last_key = g.key_signature
+                if last_time != g.timesig:
+                    e = e + "\\time %d/%d " % g.timesig
+                    last_time = g.timesig
+
+                if 'start' in g.repeats:
+                    e = e + ' \\bar ".|:" '
+
+                # we don't attempt voltas since they fail easily.
+                if 0:  # and g.repeat_bar == '|:' or g.repeat_bar == ':|:' or g.bracket:
+                    strs = []
+                    if g.repeat_bar == '|:' or g.repeat_bar == ':|:' or g.bracket == 'end':
+                        strs.append('#f')
+
+                    if g.bracket == 'start':
+                        strs.append('"0."')
+
+                    str = ' '.join(['(volta %s)' % x for x in strs])
+
+                    e = e + ' \\set Score.repeatCommands =  #\'(%s) ' % str
+
+                if g.force_break:
+                    e = e + ' \\break '
+
+            if last_clef != m.clef:
+                e = e + '\\clef "%s"' % lily_clef(m.clef)
+                last_clef = m.clef
+            if e:
+                if gap != (0, 1):
+                    k = k + ' ' + rational_to_lily_skip(gap) + '\n'
+                gap = (0, 1)
+                k = k + e
+
+            if g:
+                gap = rat_add(gap, g.length())
+                if 'stop' in g.repeats:
+                    k = k + ' \\bar ":|." '
+
+        k = '%sglobal = { %s }\n\n ' % (self.staffid(), k)
+        return k
+
+    def dump(self):
+        str = ''
+
+        layerids = []
+        for x in range(1, 5):  # 4 layers.
+            laystr = ''
+            last_frame = None
+            first_frame = None
+            gap = (0, 1)
+            for m in self.measures[1:]:
+                if not m or not m.valid:
+                    sys.stderr.write(
+                        "Skipping non-existant or invalid measure\n")
+                    continue
+
+                fr = None
+                try:
+                    fr = m.frames[x]
+                except IndexError:
+                    sys.stderr.write("Skipping nonexistent frame %d\n" % x)
+                    laystr = laystr + \
+                        "%% non existent frame %d (skipped)\n" % x
+                if fr:
+                    first_frame = fr
+                    if gap != (0, 1):
+                        laystr = laystr + \
+                            '} %s {\n ' % rational_to_lily_skip(gap)
+                        gap = (0, 1)
+                    laystr = laystr + fr.dump()
+                else:
+                    if m.global_measure:
+                        gap = rat_add(gap, m.global_measure.length())
+                    else:
+                        sys.stderr.write(
+                            "No global measure for staff %d measure %d\n"
+                            % (self.number, m.number))
+            if first_frame:
+                l = self.layerid(x)
+                laystr = '%s = { {  %s } }\n\n' % (l, laystr)
+                str = str + laystr
+                layerids.append(l)
+
+        str = str + self.dump_time_key_sigs()
+        stafdef = '\\%sglobal' % self.staffid()
+        for i in layerids:
+            stafdef = stafdef + ' \\' + i
+
+        str = str + '%s = \\context Staff = %s <<\n %s\n >>\n' % \
+            (self.staffid(), self.staffid(), stafdef)
+        return str
+
+
+def ziplist(l):
+    if len(l) < 2:
+        return []
+    else:
+        return [(l[0], l[1])] + ziplist(l[2:])
+
+
+class Chord:
+    def __init__(self, number, contents):
+        self.pitches = []
+        self.frame = None
+        self.finale = contents[:7]
+
+        self.notelist = ziplist(contents[7:])
+        self.duration = None
+        self.next = None
+        self.prev = None
+        self.number = number
+        self.note_prefix = ''
+        self.note_suffix = ''
+        self.chord_suffix = ''
+        self.chord_prefix = ''
+        self.tuplet = None
+        self.grace = 0
+
+    def measure(self):
+        if not self.frame:
+            return None
+        return self.frame.measure
+
+    def length(self):
+        if self.grace:
+            return (0, 1)
+
+        l = (1, self.duration[0])
+
+        d = 1 << self.duration[1]
+
+        dotfact = rat_subtract((2, 1), (1, d))
+        mylen = rat_multiply(dotfact, l)
+
+        if self.tuplet:
+            mylen = rat_multiply(mylen, self.tuplet.factor())
+        return mylen
+
+    def EDU_duration(self):
+        return self.finale[2]
+
+    def set_duration(self):
+        self.duration = EDU_to_duration(self.EDU_duration())
+
+    def calculate(self):
+        self.find_realpitch()
+        self.set_duration()
+
+        flag = self.finale[4]
+        if Chord.GRACE_MASK & flag:
+            self.grace = 1
+
+    def find_realpitch(self):
+
+        meas = self.measure()
+        tiestart = 0
+        if not meas or not meas.global_measure:
+            sys.stderr.write('note %d not in measure\n' % self.number)
+        elif not meas.global_measure.scale:
+            sys.stderr.write(
+                'note %d: no scale in this measure.' % self.number)
+        else:
+
+            for p in self.notelist:
+                (pitch, flag) = p
+
+                nib1 = pitch & 0x0f
+
+                if nib1 > 8:
+                    nib1 = -(nib1 - 8)
+                rest = pitch / 16
+
+                scale = meas.global_measure.scale
+                (sn, sa) = scale[rest % 7]
+                sn = sn + (rest - (rest % 7)) + 7
+                acc = sa + nib1
+                self.pitches.append((sn, acc))
+                tiestart = tiestart or (flag & Chord.TIE_START_MASK)
+        if tiestart:
+            self.chord_suffix = self.chord_suffix + ' ~ '
+
+    REST_MASK = 0x40000000
+    TIE_START_MASK = 0x40000000
+    GRACE_MASK = 0x00800000
+
+    def ly_string(self):
+        s = ''
+
+        rest = ''
+
+        if not (self.finale[4] & Chord.REST_MASK):
+            rest = 'r'
+
+        for p in self.pitches:
+            (n, a) = p
+            o = n / 7
+            n = n % 7
+
+            nn = lily_notename((n, a))
+
+            if o < 0:
+                nn = nn + (',' * -o)
+            elif o > 0:
+                nn = nn + ('\'' * o)
+
+            if s:
+                s = s + ' '
+
+            if rest:
+                nn = rest
+
+            s = s + nn
+
+        if not self.pitches:
+            s = 'r'
+        if len(self.pitches) > 1:
+            s = '<%s>' % s
+
+        s = s + '%d%s' % (self.duration[0], '.' * self.duration[1])
+        s = self.note_prefix + s + self.note_suffix
+
+        s = self.chord_prefix + s + self.chord_suffix
+
+        return s
+
+
+def fill_list_to(list, no):
+    """
+Add None to LIST until it contains entry number NO.
+    """
+    while len(list) <= no:
+        list.extend([None] * (no - len(list) + 1))
+    return list
+
+
+def read_finale_value(str):
+    """
+Pry off one value from STR. The value may be $hex, decimal, or "string".
+Return: (value, rest-of-STR)
+    """
+    while str and str[0] in ' \t\n':
+        str = str[1:]
+
+    if not str:
+        return (None, str)
+
+    if str[0] == '$':
+        str = str[1:]
+
+        hex = ''
+        while str and str[0] in '0123456789ABCDEF':
+            hex = hex + str[0]
+            str = str[1:]
+
+        return (int(hex, 16), str)
+    elif str[0] == '"':
+        str = str[1:]
+        s = ''
+        while str and str[0] != '"':
+            s = s + str[0]
+            str = str[1:]
+
+        return (s, str)
+    elif str[0] in '-0123456789':
+        dec = ''
+        while str and str[0] in '-0123456789':
+            dec = dec + str[0]
+            str = str[1:]
+
+        return (int(dec), str)
+    else:
+        sys.stderr.write("cannot convert `%s'\n" % str)
+        return (None, str)
+
+
+def parse_etf_file(fn, tag_dict):
+    """ Read FN, putting ETF info into
+    a giant dictionary.  The keys of TAG_DICT indicate which tags
+    to put into the dict.
+    """
+
+    sys.stderr.write('parsing ... ')
+    f = open(fn, encoding='utf-8')
+
+    gulp = re.sub('[\n\r]+', '\n',  f.read())
+    ls = gulp.split('\n^')
+
+    etf_file_dict = {}
+    for k in tag_dict:
+        etf_file_dict[k] = {}
+
+    last_tag = None
+    last_numbers = None
+
+    for l in ls:
+        m = re.match(r'^([a-zA-Z0-9&]+)\(([^)]+)\)', l)
+        if m and m.group(1) in tag_dict:
+            tag = m.group(1)
+
+            indices = tuple([int(s) for s in m.group(2).split(',')])
+            content = l[m.end(2)+1:]
+
+            tdict = etf_file_dict[tag]
+            if indices not in tdict:
+                tdict[indices] = []
+
+            parsed = []
+
+            if tag == 'verse' or tag == 'block':
+                m2 = re.match(r'(.*)\^end', content)
+                if m2:
+                    parsed = [m2.group(1)]
+            else:
+                while content:
+                    (v, content) = read_finale_value(content)
+                    if v is not None:
+                        parsed.append(v)
+
+            tdict[indices].extend(parsed)
+
+            last_indices = indices
+            last_tag = tag
+
+            continue
+
+# let's not do this: this really confuses when eE happens to be before  a ^text.
+#                if last_tag and last_indices:
+#                        etf_file_dict[last_tag][last_indices].append (l)
+
+    sys.stderr.write('\n')
+    return etf_file_dict
+
+
+class Etf_file:
+    def __init__(self, name):
+        self.measures = [None]
+        self.chords = [None]
+        self.frames = [None]
+        self.tuplets = [None]
+        self.staffs = [None]
+        self.slurs = [None]
+        self.articulations = [None]
+        self.syllables = [None]
+        self.verses = [None]
+        self.articulation_defs = [None]
+
+        # do it
+        self.parse(name)
+
+    def get_global_measure(self, no):
+        fill_list_to(self.measures, no)
+        if self.measures[no] is None:
+            self.measures[no] = Global_measure(no)
+
+        return self.measures[no]
+
+    def get_staff(self, staffno):
+        fill_list_to(self.staffs, staffno)
+        if self.staffs[staffno] is None:
+            self.staffs[staffno] = Staff(staffno)
+
+        return self.staffs[staffno]
+
+    # staff-spec
+    def try_IS(self, indices, contents):
+        pass
+
+    def try_BC(self, indices, contents):
+        bn = indices[0]
+        where = contents[0] / 1024.0
+
+    def try_TP(self,  indices, contents):
+        (nil, num) = indices
+
+        if self.tuplets[-1] is None or num != self.tuplets[-1].start_note:
+            self.tuplets.append(Tuplet(num))
+
+        self.tuplets[-1].append_finale(contents)
+
+    def try_IM(self, indices, contents):
+        (a, b) = indices
+        fin = contents
+        self.articulations.append(Articulation(a, b, fin))
+
+    def try_verse(self, indices, contents):
+        a = indices[0]
+        body = contents[0]
+
+        body = re.sub(r"""\^[a-z]+\([^)]+\)""", "", body)
+        body = re.sub(r"\^[a-z]+", "", body)
+        self.verses.append(Verse(a, body))
+
+    def try_ve(self, indices, contents):
+        (a, b) = indices
+        self.syllables.append(Syllable(a, b, contents))
+
+    def try_eE(self, indices, contents):
+        no = indices[0]
+        (prev, next, dur, pos, entryflag, extended, follow) = contents[:7]
+
+        fill_list_to(self.chords, no)
+        self.chords[no] = Chord(no, contents)
+
+    def try_Sx(self, indices, contents):
+        slurno = indices[0]
+        fill_list_to(self.slurs, slurno)
+        self.slurs[slurno] = Slur(slurno, contents)
+
+    def try_IX(self, indices, contents):
+        n = indices[0]
+        a = contents[0]
+        b = contents[1]
+
+        ix = None
+        try:
+            ix = self.articulation_defs[n]
+        except IndexError:
+            ix = Articulation_def(n, a, b)
+            self.articulation_defs.append(Articulation_def(n, a, b))
+
+    def try_GF(self, indices, contents):
+        (staffno, measno) = indices
+
+        st = self.get_staff(staffno)
+        meas = st.get_measure(measno)
+        meas.finale = contents
+
+    def try_FR(self, indices, contents):
+        frameno = indices[0]
+
+        startnote = contents[0]
+        endnote = contents[1]
+
+        fill_list_to(self.frames, frameno)
+
+        self.frames[frameno] = Frame((frameno, startnote, endnote))
+
+    def try_MS(self, indices, contents):
+        measno = indices[0]
+        keynum = contents[1]
+        meas = self. get_global_measure(measno)
+
+        meas.set_key_sig(keynum)
+
+        beats = contents[2]
+        beatlen = contents[3]
+        meas.set_timesig((beats, beatlen))
+
+        meas_flag1 = contents[4]
+        meas_flag2 = contents[5]
+
+        meas.set_flags(meas_flag1, meas_flag2)
+
+    routine_dict = {
+        'MS': try_MS,
+        'FR': try_FR,
+        'GF': try_GF,
+        'IX': try_IX,
+        'Sx': try_Sx,
+        'eE': try_eE,
+        'verse': try_verse,
+        've': try_ve,
+        'IM': try_IM,
+        'TP': try_TP,
+        'BC': try_BC,
+        'IS': try_IS,
+    }
+
+    def parse(self, etf_dict):
+        sys.stderr.write('reconstructing ...')
+        sys.stderr.flush()
+
+        for (tag, routine) in list(Etf_file.routine_dict.items()):
+            ks = list(etf_dict[tag].keys())
+            ks.sort()
+            for k in ks:
+                routine(self, k, etf_dict[tag][k])
+
+        sys.stderr.write('processing ...')
+        sys.stderr.flush()
+
+        self.unthread_entries()
+
+        for st in self.staffs[1:]:
+            if not st:
+                continue
+            mno = 1
+            for m in st.measures[1:]:
+                if not m:
+                    continue
+
+                m.calculate()
+                try:
+                    m.global_measure = self.measures[mno]
+                except IndexError:
+                    sys.stderr.write("Non-existent global measure %d" % mno)
+                    continue
+
+                frame_obj_list = [None]
+                for frno in m.frames:
+                    try:
+                        fr = self.frames[frno]
+                        frame_obj_list.append(fr)
+                    except IndexError:
+                        sys.stderr.write("\nNon-existent frame %d" % frno)
+
+                m.frames = frame_obj_list
+                for fr in frame_obj_list[1:]:
+                    if not fr:
+                        continue
+
+                    fr.set_measure(m)
+
+                    fr.chords = self.get_thread(fr.start, fr.end)
+                    for c in fr.chords:
+                        c.frame = fr
+                mno = mno + 1
+
+        for c in self.chords[1:]:
+            if c:
+                c.calculate()
+
+        for f in self.frames[1:]:
+            if f:
+                f.calculate()
+
+        for t in self.tuplets[1:]:
+            t.calculate(self.chords)
+
+        for s in self.slurs[1:]:
+            if s:
+                s.calculate(self.chords)
+
+        for s in self.articulations[1:]:
+            s.calculate(self.chords, self.articulation_defs)
+
+    def get_thread(self, startno, endno):
+
+        thread = []
+
+        c = None
+        try:
+            c = self.chords[startno]
+        except IndexError:
+            sys.stderr.write(
+                "Huh? Frame has invalid bounds (%d,%d)\n" % (startno, endno))
+            return []
+
+        while c and c.number != endno:
+            d = c  # hack to avoid problem with scripts/build/grand-replace.py
+            thread.append(d)
+            c = c.__next__
+
+        if c:
+            d = c  # hack to avoid problem with scripts/build/grand-replace.py
+            thread.append(d)
+
+        return thread
+
+    def dump(self):
+        str = ''
+        staffs = []
+        for s in self.staffs[1:]:
+            if s:
+                str = str + '\n\n' + s.dump()
+                staffs.append('\\' + s.staffid())
+
+        # should use \addlyrics ?
+
+        for v in self.verses[1:]:
+            str = str + v.dump()
+
+        if len(self.verses) > 1:
+            sys.stderr.write(
+                "\nLyrics found; edit to use \\addlyrics to couple to a staff\n")
+
+        if staffs:
+            str += '\\version "2.3.25"\n'
+            str = str + '<<\n  %s\n>> } ' % ' '.join(staffs)
+
+        return str
+
+    def __str__(self):
+        return 'ETF FILE %s %s' % (self.measures,  self.entries)
+
+    def unthread_entries(self):
+        for e in self.chords[1:]:
+            if not e:
+                continue
+
+            e.prev = self.chords[e.finale[0]]
+            e.next = self.chords[e.finale[1]]
+
+
+def identify():
+    sys.stderr.write("%s from LilyPond %s\n" % (ly.program_name, version))
+
+
+def warranty():
+    identify()
+    sys.stdout.write('''
+%s
+
+  %s
+
+%s
+%s
+''' % (_('Copyright (c) %s by') % '2001--2023',
+        '\n  '.join(authors),
+        _('Distributed under terms of the GNU General Public License.'),
+        _('It comes with NO WARRANTY.')))
+
+
+def get_option_parser():
+    p = ly.get_option_parser(usage=_("%s [OPTION]... ETF-FILE") % 'etf2ly',
+                             description=_("""Enigma Transport Format is a format used by Coda Music Technology's
+Finale product.  etf2ly converts a subset of ETF to a ready-to-use LilyPond file.
+"""),
+                             add_help_option=False)
+    p.add_option("-h", "--help",
+                 action="help",
+                 help=_("show this help and exit"))
+    p.version = "etf2ly (LilyPond) 2.24.2"
+    p.add_option("--version",
+                 action="version",
+                 help=_("show version number and exit"))
+    p.add_option('-o', '--output', help=_("write output to FILE"),
+                 metavar=_("FILE"),
+                 action='store')
+    p.add_option('-w', '--warranty', help=_("show warranty and copyright"),
+                 action='store_true',
+                 ),
+
+    p.add_option_group('',
+                       description=(
+                           _('Report bugs via %s')
+                           % '[email protected]') + '\n')
+    return p
+
+
+def do_options():
+    opt_parser = get_option_parser()
+    (options, args) = opt_parser.parse_args()
+    if options.warranty:
+        warranty()
+        sys.exit(0)
+
+    return (options, args)
+
+
+(options, files) = do_options()
+identify()
+
+out_filename = options.output
+
+e = None
+for f in files:
+    if f == '-':
+        f = ''
+
+    sys.stderr.write('Processing `%s\'\n' % f)
+
+    dict = parse_etf_file(f, Etf_file.routine_dict)
+    e = Etf_file(dict)
+    if not out_filename:
+        out_filename = os.path.basename(re.sub('(?i).etf$', '.ly', f))
+
+    if out_filename == f:
+        out_filename = os.path.basename(f + '.ly')
+
+    sys.stderr.write('Writing `%s\'' % out_filename)
+    ly = e.dump()
+
+    fo = open(out_filename, 'w', encoding='utf-8')
+    fo.write('%% lily was here -- automatically converted by etf2ly from %s\n' % f)
+    fo.write(ly)
+    fo.close()

lilypond-2.24.2/bin/libgio-2.0-0.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:16b31008c66821844d6724b81026f8be75d5e25fe52c4489f48ea014a2963eca
+size 1873408

lilypond-2.24.2/bin/libglib-2.0-0.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:176680ef7e5e080f726cf86f7e776a0c13c3fd79f2acd1c11a98f78f6c4264cc
+size 1611264

lilypond-2.24.2/bin/lilymidi.py

@@ -0,0 +1,304 @@
+#!/home/lily/lilypond-2.24.2/release/binaries/dependencies/install/Python-3.10.8/bin/python3.10
+
+# Copyright (C) 2006--2022 Brailcom, o.p.s.
+#
+# Author: Milan Zamazal <[email protected]>
+#
+# This file is part of LilyPond, the GNU music typesetter.
+#
+# LilyPond is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# LilyPond is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+
+import optparse
+import os
+import sys
+
+"""
+
+# relocate-preamble.py.in
+#
+# This file is part of LilyPond, the GNU music typesetter.
+#
+# Copyright (C) 2007--2022  Han-Wen Nienhuys <[email protected]>
+#
+# LilyPond is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# LilyPond is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+This is generic code, used for all python scripts.
+
+The quotes are to ensure that the source .py file can still be
+run as a python script, but does not include any sys.path handling.
+Otherwise, the lilypond-book calls inside the build
+might modify installed .pyc files.
+
+"""
+
+# This is needed for installations with a non-default layout, ie where share/
+# is not next to bin/.
+sys.path.insert (0, os.path.join ('/home/lily/lilypond-2.24.2/release/binaries/mingw/lilypond/install/share/lilypond/2.24.2', 'python'))
+
+# Dynamic relocation, for installations with a default layout including GUB,
+# but also for execution from the build directory.
+bindir = os.path.abspath (os.path.dirname (sys.argv[0]))
+topdir = os.path.dirname (bindir)
+if bindir.endswith (r'/scripts/out'):
+    topdir = os.path.join (os.path.dirname (topdir), 'out')
+datadir = os.path.abspath (os.path.join (topdir, 'share', 'lilypond'))
+for v in [ 'current', '2.24.2' ]:
+    sys.path.insert (0, os.path.join (datadir, v, 'python'))
+
+"""
+"""
+
+
+def process_options(args):
+    parser = optparse.OptionParser(version="2.24.2")
+    parser.add_option('', '--filter-tracks', metavar='REGEXP', action='store', type='string', dest='regexp',
+                      help="display only tracks numbers, of those track names matching REGEXP")
+    parser.add_option('', '--prefix-tracks', metavar='PREFIX', action='store', type='string', dest='prefix',
+                      help="prefix filtered track numbers with PREFIX")
+    parser.add_option('', '--dump', action='store_true', dest='dump',
+                      help="just dump parsed contents of the MIDI file")
+    parser.add_option('', '--pretty', action='store_true', dest='pretty',
+                      help="dump parsed contents of the MIDI file in human-readable form (implies --dump)")
+    parser.usage = parser.usage + " FILE"
+    options, args = parser.parse_args(args)
+    if len(args) != 1:
+        parser.print_help()
+        sys.exit(2)
+    return options, args
+
+
+def read_midi(file):
+    import midi
+    return midi.parse(open(file, 'rb').read())
+
+
+def track_info(data):
+    tracks = data[1]
+
+    def track_name(track):
+        name = ''
+        for time, event in track:
+            if time > 0:
+                break
+            if event[0] == 255 and event[1] == 3:
+                name = event[2]
+                break
+        return name
+    track_info = []
+    for i in range(len(tracks)):
+        track_info.append((i, track_name(tracks[i])))
+    return track_info
+
+
+class formatter:
+    def __init__(self, txt=""):
+        self.text = txt
+
+    def format_vals(self, val1, val2=""):
+        return str(val1) + str(val2)
+
+    def format(self, val1, val2=""):
+        return self.text + self.format_vals(val1, val2)
+
+
+class none_formatter (formatter):
+    def format_vals(self, val1, val2=""):
+        return ''
+
+
+class meta_formatter (formatter):
+    def format_vals(self, val1, val2):
+        return str(val2)
+
+
+class tempo_formatter (formatter):
+    def format_vals(self, val1, val2):
+        return str(ord(val2[0])*65536 + ord(val2[1])*256 + ord(val2[2])) \
+            + " msec/quarter"
+
+
+class time_signature_formatter (formatter):
+    def format_vals(self, val1, val2=""):
+        from fractions import Fraction
+        # if there are more notated 32nd notes per midi quarter than 8,
+        # we display a fraction smaller than 1 as scale factor.
+        r = Fraction(8, ord(val2[3]))
+        if r == 1:
+            ratio = ""
+        else:
+            ratio = " *" + str(r)
+        return str(ord(val2[0])) + "/" + str(1 << ord(val2[1])) + ratio \
+            + ", metronome " + str(Fraction(ord(val2[2]), 96))
+
+
+class key_signature_formatter (formatter):
+    def format_vals(self, val1, val2):
+        key_names = ['F', 'C', 'G', 'D', 'A', 'E', 'B']
+        key = (((ord(val2[0])+128) % 256)-128) + ord(val2[1])*3 + 1
+        return (key_names[key % 7] + (key//7) * "is" + (-(key//7)) * "es"
+                + " " + ['major', 'minor'][ord(val2[1])])
+
+
+class channel_formatter (formatter):
+    def __init__(self, txt, ch):
+        formatter.__init__(self, txt)
+        self.channel = ch
+
+    def format(self, val1, val2=""):
+        return self.text + "Channel " + str(self.channel) + ", " + \
+            self.format_vals(val1, val2)
+
+
+class control_mode_formatter (formatter):
+    def __init__(self, txt, ch):
+        formatter.__init__(self, txt)
+        self.mode = ch
+
+    def format(self, val1, val2=""):
+        return self.text + str(self.mode) + ", " + \
+            self.format_vals(val1, val2)
+
+
+class note_formatter (channel_formatter):
+    def pitch(self, val):
+        pitch_names = ['C', 'Cis', 'D', 'Dis', 'E',
+                       'F', 'Fis', 'G', 'Gis', 'A', 'Ais', 'B']
+        p = val % 12
+        oct = val // 12 - 1
+        return pitch_names[p] + str(oct) + "(" + str(val) + ")"
+
+    def velocity(self, val):
+        return str(val)
+
+    def format_vals(self, val1, val2):
+        if val2 > 0:
+            return self.pitch(val1) + '@' + self.velocity(val2)
+        return self.pitch(val1)
+
+
+meta_dict = {0x00: meta_formatter("Seq.Nr.:    "),
+             0x01: meta_formatter("Text:       "),
+             0x02: meta_formatter("Copyright:  "),
+             0x03: meta_formatter("Track name: "),
+             0x04: meta_formatter("Instrument: "),
+             0x05: meta_formatter("Lyric:      "),
+             0x06: meta_formatter("Marker:     "),
+             0x07: meta_formatter("Cue point:  "),
+             0x2F: none_formatter("End of Track"),
+             0x51: tempo_formatter("Tempo:      "),
+             0x54: meta_formatter("SMPTE Offs.:"),
+             0x58: time_signature_formatter("Time signature: "),
+             0x59: key_signature_formatter("Key signature: ")
+             }
+
+
+def dump_event(ev, time, padding):
+    ch = ev[0] & 0x0F
+    func = ev[0] & 0xF0
+    f = None
+    if ev[0] == 0xFF:
+        f = meta_dict.get(ev[1], formatter())
+    if func == 0x80:
+        f = note_formatter("Note off: ", ch)
+    elif func == 0x90:
+        if ev[2] == 0:
+            desc = "Note off: "
+        else:
+            desc = "Note on: "
+        f = note_formatter(desc, ch)
+    elif func == 0xA0:
+        f = note_formatter("Polyphonic aftertouch: ",
+                           ch, "Aftertouch pressure: ")
+    elif func == 0xB0:
+        f = control_mode_formatter("Control mode change: ", ch)
+    elif func == 0xC0:
+        f = channel_formatter("Program Change: ", ch)
+    elif func == 0xD0:
+        f = channel_formatter("Channel aftertouch: ", ch)
+    elif ev[0] in [0xF0, 0xF7]:
+        f = meta_formatter("System-exclusive event: ")
+
+    if f:
+        if len(ev) > 2:
+            print(padding + f.format(ev[1], ev[2]))
+        elif len(ev) > 1:
+            print(padding + f.format(ev[1]))
+        else:
+            print(padding + f.format())
+    else:
+        print(padding + "Unrecognized MIDI event: " + str(ev))
+
+
+def dump_midi(data, midi_file, options):
+    if not options.pretty:
+        print(data)
+        return
+    # First, dump general info, #tracks, etc.
+    print("Filename:     " + midi_file)
+    i = data[0]
+    m_formats = {0: 'single multi-channel track',
+                 1: "one or more simultaneous tracks",
+                 2: "one or more sequentially independent single-track patterns"}
+    print("MIDI format:  " + str(i[0]) + " (" + m_formats.get(i[0], "") + ")")
+    print("Divisions:    " + str(i[1]) + " per whole note")
+    print("#Tracks:      " + str(len(data[1])))
+    n = 0
+    for tr in data[1]:
+        time = 0
+        n += 1
+        print()
+        print("Track " + str(n) + ":")
+        print("    Time 0:")
+        for ev in tr:
+            if ev[0] > time:
+                time = ev[0]
+                print("    Time " + str(time) + ": ")
+            dump_event(ev[1], time, "        ")
+
+
+def go():
+    options, args = process_options(sys.argv[1:])
+    midi_file = args[0]
+    midi_data = read_midi(midi_file)
+    info = track_info(midi_data)
+    if (options.dump or options.pretty):
+        dump_midi(midi_data, midi_file, options)
+    elif options.regexp:
+        import re
+        regexp = re.compile(options.regexp)
+        numbers = [str(n+1) for n, name in info if regexp.search(name)]
+        if numbers:
+            if options.prefix:
+                sys.stdout.write('%s ' % (options.prefix,))
+            sys.stdout.write(','.join(numbers))
+            sys.stdout.write('\n')
+    else:
+        for n, name in info:
+            sys.stdout.write('%d %s\n' % (n+1, name,))
+
+
+if __name__ == '__main__':
+    go()

lilypond-2.24.2/bin/lilypond-book.py

@@ -0,0 +1,790 @@
+#!/home/lily/lilypond-2.24.2/release/binaries/dependencies/install/Python-3.10.8/bin/python3.10
+# -*- coding: utf-8 -*-
+
+# This file is part of LilyPond, the GNU music typesetter.
+#
+# Copyright (C) 1998--2022  Han-Wen Nienhuys <[email protected]>
+#                           Jan Nieuwenhuizen <[email protected]>
+#
+# LilyPond is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# LilyPond is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+
+r'''
+Example usage:
+
+test:
+  lilypond-book --filter="tr '[a-z]' '[A-Z]'" BOOK
+
+convert-ly on book:
+  lilypond-book --filter="convert-ly --no-version --from=1.6.11 -" BOOK
+
+classic lilypond-book:
+  lilypond-book --process="lilypond" BOOK.tely
+
+TODO:
+
+  *  ly-options: intertext?
+  *  --line-width?
+  *  eps in latex / eps by lilypond -b ps?
+  *  check latex parameters, twocolumn, multicolumn?
+  *  use --png --ps --pdf for making images?
+
+  *  Converting from lilypond-book source, substitute:
+   @mbinclude foo.itely -> @include foo.itely
+   \mbinput -> \input
+
+'''
+
+
+# TODO: Better solve the global_options copying to the snippets...
+
+import gettext
+import glob
+import hashlib
+from optparse import OptionGroup, SUPPRESS_HELP
+import os
+import re
+import shlex
+import stat
+import subprocess
+import sys
+import tempfile
+import typing
+
+# See lock_path and unlock_path; this module is not available at all on Windows.
+if os.name == 'posix':
+    import fcntl
+
+"""
+
+# relocate-preamble.py.in
+#
+# This file is part of LilyPond, the GNU music typesetter.
+#
+# Copyright (C) 2007--2022  Han-Wen Nienhuys <[email protected]>
+#
+# LilyPond is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# LilyPond is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+This is generic code, used for all python scripts.
+
+The quotes are to ensure that the source .py file can still be
+run as a python script, but does not include any sys.path handling.
+Otherwise, the lilypond-book calls inside the build
+might modify installed .pyc files.
+
+"""
+
+# This is needed for installations with a non-default layout, ie where share/
+# is not next to bin/.
+sys.path.insert (0, os.path.join ('/home/lily/lilypond-2.24.2/release/binaries/mingw/lilypond/install/share/lilypond/2.24.2', 'python'))
+
+# Dynamic relocation, for installations with a default layout including GUB,
+# but also for execution from the build directory.
+bindir = os.path.abspath (os.path.dirname (sys.argv[0]))
+topdir = os.path.dirname (bindir)
+if bindir.endswith (r'/scripts/out'):
+    topdir = os.path.join (os.path.dirname (topdir), 'out')
+datadir = os.path.abspath (os.path.join (topdir, 'share', 'lilypond'))
+for v in [ 'current', '2.24.2' ]:
+    sys.path.insert (0, os.path.join (datadir, v, 'python'))
+
+"""
+"""
+
+import book_base
+import book_docbook
+import book_html
+import book_latex
+import book_texinfo
+import book_snippets
+
+# Load translation and install _() into Python's builtins namespace.
+gettext.install('lilypond', '/home/lily/lilypond-2.24.2/release/binaries/mingw/lilypond/install/share/locale')
+
+import lilylib as ly
+
+backend = 'ps'
+
+help_summary = (
+    _("Process LilyPond snippets in hybrid HTML, LaTeX, texinfo or DocBook document.")
+    + '\n\n'
+    + _("Examples:")
+    + '''
+ $ lilypond-book --filter="tr '[a-z]' '[A-Z]'" %(BOOK)s
+ $ lilypond-book -F "convert-ly --no-version --from=2.0.0 -" %(BOOK)s
+ $ lilypond-book --process='lilypond -I include' %(BOOK)s
+''' % {'BOOK': _("BOOK")})
+
+authors = ('Jan Nieuwenhuizen <[email protected]>',
+           'Han-Wen Nienhuys <[email protected]>')
+
+################################################################
+
+
+def exit(i):
+    if ly.is_verbose():
+        raise Exception(_('Exiting (%d)...') % i)
+    else:
+        sys.exit(i)
+
+
+progress = ly.progress
+warning = ly.warning
+error = ly.error
+
+program_version = '2.24.2'
+if program_version.startswith("@"):
+    # '@' in lilypond-book output confuses texinfo
+    program_version = "dev"
+
+
+def identify():
+    progress('%s (GNU LilyPond) %s' % (ly.program_name, program_version))
+
+
+def warranty():
+    identify()
+    sys.stdout.write('''
+%s
+
+  %s
+
+%s
+%s
+''' % (_('Copyright (c) %s by') % '2001--2023',
+        '\n  '.join(authors),
+        _("Distributed under terms of the GNU General Public License."),
+        _("It comes with NO WARRANTY.")))
+
+
+def get_option_parser():
+    p = ly.get_option_parser(usage=_("%s [OPTION]... FILE") % 'lilypond-book',
+                             description=help_summary,
+                             conflict_handler="resolve",
+                             add_help_option=False)
+
+    p.add_option('-F', '--filter',
+                 help=_("pipe snippets through FILTER "
+                        "[default: `convert-ly -n -']"),
+                 metavar=_("FILTER"),
+                 action="store",
+                 dest="filter_cmd",
+                 default=None)
+
+    p.add_option('-f', '--format',
+                 help=_("use output format FORMAT (texi [default], "
+                        "texi-html, latex, html, docbook)"),
+                 metavar=_("FORMAT"),
+                 action='store')
+
+    p.add_option("-h", "--help",
+                 action="help",
+                 help=_("show this help and exit"))
+
+    # Turn on syntax highlighting using vendored Pygments
+    # when building the main documentation.  Purposefully
+    # undocumented, it is not for end users.
+    p.add_option("--highlight",
+                 action="store_true",
+                 help=SUPPRESS_HELP)
+
+    p.add_option("-I", '--include',
+                 help=_("add DIR to include path"),
+                 metavar=_("DIR"),
+                 action='append',
+                 dest='include_path',
+                 default=[])
+
+    p.add_option('--info-images-dir',
+                 help=_("format Texinfo output so that Info will "
+                        "look for images of music in DIR"),
+                 metavar=_("DIR"),
+                 action='store',
+                 dest='info_images_dir',
+                 default='')
+
+    p.add_option('--left-padding',
+                 help=_("pad left side of music to align music in spite "
+                        "of uneven bar numbers (in mm) [default: %default]"),
+                 metavar=_("PAD"),
+                 dest="padding_mm",
+                 type="float",
+                 default=3.0)
+
+    p.add_option('--lily-loglevel',
+                 help=_("print lilypond log messages according to LOGLEVEL "
+                        "[default: %default]"),
+                 metavar=_("LOGLEVEL"),
+                 action='store',
+                 dest='lily_loglevel',
+                 default=os.environ.get("LILYPOND_LOGLEVEL", None))
+
+    p.add_option('--lily-output-dir',
+                 help=_("write lily-XXX files to DIR, "
+                        "link into --output dir"),
+                 metavar=_("DIR"),
+                 action='store',
+                 dest='lily_output_dir',
+                 default=None)
+
+    p.add_option("-l", "--loglevel",
+                 help=_("print log messages according to LOGLEVEL "
+                        "(NONE, ERROR, WARNING, PROGRESS [default], DEBUG)"),
+                 metavar=_("LOGLEVEL"),
+                 action='callback',
+                 callback=ly.handle_loglevel_option,
+                 type='string')
+
+    p.add_option("-o", '--output',
+                 help=_("write output to DIR"),
+                 metavar=_("DIR"),
+                 action='store',
+                 dest='output_dir',
+                 default='')
+
+    p.add_option('-P', '--process',
+                 help=_("process ly_files using COMMAND FILE..."),
+                 metavar=_("COMMAND"),
+                 action='store',
+                 dest='process_cmd',
+                 default='')
+
+    p.add_option('--redirect-lilypond-output',
+                 help=_("redirect the lilypond output"),
+                 action='store_true',
+                 dest='redirect_output',
+                 default=False)
+
+    p.add_option('-s', '--safe',
+                 help=_("removed; using this option results in an error"),
+                 action="store_true",
+                 dest="safe_mode",
+                 default=False)
+
+    p.add_option('--skip-lily-check',
+                 help=_("do not fail if no lilypond output is found"),
+                 metavar=_("DIR"),
+                 action='store_true',
+                 dest='skip_lilypond_run',
+                 default=False)
+
+    p.add_option('--skip-png-check',
+                 help=_("do not fail if no PNG images "
+                        "are found for EPS files"),
+                 metavar=_("DIR"),
+                 action='store_true',
+                 dest='skip_png_check',
+                 default=False)
+
+    p.add_option('--use-source-file-names',
+                 help=_("write snippet output files with the same "
+                        "base name as their source file"),
+                 action='store_true',
+                 dest='use_source_file_names',
+                 default=False)
+
+    p.add_option('-V', '--verbose',
+                 help=_("be verbose"),
+                 action="callback",
+                 callback=ly.handle_loglevel_option,
+                 callback_args=("DEBUG",))
+
+    p.version = "2.24.2"
+    p.add_option("--version",
+                 help=_("show version number and exit"),
+                 action="version")
+
+    p.add_option('-w', '--warranty',
+                 help=_("show warranty and copyright"),
+                 action='store_true')
+
+    group = OptionGroup(p, "Options only for the latex and texinfo backends")
+    group.add_option('--latex-program',
+                     help=_("run executable PROG instead of latex or, "
+                            "in case --pdf option is set, "
+                            "instead of pdflatex"),
+                     metavar=_("PROG"),
+                     action='store',
+                     dest='latex_program',
+                     default='latex')
+    group.add_option('--texinfo-program',
+                     help=_("run executable PROG instead of texi2pdf"),
+                     metavar=_("PROG"),
+                     action='store',
+                     dest='texinfo_program',
+                     default='texi2pdf')
+    group.add_option('--pdf',
+                     help=_("create PDF files for use with pdftex"),
+                     action="store_true",
+                     dest="create_pdf",
+                     default=False)
+    p.add_option_group(group)
+
+    p.add_option_group('',
+                       description=(
+                           _("Report bugs via %s")
+                           % '[email protected]') + '\n')
+
+    for formatter in book_base.all_formats:
+        formatter.add_options(p)
+
+    return p
+
+
+lilypond_binary = os.path.join('/home/lily/lilypond-2.24.2/release/binaries/mingw/lilypond/install/bin', 'lilypond')
+
+# If we are called with full path, try to use lilypond binary
+# installed in the same path; this is needed in GUB binaries, where
+# @bindir is always different from the installed binary path.
+if 'bindir' in globals() and bindir:
+    lilypond_binary = os.path.join(bindir, 'lilypond')
+
+# Only use installed binary when we are installed too.
+if '/home/lily/lilypond-2.24.2/release/binaries/mingw/lilypond/install/bin' == ('@' + 'bindir@') or not os.path.exists(lilypond_binary):
+    lilypond_binary = 'lilypond'
+
+# Need to shell-quote, issue 3468
+# FIXME: we should really pass argument lists
+# everywhere instead of playing with shell syntax.
+lilypond_binary = shlex.quote(lilypond_binary)
+
+global_options = None
+
+
+def command_name(cmd):
+    # Strip all stuf after command,
+    # deal with "((latex ) >& 1 ) .." too
+    cmd = re.match(r'([\(\)]*)([^\\ ]*)', cmd).group(2)
+    return os.path.basename(cmd)
+
+
+def system_in_directory(cmd_str, directory, log_file):
+    """Execute a command in a different directory."""
+
+    if ly.is_verbose():
+        ly.progress(_("Invoking `%s\'") % cmd_str)
+    elif global_options.redirect_output:
+        ly.progress(_("Processing %s.ly") % log_file)
+    else:
+        name = command_name(cmd_str)
+        ly.progress(_("Running %s...") % name)
+
+    output_location = None
+    if global_options.redirect_output:
+        output_location = open(log_file + '.log', 'w', encoding='utf-8')
+
+    try:
+        subprocess.run(cmd_str, stdout=output_location,
+                       stderr=output_location, cwd=directory,
+                       shell=True, check=True)
+    except subprocess.CalledProcessError as e:
+        sys.stderr.write("%s\n" % e)
+        sys.exit(1)
+
+
+def process_snippets(cmd, outdated_dict,
+                     formatter, lily_output_dir):
+    """Run cmd on all of the .ly files from snippets."""
+    basenames = sorted(outdated_dict.keys())
+
+    # No need for a secure hash function, just need a digest.
+    checksum = hashlib.md5()
+    for name in basenames:
+        checksum.update(name.encode('ascii'))
+    checksum = checksum.hexdigest()
+
+    lily_output_dir = global_options.lily_output_dir
+
+    # Write list of snippet names.
+    snippet_names_file = 'snippet-names-%s.ly' % checksum
+    snippet_names_path = os.path.join(lily_output_dir, snippet_names_file)
+    with open(snippet_names_path, 'w', encoding='utf-8') as snippet_names:
+        snippet_names.write('\n'.join([name + '.ly' for name in basenames]))
+
+    # Run command.
+    cmd = formatter.adjust_snippet_command(cmd)
+    # Remove .ly ending.
+    logfile = os.path.splitext(snippet_names_path)[0]
+    snippet_names_arg = mkarg(snippet_names_path.replace(os.path.sep, '/'))
+    system_in_directory(' '.join([cmd, snippet_names_arg]),
+                        lily_output_dir,
+                        logfile)
+    os.unlink(snippet_names_path)
+
+
+def lock_path(name):
+    if os.name != 'posix':
+        return None
+
+    fp = open(name, 'w', encoding='utf-8')
+    fcntl.lockf(fp, fcntl.LOCK_EX)
+    return fp
+
+
+def unlock_path(lock):
+    if os.name != 'posix':
+        return None
+    fcntl.lockf(lock, fcntl.LOCK_UN)
+    lock.close()
+
+
+def do_process_cmd(chunks, options):
+    """Wrap do_process_cmd_locked in a filesystem lock"""
+    snippets = [c for c in chunks if isinstance(
+        c, book_snippets.LilypondSnippet)]
+
+    # calculate checksums eagerly
+    for s in snippets:
+        s.get_checksum()
+
+    os.makedirs(options.lily_output_dir, exist_ok=True)
+    lock_file = os.path.join(options.lily_output_dir, "lock")
+    lock = None
+    try:
+        lock = lock_path(lock_file)
+        do_process_cmd_locked(snippets, options)
+    finally:
+        if lock:
+            unlock_path(lock)
+
+
+def do_process_cmd_locked(snippets, options):
+    """Look at all snippets, write the outdated ones, and compile them."""
+    outdated = [c for c in snippets if c.is_outdated(options.lily_output_dir)]
+
+    if outdated:
+        # First unique the list based on the basename, by using them as keys
+        # in a dict.
+        outdated_dict = dict()
+        for snippet in outdated:
+            outdated_dict[snippet.basename()] = snippet
+
+        # Next call write_ly() for each snippet once.
+        progress(_("Writing snippets..."))
+        for snippet in outdated_dict.values():
+            snippet.write_ly()
+
+        progress(_("Processing..."))
+        process_snippets(options.process_cmd, outdated_dict,
+                         options.formatter, options.lily_output_dir)
+
+    else:
+        progress(_("All snippets are up to date..."))
+
+    progress(_("Linking files..."))
+    if options.lily_output_dir != options.output_dir:
+        for snippet in snippets:
+            snippet.link_all_output_files(options.lily_output_dir,
+                                          options.output_dir)
+
+
+###
+# Format guessing data
+
+def guess_format(input_filename):
+    format = None
+    e = os.path.splitext(input_filename)[1]
+    for formatter in book_base.all_formats:
+        if formatter.can_handle_extension(e):
+            return formatter
+    error(_("cannot determine format for: %s" % input_filename))
+    exit(1)
+
+def write_if_updated(file_name, lines):
+    try:
+        with open(file_name, encoding='utf-8') as file:
+            old_str = file.read()
+    except FileNotFoundError:
+        pass
+    else:
+        new_str = ''.join(lines)
+        if old_str == new_str:
+            progress(_("%s is up to date.") % file_name)
+
+            # this prevents make from always rerunning lilypond-book:
+            # output file must be touched in order to be up to date
+            os.utime(file_name, None)
+            return
+
+    output_dir = os.path.dirname(file_name)
+    os.makedirs(output_dir, exist_ok=True)
+
+    progress(_("Writing `%s'...") % file_name)
+    open(file_name, 'w', encoding='utf-8').writelines(lines)
+
+
+def note_input_file(name, inputs=[]):
+    # hack: inputs is mutable!
+    inputs.append(name)
+    return inputs
+
+
+def samefile(f1, f2):
+    try:
+        return os.path.samefile(f1, f2)
+    except AttributeError:                # Windoze
+        f1 = re.sub("//*", "/", f1)
+        f2 = re.sub("//*", "/", f2)
+        return f1 == f2
+
+
+def do_file(input_filename, included=False):
+    # Ugh.
+    input_absname = input_filename
+    if not input_filename or input_filename == '-':
+        in_handle = sys.stdin
+    else:
+        if os.path.exists(input_filename):
+            input_fullname = input_filename
+        else:
+            input_fullname = global_options.formatter.input_fullname(
+                input_filename)
+        # Normalize path to absolute path, since we will change cwd to the output dir!
+        # Otherwise, "lilypond-book -o out test.tex" will complain that it is
+        # overwriting the input file (which it is actually not), since the
+        # input filename is relative to the CWD...
+        input_absname = os.path.abspath(input_fullname)
+
+        note_input_file(input_fullname)
+        in_handle = open(input_fullname, 'r', encoding='utf-8')
+
+    if input_filename == '-':
+        global_options.input_dir = os.getcwd()
+        input_base = 'stdin'
+    elif included:
+        input_base = os.path.splitext(input_filename)[0]
+    else:
+        global_options.input_dir = os.path.split(input_absname)[0]
+        input_base = os.path.basename(
+            os.path.splitext(input_filename)[0])
+
+    output_filename = os.path.join(global_options.output_dir,
+                                   input_base + global_options.formatter.default_extension)
+    if (os.path.exists(input_filename)
+        and os.path.exists(output_filename)
+            and samefile(output_filename, input_absname)):
+        error(
+            _("Output would overwrite input file; use --output."))
+        exit(2)
+
+    try:
+        progress(_("Reading `%s'") % input_absname)
+        source = in_handle.read()
+
+        if not included:
+            global_options.formatter.init_default_snippet_options(source)
+
+        progress(_("Dissecting..."))
+        chunks = book_base.find_toplevel_snippets(
+            source, global_options.formatter, global_options)
+        for c in chunks:
+            c.set_output_fullpath(output_filename)
+
+        # Let the formatter modify the chunks before further processing
+        chunks = global_options.formatter.process_chunks(chunks)
+
+        def process_include(snippet):
+            name = snippet.substring('filename')
+            progress(_("Processing include `%s'") % name)
+            return do_file(name, included=True)
+
+        include_chunks = []
+        for x in chunks:
+            if isinstance(x, book_snippets.IncludeSnippet):
+               include_chunks += process_include(x)
+
+        return chunks + include_chunks
+
+    except book_snippets.CompileError:
+        progress(_("Removing `%s'") % output_filename)
+        raise book_snippets.CompileError
+
+
+def do_options():
+    global global_options
+
+    opt_parser = get_option_parser()
+    (global_options, args) = opt_parser.parse_args()
+
+    if global_options.safe_mode:
+        error("""Due to security vulnerabilities deemed unfixable
+by the developers, LilyPond's safe mode was removed in
+version 2.23.12 in order not to provide a false sense of
+security.  If you need to compile an untrusted .ly file, please
+use an external tool to run LilyPond in a sandbox.""")
+        raise SystemExit
+
+    global_options.information = {
+        'program_version': program_version, 'program_name': ly.program_name}
+
+    if global_options.lily_output_dir:
+        global_options.lily_output_dir = os.path.expanduser(
+            global_options.lily_output_dir)
+    if global_options.output_dir:
+        global_options.output_dir = os.path.expanduser(
+            global_options.output_dir)
+
+    # Compute absolute paths of include directories.
+    for i, path in enumerate(global_options.include_path):
+        global_options.include_path[i] = os.path.abspath(path)
+
+    # Append the current directory.
+    global_options.include_path.append(os.getcwd())
+
+    if global_options.warranty:
+        warranty()
+        exit(0)
+    if not args or len(args) > 1:
+        opt_parser.print_help()
+        exit(2)
+
+    return args
+
+
+def mkarg(x):
+    r"""
+    A modified version of the commands.mkarg(x)
+
+    Uses double quotes (since Windows can't handle the single quotes)
+    and escapes the characters \, $, ", and ` for unix shells.
+    """
+    if os.name == 'nt':
+        return ' "%s"' % x
+    s = ' "'
+    for c in x:
+        if c in '\\$"`':
+            s = s + '\\'
+        s = s + c
+    s = s + '"'
+    return s
+
+
+def write_output_documents(chunks: typing.List[book_snippets.Chunk], is_filter: bool):
+    text_by_path = {}
+    for ch in chunks:
+        path = ch.output_fullpath()
+        if path not in text_by_path:
+            text_by_path[path] = []
+
+        if is_filter:
+            s = ch.filter_text()
+        else:
+            s = ch.replacement_text()
+
+        text_by_path[path].append(s)
+
+    for path in text_by_path:
+        write_if_updated(path, text_by_path[path])
+
+
+def main():
+    if "LILYPOND_BOOK_LOGLEVEL" in os.environ:
+        ly.set_loglevel(os.environ["LILYPOND_BOOK_LOGLEVEL"])
+    files = do_options()
+
+    basename = os.path.splitext(files[0])[0]
+    basename = os.path.split(basename)[1]
+
+    if global_options.format:
+        # Retrieve the formatter for the given format
+        for formatter in book_base.all_formats:
+            if formatter.can_handle_format(global_options.format):
+                global_options.formatter = formatter
+    else:
+        global_options.formatter = guess_format(files[0])
+        global_options.format = global_options.formatter.format
+
+    # make the global options available to the formatters:
+    global_options.formatter.global_options = global_options
+    formats = global_options.formatter.image_formats
+
+    if global_options.process_cmd == '':
+        global_options.process_cmd = (
+            lilypond_binary + ' --formats=%s ' % formats)
+
+    global_options.process_cmd += (
+        ' '.join([' -I %s' % mkarg(p) for p in global_options.include_path])
+        + ' -daux-files ')
+
+    global_options.formatter.process_options(global_options)
+
+    if global_options.lily_loglevel:
+        ly.debug_output(_("Setting LilyPond's loglevel to %s") %
+                        global_options.lily_loglevel, True)
+        global_options.process_cmd += " --loglevel=%s" % global_options.lily_loglevel
+    elif ly.is_verbose():
+        if os.environ.get("LILYPOND_LOGLEVEL", None):
+            ly.debug_output(_("Setting LilyPond's loglevel to %s (from environment variable LILYPOND_LOGLEVEL)") %
+                            os.environ.get("LILYPOND_LOGLEVEL", None), True)
+            global_options.process_cmd += " --loglevel=%s" % os.environ.get(
+                "LILYPOND_LOGLEVEL", None)
+        else:
+            ly.debug_output(
+                _("Setting LilyPond's output to --verbose, implied by lilypond-book's setting"), True)
+            global_options.process_cmd += " --verbose"
+
+    global_options.process_cmd += " -dread-file-list -dno-strip-output-dir"
+
+    # Store the original argument to construct the dependency file below.
+    relative_output_dir = global_options.output_dir
+
+    if global_options.output_dir:
+        global_options.output_dir = os.path.abspath(global_options.output_dir)
+        # Create the directory, but do not complain if it already exists.
+        os.makedirs(global_options.output_dir, exist_ok=True)
+    else:
+        global_options.output_dir = os.getcwd()
+
+    if global_options.lily_output_dir:
+        global_options.lily_output_dir = os.path.abspath(
+            global_options.lily_output_dir)
+    else:
+        global_options.lily_output_dir = global_options.output_dir
+
+    identify()
+    try:
+        chunks = do_file(files[0])
+        if global_options.filter_cmd:
+            write_output_documents(chunks, is_filter=True)
+        elif global_options.process_cmd:
+            do_process_cmd(chunks, global_options)
+            progress(_("Compiling `%s'...") % files[0])
+            write_output_documents(chunks, is_filter=False)
+    except book_snippets.CompileError:
+        exit(1)
+
+    inputs = note_input_file('')
+    inputs.pop()
+
+    base_file_name = os.path.splitext(os.path.basename(files[0]))[0]
+    dep_file = os.path.join(global_options.output_dir, base_file_name + '.dep')
+    final_output_file = os.path.join(relative_output_dir,
+                                     base_file_name + global_options.formatter.default_extension)
+    open(dep_file, 'w', encoding='utf-8').write('%s: %s\n'
+                              % (final_output_file, ' '.join(inputs)))
+
+
+if __name__ == '__main__':
+    main()

lilypond-2.24.2/bin/lilypond-invoke-editor.py

@@ -0,0 +1,135 @@
+#!/home/lily/lilypond-2.24.2/release/binaries/dependencies/install/Python-3.10.8/bin/python3.10
+#
+# This file is part of LilyPond, the GNU music typesetter.
+#
+# Copyright (C) 2022  Jonas Hahnfeld <[email protected]>
+#
+# LilyPond is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# LilyPond is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+
+import gettext
+import os
+import re
+import shlex
+import subprocess
+import sys
+import urllib.parse
+
+# Load translation and install _() into Python's builtins namespace.
+gettext.install("lilypond", "/home/lily/lilypond-2.24.2/release/binaries/mingw/lilypond/install/share/locale")
+
+
+def show_version(file):
+    file.write("lilypond-invoke-editor (GNU LilyPond 2.24.2)\n")
+
+
+def show_help(file):
+    file.write(
+        _(
+            """Usage: lilypond-invoke-editor textedit://FILE:LINE:CHAR:COLUMN
+
+Visit a file and position the cursor.
+
+Options:
+  -h, --help          show this help
+  -v, --version       show version
+"""
+        )
+    )
+
+
+# We don't need heavy option parsing here, just expect exactly one argument.
+if len(sys.argv) != 2:
+    show_version(sys.stderr)
+    show_help(sys.stderr)
+    sys.exit(2)
+
+argument = sys.argv[1]
+
+# Handle the two options this script knows about.
+if argument in ("-h", "--help"):
+    show_version(sys.stdout)
+    show_help(sys.stdout)
+    sys.exit(0)
+if argument in ("-v", "--version"):
+    show_version(sys.stdout)
+    sys.exit(0)
+
+# Now start parsing the textedit argument, first by matching its components.
+m = re.fullmatch(r"textedit://(.*):([0-9]+):([0-9]+):([0-9]*)", argument)
+if m is None:
+    show_help(sys.stderr)
+    sys.exit(2)
+
+file, line, char, column = m.groups()
+file = urllib.parse.unquote(file)
+
+
+def replace_template(template):
+    return template % {
+        "file": file,
+        "line": line,
+        "char": char,
+        "column": column,
+    }
+
+
+# Determine the editor, going from more to less specific environment variables.
+editor = "emacs"
+for env in ("LYEDITOR", "XEDITOR", "EDITOR"):
+    if env in os.environ:
+        editor = os.environ[env]
+        break
+
+# Check if we have a template for this editor to position the cursor.
+EDITOR_TEMPLATES = {
+    "atom": [("atom", "%(file)s:%(line)s:%(column)s")],
+    "emacs": [
+        ("emacsclient", "--no-wait", "+%(line)s:%(column)s", "%(file)s"),
+        ("emacs", "+%(line)s:%(column)s", "%(file)s"),
+    ],
+    "geany": [("geany", "--line", "%(line)s", "--column", "%(column)s", "%(file)s")],
+    "gedit": [("gedit", "--wait", "%(file)s", "+%(line)s:%(column)s")],
+    "gvim": [("gvim", "--remote", "+:%(line)s:norm%(column)s", "%(file)s")],
+    "jedit": [("jedit", "-reuseview", "%(file)s", "+line:%(line)s")],
+    "kate": [
+        ("kate", "--block", "--line", "%(line)s", "--column", "%(column)s", "%(file)s")
+    ],
+    # "nc" nowadays also stands for netcat...
+    "nedit": [("nc", "-noask", "+%(line)s", "%(file)s")],
+    "syn": [("syn", "-line", "%(line)s", "-col", "%(char)s", "%(file)s")],
+    "uedit32": [("uedit32", "%(file)s", "-l%(line)s", "-c%(char)s")],
+}
+
+editor_commands = []
+if "%(file)s" in editor:
+    editor_commands = [shlex.split(editor)]
+elif editor in EDITOR_TEMPLATES:
+    editor_commands = EDITOR_TEMPLATES[editor]
+else:
+    editor_commands = [(editor, "%(file)s")]
+
+editor_commands = [list(map(replace_template, cmd)) for cmd in editor_commands]
+
+# Try commands one after another, until one succeeds.
+for cmd in editor_commands:
+    try:
+        proc = subprocess.run(cmd)
+        if proc.returncode == 0:
+            sys.exit(0)
+    except FileNotFoundError as e:
+        pass
+
+sys.stderr.write(_("failed to invoke editor:"))
+sys.stderr.write(" " + str(editor_commands) + "\n")
+sys.exit(1)

lilypond-2.24.2/bin/lilypond.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d9c9ba6fc2c1d7c082f1e36d75053f29df32e5e513d853b30887dee2f1b2ed40
+size 13852160

lilypond-2.24.2/bin/lilysong.py

@@ -0,0 +1,273 @@
+#!/home/lily/lilypond-2.24.2/release/binaries/dependencies/install/Python-3.10.8/bin/python3.10
+
+# Copyright (c) 2006--2022 Brailcom, o.p.s.
+#
+# Author: Milan Zamazal <[email protected]>
+#
+# This file is part of LilyPond, the GNU music typesetter.
+#
+# LilyPond is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# LilyPond is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+
+
+import codecs
+import optparse
+import os
+import subprocess
+import sys
+import tempfile
+
+"""
+
+# relocate-preamble.py.in
+#
+# This file is part of LilyPond, the GNU music typesetter.
+#
+# Copyright (C) 2007--2022  Han-Wen Nienhuys <[email protected]>
+#
+# LilyPond is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# LilyPond is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+This is generic code, used for all python scripts.
+
+The quotes are to ensure that the source .py file can still be
+run as a python script, but does not include any sys.path handling.
+Otherwise, the lilypond-book calls inside the build
+might modify installed .pyc files.
+
+"""
+
+# This is needed for installations with a non-default layout, ie where share/
+# is not next to bin/.
+sys.path.insert (0, os.path.join ('/home/lily/lilypond-2.24.2/release/binaries/mingw/lilypond/install/share/lilypond/2.24.2', 'python'))
+
+# Dynamic relocation, for installations with a default layout including GUB,
+# but also for execution from the build directory.
+bindir = os.path.abspath (os.path.dirname (sys.argv[0]))
+topdir = os.path.dirname (bindir)
+if bindir.endswith (r'/scripts/out'):
+    topdir = os.path.join (os.path.dirname (topdir), 'out')
+datadir = os.path.abspath (os.path.join (topdir, 'share', 'lilypond'))
+for v in [ 'current', '2.24.2' ]:
+    sys.path.insert (0, os.path.join (datadir, v, 'python'))
+
+"""
+"""
+
+
+FESTIVAL_COMMAND = ['festival', '--pipe']
+VOICE_CODINGS = {'voice_czech_ph': 'iso-8859-2'}
+
+_USAGE = """lilysong [-p PLAY-PROGRAM] FILE.xml [LANGUAGE-CODE-OR-VOICE [SPEEDUP]]
+       lilysong FILE.ly [LANGUAGE-CODE-OR-VOICE]
+       lilysong --list-voices
+       lilysong --list-languages
+"""
+
+
+def usage():
+    print('Usage:', _USAGE)
+    sys.exit(2)
+
+
+def process_options(args):
+    parser = optparse.OptionParser(usage=_USAGE, version="2.24.2")
+    parser.add_option('', '--list-voices', action='store_true', dest='list_voices',
+                      help="list available Festival voices")
+    parser.add_option('', '--list-languages', action='store_true', dest='list_languages',
+                      help="list available Festival languages")
+    parser.add_option('-p', '--play-program', metavar='PROGRAM',
+                      action='store', type='string', dest='play_program',
+                      help="use PROGRAM to play song immediately")
+    options, args = parser.parse_args(args)
+    return options, args
+
+
+def call_festival(scheme_code):
+    p = subprocess.Popen(FESTIVAL_COMMAND, stdin=subprocess.PIPE,
+                         stdout=subprocess.PIPE, close_fds=True)
+    p.stdin.write(scheme_code)
+    p.stdin.close()
+    answer = ''
+    while True:
+        process_output = p.stdout.read()
+        if not process_output:
+            break
+        answer = answer + process_output
+    return answer
+
+
+def select_voice(language_or_voice):
+    if language_or_voice[:6] == 'voice_':
+        voice = language_or_voice
+    else:
+        voice = call_festival('''
+(let ((candidates '()))
+  (mapcar (lambda (v)
+            (if (eq (cadr (assoc 'language (cadr (voice.description v)))) '%s)
+                (set! candidates (cons v candidates))))
+          (append (voice.list) (mapcar car Voice_descriptions)))
+  (if candidates
+      (format t "voice_%%s" (car candidates))
+      (format t "nil")))
+''' % (language_or_voice,))
+        if voice == 'nil':
+            voice = None
+    return voice
+
+
+def list_voices():
+    print(call_festival('''
+(let ((voices (voice.list))
+      (print-voice (lambda (v) (format t "voice_%s\n" v))))
+  (mapcar print-voice voices)
+  (mapcar (lambda (v) (if (not (member v voices)) (print-voice v)))
+          (mapcar car Voice_descriptions)))
+'''))
+
+
+def list_languages():
+    print(call_festival('''
+(let ((languages '()))
+  (let ((voices (voice.list))
+        (print-language (lambda (v)
+                          (let ((language (cadr (assoc 'language (cadr (voice.description v))))))
+                            (if (and language (not (member language languages)))
+                                (begin
+                                  (set! languages (cons language languages))
+                                  (print language)))))))
+    (mapcar print-language voices)
+    (mapcar (lambda (v) (if (not (member v voices)) (print-language v)))
+            (mapcar car Voice_descriptions))))
+'''))
+
+
+def process_xml_file(file_name, voice, speedup, play_program):
+    if speedup == 1:
+        speedup = None
+    coding = (VOICE_CODINGS.get(voice) or 'iso-8859-1')
+    _, xml_temp_file = tempfile.mkstemp('.xml')
+    try:
+        # recode the XML file
+        recodep = (coding != 'utf-8')
+        if recodep:
+            decode = codecs.getdecoder('utf-8')
+            encode = codecs.getencoder(coding)
+        input = open(file_name, encoding='utf-8')
+        output = open(xml_temp_file, 'w', encoding='utf-8')
+        while True:
+            data = input.read()
+            if not data:
+                break
+            if recodep:
+                data = encode(decode(data)[0])[0]
+            output.write(data)
+        output.close()
+        # synthesize
+        wav_file = file_name[:-3] + 'wav'
+        if speedup:
+            _, wav_temp_file = tempfile.mkstemp('.wav')
+        else:
+            wav_temp_file = wav_file
+        try:
+            print("text2wave -eval '(%s)' -mode singing '%s' -o '%s'" %
+                  (voice, xml_temp_file, wav_temp_file,))
+            result = os.system("text2wave -eval '(%s)' -mode singing '%s' -o '%s'" %
+                               (voice, xml_temp_file, wav_temp_file,))
+            if result:
+                sys.stdout.write("Festival processing failed.\n")
+                return
+            if speedup:
+                result = os.system("sox '%s' '%s' speed '%f'" %
+                                   (wav_temp_file, wav_file, speedup,))
+                if result:
+                    sys.stdout.write("Festival processing failed.\n")
+                    return
+        finally:
+            if speedup:
+                try:
+                    os.delete(wav_temp_file)
+                except OSError:
+                    pass
+        sys.stdout.write("%s created.\n" % (wav_file,))
+        # play
+        if play_program:
+            os.system("%s '%s' >/dev/null" % (play_program, wav_file,))
+    finally:
+        try:
+            os.delete(xml_temp_file)
+        except OSError:
+            pass
+
+
+def process_ly_file(file_name, voice):
+    result = os.system("lilypond '%s'" % (file_name,))
+    if result:
+        return
+    xml_file = None
+    for f in os.listdir(os.path.dirname(file_name) or '.'):
+        if (f[-4:] == '.xml' and
+                (not xml_file or os.stat.st_mtime(f) > os.stat.st_mtime(xml_file))):
+            xml_file = f
+    if xml_file:
+        process_xml_file(xml_file, voice, None, None)
+    else:
+        sys.stderr.write("No XML file found\n")
+
+
+def go():
+    options, args = process_options(sys.argv[1:])
+    if options.list_voices:
+        list_voices()
+    elif options.list_languages:
+        list_languages()
+    else:
+        arglen = len(args)
+        if arglen < 1:
+            usage()
+        file_name = args[0]
+        if arglen > 1:
+            language_or_voice = args[1]
+            voice = select_voice(language_or_voice)
+        else:
+            voice = None
+        if file_name[-3:] == '.ly':
+            if arglen > 2:
+                usage()
+            process_ly_file(file_name, voice)
+        else:
+            if arglen > 3:
+                usage()
+            elif arglen == 3:
+                try:
+                    speedup = float(args[2])
+                except ValueError:
+                    usage()
+            else:
+                speedup = None
+            process_xml_file(file_name, voice, speedup, options.play_program)
+
+
+if __name__ == '__main__':
+    go()

lilypond-2.24.2/bin/midi2ly.py

@@ -0,0 +1,1329 @@
+#!/home/lily/lilypond-2.24.2/release/binaries/dependencies/install/Python-3.10.8/bin/python3.10
+#
+# midi2ly.py -- LilyPond midi import script
+
+# This file is part of LilyPond, the GNU music typesetter.
+#
+# Copyright (C) 1998--2022  Han-Wen Nienhuys <[email protected]>
+#                           Jan Nieuwenhuizen <[email protected]>
+#
+# LilyPond is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# LilyPond is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+
+
+'''
+TODO:
+'''
+
+import gettext
+import math
+import os
+import sys
+
+"""
+
+# relocate-preamble.py.in
+#
+# This file is part of LilyPond, the GNU music typesetter.
+#
+# Copyright (C) 2007--2022  Han-Wen Nienhuys <[email protected]>
+#
+# LilyPond is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# LilyPond is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+This is generic code, used for all python scripts.
+
+The quotes are to ensure that the source .py file can still be
+run as a python script, but does not include any sys.path handling.
+Otherwise, the lilypond-book calls inside the build
+might modify installed .pyc files.
+
+"""
+
+# This is needed for installations with a non-default layout, ie where share/
+# is not next to bin/.
+sys.path.insert (0, os.path.join ('/home/lily/lilypond-2.24.2/release/binaries/mingw/lilypond/install/share/lilypond/2.24.2', 'python'))
+
+# Dynamic relocation, for installations with a default layout including GUB,
+# but also for execution from the build directory.
+bindir = os.path.abspath (os.path.dirname (sys.argv[0]))
+topdir = os.path.dirname (bindir)
+if bindir.endswith (r'/scripts/out'):
+    topdir = os.path.join (os.path.dirname (topdir), 'out')
+datadir = os.path.abspath (os.path.join (topdir, 'share', 'lilypond'))
+for v in [ 'current', '2.24.2' ]:
+    sys.path.insert (0, os.path.join (datadir, v, 'python'))
+
+"""
+"""
+
+# Load translation and install _() into Python's builtins namespace.
+gettext.install('lilypond', '/home/lily/lilypond-2.24.2/release/binaries/mingw/lilypond/install/share/locale')
+
+import lilylib as ly
+
+################################################################
+# CONSTANTS
+
+
+LINE_BELL = 60
+scale_steps = [0, 2, 4, 5, 7, 9, 11]
+global_options = None
+
+clocks_per_1 = 1536
+clocks_per_4 = 0
+
+time = None
+reference_note = 0 # a mess
+start_quant_clocks = 0
+
+duration_quant_clocks = 0
+allowed_tuplet_clocks = []
+bar_max = 0
+
+################################################################
+
+
+program_version = '2.24.2'
+
+authors = ('Jan Nieuwenhuizen <[email protected]>',
+           'Han-Wen Nienhuys <[email protected]>')
+
+
+
+def identify():
+    sys.stdout.write('%s (GNU LilyPond) %s\n' %
+                     (ly.program_name, program_version))
+
+
+def warranty():
+    identify()
+    sys.stdout.write('''
+%s
+
+  %s
+
+%s
+%s
+''' % (_('Copyright (c) %s by') % '1998--2023',
+        '\n  '.join(authors),
+        _('Distributed under terms of the GNU General Public License.'),
+        _('It comes with NO WARRANTY.')))
+
+
+def strip_extension(f, ext):
+    (p, e) = os.path.splitext(f)
+    if e == ext:
+        e = ''
+    return p + e
+
+
+class Duration:
+    allowed_durs = (1, 2, 4, 8, 16, 32, 64, 128)
+
+    def __init__(self, clocks):
+        self.clocks = clocks
+        (self.dur, self.num, self.den) = self.dur_num_den(clocks)
+
+    def dur_num_den(self, clocks):
+        for i in range(len(allowed_tuplet_clocks)):
+            if clocks == allowed_tuplet_clocks[i]:
+                return global_options.allowed_tuplets[i]
+
+        dur = 0
+        num = 1
+        den = 1
+        g = math.gcd(int(clocks), clocks_per_1)
+        if g:
+            (dur, num) = (clocks_per_1 / g, clocks / g)
+        if not dur in self.allowed_durs:
+            dur = 4
+            num = clocks
+            den = clocks_per_4
+        return (dur, num, den)
+
+    def __repr__(self):
+        if self.den == 1:
+            if self.num == 1:
+                s = '%d' % self.dur
+            elif self.num == 3 and self.dur != 1:
+                s = '%d.' % (self.dur / 2)
+            else:
+                s = '%d*%d' % (self.dur, self.num)
+        else:
+            s = '%d*%d/%d' % (self.dur, self.num, self.den)
+        return s
+
+    def dump(self):
+        global reference_note
+        reference_note.duration = self
+        return repr(self)
+
+    def compare(self, other):
+        return self.clocks - other.clocks
+
+
+def sign(x):
+    if x >= 0:
+        return 1
+    else:
+        return -1
+
+
+class Note:
+    names = (0, 0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6)
+    alterations = (0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0)
+    alteration_names = ('eses', 'es', '', 'is', 'isis')
+
+    def __init__(self, clocks, pitch, velocity):
+        self.pitch = pitch
+        self.velocity = velocity
+        # hmm
+        self.clocks = clocks
+        self.duration = Duration(clocks)
+        (self.octave, self.notename, self.alteration) = self.o_n_a()
+
+    def o_n_a(self):
+        # major scale: do-do
+        # minor scale: la-la  (= + 5) '''
+
+        n = self.names[(self.pitch) % 12]
+        a = self.alterations[(self.pitch) % 12]
+
+        key = global_options.key
+        if not key:
+            key = Key(0, 0, 0)
+
+        if a and key.flats:
+            a = - self.alterations[(self.pitch) % 12]
+            n = (n - a) % 7
+
+        #  By tradition, all scales now consist of a sequence
+        #  of 7 notes each with a distinct name, from amongst
+        #  a b c d e f g.  But, minor scales have a wide
+        #  second interval at the top - the 'leading note' is
+        #  sharped. (Why? it just works that way! Anything
+        #  else doesn't sound as good and isn't as flexible at
+        #  saying things. In medieval times, scales only had 6
+        #  notes to avoid this problem - the hexachords.)
+
+        #  So, the d minor scale is d e f g a b-flat c-sharp d
+        #  - using d-flat for the leading note would skip the
+        #  name c and duplicate the name d.  Why isn't c-sharp
+        #  put in the key signature? Tradition. (It's also
+        #  supposedly based on the Pythagorean theory of the
+        #  cycle of fifths, but that really only applies to
+        #  major scales...)  Anyway, g minor is g a b-flat c d
+        #  e-flat f-sharp g, and all the other flat minor keys
+        #  end up with a natural leading note. And there you
+        #  have it.
+
+        #  John Sankey <[email protected]>
+        #
+        #  Let's also do a-minor: a b c d e f gis a
+        #
+        #  --jcn
+
+        o = self.pitch / 12 - 4
+
+        if key.minor:
+            # as -> gis
+            if (key.sharps == 0 and key.flats == 0
+                    and n == 5 and a == -1):
+                n = 4
+                a = 1
+            # des -> cis
+            elif key.flats == 1 and n == 1 and a == -1:
+                n = 0
+                a = 1
+            # ges -> fis
+            elif key.flats == 2 and n == 4 and a == -1:
+                n = 3
+                a = 1
+            # g -> fisis
+            elif key.sharps == 5 and n == 4 and a == 0:
+                n = 3
+                a = 2
+            # d -> cisis
+            elif key.sharps == 6 and n == 1 and a == 0:
+                n = 0
+                a = 2
+            # a -> gisis
+            elif key.sharps == 7 and n == 5 and a == 0:
+                n = 4
+                a = 2
+
+        # b -> ces
+        if key.flats >= 6 and n == 6 and a == 0:
+            n = 0
+            a = -1
+            o = o + 1
+        # e -> fes
+        if key.flats >= 7 and n == 2 and a == 0:
+            n = 3
+            a = -1
+
+        # f -> eis
+        if key.sharps >= 3 and n == 3 and a == 0:
+            n = 2
+            a = 1
+        # c -> bis
+        if key.sharps >= 4 and n == 0 and a == 0:
+            n = 6
+            a = 1
+            o = o - 1
+
+        return (o, n, a)
+
+    def __repr__(self):
+        s = chr((self.notename + 2) % 7 + ord('a'))
+        return 'Note(%s %s)' % (s, repr(self.duration))
+
+    def dump(self, dump_dur=True):
+        global reference_note
+        s = chr((self.notename + 2) % 7 + ord('a'))
+        s = s + self.alteration_names[self.alteration + 2]
+        if global_options.absolute_pitches:
+            commas = self.octave
+        else:
+            delta = self.pitch - reference_note.pitch
+            commas = sign(delta) * (abs(delta) // 12)
+            if (((sign(delta)
+                  * (self.notename - reference_note.notename) + 7)
+                 % 7 >= 4)
+                or ((self.notename == reference_note.notename)
+                    and (abs(delta) > 4) and (abs(delta) < 12))):
+                commas = commas + sign(delta)
+
+        if commas > 0:
+            s = s + "'" * commas
+        elif commas < 0:
+            s = s + "," * -commas
+
+        if (dump_dur
+            and (self.duration.compare(reference_note.duration)
+                 or global_options.explicit_durations)):
+            s = s + self.duration.dump()
+
+        # Chords need to handle their reference duration themselves
+
+        reference_note = self
+
+        # TODO: move space
+        return s + ' '
+
+
+class Time:
+    def __init__(self, num, den):
+        self.clocks = 0
+        self.num = num
+        self.den = den
+
+    def bar_clocks(self):
+        return clocks_per_1 * self.num / self.den
+
+    def __repr__(self):
+        return 'Time(%d/%d)' % (self.num, self.den)
+
+    def dump(self):
+        global time
+        time = self
+        return '\n  ' + '\\time %d/%d ' % (self.num, self.den) + '\n  '
+
+
+class Tempo:
+    def __init__(self, seconds_per_1):
+        self.clocks = 0
+        self.seconds_per_1 = seconds_per_1
+
+    def __repr__(self):
+        return 'Tempo(%d)' % self.bpm()
+
+    def bpm(self):
+        return 4 * 60 / self.seconds_per_1
+
+    def dump(self):
+        return '\n  ' + '\\tempo 4 = %d ' % (self.bpm()) + '\n  '
+
+
+class Clef:
+    clefs = ('"bass_8"', 'bass', 'violin', '"violin^8"')
+
+    def __init__(self, type):
+        self.type = type
+
+    def __repr__(self):
+        return 'Clef(%s)' % self.clefs[self.type]
+
+    def dump(self):
+        return '\n  \\clef %s\n  ' % self.clefs[self.type]
+
+
+class Key:
+    key_sharps = ('c', 'g', 'd', 'a', 'e', 'b', 'fis')
+    key_flats = ('BUG', 'f', 'bes', 'es', 'as', 'des', 'ges')
+
+    def __init__(self, sharps, flats, minor):
+        self.clocks = 0
+        self.flats = flats
+        self.sharps = sharps
+        self.minor = minor
+
+    def dump(self):
+        global_options.key = self
+
+        s = ''
+        if self.sharps and self.flats:
+            pass
+        else:
+            if self.flats:
+                k = (ord('cfbeadg'[self.flats % 7]) -
+                     ord('a') - 2 - 2 * self.minor + 7) % 7
+            else:
+                k = (ord('cgdaebf'[self.sharps % 7]) -
+                     ord('a') - 2 - 2 * self.minor + 7) % 7
+
+            if not self.minor:
+                name = chr((k + 2) % 7 + ord('a'))
+            else:
+                name = chr((k + 2) % 7 + ord('a'))
+
+            # fis cis gis dis ais eis bis
+            sharps = (2, 4, 6, 1, 3, 5, 7)
+            # bes es as des ges ces fes
+            flats = (6, 4, 2, 7, 5, 3, 1)
+            a = 0
+            if self.flats:
+                if flats[k] <= self.flats:
+                    a = -1
+            else:
+                if sharps[k] <= self.sharps:
+                    a = 1
+
+            if a:
+                name = name + Note.alteration_names[a + 2]
+
+            s = '\\key ' + name
+            if self.minor:
+                s = s + ' \\minor'
+            else:
+                s = s + ' \\major'
+
+        return '\n\n  ' + s + '\n  '
+
+
+class Text:
+    text_types = (
+        'SEQUENCE_NUMBER',
+        'TEXT_EVENT',
+        'COPYRIGHT_NOTICE',
+        'SEQUENCE_TRACK_NAME',
+        'INSTRUMENT_NAME',
+        'LYRIC',
+        'MARKER',
+        'CUE_POINT',
+        'PROGRAM_NAME',
+        'DEVICE_NAME', )
+
+    @staticmethod
+    def _text_only(chr):
+        if ((' ' <= chr <= '~') or chr in ['\n', '\r']):
+            return chr
+        else:
+            return '~'
+
+    def __init__(self, type, text):
+        self.clocks = 0
+        self.type = type
+        self.text = ''.join(map(self._text_only, text))
+
+    def dump(self):
+        # urg, we should be sure that we're in a lyrics staff
+        s = ''
+        if self.type == midi.LYRIC:
+            s = '"%s"' % self.text
+            d = Duration(self.clocks)
+            if (global_options.explicit_durations
+                    or d.compare(reference_note.duration)):
+                s = s + Duration(self.clocks).dump()
+            s = s + ' '
+        elif (self.text.strip()
+              and self.type == midi.SEQUENCE_TRACK_NAME
+              and not self.text == 'control track'
+              and not self.track.lyrics_p_):
+            text = self.text.replace('(MIDI)', '').strip()
+            if text:
+                s = '\n  \\set Staff.instrumentName = "%(text)s"\n  ' % locals(
+                )
+        elif self.text.strip():
+            s = '\n  % [' + self.text_types[self.type] + '] ' + \
+                self.text + '\n  '
+        return s
+
+    def __repr__(self):
+        return 'Text(%d=%s)' % (self.type, self.text)
+
+class EndOfTrack:
+    def __init__(self):
+        self.clocks = 0
+
+    def __repr__(self):
+        return 'EndOfTrack()'
+
+    def dump(self):
+        return ''
+
+def get_voice(channel, music):
+    ly.debug_output('channel: ' + str(channel) + '\n')
+    return unthread_notes(music)
+
+
+class Channel:
+    def __init__(self, number):
+        self.number = number
+        self.events = []
+        self.music = None
+
+    def add(self, event):
+        self.events.append(event)
+
+    def get_voice(self):
+        if not self.music:
+            self.music = self.parse()
+        return get_voice(self.number, self.music)
+
+    def parse(self):
+        pitches = {}
+        notes = []
+        music = []
+        last_lyric = 0
+        last_time = 0
+        end_of_track_time = None
+        for e in self.events:
+            t = e[0]
+
+            if start_quant_clocks:
+                t = quantise_clocks(t, start_quant_clocks)
+
+            if (e[1][0] == midi.NOTE_OFF
+                    or (e[1][0] == midi.NOTE_ON and e[1][2] == 0)):
+                ly.debug_output('%d: NOTE OFF: %s' % (t, e[1][1]))
+                if not e[1][2]:
+                    ly.debug_output('   ...treated as OFF')
+                end_note(pitches, notes, t, e[1][1])
+
+            elif e[1][0] == midi.NOTE_ON:
+                if e[1][1] not in pitches:
+                    ly.debug_output('%d: NOTE ON: %s' % (t, e[1][1]))
+                    pitches[e[1][1]] = (t, e[1][2])
+                else:
+                    ly.debug_output('...ignored')
+
+            # all include ALL_NOTES_OFF
+            elif (e[1][0] >= midi.ALL_SOUND_OFF
+                  and e[1][0] <= midi.POLY_MODE_ON):
+                for i in pitches:
+                    end_note(pitches, notes, t, i)
+
+            elif e[1][0] == midi.META_EVENT:
+                if e[1][1] == midi.END_OF_TRACK:
+                    for i in pitches:
+                        end_note(pitches, notes, t, i)
+                    end_of_track_time = t
+                    break
+
+                elif e[1][1] == midi.SET_TEMPO:
+                    (u0, u1, u2) = list(map(ord, e[1][2]))
+                    us_per_4 = u2 + 256 * (u1 + 256 * u0)
+                    seconds_per_1 = us_per_4 * 4 / 1e6
+                    music.append((t, Tempo(seconds_per_1)))
+                elif e[1][1] == midi.TIME_SIGNATURE:
+                    (num, dur, clocks4, count32) = list(map(ord, e[1][2]))
+                    den = 2 ** dur
+                    music.append((t, Time(num, den)))
+                elif e[1][1] == midi.KEY_SIGNATURE:
+                    (alterations, minor) = list(map(ord, e[1][2]))
+                    sharps = 0
+                    flats = 0
+                    if alterations < 127:
+                        sharps = alterations
+                    else:
+                        flats = 256 - alterations
+
+                    k = Key(sharps, flats, minor)
+                    if not t and global_options.key:
+                        # At t == 0, a set --key overrides us
+                        k = global_options.key
+                    music.append((t, k))
+
+                    # ugh, must set key while parsing
+                    # because Note init uses key
+                    # Better do Note.calc () at dump time?
+                    global_options.key = k
+
+                elif (e[1][1] == midi.LYRIC
+                      or (global_options.text_lyrics
+                          and e[1][1] == midi.TEXT_EVENT)):
+                    self.lyrics_p_ = True
+                    if last_lyric:
+                        last_lyric.clocks = t - last_time
+                        music.append((last_time, last_lyric))
+                    last_time = t
+                    last_lyric = Text(midi.LYRIC, e[1][2])
+
+                elif (e[1][1] >= midi.SEQUENCE_NUMBER
+                      and e[1][1] <= midi.CUE_POINT):
+                    text = Text(e[1][1], e[1][2])
+                    text.track = self
+                    music.append((t, text))
+                    if text.type == midi.SEQUENCE_TRACK_NAME:
+                        self.name = text.text
+                else:
+                    if global_options.verbose:
+                        sys.stderr.write("SKIP: %s\n" % repr(e))
+            else:
+                if global_options.verbose:
+                    sys.stderr.write("SKIP: %s\n" % repr(e))
+
+        if last_lyric:
+            # last_lyric.clocks = t - last_time
+            # hmm
+            last_lyric.clocks = clocks_per_4
+            music.append((last_time, last_lyric))
+            last_lyric = 0
+
+        i = 0
+        while len(notes):
+            if i < len(music) and notes[0][0] >= music[i][0]:
+                i = i + 1
+            else:
+                music.insert(i, notes[0])
+                del notes[0]
+
+        if end_of_track_time is not None:
+            music.append((end_of_track_time, EndOfTrack()))
+
+        return music
+
+
+class Track (Channel):
+    def __init__(self):
+        Channel.__init__(self, None)
+        self.name = None
+        self.channels = {}
+        self.lyrics_p_ = False
+
+    def _add(self, event):
+        self.events.append(event)
+
+    def add(self, event, channel=None):
+        if channel is None:
+            self._add(event)
+        else:
+            self.channels[channel] = self.channels.get(
+                channel, Channel(channel))
+            self.channels[channel].add(event)
+
+    def get_voices(self):
+        return ([self.get_voice()]
+                + [self.channels[k].get_voice()
+                   for k in sorted(self.channels.keys())])
+
+
+def create_track(events):
+    track = Track()
+    for e in events:
+        data = list(e[1])
+        if data[0] > 0x7f and data[0] < 0xf0:
+            channel = data[0] & 0x0f
+            e = (e[0], tuple([data[0] & 0xf0] + data[1:]))
+            track.add(e, channel)
+        else:
+            track.add(e)
+    return track
+
+
+def quantise_clocks(clocks, quant):
+    q = int(clocks / quant) * quant
+    if q != clocks:
+        for tquant in allowed_tuplet_clocks:
+            if int(clocks / tquant) * tquant == clocks:
+                return clocks
+        if 2 * (clocks - q) > quant:
+            q = q + quant
+    return q
+
+
+def end_note(pitches, notes, t, e):
+    try:
+        (lt, vel) = pitches[e]
+        del pitches[e]
+
+        i = len(notes) - 1
+        while i > 0:
+            if notes[i][0] > lt:
+                i = i - 1
+            else:
+                break
+        d = t - lt
+        if duration_quant_clocks:
+            d = quantise_clocks(d, duration_quant_clocks)
+            if not d:
+                d = duration_quant_clocks
+
+        notes.insert(i + 1,
+                     (lt, Note(d, e, vel)))
+
+    except KeyError:
+        pass
+
+
+def unthread_notes(channel):
+    threads = []
+    while channel:
+        thread = []
+        end_busy_t = 0
+        start_busy_t = 0
+        todo = []
+        for e in channel:
+            t = e[0]
+            if (e[1].__class__ == Note
+                and ((t == start_busy_t
+                      and e[1].clocks + t == end_busy_t)
+                     or t >= end_busy_t)):
+                thread.append(e)
+                start_busy_t = t
+                end_busy_t = t + e[1].clocks
+            elif (e[1].__class__ == Time
+                  or e[1].__class__ == Key
+                  or e[1].__class__ == Text
+                  or e[1].__class__ == Tempo
+                  or e[1].__class__ == EndOfTrack):
+                thread.append(e)
+            else:
+                todo.append(e)
+        threads.append(thread)
+        channel = todo
+
+    return threads
+
+
+def dump_skip(skip, clocks):
+    global reference_note
+    saved_duration = reference_note.duration
+    result = skip + Duration(clocks).dump() + ' '
+    # "\skip D" does not change the reference duration like "sD",
+    # so we restore it after Duration.dump changes it.
+    if skip[0] == '\\':
+        reference_note.duration = saved_duration
+    return result
+
+
+def dump(d):
+    return d.dump()
+
+
+def dump_chord(ch):
+    s = ''
+    notes = []
+    for i in ch:
+        if i.__class__ == Note:
+            notes.append(i)
+        else:
+            s = s + i.dump()
+    if len(notes) == 1:
+        s = s + dump(notes[0])
+    elif len(notes) > 1:
+        global reference_note
+        reference_dur = reference_note.duration
+        s = s + '<'
+        s = s + notes[0].dump(dump_dur=False)
+        r = reference_note
+        for i in notes[1:]:
+            s = s + i.dump(dump_dur=False)
+        s = s + '>'
+        if (r.duration.compare(reference_dur)
+                or global_options.explicit_durations):
+            s = s + r.duration.dump()
+        s = s + ' '
+        reference_note = r
+    return s
+
+
+def dump_bar_line(last_bar_t, t, bar_count):
+    s = ''
+    bar_t = time.bar_clocks()
+    if t - last_bar_t >= bar_t:
+        bar_count = bar_count + (t - last_bar_t) / bar_t
+
+        if t - last_bar_t == bar_t:
+            s = '\n  | %% %(bar_count)d\n  ' % locals()
+            last_bar_t = t
+        else:
+            # urg, this will barf at meter changes
+            last_bar_t = last_bar_t + (t - last_bar_t) / bar_t * bar_t
+
+    return (s, last_bar_t, bar_count)
+
+
+def dump_voice(thread, skip):
+    global reference_note, time
+    ref = Note(0, 4*12, 0)
+    if not reference_note:
+        reference_note = ref
+    else:
+        ref.duration = reference_note.duration
+        reference_note = ref
+    last_e = None
+    chs = []
+    ch = []
+
+    for e in thread:
+        if last_e and last_e[0] == e[0]:
+            ch.append(e[1])
+        else:
+            if ch:
+                chs.append((last_e[0], ch))
+
+            ch = [e[1]]
+
+        last_e = e
+
+    if ch:
+        chs.append((last_e[0], ch))
+    t = 0
+    last_t = 0
+    last_bar_t = 0
+    bar_count = 1
+
+    lines = ['']
+    for ch in chs:
+        t = ch[0]
+
+        i = lines[-1].rfind('\n') + 1
+        if len(lines[-1][i:]) > LINE_BELL:
+            lines.append('')
+
+        if t - last_t > 0:
+            d = t - last_t
+            if bar_max and t > time.bar_clocks() * bar_max:
+                d = time.bar_clocks() * bar_max - last_t
+            lines[-1] = lines[-1] + dump_skip(skip, d)
+        elif t - last_t < 0:
+            ly.error('BUG: time skew')
+
+        (s, last_bar_t, bar_count) = dump_bar_line(last_bar_t,
+                                                   t, bar_count)
+
+        if bar_max and bar_count > bar_max:
+            break
+
+        lines[-1] = lines[-1] + s
+        lines[-1] = lines[-1] + dump_chord(ch[1])
+
+        clocks = 0
+        for i in ch[1]:
+            if i.clocks > clocks:
+                clocks = i.clocks
+
+        last_t = t + clocks
+
+        (s, last_bar_t, bar_count) = dump_bar_line(last_bar_t,
+                                                   last_t, bar_count)
+        lines[-1] = lines[-1] + s
+
+    return '\n  '.join(lines) + '\n'
+
+
+def number2ascii(i):
+    s = ''
+    i += 1
+    while i > 0:
+        m = (i - 1) % 26
+        s = '%c' % (m + ord('A')) + s
+        i = (i - m) // 26
+    return s
+
+
+def get_track_name(i):
+    return 'track' + number2ascii(i)
+
+
+def get_channel_name(i):
+    return 'channel' + number2ascii(i)
+
+
+def get_voice_name(i, zero_too_p=False):
+    if i or zero_too_p:
+        return 'voice' + number2ascii(i)
+    return ''
+
+
+def lst_append(lst, x):
+    lst.append(x)
+    return lst
+
+
+def get_voice_layout(average_pitch):
+    d = {}
+    for i in range(len(average_pitch)):
+        d[average_pitch[i]] = lst_append(d.get(average_pitch[i], []), i)
+    s = list(reversed(sorted(average_pitch)))
+    non_empty = len([x for x in s if x])
+    names = ['One', 'Two']
+    if non_empty > 2:
+        names = ['One', 'Three', 'Four', 'Two']
+    layout = ['' for x in range(len(average_pitch))]
+    for i, n in zip(s, names):
+        if i:
+            v = d[i]
+            if isinstance(v, list):
+                d[i] = v[1:]
+                v = v[0]
+            layout[v] = n
+    return layout
+
+
+def dump_track(track, n):
+    s = '\n'
+    track_name = get_track_name(n)
+
+    average_pitch = track_average_pitch(track)
+    voices = len([x for x in average_pitch[1:] if x])
+    clef = get_best_clef(average_pitch[0])
+
+    c = 0
+    vv = 0
+    for channel in track:
+        v = 0
+        channel_name = get_channel_name(c)
+        c += 1
+        for voice in channel:
+            voice_name = get_voice_name(v)
+            voice_id = track_name + channel_name + voice_name
+            item = voice_first_item(voice)
+
+            if item and item.__class__ == Note:
+                skip = 'r'
+                if global_options.skip:
+                    skip = 's'
+                s += '%(voice_id)s = ' % locals()
+                if not global_options.absolute_pitches:
+                    s += '\\relative c '
+            elif item and item.__class__ == Text:
+                skip = '" "'
+                s += '%(voice_id)s = \\lyricmode ' % locals()
+            else:
+                skip = '\\skip '
+                s += '%(voice_id)s = ' % locals()
+            s += '{\n'
+            if not n and not vv and global_options.key:
+                s += global_options.key.dump()
+            if average_pitch[vv+1] and voices > 1:
+                vl = get_voice_layout(average_pitch[1:])[vv]
+                if vl:
+                    s += '  \\voice' + vl + '\n'
+                else:
+                    if not global_options.quiet:
+                        ly.warning(
+                            _('found more than 5 voices on a staff, expect bad output'))
+            s += '  ' + dump_voice(voice, skip)
+            s += '}\n\n'
+            v += 1
+            vv += 1
+
+    s += '%(track_name)s = <<\n' % locals()
+
+    if clef.type != 2:
+        s += clef.dump() + '\n'
+
+    c = 0
+    vv = 0
+    for channel in track:
+        v = 0
+        channel_name = get_channel_name(c)
+        c += 1
+        for voice in channel:
+            voice_context_name = get_voice_name(vv, zero_too_p=True)
+            voice_name = get_voice_name(v)
+            v += 1
+            vv += 1
+            voice_id = track_name + channel_name + voice_name
+            item = voice_first_item(voice)
+            context = 'Voice'
+            if item and item.__class__ == Text:
+                context = 'Lyrics'
+            s += '  \\context %(context)s = %(voice_context_name)s \\%(voice_id)s\n' % locals()
+    s += '>>\n\n'
+    return s
+
+
+def voice_first_item(voice):
+    for event in voice:
+        if (event[1].__class__ == Note
+            or (event[1].__class__ == Text
+                and event[1].type == midi.LYRIC)):
+            return event[1]
+    return None
+
+
+def channel_first_item(channel):
+    for voice in channel:
+        first = voice_first_item(voice)
+        if first:
+            return first
+    return None
+
+
+def track_first_item(track):
+    for channel in track:
+        first = channel_first_item(channel)
+        if first:
+            return first
+    return None
+
+
+def track_average_pitch(track):
+    i = 0
+    p = [0]
+    v = 1
+    for channel in track:
+        for voice in channel:
+            c = 0
+            p.append(0)
+            for event in voice:
+                if event[1].__class__ == Note:
+                    i += 1
+                    c += 1
+                    p[v] += event[1].pitch
+            if c:
+                p[0] += p[v]
+                p[v] = p[v] / c
+            v += 1
+    if i:
+        p[0] = p[0] / i
+    return p
+
+
+def get_best_clef(average_pitch):
+    if average_pitch:
+        if average_pitch <= 3*12:
+            return Clef(0)
+        elif average_pitch <= 5*12:
+            return Clef(1)
+        elif average_pitch >= 7*12:
+            return Clef(3)
+    return Clef(2)
+
+
+class Staff:
+    def __init__(self, track):
+        self.voices = track.get_voices()
+
+    def dump(self, i):
+        return dump_track(self.voices, i)
+
+
+def convert_midi(in_file, out_file):
+    global midi
+    import midi
+
+    global clocks_per_1, clocks_per_4, key
+    global start_quant_clocks
+    global duration_quant_clocks
+    global allowed_tuplet_clocks
+    global time
+
+    full_content = open(in_file, 'rb').read()
+    clocks_max = bar_max * clocks_per_1 * 2
+    midi_dump = midi.parse(full_content, clocks_max)
+
+    clocks_per_1 = midi_dump[0][1]
+    clocks_per_4 = clocks_per_1 / 4
+    time = Time(4, 4)
+
+    if global_options.start_quant:
+        start_quant_clocks = clocks_per_1 / global_options.start_quant
+
+    if global_options.duration_quant:
+        duration_quant_clocks = clocks_per_1 / global_options.duration_quant
+
+    allowed_tuplet_clocks = []
+    for (dur, num, den) in global_options.allowed_tuplets:
+        allowed_tuplet_clocks.append(clocks_per_1 / dur * num / den)
+
+    if global_options.verbose:
+        print('allowed tuplet clocks:', allowed_tuplet_clocks)
+
+    tracks = [create_track(t) for t in midi_dump[1]]
+    # urg, parse all global track events, such as Key first
+    # this fixes key in different voice/staff problem
+    for t in tracks:
+        t.music = t.parse()
+    prev = None
+    staves = []
+    for t in tracks:
+        voices = t.get_voices()
+        if ((t.name and prev and prev.name)
+                and t.name.split(':')[0] == prev.name.split(':')[0]):
+            # staves[-1].voices += voices
+            # all global track events first
+            staves[-1].voices = ([staves[-1].voices[0]]
+                                 + [voices[0]]
+                                 + staves[-1].voices[1:]
+                                 + voices[1:])
+        else:
+            staves.append(Staff(t))
+        prev = t
+
+    tag = '%% Lily was here -- automatically converted by %s from %s' % (
+        ly.program_name, in_file)
+
+    s = tag
+    s += r'''
+\version "2.14.0"
+'''
+
+    s += r'''
+\layout {
+  \context {
+    \Voice
+    \remove Note_heads_engraver
+    \consists Completion_heads_engraver
+    \remove Rest_engraver
+    \consists Completion_rest_engraver
+  }
+}
+'''
+
+    for i in global_options.include_header:
+        s += '\n%% included from %(i)s\n' % locals()
+        s += open(i, encoding='utf-8').read()
+        if s[-1] != '\n':
+            s += '\n'
+        s += '% end\n'
+
+    for i, t in enumerate(staves):
+        s += t.dump(i)
+
+    s += '\n\\score {\n  <<\n'
+
+    control_track = False
+    i = 0
+    output_track_count = 0
+    for i, staff in enumerate(staves):
+        track_name = get_track_name(i)
+        item = track_first_item(staff.voices)
+        staff_name = track_name
+        context = None
+        if not i and not item and len(staves) > 1:
+            control_track = track_name
+            continue
+        elif (item and item.__class__ == Note):
+            context = 'Staff'
+            if control_track:
+                s += '    \\context %(context)s=%(staff_name)s \\%(control_track)s\n' % locals()
+        elif item and item.__class__ == Text:
+            context = 'Lyrics'
+        if context:
+            output_track_count += 1
+            s += '    \\context %(context)s=%(staff_name)s \\%(track_name)s\n' % locals()
+
+        # If we found a control track but no other tracks with which
+        # to combine it, create a Staff for the control track alone.
+        if (output_track_count == 0) and control_track:
+            s += '    \\context Staff \\%(control_track)s\n' % locals()
+
+    s = s + r'''  >>
+  \layout {}
+  \midi {}
+}
+'''
+
+    if not global_options.quiet:
+        ly.progress(_("%s output to `%s'...") % ('LY', out_file))
+
+    if out_file == '-':
+        handle = sys.stdout
+    else:
+        handle = open(out_file, 'w', encoding='utf-8')
+
+    handle.write(s)
+    handle.close()
+
+
+def get_option_parser():
+    p = ly.get_option_parser(usage=_("%s [OPTION]... FILE") % 'midi2ly',
+                             description=_(
+                                 "Convert %s to LilyPond input.\n") % 'MIDI',
+                             add_help_option=False)
+
+    p.add_option('-a', '--absolute-pitches',
+                 action='store_true',
+                 help=_('print absolute pitches'))
+    p.add_option('-d', '--duration-quant',
+                 metavar=_('DUR'),
+                 help=_('quantise note durations on DUR'))
+    p.add_option('-D', '--debug',
+                 action='store_true',
+                 help=_('debug printing'))
+    p.add_option('-e', '--explicit-durations',
+                 action='store_true',
+                 help=_('print explicit durations'))
+    p.add_option('-h', '--help',
+                 action='help',
+                 help=_('show this help and exit'))
+    p.add_option('-i', '--include-header',
+                 help=_('prepend FILE to output'),
+                 action='append',
+                 default=[],
+                 metavar=_('FILE'))
+    p.add_option('-k', '--key', help=_('set key: ALT=+sharps|-flats; MINOR=1'),
+                 metavar=_('ALT[:MINOR]'),
+                 default=None),
+    p.add_option('-o', '--output', help=_('write output to FILE'),
+                 metavar=_('FILE'),
+                 action='store')
+    p.add_option('-p', '--preview', help=_('preview of first 4 bars'),
+                 action='store_true')
+    p.add_option('-q', '--quiet',
+                 action="store_true",
+                 help=_("suppress progress messages and warnings about excess voices"))
+    p.add_option('-s', '--start-quant', help=_('quantise note starts on DUR'),
+                 metavar=_('DUR'))
+    p.add_option('-S', '--skip',
+                 action="store_true",
+                 help=_("use s instead of r for rests"))
+    p.add_option('-t', '--allow-tuplet',
+                 metavar=_('DUR*NUM/DEN'),
+                 action='append',
+                 dest='allowed_tuplets',
+                 help=_('allow tuplet durations DUR*NUM/DEN'),
+                 default=[])
+    p.add_option('-V', '--verbose', help=_('be verbose'),
+                 action='store_true')
+    p.version = 'midi2ly (LilyPond) 2.24.2'
+    p.add_option('--version',
+                 action='version',
+                 help=_('show version number and exit'))
+    p.add_option('-w', '--warranty', help=_('show warranty and copyright'),
+                 action='store_true',)
+    p.add_option('-x', '--text-lyrics', help=_('treat every text as a lyric'),
+                 action='store_true')
+
+    p.add_option_group(_('Examples'),
+                       description=r'''
+  $ midi2ly --key=-2:1 --duration-quant=32 --allow-tuplet=4*2/3 --allow-tuplet=2*4/3 foo.midi
+''')
+    p.add_option_group('',
+                       description=(
+                           _('Report bugs via %s')
+                           % '[email protected]') + '\n')
+    return p
+
+
+def do_options():
+    opt_parser = get_option_parser()
+    (options, args) = opt_parser.parse_args()
+
+    if options.warranty:
+        warranty()
+        sys.exit(0)
+
+    if not args or args[0] == '-':
+        opt_parser.print_help()
+        sys.stderr.write('\n%s: %s %s\n' % (ly.program_name, _('error: '),
+                                            _('no files specified on command line.')))
+        sys.exit(2)
+
+    if options.duration_quant:
+        options.duration_quant = int(options.duration_quant)
+
+    if options.key:
+        (alterations, minor) = list(
+            map(int, (options.key + ':0').split(':')))[0:2]
+        sharps = 0
+        flats = 0
+        if alterations >= 0:
+            sharps = alterations
+        else:
+            flats = - alterations
+        options.key = Key(sharps, flats, minor)
+
+    if options.start_quant:
+        options.start_quant = int(options.start_quant)
+
+    global bar_max
+    if options.preview:
+        bar_max = 4
+
+    options.allowed_tuplets = [list(map(int, a.replace('/', '*').split('*')))
+                               for a in options.allowed_tuplets]
+
+    if options.verbose:
+        sys.stderr.write('Allowed tuplets: %s\n' %
+                         repr(options.allowed_tuplets))
+
+    global global_options
+    global_options = options
+
+    return args
+
+
+def main():
+    files = do_options()
+
+    exts = ['.midi', '.mid', '.MID']
+    for f in files:
+        g = f
+        for e in exts:
+            g = strip_extension(g, e)
+        if not os.path.exists(f):
+            for e in exts:
+                n = g + e
+                if os.path.exists(n):
+                    f = n
+                    break
+
+        if not global_options.output:
+            outdir = '.'
+            outbase = os.path.basename(g)
+            o = outbase + '-midi.ly'
+        elif (global_options.output[-1] == os.sep
+              or os.path.isdir(global_options.output)):
+            outdir = global_options.output
+            outbase = os.path.basename(g)
+            o = os.path.join(outdir, outbase + '-midi.ly')
+        else:
+            o = global_options.output
+            (outdir, outbase) = os.path.split(o)
+
+        if outdir and outdir != '.' and not os.path.exists(outdir):
+            os.mkdir(outdir, 0o777)
+
+        convert_midi(f, o)
+
+
+if __name__ == '__main__':
+    main()

lilypond-2.24.2/bin/python310.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c30589187be320bc8e65177aeb8dc1d39957f7b7dcda4c13524dd7f436fb0948
+size 4492160

lilypond-2.24.2/bin/python310.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1fc143399b184ff1c26246da037d1d20f99b166922cd3ac16ed299b99b80e4de
+size 2640871

lilypond-2.24.2/etc/fonts/conf.d/10-hinting-slight.conf

@@ -0,0 +1,15 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<fontconfig>
+  <description>Set hintslight to hintstyle</description>
+
+  <match target="pattern">
+    <!--
+      This sort of configuration is available on the major desktop environments
+      and we don't have to break it with "assign" unconditionally. however, we
+      want to set something for others. So we use "append" here to get this working
+      in both cases so that most clients would takes a look at the first place only.
+    -->
+    <edit name="hintstyle" mode="append"><const>hintslight</const></edit>
+  </match>
+</fontconfig>

lilypond-2.24.2/etc/fonts/conf.d/10-scale-bitmap-fonts.conf

@@ -0,0 +1,83 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<fontconfig>
+  <description>Bitmap scaling</description>
+<!--
+  If font is bitmap, calculate scale factor.
+  Note that color bitmap fonts have scalable=true, while
+  non-color ones have scalable=false.  Both groups have outline=false.
+  -->
+<match target="font">
+  <test name="outline" compare="eq">
+    <bool>false</bool>
+  </test>
+  <edit name="pixelsizefixupfactor" mode="assign">
+    <divide>
+      <name target="pattern">pixelsize</name>
+      <name target="font"   >pixelsize</name>
+    </divide>
+  </edit>
+</match>
+<!--
+  For non-scalable bitmap fonts (ie. non-color), skip
+  minor scaling if hinting is enabled.
+  -->
+<match target="font">
+  <test name="outline" compare="eq">
+    <bool>false</bool>
+  </test>
+  <test name="scalable" compare="eq">
+    <bool>false</bool>
+  </test>
+  <test name="hinting" compare="eq">
+    <bool>true</bool>
+  </test>
+  <edit name="scalingnotneeded" mode="assign">
+    <and>
+      <less>
+        <name>pixelsizefixupfactor</name>
+        <double>1.2</double>
+      </less>
+      <more>
+        <name>pixelsizefixupfactor</name>
+        <double>0.8</double>
+      </more>
+    </and>
+  </edit>
+</match>
+<match target="font">
+  <test name="scalingnotneeded" compare="eq">
+    <bool>true</bool>
+  </test>
+  <edit name="pixelsizefixupfactor" mode="assign">
+    <double>1.0</double>
+  </edit>
+</match>
+<!--
+  If we *are* going to scale, go ahead and do it.
+  -->
+<match target="font">
+  <test name="outline" compare="eq">
+    <bool>false</bool>
+  </test>
+  <test name="pixelsizefixupfactor" compare="not_eq">
+    <double>1.0</double>
+  </test>
+  <edit name="matrix" mode="assign">
+    <times>
+      <name>matrix</name>
+      <matrix>
+        <name>pixelsizefixupfactor</name> <double>0</double>
+        <double>0</double> <name>pixelsizefixupfactor</name>
+       </matrix>
+    </times>
+  </edit>
+  <edit name="size" mode="assign">
+    <divide>
+      <name>size</name>
+      <name>pixelsizefixupfactor</name>
+    </divide>
+  </edit>
+</match>
+
+</fontconfig>

lilypond-2.24.2/etc/fonts/conf.d/10-sub-pixel-none.conf

@@ -0,0 +1,15 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<fontconfig>
+  <description>Disable sub-pixel rendering</description>
+<!--  Disable sub-pixel rendering --> 
+  <match target="pattern">
+    <!--
+      This sort of configuration is available on the major desktop environments
+      and we don't have to break it with "assign" unconditionally. however, we
+      want to set something for others. So we use "append" here to get this working
+      in both cases so that most clients would takes a look at the first place only.
+    -->
+    <edit name="rgba" mode="append"><const>none</const></edit>
+  </match>
+</fontconfig>

lilypond-2.24.2/etc/fonts/conf.d/10-yes-antialias.conf

@@ -0,0 +1,8 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<fontconfig>
+  <description>Enable antialiasing</description>
+  <match target="pattern">
+    <edit name="antialias" mode="append"><bool>true</bool></edit>
+  </match>
+</fontconfig>

lilypond-2.24.2/etc/fonts/conf.d/11-lcdfilter-default.conf

@@ -0,0 +1,17 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<fontconfig>
+  <description>Use lcddefault as default for LCD filter</description>
+<!--  Use lcddefault as default for LCD filter -->
+  <match target="pattern">
+    <!--
+      This sort of configuration is available on the major desktop environments
+      and we don't have to break it with "assign" unconditionally. however, we
+      want to set something for others. So we use "append" here to get this working
+      in both cases so that most clients would takes a look at the first place only.
+    -->
+    <edit mode="append" name="lcdfilter">
+      <const>lcddefault</const>
+    </edit>
+  </match>
+</fontconfig>

lilypond-2.24.2/etc/fonts/conf.d/20-unhint-small-vera.conf

@@ -0,0 +1,49 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<fontconfig>
+  <description>Disable hinting for Bitstream Vera fonts when the size is less than 8ppem</description>
+<!-- 
+	The Bitstream Vera fonts have GASP entries suggesting that hinting be
+	disabled below 8 ppem, but FreeType ignores those, preferring to use
+	the data found in the instructed hints.  The initial Vera release
+	didn't include the right instructions in the 'prep' table. Fix this
+	by disabling hinting manually at smaller sizes (< 8ppem)
+ -->
+
+	<match target="font">
+		<test name="family" compare="eq" ignore-blanks="true">
+			<string>Bitstream Vera Sans</string>
+		</test>
+		<test name="pixelsize" compare="less">
+			<double>7.5</double>
+		</test>
+		<edit name="hinting">
+			<bool>false</bool>
+		</edit>
+	</match>
+
+	<match target="font">
+		<test name="family" compare="eq" ignore-blanks="true">
+			<string>Bitstream Vera Serif</string>
+		</test>
+		<test name="pixelsize" compare="less">
+			<double>7.5</double>
+		</test>
+		<edit name="hinting">
+			<bool>false</bool>
+		</edit>
+	</match>
+
+	<match target="font">
+		<test name="family" compare="eq" ignore-blanks="true">
+			<string>Bitstream Vera Sans Mono</string>
+		</test>
+		<test name="pixelsize" compare="less">
+			<double>7.5</double>
+		</test>
+		<edit name="hinting">
+			<bool>false</bool>
+		</edit>
+	</match>
+
+</fontconfig>

lilypond-2.24.2/etc/fonts/conf.d/30-metric-aliases.conf

@@ -0,0 +1,637 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<fontconfig>
+  <description>Set substitutions for similar/metric-compatible families</description>
+
+<!--
+
+Alias similar/metric-compatible families from various sources:
+
+PostScript fonts:       URW fonts:           GUST fonts:        Windows fonts:
+======================  ==================  =================  ==================
+Helvetica               Nimbus Sans         TeX Gyre Heros
+Helvetica Narrow        Nimbus Sans Narrow  TeX Gyre Heros Cn
+Times                   Nimbus Roman        TeX Gyre Termes
+Courier                 Nimbus Mono PS      TeX Gyre Cursor
+ITC Avant Garde Gothic  URW Gothic          TeX Gyre Adventor
+ITC Bookman             URW Bookman         TeX Gyre Bonum     Bookman Old Style
+ITC Zapf Chancery       Z003                TeX Gyre Chorus
+Palatino                P052                TeX Gyre Pagella   Palatino Linotype
+New Century Schoolbook  C059                TeX Gyre Schola    Century Schoolbook
+
+Microsoft fonts:  Liberation fonts:       Google CrOS core fonts:  StarOffice fonts:  AMT fonts:
+================  ======================  =======================  =================  ==============
+Arial             Liberation Sans         Arimo                    Albany             Albany AMT
+Arial Narrow      Liberation Sans Narrow
+Times New Roman   Liberation Serif        Tinos                    Thorndale          Thorndale AMT
+Courier New       Liberation Mono         Cousine                  Cumberland         Cumberland AMT
+Cambria                                   Caladea
+Calibri                                   Carlito
+Symbol                                    SymbolNeu
+
+Microsoft fonts:  Other fonts:
+================  ============
+Georgia           Gelasio
+
+We want for each of them to fallback to any of these available,
+but in an order preferring similar designs first.  We do this in three steps:
+
+1) Alias each specific to its generic family.
+   e.g. Liberation Sans to Arial
+
+2) Weak alias each generic to the other generic of its family.
+   e.g. Arial to Helvetica
+
+3) Alias each generic to its specifics.
+   e.g. Arial to Liberation Sans, Arimo, Albany, and Albany AMT
+
+NOTE: The (URW)++ fonts mappings of generics to specifics were removed, because
+      upstream now includes them in their release of (URW)++ Core Font Set here:
+      https://github.com/ArtifexSoftware/urw-base35-fonts/tree/master/fontconfig
+-->
+
+<!-- Map specifics to generics -->
+
+	<!-- PostScript -->
+	<alias binding="same">
+	  <family>Nimbus Sans L</family>
+	  <default>
+	  <family>Helvetica</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Nimbus Sans</family>
+	  <default>
+	  <family>Helvetica</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>TeX Gyre Heros</family>
+	  <default>
+	  <family>Helvetica</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Nimbus Sans Narrow</family>
+	  <default>
+	  <family>Helvetica Narrow</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>TeX Gyre Heros Cn</family>
+	  <default>
+	  <family>Helvetica Narrow</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Nimbus Roman No9 L</family>
+	  <default>
+	  <family>Times</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Nimbus Roman</family>
+	  <default>
+	  <family>Times</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>TeX Gyre Termes</family>
+	  <default>
+	  <family>Times</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Nimbus Mono L</family>
+	  <default>
+	  <family>Courier</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Nimbus Mono</family>
+	  <default>
+	  <family>Courier</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Nimbus Mono PS</family>
+	  <default>
+	  <family>Courier</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>TeX Gyre Cursor</family>
+	  <default>
+	  <family>Courier</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Avant Garde</family>
+	  <default>
+	  <family>ITC Avant Garde Gothic</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>URW Gothic L</family>
+	  <default>
+	  <family>ITC Avant Garde Gothic</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>URW Gothic</family>
+	  <default>
+	  <family>ITC Avant Garde Gothic</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>TeX Gyre Adventor</family>
+	  <default>
+	  <family>ITC Avant Garde Gothic</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Bookman</family>
+	  <default>
+	  <family>ITC Bookman</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>URW Bookman L</family>
+	  <default>
+	  <family>ITC Bookman</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Bookman URW</family>
+	  <default>
+	  <family>ITC Bookman</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>URW Bookman</family>
+	  <default>
+	  <family>ITC Bookman</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>TeX Gyre Bonum</family>
+	  <default>
+	  <family>ITC Bookman</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Bookman Old Style</family>
+	  <default>
+	  <family>ITC Bookman</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Zapf Chancery</family>
+	  <default>
+	  <family>ITC Zapf Chancery</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>URW Chancery L</family>
+	  <default>
+	  <family>ITC Zapf Chancery</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Chancery URW</family>
+	  <default>
+	  <family>ITC Zapf Chancery</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Z003</family>
+	  <default>
+	  <family>ITC Zapf Chancery</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>TeX Gyre Chorus</family>
+	  <default>
+	  <family>ITC Zapf Chancery</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>URW Palladio L</family>
+	  <default>
+	  <family>Palatino</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Palladio URW</family>
+	  <default>
+	  <family>Palatino</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>P052</family>
+	  <default>
+	  <family>Palatino</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>TeX Gyre Pagella</family>
+	  <default>
+	  <family>Palatino</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Palatino Linotype</family>
+	  <default>
+	  <family>Palatino</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Century Schoolbook L</family>
+	  <default>
+	  <family>New Century Schoolbook</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Century SchoolBook URW</family>
+	  <default>
+	  <family>New Century Schoolbook</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>C059</family>
+	  <default>
+	  <family>New Century Schoolbook</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>TeX Gyre Schola</family>
+	  <default>
+	  <family>New Century Schoolbook</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Century Schoolbook</family>
+	  <default>
+	  <family>New Century Schoolbook</family>
+	  </default>
+	</alias>
+
+	<!-- Microsoft -->
+	<alias binding="same">
+	  <family>Arimo</family>
+	  <default>
+	    <family>Arial</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Liberation Sans</family>
+	  <default>
+	  <family>Arial</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Liberation Sans Narrow</family>
+	  <default>
+	    <family>Arial Narrow</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Albany</family>
+	  <default>
+	  <family>Arial</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Albany AMT</family>
+	  <default>
+	  <family>Arial</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Tinos</family>
+	  <default>
+	    <family>Times New Roman</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Liberation Serif</family>
+	  <default>
+	  <family>Times New Roman</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Thorndale</family>
+	  <default>
+	  <family>Times New Roman</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Thorndale AMT</family>
+	  <default>
+	  <family>Times New Roman</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Cousine</family>
+	  <default>
+	    <family>Courier New</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Liberation Mono</family>
+	  <default>
+	  <family>Courier New</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Cumberland</family>
+	  <default>
+	  <family>Courier New</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Cumberland AMT</family>
+	  <default>
+	  <family>Courier New</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Gelasio</family>
+	  <default>
+	  <family>Georgia</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Caladea</family>
+	  <default>
+	  <family>Cambria</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>Carlito</family>
+	  <default>
+	  <family>Calibri</family>
+	  </default>
+	</alias>
+
+	<alias binding="same">
+	  <family>SymbolNeu</family>
+	  <default>
+	  <family>Symbol</family>
+	  </default>
+  </alias>
+
+<!-- Accept the other group as fallback -->
+
+	<!-- PostScript -->
+	<alias>
+	  <family>Helvetica</family>
+	  <default>
+	  <family>Arial</family>
+	  </default>
+	</alias>
+
+	<alias>
+	  <family>Helvetica Narrow</family>
+	  <default>
+	  <family>Arial Narrow</family>
+	  </default>
+	</alias>
+
+	<alias>
+	  <family>Times</family>
+	  <default>
+	  <family>Times New Roman</family>
+	  </default>
+	</alias>
+
+	<alias>
+	  <family>Courier</family>
+	  <default>
+	  <family>Courier New</family>
+	  </default>
+	</alias>
+
+	<!-- Microsoft -->
+	<alias>
+	  <family>Arial</family>
+	  <default>
+	  <family>Helvetica</family>
+	  </default>
+	</alias>
+
+	<alias>
+	  <family>Arial Narrow</family>
+	  <default>
+	  <family>Helvetica Narrow</family>
+	  </default>
+	</alias>
+
+	<alias>
+	  <family>Times New Roman</family>
+	  <default>
+	  <family>Times</family>
+	  </default>
+	</alias>
+
+	<alias>
+	  <family>Courier New</family>
+	  <default>
+	  <family>Courier</family>
+	  </default>
+	</alias>
+
+<!-- Map generics to specifics -->
+
+	<!-- PostScript -->
+	<alias binding="same">
+	  <family>Helvetica</family>
+	  <accept>
+	  <family>TeX Gyre Heros</family>
+	  </accept>
+	</alias>
+
+	<alias binding="same">
+	  <family>Helvetica Narrow</family>
+	  <accept>
+	  <family>TeX Gyre Heros Cn</family>
+	  </accept>
+	</alias>
+
+	<alias binding="same">
+	  <family>Times</family>
+	  <accept>
+	  <family>TeX Gyre Termes</family>
+	  </accept>
+	</alias>
+
+	<alias binding="same">
+	  <family>Courier</family>
+	  <accept>
+	  <family>TeX Gyre Cursor</family>
+	  </accept>
+	</alias>
+
+	<alias binding="same">
+	  <family>Courier Std</family>
+	  <accept>
+	  <family>Courier</family>
+	  </accept>
+	</alias>
+
+	<alias binding="same">
+	  <family>ITC Avant Garde Gothic</family>
+	  <accept>
+	  <family>TeX Gyre Adventor</family>
+	  </accept>
+	</alias>
+
+	<alias binding="same">
+	  <family>ITC Bookman</family>
+	  <accept>
+	  <family>Bookman Old Style</family>
+	  <family>TeX Gyre Bonum</family>
+	  </accept>
+	</alias>
+
+	<alias binding="same">
+	  <family>ITC Zapf Chancery</family>
+	  <accept>
+	  <family>TeX Gyre Chorus</family>
+	  </accept>
+	</alias>
+
+	<alias binding="same">
+	  <family>Palatino</family>
+	  <accept>
+	  <family>Palatino Linotype</family>
+	  <family>TeX Gyre Pagella</family>
+	  </accept>
+	</alias>
+
+	<alias binding="same">
+	  <family>New Century Schoolbook</family>
+	  <accept>
+	  <family>Century Schoolbook</family>
+	  <family>TeX Gyre Schola</family>
+	  </accept>
+	</alias>
+
+	<!-- Microsoft -->
+	<alias binding="same">
+	  <family>Arial</family>
+	  <accept>
+	    <family>Arimo</family>
+	    <family>Liberation Sans</family>
+	    <family>Albany</family>
+	    <family>Albany AMT</family>
+	  </accept>
+	</alias>
+
+	<alias binding="same">
+	  <family>Arial Narrow</family>
+	  <accept>
+	    <family>Liberation Sans Narrow</family>
+	  </accept>
+	</alias>
+
+	<alias binding="same">
+	  <family>Times New Roman</family>
+	  <accept>
+	    <family>Tinos</family>
+	    <family>Liberation Serif</family>
+	    <family>Thorndale</family>
+	    <family>Thorndale AMT</family>
+	  </accept>
+	</alias>
+
+	<alias binding="same">
+	  <family>Courier New</family>
+	  <accept>
+	    <family>Cousine</family>
+	    <family>Liberation Mono</family>
+	    <family>Cumberland</family>
+	    <family>Cumberland AMT</family>
+	  </accept>
+	</alias>
+
+	<alias binding="same">
+	  <family>Georgia</family>
+	  <accept>
+	    <family>Gelasio</family>
+	  </accept>
+	</alias>
+
+	<alias binding="same">
+	  <family>Cambria</family>
+	  <accept>
+	    <family>Caladea</family>
+	  </accept>
+	</alias>
+
+	<alias binding="same">
+	  <family>Calibri</family>
+	  <accept>
+	    <family>Carlito</family>
+	  </accept>
+  </alias>
+
+	<alias binding="same">
+	  <family>Symbol</family>
+	  <accept>
+	    <family>SymbolNeu</family>
+	  </accept>
+  </alias>
+
+</fontconfig>

lilypond-2.24.2/etc/fonts/conf.d/40-nonlatin.conf

@@ -0,0 +1,332 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<fontconfig>
+  <description>Set substitutions for non-Latin fonts</description>
+<!--
+  Mark common families with their generics so we'll get
+  something reasonable
+-->
+
+<!--
+  Serif faces
+ -->
+	<alias>
+		<family>Nazli</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Lotoos</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Mitra</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Ferdosi</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Badr</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Zar</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Titr</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Jadid</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Kochi Mincho</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>AR PL SungtiL GB</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>AR PL Mingti2L Big5</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>ＭＳ 明朝</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>NanumMyeongjo</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>UnBatang</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Baekmuk Batang</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>MgOpen Canonica</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Sazanami Mincho</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>AR PL ZenKai Uni</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>ZYSong18030</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>FreeSerif</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>SimSun</family>
+		<default><family>serif</family></default>
+	</alias>
+<!--
+  Sans-serif faces
+ -->
+	<alias>
+		<family>Arshia</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Elham</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Farnaz</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Nasim</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Sina</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Roya</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Koodak</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Terafik</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Kochi Gothic</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>AR PL KaitiM GB</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>AR PL KaitiM Big5</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>ＭＳ ゴシック</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>NanumGothic</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>UnDotum</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Baekmuk Dotum</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>MgOpen Modata</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Sazanami Gothic</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>AR PL ShanHeiSun Uni</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>ZYSong18030</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>FreeSans</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+<!--
+  Monospace faces
+ -->
+	<alias>
+		<family>NSimSun</family>
+		<default><family>monospace</family></default>
+	</alias>
+	<alias>
+		<family>ZYSong18030</family>
+		<default><family>monospace</family></default>
+	</alias>
+	<alias>
+		<family>NanumGothicCoding</family>
+		<default><family>monospace</family></default>
+	</alias>
+	<alias>
+		<family>FreeMono</family>
+		<default><family>monospace</family></default>
+	</alias>
+
+<!--
+  Fantasy faces
+ -->
+	<alias>
+		<family>Homa</family>
+		<default><family>fantasy</family></default>
+	</alias>
+	<alias>
+		<family>Kamran</family>
+		<default><family>fantasy</family></default>
+	</alias>
+	<alias>
+		<family>Fantezi</family>
+		<default><family>fantasy</family></default>
+	</alias>
+	<alias>
+		<family>Tabassom</family>
+		<default><family>fantasy</family></default>
+	</alias>
+
+<!--
+  Cursive faces
+ -->
+	<alias>
+		<family>IranNastaliq</family>
+		<default><family>cursive</family></default>
+	</alias>
+	<alias>
+		<family>Nafees Nastaleeq</family>
+		<default><family>cursive</family></default>
+	</alias>
+
+<!--
+  system-ui
+-->
+	<alias>
+		<family>Noto Sans Arabic UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Noto Sans Bengali UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Noto Sans Devanagari UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Noto Sans Gujarati UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Noto Sans Gurmukhi UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Noto Sans Kannada UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Noto Sans Khmer UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Noto Sans Lao UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Noto Sans Malayalam UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Noto Sans Myanmar UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Noto Sans Oriya UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Noto Sans Sinhala UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Noto Sans Tamil UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Noto Sans Telugu UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Noto Sans Thai UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Leelawadee UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Nirmala UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Yu Gothic UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Meiryo UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>MS UI Gothic</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Khmer UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Lao UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Microsoft JhengHei UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Microsoft YaHei UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+
+</fontconfig>

lilypond-2.24.2/etc/fonts/conf.d/45-generic.conf

@@ -0,0 +1,136 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<fontconfig>
+  <description>Set substitutions for emoji/math fonts</description>
+
+<!-- Keep in sync with 60-generic.conf -->
+
+<!-- Emoji -->
+
+	<!-- System emoji -->
+	<alias binding="same">
+		<family>Noto Color Emoji</family> <!-- Google -->
+		<default><family>emoji</family></default>
+	</alias>
+	<alias binding="same">
+		<family>Apple Color Emoji</family> <!-- Apple -->
+		<default><family>emoji</family></default>
+	</alias>
+	<alias binding="same">
+		<family>Segoe UI Emoji</family> <!-- Microsoft -->
+		<default><family>emoji</family></default>
+	</alias>
+	<alias binding="same">
+		<family>Twitter Color Emoji</family> <!-- Twitter -->
+		<default><family>emoji</family></default>
+	</alias>
+	<alias binding="same">
+		<family>EmojiOne Mozilla</family> <!-- Mozilla -->
+		<default><family>emoji</family></default>
+	</alias>
+	<!-- Third-party emoji -->
+	<alias binding="same">
+		<family>Emoji Two</family>
+		<default><family>emoji</family></default>
+	</alias>
+	<alias binding="same">
+		<family>JoyPixels</family>
+		<default><family>emoji</family></default>
+	</alias>
+	<alias binding="same">
+		<family>Emoji One</family>
+		<default><family>emoji</family></default>
+	</alias>
+	<!-- B&W -->
+	<alias binding="same">
+		<family>Noto Emoji</family> <!-- Google -->
+		<default><family>emoji</family></default>
+	</alias>
+	<alias binding="same">
+		<family>Android Emoji</family> <!-- Google -->
+		<default><family>emoji</family></default>
+	</alias>
+
+	<!-- Add language for emoji, to match other emoji fonts. -->
+	<match>
+		<test name="family">
+			<string>emoji</string>
+		</test>
+		<edit name="lang" mode="prepend">
+			<string>und-zsye</string>
+		</edit>
+	</match>
+
+	<match>
+		<test name="lang">
+			<string>und-zsye</string>
+		</test>
+		<test qual="all" name="family" compare="not_eq">
+			<string>emoji</string>
+		</test>
+
+		<!-- Add generic family. -->
+		<edit name="family" mode="append" binding="strong">
+			<string>emoji</string>
+		</edit>
+	</match>
+
+
+<!-- Math -->
+
+	<!-- https://en.wikipedia.org/wiki/Category:Mathematical_OpenType_typefaces -->
+	<alias binding="same">
+		<family>XITS Math</family> <!-- Khaled Hosny -->
+		<default><family>math</family></default>
+	</alias>
+	<alias binding="same">
+		<family>STIX Two Math</family> <!-- AMS -->
+		<default><family>math</family></default>
+	</alias>
+	<alias binding="same">
+		<family>Cambria Math</family> <!-- Microsoft -->
+		<default><family>math</family></default>
+	</alias>
+	<alias binding="same">
+		<family>Latin Modern Math</family> <!-- TeX -->
+		<default><family>math</family></default>
+	</alias>
+	<alias binding="same">
+		<family>Minion Math</family> <!-- Adobe -->
+		<default><family>math</family></default>
+	</alias>
+	<alias binding="same">
+		<family>Lucida Math</family> <!-- Adobe -->
+		<default><family>math</family></default>
+	</alias>
+	<alias binding="same">
+		<family>Asana Math</family>
+		<default><family>math</family></default>
+	</alias>
+
+	<!-- Add language for math, to match other math fonts. -->
+	<match>
+		<test name="family">
+			<string>math</string>
+		</test>
+		<edit name="lang" mode="prepend">
+			<string>und-zmth</string>
+		</edit>
+	</match>
+
+	<match>
+		<test name="lang">
+			<string>und-zmth</string>
+		</test>
+		<test qual="all" name="family" compare="not_eq">
+			<string>math</string>
+		</test>
+
+		<!-- Add generic family -->
+		<edit name="family" mode="append" binding="strong">
+			<string>math</string>
+		</edit>
+	</match>
+
+
+</fontconfig>

lilypond-2.24.2/etc/fonts/conf.d/45-latin.conf

@@ -0,0 +1,301 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<fontconfig>
+  <description>Set substitutions for Latin fonts</description>
+<!--
+  Mark common families with their generics so we'll get
+  something reasonable
+-->
+
+<!--
+  Serif faces
+ -->
+	<alias>
+		<family>Bitstream Vera Serif</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Cambria</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Constantia</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>DejaVu Serif</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Elephant</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Garamond</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Georgia</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Liberation Serif</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Luxi Serif</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>MS Serif</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Nimbus Roman No9 L</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Nimbus Roman</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Palatino Linotype</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Thorndale AMT</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Thorndale</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Times New Roman</family>
+		<default><family>serif</family></default>
+	</alias>
+	<alias>
+		<family>Times</family>
+		<default><family>serif</family></default>
+	</alias>
+<!--
+  Sans-serif faces
+ -->
+	<alias>
+		<family>Albany AMT</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Albany</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Arial Unicode MS</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Arial</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Bitstream Vera Sans</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Britannic</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Calibri</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Candara</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Century Gothic</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Corbel</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>DejaVu Sans</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Helvetica</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Haettenschweiler</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Liberation Sans</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>MS Sans Serif</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Nimbus Sans L</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Nimbus Sans</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Luxi Sans</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Tahoma</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Trebuchet MS</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Twentieth Century</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+	<alias>
+		<family>Verdana</family>
+		<default><family>sans-serif</family></default>
+	</alias>
+<!--
+  Monospace faces
+ -->
+	<alias>
+		<family>Andale Mono</family>
+		<default><family>monospace</family></default>
+	</alias>
+ 	<alias>
+		<family>Bitstream Vera Sans Mono</family>
+		<default><family>monospace</family></default>
+	</alias>
+	<alias>
+		<family>Consolas</family>
+		<default><family>monospace</family></default>
+	</alias>
+	<alias>
+		<family>Courier New</family>
+		<default><family>monospace</family></default>
+	</alias>
+	<alias>
+		<family>Courier</family>
+		<default><family>monospace</family></default>
+	</alias>
+	<alias>
+		<family>Courier Std</family>
+		<default><family>monospace</family></default>
+	</alias>
+	<alias>
+		<family>Cumberland AMT</family>
+		<default><family>monospace</family></default>
+	</alias>
+	<alias>
+		<family>Cumberland</family>
+		<default><family>monospace</family></default>
+	</alias>
+	<alias>
+		<family>DejaVu Sans Mono</family>
+		<default><family>monospace</family></default>
+	</alias>
+	<alias>
+		<family>Fixedsys</family>
+		<default><family>monospace</family></default>
+	</alias>
+	<alias>
+		<family>Inconsolata</family>
+		<default><family>monospace</family></default>
+	</alias>
+	<alias>
+		<family>Liberation Mono</family>
+		<default><family>monospace</family></default>
+	</alias>
+	<alias>
+		<family>Luxi Mono</family>
+		<default><family>monospace</family></default>
+	</alias>
+	<alias>
+		<family>Nimbus Mono L</family>
+		<default><family>monospace</family></default>
+	</alias>
+	<alias>
+		<family>Nimbus Mono</family>
+		<default><family>monospace</family></default>
+	</alias>
+	<alias>
+		<family>Nimbus Mono PS</family>
+		<default><family>monospace</family></default>
+	</alias>
+	<alias>
+		<family>Terminal</family>
+		<default><family>monospace</family></default>
+	</alias>
+<!--
+  Fantasy faces
+ -->
+	<alias>
+		<family>Bauhaus Std</family>
+		<default><family>fantasy</family></default>
+	</alias>
+	<alias>
+		<family>Cooper Std</family>
+		<default><family>fantasy</family></default>
+	</alias>
+	<alias>
+		<family>Copperplate Gothic Std</family>
+		<default><family>fantasy</family></default>
+	</alias>
+	<alias>
+		<family>Impact</family>
+		<default><family>fantasy</family></default>
+	</alias>
+<!--
+  Cursive faces
+  -->
+	<alias>
+		<family>Comic Sans MS</family>
+		<default><family>cursive</family></default>
+	</alias>
+	<alias>
+		<family>ITC Zapf Chancery Std</family>
+		<default><family>cursive</family></default>
+	</alias>
+	<alias>
+		<family>Zapfino</family>
+		<default><family>cursive</family></default>
+	</alias>
+<!--
+  system-ui
+-->
+	<alias>
+		<family>Cantarell</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Noto Sans UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Segoe UI</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Segoe UI Historic</family>
+		<default><family>system-ui</family></default>
+	</alias>
+	<alias>
+		<family>Segoe UI Symbol</family>
+		<default><family>system-ui</family></default>
+	</alias>
+
+</fontconfig>

lilypond-2.24.2/etc/fonts/conf.d/48-spacing.conf

@@ -0,0 +1,16 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<fontconfig>
+  <description>Add mono to the family when spacing is 100</description>
+<!--
+  If the request specifies spacing 100, add monospace to family
+ -->
+	<match target="pattern">
+		<test qual="any" name="spacing" compare="eq">
+			<int>100</int>
+		</test>
+		<edit name="family" mode="prepend">
+			<string>monospace</string>
+		</edit>
+	</match>
+</fontconfig>

lilypond-2.24.2/etc/fonts/conf.d/49-sansserif.conf

@@ -0,0 +1,22 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<fontconfig>
+  <description>Add sans-serif to the family when no generic name</description>
+<!--
+  If the font still has no generic name, add sans-serif
+ -->
+	<match target="pattern">
+		<test qual="all" name="family" compare="not_eq">
+			<string>sans-serif</string>
+		</test>
+		<test qual="all" name="family" compare="not_eq">
+			<string>serif</string>
+		</test>
+		<test qual="all" name="family" compare="not_eq">
+			<string>monospace</string>
+		</test>
+		<edit name="family" mode="append_last">
+			<string>sans-serif</string>
+		</edit>
+	</match>
+</fontconfig>

lilypond-2.24.2/etc/fonts/conf.d/50-user.conf

@@ -0,0 +1,16 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<fontconfig>
+  <description>Load per-user customization files</description>
+	<!--
+	    Load per-user customization files where stored on XDG Base Directory
+	    specification compliant places. it should be usually:
+	      $HOME/.config/fontconfig/conf.d
+	      $HOME/.config/fontconfig/fonts.conf
+	-->
+	<include ignore_missing="yes" prefix="xdg">fontconfig/conf.d</include>
+	<include ignore_missing="yes" prefix="xdg">fontconfig/fonts.conf</include>
+	<!-- the following elements will be removed in the future -->
+	<include ignore_missing="yes" deprecated="yes">~/.fonts.conf.d</include>
+	<include ignore_missing="yes" deprecated="yes">~/.fonts.conf</include>
+</fontconfig>

lilypond-2.24.2/etc/fonts/conf.d/51-local.conf

@@ -0,0 +1,7 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<fontconfig>
+  <description>Load local customization file</description>
+	<!-- Load local system customization file -->
+	<include ignore_missing="yes">local.conf</include>
+</fontconfig>

lilypond-2.24.2/etc/fonts/conf.d/60-generic.conf

@@ -0,0 +1,64 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<fontconfig>
+  <description>Set preferable fonts for emoji/math fonts</description>
+<!-- Keep in sync with 45-generic.conf -->
+
+<!-- Emoji -->
+
+	<!-- Prefer to match color emoji font. -->
+	<match>
+		<test name="lang">
+			<string>und-zsye</string>
+		</test>
+		<test qual="all" name="color" compare="not_eq">
+			<bool>true</bool>
+		</test>
+		<test qual="all" name="color" compare="not_eq">
+			<bool>false</bool>
+		</test>
+		<edit name="color" mode="append">
+			<bool>true</bool>
+		</edit>
+	</match>
+
+	<!-- TODO
+	 ! Match on "color" and alias B&W ones first if no color is requested.
+	 ! That's "hard" because <alias> doesn't work in match and needs to be
+	 ! expanded to its non-sugar form.
+	 !-->
+	<alias binding="same">
+		<family>emoji</family>
+		<prefer>
+			<!-- System fonts -->
+			<family>Noto Color Emoji</family> <!-- Google -->
+			<family>Apple Color Emoji</family> <!-- Apple -->
+			<family>Segoe UI Emoji</family> <!-- Microsoft -->
+			<family>Twitter Color Emoji</family> <!-- Twitter -->
+			<family>EmojiOne Mozilla</family> <!-- Mozilla -->
+			<!-- Third-Party fonts -->
+			<family>Emoji Two</family>
+			<family>JoyPixels</family>
+			<family>Emoji One</family>
+			<!-- Non-color -->
+			<family>Noto Emoji</family> <!-- Google -->
+			<family>Android Emoji</family> <!-- Google -->
+		</prefer>
+	</alias>
+
+<!-- Math -->
+	<alias binding="same">
+		<!-- https://en.wikipedia.org/wiki/Category:Mathematical_OpenType_typefaces -->
+		<family>math</family>
+		<prefer>
+			<family>XITS Math</family> <!-- Khaled Hosny -->
+			<family>STIX Two Math</family> <!-- AMS -->
+			<family>Cambria Math</family> <!-- Microsoft -->
+			<family>Latin Modern Math</family> <!-- TeX -->
+			<family>Minion Math</family> <!-- Adobe -->
+			<family>Lucida Math</family> <!-- Adobe -->
+			<family>Asana Math</family>
+		</prefer>
+	</alias>
+
+</fontconfig>

lilypond-2.24.2/etc/fonts/conf.d/60-latin.conf

@@ -0,0 +1,88 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<fontconfig>
+  <description>Set preferable fonts for Latin</description>
+	<alias>
+		<family>serif</family>
+		<prefer>
+			<family>Noto Serif</family>
+			<family>DejaVu Serif</family>
+			<family>Times New Roman</family>
+			<family>Thorndale AMT</family>
+			<family>Luxi Serif</family>
+			<family>Nimbus Roman No9 L</family>
+			<family>Nimbus Roman</family>
+			<family>Times</family>
+		</prefer>
+	</alias>
+	<alias>
+		<family>sans-serif</family>
+		<prefer>
+			<family>Noto Sans</family>
+			<family>DejaVu Sans</family>
+			<family>Verdana</family>
+			<family>Arial</family>
+			<family>Albany AMT</family>
+			<family>Luxi Sans</family>
+			<family>Nimbus Sans L</family>
+			<family>Nimbus Sans</family>
+			<family>Helvetica</family>
+			<family>Lucida Sans Unicode</family>
+			<family>BPG Glaho International</family> <!-- lat,cyr,arab,geor -->
+			<family>Tahoma</family> <!-- lat,cyr,greek,heb,arab,thai -->
+		</prefer>
+	</alias>
+	<alias>
+		<family>monospace</family>
+		<prefer>
+			<family>Noto Sans Mono</family>
+			<family>DejaVu Sans Mono</family>
+			<family>Inconsolata</family>
+			<family>Andale Mono</family>
+			<family>Courier New</family>
+			<family>Cumberland AMT</family>
+			<family>Luxi Mono</family>
+			<family>Nimbus Mono L</family>
+			<family>Nimbus Mono</family>
+			<family>Nimbus Mono PS</family>
+			<family>Courier</family>
+		</prefer>
+	</alias>
+<!--
+  Fantasy faces
+ -->
+ 	<alias>
+		<family>fantasy</family>
+		<prefer>
+			<family>Impact</family>
+			<family>Copperplate Gothic Std</family>
+			<family>Cooper Std</family>
+			<family>Bauhaus Std</family>
+		</prefer>
+	</alias>
+<!--
+  Cursive faces
+  -->
+	<alias>
+		<family>cursive</family>
+		<prefer>
+			<family>ITC Zapf Chancery Std</family>
+			<family>Zapfino</family>
+			<family>Comic Sans MS</family>
+		</prefer>
+	</alias>
+<!--
+  system-ui
+-->
+	<alias>
+		<family>system-ui</family>
+		<prefer>
+			<family>Cantarell</family>
+			<family>Noto Sans UI</family>
+			<family>Segoe UI</family>
+			<family>Segoe UI Historic</family>
+			<family>Segoe UI Symbol</family>
+		</prefer>
+	</alias>
+
+</fontconfig>

lilypond-2.24.2/etc/fonts/conf.d/65-fonts-persian.conf

@@ -0,0 +1,418 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<!--
+  fonts-persian.conf
+  To configure Persian fonts from The FarsiWeb Project.
+
+  Copyright (C) 2005  Sharif FarsiWeb, Inc. <[email protected]>
+
+  Permission to use, copy, modify, distribute, and sell this software and its
+  documentation for any purpose is hereby granted without fee, provided that
+  the above copyright notice appear in all copies and that both that
+  copyright notice and this permission notice appear in supporting
+  documentation, and that the name of Sharif FarsiWeb, Inc. not be used in
+  advertising or publicity pertaining to distribution of the software without
+  specific, written prior permission.  Sharif FarsiWeb, Inc. makes no
+  representations about the suitability of this software for any purpose.  It
+  is provided "as is" without express or implied warranty.
+
+  SHARIF FARSIWEB, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+  INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+  EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+  CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+  DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+  TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+
+  ChangeLog:
+    2005-04-03  Behdad Esfahbod:  Initial revision.
+    2005-10-09  Behdad Esfahbod:  Turned off back-slant and Tahoma sections.
+    2005-11-30  Behdad Esfahbod:  Set Titr susbtitution size to 24 points.
+    2008	Behdad Esfahbod:  Cleanup.  Add fantasy and cursive.
+  -->
+<fontconfig>
+
+<!-- Deprecated fonts are discouraged -->
+
+	<!-- Nesf[2] is officially deprecated and has problematic tables -->
+	<alias binding="same">
+	  <family>Nesf</family>
+	  <accept><family>Nesf2</family></accept>
+	</alias>
+	<alias binding="same">
+	  <family>Nesf2</family>
+	  <accept><family>Persian_sansserif_default</family></accept>
+	</alias>
+
+<!-- Name changes and spelling variant aliases -->
+
+	<alias binding="same">
+	  <family>Nazanin</family>
+	  <accept><family>Nazli</family></accept>
+	</alias>
+	<alias binding="same">
+	  <family>Lotus</family>
+	  <accept><family>Lotoos</family></accept>
+	</alias>
+	<alias binding="same">
+	  <family>Yaqut</family>
+	  <accept><family>Yaghoot</family></accept>
+	</alias>
+	<alias binding="same">
+	  <family>Yaghut</family>
+	  <accept><family>Yaghoot</family></accept>
+	</alias>
+	<alias binding="same">
+	  <family>Traffic</family>
+	  <accept><family>Terafik</family></accept>
+	</alias>
+	<alias binding="same">
+	  <family>Ferdowsi</family>
+	  <accept><family>Ferdosi</family></accept>
+	</alias>
+	<alias binding="same">
+	  <family>Fantezy</family>
+	  <accept><family>Fantezi</family></accept>
+	</alias>
+
+
+<!-- Classify fonts. -->
+
+	<!-- Persian_title class -->
+	<alias binding="same">
+	  <family>Jadid</family>
+	  <accept><family>Persian_title</family></accept>
+	</alias>
+	<alias binding="same">
+	  <family>Titr</family>
+	  <accept><family>Persian_title</family></accept>
+	</alias>
+
+	<!-- Persian_fantasy class -->
+	<alias binding="same">
+	  <family>Kamran</family>
+	  <accept>
+	  <family>Persian_fantasy</family>
+	  <family>Homa</family>
+	  </accept>
+	</alias>
+	<alias binding="same">
+	  <family>Homa</family>
+	  <accept>
+	  <family>Persian_fantasy</family>
+	  <family>Kamran</family>
+	  </accept>
+	</alias>
+	<alias binding="same">
+	  <family>Fantezi</family>
+	  <accept><family>Persian_fantasy</family></accept>
+	</alias>
+	<alias binding="same">
+	  <family>Tabassom</family>
+	  <accept><family>Persian_fantasy</family></accept>
+	</alias>
+
+	<!-- Persian_square class -->
+	<alias binding="same">
+	  <family>Arshia</family>
+	  <accept><family>Persian_square</family></accept>
+	</alias>
+	<alias binding="same">
+	  <family>Nasim</family>
+	  <accept><family>Persian_square</family></accept>
+	</alias>
+	<alias binding="same">
+	  <family>Elham</family>
+	  <accept>
+	  <family>Persian_square</family>
+	  <family>Farnaz</family>
+	  </accept>
+	</alias>
+	<alias binding="same">
+	  <family>Farnaz</family>
+	  <accept>
+	  <family>Persian_square</family>
+	  <family>Elham</family>
+	  </accept>
+	</alias>
+	<alias binding="same">
+	  <family>Sina</family>
+	  <accept><family>Persian_square</family></accept>
+	</alias>
+
+<!-- Font ordering per class -->
+
+	<!-- Persian_title class -->
+	<alias binding="same">
+	  <family>Persian_title</family>
+	  <accept>
+	  <family>Titr</family>
+	  <family>Jadid</family>
+	  <family>Persian_serif</family>
+	  </accept>
+	</alias>
+
+	<!-- Persian_fantasy class -->
+	<alias binding="same">
+	  <family>Persian_fantasy</family>
+	  <accept>
+	  <family>Homa</family>
+	  <family>Kamran</family>
+	  <family>Fantezi</family>
+	  <family>Tabassom</family>
+	  <family>Persian_square</family>
+	  </accept>
+	</alias>
+
+	<!-- Persian_square class -->
+	<alias binding="same">
+	  <family>Persian_square</family>
+	  <accept>
+	  <family>Arshia</family>
+	  <family>Elham</family>
+	  <family>Farnaz</family>
+	  <family>Nasim</family>
+	  <family>Sina</family>
+	  <family>Persian_serif</family>
+	  </accept>
+	</alias>
+
+<!-- Register the fonts that we actually do have -->
+
+	<match target="scan">
+		<test name="family" compare="eq" ignore-blanks="true">
+			<string>Elham</string>
+		</test>
+		<edit name="foundry">
+			<string>farsiweb</string>
+		</edit>
+	</match>
+
+	<match target="scan">
+		<test name="family" compare="eq" ignore-blanks="true">
+			<string>Homa</string>
+		</test>
+		<edit name="foundry">
+			<string>farsiweb</string>
+		</edit>
+	</match>
+
+	<match target="scan">
+		<test name="family" compare="eq" ignore-blanks="true">
+			<string>Koodak</string>
+		</test>
+		<edit name="foundry">
+			<string>farsiweb</string>
+		</edit>
+	</match>
+
+	<match target="scan">
+		<test name="family" compare="eq" ignore-blanks="true">
+			<string>Nazli</string>
+		</test>
+		<edit name="foundry">
+			<string>farsiweb</string>
+		</edit>
+	</match>
+
+	<match target="scan">
+		<test name="family" compare="eq" ignore-blanks="true">
+			<string>Roya</string>
+		</test>
+		<edit name="foundry">
+			<string>farsiweb</string>
+		</edit>
+	</match>
+
+	<match target="scan">
+		<test name="family" compare="eq" ignore-blanks="true">
+			<string>Terafik</string>
+		</test>
+		<edit name="foundry">
+			<string>farsiweb</string>
+		</edit>
+	</match>
+
+	<match target="scan">
+		<test name="family" compare="eq" ignore-blanks="true">
+			<string>Titr</string>
+		</test>
+		<edit name="foundry">
+			<string>farsiweb</string>
+		</edit>
+	</match>
+
+
+<!-- Our fonts should oblique to the other side (TURNED-OFF) -->
+
+	<match target="font">
+		<test name="foundry">
+			<!--string>farsiweb</string-->
+			<string>TURNED-OFF</string>
+		</test>
+		<test name="foundry">
+			<string>farsiweb</string>
+		</test>
+		<!-- check to see if the font is roman -->
+		<test name="slant">
+			<const>roman</const>
+		</test>
+		<!-- check to see if the pattern requested non-roman -->
+		<test target="pattern" name="slant" compare="not_eq">
+			<const>roman</const>
+		</test>
+		<!-- multiply the matrix to slant the font -->
+		<edit name="matrix" mode="assign">
+			<times>
+				<name>matrix</name>
+				<matrix><double>1</double><double>-0.2</double>
+					<double>0</double><double>1</double>
+				</matrix>
+			</times>
+		</edit>
+		<!-- pretend the font is oblique now -->
+		<edit name="slant" mode="assign">
+			<const>oblique</const>
+		</edit>
+	</match>
+
+
+<!--
+  We can't hint our fonts well, so turn off hinting.
+  Moreover, the bitmaps we have designed (well, they
+  have designed), suck, so disable them too.
+  -->
+
+	<match target="font">
+		<test name="foundry">
+			<string>farsiweb</string>
+		</test>
+		<edit name="autohint">
+			<bool>false</bool>
+		</edit>
+		<edit name="hinting">
+			<bool>false</bool>
+		</edit>
+ 		<edit name="embeddedbitmap">
+ 			<bool>false</bool>
+ 		</edit>
+	</match>
+
+
+<!-- Alias our fonts to common families -->
+
+	<!-- Persian serif fonts -->
+	<alias>
+		<family>serif</family>
+		<accept>
+			<family>Nazli</family>
+			<family>Lotoos</family>
+			<family>Mitra</family>
+			<family>Ferdosi</family>
+			<family>Badr</family>
+			<family>Zar</family>
+		</accept>
+	</alias>
+
+	<!-- Persian sans-serif fonts -->
+	<alias>
+		<family>sans-serif</family>
+		<accept>
+			<family>Roya</family>
+			<family>Koodak</family>
+			<family>Terafik</family>
+		</accept>
+	</alias>
+
+	<!-- Persian monospace fonts -->
+	<alias>
+		<family>monospace</family>
+		<accept>
+			<!-- Not really monospace -->
+			<family>Terafik</family>
+		</accept>
+	</alias>
+
+	<!-- Persian fantasy fonts -->
+	<alias>
+		<family>fantasy</family>
+		<accept>
+			<family>Homa</family>
+			<family>Kamran</family>
+			<family>Fantezi</family>
+			<family>Tabassom</family>
+		</accept>
+	</alias>
+
+	<!-- Persian (and Urdu) Nastaliq/cursive fonts -->
+	<alias>
+		<family>cursive</family>
+		<accept>
+			<family>IranNastaliq</family>
+			<family>Nafees Nastaleeq</family>
+		</accept>
+	</alias>
+
+<!-- Use Titr in titles -->
+
+	<!-- Both serif... -->
+	<match>
+		<test name="family">
+			<string>serif</string>
+		</test>
+		<test name="weight" compare="more_eq">
+			<int>200</int>
+		</test>
+		<test name="size" compare="more_eq">
+			<double>24</double>
+		</test>
+		<edit name="family" mode="prepend">
+			<string>Titr</string>
+		</edit>
+	</match>
+
+	<!-- and sans-serif. -->
+	<match>
+		<test name="family">
+			<string>sans-serif</string>
+		</test>
+		<test name="weight" compare="more_eq">
+			<int>200</int>
+		</test>
+		<test name="size" compare="more_eq">
+			<double>24</double>
+		</test>
+		<edit name="family" mode="prepend">
+			<string>Titr</string>
+		</edit>
+	</match>
+
+	<!-- and more. -->
+	<match>
+		<test name="family">
+			<string>Persian_sansserif_default</string>
+		</test>
+		<test name="weight" compare="more_eq">
+			<int>200</int>
+		</test>
+		<test name="size" compare="more_eq">
+			<double>24</double>
+		</test>
+		<edit name="family" mode="prepend" binding="same">
+			<string>Titr</string>
+		</edit>
+	</match>
+
+
+<!-- Default substituted for deprecated sans-serif fonts -->
+
+	<match>
+		<test name="family">
+			<string>Persian_sansserif_default</string>
+		</test>
+		<edit name="family" mode="assign" binding="same">
+			<string>Roya</string>
+		</edit>
+	</match>
+
+</fontconfig>

lilypond-2.24.2/etc/fonts/conf.d/65-nonlatin.conf

@@ -0,0 +1,228 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<fontconfig>
+  <description>Set preferable fonts for non-Latin</description>
+	<alias>
+		<family>serif</family>
+		<prefer>
+			<family>Artsounk</family> <!-- armenian -->
+			<family>BPG UTF8 M</family> <!-- georgian -->
+			<family>Kinnari</family> <!-- thai -->
+			<family>Norasi</family> <!-- thai -->
+			<family>Frank Ruehl</family> <!-- hebrew -->
+			<family>Dror</family>  <!-- hebrew -->
+			<family>JG LaoTimes</family>  <!-- lao -->
+			<family>Saysettha Unicode</family>  <!-- lao -->
+			<family>Pigiarniq</family> <!-- canadian syllabics -->
+			<family>B Davat</family> <!-- arabic (fa) -->
+			<family>B Compset</family>  <!-- arabic (fa) -->
+			<family>Kacst-Qr</family> <!-- arabic (ar) -->
+			<family>Urdu Nastaliq Unicode</family> <!-- arabic (ur) -->
+			<family>Raghindi</family> <!-- devanagari -->
+			<family>Mukti Narrow</family> <!-- bengali -->
+			<family>malayalam</family> <!-- malayalam -->
+			<family>Sampige</family> <!-- kannada -->
+			<family>padmaa</family> <!-- gujarati -->
+			<family>Hapax Berbère</family> <!-- tifinagh -->
+			<family>MS Mincho</family> <!-- han (ja) -->
+			<family>SimSun</family> <!-- han (zh-cn,zh-tw) -->
+			<family>PMingLiu</family> <!-- han (zh-tw) -->
+			<family>WenQuanYi Zen Hei</family> <!-- han (zh-cn,zh-tw) -->
+			<family>WenQuanYi Bitmap Song</family> <!-- han (zh-cn,zh-tw) -->
+			<family>AR PL ShanHeiSun Uni</family> <!-- han (ja,zh-cn,zh-tw) -->
+			<family>AR PL New Sung</family> <!-- han (zh-cn,zh-tw) -->
+			<family>ZYSong18030</family> <!-- han (zh-cn,zh-tw) -->
+			<family>HanyiSong</family> <!-- han (zh-cn,zh-tw) -->
+			<family>MgOpen Canonica</family>
+			<family>Sazanami Mincho</family>
+			<family>IPAMonaMincho</family>
+			<family>IPAMincho</family>
+			<family>Kochi Mincho</family>
+			<family>AR PL SungtiL GB</family>
+			<family>AR PL Mingti2L Big5</family>
+ 			<family>AR PL Zenkai Uni</family>
+			<family>ＭＳ 明朝</family>
+ 			<family>ZYSong18030</family>
+			<family>NanumMyeongjo</family> <!-- hangul (ko) -->
+			<family>UnBatang</family> <!-- hangul (ko) -->
+			<family>Baekmuk Batang</family> <!-- hangul (ko) -->
+ 			<family>KacstQura</family>
+ 			<family>Frank Ruehl CLM</family>
+			<family>Lohit Bengali</family>
+ 			<family>Lohit Gujarati</family>
+ 			<family>Lohit Hindi</family>
+			<family>Lohit Marathi</family>
+			<family>Lohit Maithili</family>
+			<family>Lohit Kashmiri</family>
+			<family>Lohit Konkani</family>
+			<family>Lohit Nepali</family>
+			<family>Lohit Sindhi</family>
+ 			<family>Lohit Punjabi</family>
+ 			<family>Lohit Tamil</family>
+			<family>Rachana</family>
+			<family>Lohit Malayalam</family>
+ 			<family>Lohit Kannada</family>
+ 			<family>Lohit Telugu</family>
+ 			<family>Lohit Oriya</family>
+ 			<family>LKLUG</family>
+		</prefer>
+	</alias>
+	<alias>
+		<family>sans-serif</family>
+		<prefer>
+			<family>Nachlieli</family> <!-- hebrew -->
+			<family>Lucida Sans Unicode</family>
+			<family>Yudit Unicode</family>
+			<family>Kerkis</family> <!-- greek -->
+			<family>ArmNet Helvetica</family> <!-- armenian -->
+			<family>Artsounk</family> <!-- armenian -->
+			<family>BPG UTF8 M</family> <!-- georgian -->
+			<family>Waree</family> <!-- thai -->
+			<family>Loma</family> <!-- thai -->
+			<family>Garuda</family> <!-- thai -->
+			<family>Umpush</family> <!-- thai -->
+			<family>Saysettha Unicode</family> <!-- lao? -->
+			<family>JG Lao Old Arial</family> <!-- lao -->
+			<family>GF Zemen Unicode</family> <!-- ethiopic -->
+			<family>Pigiarniq</family> <!-- canadian syllabics -->
+			<family>B Davat</family> <!-- arabic (fa) -->
+			<family>B Compset</family> <!-- arabic (fa) -->
+			<family>Kacst-Qr</family> <!-- arabic (ar) -->
+			<family>Urdu Nastaliq Unicode</family> <!-- arabic (ur) -->
+			<family>Raghindi</family> <!-- devanagari -->
+			<family>Mukti Narrow</family> <!-- bengali -->
+			<family>malayalam</family> <!-- malayalam -->
+			<family>Sampige</family> <!-- kannada -->
+			<family>padmaa</family> <!-- gujarati -->
+			<family>Hapax Berbère</family> <!-- tifinagh -->
+			<family>MS Gothic</family> <!-- han (ja) -->
+			<family>UmePlus P Gothic</family> <!-- han (ja) -->
+			<family>Microsoft YaHei</family> <!-- han (zh-cn,zh-tw) -->
+			<family>Microsoft JhengHei</family> <!-- han (zh-tw) -->
+			<family>WenQuanYi Zen Hei</family> <!-- han (zh-cn,zh-tw) -->
+			<family>WenQuanYi Bitmap Song</family> <!-- han (zh-cn,zh-tw) -->
+			<family>AR PL ShanHeiSun Uni</family> <!--han (ja,zh-cn,zh-tw) -->
+			<family>AR PL New Sung</family> <!-- han (zh-cn,zh-tw) -->
+			<family>MgOpen Modata</family>
+			<family>VL Gothic</family>
+			<family>IPAMonaGothic</family>
+			<family>IPAGothic</family>
+			<family>Sazanami Gothic</family>
+			<family>Kochi Gothic</family>
+			<family>AR PL KaitiM GB</family>
+			<family>AR PL KaitiM Big5</family>
+ 			<family>AR PL ShanHeiSun Uni</family>
+ 			<family>AR PL SungtiL GB</family>
+ 			<family>AR PL Mingti2L Big5</family>
+			<family>ＭＳ ゴ��ック</family>
+			<family>ZYSong18030</family> <!-- han (zh-cn,zh-tw) -->
+			<family>TSCu_Paranar</family> <!-- tamil -->
+			<family>NanumGothic</family> <!-- hangul (ko) -->
+			<family>UnDotum</family> <!-- hangul (ko) -->
+			<family>Baekmuk Dotum</family> <!-- hangul (ko) -->
+ 			<family>Baekmuk Gulim</family> <!-- hangul (ko) -->
+ 			<family>KacstQura</family>
+			<family>Lohit Bengali</family>
+ 			<family>Lohit Gujarati</family>
+ 			<family>Lohit Hindi</family>
+			<family>Lohit Marathi</family>
+			<family>Lohit Maithili</family>
+			<family>Lohit Kashmiri</family>
+			<family>Lohit Konkani</family>
+			<family>Lohit Nepali</family>
+			<family>Lohit Sindhi</family>
+ 			<family>Lohit Punjabi</family>
+ 			<family>Lohit Tamil</family>
+			<family>Meera</family>
+ 			<family>Lohit Malayalam</family>
+ 			<family>Lohit Kannada</family>
+ 			<family>Lohit Telugu</family>
+ 			<family>Lohit Oriya</family>
+ 			<family>LKLUG</family>
+		</prefer>
+	</alias>
+	<alias>
+		<family>monospace</family>
+		<prefer>
+			<family>Miriam Mono</family> <!-- hebrew -->
+			<family>VL Gothic</family>
+			<family>IPAMonaGothic</family>
+			<family>IPAGothic</family>
+			<family>Sazanami Gothic</family>
+			<family>Kochi Gothic</family>
+			<family>AR PL KaitiM GB</family>
+			<family>MS Gothic</family> <!-- han (ja) -->
+			<family>UmePlus Gothic</family> <!-- han (ja) -->
+			<family>NSimSun</family> <!-- han (zh-cn,zh-tw) -->
+			<family>MingLiu</family> <!-- han (zh-tw) -->
+			<family>AR PL ShanHeiSun Uni</family> <!-- han (ja,zh-cn,zh-tw) -->
+			<family>AR PL New Sung Mono</family> <!-- han (zh-cn,zh-tw) -->
+			<family>HanyiSong</family> <!-- han (zh-cn) -->
+			<family>AR PL SungtiL GB</family>
+			<family>AR PL Mingti2L Big5</family>
+			<family>ZYSong18030</family> <!-- han (zh-cn,zh-tw) -->
+			<family>NanumGothicCoding</family> <!-- hangul (ko) -->
+			<family>NanumGothic</family> <!-- hangul (ko) -->
+			<family>UnDotum</family> <!-- hangul (ko) -->
+			<family>Baekmuk Dotum</family> <!-- hangul (ko) -->
+			<family>Baekmuk Gulim</family> <!-- hangul (ko) -->
+			<family>TlwgTypo</family> <!-- thai -->
+			<family>TlwgTypist</family> <!-- thai -->
+			<family>TlwgTypewriter</family> <!-- thai -->
+			<family>TlwgMono</family> <!-- thai -->
+			<family>Hasida</family> <!-- hebrew -->
+			<family>GF Zemen Unicode</family> <!-- ethiopic -->
+			<family>Hapax Berbère</family> <!-- tifinagh -->
+			<family>Lohit Bengali</family>
+			<family>Lohit Gujarati</family>
+			<family>Lohit Hindi</family>
+			<family>Lohit Marathi</family>
+			<family>Lohit Maithili</family>
+			<family>Lohit Kashmiri</family>
+			<family>Lohit Konkani</family>
+			<family>Lohit Nepali</family>
+			<family>Lohit Sindhi</family>
+			<family>Lohit Punjabi</family>
+			<family>Lohit Tamil</family>
+			<family>Meera</family>
+			<family>Lohit Malayalam</family>
+			<family>Lohit Kannada</family>
+			<family>Lohit Telugu</family>
+			<family>Lohit Oriya</family>
+			<family>LKLUG</family>
+		</prefer>
+	</alias>
+<!--
+  system-ui
+-->
+	<alias>
+		<family>system-ui</family>
+		<prefer>
+			<family>Noto Sans Arabic UI</family><!-- ar -->
+			<family>Noto Sans Bengali UI</family><!-- bn -->
+			<family>Noto Sans Devanagari UI</family><!-- hi, mai, mr -->
+			<family>Noto Sans Gujarati UI</family><!-- gu -->
+			<family>Noto Sans Gurmukhi UI</family><!-- pa -->
+			<family>Noto Sans Kannada UI</family><!-- kn -->
+			<family>Noto Sans Khmer UI</family><!-- km -->
+			<family>Noto Sans Lao UI</family><!-- lo -->
+			<family>Noto Sans Malayalam UI</family><!-- ml -->
+			<family>Noto Sans Myanmar UI</family><!-- my -->
+			<family>Noto Sans Oriya UI</family><!-- or -->
+			<family>Noto Sans Sinhala UI</family><!-- si -->
+			<family>Noto Sans Tamil UI</family><!-- ta -->
+			<family>Noto Sans Telugu UI</family><!-- te -->
+			<family>Noto Sans Thai UI</family><!-- th -->
+			<family>Leelawadee UI</family><!-- bug, th, jv, km, lo -->
+			<family>Nirmala UI</family><!-- Indic -->
+			<family>Yu Gothic UI</family><!-- han (ja) -->
+			<family>Meiryo UI</family><!-- han (ja) -->
+			<family>MS UI Gothic</family><!-- han (ja) -->
+			<family>Khmer UI</family><!-- km -->
+			<family>Lao UI</family><!-- lo -->
+			<family>Microsoft YaHei UI</family><!-- han (zh-cn) -->
+			<family>Microsoft JhengHei UI</family><!-- han (zh-tw) -->
+		</prefer>
+	</alias>
+
+</fontconfig>

lilypond-2.24.2/etc/fonts/conf.d/69-unifont.conf

@@ -0,0 +1,28 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<fontconfig>
+	<alias>
+		<family>serif</family>
+		<prefer>
+			<family>FreeSerif</family>
+			<family>Code2000</family>
+			<family>Code2001</family> <!-- plane1 and beyond -->
+		</prefer>
+	</alias>
+	<alias>
+		<family>sans-serif</family>
+		<prefer>
+			<family>FreeSans</family>
+			<family>Arial Unicode MS</family>
+			<family>Arial Unicode</family>
+			<family>Code2000</family> <!-- almost everything; serif actually -->
+			<family>Code2001</family> <!-- plane1 and beyond -->
+		</prefer>
+	</alias>
+	<alias>
+		<family>monospace</family>
+		<prefer>
+			<family>FreeMono</family>
+		</prefer>
+	</alias>
+</fontconfig>

lilypond-2.24.2/etc/fonts/conf.d/80-delicious.conf

@@ -0,0 +1,19 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<fontconfig>
+<!-- Fix-ups for Delicious family -->
+
+<!-- Delicious 'heavy' variant says its Medium weight -->
+<match target="scan">
+	<test name="family" compare="eq" ignore-blanks="true">
+		<string>Delicious</string>
+	</test>
+	<test name="style">
+		<string>Heavy</string>
+	</test>
+	<edit name="weight">
+		<const>heavy</const>
+	</edit>
+</match>
+
+</fontconfig>

lilypond-2.24.2/etc/fonts/conf.d/90-synthetic.conf

@@ -0,0 +1,64 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<fontconfig>
+<!-- 
+ Artificial oblique for fonts without an italic or oblique version
+ -->
+ 
+	<match target="font">
+		<!-- check to see if the font is roman -->
+		<test name="slant">
+			<const>roman</const>
+		</test>
+		<!-- check to see if the pattern requested non-roman -->
+		<test target="pattern" name="slant" compare="not_eq">
+			<const>roman</const>
+		</test>
+		<!-- multiply the matrix to slant the font -->
+		<edit name="matrix" mode="assign">
+			<times>
+				<name>matrix</name>
+				<matrix><double>1</double><double>0.2</double>
+					<double>0</double><double>1</double>
+				</matrix>
+			</times>
+		</edit>
+		<!-- pretend the font is oblique now -->
+		<edit name="slant" mode="assign">
+			<const>oblique</const>
+		</edit>
+		<!-- and disable embedded bitmaps for artificial oblique -->
+		<edit name="embeddedbitmap" mode="assign">
+			<bool>false</bool>
+		</edit>
+	</match>
+
+<!--
+ Synthetic emboldening for fonts that do not have bold face available
+ -->
+
+	<match target="font">
+		<!-- check to see if the weight in the font is less than medium which possibly need emboldening -->
+		<test name="weight" compare="less_eq">
+			<const>medium</const>
+		</test>
+		<!-- check to see if the pattern requests bold -->
+		<test target="pattern" name="weight" compare="more_eq">
+			<const>bold</const>
+		</test>
+		<!--
+		  set the embolden flag
+		  needed for applications using cairo, e.g. gucharmap, gedit, ...
+		-->
+		<edit name="embolden" mode="assign">
+			<bool>true</bool>
+		</edit>
+		<!--
+		 set weight to bold
+		 needed for applications using Xft directly, e.g. Firefox, ...
+		-->
+		<edit name="weight" mode="assign">
+			<const>bold</const>
+		</edit>
+	</match>
+</fontconfig>

lilypond-2.24.2/etc/fonts/conf.d/README

@@ -0,0 +1,23 @@
+conf.d/README
+
+Each file in this directory is a fontconfig configuration file.  Fontconfig
+scans this directory, loading all files of the form [0-9][0-9]*.conf.
+These files are normally installed in /usr/share/fontconfig/conf.avail
+and then symlinked here, allowing them to be easily installed and then
+enabled/disabled by adjusting the symlinks.
+
+The files are loaded in numeric order, the structure of the configuration
+has led to the following conventions in usage:
+
+ Files beginning with:	Contain:
+ 
+ 00 through 09		Font directories
+ 10 through 19		system rendering defaults (AA, etc)
+ 20 through 29		font rendering options
+ 30 through 39		family substitution
+ 40 through 49		generic identification, map family->generic
+ 50 through 59		alternate config file loading
+ 60 through 69		generic aliases, map generic->family
+ 70 through 79		select font (adjust which fonts are available)
+ 80 through 89		match target="scan" (modify scanned patterns)
+ 90 through 99		font synthesis

lilypond-2.24.2/etc/fonts/fonts.conf

@@ -0,0 +1,101 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<!-- /etc/fonts/fonts.conf file to configure system font access -->
+<fontconfig>
+	<description>Default configuration file</description>
+
+<!--
+	DO NOT EDIT THIS FILE.
+	IT WILL BE REPLACED WHEN FONTCONFIG IS UPDATED.
+	LOCAL CHANGES BELONG IN 'local.conf'.
+
+	The intent of this standard configuration file is to be adequate for
+	most environments.  If you have a reasonably normal environment and
+	have found problems with this configuration, they are probably
+	things that others will also want fixed.  Please submit any problems
+	to the fontconfig issue tracking system located at fontconfig.org
+
+	Note that the normal 'make install' procedure for fontconfig is to
+	replace any existing fonts.conf file with the new version.  Place
+	any local customizations in local.conf which this file references.
+
+	Keith Packard
+-->
+
+<!-- Font directory list -->
+
+	<dir>WINDOWSFONTDIR</dir> <dir>WINDOWSUSERFONTDIR</dir>
+	
+	<dir prefix="xdg">fonts</dir>
+	<!-- the following element will be removed in the future -->
+	<dir>~/.fonts</dir>
+
+<!--
+  Accept deprecated 'mono' alias, replacing it with 'monospace'
+-->
+	<match target="pattern">
+		<test qual="any" name="family">
+			<string>mono</string>
+		</test>
+		<edit name="family" mode="assign" binding="same">
+			<string>monospace</string>
+		</edit>
+	</match>
+
+<!--
+  Accept alternate 'sans serif' spelling, replacing it with 'sans-serif'
+-->
+	<match target="pattern">
+		<test qual="any" name="family">
+			<string>sans serif</string>
+		</test>
+		<edit name="family" mode="assign" binding="same">
+			<string>sans-serif</string>
+		</edit>
+	</match>
+
+<!--
+  Accept deprecated 'sans' alias, replacing it with 'sans-serif'
+-->
+	<match target="pattern">
+		<test qual="any" name="family">
+			<string>sans</string>
+		</test>
+		<edit name="family" mode="assign" binding="same">
+			<string>sans-serif</string>
+		</edit>
+	</match>
+<!--
+  Accept alternate 'system ui' spelling, replacing it with 'system-ui'
+-->
+	<match target="pattern">
+		<test qual="any" name="family">
+			<string>system ui</string>
+		</test>
+		<edit name="family" mode="assign" binding="same">
+			<string>system-ui</string>
+		</edit>
+	</match>
+
+<!--
+  Load local system customization file
+-->
+	<include ignore_missing="yes">conf.d</include>
+
+<!-- Font cache directory list -->
+
+	<cachedir>LOCAL_APPDATA_FONTCONFIG_CACHE</cachedir>
+	<cachedir prefix="xdg">fontconfig</cachedir>
+	<!-- the following element will be removed in the future -->
+	<cachedir>~/.fontconfig</cachedir>
+
+	<config>
+<!--
+  Rescan configuration every 30 seconds when FcFontSetList is called
+ -->
+		<rescan>
+			<int>30</int>
+		</rescan>
+	</config>
+
+</fontconfig>

lilypond-2.24.2/etc/relocate/fontconfig.reloc

@@ -0,0 +1,2 @@
+set? FONTCONFIG_FILE=$INSTALLER_PREFIX/etc/fonts/fonts.conf
+set? FONTCONFIG_PATH=$INSTALLER_PREFIX/etc/fonts

lilypond-2.24.2/etc/relocate/guile.reloc

@@ -0,0 +1,2 @@
+prependdir GUILE_LOAD_PATH=$INSTALLER_PREFIX/share/guile/2.2
+prependdir GUILE_LOAD_COMPILED_PATH=$INSTALLER_PREFIX/lib/guile/2.2/ccache

lilypond-2.24.2/etc/relocate/libexec.reloc

@@ -0,0 +1 @@
+prependdir PATH=$INSTALLER_PREFIX/libexec