#!/usr/bin/env python
# coding=latin-1
'''
Copyright (C) 2012-2025: Willem G. Vree
Contributions: Nils Liberg, Nicolas Froment, Norman Schmidt, Reinier Maliepaard, Martin Tarenskeen,
               Paul Villiger, Alexander Scheutzow, Herbert Schneider, David Randolph, Michael Strasser

This program is free software; you can redistribute it and/or modify it under the terms of the
Lesser GNU General Public License as published by the Free Software Foundation;

This program 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 Lesser GNU General Public License for more details. <http://www.gnu.org/licenses/lgpl.html>.
'''
# mypy: ignore-errors
# flake8: noqa
# pylint: skip-file

from functools import reduce
try:    import xml.etree.cElementTree as E
except: import xml.etree.ElementTree as E
import types, sys, os, re, datetime

VERSION = 268

python3 = sys.version_info[0] > 2
lmap = lambda f, xs: list (map (f, xs))   # eager map for python 3
if python3:
    int_type = int
    list_type = list
    tuple_type = tuple
    str_type = str
    uni_type = str
    stdin = sys.stdin.buffer if sys.stdin else None  # read binary if stdin available!
else:
    int_type = types.IntType
    list_type = types.ListType
    tuple_type = types.TupleType
    str_type = types.StringTypes
    uni_type = types.UnicodeType
    stdin = sys.stdin

info_list = []  # diagnostic messages
debug = 0
def info (s, warn=1):
    x = (warn and '-- ' or '') + s
    info_list.append (x + '\n')         # collect messages
    if __name__ == '__main__':          # only write to stdout when called as main progeam
        try: sys.stderr.write (x + '\n')
        except: sys.stderr.write (repr (x) + '\n')

def getInfo (): # get string of diagnostic messages, then clear messages
    global info_list
    xs = ''.join (info_list)
    info_list = []
    return xs

#-----------------------------------------------------------------
# Functions and Classes for evaluating parsing expressions
#-----------------------------------------------------------------

class G:
    loc = 0
    zonderwit = 0
    str = ''
    prevloc = 0     # remember previous match position of a note/rest

def setLoc (n):
    G.loc = n

def setStr (str):
    G.str = str
    G.prevloc = 0

def pas (regex):    # regex => Gram (str => None | [str], str))
    def f (str):
        lengte = len (str)
        if G.zonderwit: str = str.lstrip ()  # verwijder spaties voor het passen
        dlen = lengte - len (str)           # aantal verwijderde spaties
        r = re.match (regex, str)
        if r:
            setLoc (G.loc + r.end () + dlen) # gloc is index in de reeks met spaties
            return [r.group (0)], str [r.end():]
        else: return None, str
    return Gram (f)

def plus (g1, g2):  # (Gram, Gram) => Gram (str => None | [str], str))
    def f (str):
        r1, rest1 = g1.parse (str)
        if (r1 != None):
            r2, rest2 = g2.parse (rest1)
            if r2 != None: return r1 + r2, rest2
            else: return None, str
        else: return None, str
    return Gram (f)

def Optional (g1, d = None):   # (Gram, str) => Gram (str => [str], str)
    if type (g1) == str: g1 = Literal (g1)
    def f (str):
        r, rest = g1.parse (str)
        if r != None: return r, rest
        else: return [d] if d != None else [], str
    return Gram (f)

def ZeroOrMore (g1):
    if type (g1) == str: g1 = Literal (g1)
    def f (str):
        r1, rest1 = g1.parse (str)
        if r1 != None:
            r2, rest2 = ZeroOrMore (g1).parse (rest1)
            return r1 + r2, rest2
        else: return [], str
    return Gram (f)

def OneOrMore (g1):
    if type (g1) == str: g1 = Literal (g1)
    def f (str):
        r1, rest1 = g1.parse (str)
        if r1 != None:
            r2, rest2 = ZeroOrMore (g1).parse (rest1)
            return r1 + r2, rest2
        else: return None, str
    return Gram (f)

def alt (g1, g2):
    def f (str):
        r1, rest1 = g1.parse (str)
        if r1 != None: return r1, rest1
        else:
            r2, rest2 = g2.parse (str)
            if r2 != None: return r2, rest2
            else: return None, str
    return Gram (f)

def langste (g1, g2):
    def f (str):
        r1, rest1 = g1.parse (str)
        if r1 != None:
            setLoc (g1.beg) # zelfde begin voor 2e pas
            r2, rest2 = g2.parse (str)
            if r2 != None:  # gloc staat op g2.end
                if g2.end > g1.end: # neem de langste passing
                    return r2, rest2
                else:       # gloc op g1.end zetten
                    setLoc (g1.end)
                    return r1, rest1
                return (r2, rest2) if g2.paslen > g1.paslen else (r1, rest1)
            else: return r1, rest1
        else:
            r2, rest2 = g2.parse (str)
            if r2 != None: return r2, rest2
            else: return None, str
    return Gram (f)

def Group (g1):
    def f (str):
        r, rest = g1.parse (str)
        if r != None: return [r], rest
        else: return None, str
    return Gram (f)

def Combine (g1):
    def f (str):
        lengte = len (str)
        str = str.lstrip (' \t\n')  # verwijder spaties voor het passen (alleen gewone spaties!)
        dlen = lengte - len (str)   # aantal verwijderde spaties
        rs, rest = g1.zonderWit (False).parse (str) # spaties significant in g1
        if rs != None:
            setLoc (G.loc + dlen)   # gloc is index in de reeks met spaties
            r = reduce (lambda a, b: a + b, rs)
            return [r], rest
        else: return None, str
    return Gram (f)

def oneOf (keus):
    def f (str):
        lengte = len (str)
        if G.zonderwit: str = str.lstrip ()
        dlen = lengte - len (str)
        ts = keus.split ();
        ts.sort (reverse = True, key = lambda x: len (x)) # de langste eerst
        for t in ts:
            if str.startswith (t):
                setLoc (G.loc + len (t) + dlen)
                return [t], str [len (t):]
        return None, str
    return Gram (f)

def CharsNotIn (reeks, exact=-1):
    def f (str):
        lengte = len (str)
        if G.zonderwit: str = str.lstrip ()  # verwijder spaties voor het passen
        dlen = lengte - len (str)           # aantal verwijderde spaties
        r = ''
        while len (str) > 0 and len (r) != exact and str[0] not in reeks:
            r += str[0]
            str = str [1:]
        if len (r) > 0 and (len (r) == exact or exact == -1):
            setLoc (G.loc + len (r) + dlen) # gloc is index in de reeks met spaties
            return [r], str
        else: return None, str
    return Gram (f)

def Suppress (g1):
    if type (g1) == str: g1 = Literal (g1)
    def f (str):
        r1, rest1 = g1.parse (str)
        if r1 != None: return [], rest1
        else: return None, str
    return Gram (f)

def FollowedBy (g1):
    if type (g1) == str: g1 = Literal (g1)
    def f (str):
        begin = G.loc   # echt ontleden maar G.loc niet opschuiven
        r1, rest1 = g1.parse (str)
        setLoc (begin)  # terug naar begin, want uitdrukking wordt later nogmaals ontleed
        if r1 != None: return [], str
        else: return None, str
    return Gram (f)

def Literal (str):
    xs = ['\\' + x if x in '[$().|*+' else x for x in str]
    return pas (''.join (xs))

def StringEnd ():
    def f (str):
        g1 = pas (r'$')
        r, rest = g1.parse (str)
        if r != None: r = []
        return r, rest
    return Gram (f)

class Gram:
    def __init__ (self, fa):
        self.f = fa
        self.laatweg = 0
        self.transform = None
        self.zw = None
        self.gwitprv = None
        self.beg = 0
        self.end = 0
    def parseString (self, str):
        setLoc (0)
        setStr (str)
        r, rest = self.parse (str)
        if r == None:   # grammatica faalt als geheel
            foutreeks = str [self.beg : self.beg + 40]
            raise Exception ('*** cannot parse: "%s" ***' % foutreeks)
        return r
    def parse (self, str):
        if self.zw != None:
            self.gwitprv = G.zonderwit   # vorige toestand bewaren
            G.zonderwit = self.zw        # de nieuwe toestand
        self.beg = G.loc         # beginindex van het passen
        r, rest = self.f (str)  # het passen
        if self.laatweg and r != None: r = []
        if self.zw != None:     # vorige toestand herstellen
            G.zonderwit = self.gwitprv
        self.end = G.loc         # eindindex van het passen
        if r != None and self.transform:
            r = Res (r, self.beg, self.end)
            r = self.transform (r)
        if r == None: setLoc (self.beg) # herstel de tekenindex na falen
        return r, rest
    def setParseAction (self, aktie):
        self.transform = aktie
        return self
    def zonderWit (self, b=True):
        self.zw = b
        return self
    def suppress (self):
        self.laatweg = 1
        return self
    def __add__ (self, other): return plus (self, other)
    def __or__ (self, other):  return alt  (self, other)
    def __xor__ (self, other): return langste (self, other)
    def __invert__ (self):
        def f (str):
            r, rest = self.parse (str)
            if r != None: return None, str
            else: return [], str
        return Gram (f)

class Res (list_type):
    def __init__ (s, xs, beg_p, end_p):
        super(Res, s).__init__(xs)
        s.beg = beg_p
        s.end = end_p

#-----------------------------------------------------------------
# Parsing Expression Grammar for ABC
#-----------------------------------------------------------------

def abc_grammar ():     # header, voice and lyrics grammar for ABC
    #-----------------------------------------------------------------
    # expressions that catch and skip some syntax errors (see corresponding parse expressions)
    #-----------------------------------------------------------------
    b1 = pas (u"[-,'<>\u2019#]")    # catch misplaced chars in chords
    b2 = pas (r'[^H-Wh-w~=]*')      # same in user defined symbol definition
    b3 = pas (r'[^=]*')             # same, second part

    #-----------------------------------------------------------------
    # ABC header (field_str elements are matched later with reg. epr's)
    #-----------------------------------------------------------------

    digits = pas (r'\d+')
    number = pas (r'\d+').setParseAction (lambda t: list (map (int, t)))
    field_str = pas (r'[^]]*')      # match anything until end of field
    field_str.setParseAction (lambda t: [t[0].strip ()])  # and strip spacing

    userdef_symbol  = pas (r'[H-Wh-w~]')
    fieldId = oneOf ('K L M Q P I T C O A Z N G H R B D F S E r Y') # info fields
    X_field = Literal ('X') + Suppress (':') + field_str
    U_field = Literal ('U') + Suppress (':') + b2 + Optional (userdef_symbol, 'H') + b3 + Suppress ('=') + field_str
    V_field = Literal ('V') + Suppress (':') + pas (r'\w+') + field_str
    inf_fld = fieldId + Suppress (':') + field_str
    ifield = Suppress ('[') + (X_field | U_field | V_field | inf_fld) + Suppress (']')
    abc_header = OneOrMore (ifield) + StringEnd ()

    #---------------------------------------------------------------------------------
    # I:score with recursive part groups and {* grand staff marker
    #---------------------------------------------------------------------------------

    voiceId = Suppress (Optional ('*')) + pas (r'\w+')
    voice_gr = Suppress ('(') + OneOrMore (voiceId | Suppress ('|')) + Suppress (')')
    simple_part = voiceId | voice_gr | Suppress ('|')
    grand_staff = oneOf ('{* {') + OneOrMore (simple_part) + Suppress ('}')
    part = Gram (None)   # de functie wordt verderop toegekend
    part_seq = OneOrMore (part | Suppress ('|'))
    brace_gr = Suppress ('{') + part_seq + Suppress ('}')
    bracket_gr = Suppress ('[') + part_seq + Suppress (']')
    part.f = (simple_part | grand_staff | brace_gr | bracket_gr | Suppress ('|')).f
    abc_scoredef = Suppress (oneOf ('staves score')) + OneOrMore (part)

    #----------------------------------------
    # ABC lyric lines (white space sensitive)
    #----------------------------------------

    skip_note   = oneOf ('* -')
    extend_note = Literal ('_')
    measure_end = Literal ('|')
    syl_str     = CharsNotIn ('*-_| \t\n\\]')
    syl_chars   = Combine (OneOrMore (syl_str | pas (r'\\.')))
    white       = pas (r'[ \t]+')
    syllable    = syl_chars + Optional ('-')
    lyr_elem    = (syllable | skip_note | extend_note | measure_end) + Suppress (Optional (white))
    lyr_line    = Suppress (Optional (white)) + ZeroOrMore (lyr_elem)

    syllable.setParseAction (lambda t: [pObj ('syl', t)])
    skip_note.setParseAction (lambda t: [pObj ('skip', t)])
    extend_note.setParseAction (lambda t: [pObj ('ext', t)])
    measure_end.setParseAction (lambda t: [pObj ('sbar', t)])
    lyr_line_wsp = lyr_line.zonderWit (False)

    #---------------------------------------------------------------------------------
    # ABC voice (not white space sensitive, beams detected in note/rest parse actions)
    #---------------------------------------------------------------------------------

    inline_field =  Suppress ('[') + (inf_fld | U_field | V_field) + Suppress (']')
    lyr_fld = Suppress ('[') + Suppress ('w') + Suppress (':') + lyr_line_wsp + Suppress (']')  # lyric line
    lyr_blk = OneOrMore (lyr_fld)       # verses
    fld_or_lyr = inline_field | lyr_blk # inline field or block of lyric verses

    note_length = Optional (number, 1) + Group (ZeroOrMore ('/')) + Optional (number, 2)
    octaveHigh = OneOrMore ("'").setParseAction (lambda t: [len (t)])
    octaveLow = OneOrMore (',').setParseAction (lambda t: [-len (t)])
    octave  = octaveHigh | octaveLow

    basenote = oneOf ('C D E F G A B c d e f g a b y')  # includes spacer for parse efficiency
    alteration = Optional (digits, '0') + Optional (pas (r'/+'), '') +  Optional (digits, '')
    accidental = oneOf ('^^ __ ^ _ =') + alteration
    rest_sym  = oneOf ('x X z Z')
    slur_beg = oneOf ("( (, (' .( .(, .('") + ~digits      # no tuplet_start
    slur_ends = OneOrMore (oneOf (') .)'))

    long_decoration = Combine (oneOf ('! +') + CharsNotIn ('!+ \n') + oneOf ('! +'))
    staccato        = Literal ('.') + ~Literal ('|')    # avoid dotted barline
    pizzicato       = Literal ('!+!')   # special case: plus sign is old style deco marker
    decoration      = slur_beg | staccato | userdef_symbol | long_decoration | pizzicato
    decorations     = OneOrMore (decoration)

    tie = oneOf ('.- -')
    rest = Optional (accidental) + rest_sym + note_length
    pitch = Optional (accidental) + basenote + Optional (octave, 0)
    note = pitch + note_length + Optional (tie) + Optional (slur_ends)
    dec_note = Optional (decorations) + pitch + note_length + Optional (tie) + Optional (slur_ends)
    chord_note = dec_note | rest | b1
    grace_notes = Gram (None)   # de functie wordt verderop toegekend
    chord = Suppress ('[') + OneOrMore (chord_note | grace_notes) + Suppress (']') + note_length + Optional (tie) + Optional (slur_ends)
    stem = note | chord | rest

    broken = Combine (OneOrMore ('<') | OneOrMore ('>'))

    tuplet_num   = Suppress ('(') + number
    tuplet_into  = Suppress (':') + Optional (number, 0)
    tuplet_notes = Suppress (':') + Optional (number, 0)
    tuplet_start = tuplet_num + Optional (tuplet_into + Optional (tuplet_notes))

    acciaccatura    = Literal ('/')
    grace_stem      = Optional (decorations) + stem
    hulp = Group (Suppress ('{') + Optional (acciaccatura) + OneOrMore (grace_stem) + Suppress ('}'))
    grace_notes.f   = hulp.f

    text_expression  = Optional (oneOf ('^ _ < > @'), '^') + Optional (CharsNotIn ('"'), "")
    chord_accidental = oneOf ('# b =')
    triad            = oneOf ('ma Maj maj M mi min m aug dim o + -')
    seventh          = oneOf ('7 ma7 Maj7 M7 maj7 mi7 min7 m7 dim7 o7 -7 aug7 +7 m7b5 mi7b5')
    sixth            = oneOf ('6 ma6 M6 mi6 min6 m6')
    ninth            = oneOf ('9 ma9 M9 maj9 Maj9 mi9 min9 m9')
    elevn            = oneOf ('11 ma11 M11 maj11 Maj11 mi11 min11 m11')
    thirt            = oneOf ('13 ma13 M13 maj13 Maj13 mi13 min13 m13')
    suspended        = oneOf ('sus sus2 sus4')
    chord_degree     = Combine (Optional (chord_accidental) + oneOf ('2 4 5 6 7 9 11 13'))
    chord_kind       = Optional (seventh | sixth | ninth | elevn | thirt | triad) + Optional (suspended)
    chord_root       = oneOf ('C D E F G A B') + Optional (chord_accidental)
    chord_bass       = oneOf ('C D E F G A B') + Optional (chord_accidental) # needs a different parse action
    chordsym         = chord_root + chord_kind + ZeroOrMore (chord_degree) + Optional (Suppress ('/') + chord_bass)
    chord_sym        = chordsym + Optional (Literal ('(') + CharsNotIn (')') + Literal (')')).suppress ()
    chord_or_text    = Suppress ('"') + (chord_sym ^ text_expression) + Suppress ('"')

    volta_nums = Suppress (Optional ('[')) + Combine (digits + ZeroOrMore (oneOf (', -') + digits))
    volta_text = Suppress (Literal ('[')) + pas (r'"[^"]+"')
    volta = volta_nums | volta_text
    invisible_barline = oneOf ('[|] []')
    dashed_barline = oneOf (': .|')
    double_rep = Literal (':') + FollowedBy (':')   # otherwise ambiguity with dashed barline
    voice_overlay = Combine (OneOrMore ('&'))
    bare_volta = FollowedBy (Literal ('[') + digits)   # no barline, but volta follows (volta is parsed in next measure)
    bar_left = (oneOf ('[|: |: [: :') + Optional (volta)) | Suppress (Optional ('|')) + volta | oneOf ('| [|')
    bars = ZeroOrMore (':') + ZeroOrMore ('[') + OneOrMore (oneOf ('| ]'))
    bar_right = invisible_barline | double_rep | Combine (bars) | dashed_barline | voice_overlay | bare_volta

    errors =  ~bar_right + Optional (pas (r'[ \n]+')) + pas (r'[^:&|]')
    linebreak = Literal ('$') | ~decorations + Literal ('!')    # no need for I:linebreak !!!
    element =  fld_or_lyr | broken | decorations | stem | chord_or_text | grace_notes | tuplet_start | linebreak | errors
    measure      = Group (ZeroOrMore (inline_field) + Optional (bar_left) + ZeroOrMore (element) + bar_right + Optional (linebreak) + Optional (lyr_blk))
    noBarMeasure = Group (ZeroOrMore (inline_field) + Optional (bar_left) + OneOrMore (element) + Optional (linebreak) + Optional (lyr_blk))
    abc_voice = ZeroOrMore (measure) + Optional (noBarMeasure | Group (bar_left)) + ZeroOrMore (Suppress (inline_field)) + StringEnd ()

    abc_acclist = OneOrMore (Group (accidental + basenote)).zonderWit () # used in explicit key definition, like K:C ^F _1B _12/36G

    #----------------------------------------
    # I:percmap note [step] [midi] [note-head]
    #----------------------------------------

    white2 = (white | StringEnd ()).suppress ()
    w3 = Optional (white2)
    percid = pas (r'[\w-]+')    # Word (alphanums + '-')
    step = basenote + Optional (octave, 0)
    pitchg = Group (Optional (accidental, '') + step + FollowedBy (white2))
    stepg = Group (step + FollowedBy (white2)) | Literal ('*')
    midi = (Literal ('*') | number | pitchg | percid)
    nhd = Optional (Combine (percid + Optional ('+')), '')
    perc_wsp = Literal ('percmap') + w3 + pitchg + w3 + Optional (stepg, '*') + w3 + Optional (midi, '*') + w3 + nhd

    accidental.setParseAction (alterAction) # parse actions must be set before calling leaveWhitespace
    abc_percmap = perc_wsp.zonderWit (False)

    #----------------------------------------------------------------
    # Parse actions to convert all relevant results into an abstract
    # syntax tree where all tree nodes are instances of pObj
    #----------------------------------------------------------------


    ifield.setParseAction (lambda t: [pObj ('field', t)])
    voiceId.setParseAction (lambda t: [pObj ('vid', t, 1)])
    voice_gr.setParseAction (lambda t: [pObj ('voicegr', t, 1)])
    grand_staff.setParseAction (lambda t: [pObj ('grand', t, 1)]) # 1 = keep ordered list of results
    brace_gr.setParseAction (lambda t: [pObj ('bracegr', t, 1)])
    bracket_gr.setParseAction (lambda t: [pObj ('bracketgr', t, 1)])
    abc_scoredef.setParseAction (lambda t: pObj ('score', t, 1))
    inline_field.setParseAction (lambda t: [pObj ('inline', t)])
    lyr_fld.setParseAction (lambda t: [pObj ('lyr_fld', t, 1)])
    lyr_blk.setParseAction (lambda t: [pObj ('lyr_blk', t, 1)]) # 1 = keep ordered list of lyric lines
    note_length.setParseAction (lambda t: [pObj ('dur', (t[0], (t[2] << len (t[1])) >> 1))])
    slur_ends.setParseAction (lambda t: [pObj ('slurs', t)])
    pizzicato.setParseAction (lambda t: ['!plus!']) # translate !+!
    decorations.setParseAction (lambda t: [pObj ('deco', t)])
    tie.setParseAction (lambda t: [pObj ('tie', t)])
    rest.setParseAction (restActn)
    pitch.setParseAction (lambda t: [pObj ('pitch', t)])
    note.setParseAction (noteActn)
    dec_note.setParseAction (noteActn)
    chord.setParseAction (lambda t: [pObj ('chord', t, 1)])
    broken.setParseAction (lambda t: [pObj ('broken', t)])
    tuplet_start.setParseAction (lambda t: [pObj ('tup', t)])
    grace_notes.setParseAction (doGrace)
    acciaccatura.setParseAction (lambda t: [pObj ('accia', t)])
    text_expression.setParseAction (lambda t: [pObj ('text', t)])
    chordsym.setParseAction (lambda t: [pObj ('chordsym', t)])
    chord_root.setParseAction (lambda t: [pObj ('root', t)])
    chord_kind.setParseAction (lambda t: [pObj ('kind', t)])
    chord_degree.setParseAction (lambda t: [pObj ('degree', t)])
    chord_bass.setParseAction (lambda t: [pObj ('bass', t)])
    bare_volta.setParseAction (lambda t: ['|']) # return barline that user forgot
    dashed_barline.setParseAction (lambda t: ['.|'])
    bar_right.setParseAction (lambda t: [pObj ('rbar', t)])
    bar_left.setParseAction (lambda t: [pObj ('lbar', t)])
    linebreak.setParseAction (lambda t: [pObj ('linebrk', t)])
    measure.setParseAction (doMaat)
    noBarMeasure.setParseAction (doMaat)
    b1.setParseAction (errorWarn)
    b2.setParseAction (errorWarn)
    b3.setParseAction (errorWarn)
    errors.setParseAction (errorWarn)

    return abc_header.zonderWit (), abc_voice.zonderWit (), abc_scoredef.zonderWit (), abc_percmap, abc_acclist

class pObj (object):    # every relevant parse result is converted into a pObj
    def __init__ (s, name, t, seq=0):   # t = list of nested parse results
        s.name = name   # name uniqueliy identifies this pObj
        rest = []       # collect parse results that are not a pObj
        attrs = {}      # new attributes
        for x in t:     # nested pObj's become attributes of this pObj
            if type (x) == pObj:
                attrs [x.name] = attrs.get (x.name, []) + [x]
            else:
                rest.append (x)             # collect non-pObj's (mostly literals)
        for name, xs in attrs.items ():
            if len (xs) == 1: xs = xs[0]    # only list if more then one pObj
            setattr (s, name, xs)           # create the new attributes
        s.t = rest      # all nested non-pObj's (mostly literals)
        s.objs = seq and t or []            # for nested ordered (lyric) pObj's

    def __repr__ (s):   # make a nice string representation of a pObj
        r = []
        for nm in dir (s):
            if nm.startswith ('_'): continue # skip build in attributes
            elif nm == 'name': continue     # redundant
            else:
                x = getattr (s, nm)
                if not x: continue          # s.t may be empty (list of non-pObj's)
                if type (x) == list_type:  r.extend (x)
                else:                           r.append (x)
        xs = []
        for x in r:     # recursively call __repr__ and convert all strings to latin-1
            if isinstance (x, str_type): xs.append (x)          # string -> no recursion
            else:                        xs.append (repr (x))   # pObj -> recursive call
        return '(' + s.name + ' ' +','.join (xs) + ')'

def detectBeamBreak (line, loc, t):
    xs = line[G.prevloc:loc+1]  # string between previous and current note match
    xs = xs.lstrip ()           # first note match starts on a space!
    xs = re.sub (r'"[^"]*"', '', xs)  # remove chords and annotations (because: may contain spaces)
    xs = re.sub (r'\[[^]]:[^]]*]', '', xs)  # remove inline fields as well
    G.prevloc = loc             # location in string 'line' of current note match
    b = pObj ('bbrk', [' ' in xs])  # space somewhere between two notes -> beambreak
    t.insert (0, b)             # insert beambreak as a nested parse result

def noteActn (t):    # detect beambreak between previous and current note/rest
    if 'y' in t[0].t: return [] # discard spacer
    detectBeamBreak (G.str, t.beg, t)      # adds beambreak to parse result t as side effect
    if debug: print ('--noot', t.beg, t.end, repr (G.str [t.beg : t.end]))
    return [pObj ('note', t)]

def restActn (t):    # detect beambreak between previous and current note/rest
    detectBeamBreak (G.str, t.beg, t)    # adds beambreak to parse result t as side effect
    if debug: print ('--rust', t.beg, t.end, repr (G.str [t.beg : t.end]))
    return [pObj ('rest', t)]

def alterAction (t):    # accidental, teller, slashes, noemer
    nsl = len (t[2])    # number of slashes
    if nsl == 0:        # no slash
        if t[1] == '0': return [t[0]] # ^C
        return [(t[0], t[1])]           # ^2C
    else:               # default t[3] == 2
        if t[3]: d = t[3]
        else:    d = str (2 << (nsl - 1))   # / == /2, // == /4
    return [(t[0], t[1].replace ('0','1') + '_' + d)]   # ^n_d

def errorWarn (t):
    if not t[0]: return []      # only warn if catched string not empty
    info ('**misplaced symbol: %s' % t[0], warn=0)
    lineCopy = G.str [:]
    loc = t.end - 1 # de fout kan met spaties beginnen en is dan een string met de letter aan het eind
    if loc > 40:
        lineCopy = G.str [loc - 40: loc + 40]
        loc = 40
    info (lineCopy.replace ('\n', ' '), warn=0)
    info (loc * '-' + '^', warn=0)
    return []

def debugAction (t, soort_pObj):    # voor regels met (soort_pObj) en zonder parseAction
    print ('debug', t, t.beg, t.end, G.str [t.beg : t.end])
    return [pObj (soort_pObj, t)] if soort_pObj else t

#-------------------------------------------------------------
# transformations of a measure (called by parse action doMaat)
#-------------------------------------------------------------

def simplify (a, b):    # divide a and b by their greatest common divisor
    x, y = a, b
    while b: a, b = b, a % b
    return x // a, y // a

def doBroken (prev, brk, x):
    if not prev: info ('error in broken rhythm: %s' % x); return    # no changes
    nom1, den1 = prev.dur.t # duration of first note/chord
    nom2, den2 = x.dur.t    # duration of second note/chord
    if  brk == '>':
        nom1, den1  = simplify (3 * nom1, 2 * den1)
        nom2, den2  = simplify (1 * nom2, 2 * den2)
    elif brk == '<':
        nom1, den1  = simplify (1 * nom1, 2 * den1)
        nom2, den2  = simplify (3 * nom2, 2 * den2)
    elif brk == '>>':
        nom1, den1  = simplify (7 * nom1, 4 * den1)
        nom2, den2  = simplify (1 * nom2, 4 * den2)
    elif brk == '<<':
        nom1, den1  = simplify (1 * nom1, 4 * den1)
        nom2, den2  = simplify (7 * nom2, 4 * den2)
    else: return            # give up
    prev.dur.t = nom1, den1 # change duration of previous note/chord
    x.dur.t = nom2, den2    # and current note/chord

def convertBroken (t):  # convert broken rhythms to normal note durations
    prev = None # the last note/chord before the broken symbol
    brk = ''    # the broken symbol
    remove = [] # indexes to broken symbols (to be deleted) in measure
    for i, x in enumerate (t):  # scan all elements in measure
        if x.name == 'note' or x.name == 'chord' or x.name == 'rest':
            if brk:                 # a broken symbol was encountered before
                doBroken (prev, brk, x) # change duration previous note/chord/rest and current one
                brk = ''
            else:
                prev = x            # remember the last note/chord/rest
        elif x.name == 'broken':
            brk = x.t[0]            # remember the broken symbol (=string)
            remove.insert (0, i)    # and its index, highest index first
    for i in remove: del t[i]       # delete broken symbols from high to low

def ptc2midi (n):       # convert parsed pitch attribute to a midi number
    pt = getattr (n, 'pitch', '')
    if pt:
        p = pt.t
        if len (p) == 3: acc, step, oct = p
        else:       acc = ''; step, oct = p
        nUp = step.upper ()
        oct = (4 if nUp == step else 5) + int (oct)
        midi = oct * 12 + [0,2,4,5,7,9,11]['CDEFGAB'.index (nUp)] + {'^':1,'_':-1}.get (acc, 0) + 12
    else: midi = 130    # all non pitch objects first
    return midi

def convertChord (t):   # convert chord to sequence of notes in musicXml-style
    ins = []
    for i, x in enumerate (t):
        if x.name == 'chord':
            if hasattr (x, 'rest') and not hasattr (x, 'note'): # chords containing only rests
                if type (x.rest) == list_type: x.rest = x.rest[0] # more rests == one rest
                ins.insert (0, (i, [x.rest]))   # just output a single rest, no chord
                continue
            num1, den1 = x.dur.t                # chord duration
            tie = getattr (x, 'tie', None)      # chord tie
            slurs = getattr (x, 'slurs', [])    # slur endings
            if type (x.note) != list_type: x.note = [x.note]    # when chord has only one note ...
            elms = []; j = 0                    # sort chord notes, highest first
            nss = sorted (x.objs, key = ptc2midi, reverse=1) if mxm.orderChords else x.objs
            for nt in nss:   # all chord elements (note | decorations | rest | grace note)
                if nt.name == 'note':
                    num2, den2 = nt.dur.t           # note duration * chord duration
                    nt.dur.t = simplify (num1 * num2, den1 * den2)
                    if tie: nt.tie = tie            # tie on all chord notes
                    if j == 0 and slurs: nt.slurs = slurs   # slur endings only on first chord note
                    if j > 0: nt.chord = pObj ('chord', [1]) # label all but first as chord notes
                    else:                           # remember all pitches of the chord in the first note
                        pitches = [n.pitch for n in x.note] # to implement conversion of erroneous ties to slurs
                        nt.pitches = pObj ('pitches', pitches)
                    j += 1
                if nt.name not in ['dur','tie','slurs','rest']: elms.append (nt)
            ins.insert (0, (i, elms))           # chord position, [note|decotation|grace note]
    for i, notes in ins:                        # insert from high to low
        for nt in reversed (notes):
            t.insert (i+1, nt)                  # insert chord notes after chord
        del t[i]                                # remove chord itself

def doMaat (t):             # t is a Group() result -> the measure is in t[0]
    if debug: print ('--maat', t.beg, t.end, repr (G.str [t.beg : t.end]))
    convertBroken (t[0])    # remove all broken rhythms and convert to normal durations
    convertChord (t[0])     # replace chords by note sequences in musicXML style
    return [t[0]]           # vergelijkbaar met pyparsing

def doGrace (t):        # t is a Group() result -> the grace sequence is in t[0]
    convertChord (t[0]) # a grace sequence may have chords
    grcNts = [nt for nt in t[0] if nt.name == 'note']
    numNts = len ([nt for nt in grcNts if not getattr (nt, 'chord', '')]) # exclude chord notes
    for nt in grcNts:   # flag all notes within the grace sequence
        if nt.name == 'note': nt.grace = numNts # grace attribute = number of grace notes
    return t[0]         # ungroup the parse result
#--------------------
# musicXML generation
#----------------------------------

def compChordTab ():    # avoid some typing work: returns mapping constant {ABC chordsyms -> musicXML kind}
    maj, min, aug, dim, dom, ch7, ch6, ch9, ch11, ch13, hd = 'major minor augmented diminished dominant -seventh -sixth -ninth -11th -13th half-diminished'.split ()
    triad   = zip ('ma Maj maj M mi min m aug dim o + -'.split (), [maj, maj, maj, maj, min, min, min, aug, dim, dim, aug, min])
    seventh = zip ('7 ma7 Maj7 M7 maj7 mi7 min7 m7 dim7 o7 -7 aug7 +7 m7b5 mi7b5'.split (),
                   [dom, maj+ch7, maj+ch7, maj+ch7, maj+ch7, min+ch7, min+ch7, min+ch7, dim+ch7, dim+ch7, min+ch7, aug+ch7, aug+ch7, hd, hd])
    sixth   = zip ('6 ma6 M6 mi6 min6 m6'.split (), [maj+ch6, maj+ch6, maj+ch6, min+ch6, min+ch6, min+ch6])
    ninth   = zip ('9 ma9 M9 maj9 Maj9 mi9 min9 m9'.split (), [dom+ch9, maj+ch9, maj+ch9, maj+ch9, maj+ch9, min+ch9, min+ch9, min+ch9])
    elevn   = zip ('11 ma11 M11 maj11 Maj11 mi11 min11 m11'.split (), [dom+ch11, maj+ch11, maj+ch11, maj+ch11, maj+ch11, min+ch11, min+ch11, min+ch11])
    thirt   = zip ('13 ma13 M13 maj13 Maj13 mi13 min13 m13'.split (), [dom+ch13, maj+ch13, maj+ch13, maj+ch13, maj+ch13, min+ch13, min+ch13, min+ch13])
    sus     = zip ('sus sus4 sus2'.split (), ['suspended-fourth', 'suspended-fourth', 'suspended-second'])
    return dict (list (triad) + list (seventh) + list (sixth) + list (ninth) + list (elevn) + list (thirt) + list (sus))

def addElem (parent, child, level):
    indent = 2
    chldrn = list (parent)
    if chldrn:
        chldrn[-1].tail += indent * ' '
    else:
        parent.text = '\n' + level * indent * ' '
    parent.append (child)
    child.tail = '\n' + (level-1) * indent * ' '

def delElem (parent, child):    # child must be one of the parent's children
    last_elm = list (parent) [-1]
    parent.remove (child)
    if child == last_elm:       # correct the tail (indent) when child was the last element
        elms = list (parent)
        if elms:                # child was not the only element in parent
            last_elm = elms [-1]
            last_elm.tail = child.tail  # keep the indent from deleted child

def addElemT (parent, tag, text, level):
    e = E.Element (tag)
    e.text = text
    addElem (parent, e, level)
    return e

def mkTmod (tmnum, tmden, lev):
    tmod = E.Element ('time-modification')
    addElemT (tmod, 'actual-notes', str (tmnum), lev + 1)
    addElemT (tmod, 'normal-notes', str (tmden), lev + 1)
    return tmod

def addDirection (parent, elems, lev, gstaff, subelms=[], placement='below', cue_on=0):
    dir = E.Element ('direction', placement=placement)
    addElem (parent, dir, lev)
    if type (elems) != list_type: elems = [(elems, subelms)]    # ugly hack to provide for multiple direction types
    for elem, subelms in elems: # add direction types
        typ = E.Element ('direction-type')
        addElem (dir, typ, lev + 1)
        addElem (typ, elem, lev + 2)
        for subel in subelms: addElem (elem, subel, lev + 3)
    if cue_on: addElem (dir, E.Element ('level', size='cue'), lev + 1)
    if gstaff: addElemT (dir, 'staff', str (gstaff), lev + 1)
    return dir

def removeElems (root_elem, parent_str, elem_str):
    for p in root_elem.findall (parent_str):
        e = p.find (elem_str)
        if e != None: p.remove (e)

def alignLyr (vce, lyrs):
    empty_el = pObj ('leeg', '*')
    for k, lyr in enumerate (lyrs): # lyr = one full line of lyrics
        i = 0               # syl counter
        for elem in vce:    # reiterate the voice block for each lyrics line
            if elem.name == 'note' and not (hasattr (elem, 'chord') or hasattr (elem, 'grace')):
                if i >= len (lyr): lr = empty_el
                else: lr = lyr [i]
                lr.t[0] = lr.t[0].replace ('%5d',']')
                elem.objs.append (lr)
                if lr.name != 'sbar': i += 1
            if elem.name == 'rbar' and i < len (lyr) and lyr[i].name == 'sbar': i += 1
    return vce

slur_move = re.compile (r'(?<![!+])([}><][<>]?)(\)+)')  # (?<!...) means: not preceeded by ...
mm_rest = re.compile (r'([XZ])(\d+)')
bar_space = re.compile (r'([:|][ |\[\]]+[:|])')         # barlines with spaces
def fixSlurs (x):   # repair slurs when after broken sign or grace-close
    def f (mo):     # replace a multi-measure rest by single measure rests
        n = int (mo.group (2))
        return (n * (mo.group (1) + '|')) [:-1]
    def g (mo):     # squash spaces in barline expressions
        return mo.group (1).replace (' ','')
    x = mm_rest.sub (f, x)
    x = bar_space.sub (g, x)
    return slur_move.sub (r'\2\1', x)

def splitHeaderVoices (abctext):
    escField = lambda x: '[' + x.replace (']',r'%5d') + ']' # hope nobody uses %5d in a field
    r1 = re.compile (r'%.*$')           # comments
    r2 = re.compile (r'^([A-Zw]:.*$)|\[[A-Zw]:[^]]*]$')     # information field, including lyrics
    r3 = re.compile (r'^%%(?=[^%])')    # directive: ^%% folowed by not a %
    xs, nx, mcont, fcont = [], 0, 0, 0  # result lines, X-encountered, music continuation, field continuation
    mln = fln = ''                      # music line, field line
    for x in abctext.splitlines ():
        x = x.strip ()
        if not x and nx == 1: break     # end of tune (empty line)
        if x.startswith ('X:'):
            if nx == 1: break           # second tune starts without an empty line !!
            nx = 1                      # start first tune
        x = r3.sub ('I:', x)            # replace %% -> I:
        x2 = r1.sub ('', x)             # remove comment
        while x2.endswith ('*') and not (x2.startswith ('w:') or x2.startswith ('+:') or 'percmap' in x2):
            x2 = x2[:-1]                # remove old syntax for right adjusting
        if not x2: continue             # empty line
        if x2[:2] == 'W:':
            field = x2 [2:].strip ()
            ftype = mxm.metaMap.get ('W', 'W')  # respect the (user defined --meta) mapping of various ABC fields to XML meta data types
            c = mxm.metadata.get (ftype, '')
            mxm.metadata [ftype] = c + '\n' + field if c else field   # concatenate multiple info fields with new line as separator
            continue                    # skip W: lyrics
        if x2[:2] == '+:':              # field continuation
            fln += ' ' + x2[2:]         # continuation is considered to add a space
            continue
        ro = r2.match (x2)              # single field on a line
        if ro:                          # field -> inline_field, escape all ']'
            if fcont:                   # old style \-info-continuation active
                fcont = x2 [-1] == '\\' # possible further \-info-continuation
                fln += re.sub (r'^.:(.*?)\\*$', r'\1', x2) # add continuation, remove .: and \
                continue
            if fln: mln += escField (fln)
            if x2.startswith ('['): x2 = x2.strip ('[]')
            fcont = x2 [-1] == '\\'     # first encounter of old style \-info-continuation
            fln = x2.rstrip ('\\')      # remove continuation from field and inline brackets
            continue
        if nx == 1:                     # x2 is a new music line
            fcont = 0                   # stop \-continuations (-> only adjacent \-info-continuations are joined)
            if fln:
                mln +=  escField (fln)
                fln = ''
            if mcont:
                mcont = x2 [-1] == '\\'
                mln += x2.rstrip ('\\')
            else:
                if mln: xs.append (mln); mln = ''
                mcont = x2 [-1] == '\\'
                mln = x2.rstrip ('\\')
            if not mcont: xs.append (mln); mln = ''
    if fln: mln += escField (fln)
    if mln: xs.append (mln)

    hs = re.split (r'(\[K:[^]]*\])', xs [0])   # look for end of header K:
    if len (hs) == 1: header = hs[0]; xs [0] = ''               # no K: present
    else: header = hs [0] + hs [1]; xs [0] = ''.join (hs[2:])   # h[1] is the first K:
    abctext = '\n'.join (xs)                    # the rest is body text
    hfs, vfs = [], []
    for x in header[1:-1].split (']['):
        if x[0] == 'V': vfs.append (x)          # filter voice- and midi-definitions
        elif x[:6] == 'I:MIDI': vfs.append (x)  # from the header to vfs
        elif x[:9] == 'I:percmap': vfs.append (x)  # and also percmap
        else: hfs.append (x)                    # all other fields stay in header
    header = '[' + ']['.join (hfs) + ']'        # restore the header
    abctext = ('[' + ']['.join (vfs) + ']' if vfs else '') + abctext    # prepend voice/midi from header before abctext

    xs = abctext.split ('[V:')
    if len (xs) == 1: abctext = '[V:1]' + abctext # abc has no voice defs at all
    elif re.sub (r'\[[A-Z]:[^]]*\]', '', xs[0]).strip ():   # remove inline fields from starting text, if any
        abctext = '[V:1]' + abctext     # abc with voices has no V: at start

    r1 = re.compile (r'\[V:\s*(\S*)[ \]]') # get voice id from V: field (skip spaces betwee V: and ID)
    vmap = {}                           # {voice id -> [voice abc string]}
    vorder = {}                         # mark document order of voices
    xs = re.split (r'(\[V:[^]]*\])', abctext)   # split on every V-field (V-fields included in split result list)
    if len (xs) == 1: raise ValueError ('bugs ...')
    else:
        pm = re.findall (r'\[P:.\]', xs[0])         # all P:-marks after K: but before first V:
        if pm: xs[2] = ''.join (pm) + xs[2]         # prepend P:-marks to the text of the first voice
        header += re.sub (r'\[P:.\]', '', xs[0])    # clear all P:-marks from text between K: and first V: and put text in the header
        i = 1
        while i < len (xs):             # xs = ['', V-field, voice abc, V-field, voice abc, ...]
            vce, abc = xs[i:i+2]
            id = r1.search (vce).group (1)                  # get voice ID from V-field
            if not id: id, vce = '1', '[V:1]'               # voice def has no ID
            vmap[id] = vmap.get (id, []) + [vce, abc]       # collect abc-text for each voice id (include V-fields)
            if id not in vorder: vorder [id] = i            # store document order of first occurrence of voice id
            i += 2
    voices = []
    ixs = sorted ([(i, id) for id, i in vorder.items ()])   # restore document order of voices
    for i, id in ixs:
        voice = ''.join (vmap [id])     # all abc of one voice
        voice = fixSlurs (voice)        # put slurs right after the notes
        voices.append ((id, voice))
    return header, voices

def mergeMeasure (m1, m2, slur_offset, voice_offset, rOpt, is_grand=0, is_overlay=0):
    slurs = m2.findall ('note/notations/slur')
    for slr in slurs:
        slrnum = int (slr.get ('number')) + slur_offset
        slr.set ('number', str (slrnum))    # make unique slurnums in m2
    vs = m2.findall ('note/voice')          # set all voice number elements in m2
    for v in vs: v.text  = str (voice_offset + int (v.text))
    ls = m1.findall ('note/lyric')          # all lyric elements in m1
    lnum_max = max ([int (l.get ('number')) for l in ls] + [0]) # highest lyric number in m1
    ls = m2.findall ('note/lyric')          # update lyric elements in m2
    for el in ls:
        n = int (el.get ('number'))
        el.set ('number', str (n + lnum_max))
    ns = m1.findall ('note')    # determine the total duration of m1, subtract all backups
    dur1 = sum (int (n.find ('duration').text) for n in ns
                if n.find ('grace') == None and n.find ('chord') == None)
    dur1 -= sum (int (b.text) for b in m1.findall ('backup/duration'))
    repbar, nns, es = None, 0, []  # nns = number of real notes in m2
    for e in list (m2): # scan all elements of m2
        if e.tag == 'attributes':
            if not is_grand: continue # no attribute merging for normal voices
            else: nns += 1      # but we do merge (clef) attributes for a grand staff
        if e.tag == 'print': continue
        if e.tag == 'note' and (rOpt or e.find ('rest') == None): nns += 1
        if e.tag == 'barline' and e.find ('repeat') != None: repbar = e;
        es.append (e)           # buffer elements to be merged
    if nns > 0:                 # only merge if m2 contains any real notes
        if dur1 > 0:            # only insert backup if duration of m1 > 0
            b = E.Element ('backup')
            addElem (m1, b, level=3)
            addElemT (b, 'duration', str (dur1), level=4)
        for e in es: addElem (m1, e, level=3)   # merge buffered elements of m2
    elif is_overlay and repbar != None: addElem (m1, repbar, level=3)   # merge repeat in empty overlay

def mergePartList (parts, rOpt, is_grand=0):    # merge parts, make grand staff when is_grand true

    def delAttrs (part):                # for the time being we only keep clef attributes
        xs = [(m, e) for m in part.findall ('measure') for e in m.findall ('attributes')]
        for m, e in xs:
            for c in list (e):
                if c.tag == 'clef': continue    # keep clef attribute
                if c.tag == 'staff-details': continue    # keep staff-details attribute
                e.remove (c)                    # delete all other attrinutes for higher staff numbers
            if len (list (e)) == 0: m.remove (e)    # remove empty attributes element

    p1 = parts[0]
    for p2 in parts[1:]:
        if is_grand: delAttrs (p2)                          # delete all attributes except clef
        for i in range (len (p1) + 1, len (p2) + 1):        # second part longer than first one
            maat = E.Element ('measure', number = str(i))   # append empty measures
            addElem (p1, maat, 2)
        slurs = p1.findall ('measure/note/notations/slur')  # find highest slur num in first part
        slur_max = max ([int (slr.get ('number')) for slr in slurs] + [0])
        vs = p1.findall ('measure/note/voice')              # all voice number elements in first part
        vnum_max = max ([int (v.text) for v in vs] + [0])   # highest voice number in first part
        for im, m2 in enumerate (p2.findall ('measure')):   # merge all measures of p2 into p1
            mergeMeasure (p1[im], m2, slur_max, vnum_max, rOpt, is_grand) # may change slur numbers in p1
    return p1

def mergeParts (parts, vids, staves, rOpt, is_grand=0):
    if not staves: return parts, vids   # no voice mapping
    partsnew, vidsnew = [], []
    for voice_ids in staves:
        pixs = []
        for vid in voice_ids:
            if vid in vids: pixs.append (vids.index (vid))
            else: info ('score partname %s does not exist' % vid)
        if pixs:
            xparts = [parts[pix] for pix in pixs]
            if len (xparts) > 1: mergedpart = mergePartList (xparts, rOpt, is_grand)
            else:                mergedpart = xparts [0]
            partsnew.append (mergedpart)
            vidsnew.append (vids [pixs[0]])
    return partsnew, vidsnew

def mergePartMeasure (part, msre, ovrlaynum, rOpt): # merge msre into last measure of part, only for overlays
    slur_offset = 0;    # slur numbers determined by the slurstack size (as in a single voice)
    last_msre = list (part)[-1] # last measure in part
    mergeMeasure (last_msre, msre, slur_offset, ovrlaynum, rOpt, is_overlay=1) # voice offset = s.overlayVNum

def pushSlur (boogStapel, stem):
    if stem not in boogStapel: boogStapel [stem] = [] # initialize slurstack for stem
    boognum = sum (map (len, boogStapel.values ())) + 1  # number of open slurs in all (overlay) voices
    boogStapel [stem].append (boognum)
    return boognum

def setFristVoiceNameFromGroup (vids, vdefs): # vids = [vid], vdef = {vid -> (name, subname, voicedef)}
    vids = [v for v in vids if v in vdefs]  # only consider defined voices
    if not vids: return vdefs
    vid0 = vids [0]                         # first vid of the group
    _, _, vdef0 = vdefs [vid0]              # keep de voice definition (vdef0) when renaming vid0
    for vid in vids:
        nm, snm, vdef = vdefs [vid]
        if nm:                              # first non empty name encountered will become
            vdefs [vid0] = nm, snm, vdef0   # name of merged group == name of first voice in group (vid0)
            break
    return vdefs

def mkGrand (p, vdefs):             # transform parse subtree into list needed for s.grands
    xs = []
    for i, x in enumerate (p.objs): # changing p.objs [i] alters the tree. changing x has no effect on the tree.
        if type (x) == pObj:
            us = mkGrand (x, vdefs) # first get transformation results of current pObj
            if x.name == 'grand':   # x.objs contains ordered list of nested parse results within x
                vids = [y.objs[0] for y in x.objs[1:]]  # the voice ids in the grand staff
                nms = [vdefs [u][0] for u in vids if u in vdefs] # the names of those voices
                accept = sum ([1 for nm in nms if nm]) == 1 # accept as grand staff when only one of the voices has a name
                if accept or us[0] == '{*':
                    xs.append (us[1:])      # append voice ids as a list (discard first item '{' or '{*')
                    vdefs = setFristVoiceNameFromGroup (vids, vdefs)
                    p.objs [i] = x.objs[1]  # replace voices by first one in the grand group (this modifies the parse tree)
                else:
                    xs.extend (us[1:])      # extend current result with all voice ids of rejected grand staff
            else: xs.extend (us)    # extend current result with transformed pObj
        else: xs.append (p.t[0])    # append the non pObj (== voice id string)
    return xs

def mkStaves (p, vdefs):            # transform parse tree into list needed for s.staves
    xs = []
    for i, x in enumerate (p.objs): # structure and comments identical to mkGrand
        if type (x) == pObj:
            us = mkStaves (x, vdefs)
            if x.name == 'voicegr':
                xs.append (us)
                vids = [y.objs[0] for y in x.objs]
                vdefs = setFristVoiceNameFromGroup (vids, vdefs)
                p.objs [i] = x.objs[0]
            else:
                xs.extend (us)
        else:
            if p.t[0] not in '{*':  xs.append (p.t[0])
    return xs

def mkGroups (p):                   # transform parse tree into list needed for s.groups
    xs = []
    for x in p.objs:
        if type (x) == pObj:
            if x.name == 'vid': xs.extend (mkGroups (x))
            elif x.name == 'bracketgr': xs.extend (['['] + mkGroups (x) + [']'])
            elif x.name == 'bracegr':   xs.extend (['{'] + mkGroups (x) + ['}'])
            else: xs.extend (mkGroups (x) + ['}'])  # x.name == 'grand' == rejected grand staff
        else:
            xs.append (p.t[0])
    return xs

def stepTrans (step, soct, clef):   # [A-G] (1...8)
    if clef.startswith ('bass'):
        nm7 = 'C,D,E,F,G,A,B'.split (',')
        n = 14 + nm7.index (step) - 12  # two octaves extra to avoid negative numbers
        step, soct = nm7 [n % 7], soct + n // 7 - 2  # subtract two octaves again
    return step, soct

def reduceMids (parts, vidsnew, midiInst):       # remove redundant instruments from a part
    for pid, part in zip (vidsnew, parts):
        mids, repls, has_perc = {}, {}, 0
        for ipid, ivid, ch, prg, vol, pan in sorted (list (midiInst.values ())):
            if ipid != pid: continue                # only instruments from part pid
            if ch == '10': has_perc = 1; continue   # only consider non percussion instruments
            instId, inst = 'I%s-%s' % (ipid, ivid), (ch, prg)
            if inst in mids:                        # midi instrument already defined in this part
                repls [instId]  = mids [inst]       # remember to replace instId by inst (see below)
                del midiInst [instId]               # instId is redundant
            else: mids [inst] = instId              # collect unique instruments in this part
        if len (mids) < 2 and not has_perc:         # only one instrument used -> no instrument tags needed in notes
            removeElems (part, 'measure/note', 'instrument')    # no instrument tag needed for one- or no-instrument parts
        else:
            for e in part.findall ('measure/note/instrument'):
                id = e.get ('id')                   # replace all redundant instrument Id's
                if id in repls: e.set ('id', repls [id])

def scanEdo (abctxt):
    ri = re.findall (r'[_^](\d)[a-gA-G]', abctxt)
    rf = re.findall (r'[_^](\d+/\d+)[a-gA-G]', abctxt)
    t = 53 if len (ri + rf) > 0 else 12
    return t

class stringAlloc:
    def __init__ (s):
        s.snaarVrij = []    # [[(t1, t2) ...] for each string ]
        s.snaarIx = []      # index in snaarVrij for each string
        s.curstaff = -1     # staff being allocated
    def beginZoek (s):      # reset snaarIx at start of each voice
        s.snaarIx = []
        for i in range (len (s.snaarVrij)): s.snaarIx.append (0)
    def setlines (s, stflines, stfnum):
        if stfnum != s.curstaff:    # initialize for new staff
            s.curstaff = stfnum
            s.snaarVrij = []
            for i in range (stflines): s.snaarVrij.append ([])
            s.beginZoek ()
    def isVrij (s, snaar, t1, t2):  # see if string snaar is free between t1 and t2
        xs = s.snaarVrij [snaar]
        for i in range (s.snaarIx [snaar], len (xs)):
            tb, te = xs [i]
            if t1 >= te: continue   # te_prev < t1 <= te
            if t1 >= tb: s.snaarIx [snaar] = i; return 0    # tb <= t1 < te
            if t2 > tb: s.snaarIx [snaar] = i; return 0     # t1 < tb < t2
            s.snaarIx [snaar] = i;  # remember position for next call
            xs.insert (i, (t1,t2))  # te_prev < t1 < t2 < tb
            return 1
        xs.append ((t1,t2))
        s.snaarIx [snaar] = len (xs) - 1
        return 1
    def bezet (s, snaar, t1, t2):   # force allocation of note (t1,t2) on string snaar
        xs = s.snaarVrij [snaar]
        for i, (tb, te) in enumerate (xs):
            if t1 >= te: continue   # te_prev < t1 <= te
            xs.insert (i, (t1, t2))
            return
        xs.append ((t1,t2))

class MusicXml:
    typeMap = {1:'long', 2:'breve', 4:'whole', 8:'half', 16:'quarter', 32:'eighth', 64:'16th', 128:'32nd', 256:'64th'}
    dynaMap = {'p':1,'pp':1,'ppp':1,'pppp':1,'ppppp':1,'pppppp':1,'f':1,'ff':1,'fff':1,'ffff':1,'fffff':1,'ffffff':1,'mp':1,'mf':1, 'sf':1, 'sfp':1, 'sfpp':1, 'fp':1, 'rf':1, 'rfz':1, 'sfz':1, 'sffz':1, 'fz':1, 'pf':1, 'sfzp':1}
    tempoMap = {'larghissimo':40, 'moderato':104, 'adagissimo':44, 'allegretto':112, 'lentissimo':48, 'allegro':120, 'largo':56,
            'vivace':168, 'adagio':59, 'vivo':180, 'lento':62, 'presto':192, 'larghetto':66, 'allegrissimo':208, 'adagietto':76,
            'vivacissimo':220, 'andante':88, 'prestissimo':240, 'andantino':96}
    wedgeMap = {'>(':1, '>)':1, '<(':1,'<)':1,'crescendo(':1,'crescendo)':1,'diminuendo(':1,'diminuendo)':1}
    artMap = {'.':'staccato','>':'accent','accent':'accent','wedge':'staccatissimo','tenuto':'tenuto',
              'breath':'breath-mark','marcato':'strong-accent','^':'strong-accent','slide':'scoop'}
    ornMap = {'trill':'trill-mark','T':'trill-mark','turn':'turn','uppermordent':'inverted-mordent','lowermordent':'mordent',
              'pralltriller':'inverted-mordent','mordent':'mordent','turn':'turn','invertedturn':'inverted-turn'}
    tecMap = {'upbow':'up-bow', 'downbow':'down-bow', 'plus':'stopped','open':'open-string','snap':'snap-pizzicato',
              'thumb':'thumb-position'}
    capoMap = {'fine':('Fine','fine','yes'), 'D.S.':('D.S.','dalsegno','segno'), 'D.C.':('D.C.','dacapo','yes'),'dacapo':('D.C.','dacapo','yes'),
               'dacoda':('To Coda','tocoda','coda'), 'coda':('coda','coda','coda'), 'segno':('segno','segno','segno')}
    sharpness = ['Fb', 'Cb','Gb','Db','Ab','Eb','Bb','F','C','G','D','A', 'E', 'B', 'F#','C#','G#','D#','A#','E#','B#']
    offTab = {'maj':8, 'm':11, 'min':11, 'mix':9, 'dor':10, 'phr':12, 'lyd':7, 'loc':13}
    modTab = {'maj':'major', 'm':'minor', 'min':'minor', 'mix':'mixolydian', 'dor':'dorian', 'phr':'phrygian', 'lyd':'lydian', 'loc':'locrian'}
    clefMap = { 'alto1':('C','1'), 'alto2':('C','2'), 'alto':('C','3'), 'alto4':('C','4'), 'tenor':('C','4'),
                'bass3':('F','3'), 'bass':('F','4'), 'treble':('G','2'), 'perc':('percussion',''), 'none':('',''), 'tab':('TAB','5')}
    clefLineMap = {'B':'treble', 'G':'alto1', 'E':'alto2', 'C':'alto', 'A':'tenor', 'F':'bass3', 'D':'bass'}
    accTab = {12: {'=':'natural', '_':'flat', '__':'flat-flat', '^':'sharp', '^^':'sharp-sharp'},
        53: {'_1':'quarter-flat', '_2':'flat-2', '_3':'flat-3', '_4':'slash-flat', '_5':'flat',
             '_8':'double-slash-flat', '_9':'flat-flat', '^1':'quarter-sharp', '^2':'sharp-2',
             '^3':'sharp-3', '^4':'sharp','^5':'slash-quarter-sharp', '^8':'slash-sharp', '^9':'sharp-sharp'},
        36: {'_1':'natural-down', '_2':'flat-up', '_3':'flat', '_4':'flat-down', '=':'natural',
             '^1':'natural-up', '^2':'sharp-down', '_^3':'sharp', '^4':'sharp-up'}}
    chordTab = compChordTab ()
    uSyms = {'~':'roll', 'H':'fermata','L':'>','M':'lowermordent','O':'coda',
             'P':'uppermordent','S':'segno','T':'trill','u':'upbow','v':'downbow'}
    pageFmtDef = [0.75,297,210,18,18,10,10] # the abcm2ps page formatting defaults for A4
    metaTab = {'O':'origin', 'A':'area', 'Z':'transcription', 'N':'notes', 'G':'group', 'H':'history', 'R':'rhythm',
                'B':'book', 'D':'discography', 'F':'fileurl', 'S':'source', 'P':'partmap', 'W':'lyrics'}
    metaMap = {'C':'composer'}  # mapping of composer is fixed
    metaTypes = {'composer':1,'lyricist':1,'poet':1,'arranger':1,'translator':1, 'rights':1} # valid MusicXML meta data types
    tuningDef = 'E2,A2,D3,G3,B3,E4'.split (',') # default string tuning (guitar)
    inst_tb = ["acoustic_grand_piano", "bright_acoustic_piano", "electric_grand_piano",
        "honkytonk_piano", "electric_piano_1", "electric_piano_2", "harpsichord", "clavinet", "celesta",
        "glockenspiel", "music_box", "vibraphone", "marimba", "xylophone", "tubular_bells", "dulcimer",
        "drawbar_organ", "percussive_organ", "rock_organ", "church_organ", "reed_organ", "accordion",
        "harmonica", "tango_accordion", "acoustic_guitar_nylon", "acoustic_guitar_steel",
        "electric_guitar_jazz", "electric_guitar_clean", "electric_guitar_muted", "overdriven_guitar",
        "distortion_guitar", "guitar_harmonics", "acoustic_bass", "electric_bass_finger",
        "electric_bass_pick", "fretless_bass", "slap_bass_1", "slap_bass_2", "synth_bass_1",
        "synth_bass_2", "violin", "viola", "cello", "contrabass", "tremolo_strings", "pizzicato_strings",
        "orchestral_harp", "timpani", "string_ensemble_1", "string_ensemble_2", "synth_strings_1",
        "synth_strings_2", "choir_aahs", "voice_oohs", "synth_choir", "orchestra_hit", "trumpet",
        "trombone", "tuba", "muted_trumpet", "french_horn", "brass_section", "synth_brass_1",
        "synth_brass_2", "soprano_sax", "alto_sax", "tenor_sax", "baritone_sax", "oboe", "english_horn",
        "bassoon", "clarinet", "piccolo", "flute", "recorder", "pan_flute", "blown_bottle", "shakuhachi",
        "whistle", "ocarina", "lead_1_square", "lead_2_sawtooth", "lead_3_calliope", "lead_4_chiff",
        "lead_5_charang", "lead_6_voice", "lead_7_fifths", "lead_8_bass__lead", "pad_1_new_age",
        "pad_2_warm", "pad_3_polysynth", "pad_4_choir", "pad_5_bowed", "pad_6_metallic", "pad_7_halo",
        "pad_8_sweep", "fx_1_rain", "fx_2_soundtrack", "fx_3_crystal", "fx_4_atmosphere",
        "fx_5_brightness", "fx_6_goblins", "fx_7_echoes", "fx_8_scifi", "sitar", "banjo", "shamisen",
        "koto", "kalimba", "bagpipe", "fiddle", "shanai", "tinkle_bell", "agogo", "steel_drums",
        "woodblock", "taiko_drum", "melodic_tom", "synth_drum", "reverse_cymbal", "guitar_fret_noise",
        "breath_noise", "seashore", "bird_tweet", "telephone_ring", "helicopter", "applause","gunshot"]
    perc_tb = ["high_q", "slap", "scratch_push", "scratch_pull", "sticks", "square_click", "metronome_click",
        "metronome_bell", "bass_drum_2", "bass_drum_1", "side_stick", "snare_drum_1", "hand_clap",
        "snare_drum_2", "low_tom_2", "closed_hi-hat", "low_tom_1", "pedal_hi-hat", "mid_tom_2",
        "open_hi-hat", "mid_tom_1", "high_tom_2", "crash_cymbal_1", "high_tom_1", "ride_cymbal_1",
        "chinese_cymbal", "ride_bell", "tambourine", "splash_cymbal", "cowbell", "crash_cymbal_2",
        "vibra_slap", "ride_cymbal_2", "high_bongo", "low_bongo", "mute_high_conga", "open_high_conga",
        "low_conga", "high_timbale", "low_timbale", "high_agogo", "low_agogo", "cabasa", "maracas",
        "short_whistle", "long_whistle", "short_guiro", "long_guiro", "claves", "high_wood_block",
        "low_wood_block", "mute_cuica", "open_cuica", "mute_triangle", "open_triangle", "shaker",
        "jingle_bell", "belltree", "castanets", "mute_surdo", "open_surdo"]

    def __init__ (s):
        s.pageFmtCmd = []   # set by command line option -p
        s.reset ()
    def reset (s, fOpt=False, mOpt=False):
        s.divisions = 2520  # xml duration of 1/4 note, 2^3 * 3^2 * 5 * 7 => 5,7,9 tuplets
        s.ties = {}         # {abc pitch tuple -> alteration} for all open ties
        s.slurstack = {}    # stack of open slur numbers per (overlay) voice
        s.slurbeg = []      # type of slurs to start (when slurs are detected at element-level)
        s.tmnum = 0         # time modification, numerator
        s.tmden = 0         # time modification, denominator
        s.ntup = 0          # number of tuplet notes remaining
        s.trem = 0          # number of bars for tremolo
        s.intrem = 0        # mark tremolo sequence (for duration doubling)
        s.tupnts = []       # all tuplet modifiers with corresp. durations: [(duration, modifier), ...]
        s.irrtup = 0        # 1 if an irregular tuplet
        s.ntype = ''        # the normal-type of a tuplet (== duration type of a normal tuplet note)
        s.unitL =  (1, 8)   # default unit length
        s.unitLcur = (1, 8) # unit length of current voice
        s.keyAlts = {}      # alterations implied by key
        s.msreAlts = {}     # temporarily alterations
        s.curVolta = ''     # open volta bracket
        s.title = ''        # title of music
        s.creator = {}      # {creator-type -> creator string}
        s.metadata = {}     # {metadata-type -> string}
        s.lyrdash = {}      # {lyric number -> 1 if dash between syllables}
        s.usrSyms = s.uSyms # user defined symbols
        s.prevNote = [None, None]   # xml element of previous beamed note to correct beams (start, continue)
        s.prevLyric = {}    # xml element of previous lyric to add/correct extend type (start, continue)
        s.grcbrk = False    # remember beambreak before grace sequence
        s.linebrk = 0       # 1 if next measure should start with a line break
        s.nextdecos = []    # decorations for the next note
        s.prevmsre = None   # the previous measure
        s.supports_tag = 0  # issue supports-tag in xml file when abc uses explicit linebreaks
        s.staveDefs = []    # collected %%staves or %%score instructions from score
        s.staves = []       # staves = [[voice names to be merged into one stave]]
        s.groups = []       # list of merged part names with interspersed {[ and }]
        s.grands = []       # [[vid1, vid2, ..], ...] voiceIds to be merged in a grand staff
        s.gStaffNums = {}   # map each voice id in a grand staff to a staff number
        s.gNstaves = {}     # map each voice id in a grand staff to total number of staves
        s.pageFmtAbc = []   # formatting from abc directives
        s.mdur = (4,4)      # duration of one measure
        s.gtrans = 0        # octave transposition (by clef)
        s.midprg = ['', '', '', ''] # MIDI channel nr, program nr, volume, panning for the current part
        s.nid = ''          # current ABC note for error messages
        s.vid = ''          # abc voice id for the current voice
        s.pid = ''          # xml part id for the current voice
        s.gcue_on = 0       # insert <cue/> tag in each note
        s.percVoice = 0     # 1 if percussion enabled
        s.percMap = {}      # (part-id, abc_pitch, xml-octave) -> (abc staff step, midi note number, xml notehead)
        s.pMapFound = 0     # at least one I:percmap has been found
        s.vcepid = {}       # voice_id -> part_id
        s.midiInst = {}     # inst_id -> (part_id, voice_id, channel, midi_number), remember instruments used
        s.capo = 0          # fret position of the capodastro
        s.tunmid = []       # midi numbers of strings
        s.tunTup = []       # ordered midi numbers of strings [(midi_num, string_num), ...] (midi_num from high to low)
        s.fOpt = fOpt       # force string/fret allocations for tab staves
        s.orderChords = 0   # order notes in a chord
        s.chordDecos = {}   # decos that should be distributed to all chord notes for xml
        ch10 = 'acoustic-bass-drum,35;bass-drum-1,36;side-stick,37;acoustic-snare,38;hand-clap,39;electric-snare,40;low-floor-tom,41;closed-hi-hat,42;high-floor-tom,43;pedal-hi-hat,44;low-tom,45;open-hi-hat,46;low-mid-tom,47;hi-mid-tom,48;crash-cymbal-1,49;high-tom,50;ride-cymbal-1,51;chinese-cymbal,52;ride-bell,53;tambourine,54;splash-cymbal,55;cowbell,56;crash-cymbal-2,57;vibraslap,58;ride-cymbal-2,59;hi-bongo,60;low-bongo,61;mute-hi-conga,62;open-hi-conga,63;low-conga,64;high-timbale,65;low-timbale,66;high-agogo,67;low-agogo,68;cabasa,69;maracas,70;short-whistle,71;long-whistle,72;short-guiro,73;long-guiro,74;claves,75;hi-wood-block,76;low-wood-block,77;mute-cuica,78;open-cuica,79;mute-triangle,80;open-triangle,81'
        s.percsnd = [x.split (',') for x in ch10.split (';')]   # {name -> midi number} of standard channel 10 sound names
        s.gTime = (0,0)     # (XML begin time, XML end time) in divisions
        s.tabStaff = ''     # == pid (part ID) for a tab staff
        s.edo = 12          # tuning
        s.mus53 = mOpt      # musescore playable edo53

    def getAlter (s, acc):
        regacc = {'=':'0', '_':'-1', '__':'-2', '^':'1', '^^':'2'}
        reg53 = {'_9':'-2', '_5':'-1', '^4':'1', '^9':'2'}
        if acc == '': return ''
        if acc in regacc: return regacc [acc]
        if s.edo == 53 and acc in reg53: return reg53 [acc]
        edo = 36 if acc.endswith ('u') else s.edo
        acc = acc.replace ('u','')
        teken = -1 if acc[0] == '_' else 1
        n = teken * int (acc[1:]) * 12 / edo
        return str (round (n, 3))

    def getAcc (s, acc):
        edo = 36 if acc.endswith ('u') else s.edo
        acc = acc.replace ('u','')
        if acc in s.accTab [edo]: return s.accTab [edo][acc]
        if acc in s.accTab [12]: return s.accTab [12][acc]
        info ('error: unknown accidental %s in note: %s voice: %s, part: %s' % (acc, s.nid, s.vid, s.pid))
        return 'natural'

    def decTupAcc (s, tupacc):
        acc, fraq = tupacc  # fraq = 'n' or 'n_m'
        if acc in ['__','^^']:
            info ('error: a fractional suffix (%s) is ignored after %s, note: %s, voice %s, part %s' % (fraq, acc, s.nid, s.vid, s.pid))
        elif '_' in fraq:
            n, m = map (int, fraq.split ('_'))
            n, m = simplify (n, m)
            if   m == 53: acc = acc + str (n // 12)
            elif m == 3: acc = acc + str (n) + 'u' # markeer als up/down
            elif n == 1 and m == 1: pass
            elif n == 1 and m == 2: acc = acc + str (n)
            else:
                info ('accidental %s%d/%d not supported, note: %s, voice %s, part %s' % (acc, n, m, s.nid, s.vid, s.pid))
        else:
            acc = acc + fraq
        return acc

    def mkPitch (s, acc, note, oct, lev):
        if s.percVoice: # percussion map switched off by perc=off (see doClef)
            octq = int (oct) + s.gtrans     # honour the octave= transposition when querying percmap
            tup = s.percMap.get ((s.pid, acc+note, octq), s.percMap.get (('', acc+note, octq), 0))
            if tup: step, soct, midi, notehead = tup
            else: step, soct = note, octq
            octnum = (4 if step.upper() == step else 5) + int (soct)
            if not tup: # add percussion map for unmapped notes in this part
                midi = str (octnum * 12 + [0,2,4,5,7,9,11]['CDEFGAB'.index (step.upper())] + {'^':1,'_':-1}.get (acc, 0) + 12)
                notehead = {'^':'x', '_':'circle-x'}.get (acc, 'normal')
                if s.pMapFound: info ('no I:percmap for: %s%s in part %s, voice %s' % (acc+note, -oct*',' if oct<0 else oct*"'", s.pid, s.vid))
                s.percMap [(s.pid, acc+note, octq)] =  (note, octq, midi, notehead)
            else:       # correct step value for clef
                step, octnum = stepTrans (step.upper (), octnum, s.curClef)
            pitch = E.Element ('unpitched')
            addElemT (pitch, 'display-step', step.upper (), lev + 1)
            addElemT (pitch, 'display-octave', str (octnum), lev + 1)
            return pitch, '', midi, notehead, acc
        nUp = note.upper ()
        octnum = (4 if nUp == note else 5) + int (oct) + s.gtrans
        pitch = E.Element ('pitch')
        addElemT (pitch, 'step', nUp, lev + 1)
        alter = ''
        if (note, oct) in s.ties:
            tied_alter, _, vnum, _ = s.ties [(note,oct)]    # vnum = overlay voice number when tie started
            if vnum == s.overlayVnum: alter = tied_alter    # tied note in the same overlay -> same alteration
        else:
            if acc: s.msreAlts [(nUp, octnum)] = acc    # explicit notated alteration
            elif (nUp, octnum) in s.msreAlts:   acc = s.msreAlts [(nUp, octnum)]  # temporary alteration
            elif nUp in s.keyAlts:              acc = s.keyAlts [nUp] # alteration implied by the key
            alter = s.getAlter (acc)                    # acc from notation, key or current alteration
        if alter: addElemT (pitch, 'alter', alter, lev + 1)
        addElemT (pitch, 'octave', str (octnum), lev + 1)
        return pitch, alter, '', '', acc

    def getNoteDecos (s, n):
        decos = s.nextdecos             # decorations encountered so far
        ndeco = getattr (n, 'deco', 0)  # possible decorations of notes of a chord
        if ndeco:                       # add decorations, translate used defined symbols
            decos += [s.usrSyms.get (d, d).strip ('!+') for d in ndeco.t]
        s.nextdecos = []
        if s.tabStaff == s.pid and s.fOpt and n.name != 'rest':  # force fret/string allocation if explicit string decoration is missing
            if [d for d in decos if d in '0123456789'] == []: decos.append ('0')
        return decos

    def mkNote (s, n, lev):
        isgrace = getattr (n, 'grace', 0)
        ischord = getattr (n, 'chord', '')
        if s.ntup >= 0 and not isgrace and not ischord:
            s.ntup -= 1                 # count tuplet notes only on non-chord, non grace notes
            if s.ntup == -1 and s.trem <= 0:
                s.intrem = 0            # tremolo pair ends at first note that is not a new tremolo pair (s.trem > 0)
        nnum, nden = n.dur.t            # abc dutation of note
        if s.intrem: nnum += nnum       # double duration of tremolo duplets
        if nden == 0: nden = 1          # occurs with illegal ABC like: "A2 1". Now interpreted as A2/1
        num, den = simplify (nnum * s.unitLcur[0], nden * s.unitLcur[1])  # normalised with unit length
        if isgrace > 0:
            unitNum, unitDen = (1, 16) if isgrace > 1 else (1, 8)   # in ABC grace notes have fixed unit length
            num, den = simplify (nnum * unitNum, nden * unitDen)
        if den > 64:    # limit denominator to 64
            num = int (round (64 * float (num) / den))  # scale note to num/64
            num, den  = simplify (max ([num, 1]), 64)   # smallest num == 1
            info ('duration too small: rounded to %d/%d' % (num, den))
        if n.name == 'rest' and ('Z' in n.t or 'X' in n.t):
              num, den = s.mdur         # duration of one measure
        noMsrRest = not (n.name == 'rest' and (num, den) == s.mdur) # not a measure rest
        dvs = (4 * s.divisions * num) // den    # divisions is xml-duration of 1/4
        rdvs = dvs                      # real duration (will be 0 for chord/grace)
        num, den = simplify (num, den * 4)      # scale by 1/4 for s.typeMap
        ndot = 0
        if num == 3 and noMsrRest: ndot = 1; den = den // 2 # look for dotted notes
        if num == 7 and noMsrRest: ndot = 2; den = den // 4
        nt = E.Element ('note')
        if isgrace > 0:                 # a grace note (and possibly a chord note)
            grace = E.Element ('grace')
            if s.acciatura: grace.set ('slash', 'yes'); s.acciatura = 0
            addElem (nt, grace, lev + 1)
            dvs = rdvs = 0              # no (real) duration for a grace note
        if s.gcue_on:                   # insert cue tag
            cue = E.Element ('cue')
            addElem (nt, cue, lev + 1)
        if ischord:                     # a chord note
            chord = E.Element ('chord')
            addElem (nt, chord, lev + 1)
            rdvs = 0                    # chord notes no real duration
        if den not in s.typeMap:        # take the nearest smaller legal duration
            info ('illegal duration %d/%d' % (nnum, nden))
            den = min (x for x in s.typeMap.keys () if x > den)
        xmltype = str (s.typeMap [den]) # xml needs the note type in addition to duration
        acc, step, oct = '', 'C', '0'   # abc-notated pitch elements (accidental, pitch step, octave)
        alter, midi, notehead = '', '', ''      # xml alteration
        if n.name == 'rest':
            if 'x' in n.t or 'X' in n.t: nt.set ('print-object', 'no')
            rest = E.Element ('rest')
            if not noMsrRest: rest.set ('measure', 'yes')
            addElem (nt, rest, lev + 1)
        else:
            p = n.pitch.t           # get pitch elements from parsed tokens
            if len (p) == 3:    acc, step, oct = p
            else:               step, oct = p
            s.nid = acc[0] + acc [1] if type (acc) == tuple_type else acc
            s.nid += step + (-oct*',' if oct<0 else oct*"'")        # current ABC note for error messages
            if type (acc) == tuple_type: acc = s.decTupAcc (acc)    # microtonal accidentals
            pitch, alter, midi, notehead, acc53 = s.mkPitch (acc, step, oct, lev + 1)
            if midi: acc = ''       # erase accidental for percussion notes
            addElem (nt, pitch, lev + 1)
            if s.mus53 and '.' in alter: acc = acc53    # force accidentals everywhere!
        if s.ntup >= 0:                 # modify duration for tuplet notes
            dvs = dvs * s.tmden // s.tmnum
        if dvs:
            addElemT (nt, 'duration', str (dvs), lev + 1)   # skip when dvs == 0, requirement of musicXML
            if not ischord: s.gTime = s.gTime [1], s.gTime [1] + dvs
        ptup = (step, oct)              # pitch tuple without alteration to check for ties
        tstop = ptup in s.ties and s.ties[ptup][2] == s.overlayVnum  # open tie on this pitch tuple in this overlay
        if tstop:
            tie = E.Element ('tie', type='stop')
            addElem (nt, tie, lev + 1)
        if getattr (n, 'tie', 0):
            tie = E.Element ('tie', type='start')
            addElem (nt, tie, lev + 1)
        if (s.midprg != ['', '', '', ''] or midi) and n.name != 'rest': # only add when %%midi was present or percussion
            instId = 'I%s-%s' % (s.pid, 'X' + midi if midi else s.vid)
            chan, midi = ('10', midi) if midi else s.midprg [:2]
            inst = E.Element ('instrument', id=instId)  # instrument id for midi
            addElem (nt, inst, lev + 1)
            if instId not in s.midiInst: s.midiInst [instId] = (s.pid, s.vid, chan, midi, s.midprg [2], s.midprg [3]) # for instrument list in mkScorePart
        addElemT (nt, 'voice', '1', lev + 1)    # default voice, for merging later
        if noMsrRest: addElemT (nt, 'type', xmltype, lev + 1) # add note type if not a measure rest
        for i in range (ndot):          # add dots
            dot = E.Element ('dot')
            addElem (nt, dot, lev + 1)
        decos = s.getNoteDecos (n)      # get decorations for this note
        if acc and not tstop:           # only add accidental if note not tied
            e = E.Element ('accidental')
            if 'courtesy' in decos:
                e.set ('parentheses', 'yes')
                decos.remove ('courtesy')
            e.text = s.getAcc (acc)
            addElem (nt, e, lev + 1)
        tupnotation = ''                # start/stop notation element for tuplets
        if s.ntup >= 0:                 # add time modification element for tuplet notes
            tmod = mkTmod (s.tmnum, s.tmden, lev + 1)
            addElem (nt, tmod, lev + 1)
            if s.ntup > 0 and not s.tupnts: tupnotation = 'start'
            s.tupnts.append ((rdvs, tmod))      # remember all tuplet modifiers with corresp. durations
            if s.ntup == 0:             # last tuplet note (and possible chord notes there after)
                if rdvs: tupnotation = 'stop'   # only insert notation in the real note (rdvs > 0)
                s.cmpNormType (rdvs, lev + 1)   # compute and/or add normal-type elements (-> s.ntype)
        hasStem = 1
        if not ischord: s.chordDecos = {}       # clear on non chord note
        if 'stemless' in decos or (s.nostems and n.name != 'rest') or 'stemless' in s.chordDecos:
            hasStem = 0
            addElemT (nt, 'stem', 'none', lev + 1)
            if 'stemless' in decos: decos.remove ('stemless')   # do not handle in doNotations
            if hasattr (n, 'pitches'): s.chordDecos ['stemless'] = 1    # set on first chord note
        if notehead:
            nh = addElemT (nt, 'notehead', re.sub (r'[+-]$', '', notehead), lev + 1)
            if notehead[-1] in '+-': nh.set ('filled', 'yes' if notehead[-1] == '+' else 'no')
        gstaff = s.gStaffNums.get (s.vid, 0)    # staff number of the current voice
        if gstaff: addElemT (nt, 'staff', str (gstaff), lev + 1)
        if hasStem: s.doBeams (n, nt, den, lev + 1)   # no stems -> no beams in a tab staff
        s.doNotations (n, decos, ptup, alter, tupnotation, tstop, nt, lev + 1)
        if n.objs: s.doLyr (n, nt, lev + 1)
        else: s.prevLyric = {}   # clear on note without lyrics
        return nt

    def cmpNormType (s, rdvs, lev): # compute the normal-type of a tuplet (only needed for Finale)
        if rdvs:    # the last real tuplet note (chord notes can still follow afterwards with rdvs == 0)
            durs = [dur for dur, tmod in s.tupnts if dur > 0]
            ndur = sum (durs) // s.tmnum    # duration of the normal type
            s.irrtup = any ((dur != ndur) for dur in durs)  # irregular tuplet
            tix = 16 * s.divisions // ndur  # index in typeMap of normal-type duration
            if tix in s.typeMap:
                s.ntype = str (s.typeMap [tix]) # the normal-type
            else: s.irrtup = 0          # give up, no normal type possible
        if s.irrtup:                    # only add normal-type for irregular tuplets
            for dur, tmod in s.tupnts:  # add normal-type to all modifiers
                addElemT (tmod, 'normal-type', s.ntype, lev + 1)
        s.tupnts = []                   # reset the tuplet buffer

    def doNotations (s, n, decos, ptup, alter, tupnotation, tstop, nt, lev):
        slurs = getattr (n, 'slurs', 0) # slur ends
        pts = getattr (n, 'pitches', [])            # all chord notes available in the first note
        ov = s.overlayVnum                          # current overlay voice number (0 for the main voice)
        if pts:                                     # make list of pitches in chord: [(pitch, octave), ..]
            if type (pts.pitch) == pObj: pts = [pts.pitch]      # chord with one note
            else: pts = [tuple (p.t[-2:]) for p in pts.pitch]   # normal chord
        for pt, (tie_alter, nts, vnum, ntelm) in sorted (list (s.ties.items ())):  # scan all open ties and delete illegal ones
            if vnum != s.overlayVnum: continue      # tie belongs to different overlay
            if pts and pt in pts: continue          # pitch tuple of tie exists in chord
            if getattr (n, 'chord', 0): continue    # skip chord notes
            if pt == ptup: continue                 # skip correct single note tie
            if getattr (n, 'grace', 0): continue    # skip grace notes
            info ('tie between different pitches: %s%s converted to slur' % pt)
            del s.ties [pt]                         # remove the note from pending ties
            e = [t for t in ntelm.findall ('tie') if t.get ('type') == 'start'][0]  # get the tie start element
            ntelm.remove (e)                        # delete start tie element
            e = [t for t in nts.findall ('tied') if t.get ('type') == 'start'][0]   # get the tied start element
            e.tag = 'slur'                          # convert tie into slur
            slurnum = pushSlur (s.slurstack, ov)
            e.set ('number', str (slurnum))
            if slurs: slurs.t.append (')')          # close slur on this note
            else: slurs = pObj ('slurs', [')'])
        tstart = getattr (n, 'tie', 0)  # start a new tie
        if not (tstop or tstart or decos or slurs or s.slurbeg or tupnotation or s.trem): return nt
        nots = E.Element ('notations')  # notation element needed
        if s.trem:  # +/- => tuple tremolo sequence / single note tremolo
            if s.trem < 0: tupnotation = 'single'; s.trem = -s.trem
            if not tupnotation: return  # only add notation at first or last note of a tremolo sequence
            orn = E.Element ('ornaments')
            trm = E.Element ('tremolo', type=tupnotation)   # type = start, stop or single
            trm.text = str (s.trem)     # the number of bars in a tremolo note
            addElem (nots, orn, lev + 1)
            addElem (orn, trm, lev + 2)
            if tupnotation == 'stop' or tupnotation == 'single': s.trem = 0
        elif tupnotation:       # add tuplet type
            tup = E.Element ('tuplet', type=tupnotation)
            if tupnotation == 'start': tup.set ('bracket', 'yes')
            addElem (nots, tup, lev + 1)
        if tstop:               # stop tie
            del s.ties[ptup]    # remove flag
            tie = E.Element ('tied', type='stop')
            addElem (nots, tie, lev + 1)
        if tstart:              # start a tie
            s.ties[ptup] = (alter, nots, s.overlayVnum, nt) # remember pitch tuple to stop tie and apply same alteration
            tie = E.Element ('tied', type='start')
            if tstart.t[0] == '.-': tie.set ('line-type', 'dotted')
            addElem (nots, tie, lev + 1)
        if decos:               # look for slurs and decorations
            slurMap = { '(':1, '.(':1, '(,':1, "('":1, '.(,':1, ".('":1 }
            arts = []           # collect articulations
            for d in decos:     # do all slurs and decos
                if d in slurMap: s.slurbeg.append (d); continue # slurs made in while loop at the end
                elif d == 'fermata' or d == 'H':
                    ntn = E.Element ('fermata', type='upright')
                elif d == 'arpeggio':
                    ntn = E.Element ('arpeggiate', number='1')
                elif d in ['~(', '~)']:
                    if d[1] == '(': tp = 'start'; s.glisnum += 1; gn = s.glisnum
                    else:           tp = 'stop'; gn = s.glisnum; s.glisnum -= 1
                    if s.glisnum < 0: s.glisnum = 0; continue   # stop without previous start
                    ntn = E.Element ('glissando', {'line-type':'wavy', 'number':'%d' % gn, 'type':tp})
                elif d in ['-(', '-)']:
                    if d[1] == '(': tp = 'start'; s.slidenum += 1; gn = s.slidenum
                    else:           tp = 'stop'; gn = s.slidenum; s.slidenum -= 1
                    if s.slidenum < 0: s.slidenum = 0; continue   # stop without previous start
                    ntn = E.Element ('slide', {'line-type':'solid', 'number':'%d' % gn, 'type':tp})
                else: arts.append (d); continue
                addElem (nots, ntn, lev + 1)
            if arts:        # do only note articulations and collect staff annotations in xmldecos
                rest = s.doArticulations (nt, nots, arts, lev + 1)
                if rest: info ('unhandled note decorations: %s' % rest)
        if slurs:           # these are only slur endings
            for d in slurs.t:           # slurs to be closed on this note
                if not s.slurstack.get (ov, 0): break    # no more open old slurs for this (overlay) voice
                slurnum = s.slurstack [ov].pop ()
                slur = E.Element ('slur', number='%d' % slurnum, type='stop')
                addElem (nots, slur, lev + 1)
        while s.slurbeg:    # create slurs beginning on this note
            stp = s.slurbeg.pop (0)
            slurnum = pushSlur (s.slurstack, ov)
            ntn = E.Element ('slur', number='%d' % slurnum, type='start')
            if '.' in stp: ntn.set ('line-type', 'dotted')
            if ',' in stp: ntn.set ('placement', 'below')
            if "'" in stp: ntn.set ('placement', 'above')
            addElem (nots, ntn, lev + 1)
        if list (nots) != []:    # only add notations if not empty
            addElem (nt, nots, lev)

    def doArticulations (s, nt, nots, arts, lev):
        decos = []
        for a in arts:
            if a in s.artMap:
                art = E.Element ('articulations')
                addElem (nots, art, lev)
                addElem (art, E.Element (s.artMap[a]), lev + 1)
            elif a in s.ornMap:
                orn = E.Element ('ornaments')
                addElem (nots, orn, lev)
                addElem (orn, E.Element (s.ornMap[a]), lev + 1)
            elif a in ['trill(','trill)']:
                orn = E.Element ('ornaments')
                addElem (nots, orn, lev)
                type = 'start' if a.endswith ('(') else 'stop'
                if type == 'start': addElem (orn, E.Element ('trill-mark'), lev + 1)
                addElem (orn, E.Element ('wavy-line', type=type), lev + 1)
            elif a in s.tecMap:
                tec = E.Element ('technical')
                addElem (nots, tec, lev)
                addElem (tec, E.Element (s.tecMap[a]), lev + 1)
            elif a in '0123456':
                tec = E.Element ('technical')
                addElem (nots, tec, lev)
                if s.tabStaff == s.pid:             # current voice belongs to a tabStaff
                    alt = int (nt.findtext ('pitch/alter') or 0)    # find midi number of current note
                    step = nt.findtext ('pitch/step')
                    oct = int (nt.findtext ('pitch/octave'))
                    midi = oct * 12 + [0,2,4,5,7,9,11]['CDEFGAB'.index (step)] + alt + 12
                    if a == '0':                    # no string annotation: find one
                        firstFit = ''
                        for smid, istr in s.tunTup: # midi numbers of open strings from high to low
                            if midi >= smid:        # highest open string where this note can be played
                                isvrij = s.strAlloc.isVrij (istr - 1, s.gTime [0], s.gTime [1])
                                a = str (istr)      # string number
                                if not firstFit: firstFit = a
                                if isvrij: break
                        if not isvrij:              # no free string, take the first fit (lowest fret)
                            a = firstFit
                            s.strAlloc.bezet (int (a) - 1, s.gTime [0], s.gTime [1])
                    else:                           # force annotated string number
                        s.strAlloc.bezet (int (a) - 1, s.gTime [0], s.gTime [1])
                    bmidi = s.tunmid [int (a) - 1]  # midi number of allocated string (with capodastro)
                    fret =  midi - bmidi            # fret position (respecting capodastro)
                    if fret < 25 and fret >= 0:
                        addElemT (tec, 'fret', str (fret), lev + 1)
                    else:
                        altp = 'b' if alt == -1 else '#' if alt == 1 else ''
                        info ('fret %d out of range, note %s%d on string %s' % (fret, step+altp, oct, a))
                    addElemT (tec, 'string', a, lev + 1)
                else:
                    addElemT (tec, 'fingering', a, lev + 1)
            else: decos.append (a)  # return staff annotations
        return decos

    def doLyr (s, n, nt, lev):
        for i, lyrobj in enumerate (n.objs):
            lyrel = E.Element ('lyric', number = str (i + 1))
            if lyrobj.name == 'syl':
                dash = len (lyrobj.t) == 2
                if dash:
                    if i in s.lyrdash:  type = 'middle'
                    else:               type = 'begin'; s.lyrdash [i] = 1
                else:
                    if i in s.lyrdash:  type = 'end';   del s.lyrdash [i]
                    else:               type = 'single'
                addElemT (lyrel, 'syllabic', type, lev + 1)
                txt = lyrobj.t[0]                       # the syllabe
                txt = re.sub (r'(?<!\\)~', ' ', txt)    # replace ~ by space when not escaped (preceded by \)
                txt = re.sub (r'\\(.)', r'\1', txt)     # replace all escaped characters by themselves (for the time being)
                addElemT (lyrel, 'text', txt, lev + 1)
            elif lyrobj.name == 'ext' and i in s.prevLyric:
                pext = s.prevLyric [i].find ('extend')  # identify previous extend
                if pext == None:
                    ext = E.Element ('extend', type = 'start')
                    addElem (s.prevLyric [i], ext, lev + 1)
                elif pext.get('type') == 'stop':        # subsequent extend: stop -> continue
                    pext.set ('type', 'continue')
                ext = E.Element ('extend', type = 'stop')   # always stop on current extend
                addElem (lyrel, ext, lev + 1)
            elif lyrobj.name == 'ext': info ('lyric extend error'); continue
            else: continue          # skip other lyric elements or errors
            addElem (nt, lyrel, lev)
            s.prevLyric [i] = lyrel # for extension (melisma) on the next note

    def doBeams (s, n, nt, den, lev):
        def closeBeam (grcIx):
            pbm = s.prevNote [grcIx].find ('beam')
            if pbm != None:
                if pbm.text == 'begin':
                    delElem (s.prevNote [grcIx], pbm)
                elif pbm.text == 'continue':
                    pbm.text = 'end'
            s.prevNote [grcIx] = None
        if hasattr (n, 'chord'): return # chord do not contain real beam breaks
        grcIx = 1 if hasattr (n, 'grace') else 0    # track grace sequence separately
        firstnote = s.prevNote [grcIx] == None
        bbrk = n.bbrk.t[0] or (den < 32 and not firstnote)
        if grcIx == 0 and s.grcbrk: # beam break before grace sequence
            bbrk = 1
            s.grcbrk = False        # only valid once
        if grcIx == 0 and s.prevNote [1] != None:   # normal note after grace sequence
            closeBeam (1)           # close/remove beam in previous grace sequence
        if firstnote:
            pbm = None
            s.grcbrk = True if grcIx and n.bbrk.t[0] else False # on first grace note
        else:
            pbm = s.prevNote [grcIx].find ('beam')
        bm = E.Element ('beam', number='2' if grcIx else '1')
        bm.text = 'begin'
        if pbm != None:
            if bbrk: closeBeam (grcIx)
            else:    bm.text = 'continue'
        if n.name != 'rest':
            if den >= 32: addElem (nt, bm, lev)
            s.prevNote [grcIx] = nt

    def stopBeams (s):
        for grcIx in [0, 1]:
            if s.prevNote [grcIx] == None: continue
            pbm = s.prevNote [grcIx].find ('beam')
            if pbm != None:
                if pbm.text == 'begin':
                    delElem (s.prevNote [grcIx], pbm)
                elif pbm.text == 'continue':
                    pbm.text = 'end'
            s.prevNote [grcIx] = None

    def staffDecos (s, decos, maat, lev):
        gstaff = s.gStaffNums.get (s.vid, 0)        # staff number of the current voice
        for d in decos:
            d = s.usrSyms.get (d, d).strip ('!+')   # try to replace user defined symbol
            if d in s.dynaMap:
                dynel = E.Element ('dynamics')
                addDirection (maat, dynel, lev, gstaff, [E.Element (d)], 'below', s.gcue_on)
            elif d in s.wedgeMap:  # wedge
                if ')' in d: type = 'stop'
                else: type = 'crescendo' if '<' in d or 'crescendo' in d else 'diminuendo'
                addDirection (maat, E.Element ('wedge', type=type), lev, gstaff)
            elif d.startswith ('8v'):
                if 'a' in d: type, plce = 'down', 'above'
                else:        type, plce = 'up', 'below'
                if ')' in d: type = 'stop'
                addDirection (maat, E.Element ('octave-shift', type=type, size='8'), lev, gstaff, placement=plce)
            elif d in (['ped','ped-up']):
                type = 'stop' if d.endswith ('up') else 'start'
                addDirection (maat, E.Element ('pedal', type=type), lev, gstaff)
            elif d in ['coda', 'segno']:
                text, attr, val = s.capoMap [d]
                dir = addDirection (maat, E.Element (text), lev, gstaff, placement='above')
                sound = E.Element ('sound'); sound.set (attr, val)
                addElem (dir, sound, lev + 1)
            elif d in s.capoMap:
                text, attr, val = s.capoMap [d]
                words = E.Element ('words'); words.text = text
                dir = addDirection (maat, words, lev, gstaff, placement='above')
                sound = E.Element ('sound'); sound.set (attr, val)
                addElem (dir, sound, lev + 1)
            elif d == '(' or d == '.(': s.slurbeg.append (d)   # start slur on next note
            elif d in ['/-','//-','///-','////-']:  # duplet tremolo sequence
                s.tmnum, s.tmden, s.ntup, s.trem, s.intrem = 2, 1, 2, len (d) - 1, 1
            elif d in ['/','//','///']: s.trem = - len (d)  # single note tremolo
            elif d == 'rbstop': s.rbStop = 1;   # sluit een open volta aan het eind van de maat
            else: s.nextdecos.append (d)    # keep annotation for the next note

    def doFields (s, maat, fieldmap, lev):
        def instDir (midelm, midnum, dirtxt):
            instId = 'I%s-%s' % (s.pid, s.vid)
            words = E.Element ('words'); words.text = dirtxt % midnum
            snd = E.Element ('sound')
            mi = E.Element ('midi-instrument', id=instId)
            dir = addDirection (maat, words, lev, gstaff, placement='above')
            addElem (dir, snd, lev + 1)
            addElem (snd, mi, lev + 2)
            addElemT (mi, midelm, midnum, lev + 3)
        def addTrans (n):
            e = E.Element ('transpose')
            addElemT (e, 'chromatic', n, lev + 2)  # n == signed number string given after transpose
            atts.append ((9, e))
        def doClef (field):
            if re.search (r'perc|map', field):  # percussion clef or new style perc=on or map=perc
                r = re.search (r'(perc|map)\s*=\s*(\S*)', field)
                s.percVoice = 0 if r and r.group (2) not in ['on','true','perc'] else 1
                field = re.sub (r'(perc|map)\s*=\s*(\S*)', '', field)   # erase the perc= for proper clef matching
            clef, gtrans = 0, 0
            clefn = re.search (r'alto1|alto2|alto4|alto|tenor|bass3|bass|treble|perc|none|tab', field)
            clefm = re.search (r"(?:^m=| m=|middle=)([A-Ga-g])([,']*)", field)
            trans_oct2 = re.search (r'octave=([-+]?\d)', field)
            trans = re.search (r'(?:^t=| t=|transpose=)(-?[\d]+)', field)
            trans_oct = re.search (r'([+-^_])(8|15)', field)
            cue_onoff = re.search (r'cue=(on|off)', field)
            strings = re.search (r"strings=(\S+)", field)
            stafflines = re.search (r'stafflines=\s*(\d)', field)
            capo = re.search (r'capo=(\d+)', field)
            if clefn:
                clef = clefn.group ()
            if clefm:
                note, octstr = clefm.groups ()
                nUp = note.upper ()
                octnum = (4 if nUp == note else 5) + (len (octstr) if "'" in octstr else -len (octstr))
                gtrans = (3 if nUp in 'AFD' else 4) - octnum
                if clef not in ['perc', 'none']: clef = s.clefLineMap [nUp]
            if clef:
                s.gtrans = gtrans   # only change global tranposition when a clef is really defined
                if clef != 'none': s.curClef = clef       # keep track of current abc clef (for percmap)
                sign, line = s.clefMap [clef]
                if not sign: return
                c = E.Element ('clef')
                if gstaff: c.set ('number', str (gstaff))   # only add staff number when defined
                addElemT (c, 'sign', sign, lev + 2)
                if line: addElemT (c, 'line', line, lev + 2)
                if trans_oct:
                    n = trans_oct.group (1) in '-_' and -1 or 1
                    if trans_oct.group (2) == '15': n *= 2  # 8 => 1 octave, 15 => 2 octaves
                    addElemT (c, 'clef-octave-change', str (n), lev + 2) # transpose print out
                    if trans_oct.group (1) in '+-': s.gtrans += n   # also transpose all pitches with one octave
                atts.append ((7, c))
            if trans_oct2:  # octave= can also be in a K: field
                n = int (trans_oct2.group (1))
                s.gtrans = gtrans + n
            if trans != None:   # add transposition in semitones
                e = E.Element ('transpose')
                addElemT (e, 'chromatic', str (trans.group (1)), lev + 3)
                atts.append ((9, e))
            if cue_onoff: s.gcue_on = cue_onoff.group (1) == 'on'
            nlines = 0
            if clef == 'tab':
                s.tabStaff = s.pid
                if capo: s.capo = int (capo.group (1))
                if strings: s.tuning = strings.group (1).split (',')
                s.tunmid = [int (boct) * 12 + [0,2,4,5,7,9,11]['CDEFGAB'.index (bstep)] + 12 + s.capo for bstep, boct in s.tuning]
                s.tunTup = sorted (zip (s.tunmid, range (len (s.tunmid), 0, -1)), reverse=1)
                s.tunmid.reverse ()
                nlines = str (len (s.tuning))
                s.strAlloc.setlines (len (s.tuning), s.pid)
                s.nostems = 'nostems' in field  # tab clef without stems
                s.diafret = 'diafret' in field  # tab with diatonic fretting
            if stafflines or nlines:
                e = E.Element ('staff-details')
                if gstaff: e.set ('number', str (gstaff))   # only add staff number when defined
                if not nlines: nlines = stafflines.group (1)
                addElemT (e, 'staff-lines', nlines, lev + 2)
                if clef == 'tab':
                    for line, t in enumerate (s.tuning):
                        st = E.Element ('staff-tuning', line=str(line+1))
                        addElemT (st, 'tuning-step', t[0], lev + 3)
                        addElemT (st, 'tuning-octave', t[1], lev + 3)
                        addElem (e, st, lev + 2)
                if s.capo: addElemT (e, 'capo', str (s.capo), lev + 2)
                atts.append ((8, e))
        s.diafret = 0           # chromatic fretting is default
        atts = []               # collect xml attribute elements [(order-number, xml-element), ..]
        gstaff = s.gStaffNums.get (s.vid, 0)    # staff number of the current voice
        for ftype, field in fieldmap.items ():
            if not field:       # skip empty fields
                continue
            if ftype == 'Div':  # not an abc field, but handled as if
                d = E.Element ('divisions')
                d.text = field
                atts.append ((1, d))
            elif ftype == 'gstaff':  # make grand staff
                e = E.Element ('staves')
                e.text = str (field)
                atts.append ((4, e))
            elif ftype == 'M':
                if field == 'none': continue
                if field == 'C': field = '4/4'
                elif field == 'C|': field = '2/2'
                t = E.Element ('time')
                if '/' not in field:
                    info ('M:%s not recognized, 4/4 assumed' % field)
                    field = '4/4'
                beats, btype = field.split ('/')[:2]
                try: s.mdur = simplify (eval (beats), int (btype))  # measure duration for Z and X rests (eval allows M:2+3/4)
                except:
                    info ('error in M:%s, 4/4 assumed' % field)
                    s.mdur = (4,4)
                    beats, btype = '4','4'
                addElemT (t, 'beats', beats, lev + 2)
                addElemT (t, 'beat-type', btype, lev + 2)
                atts.append ((3, t))
            elif ftype == 'K':
                accs = ['F','C','G','D','A','E','B']    # == s.sharpness [7:14]
                mode = ''
                key = re.match (r'\s*([A-G][#b]?)\s*([a-zA-Z]*)', field)
                altre = r'[=^_](\d*/*\d*|[_^]?)[A-Ga-g]'
                alts = re.search (r'\s((\s?'+altre+')+)', ' ' + field)  # avoid matching middle=G and m=G
                if key:
                    key, mode = key.groups ()
                    mode = mode.lower ()[:3] # only first three chars, no case
                    if mode not in s.offTab: mode = 'maj'
                    fifths = s.sharpness.index (key) - s.offTab [mode]
                    if fifths >= 0: s.keyAlts = dict (zip (accs[:fifths], fifths * ['^']))
                    else:           s.keyAlts = dict (zip (accs[fifths:], -fifths * ['_']))
                elif field.startswith ('none') or field == '':  # the default key
                    fifths = 0
                    mode = 'maj'
                if alts:
                    accs = abc_acclist.parseString (alts.group (1))
                    for acc, step in accs:
                        if type (acc) == tuple_type: acc = s.decTupAcc (acc)   # microtonal accidentals
                        s.keyAlts [step.upper ()] = acc
                    k = E.Element ('key')
                    koctave = []
                    lowerCaseSteps = [step.upper () for acc, step in accs if step.islower ()]
                    for step, acc in list (s.keyAlts.items ()):
                        if acc == '=':                      # skip neutrals
                            del s.keyAlts [step.upper ()]   # otherwise you get neutral signs on normal notes
                            continue
                        addElemT (k, 'key-step', step.upper (), lev + 2)
                        addElemT (k, 'key-alter', s.getAlter (acc), lev + 2)
                        addElemT (k, 'key-accidental', s.getAcc (acc), lev + 2)
                        koctave.append ('5' if step in lowerCaseSteps else '4')
                    if koctave:                     # only key signature if not empty
                        for n, oct in enumerate (koctave):
                            e = E.Element ('key-octave', number= str (n + 1))
                            e.text = oct
                            addElem (k, e, lev + 2)
                        atts.append ((2, k))
                elif mode:
                    k = E.Element ('key')
                    addElemT (k, 'fifths', str (fifths), lev + 2)
                    addElemT (k, 'mode', s.modTab [mode], lev + 2)
                    atts.append ((2, k))
                doClef (field)
            elif ftype == 'L':
                try: s.unitLcur = lmap (int, field.split ('/'))
                except: s.unitLcur = (1,8)
                if len (s.unitLcur) == 1 or s.unitLcur[1] not in s.typeMap:
                    info ('L:%s is not allowed, 1/8 assumed' % field)
                    s.unitLcur = 1,8
            elif ftype == 'V':
                doClef (field)
            elif ftype == 'I':
                s.doField_I (ftype, field, instDir, addTrans)
            elif ftype == 'Q':
                s.doTempo (maat, field, lev)
            elif ftype == 'P':  # ad hoc translation of P: into a staff text direction
                words = E.Element ('rehearsal')
                words.set ('font-weight', 'bold')
                words.text = field
                addDirection (maat, words, lev, gstaff, placement='above')
            elif ftype in 'TCOAZNGHRBDFSU':
                info ('**illegal header field in body: %s, content: %s' % (ftype, field))
            else:
                info ('unhandled field: %s, content: %s' % (ftype, field))

        if atts:
            att = E.Element ('attributes')      # insert sub elements in the order required by musicXML
            addElem (maat, att, lev)
            for _, att_elem in sorted (atts, key=lambda x: x[0]):   # ordering !
                addElem (att, att_elem, lev + 1)
        if s.diafret:
            other = E.Element ('other-direction'); other.text = 'diatonic fretting'
            addDirection (maat, other, lev, 0)

    def doTempo (s, maat, field, lev):
        gstaff = s.gStaffNums.get (s.vid, 0)    # staff number of the current voice
        t = re.search (r'(\d)/(\d\d?)\s*=\s*(\d[.\d]*)|(\d[.\d]*)', field)
        rtxt = re.search (r'"([^"]*)"', field) # look for text in Q: field
        if not t and not rtxt: return
        elems = []  # [(element, sub-elements)] will be added as direction-types
        if rtxt:
            num, den, upm = 1, 4, s.tempoMap.get (rtxt.group (1).lower ().strip (), 120)
            words = E.Element ('words'); words.text = rtxt.group (1)
            elems.append ((words, []))
        if t:
            try:
                if t.group (4): num, den, upm = 1, s.unitLcur[1] , float (t.group (4))  # old syntax Q:120
                else:           num, den, upm = int (t.group (1)), int (t.group (2)), float (t.group (3))
            except: info ('conversion error: %s' % field); return
            num, den = simplify (num, den);
            dotted, den_not = (1, den // 2) if num == 3 else (0, den)
            metro = E.Element ('metronome')
            u = E.Element ('beat-unit'); u.text = s.typeMap.get (4 * den_not, 'quarter')
            pm = E.Element ('per-minute'); pm.text = ('%.2f' % upm).rstrip ('0').rstrip ('.')
            subelms = [u, E.Element ('beat-unit-dot'), pm] if dotted else [u, pm]
            elems.append ((metro, subelms))
        dir = addDirection (maat, elems, lev, gstaff, [], placement='above')
        if num != 1 and num != 3: info ('in Q: numerator in %d/%d not supported' % (num, den))
        qpm = 4. * num * upm / den
        sound = E.Element ('sound'); sound.set ('tempo', '%.2f' % qpm)
        addElem (dir, sound, lev + 1)

    def mkBarline (s, maat, loc, lev, style='', dir='', ending=''):
        b = E.Element ('barline', location=loc)
        if style:
            addElemT (b, 'bar-style', style, lev + 1)
        if s.curVolta:    # first stop a current volta
            end = E.Element ('ending', number=s.curVolta, type='stop')
            s.curVolta = ''
            if loc == 'left':   # stop should always go to a right barline
                bp = E.Element ('barline', location='right')
                addElem (bp, end, lev + 1)
                addElem (s.prevmsre, bp, lev)   # prevmsre has no right barline! (ending would have stopped there)
            else:
                addElem (b, end, lev + 1)
        if ending:
            ending = ending.replace ('-',',')   # MusicXML only accepts comma's
            endtxt = ''
            if ending.startswith ('"'):     # ending is a quoted string
                endtxt = ending.strip ('"')
                ending = '33'               # any number that is not likely to occur elsewhere
            end = E.Element ('ending', number=ending, type='start')
            if endtxt: end.text = endtxt    # text appears in score in stead of number attribute
            addElem (b, end, lev + 1)
            s.curVolta = ending
        if dir:
            r = E.Element ('repeat', direction=dir)
            addElem (b, r, lev + 1)
        addElem (maat, b, lev)

    def doChordSym (s, maat, sym, lev):
        alterMap = {'#':'1','=':'0','b':'-1'}
        rnt = sym.root.t
        chord = E.Element ('harmony')
        addElem (maat, chord, lev)
        root = E.Element ('root')
        addElem (chord, root, lev + 1)
        addElemT (root, 'root-step', rnt[0], lev + 2)
        if len (rnt) == 2: addElemT (root, 'root-alter', alterMap [rnt[1]], lev + 2)
        kind = s.chordTab.get (sym.kind.t[0], 'major') if sym.kind.t else 'major'
        addElemT (chord, 'kind', kind, lev + 1)
        if hasattr (sym, 'bass'):
            bnt = sym.bass.t
            bass = E.Element ('bass')
            addElem (chord, bass, lev + 1)
            addElemT (bass, 'bass-step', bnt[0], lev + 2)
            if len (bnt) == 2: addElemT (bass, 'bass-alter', alterMap [bnt[1]], lev + 2)
        degs = getattr (sym, 'degree', '')
        if degs:
            if type (degs) != list_type: degs = [degs]
            for deg in degs:
                deg = deg.t[0]
                if deg[0] == '#':   alter = '1';  deg = deg[1:]
                elif deg[0] == 'b': alter = '-1'; deg = deg[1:]
                else:               alter = '0';  deg = deg
                degree = E.Element ('degree')
                addElem (chord, degree, lev + 1)
                addElemT (degree, 'degree-value', deg, lev + 2)
                addElemT (degree, 'degree-alter', alter, lev + 2)
                addElemT (degree, 'degree-type', 'add', lev + 2)

    def mkMeasure (s, i, t, lev, fieldmap={}):
        s.msreAlts = {}
        s.ntup, s.trem, s.intrem = -1, 0, 0
        s.acciatura = 0 # next grace element gets acciatura attribute
        s.rbStop = 0    # sluit een open volta aan het eind van de maat
        overlay = 0
        maat = E.Element ('measure', number = str(i))
        if fieldmap: s.doFields (maat, fieldmap, lev + 1)
        if s.linebrk:   # there was a line break in the previous measure
            e = E.Element ('print')
            e.set ('new-system', 'yes')
            addElem (maat, e, lev + 1)
            s.linebrk = 0
        for it, x in enumerate (t):
            if x.name == 'note' or x.name == 'rest':
                if x.dur.t[0] == 0:  # a leading zero was used for stemmless in abcm2ps, we only support !stemless!
                    x.dur.t = tuple ([1, x.dur.t[1]])
                note = s.mkNote (x, lev + 1)
                addElem (maat, note, lev + 1)
            elif x.name == 'lbar':
                bar = x.t[0]
                if bar == '|' or bar == '[|': pass # skip redundant bar
                elif ':' in bar:    # forward repeat
                    volta = x.t[1] if len (x.t) == 2  else ''
                    s.mkBarline (maat, 'left', lev + 1, style='heavy-light', dir='forward', ending=volta)
                else:               # bar must be a volta number
                    s.mkBarline (maat, 'left', lev + 1, ending=bar)
            elif x.name == 'rbar':
                bar = x.t[0]
                if bar == '.|':
                    s.mkBarline (maat, 'right', lev + 1, style='dotted')
                elif ':' in bar:  # backward repeat
                    s.mkBarline (maat, 'right', lev + 1, style='light-heavy', dir='backward')
                elif bar == '||':
                    s.mkBarline (maat, 'right', lev + 1, style='light-light')
                elif bar == '[|]' or bar == '[]':
                    s.mkBarline (maat, 'right', lev + 1, style='none')
                elif '[' in bar or ']' in bar:
                    s.mkBarline (maat, 'right', lev + 1, style='light-heavy')
                elif bar == '|' and s.rbStop:   # normale barline hoeft niet, behalve om een volta te stoppen
                    s.mkBarline (maat, 'right', lev + 1, style='regular')
                elif bar[0] == '&': overlay = 1
            elif x.name == 'tup':
                if   len (x.t) == 3: n, into, nts = x.t
                elif len (x.t) == 2: n, into, nts = x.t + [0]
                else:                n, into, nts = x.t[0], 0, 0
                if into == 0: into = 3 if n in [2,4,8] else 2
                if nts == 0: nts = n
                s.tmnum, s.tmden, s.ntup = n, into, nts
            elif x.name == 'deco':
                s.staffDecos (x.t, maat, lev + 1)   # output staff decos, postpone note decos to next note
            elif x.name == 'text':
                pos, text = x.t[:2]
                place = 'above' if pos == '^' else 'below'
                words = E.Element ('words')
                words.text = text
                gstaff = s.gStaffNums.get (s.vid, 0)    # staff number of the current voice
                addDirection (maat, words, lev + 1, gstaff, placement=place)
            elif x.name == 'inline':
                fieldtype, fieldval = x.t[0], ' '.join (x.t[1:])
                s.doFields (maat, {fieldtype:fieldval}, lev + 1)
            elif x.name == 'accia': s.acciatura = 1
            elif x.name == 'linebrk':
                s.supports_tag = 1
                if it > 0 and t[it -1].name == 'lbar':  # we are at start of measure
                    e = E.Element ('print')             # output linebreak now
                    e.set ('new-system', 'yes')
                    addElem (maat, e, lev + 1)
                else:
                    s.linebrk = 1   # output linebreak at start of next measure
            elif x.name == 'chordsym':
                s.doChordSym (maat, x, lev + 1)
        s.stopBeams ()
        s.prevmsre = maat
        return maat, overlay

    def mkPart (s, maten, id, lev, attrs, nstaves, rOpt):
        s.slurstack = {}
        s.glisnum = 0;          # xml number attribute for glissandos
        s.slidenum = 0;         # xml number attribute for slides
        s.unitLcur = s.unitL    # set the default unit length at begin of each voice
        s.curVolta = ''
        s.lyrdash = {}
        s.linebrk = 0
        s.midprg = ['', '', '', ''] # MIDI channel nr, program nr, volume, panning for the current part
        s.gcue_on = 0           # reset cue note marker for each new voice
        s.gtrans = 0            # reset octave transposition (by clef)
        s.percVoice = 0         # 1 if percussion clef encountered
        s.curClef = ''          # current abc clef (for percmap)
        s.nostems = 0           # for the tab clef
        s.tuning = s.tuningDef  # reset string tuning to default
        part = E.Element ('part', id=id)
        s.overlayVnum = 0       # overlay voice number to relate ties that extend from one overlayed measure to the next
        gstaff = s.gStaffNums.get (s.vid, 0)    # staff number of the current voice
        attrs_cpy = attrs.copy ()   # don't change attrs itself in next line
        if gstaff == 1: attrs_cpy ['gstaff'] = nstaves  # make a grand staff
        if 'perc' in attrs_cpy.get ('V', ''): del attrs_cpy ['K'] # remove key from percussion voice
        msre, overlay = s.mkMeasure (1, maten[0], lev + 1, attrs_cpy)
        addElem (part, msre, lev + 1)
        for i, maat in enumerate (maten[1:]):
            s.overlayVnum = s.overlayVnum + 1 if overlay else 0
            msre, next_overlay = s.mkMeasure (i+2, maat, lev + 1)
            if overlay: mergePartMeasure (part, msre, s.overlayVnum, rOpt)
            else:       addElem (part, msre, lev + 1)
            overlay = next_overlay
        return part

    def mkScorePart (s, id, vids_p, partAttr, lev):
        def mkInst (instId, vid, midchan, midprog, midnot, vol, pan, lev):
            si = E.Element ('score-instrument', id=instId)
            try: imidprg = int (midprog)
            except: imidprg = -1
            if imidprg < 0 or imidprg >= len (s.inst_tb): instnm = 'no name'
            else: instnm = s.inst_tb [imidprg]
            if midchan == '10':
                iperc = int (midnot) - 27
                if iperc < 0 or iperc >= len (s.perc_tb) : instnm = 'no name'
                else: instnm = s.perc_tb [iperc]
            addElemT (si, 'instrument-name', instnm, lev + 2)   # MuseScore needs a name
            mi = E.Element ('midi-instrument', id=instId)
            if midchan: addElemT (mi, 'midi-channel', midchan, lev + 2)
            if imidprg >= 0: addElemT (mi, 'midi-program', str (imidprg + 1), lev + 2) # compatible with abc2midi
            if midnot:  addElemT (mi, 'midi-unpitched', str (int (midnot) + 1), lev + 2)
            if vol: addElemT (mi, 'volume', '%.2f' % (int (vol) / 1.27), lev + 2)
            if pan: addElemT (mi, 'pan', '%.2f' % (int (pan) / 127. * 180 - 90), lev + 2)
            return (si, mi)
        naam, subnm, midprg = partAttr [id]
        sp = E.Element ('score-part', id='P'+id)
        nm = E.Element ('part-name')
        nm.text = naam
        addElem (sp, nm, lev + 1)
        snm = E.Element ('part-abbreviation')
        snm.text = subnm
        if subnm: addElem (sp, snm, lev + 1)    # only add if subname was given
        inst = []
        for instId, (pid, vid, chan, midprg, vol, pan) in sorted (s.midiInst.items ()):
            midprg, midnot = ('0', midprg) if chan == '10' else (midprg, '')
            if pid == id: inst.append (mkInst (instId, vid, chan, midprg, midnot, vol, pan, lev))
        for si, mi in inst: addElem (sp, si, lev + 1)
        for si, mi in inst: addElem (sp, mi, lev + 1)
        return sp

    def mkPartlist (s, vids, partAttr, lev):
        def addPartGroup (sym, num):
            pg = E.Element ('part-group', number=str (num), type='start')
            addElem (partlist, pg, lev + 1)
            addElemT (pg, 'group-symbol', sym, lev + 2)
            addElemT (pg, 'group-barline', 'yes', lev + 2)
        partlist = E.Element ('part-list')
        g_num = 0       # xml group number
        for g in (s.groups or vids):    # brace/bracket or abc_voice_id
            if   g == '[': g_num += 1; addPartGroup ('bracket', g_num)
            elif g == '{': g_num += 1; addPartGroup ('brace', g_num)
            elif g in '}]':
                pg = E.Element ('part-group', number=str (g_num), type='stop')
                addElem (partlist, pg, lev + 1)
                g_num -= 1
            else:   # g = abc_voice_id
                if g not in vids: continue  # error in %%score
                sp = s.mkScorePart (g, vids, partAttr, lev + 1)
                addElem (partlist, sp, lev + 1)
        return partlist

    def doField_I (s, type, x, instDir, addTrans):
        def instChange (midchan, midprog):  # instDir -> doFields
            if midchan and midchan != s.midprg [0]: instDir ('midi-channel', midchan, 'chan: %s')
            if midprog and midprog != s.midprg [1]: instDir ('midi-program', str (int (midprog) + 1), 'prog: %s')
        def readPfmt (x, n): # read ABC page formatting constant
            if not s.pageFmtAbc: s.pageFmtAbc = s.pageFmtDef    # set the default values on first change
            ro = re.search (r'[^.\d]*([\d.]+)\s*(cm|in|pt)?', x)    # float followed by unit
            if ro:
                x, unit = ro.groups ()  # unit == None when not present
                u = {'cm':10., 'in':25.4, 'pt':25.4/72} [unit] if unit else 1.
                s.pageFmtAbc [n] = float (x) * u   # convert ABC values to millimeters
            else: info ('error in page format: %s' % x)
        def readPercMap (x):    # parse I:percmap <abc_note> <step> <MIDI> <notehead>
            def getMidNum (sndnm):          # find midi number of GM drum sound name
                pnms = sndnm.split ('-')    # sound name parts (from I:percmap)
                ps = s.percsnd [:]          # copy of the instruments
                _f = lambda ip, xs, pnm: ip < len (xs) and xs[ip].find (pnm) > -1   # part xs[ip] and pnm match
                for ip, pnm in enumerate (pnms):    # match all percmap sound name parts
                    ps = [(nm, mnum) for nm, mnum in ps if _f (ip, nm.split ('-'), pnm) ]   # filter instruments
                    if len (ps) <= 1: break # no match or one instrument left
                if len (ps) == 0: info ('drum sound: %s not found' % sndnm); return '38'
                return ps [0][1]            # midi number of (first) instrument found
            def midiVal (acc, step, oct):   # abc note -> midi note number
                oct = (4 if step.upper() == step else 5) + int (oct)
                return oct * 12 + [0,2,4,5,7,9,11]['CDEFGAB'.index (step.upper())] + {'^':1,'_':-1,'=':0}.get (acc, 0) + 12
            p0, p1, p2, p3, p4 = abc_percmap.parseString (x) # percmap, abc-note, display-step, midi, note-head
            acc, astep, aoct = p1
            nstep, noct = (astep, aoct) if p2 == '*' else p2
            if p3 == '*':                           midi = str (midiVal (acc, astep, aoct))
            elif isinstance (p3, list_type):        midi = str (midiVal (p3[0], p3[1], p3[2]))
            elif isinstance (p3, int_type):         midi = str (p3)
            else:                                   midi = getMidNum (p3.lower ())
            head = re.sub (r'(.)-([^x])', r'\1 \2', p4) # convert abc note head names to xml
            s.percMap [(s.pid, acc + astep, aoct)] = (nstep, noct, midi, head)
        if x.startswith ('score') or x.startswith ('staves'):
            s.staveDefs += [x]          # collect all voice mappings
        elif x.startswith ('staffwidth'): info ('skipped I-field: %s' % x)
        elif x.startswith ('staff'):    # set new staff number of the current voice
            r1 = re.search (r'staff *([+-]?)(\d)', x)
            if r1:
                sign = r1.group (1)
                num = int (r1.group (2))
                gstaff = s.gStaffNums.get (s.vid, 0)    # staff number of the current voice
                if sign:                                # relative staff number
                    num = (sign == '-') and gstaff - num or gstaff + num
                else:                                   # absolute abc staff number
                    try: vabc = s.staves [num - 1][0]   # vid of (first voice of) abc-staff num
                    except: vabc = 0; info ('abc staff %s does not exist' % num)
                    num = s.gStaffNumsOrg.get (vabc, 0) # xml staff number of abc-staff num
                if gstaff and num > 0 and num <= s.gNstaves [s.vid]:
                    s.gStaffNums [s.vid] = num
                else: info ('could not relocate to staff: %s' % r1.group ())
            else: info ('not a valid staff redirection: %s' % x)
        elif x.startswith ('scale'): readPfmt (x, 0)
        elif x.startswith ('pageheight'): readPfmt (x, 1)
        elif x.startswith ('pagewidth'): readPfmt (x, 2)
        elif x.startswith ('leftmargin'): readPfmt (x, 3)
        elif x.startswith ('rightmargin'): readPfmt (x, 4)
        elif x.startswith ('topmargin'): readPfmt (x, 5)
        elif x.startswith ('botmargin'): readPfmt (x, 6)
        elif x.startswith ('MIDI') or x.startswith ('midi'):
            r1 = re.search (r'program *(\d*) +(\d+)', x)
            r2 = re.search (r'channel *(\d+)', x)
            r3 = re.search (r"drummap\s+([_=^]*)([A-Ga-g])([,']*)\s+(\d+)", x)
            r4 = re.search (r'control *(\d+) +(\d+)', x)
            r5 = re.search (r'temperamentequal *(\d+)', x)
            ch_nw, prg_nw, vol_nw, pan_nw = '', '', '', ''
            if r1: ch_nw, prg_nw = r1.groups () # channel nr or '', program nr
            if r2: ch_nw = r2.group (1)         # channel nr only
            if r4:
                cnum, cval = r4.groups ()       # controller number, controller value
                if cnum == '7': vol_nw = cval
                if cnum == '10': pan_nw = cval
            if r1 or r2 or r4:
                ch  = ch_nw  or s.midprg [0]
                prg = prg_nw or s.midprg [1]
                vol = vol_nw or s.midprg [2]
                pan = pan_nw or s.midprg [3]
                instId = 'I%s-%s' % (s.pid, s.vid)              # only look for real instruments, no percussion
                if instId in s.midiInst: instChange (ch, prg)   # instChance -> doFields
                s.midprg = [ch, prg, vol, pan]  # mknote: new instrument -> s.midiInst
            if r3:      # translate drummap to percmap
                acc, step, oct, midi = r3.groups ()
                oct = -len (oct) if ',' in x else len (oct)
                notehead = 'x' if acc == '^' else 'circle-x' if acc == '_' else 'normal'
                s.percMap [(s.pid, acc + step, oct)] = (step, oct, midi, notehead)
            if r5: s.edo = int (r5.group (1))
            r = re.search (r'transpose[^-\d]*(-?\d+)', x)
            if r: addTrans (r.group (1))        # addTrans -> doFields
        elif x.startswith ('percmap'): readPercMap (x); s.pMapFound = 1
        else: info ('skipped I-field: %s' % x)

    def parseStaveDef (s, vdefs):
        for vid in vdefs: s.vcepid [vid] = vid              # default: each voice becomes an xml part
        if not s.staveDefs: return vdefs
        for x in s.staveDefs [1:]: info ('%%%%%s dropped, multiple stave mappings not supported' % x)
        x = s.staveDefs [0]                                 # only the first %%score is honoured
        score = abc_scoredef.parseString (x)
        f = lambda x: type (x) == uni_type and [x] or x
        s.staves = lmap (f, mkStaves (score, vdefs))        # [[vid] for each staff]
        s.grands = lmap (f, mkGrand (score, vdefs))         # [staff-id], staff-id == [vid][0]
        s.groups = mkGroups (score)
        vce_groups = [vids for vids in s.staves if len (vids) > 1]  # all voice groups
        d = {}                                              # for each voice group: map first voice id -> all merged voice ids
        for vgr in vce_groups: d [vgr[0]] = vgr
        for gstaff in s.grands:                             # for all grand staves
            if len (gstaff) == 1: continue                  # skip single parts
            for v, stf_num in zip (gstaff, range (1, len (gstaff) + 1)):
                for vx in d.get (v, [v]):                   # allocate staff numbers
                    s.gStaffNums [vx] = stf_num             # to all constituant voices
                    s.gNstaves [vx] = len (gstaff)          # also remember total number of staves
        s.gStaffNumsOrg = s.gStaffNums.copy ()              # keep original allocation for abc -> xml staff map
        for xmlpart in s.grands:
            pid = xmlpart [0]                               # part id == first staff id == first voice id
            vces = [v for stf in xmlpart for v in d.get (stf, [stf])]
            for v in vces: s.vcepid [v] = pid
        return vdefs

    def voiceNamesAndMaps (s, ps):  # get voice names and mappings
        vdefs = {}
        for vid, vcedef, vce in ps: # vcedef == emtpy or first pObj == voice definition
            pname, psubnm = '', ''  # part name and abbreviation
            if not vcedef:          # simple abc without voice definitions
                vdefs [vid] =  pname, psubnm, ''
            else:                   # abc with voice definitions
                if vid != vcedef.t[1]: info ('voice ids unequal: %s (reg-ex) != %s (grammar)' % (vid, vcedef.t[1]))
                rn = re.search (r'(?:name|nm)="([^"]*)"', vcedef.t[2])
                if rn: pname = rn.group (1)
                rn = re.search (r'(?:subname|snm|sname)="([^"]*)"', vcedef.t[2])
                if rn: psubnm = rn.group (1)
                vcedef.t[2] = vcedef.t[2].replace ('"%s"' % pname, '""').replace ('"%s"' % psubnm, '""')   # clear voice name to avoid false clef matches later on
                vdefs [vid] =  pname, psubnm, vcedef.t[2]
            xs = [pObj.t[1] for maat in vce for pObj in maat if pObj.name == 'inline']  # all inline statements in vce
            s.staveDefs += [x.replace ('%5d',']') for x in xs if x.startswith ('score') or x.startswith ('staves')] # filter %%score and %%staves
        return vdefs

    def doHeaderField (s, fld, attrmap):
        type, value = fld.t[0], fld.t[1].replace ('%5d',']')    # restore closing brackets (see splitHeaderVoices)
        if not value:    # skip empty field
            return
        if type == 'M':
            attrmap [type] = value
        elif type == 'L':
            try: s.unitL = lmap (int, fld.t[1].split ('/'))
            except:
                info ('illegal unit length:%s, 1/8 assumed' % fld.t[1])
                s.unitL = 1,8
            if len (s.unitL) == 1 or s.unitL[1] not in s.typeMap:
                info ('L:%s is not allowed, 1/8 assumed' % fld.t[1])
                s.unitL = 1,8
        elif type == 'K':
            attrmap[type] = value
        elif type == 'T':
            s.title = s.title + '\n' + value if s.title else value
        elif type == 'U':
            sym = fld.t[2].strip ('!+')
            s.usrSyms [value] = sym
        elif type == 'I':
            s.doField_I (type, value, lambda x,y,z:0, lambda x:0)
        elif type == 'Q':
            attrmap[type] = value
        elif type in 'CRZNOAGHBDFSP':           # part maps are treated as meta data
            type = s.metaMap.get (type, type)   # respect the (user defined --meta) mapping of various ABC fields to XML meta data types
            c = s.metadata.get (type, '')
            s.metadata [type] = c + '\n' + value if c else value    # concatenate multiple info fields with new line as separator
        else:
            info ('skipped header: %s' % fld)

    def mkIdentification (s, score, lev):
        if s.title:
            xs = s.title.split ('\n')   # the first T: line goes to work-title
            ys = '\n'.join (xs [1:])    # place subsequent T: lines into work-number
            w = E.Element ('work')
            addElem (score, w, lev + 1)
            if ys: addElemT (w, 'work-number', ys, lev + 2)
            addElemT (w, 'work-title', xs[0], lev + 2)
        ident = E.Element ('identification')
        addElem (score, ident, lev + 1)
        for mtype, mval in s.metadata.items ():
            if mtype in s.metaTypes and mtype != 'rights':    # all metaTypes are MusicXML creator types
                c = E.Element ('creator', type=mtype)
                c.text = mval
                addElem (ident, c, lev + 2)
        if 'rights' in s.metadata:
            c = addElemT (ident, 'rights', s.metadata ['rights'], lev + 2)
        encoding = E.Element ('encoding')
        addElem (ident, encoding, lev + 2)
        encoder = E.Element ('encoder')
        encoder.text = 'abc2xml version %d' % VERSION
        addElem (encoding, encoder, lev + 3)
        software = E.Element ('software')
        software.text = 'https://wim.vree.org/svgParse/abc2xml.html'
        addElem (encoding, software, lev + 3)
        if s.supports_tag:  # avoids interference of auto-flowing and explicit linebreaks
            suports = E.Element ('supports', attribute="new-system", element="print", type="yes", value="yes")
            addElem (encoding, suports, lev + 3)
        encodingDate = E.Element ('encoding-date')
        encodingDate.text = str (datetime.date.today ())
        addElem (encoding, encodingDate, lev + 3)
        s.addMeta (ident, lev + 2)

    def mkDefaults (s, score, lev):
        if s.pageFmtCmd: s.pageFmtAbc = s.pageFmtCmd
        if not s.pageFmtAbc: return # do not output the defaults if none is desired
        abcScale, h, w, l, r, t, b = s.pageFmtAbc
        space = abcScale * 2.117    # 2.117 = 6pt = space between staff lines for scale = 1.0 in abcm2ps
        mils = 4 * space    # staff height in millimeters
        scale = 40. / mils  # tenth's per millimeter
        dflts = E.Element ('defaults')
        addElem (score, dflts, lev)
        scaling = E.Element ('scaling')
        addElem (dflts, scaling, lev + 1)
        addElemT (scaling, 'millimeters', '%g' % mils, lev + 2)
        addElemT (scaling, 'tenths', '40', lev + 2)
        layout = E.Element ('page-layout')
        addElem (dflts, layout, lev + 1)
        addElemT (layout, 'page-height', '%g' % (h * scale), lev + 2)
        addElemT (layout, 'page-width', '%g' % (w * scale), lev + 2)
        margins = E.Element ('page-margins', type='both')
        addElem (layout, margins, lev + 2)
        addElemT (margins, 'left-margin', '%g' % (l * scale), lev + 3)
        addElemT (margins, 'right-margin', '%g' % (r * scale), lev + 3)
        addElemT (margins, 'top-margin', '%g' % (t * scale), lev + 3)
        addElemT (margins, 'bottom-margin', '%g' % (b * scale), lev + 3)

    def addMeta (s, parent, lev):
        misc = E.Element ('miscellaneous')
        mf = 0
        for mtype, mval in sorted (s.metadata.items ()):
            if mtype == 'S':
                addElemT (parent, 'source', mval, lev)
            elif mtype in s.metaTypes: continue  # mapped meta data has already been output (in creator elements)
            else:
                mf = E.Element ('miscellaneous-field', name=s.metaTab [mtype])
                mf.text = mval
                addElem (misc, mf, lev + 1)
        if mf != 0: addElem (parent, misc, lev)

    def parse (s, abctext, rOpt=False, bOpt=False, fOpt=False, mOpt=False):
        s.reset (fOpt, mOpt)
        s.edo = scanEdo (abctext)   # look for fractional/integer accidentals
        if s.mus53: # redefine accidentals to those that are playable by musescore
            xs = {'_1':'flat-1', '_4':'flat-4', '^1':'sharp-1', '^5':'sharp-5'}
            for a, v in xs.items (): mxm.accTab [53][a] = v
        header, voices = splitHeaderVoices (abctext)
        ps = []
        try:
            lbrk_insert = 0 if re.search (r'I:linebreak\s*([!$]|none)|I:continueall\s*(1|true)', header) else bOpt
            hs = abc_header.parseString (header) if header else ''
            for id, voice in voices:
                if lbrk_insert:                                 # insert linebreak at EOL
                    r1 = re.compile (r'\[[wA-Z]:[^]]*\]')       # inline field
                    has_abc = lambda x: r1.sub ('', x).strip () # empty if line only contains inline fields
                    voice = '\n'.join ([balk.rstrip ('$!') + '$' if has_abc (balk) else balk for balk in voice.splitlines ()])
                prevLeftBar = None      # previous voice ended with a left-bar symbol (double repeat)
                s.orderChords = s.fOpt and ('tab' in voice [:200] or [x for x in hs if x.t[0] == 'K' and 'tab' in x.t[1]])
                vce = abc_voice.parseString (voice)
                lyr_notes = []          # remember notes between lyric blocks
                for m in vce:           # all measures
                    for e in m:         # all abc-elements
                        if e.name == 'lyr_blk':         # -> e.objs is list of lyric lines
                            lyr = [line.objs for line in e.objs]    # line.objs is listof syllables
                            alignLyr (lyr_notes, lyr)   # put all syllables into corresponding notes
                            lyr_notes = []
                        else:
                            lyr_notes.append (e)
                if not vce:             # empty voice, insert an inline field that will be rejected
                    vce = [[pObj ('inline', ['I', 'empty voice'])]]
                if prevLeftBar:
                    vce[0].insert (0, prevLeftBar)  # insert at begin of first measure
                    prevLeftBar = None
                if vce[-1] and vce[-1][-1].name == 'lbar':  # last measure ends with an lbar
                    prevLeftBar = vce[-1][-1]
                    if len (vce) > 1:   # vce should not become empty (-> exception when taking vcelyr [0][0])
                        del vce[-1]     # lbar was the only element in measure vce[-1]
                vcelyr = vce
                elem1 = vcelyr [0][0]   # the first element of the first measure
                if  elem1.name == 'inline'and elem1.t[0] == 'V':    # is a voice definition
                    voicedef = elem1
                    del vcelyr [0][0]   # do not read voicedef twice
                else:
                    voicedef = ''
                ps.append ((id, voicedef, vcelyr))
        except Exception as err:
            info ('*** cannot parse score ***', warn=0)
            pass

        score = E.Element ('score-partwise')
        attrmap = {'Div': str (s.divisions), 'K':'C treble', 'M':'4/4'}
        for res in hs:
            if res.name == 'field':
                s.doHeaderField (res, attrmap)
            else:
                info ('unexpected header item: %s' % res)

        vdefs = s.voiceNamesAndMaps (ps)
        vdefs = s.parseStaveDef (vdefs)

        lev = 0
        vids, parts, partAttr = [], [], {}
        s.strAlloc = stringAlloc ()
        for vid, _, vce in ps:          # voice id, voice parse tree
            pname, psubnm, voicedef = vdefs [vid]   # part name
            attrmap ['V'] = voicedef    # abc text of first voice definition (after V:vid) or empty
            pid = 'P%s' % vid           # let part id start with an alpha
            s.vid = vid                 # avoid parameter passing, needed in mkNote for instrument id
            s.pid = s.vcepid [s.vid]    # xml part-id for the current voice
            s.gTime = (0, 0)            # reset time
            s.strAlloc.beginZoek ()     # reset search index
            part = s.mkPart (vce, pid, lev + 1, attrmap, s.gNstaves.get (vid, 0), rOpt)
            if 'Q' in attrmap: del attrmap ['Q']    # header tempo only in first part
            parts.append (part)
            vids.append (vid)
            partAttr [vid] = (pname, psubnm, s.midprg)
            if s.midprg != ['', '', '', ''] and not s.percVoice:    # when a part has only rests
                instId = 'I%s-%s' % (s.pid, s.vid)
                if instId not in s.midiInst: s.midiInst [instId] = (s.pid, s.vid, s.midprg [0], s.midprg [1], s.midprg [2], s.midprg [3])
        parts, vidsnew = mergeParts (parts, vids, s.staves, rOpt) # merge parts into staves as indicated by %%score
        parts, vidsnew = mergeParts (parts, vidsnew, s.grands, rOpt, 1) # merge grand staves
        reduceMids (parts, vidsnew, s.midiInst)

        s.mkIdentification (score, lev)
        s.mkDefaults (score, lev + 1)

        partlist = s.mkPartlist (vids, partAttr, lev + 1)
        addElem (score, partlist, lev + 1)
        for ip, part in enumerate (parts): addElem (score, part, lev + 1)

        return score


def decodeInput (data_string):
    try:        enc = 'utf-8';   unicode_string = data_string.decode (enc)
    except:
        try:    enc = 'latin-1'; unicode_string = data_string.decode (enc)
        except: raise ValueError ('data not encoded in utf-8 nor in latin-1')
    unicode_string = unicode_string.replace ('\r\n', '\n')
    info ('decoded from %s' % enc)
    return unicode_string

def ggd (a, b): # greatest common divisor
    return a if b == 0 else ggd (b, a % b)

xmlVersion = "<?xml version='1.0' encoding='utf-8'?>"
def fixDoctype (elem):
    if python3: xs = E.tostring (elem, encoding='unicode')  # writing to file will auto-encode to utf-8
    else:       xs = E.tostring (elem, encoding='utf-8')    # keep the string utf-8 encoded for writing to file
    ys = xs.split ('\n')
    ys.insert (0, xmlVersion)  # crooked logic of ElementTree lib
    ys.insert (1, '<!DOCTYPE score-partwise PUBLIC "-//Recordare//DTD MusicXML 3.0 Partwise//EN" "http://www.musicxml.org/dtds/partwise.dtd">')
    return '\n'.join (ys)

def xml2mxl (pad, fnm, data):   # write xml data to compressed .mxl file
    from zipfile import ZipFile, ZIP_DEFLATED
    fnmext = fnm + '.xml'       # file name with extension, relative to the root within the archive
    outfile = os.path.join (pad, fnm + '.mxl')
    meta  = '%s\n<container><rootfiles>\n' % xmlVersion
    meta += '<rootfile full-path="%s" media-type="application/vnd.recordare.musicxml+xml"/>\n' % fnmext
    meta += '</rootfiles></container>'
    f = ZipFile (outfile, 'w', ZIP_DEFLATED)
    f.writestr ('META-INF/container.xml', meta)
    f.writestr (fnmext, data)
    f.close ()
    info ('%s written' % outfile, warn=0)

def convert (pad, fnm, abc_string, mxl, rOpt=False, tOpt=False, bOpt=False, fOpt=False, mOpt=False):  # not used, backwards compatibility
    score = mxm.parse (abc_string, rOpt, bOpt, fOpt, mOpt)
    writefile (pad, fnm, '', score, mxl, tOpt)

def writefile (pad, fnm, fnmNum, xmldoc, mxlOpt, tOpt=False):
    ipad, ifnm = os.path.split (fnm)                    # base name of input path is
    if tOpt:
        x = xmldoc.findtext ('work/work-title', 'no_title')
        ifnm = x.replace (',','_').replace ("'",'_').replace ('?','_')
    else:
        ifnm += fnmNum
    xmlstr = fixDoctype (xmldoc)
    if pad:
        if not mxlOpt or mxlOpt in ['a', 'add']:
            outfnm = os.path.join (pad, ifnm + '.xml')  # joined with path from -o option
            if python3: outfile = open (outfnm, 'w', encoding='utf-8')  # for Windows ...
            else: outfile = open (outfnm, 'w')
            outfile.write (xmlstr)
            outfile.close ()
            info ('%s written' % outfnm, warn=0)
        if mxlOpt: xml2mxl (pad, ifnm, xmlstr)          # also write a compressed version
    else:
        outfile = sys.stdout
        if not sys.stdout.isatty () and python3 and sys.version_info.minor > 6:
            sys.stdout.reconfigure (encoding='utf-8')   # for Windows again
        outfile.write (xmlstr)
        outfile.write ('\n')

def readfile (fnmext, errmsg='read error: '):
    try:
        if fnmext == '-.abc': fobj = stdin  # see python2/3 differences
        else: fobj = open (fnmext, 'rb')
        encoded_data = fobj.read ()
        fobj.close ()
        return encoded_data if type (encoded_data) == uni_type else decodeInput (encoded_data)
    except Exception as e:
        info (errmsg + repr (e) + ' ' + fnmext)
        return None

def expand_abc_include (abctxt):
    ys = []
    for x in abctxt.splitlines ():
        if x.startswith ('%%abc-include') or x.startswith ('I:abc-include'):
            x = readfile (x[13:].strip (), 'include error: ')
        if x != None: ys.append (x)
    return '\n'.join (ys)

abc_header, abc_voice, abc_scoredef, abc_percmap, abc_acclist = abc_grammar () # compute grammars only once
mxm = MusicXml ()               # same for instance of MusicXml

def getXmlScores (abc_string, skip=0, num=1, rOpt=False, bOpt=False, fOpt=False): # not used, backwards compatibility
    return [fixDoctype (xml_doc) for xml_doc in
        getXmlDocs (abc_string, skip=0, num=1, rOpt=False, bOpt=False, fOpt=False)]

def getXmlDocs (abc_string, skip=0, num=1, rOpt=False, bOpt=False, fOpt=False, mOpt=False): # added by David Randolph
    xml_docs = []
    abctext = expand_abc_include (abc_string)
    fragments = re.split (r'^\s*X:', abctext, flags=re.M)
    preamble = fragments [0]    # tunes can be preceeded by formatting instructions
    tunes = fragments[1:]
    if not tunes and preamble: tunes, preamble = ['1\n' + preamble], ''  # tune without X:
    for itune, tune in enumerate (tunes):
        if itune < skip: continue           # skip tunes, then read at most num tunes
        if itune >= skip + num: break
        tune = preamble + 'X:' + tune       # restore preamble before each tune
        try:                                # convert string abctext -> file pad/fnmNum.xml
            score = mxm.parse (tune, rOpt, bOpt, fOpt, mOpt)
            ds = list (score.iter ('duration')) # need to iterate twice
            ss = [int (d.text) for d in ds]
            deler = reduce (ggd, ss + [21]) # greatest common divisor of all durations
            for i, d in enumerate (ds): d.text = str (ss [i] // deler)
            for d in score.iter ('divisions'): d.text = str (int (d.text) // deler)
            xml_docs.append (score)
        except Exception as err:
            info ('an exception occurred.\n%s' % err)
            #~ pass
            raise
    return xml_docs

#----------------
# Main Program
#----------------
if __name__ == '__main__':
    from optparse import OptionParser
    from glob import glob
    import time

    parser = OptionParser (usage='%prog [-h] [-r] [-t] [-b] [-m SKIP NUM] [-o DIR] [-p PFMT] [-z MODE] [--meta MAP] <file1> [<file2> ...]', version='version %d' % VERSION)
    parser.add_option ("-o", action="store", help="store xml files in DIR", default='', metavar='DIR')
    parser.add_option ("-m", action="store", help="skip SKIP (0) tunes, then read at most NUM (1) tunes", nargs=2, type='int', default=(0,1), metavar='SKIP NUM')
    parser.add_option ("-p", action="store", help="pageformat PFMT (mm) = scale (0.75), pageheight (297), pagewidth (210), leftmargin (18), rightmargin (18), topmargin (10), botmargin (10)", default='', metavar='PFMT')
    parser.add_option ("-z", "--mxl", dest="mxl", help="store as compressed mxl, MODE = a(dd) or r(eplace)", default='', metavar='MODE')
    parser.add_option ("-r", action="store_true", help="show whole measure rests in merged staffs", default=False)
    parser.add_option ("-t", action="store_true", help="use tune title as file name", default=False)
    parser.add_option ("-b", action="store_true", help="line break at EOL", default=False)
    parser.add_option ("--meta", action="store", help="map infofields to XML metadata, MAP = R:poet,Z:lyricist,N:...", default='', metavar='MAP')
    parser.add_option ("-f", action="store_true", help="force string/fret allocations for tab staves", default=False)
    parser.add_option ("--mus53", action="store_true", help="generate makam accidentals playable by musescore", default=False)
    options, args = parser.parse_args ()
    if len (args) == 0: parser.error ('no input file given')
    pad = options.o
    if options.mxl and options.mxl not in ['a','add', 'r', 'replace']:
        parser.error ('MODE should be a(dd) or r(eplace), not: %s' % options.mxl)
    if pad:
        if not os.path.exists (pad): os.mkdir (pad)
        if not os.path.isdir (pad): parser.error ('%s is not a directory' % pad)
    if options.p:   # set page formatting values
        try:        # space, page-height, -width, margin-left, -right, -top, -bottom
            mxm.pageFmtCmd = lmap (float, options.p.split (','))
            if len (mxm.pageFmtCmd) != 7: raise ValueError ('-p needs 7 values')
        except Exception as err: parser.error (err)
    for x in options.meta.split (','):
        if not x: continue
        try: field, tag = x.split (':')
        except: parser.error ('--meta: %s cannot be split on colon' % x)
        if field not in 'OAZNGHRBDFSPW': parser.error ('--meta: field %s is no valid ABC field' % field)
        if tag not in mxm.metaTypes: parser.error ('--meta: tag %s is no valid XML creator type' % tag)
        mxm.metaMap [field] = tag
    fnmext_list = []
    for i in args:
        if i == '-': fnmext_list.append ('-.abc')   # represents standard input
        else:        fnmext_list += glob (i)
    if not fnmext_list: parser.error ('none of the input files exist')
    t_start = time.time ()
    for fnmext in fnmext_list:
        fnm, ext = os.path.splitext (fnmext)
        if ext.lower () not in ('.abc'):
            info ('skipped input file %s, it should have extension .abc' % fnmext)
            continue
        if os.path.isdir (fnmext):
            info ('skipped directory %s. Only files are accepted' % fnmext)
            continue
        abctext = readfile (fnmext)
        skip, num = options.m
        xml_docs = getXmlDocs (abctext, skip, num, options.r, options.b, options.f, options.mus53)
        for itune, xmldoc in enumerate (xml_docs):
            fnmNum = '%02d' % (itune + 1) if len (xml_docs) > 1 else ''
            writefile (pad, fnm, fnmNum, xmldoc, options.mxl, options.t)
    info ('done in %.2f secs' % (time.time () - t_start))
