upl base codes

.gitattributes

@@ -1,35 +1,35 @@
 *.7z filter=lfs diff=lfs merge=lfs -text
 *.arrow filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text
+*.bin.* filter=lfs diff=lfs merge=lfs -text
 *.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
 *.ftz filter=lfs diff=lfs merge=lfs -text
 *.gz filter=lfs diff=lfs merge=lfs -text
 *.h5 filter=lfs diff=lfs merge=lfs -text
 *.joblib filter=lfs diff=lfs merge=lfs -text
 *.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
 *.model filter=lfs diff=lfs merge=lfs -text
 *.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
 *.onnx filter=lfs diff=lfs merge=lfs -text
 *.ot filter=lfs diff=lfs merge=lfs -text
 *.parquet filter=lfs diff=lfs merge=lfs -text
 *.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
 *.pt filter=lfs diff=lfs merge=lfs -text
 *.pth filter=lfs diff=lfs merge=lfs -text
 *.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
 saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
 *.tflite filter=lfs diff=lfs merge=lfs -text
 *.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
 *.xz filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.zstandard filter=lfs diff=lfs merge=lfs -text
+*.tfevents* filter=lfs diff=lfs merge=lfs -text
+*.db* filter=lfs diff=lfs merge=lfs -text
+*.ark* filter=lfs diff=lfs merge=lfs -text
+**/*ckpt*data* filter=lfs diff=lfs merge=lfs -text
+**/*ckpt*.meta filter=lfs diff=lfs merge=lfs -text
+**/*ckpt*.index filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.AppImage filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,3 @@
+example/*
+*__pycache__
+test.py

app.py

@@ -0,0 +1,61 @@
+import os
+import sys
+import torch
+import shutil
+import gradio as gr
+from piano_transcription_inference import PianoTranscription, sample_rate, load_audio
+from convert import *
+
+
+def audio2midi(audio_path: str):
+    if os.path.exists("./example"):
+        shutil.rmtree("./example")
+
+    os.mkdir("./example")
+    # Load audio
+    audio, _ = load_audio(audio_path, sr=sample_rate, mono=True)
+    if not sys.platform.startswith("linux"):
+        userdir = os.path.expandvars(r"%USERPROFILE%")
+        if not os.path.exists(
+            f"{userdir}/piano_transcription_inference_data/note_F1=0.9677_pedal_F1=0.9186.pth"
+        ):
+            download(
+                "https://www.modelscope.cn/api/v1/models/monetjoe/CRNN_note_F1_0.9677_pedal_F1_0.9186/repo?Revision=master&FilePath=CRNN_note_F1%3D0.9677_pedal_F1%3D0.9186.pth",
+                f"{userdir}/piano_transcription_inference_data",
+                "note_F1=0.9677_pedal_F1=0.9186.pth",
+            )
+    # Transcriptor
+    transcriptor = PianoTranscription(
+        device="cuda" if torch.cuda.is_available() else "cpu", checkpoint_path=None
+    )  # device: 'cuda' | 'cpu'
+    # Transcribe and write out to MIDI file
+    basename = os.path.basename(audio_path).split(".")[-2]
+    midi_path = f"./example/{basename}.mid"
+    # midi_path = audio_path.replace(audio_path.split(".")[-1], "mid")
+    transcriptor.transcribe(audio, midi_path)
+    return midi_path
+
+
+def inference(audio_path: str):
+    midi_path = audio2midi(audio_path)
+    xml_path = midi2xml(midi_path)
+    abc = xml2abc(xml_path)
+    mxl_path = xml2mxl(xml_path)
+    pdf_path, jpg_path = mxl2jpg(mxl_path)
+    return midi_path, pdf_path, xml_path, mxl_path, abc, jpg_path
+
+
+iface = gr.Interface(
+    fn=inference,
+    inputs=gr.Audio(label="上传音频100%后再点提交", type="filepath"),
+    outputs=[
+        gr.components.File(label="下载 MIDI"),
+        gr.components.File(label="下载 PDF 乐谱"),
+        gr.components.File(label="下载 MusicXML"),
+        gr.components.File(label="下载 MXL"),
+        gr.Textbox(label="abc 乐谱", show_copy_button=True),
+        gr.Image(label="五线谱", type="filepath"),
+    ],
+)
+
+iface.launch(share=True)

convert.py

@@ -0,0 +1,118 @@
+import os
+import sys
+import fitz
+import requests
+import subprocess
+from PIL import Image
+
+
+def download(url: str, directory: str, filename: str):
+    """
+    Download a .pth file from a URL and save it to a specified directory.
+    Parameters:
+    - url (str): The URL of the .pth file to download.
+    - directory (str): The local directory where the file should be saved.
+    """
+    # Ensure the directory exists, if not, create it
+    if directory != "" and not os.path.exists(directory):
+        os.makedirs(directory)
+    # Create the full path for the file to be saved
+    file_path = os.path.join(directory, filename)
+    # Send a GET request to the URL
+    response = requests.get(url, stream=True)
+    # Check if the request was successful
+    if response.status_code == 200:
+        # Open the file in write-binary mode
+        with open(file_path, "wb") as file:
+            # Write the contents of the response to the file
+            for chunk in response.iter_content(chunk_size=1024):
+                if chunk:  # Filter out keep-alive new chunks
+                    file.write(chunk)
+
+        print(f"The file has been downloaded and saved to {file_path}")
+
+    else:
+        print(f"Failed to download the file. Status code: {response.status_code}")
+
+
+if sys.platform.startswith("linux"):
+    apkname = "MuseScore.AppImage"
+    extra_dir = "squashfs-root"
+    if not os.path.exists(apkname):
+        download(
+            url="https://cdn.jsdelivr.net/musescore/v4.2.0/MuseScore-4.2.0.233521125-x86_64.AppImage",
+            directory="",
+            filename=apkname,
+        )
+
+    if not os.path.exists(extra_dir):
+        subprocess.run(["chmod", "+x", f"./{apkname}"])
+        subprocess.run([f"./{apkname}", "--appimage-extract"])
+
+    mscore = f"./{extra_dir}/AppRun"
+    os.environ["QT_QPA_PLATFORM"] = "offscreen"
+
+else:
+    mscore = "D:/Program Files/MuseScore 3/bin/MuseScore3.exe"
+
+
+def xml2abc(xml_path: str):
+    result = subprocess.run(
+        f"python xml2abc.py {xml_path}", stdout=subprocess.PIPE, text=True
+    )
+    if result.returncode == 0:
+        return result.stdout
+
+    return ""
+
+
+def xml2mxl(xml_path: str):
+    mxl_file = xml_path.replace(".musicxml", ".mxl")
+    command = [mscore, "-o", mxl_file, xml_path]
+    result = subprocess.run(command)
+    print(result)
+    return mxl_file
+
+
+def midi2xml(mid_file: str):
+    xml_file = mid_file.replace(".mid", ".musicxml")
+    command = [mscore, "-o", xml_file, mid_file]
+    result = subprocess.run(command)
+    print(result)
+    return xml_file
+
+
+def pdf2img(pdf_path: str):
+    output_path = pdf_path.replace(".pdf", ".jpg")
+    doc = fitz.open(pdf_path)
+    # 创建一个图像列表
+    images = []
+    for page_number in range(doc.page_count):
+        page = doc[page_number]
+        # 将页面渲染为图像
+        image = page.get_pixmap()
+        # 将图像添加到列表
+        images.append(
+            Image.frombytes("RGB", [image.width, image.height], image.samples)
+        )
+    # 竖向合并图像
+    merged_image = Image.new(
+        "RGB", (images[0].width, sum(image.height for image in images))
+    )
+    y_offset = 0
+    for image in images:
+        merged_image.paste(image, (0, y_offset))
+        y_offset += image.height
+    # 保存合并后的图像为JPG
+    merged_image.save(output_path, "JPEG")
+    # 关闭PDF文档
+    doc.close()
+    return output_path
+
+
+def mxl2jpg(mxl_file: str):
+    pdf_score = mxl_file.replace(".mxl", ".pdf")
+    command = [mscore, "-o", pdf_score, mxl_file]
+    result = subprocess.run(command)
+    print(result)
+    return pdf_score, pdf2img(pdf_score)

requirements.txt

@@ -0,0 +1,3 @@
+librosa==0.9.2
+piano_transcription_inference
+pymupdf

xml2abc.py

@@ -0,0 +1,2156 @@
+#!/usr/bin/env python
+# coding=latin-1
+'''
+Copyright (C) 2012-2018: W.G. Vree
+Contributions: M. Tarenskeen, N. Liberg, Paul Villiger, Janus Meuris, Larry Myerscough, 
+Dick Jackson, Jan Wybren de Jong, Mark Zealey.
+
+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>.
+'''
+
+try:
+    import xml.etree.cElementTree as E
+except:
+    import xml.etree.ElementTree as E
+import os
+import sys
+import types
+import re
+import math
+
+VERSION = 145
+
+python3 = sys.version_info.major > 2
+if python3:
+    tupletype = tuple
+    listtype = list
+    max_int = sys.maxsize
+else:
+    tupletype = types.TupleType
+    listtype = types.ListType
+    max_int = sys.maxint
+
+note_ornamentation_map = {        # for notations/, modified from EasyABC
+    'ornaments/trill-mark':       'T',
+    'ornaments/mordent':          'M',
+    'ornaments/inverted-mordent': 'P',
+    'ornaments/turn':             '!turn!',
+    'ornaments/inverted-turn':    '!invertedturn!',
+    'technical/up-bow':           'u',
+    'technical/down-bow':         'v',
+    'technical/harmonic':         '!open!',
+    'technical/open-string':      '!open!',
+    'technical/stopped':          '!plus!',
+    'technical/snap-pizzicato':   '!snap!',
+    'technical/thumb-position':   '!thumb!',
+    'articulations/accent':       '!>!',
+    'articulations/strong-accent': '!^!',
+    'articulations/staccato':     '.',
+    'articulations/staccatissimo': '!wedge!',
+    'articulations/scoop':        '!slide!',
+    'fermata':                    '!fermata!',
+    'arpeggiate':                 '!arpeggio!',
+    'articulations/tenuto':       '!tenuto!',
+    # not sure whether this is the right translation
+    'articulations/staccatissimo': '!wedge!',
+    # not sure whether this is the right translation
+    'articulations/spiccato':     '!wedge!',
+    # this may need to be tested to make sure it appears on the right side of the note
+    'articulations/breath-mark':  '!breath!',
+    'articulations/detached-legato': '!tenuto!.',
+}
+
+dynamics_map = {    # for direction/direction-type/dynamics/
+    'p':    '!p!',
+    'pp':   '!pp!',
+    'ppp':  '!ppp!',
+    'pppp': '!pppp!',
+    'f':    '!f!',
+    'ff':   '!ff!',
+    'fff':  '!fff!',
+    'ffff': '!ffff!',
+    'mp':   '!mp!',
+    'mf':   '!mf!',
+    'sfz':  '!sfz!',
+}
+
+percSvg = '''%%beginsvg
+    <defs>
+    <text id="x" x="-3" y="0">&#xe263;</text>
+    <text id="x-" x="-3" y="0">&#xe263;</text>
+    <text id="x+" x="-3" y="0">&#xe263;</text>
+    <text id="normal" x="-3.7" y="0">&#xe0a3;</text>
+    <text id="normal-" x="-3.7" y="0">&#xe0a3;</text>
+    <text id="normal+" x="-3.7" y="0">&#xe0a4;</text>
+    <g id="circle-x"><text x="-3" y="0">&#xe263;</text><circle r="4" class="stroke"></circle></g>
+    <g id="circle-x-"><text x="-3" y="0">&#xe263;</text><circle r="4" class="stroke"></circle></g>
+    <path id="triangle" d="m-4 -3.2l4 6.4 4 -6.4z" class="stroke" style="stroke-width:1.4"></path>
+    <path id="triangle-" d="m-4 -3.2l4 6.4 4 -6.4z" class="stroke" style="stroke-width:1.4"></path>
+    <path id="triangle+" d="m-4 -3.2l4 6.4 4 -6.4z" class="stroke" style="fill:#000"></path>
+    <path id="square" d="m-3.5 3l0 -6.2 7.2 0 0 6.2z" class="stroke" style="stroke-width:1.4"></path>
+    <path id="square-" d="m-3.5 3l0 -6.2 7.2 0 0 6.2z" class="stroke" style="stroke-width:1.4"></path>
+    <path id="square+" d="m-3.5 3l0 -6.2 7.2 0 0 6.2z" class="stroke" style="fill:#000"></path>
+    <path id="diamond" d="m0 -3l4.2 3.2 -4.2 3.2 -4.2 -3.2z" class="stroke" style="stroke-width:1.4"></path>
+    <path id="diamond-" d="m0 -3l4.2 3.2 -4.2 3.2 -4.2 -3.2z" class="stroke" style="stroke-width:1.4"></path>
+    <path id="diamond+" d="m0 -3l4.2 3.2 -4.2 3.2 -4.2 -3.2z" class="stroke" style="fill:#000"></path>
+    </defs>
+    %%endsvg'''
+
+tabSvg = '''%%beginsvg
+    <style type="text/css">
+    .bf {font-family:sans-serif; font-size:7px}
+    </style>
+    <defs>
+    <rect id="clr" x="-3" y="-1" width="6" height="5" fill="white"></rect>
+    <rect id="clr2" x="-3" y="-1" width="11" height="5" fill="white"></rect>'''
+
+kopSvg = '<g id="kop%s" class="bf"><use xlink:href="#clr"></use><text x="-2" y="3">%s</text></g>\n'
+kopSvg2 = '<g id="kop%s" class="bf"><use xlink:href="#clr2"></use><text x="-2" y="3">%s</text></g>\n'
+
+info_list = []  # diagnostic messages
+
+
+def info(s, warn=1):
+    x = ('-- ' if warn else '') + s + '\n'
+    info_list.append(x)
+    if __name__ == '__main__':  # only when run from the command line
+        sys.stderr.write(x)
+
+# -------------------
+# data abstractions
+# -------------------
+
+
+class Measure:
+    def __init__(s, p):
+        s.reset()
+        s.ixp = p       # part number
+        s.ixm = 0       # measure number
+        s.mdur = 0      # measure duration (nominal metre value in divisions)
+        s.divs = 0      # number of divisions per 1/4
+        s.mtr = 4, 4     # meter
+
+    def reset(s):      # reset each measure
+        s.attr = ''     # measure signatures, tempo
+        s.lline = ''    # left barline, but only holds ':' at start of repeat, otherwise empty
+        s.rline = '|'   # right barline
+        s.lnum = ''     # (left) volta number
+
+
+class Note:
+    def __init__(s, dur=0, n=None):
+        s.tijd = 0      # the time in XML division units
+        s.dur = dur     # duration of a note in XML divisions
+        s.fact = None   # time modification for tuplet notes (num, div)
+        s.tup = ['']    # start(s) and/or stop(s) of tuplet
+        s.tupabc = ''   # abc tuplet string to issue before note
+        s.beam = 0      # 1 = beamed
+        s.grace = 0     # 1 = grace note
+        s.before = []   # abc string that goes before the note/chord
+        s.after = ''    # the same after the note/chord
+        s.ns = n and [n] or []  # notes in the chord
+        s.lyrs = {}     # {number -> syllabe}
+        s.tab = None    # (string number, fret number)
+        s.ntdec = ''    # !string!, !courtesy!
+
+
+class Elem:
+    def __init__(s, string):
+        s.tijd = 0      # the time in XML division units
+        s.str = string  # any abc string that is not a note
+
+
+class Counter:
+    def inc(s, key, voice): s.counters[key][voice] = s.counters[key].get(
+        voice, 0) + 1
+
+    def clear(s, vnums):  # reset all counters
+        tups = list(zip(vnums.keys(), len(vnums) * [0]))
+        s.counters = {'note': dict(tups), 'nopr': dict(
+            tups), 'nopt': dict(tups)}
+
+    def getv(s, key, voice): return s.counters[key][voice]
+
+    def prcnt(s, ip):  # print summary of all non zero counters
+        for iv in s.counters['note']:
+            if s.getv('nopr', iv) != 0:
+                info('part %d, voice %d has %d skipped non printable notes' %
+                     (ip, iv, s.getv('nopr', iv)))
+            if s.getv('nopt', iv) != 0:
+                info('part %d, voice %d has %d notes without pitch' %
+                     (ip, iv, s.getv('nopt', iv)))
+            if s.getv('note', iv) == 0:  # no real notes counted in this voice
+                info('part %d, skipped empty voice %d' % (ip, iv))
+
+
+class Music:
+    def __init__(s, options):
+        s.tijd = 0              # the current time
+        s.maxtime = 0           # maximum time in a measure
+        s.gMaten = []           # [voices,.. for all measures in a part]
+        # [{num: (abc_lyric_string, melis)},.. for all measures in a part]
+        s.gLyrics = []
+        # all used voice id's in a part (xml voice id's == numbers)
+        s.vnums = {}
+        s.cnt = Counter()      # global counter object
+        s.vceCnt = 1            # the global voice count over all parts
+        s.lastnote = None       # the last real note record inserted in s.voices
+        s.bpl = options.b       # the max number of bars per line when writing abc
+        s.cpl = options.n       # the number of chars per line when writing abc
+        s.repbra = 0            # true if volta is used somewhere
+        s.nvlt = options.v      # no volta on higher voice numbers
+        s.jscript = options.j   # compatibility with javascript version
+
+    def initVoices(s, newPart=0):
+        s.vtimes, s.voices, s.lyrics = {}, {}, {}
+        for v in s.vnums:
+            # {voice: the end time of the last item in each voice}
+            s.vtimes[v] = 0
+            s.voices[v] = []   # {voice: [Note|Elem, ..]}
+            s.lyrics[v] = []   # {voice: [{num: syl}, ..]}
+        if newPart:
+            s.cnt.clear(s.vnums)   # clear counters once per part
+
+    def incTime(s, dt):
+        s.tijd += dt
+        if s.tijd < 0:
+            s.tijd = 0   # erroneous <backup> element
+        if s.tijd > s.maxtime:
+            s.maxtime = s.tijd
+
+    def appendElemCv(s, voices, elem):
+        for v in voices:
+            s.appendElem(v, elem)  # insert element in all voices
+
+    def insertElem(s, v, elem):    # insert at the start of voice v in the current measure
+        obj = Elem(elem)
+        obj.tijd = 0        # because voice is sorted later
+        s.voices[v].insert(0, obj)
+
+    def appendObj(s, v, obj, dur):
+        obj.tijd = s.tijd
+        s.voices[v].append(obj)
+        s.incTime(dur)
+        if s.tijd > s.vtimes[v]:
+            s.vtimes[v] = s.tijd   # don't update for inserted earlier items
+
+    def appendElem(s, v, elem, tel=0):
+        s.appendObj(v, Elem(elem), 0)
+        if tel:
+            # count number of certain elements in each voice (in addition to notes)
+            s.cnt.inc('note', v)
+
+    def appendElemT(s, v, elem, tijd):  # insert element at specified time
+        obj = Elem(elem)
+        obj.tijd = tijd
+        s.voices[v].append(obj)
+
+    def appendNote(s, v, note, noot):
+        note.ns.append(note.ntdec + noot)
+        s.appendObj(v, note, int(note.dur))
+        # remember last note/rest for later modifications (chord, grace)
+        s.lastnote = note
+        if noot != 'z' and noot != 'x':         # real notes and grace notes
+            s.cnt.inc('note', v)   # count number of real notes in each voice
+            if not note.grace:                  # for every real note
+                s.lyrics[v].append(note.lyrs)  # even when it has no lyrics
+
+    def getLastRec(s, voice):
+        if s.gMaten:
+            # the last record in the last measure
+            return s.gMaten[-1][voice][-1]
+        return None                                 # no previous records in the first measure
+
+    def getLastMelis(s, voice, num):   # get melisma of last measure
+        if s.gLyrics:
+            # the previous lyrics dict in this voice
+            lyrdict = s.gLyrics[-1][voice]
+            if num in lyrdict:
+                # lyrdict = num -> (lyric string, melisma)
+                return lyrdict[num][1]
+        return 0  # no previous lyrics in voice or line number
+
+    def addChord(s, note, noot):   # careful: we assume that chord notes follow immediately
+        for d in note.before:       # put all decorations before chord
+            if d not in s.lastnote.before:
+                s.lastnote.before += [d]
+        s.lastnote.ns.append(note.ntdec + noot)
+
+    def addBar(s, lbrk, m):  # linebreak, measure data
+        if m.mdur and s.maxtime > m.mdur:
+            info('measure %d in part %d longer than metre' % (m.ixm+1, m.ixp+1))
+        s.tijd = s.maxtime              # the time of the bar lines inserted here
+        for v in s.vnums:
+            if m.lline or m.lnum:       # if left barline or left volta number
+                p = s.getLastRec(v)    # get the previous barline record
+                if p:                   # in measure 1 no previous measure is available
+                    x = p.str           # p.str is the ABC barline string
+                    if m.lline:         # append begin of repeat, m.lline == ':'
+                        x = (x + m.lline).replace(':|:',
+                                                  '::').replace('||', '|')
+                    if s.nvlt == 3:     # add volta number only to lowest voice in part 0
+                        if m.ixp + v == min(s.vnums):
+                            x += m.lnum
+                    elif m.lnum:        # new behaviour with I:repbra 0
+                        # add volta number(s) or text to all voices
+                        x += m.lnum
+                        s.repbra = 1    # signal occurrence of a volta
+                    p.str = x           # modify previous right barline
+                elif m.lline:           # begin of new part and left repeat bar is required
+                    s.insertElem(v, '|:')
+            if lbrk:
+                p = s.getLastRec(v)    # get the previous barline record
+                if p:
+                    p.str += lbrk     # insert linebreak char after the barlines+volta
+            if m.attr:                  # insert signatures at front of buffer
+                s.insertElem(v, '%s' % m.attr)
+            # insert current barline record at time maxtime
+            s.appendElem(v, ' %s' % m.rline)
+            # make all times consistent
+            s.voices[v] = sortMeasure(s.voices[v], m)
+            lyrs = s.lyrics[v]          # [{number: sylabe}, .. for all notes]
+            # {number: (abc_lyric_string, melis)} for this voice
+            lyrdict = {}
+            # the lyrics numbers in this measure
+            nums = [num for d in lyrs for num in d.keys()]
+            # the highest lyrics number in this measure
+            maxNums = max(nums + [0])
+            for i in range(maxNums, 0, -1):
+                # collect the syllabi with number i
+                xs = [syldict.get(i, '') for syldict in lyrs]
+                melis = s.getLastMelis(v, i)  # get melisma from last measure
+                lyrdict[i] = abcLyr(xs, melis)
+            # {number: (abc_lyric_string, melis)} for this measure
+            s.lyrics[v] = lyrdict
+            mkBroken(s.voices[v])
+        s.gMaten.append(s.voices)
+        s.gLyrics.append(s.lyrics)
+        s.tijd = s.maxtime = 0
+        s.initVoices()
+
+    def outVoices(s, divs, ip, isSib):  # output all voices of part ip
+        # xml voice number -> abc voice number (one part)
+        vvmap = {}
+        vnum_keys = list(s.vnums.keys())
+        if s.jscript or isSib:
+            vnum_keys.sort()
+        lvc = min(vnum_keys or [1])  # lowest xml voice number of this part
+        for iv in vnum_keys:
+            if s.cnt.getv('note', iv) == 0:    # no real notes counted in this voice
+                continue            # skip empty voices
+            if abcOut.denL:
+                unitL = abcOut.denL  # take the unit length from the -d option
+            else:
+                # compute the best unit length for this voice
+                unitL = compUnitLength(iv, s.gMaten, divs)
+            abcOut.cmpL.append(unitL)  # remember for header output
+            vn, vl = [], {}         # for voice iv: collect all notes to vn and all lyric lines to vl
+            for im in range(len(s.gMaten)):
+                measure = s.gMaten[im][iv]
+                vn.append(outVoice(measure, divs[im], im, ip, unitL))
+                checkMelismas(s.gLyrics, s.gMaten, im, iv)
+                for n, (lyrstr, melis) in s.gLyrics[im][iv].items():
+                    if n in vl:
+                        while len(vl[n]) < im:
+                            vl[n].append('')  # fill in skipped measures
+                        vl[n].append(lyrstr)
+                    else:
+                        vl[n] = im * [''] + [lyrstr]    # must skip im measures
+            for n, lyrs in vl.items():  # fill up possibly empty lyric measures at the end
+                mis = len(vn) - len(lyrs)
+                lyrs += mis * ['']
+            abcOut.add('V:%d' % s.vceCnt)
+            if s.repbra:
+                if s.nvlt == 1 and s.vceCnt > 1:
+                    abcOut.add('I:repbra 0')  # only volta on first voice
+                if s.nvlt == 2 and iv > lvc:
+                    # only volta on first voice of each part
+                    abcOut.add('I:repbra 0')
+            if s.cpl > 0:
+                # option -n (max chars per line) overrules -b (max bars per line)
+                s.bpl = 0
+            elif s.bpl == 0:
+                s.cpl = 100    # the default: 100 chars per line
+            bn = 0                  # count bars
+            while vn:               # while still measures available
+                ib = 1
+                chunk = vn[0]
+                while ib < len(vn):
+                    if s.cpl > 0 and len(chunk) + len(vn[ib]) >= s.cpl:
+                        break    # line full (number of chars)
+                    if s.bpl > 0 and ib >= s.bpl:
+                        # line full (number of bars)
+                        break
+                    chunk += vn[ib]
+                    ib += 1
+                bn += ib
+                abcOut.add(chunk + ' %%%d' % bn)   # line with barnumer
+                del vn[:ib]         # chop ib bars
+                # order the numbered lyric lines for output
+                lyrlines = sorted(vl.items())
+                for n, lyrs in lyrlines:
+                    abcOut.add('w: ' + '|'.join(lyrs[:ib]) + '|')
+                    del lyrs[:ib]
+            vvmap[iv] = s.vceCnt   # xml voice number -> abc voice number
+            s.vceCnt += 1           # count voices over all parts
+        s.gMaten = []               # reset the follwing instance vars for each part
+        s.gLyrics = []
+        # print summary of skipped items in this part
+        s.cnt.prcnt(ip+1)
+        return vvmap
+
+
+class ABCoutput:
+    pagekeys = 'scale,pageheight,pagewidth,leftmargin,rightmargin,topmargin,botmargin'.split(
+        ',')
+
+    def __init__(s, fnmext, pad, X, options):
+        s.fnmext = fnmext
+        s.outlist = []          # list of ABC strings
+        s.title = 'T:Title'
+        s.key = 'none'
+        s.clefs = {}            # clefs for all abc-voices
+        s.mtr = 'none'
+        s.tempo = 0             # 0 -> no tempo field
+        s.tempo_units = (1, 4)  # note type of tempo direction
+        s.pad = pad             # the output path or none
+        s.X = X + 1             # the abc tune number
+        # denominator of the unit length (L:) from -d option
+        s.denL = options.d
+        # 0 -> no %%MIDI, 1 -> only program, 2 -> all %%MIDI
+        s.volpan = int(options.m)
+        s.cmpL = []             # computed optimal unit length for all voices
+        s.jscript = options.j   # compatibility with javascript version
+        s.tstep = options.t     # translate percmap to voicemap
+        s.stemless = 0          # use U:s=!stemless!
+        s.shiftStem = options.s  # shift note heads 3 units left
+        s.dojef = 0             # => s.tstep in mkHeader
+        if pad:
+            _, base_name = os.path.split(fnmext)
+            s.outfile = open(os.path.join(pad, base_name), 'w')
+        else:
+            s.outfile = sys.stdout
+        if s.jscript:
+            s.X = 1   # always X:1 in javascript version
+        s.pageFmt = {}
+        for k in s.pagekeys:
+            s.pageFmt[k] = None
+        if len(options.p) == 7:
+            for k, v in zip(s.pagekeys, options.p):
+                try:
+                    s.pageFmt[k] = float(v)
+                except:
+                    info('illegal float %s for %s', (k, v))
+                    continue
+
+    def add(s, str):
+        s.outlist.append(str + '\n')   # collect all ABC output
+
+    # stfmap = [parts], part = [staves], stave = [voices]
+    def mkHeader(s, stfmap, partlist, midimap, vmpdct, koppen):
+        accVce, accStf, staffs = [], [], stfmap[:]  # staffs is consumed
+        for x in partlist:              # collect partnames into accVce and staff groups into accStf
+            try:
+                prgroupelem(x, ('', ''), '', stfmap, accVce, accStf)
+            except:
+                info('lousy musicxml: error in part-list')
+        staves = ' '.join(accStf)
+        clfnms = {}
+        for part, (partname, partabbrv) in zip(staffs, accVce):
+            if not part:
+                continue       # skip empty part
+            firstVoice = part[0][0]     # the first voice number in this part
+            nm = partname.replace('\n', '\\n').replace('.:', '.').strip(':')
+            snm = partabbrv.replace('\n', '\\n').replace('.:', '.').strip(':')
+            clfnms[firstVoice] = (nm and 'nm="%s"' %
+                                  nm or '') + (snm and ' snm="%s"' % snm or '')
+        hd = ['X:%d\n%s\n' % (s.X, s.title)]
+        for i, k in enumerate(s.pagekeys):
+            if s.jscript and k in ['pageheight', 'topmargin', 'botmargin']:
+                continue
+            if s.pageFmt[k] != None:
+                hd.append('%%%%%s %.2f%s\n' %
+                          (k, s.pageFmt[k], i > 0 and 'cm' or ''))
+        if staves and len(accStf) > 1:
+            hd.append('%%score ' + staves + '\n')
+        # default no tempo field
+        tempo = s.tempo and 'Q:%d/%d=%s\n' % (
+            s.tempo_units[0], s.tempo_units[1], s.tempo) or ''
+        d = {}  # determine the most frequently occurring unit length over all voices
+        for x in s.cmpL:
+            d[x] = d.get(x, 0) + 1
+        if s.jscript:
+            # when tie (1) sort on key (0)
+            defLs = sorted(d.items(), key=lambda x: (-x[1], x[0]))
+        else:
+            defLs = sorted(d.items(), key=lambda x: -x[1])
+        # override default unit length with -d option
+        defL = s.denL and s.denL or defLs[0][0]
+        hd.append('L:1/%d\n%sM:%s\n' % (defL, tempo, s.mtr))
+        hd.append('I:linebreak $\nK:%s\n' % s.key)
+        if s.stemless:
+            hd.append('U:s=!stemless!\n')
+        vxs = sorted(vmpdct.keys())
+        for vx in vxs:
+            hd.extend(vmpdct[vx])
+        s.dojef = 0    # translate percmap to voicemap
+        for vnum, clef in s.clefs.items():
+            ch, prg, vol, pan = midimap[vnum-1][:4]
+            # map of abc percussion notes to midi notes
+            dmap = midimap[vnum - 1][4:]
+            if dmap and 'perc' not in clef:
+                clef = (clef + ' map=perc').strip()
+            hd.append('V:%d %s %s\n' % (vnum, clef, clfnms.get(vnum, '')))
+            if vnum in vmpdct:
+                hd.append('%%%%voicemap tab%d\n' % vnum)
+                hd.append(
+                    'K:none\nM:none\n%%clef none\n%%staffscale 1.6\n%%flatbeams true\n%%stemdir down\n')
+            if 'perc' in clef:
+                hd.append('K:none\n')  # no key for a perc voice
+            if s.volpan > 1:    # option -m 2 -> output all recognized midi commands when needed and present in xml
+                if ch > 0 and ch != vnum:
+                    hd.append('%%%%MIDI channel %d\n' % ch)
+                if prg > 0:
+                    hd.append('%%%%MIDI program %d\n' % (prg - 1))
+                if vol >= 0:
+                    # volume == 0 is possible ...
+                    hd.append('%%%%MIDI control 7 %.0f\n' % vol)
+                if pan >= 0:
+                    hd.append('%%%%MIDI control 10 %.0f\n' % pan)
+            elif s.volpan > 0:  # default -> only output midi program command when present in xml
+                if dmap and ch > 0:
+                    # also channel if percussion part
+                    hd.append('%%%%MIDI channel %d\n' % ch)
+                if prg > 0:
+                    hd.append('%%%%MIDI program %d\n' % (prg - 1))
+            for abcNote, step, midiNote, notehead in dmap:
+                if not notehead:
+                    notehead = 'normal'
+                if abcMid(abcNote) != midiNote or abcNote != step:
+                    if s.volpan > 0:
+                        hd.append('%%%%MIDI drummap %s %s\n' %
+                                  (abcNote, midiNote))
+                    hd.append('I:percmap %s %s %s %s\n' %
+                              (abcNote, step, midiNote, notehead))
+                    s.dojef = s.tstep   # == options.t
+            if defL != s.cmpL[vnum-1]:  # only if computed unit length different from header
+                hd.append('L:1/%d\n' % s.cmpL[vnum-1])
+        s.outlist = hd + s.outlist
+        if koppen:  # output SVG stuff needed for tablature
+            # shift note heads 3 units left
+            k1 = kopSvg.replace('-2', '-5') if s.shiftStem else kopSvg
+            k2 = kopSvg2.replace('-2', '-5') if s.shiftStem else kopSvg2
+            tb = tabSvg.replace('-3', '-6') if s.shiftStem else tabSvg
+            # javascript compatibility
+            ks = sorted(koppen.keys())
+            ks = [k2 % (k, k) if len(k) == 2 else k1 % (k, k) for k in ks]
+            # javascript compatibility
+            tbs = map(lambda x: x.strip() + '\n', tb.splitlines())
+            s.outlist = tbs + ks + ['</defs>\n%%endsvg\n'] + s.outlist
+
+    def getABC(s):
+        str = ''.join(s.outlist)
+        if s.dojef:
+            str = perc2map(str)
+        return str
+
+    def writeall(s):  # determine the required encoding of the entire ABC output
+        str = s.getABC()
+        if python3:
+            s.outfile.write(str)
+        else:
+            s.outfile.write(str.encode('utf-8'))
+        if s.pad:
+            s.outfile.close()                # close each file with -o option
+        else:
+            # add empty line between tunes on stdout
+            s.outfile.write('\n')
+        # info('%s written with %d voices' % (s.fnmext, len(s.clefs)), warn=0)
+
+# ----------------
+# functions
+# ----------------
+
+
+def abcLyr(xs, melis):  # Convert list xs to abc lyrics.
+    if not ''.join(xs):
+        return '', 0  # there is no lyrics in this measure
+    res = []
+    for x in xs:        # xs has for every note a lyrics syllabe or an empty string
+        if x == '':     # note without lyrics
+            if melis:
+                x = '_'   # set melisma
+            else:
+                x = '*'       # skip note
+        elif x.endswith('_') and not x.endswith('\_'):  # start of new melisma
+            x = x.replace('_', '')  # remove and set melis boolean
+            melis = 1           # so next skips will become melisma
+        else:
+            melis = 0         # melisma stops on first syllable
+        res.append(x)
+    return (' '.join(res), melis)
+
+
+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 abcdur(nx, divs, uL):      # convert an musicXML duration d to abc units with L:1/uL
+    if nx.dur == 0:
+        return ''   # when called for elements without duration
+    num, den = simplify(uL * nx.dur, divs * 4)  # L=1/8 -> uL = 8 units
+    if nx.fact:                 # apply tuplet time modification
+        numfac, denfac = nx.fact
+        num, den = simplify(num * numfac, den * denfac)
+    if den > 64:                # limit the denominator to a maximum of 64
+        x = float(num) / den
+        n = math.floor(x)  # when just above an integer n
+        if x - n < 0.1 * x:
+            num, den = n, 1        # round to n
+        num64 = 64. * num / den + 1.0e-15           # to get Python2 behaviour of round
+        num, den = simplify(int(round(num64)), 64)
+    if num == 1:
+        if den == 1:
+            dabc = ''
+        elif den == 2:
+            dabc = '/'
+        else:
+            dabc = '/%d' % den
+    elif den == 1:
+        dabc = '%d' % num
+    else:
+        dabc = '%d/%d' % (num, den)
+    return dabc
+
+
+def abcMid(note):  # abc note -> midi pitch
+    r = re.search(r"([_^]*)([A-Ga-g])([',]*)", note)
+    if not r:
+        return -1
+    acc, n, oct = r.groups()
+    nUp = n.upper()
+    p = 60 + [0, 2, 4, 5, 7, 9,
+              11]['CDEFGAB'.index(nUp)] + (12 if nUp != n else 0)
+    if acc:
+        p += (1 if acc[0] == '^' else -1) * len(acc)
+    if oct:
+        p += (12 if oct[0] == "'" else -12) * len(oct)
+    return p
+
+
+def staffStep(ptc, o, clef, tstep):
+    ndif = 0
+    if 'stafflines=1' in clef:
+        ndif += 4                    # meaning of one line: E (xml) -> B (abc)
+    if not tstep and clef.startswith('bass'):
+        ndif += 12   # transpose bass -> treble (C3 -> A4)
+    if ndif:    # diatonic transposition == addition modulo 7
+        nm7 = 'C,D,E,F,G,A,B'.split(',')
+        n = nm7.index(ptc) + ndif
+        ptc, o = nm7[n % 7], o + n // 7
+    if o > 4:
+        ptc = ptc.lower()
+    if o > 5:
+        ptc = ptc + (o-5) * "'"
+    if o < 4:
+        ptc = ptc + (4-o) * ","
+    return ptc
+
+
+def setKey(fifths, mode):
+    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, 'ion': 8, 'm': 11, 'min': 11, 'aeo': 11,
+              'mix': 9, 'dor': 10, 'phr': 12, 'lyd': 7, 'loc': 13, 'non': 8}
+    mode = mode.lower()[:3]  # only first three chars, no case
+    key = sharpness[offTab[mode] + fifths] + \
+        (mode if offTab[mode] != 8 else '')
+    accs = ['F', 'C', 'G', 'D', 'A', 'E', 'B']
+    if fifths >= 0:
+        msralts = dict(zip(accs[:fifths], fifths * [1]))
+    else:
+        msralts = dict(zip(accs[fifths:], -fifths * [-1]))
+    return key, msralts
+
+
+def insTup(ix, notes, fact):   # read one nested tuplet
+    tupcnt = 0
+    nx = notes[ix]
+    if 'start' in nx.tup:
+        nx.tup.remove('start')  # do recursive calls when starts remain
+    tix = ix                    # index of first tuplet note
+    fn, fd = fact               # xml time-mod of the higher level
+    fnum, fden = nx.fact        # xml time-mod of the current level
+    tupfact = fnum//fn, fden//fd  # abc time mod of this level
+    while ix < len(notes):
+        lastix = ix - 1
+        nx = notes[ix]
+        if isinstance(nx, Elem) or nx.grace:
+            ix += 1             # skip all non tuplet elements
+            continue
+        if 'start' in nx.tup:   # more nested tuplets to start
+            # ix is on the stop note!
+            ix, tupcntR = insTup(ix, notes, tupfact)
+            tupcnt += tupcntR
+        elif nx.fact:
+            tupcnt += 1         # count tuplet elements
+        if 'stop' in nx.tup:
+            nx.tup.remove('stop')
+            break
+        if not nx.fact:         # stop on first non tuplet note
+            ix = lastix         # back to last tuplet note
+            break
+        ix += 1
+    # put abc tuplet notation before the recursive ones
+    tup = (tupfact[0], tupfact[1], tupcnt)
+    if tup == (3, 2, 3):
+        tupPrefix = '(3'
+    else:
+        tupPrefix = '(%d:%d:%d' % tup
+    notes[tix].tupabc = tupPrefix + notes[tix].tupabc
+    return ix, tupcnt           # ix is on the last tuplet note
+
+
+def mkBroken(vs):      # introduce broken rhythms (vs: one voice, one measure)
+    vs = [n for n in vs if isinstance(n, Note)]
+    i = 0
+    while i < len(vs) - 1:
+        n1, n2 = vs[i], vs[i+1]     # scan all adjacent pairs
+        # skip if note in tuplet or has no duration or outside beam
+        if not n1.fact and not n2.fact and n1.dur > 0 and n2.beam:
+            if n1.dur * 3 == n2.dur:
+                n2.dur = (2 * n2.dur) // 3
+                n1.dur = n1.dur * 2
+                n1.after = '<' + n1.after
+                i += 1              # do not chain broken rhythms
+            elif n2.dur * 3 == n1.dur:
+                n1.dur = (2 * n1.dur) // 3
+                n2.dur = n2.dur * 2
+                n1.after = '>' + n1.after
+                i += 1              # do not chain broken rhythms
+        i += 1
+
+
+def outVoice(measure, divs, im, ip, unitL):    # note/elem objects of one measure in one voice
+    ix = 0
+    while ix < len(measure):   # set all (nested) tuplet annotations
+        nx = measure[ix]
+        if isinstance(nx, Note) and nx.fact and not nx.grace:
+            # read one tuplet, insert annotation(s)
+            ix, tupcnt = insTup(ix, measure, (1, 1))
+        ix += 1
+    vs = []
+    for nx in measure:
+        if isinstance(nx, Note):
+            # xml -> abc duration string
+            durstr = abcdur(nx, divs, unitL)
+            chord = len(nx.ns) > 1
+            cns = [nt[:-1] for nt in nx.ns if nt.endswith('-')]
+            tie = ''
+            if chord and len(cns) == len(nx.ns):      # all chord notes tied
+                nx.ns = cns     # chord notes without tie
+                tie = '-'       # one tie for whole chord
+            s = nx.tupabc + ''.join(nx.before)
+            if chord:
+                s += '['
+            for nt in nx.ns:
+                s += nt
+            if chord:
+                s += ']' + tie
+            if s.endswith('-'):
+                s, tie = s[:-1], '-'   # split off tie
+            s += durstr + tie   # and put it back again
+            s += nx.after
+            nospace = nx.beam
+        else:
+            if isinstance(nx.str, listtype):
+                nx.str = nx.str[0]
+            s = nx.str
+            nospace = 1
+        if nospace:
+            vs.append(s)
+        else:
+            vs.append(' ' + s)
+    vs = ''.join(vs)   # ad hoc: remove multiple pedal directions
+    while vs.find('!ped!!ped!') >= 0:
+        vs = vs.replace('!ped!!ped!', '!ped!')
+    while vs.find('!ped-up!!ped-up!') >= 0:
+        vs = vs.replace('!ped-up!!ped-up!', '!ped-up!')
+    while vs.find('!8va(!!8va)!') >= 0:
+        vs = vs.replace('!8va(!!8va)!', '')    # remove empty ottava's
+    return vs
+
+
+def sortMeasure(voice, m):
+    voice.sort(key=lambda o: o.tijd)   # sort on time
+    time = 0
+    v = []
+    rs = []                            # holds rests in between notes
+    for i, nx in enumerate(voice):    # establish sequentiality
+        if nx.tijd > time and chkbug(nx.tijd - time, m):
+            # fill hole with invisble rest
+            v.append(Note(nx.tijd - time, 'x'))
+            rs.append(len(v) - 1)
+        if isinstance(nx, Elem):
+            if nx.tijd < time:
+                nx.tijd = time  # shift elems without duration to where they fit
+            v.append(nx)
+            time = nx.tijd
+            continue
+        if nx.tijd < time:                  # overlapping element
+            if nx.ns[0] == 'z':
+                continue    # discard overlapping rest
+            if v[-1].tijd <= nx.tijd:       # we can do something
+                if v[-1].ns[0] == 'z':      # shorten rest
+                    v[-1].dur = nx.tijd - v[-1].tijd
+                    if v[-1].dur == 0:
+                        del v[-1]        # nothing left
+                    info('overlap in part %d, measure %d: rest shortened' %
+                         (m.ixp+1, m.ixm+1))
+                else:                       # make a chord of overlap
+                    v[-1].ns += nx.ns
+                    info('overlap in part %d, measure %d: added chord' %
+                         (m.ixp+1, m.ixm+1))
+                    nx.dur = (nx.tijd + nx.dur) - time  # the remains
+                    if nx.dur <= 0:
+                        continue            # nothing left
+                    nx.tijd = time          # append remains
+            else:                           # give up
+                info('overlapping notes in one voice! part %d, measure %d, note %s discarded' % (
+                    m.ixp+1, m.ixm+1, isinstance(nx, Note) and nx.ns or nx.str))
+                continue
+        v.append(nx)
+        if isinstance(nx, Note):
+            if nx.ns[0] in 'zx':
+                rs.append(len(v) - 1)     # remember rests between notes
+            elif len(rs):
+                if nx.beam and not nx.grace:    # copy beam into rests
+                    for j in rs:
+                        v[j].beam = nx.beam
+                rs = []                     # clear rests on each note
+        time = nx.tijd + nx.dur
+    #   when a measure contains no elements and no forwards -> no incTime -> s.maxtime = 0 -> right barline
+    #   is inserted at time == 0 (in addbar) and is only element in the voice when sortMeasure is called
+    if time == 0:
+        info('empty measure in part %d, measure %d, it should contain at least a rest to advance the time!' % (
+            m.ixp+1, m.ixm+1))
+    return v
+
+
+def getPartlist(ps):   # correct part-list (from buggy xml-software)
+    xs = []  # the corrected part-list
+    e = []  # stack of opened part-groups
+    for x in list(ps):  # insert missing stops, delete double starts
+        if x.tag == 'part-group':
+            num, type = x.get('number'), x.get('type')
+            if type == 'start':
+                if num in e:    # missing stop: insert one
+                    xs.append(E.Element('part-group', number=num, type='stop'))
+                    xs.append(x)
+                else:           # normal start
+                    xs.append(x)
+                    e.append(num)
+            else:
+                if num in e:    # normal stop
+                    e.remove(num)
+                    xs.append(x)
+                else:
+                    pass      # double stop: skip it
+        else:
+            xs.append(x)
+    for num in reversed(e):    # fill missing stops at the end
+        xs.append(E.Element('part-group', number=num, type='stop'))
+    return xs
+
+
+def parseParts(xs, d, e):  # -> [elems on current level], rest of xs
+    if not xs:
+        return [], []
+    x = xs.pop(0)
+    if x.tag == 'part-group':
+        num, type = x.get('number'), x.get('type')
+        if type == 'start':  # go one level deeper
+            s = [x.findtext(n, '') for n in ['group-symbol',
+                                             'group-barline', 'group-name', 'group-abbreviation']]
+            d[num] = s     # remember groupdata by group number
+            e.append(num)  # make stack of open group numbers
+            # parse one level deeper to next stop
+            elemsnext, rest1 = parseParts(xs, d, e)
+            # parse the rest on this level
+            elems, rest2 = parseParts(rest1, d, e)
+            return [elemsnext] + elems, rest2
+        else:               # stop: close level and return group-data
+            nums = e.pop()  # last open group number in stack order
+            if xs and xs[0].get('type') == 'stop':     # two consequetive stops
+                # in the wrong order (tempory solution)
+                if num != nums:
+                    # exchange values    (only works for two stops!!!)
+                    d[nums], d[num] = d[num], d[nums]
+            # retrieve an return groupdata as last element of the group
+            sym = d[num]
+            return [sym], xs
+    else:
+        # parse remaining elements on current level
+        elems, rest = parseParts(xs, d, e)
+        name = x.findtext('part-name', ''), x.findtext('part-abbreviation', '')
+        return [name] + elems, rest
+
+
+def bracePart(part):       # put a brace on multistaff part and group voices
+    if not part:
+        return []  # empty part in the score
+    brace = []
+    for ivs in part:
+        if len(ivs) == 1:  # stave with one voice
+            brace.append('%s' % ivs[0])
+        else:               # stave with multiple voices
+            brace += ['('] + ['%s' % iv for iv in ivs] + [')']
+        brace.append('|')
+    del brace[-1]           # no barline at the end
+    if len(part) > 1:
+        brace = ['{'] + brace + ['}']
+    return brace
+
+
+# collect partnames (accVce) and %%score map (accStf)
+def prgroupelem(x, gnm, bar, pmap, accVce, accStf):
+    if type(x) == tupletype:   # partname-tuple = (part-name, part-abbrev)
+        y = pmap.pop(0)
+        if gnm[0]:
+            # put group-name before part-name
+            x = [n1 + ':' + n2 for n1, n2 in zip(gnm, x)]
+        accVce.append(x)
+        accStf.extend(bracePart(y))
+    # misuse of group just to add extra name to stave
+    elif len(x) == 2 and type(x[0]) == tupletype:
+        y = pmap.pop(0)
+        # x[0] = partname-tuple, x[1][2:] = groupname-tuple
+        nms = [n1 + ':' + n2 for n1, n2 in zip(x[0], x[1][2:])]
+        accVce.append(nms)
+        accStf.extend(bracePart(y))
+    else:
+        prgrouplist(x, bar, pmap, accVce, accStf)
+
+
+# collect partnames, scoremap for a part-group
+def prgrouplist(x, pbar, pmap, accVce, accStf):
+    # bracket symbol, continue barline, group-name-tuple
+    sym, bar, gnm, gabbr = x[-1]
+    bar = bar == 'yes' or pbar      # pbar -> the parent has bar
+    accStf.append(sym == 'brace' and '{' or '[')
+    for z in x[:-1]:
+        prgroupelem(z, (gnm, gabbr), bar, pmap, accVce, accStf)
+        if bar:
+            accStf.append('|')
+    if bar:
+        del accStf[-1]         # remove last one before close
+    accStf.append(sym == 'brace' and '}' or ']')
+
+
+def compUnitLength(iv, maten, divs):   # compute optimal unit length
+    uLmin, minLen = 0, max_int
+    for uL in [4, 8, 16]:     # try 1/4, 1/8 and 1/16
+        vLen = 0            # total length of abc duration strings in this voice
+        for im, m in enumerate(maten):  # all measures
+            for e in m[iv]:  # all notes in voice iv
+                if isinstance(e, Elem) or e.dur == 0:
+                    continue  # no real durations
+                # add len of duration string
+                vLen += len(abcdur(e, divs[im], uL))
+        if vLen < minLen:
+            uLmin, minLen = uL, vLen  # remember the smallest
+    return uLmin
+
+
+def doSyllable(syl):
+    txt = ''
+    for e in syl:
+        if e.tag == 'elision':
+            txt += '~'
+        elif e.tag == 'text':   # escape - and space characters
+            txt += (e.text or '').replace('_',
+                                          '\_').replace('-', r'\-').replace(' ', '~')
+    if not txt:
+        return txt
+    if syl.findtext('syllabic') in ['begin', 'middle']:
+        txt += '-'
+    if syl.find('extend') is not None:
+        txt += '_'
+    return txt
+
+
+def checkMelismas(lyrics, maten, im, iv):
+    if im == 0:
+        return
+    maat = maten[im][iv]               # notes of the current measure
+    curlyr = lyrics[im][iv]            # lyrics dict of current measure
+    prvlyr = lyrics[im-1][iv]          # lyrics dict of previous measure
+    for n, (lyrstr, melis) in prvlyr.items():  # all lyric numbers in the previous measure
+        if n not in curlyr and melis:   # melisma required, but no lyrics present -> make one!
+            ms = getMelisma(maat)      # get a melisma for the current measure
+            if ms:
+                # set melisma as the n-th lyrics of the current measure
+                curlyr[n] = (ms, 0)
+
+
+def getMelisma(maat):                  # get melisma from notes in maat
+    ms = []
+    for note in maat:                   # every note should get an underscore
+        if not isinstance(note, Note):
+            continue    # skip Elem's
+        if note.grace:
+            continue         # skip grace notes
+        if note.ns[0] in 'zx':
+            break   # stop on first rest
+        ms.append('_')
+    return ' '.join(ms)
+
+
+def perc2map(abcIn):
+    fillmap = {'diamond': 1, 'triangle': 1, 'square': 1, 'normal': 1}
+    abc = map(lambda x: x.strip(), percSvg.splitlines())
+    id = 'default'
+    maps = {'default': []}
+    dmaps = {'default': []}
+    r1 = re.compile(r'V:\s*(\S+)')
+    ls = abcIn.splitlines()
+    for x in ls:
+        if 'I:percmap' in x:
+            noot, step, midi, kop = map(lambda x: x.strip(), x.split()[1:])
+            if kop in fillmap:
+                kop = kop + '+' + ',' + kop
+            x = '%%%%map perc%s %s print=%s midi=%s heads=%s' % (
+                id, noot, step, midi, kop)
+            maps[id].append(x)
+        if '%%MIDI' in x:
+            dmaps[id].append(x)
+        if 'V:' in x:
+            r = r1.match(x)
+            if r:
+                id = r.group(1)
+                if id not in maps:
+                    maps[id] = []
+                    dmaps[id] = []
+    ids = sorted(maps.keys())
+    for id in ids:
+        abc += maps[id]
+    id = 'default'
+    for x in ls:
+        if 'I:percmap' in x:
+            continue
+        if '%%MIDI' in x:
+            continue
+        if 'V:' in x or 'K:' in x:
+            r = r1.match(x)
+            if r:
+                id = r.group(1)
+            abc.append(x)
+            if id in dmaps and len(dmaps[id]) > 0:
+                abc.extend(dmaps[id])
+                del dmaps[id]
+            if 'perc' in x and 'map=' not in x:
+                x += ' map=perc'
+            if 'map=perc' in x and len(maps[id]) > 0:
+                abc.append('%%voicemap perc' + id)
+            if 'map=off' in x:
+                abc.append('%%voicemap')
+        else:
+            abc.append(x)
+    return '\n'.join(abc) + '\n'
+
+
+def addoct(ptc, o):    # xml staff step, xml octave number
+    p = ptc
+    if o > 4:
+        p = ptc.lower()
+    if o > 5:
+        p = p + (o-5) * "'"
+    if o < 4:
+        p = p + (4-o) * ","
+    return p            # abc pitch == abc note without accidental
+
+
+def chkbug(dt, m):
+    if dt > m.divs / 16:
+        return 1   # duration should be > 1/64 note
+    info('MuseScore bug: incorrect duration, smaller then 1/64! in measure %d, part %d' % (m.ixm, m.ixp))
+    return 0
+
+# ----------------
+# parser
+# ----------------
+
+
+class Parser:
+    note_alts = [   # 3 alternative notations of the same note for tablature mapping
+        [x.strip()
+         for x in '=C,  ^C, =D, ^D, =E, =F, ^F, =G, ^G, =A, ^A, =B'.split(',')],
+        [x.strip()
+         for x in '^B,  _D,^^C, _E, _F, ^E, _G,^^F, _A,^^G, _B, _C'.split(',')],
+        [x.strip() for x in '__D,^^B,__E,__F,^^D,__G,^^E,__A,_/A,__B,__C,^^A'.split(',')]]
+    step_map = {'C': 0, 'D': 2, 'E': 4, 'F': 5, 'G': 7, 'A': 9, 'B': 11}
+
+    def __init__(s, options):
+        # unfold repeats, number of chars per line, credit filter level, volta option
+        s.slurBuf = {}    # dict of open slurs keyed by slur number
+        # {direction-type + number -> (type, voice | time)} dict for proper closing
+        s.dirStk = {}
+        s.ingrace = 0     # marks a sequence of grace notes
+        s.msc = Music(options)  # global music data abstraction
+        s.unfold = options.u    # turn unfolding repeats on
+        s.ctf = options.c       # credit text filter level
+        s.gStfMap = []    # [[abc voice numbers] for all parts]
+        s.midiMap = []    # midi-settings for each abc voice, in order
+        s.drumInst = {}   # inst_id -> midi pitch for channel 10 notes
+        s.drumNotes = {}  # (xml voice, abc note) -> (midi note, note head)
+        s.instMid = []    # [{inst id -> midi-settings} for all parts]
+        # default midi settings for channel, program, volume, panning
+        s.midDflt = [-1, -1, -1, -91]
+        # xml-notenames (without octave) with accidentals from the key
+        s.msralts = {}
+        # abc-notenames (with voice number) with passing accidentals
+        s.curalts = {}
+        s.stfMap = {}     # xml staff number -> [xml voice number]
+        s.vce2stf = {}    # xml voice number -> allocated staff number
+        s.clefMap = {}    # xml staff number -> abc clef (for header only)
+        s.curClef = {}    # xml staff number -> current abc clef
+        s.stemDir = {}    # xml voice number -> current stem direction
+        s.clefOct = {}    # xml staff number -> current clef-octave-change
+        s.curStf = {}     # xml voice number -> current xml staff number
+        s.nolbrk = options.x   # generate no linebreaks ($)
+        s.jscript = options.j   # compatibility with javascript version
+        s.ornaments = sorted(note_ornamentation_map.items())
+        s.doPageFmt = len(options.p) == 1  # translate xml page format
+        s.tstep = options.t     # clef determines step on staff (percussion)
+        s.dirtov1 = options.v1  # all directions to first voice of staff
+        s.ped = options.ped     # render pedal directions
+        s.wstems = options.stm  # translate stem elements
+        s.pedVce = None   # voice for pedal directions
+        s.repeat_str = {}  # staff number -> [measure number, repeat-text]
+        s.tabVceMap = {}  # abc voice num -> [%%map ...] for tab voices
+        s.koppen = {}     # noteheads needed for %%map
+
+    # match slur number n in voice v2, add abc code to before/after
+    def matchSlur(s, type2, n, v2, note2, grace, stopgrace):
+        if type2 not in ['start', 'stop']:
+            return   # slur type continue has no abc equivalent
+        if n == None:
+            n = '1'
+        if n in s.slurBuf:
+            type1, v1, note1, grace1 = s.slurBuf[n]
+            if type2 != type1:              # slur complete, now check the voice
+                if v2 == v1:                # begins and ends in the same voice: keep it
+                    # normal slur: start before stop and no grace slur
+                    if type1 == 'start' and (not grace1 or not stopgrace):
+                        # keep left-right order!
+                        note1.before = ['('] + note1.before
+                        note2.after += ')'
+                    # no else: don't bother with reversed stave spanning slurs
+                del s.slurBuf[n]           # slur finished, remove from stack
+            else:                           # double definition, keep the last
+                info('double slur numbers %s-%s in part %d, measure %d, voice %d note %s, first discarded' %
+                     (type2, n, s.msr.ixp+1, s.msr.ixm+1, v2, note2.ns))
+                s.slurBuf[n] = (type2, v2, note2, grace)
+        else:                               # unmatched slur, put in dict
+            s.slurBuf[n] = (type2, v2, note2, grace)
+
+    def doNotations(s, note, nttn, isTab):
+        for key, val in s.ornaments:
+            if nttn.find(key) != None:
+                note.before += [val]  # just concat all ornaments
+        trem = nttn.find('ornaments/tremolo')
+        if trem != None:
+            type = trem.get('type')
+            if type == 'single':
+                note.before.insert(0, '!%s!' % (int(trem.text) * '/'))
+            else:
+                note.fact = None    # no time modification in ABC
+                if s.tstep:         # abc2svg version
+                    if type == 'stop':
+                        note.before.insert(0, '!trem%s!' % trem.text)
+                else:               # abc2xml version
+                    if type == 'start':
+                        note.before.insert(0, '!%s-!' % (int(trem.text) * '/'))
+        fingering = nttn.findall('technical/fingering')
+        for finger in fingering:    # handle multiple finger annotations
+            if not isTab:
+                # fingering goes before chord (addChord)
+                note.before += ['!%s!' % finger.text]
+        snaar = nttn.find('technical/string')
+        if snaar != None and isTab:
+            if s.tstep:
+                fret = nttn.find('technical/fret')
+                if fret != None:
+                    note.tab = (snaar.text, fret.text)
+            else:
+                # no double string decos (bug in musescore)
+                deco = '!%s!' % snaar.text
+                if deco not in note.ntdec:
+                    note.ntdec += deco
+        wvlns = nttn.findall('ornaments/wavy-line')
+        for wvln in wvlns:
+            if wvln.get('type') == 'start':
+                # keep left-right order!
+                note.before = ['!trill(!'] + note.before
+            elif wvln.get('type') == 'stop':
+                note.after += '!trill)!'
+        glis = nttn.find('glissando')
+        if glis == None:
+            glis = nttn.find('slide')  # treat slide as glissando
+        if glis != None:
+            lt = '~' if glis.get('line-type') == 'wavy' else '-'
+            if glis.get('type') == 'start':
+                # keep left-right order!
+                note.before = ['!%s(!' % lt] + note.before
+            elif glis.get('type') == 'stop':
+                note.before = ['!%s)!' % lt] + note.before
+
+    def tabnote(s, alt, ptc, oct, v, ntrec):
+        p = s.step_map[ptc] + int(alt or '0')  # p in -2 .. 13
+        if p > 11:
+            oct += 1             # octave correction
+        if p < 0:
+            oct -= 1
+        p = p % 12                      # remap p into 0..11
+        snaar_nw, fret_nw = ntrec.tab   # the computed/annotated allocation of nt
+        for i in range(4):             # support same note on 4 strings
+            # get alternative representation of same note
+            na = s.note_alts[i % 3][p]
+            o = oct
+            if na in ['^B', '^^B']:
+                o -= 1  # because in adjacent octave
+            if na in ['_C', '__C']:
+                o += 1
+            if '/' in na or i == 3:
+                o = 9   # emergency notation for 4th string case
+            nt = addoct(na, o)
+            # the current allocation of nt
+            snaar, fret = s.tabmap.get((v, nt), ('', ''))
+            if not snaar:
+                break             # note not yet allocated
+            if snaar_nw == snaar:
+                return nt  # use present allocation
+            if i == 3:                  # new allocaion needed but none is free
+                fmt = 'rejected: voice %d note %3s string %s fret %2s remains: string %s fret %s'
+                info(fmt % (v, nt, snaar_nw, fret_nw, snaar, fret), 1)
+                ntrec.tab = (snaar, fret)
+        # for tablature map (voice, note) -> (string, fret)
+        s.tabmap[v, nt] = ntrec.tab
+        # ABC code always in key C (with midi pitch alterations)
+        return nt
+
+    def ntAbc(s, ptc, oct, note, v, ntrec, isTab):  # pitch, octave -> abc notation
+        acc2alt = {'double-flat': -2, 'flat-flat': -2, 'flat': -1,
+                   'natural': 0, 'sharp': 1, 'sharp-sharp': 2, 'double-sharp': 2}
+        oct += s.clefOct.get(s.curStf[v], 0)  # minus clef-octave-change value
+        acc = note.findtext('accidental')  # should be the notated accidental
+        alt = note.findtext('pitch/alter')  # pitch alteration (midi)
+        if ntrec.tab:
+            # implies s.tstep is true (options.t was given)
+            return s.tabnote(alt, ptc, oct, v, ntrec)
+        elif isTab and s.tstep:
+            nt = ['__', '_', '', '^', '^^'][int(
+                alt or '0') + 2] + addoct(ptc, oct)
+            info('no string notation found for note %s in voice %d' % (nt, v), 1)
+        p = addoct(ptc, oct)
+        if alt == None and s.msralts.get(ptc, 0):
+            alt = 0  # no alt but key implies alt -> natural!!
+        if alt == None and (p, v) in s.curalts:
+            alt = 0     # no alt but previous note had one -> natural!!
+        if acc == None and alt == None:
+            return p    # no acc, no alt
+        elif acc != None:
+            alt = acc2alt[acc]      # acc takes precedence over the pitch here!
+        else:   # now see if we really must add an accidental
+            alt = int(float(alt))
+            if (p, v) in s.curalts:  # the note in this voice has been altered before
+                if alt == s.curalts[(p, v)]:
+                    return p      # alteration still the same
+            elif alt == s.msralts.get(ptc, 0):
+                return p    # alteration implied by the key
+            # in xml we have separate notated ties and playback ties
+            tieElms = note.findall('tie') + note.findall('notations/tied')
+            if 'stop' in [e.get('type') for e in tieElms]:
+                return p    # don't alter tied notes
+            info('accidental %d added in part %d, measure %d, voice %d note %s' % (
+                alt, s.msr.ixp+1, s.msr.ixm+1, v+1, p))
+        s.curalts[(p, v)] = alt
+        # and finally ... prepend the accidental
+        p = ['__', '_', '=', '^', '^^'][alt+2] + p
+        return p
+
+    def doNote(s, n):    # parse a musicXML note tag
+        note = Note()
+        v = int(n.findtext('voice', '1'))
+        if s.isSib:
+            v += 100 * int(n.findtext('staff', '1'))  # repair bug in Sibelius
+        chord = n.find('chord') != None
+        p = n.findtext('pitch/step') or n.findtext('unpitched/display-step')
+        o = n.findtext(
+            'pitch/octave') or n.findtext('unpitched/display-octave')
+        r = n.find('rest')
+        numer = n.findtext('time-modification/actual-notes')
+        if numer:
+            denom = n.findtext('time-modification/normal-notes')
+            note.fact = (int(numer), int(denom))
+        note.tup = [x.get('type') for x in n.findall('notations/tuplet')]
+        dur = n.findtext('duration')
+        grc = n.find('grace')
+        note.grace = grc != None
+        # strings with ABC stuff that goes before or after a note/chord
+        note.before, note.after = [], ''
+        if note.grace and not s.ingrace:  # open a grace sequence
+            s.ingrace = 1
+            note.before = ['{']
+            if grc.get('slash') == 'yes':
+                note.before += ['/']  # acciaccatura
+        stopgrace = not note.grace and s.ingrace
+        if stopgrace:                   # close the grace sequence
+            s.ingrace = 0
+            s.msc.lastnote.after += '}'  # close grace on lastenote.after
+        if dur == None or note.grace:
+            dur = 0
+        if r == None and n.get('print-object') == 'no':
+            if chord:
+                return
+            # turn invisible notes (that advance the time) into invisible rests
+            r = 1
+        note.dur = int(dur)
+        if r == None and (not p or not o):  # not a rest and no pitch
+            s.msc.cnt.inc('nopt', v)       # count unpitched notes
+            o, p = 5, 'E'                    # make it an E5 ??
+        isTab = s.curClef and s.curClef.get(s.curStf[v], '').startswith('tab')
+        nttn = n.find('notations')     # add ornaments
+        if nttn != None:
+            s.doNotations(note, nttn, isTab)
+        e = n.find('stem') if r == None else None  # no !stemless! before rest
+        if e != None and e.text == 'none' and (not isTab or v in s.hasStems or s.tstep):
+            note.before += ['s']
+            abcOut.stemless = 1
+        e = n.find('accidental')
+        if e != None and e.get('parentheses') == 'yes':
+            note.ntdec += '!courtesy!'
+        if r != None:
+            noot = 'x' if n.get('print-object') == 'no' or isTab else 'z'
+        else:
+            noot = s.ntAbc(p, int(o), n, v, note, isTab)
+        if n.find('unpitched') != None:
+            clef = s.curClef[s.curStf[v]]     # the current clef for this voice
+            # (clef independent) step value of note on the staff
+            step = staffStep(p, int(o), clef, s.tstep)
+            instr = n.find('instrument')
+            instId = instr.get('id') if instr != None else 'dummyId'
+            midi = s.drumInst.get(instId, abcMid(noot))
+            # replace spaces in xml notehead names for percmap
+            nh = n.findtext('notehead', '').replace(' ', '-')
+            if nh == 'x':
+                noot = '^' + noot.replace('^', '').replace('_', '')
+            if nh in ['circle-x', 'diamond', 'triangle']:
+                noot = '_' + noot.replace('^', '').replace('_', '')
+            if nh and n.find('notehead').get('filled', '') == 'yes':
+                nh += '+'
+            if nh and n.find('notehead').get('filled', '') == 'no':
+                nh += '-'
+            # keep data for percussion map
+            s.drumNotes[(v, noot)] = (step, midi, nh)
+        # in xml we have separate notated ties and playback ties
+        tieElms = n.findall('tie') + n.findall('notations/tied')
+        # n can have stop and start tie
+        if 'start' in [e.get('type') for e in tieElms]:
+            noot = noot + '-'
+        note.beam = sum([1 for b in n.findall('beam') if b.text in [
+                        'continue', 'end']]) + int(note.grace)
+        lyrlast = 0
+        rsib = re.compile(r'^.*verse')
+        for e in n.findall('lyric'):
+            # also do Sibelius numbers
+            lyrnum = int(rsib.sub('', e.get('number', '1')))
+            if lyrnum == 0:
+                lyrnum = lyrlast + 1                # and correct Sibelius bugs
+            else:
+                lyrlast = lyrnum
+            note.lyrs[lyrnum] = doSyllable(e)
+        stemdir = n.findtext('stem')
+        if s.wstems and (stemdir == 'up' or stemdir == 'down'):
+            if stemdir != s.stemDir.get(v, ''):
+                s.stemDir[v] = stemdir
+                s.msc.appendElem(v, '[I:stemdir %s]' % stemdir)
+        if chord:
+            s.msc.addChord(note, noot)
+        else:
+            xmlstaff = int(n.findtext('staff', '1'))
+            if s.curStf[v] != xmlstaff:    # the note should go to another staff
+                dstaff = xmlstaff - s.curStf[v]    # relative new staff number
+                # remember the new staff for this voice
+                s.curStf[v] = xmlstaff
+                # insert a move before the note
+                s.msc.appendElem(v, '[I:staff %+d]' % dstaff)
+            s.msc.appendNote(v, note, noot)
+        # s.msc.lastnote points to the last real note/chord inserted above
+        for slur in n.findall('notations/slur'):
+            s.matchSlur(slur.get('type'), slur.get(
+                'number'), v, s.msc.lastnote, note.grace, stopgrace)  # match slur definitions
+
+    def doAttr(s, e):    # parse a musicXML attribute tag
+        teken = {'C1': 'alto1', 'C2': 'alto2', 'C3': 'alto', 'C4': 'tenor', 'F4': 'bass',
+                 'F3': 'bass3', 'G2': 'treble', 'TAB': 'tab', 'percussion': 'perc'}
+        dvstxt = e.findtext('divisions')
+        if dvstxt:
+            s.msr.divs = int(dvstxt)
+        # for transposing instrument
+        steps = int(e.findtext('transpose/chromatic', '0'))
+        fifths = e.findtext('key/fifths')
+        first = s.msc.tijd == 0 and s.msr.ixm == 0  # first attributes in first measure
+        if fifths:
+            key, s.msralts = setKey(
+                int(fifths), e.findtext('key/mode', 'major'))
+            if first and not steps and abcOut.key == 'none':
+                # first measure -> header, if not transposing instrument or percussion part!
+                abcOut.key = key
+            elif key != abcOut.key or not first:
+                s.msr.attr += '[K:%s]' % key    # otherwise -> voice
+        beats = e.findtext('time/beats')
+        if beats:
+            unit = e.findtext('time/beat-type')
+            mtr = beats + '/' + unit
+            if first:
+                abcOut.mtr = mtr          # first measure -> header
+            else:
+                s.msr.attr += '[M:%s]' % mtr  # otherwise -> voice
+            s.msr.mtr = int(beats), int(unit)
+        # duration of measure in xml-divisions
+        s.msr.mdur = (s.msr.divs * s.msr.mtr[0] * 4) // s.msr.mtr[1]
+        for ms in e.findall('measure-style'):
+            n = int(ms.get('number', '1'))    # staff number
+            voices = s.stfMap[n]               # all voices of staff n
+            for mr in ms.findall('measure-repeat'):
+                ty = mr.get('type')
+                if ty == 'start':               # remember start measure number and text voor each staff
+                    s.repeat_str[n] = [s.msr.ixm, mr.text]
+                    for v in voices:            # insert repeat into all voices, value will be overwritten at stop
+                        s.msc.insertElem(v, s.repeat_str[n])
+                elif ty == 'stop':              # calculate repeat measure count for this staff n
+                    start_ix, text_ = s.repeat_str[n]
+                    repeat_count = s.msr.ixm - start_ix
+                    if text_:
+                        mid_str = "%s " % text_
+                        repeat_count /= int(text_)
+                    else:
+                        mid_str = ""            # overwrite repeat with final string
+                    s.repeat_str[n][0] = '[I:repeat %s%d]' % (
+                        mid_str, repeat_count)
+                    del s.repeat_str[n]        # remove closed repeats
+        toct = e.findtext('transpose/octave-change', '')
+        if toct:
+            steps += 12 * int(toct)       # extra transposition of toct octaves
+        for clef in e.findall('clef'):         # a part can have multiple staves
+            # local staff number for this clef
+            n = int(clef.get('number', '1'))
+            sgn = clef.findtext('sign')
+            line = clef.findtext('line', '') if sgn not in [
+                'percussion', 'TAB'] else ''
+            cs = teken.get(sgn + line, '')
+            oct = clef.findtext('clef-octave-change', '') or '0'
+            if oct:
+                cs += {-2: '-15', -1: '-8', 1: '+8',
+                       2: '+15'}.get(int(oct), '')
+            # xml playback pitch -> abc notation pitch
+            s.clefOct[n] = -int(oct)
+            if steps:
+                cs += ' transpose=' + str(steps)
+            stfdtl = e.find('staff-details')
+            if stfdtl and int(stfdtl.get('number', '1')) == n:
+                lines = stfdtl.findtext('staff-lines')
+                if lines:
+                    lns = '|||' if lines == '3' and sgn == 'TAB' else lines
+                    cs += ' stafflines=%s' % lns
+                    s.stafflines = int(lines)  # remember for tab staves
+                strings = stfdtl.findall('staff-tuning')
+                if strings:
+                    tuning = [st.findtext(
+                        'tuning-step') + st.findtext('tuning-octave') for st in strings]
+                    cs += ' strings=%s' % ','.join(tuning)
+                capo = stfdtl.findtext('capo')
+                if capo:
+                    cs += ' capo=%s' % capo
+            # keep track of current clef (for percmap)
+            s.curClef[n] = cs
+            if first:
+                # clef goes to header (where it is mapped to voices)
+                s.clefMap[n] = cs
+            else:
+                # clef change to all voices of staff n
+                voices = s.stfMap[n]
+                for v in voices:
+                    if n != s.curStf[v]:       # voice is not at its home staff n
+                        dstaff = n - s.curStf[v]
+                        # reset current staff at start of measure to home position
+                        s.curStf[v] = n
+                        s.msc.appendElem(v, '[I:staff %+d]' % dstaff)
+                    s.msc.appendElem(v, '[K:%s]' % cs)
+
+    def findVoice(s, i, es):
+        # directions belong to a staff
+        stfnum = int(es[i].findtext('staff', 1))
+        vs = s.stfMap[stfnum]                      # voices in this staff
+        # directions to first voice of staff
+        v1 = vs[0] if vs else 1
+        if s.dirtov1:
+            return stfnum, v1, v1         # option --v1
+        for e in es[i+1:]:                         # or to the voice of the next note
+            if e.tag == 'note':
+                v = int(e.findtext('voice', '1'))
+                if s.isSib:
+                    # repair bug in Sibelius
+                    v += 100 * int(e.findtext('staff', '1'))
+                # use our own staff allocation
+                stf = s.vce2stf[v]
+                return stf, v, v1                   # voice of next note, first voice of staff
+            if e.tag == 'backup':
+                break
+        return stfnum, v1, v1                       # no note found, fall back to v1
+
+    def doDirection(s, e, i, es):  # parse a musicXML direction tag
+        def addDirection(x, vs, tijd, stfnum):
+            if not x:
+                return
+            vs = s.stfMap[stfnum] if '!8v' in x else [
+                vs]  # ottava's go to all voices of staff
+            for v in vs:
+                if tijd != None:   # insert at time of encounter
+                    s.msc.appendElemT(v, x.replace(
+                        '(', ')').replace('ped', 'ped-up'), tijd)
+                else:
+                    s.msc.appendElem(v, x)
+
+        def startStop(dtype, vs, stfnum=1):
+            typmap = {'down': '!8va(!', 'up': '!8vb(!', 'crescendo': '!<(!',
+                      'diminuendo': '!>(!', 'start': '!ped!'}
+            type = t.get('type', '')
+            # key to match the closing direction
+            k = dtype + t.get('number', '1')
+            if type in typmap:                      # opening the direction
+                x = typmap[type]
+                if k in s.dirStk:                   # closing direction already encountered
+                    stype, tijd = s.dirStk[k]
+                    del s.dirStk[k]
+                    if stype == 'stop':
+                        addDirection(x, vs, tijd, stfnum)
+                    else:
+                        info('%s direction %s has no stop in part %d, measure %d, voice %d' % (
+                            dtype, stype, s.msr.ixp+1, s.msr.ixm+1, vs+1))
+                        # remember voice and type for closing
+                        s.dirStk[k] = ((type, vs))
+                else:
+                    # remember voice and type for closing
+                    s.dirStk[k] = ((type, vs))
+            elif type == 'stop':
+                if k in s.dirStk:                   # matching open direction found
+                    type, vs = s.dirStk[k]
+                    del s.dirStk[k]   # into the same voice
+                    if type == 'stop':
+                        info('%s direction %s has double stop in part %d, measure %d, voice %d' % (
+                            dtype, type, s.msr.ixp+1, s.msr.ixm+1, vs+1))
+                        x = ''
+                    else:
+                        x = typmap[type].replace(
+                            '(', ')').replace('ped', 'ped-up')
+                else:                               # closing direction found before opening
+                    s.dirStk[k] = ('stop', s.msc.tijd)
+                    x = ''                          # delay code generation until opening found
+            else:
+                raise ValueError('wrong direction type')
+            addDirection(x, vs, None, stfnum)
+        tempo, wrdstxt = None, ''
+        plcmnt = e.get('placement')
+        stf, vs, v1 = s.findVoice(i, es)
+        jmp = ''    # for jump sound elements: dacapo, dalsegno and family
+        jmps = [('dacapo', 'D.C.'), ('dalsegno', 'D.S.'), ('tocoda',
+                                                           'dacoda'), ('fine', 'fine'), ('coda', 'O'), ('segno', 'S')]
+        # there are many possible attributes for sound
+        t = e.find('sound')
+        if t != None:
+            minst = t.find('midi-instrument')
+            if minst:
+                prg = t.findtext('midi-instrument/midi-program')
+                chn = t.findtext('midi-instrument/midi-channel')
+                vids = [v for v, id in s.vceInst.items() if id ==
+                        minst.get('id')]
+                if vids:
+                    # direction for the indentified voice, not the staff
+                    vs = vids[0]
+                parm, inst = ('program', str(int(prg) - 1)
+                              ) if prg else ('channel', chn)
+                if inst and abcOut.volpan > 0:
+                    s.msc.appendElem(vs, '[I:MIDI= %s %s]' % (parm, inst))
+            tempo = t.get('tempo')  # look for tempo attribute
+            if tempo:
+                # hope it is a number and insert in voice 1
+                tempo = '%.0f' % float(tempo)
+                tempo_units = (1, 4)  # always 1/4 for sound elements!
+            for r, v in jmps:
+                if t.get(r, ''):
+                    jmp = v
+                    break
+        dirtypes = e.findall('direction-type')
+        for dirtyp in dirtypes:
+            units = {'whole': (1, 1), 'half': (
+                1, 2), 'quarter': (1, 4), 'eighth': (1, 8)}
+            metr = dirtyp.find('metronome')
+            if metr != None:
+                t = metr.findtext('beat-unit', '')
+                if t in units:
+                    tempo_units = units[t]
+                else:
+                    tempo_units = units['quarter']
+                if metr.find('beat-unit-dot') != None:
+                    tempo_units = simplify(
+                        tempo_units[0] * 3, tempo_units[1] * 2)
+                # look for a number
+                tmpro = re.search('[.\d]+', metr.findtext('per-minute'))
+                if tmpro:
+                    tempo = tmpro.group()  # overwrites the value set by the sound element of this direction
+            t = dirtyp.find('wedge')
+            if t != None:
+                startStop('wedge', vs)
+            allwrds = dirtyp.findall('words')        # insert text annotations
+            if not allwrds:
+                # treat rehearsal mark as text annotation
+                allwrds = dirtyp.findall('rehearsal')
+            for wrds in allwrds:
+                if jmp:  # ignore the words when a jump sound element is present in this direction
+                    s.msc.appendElem(vs, '!%s!' % jmp, 1)  # to voice
+                    break
+                plc = plcmnt == 'below' and '_' or '^'
+                if float(wrds.get('default-y', '0')) < 0:
+                    plc = '_'
+                wrdstxt += (wrds.text or '').replace('"',
+                                                     '\\"').replace('\n', '\\n')
+            wrdstxt = wrdstxt.strip()
+            for key, val in dynamics_map.items():
+                if dirtyp.find('dynamics/' + key) != None:
+                    s.msc.appendElem(vs, val, 1)   # to voice
+            if dirtyp.find('coda') != None:
+                s.msc.appendElem(vs, 'O', 1)
+            if dirtyp.find('segno') != None:
+                s.msc.appendElem(vs, 'S', 1)
+            t = dirtyp.find('octave-shift')
+            if t != None:
+                # assume size == 8 for the time being
+                startStop('octave-shift', vs, stf)
+            t = dirtyp.find('pedal')
+            if t != None and s.ped:
+                if not s.pedVce:
+                    s.pedVce = vs
+                startStop('pedal', s.pedVce)
+            if dirtyp.findtext('other-direction') == 'diatonic fretting':
+                s.diafret = 1
+        if tempo:
+            # hope it is a number and insert in voice 1
+            tempo = '%.0f' % float(tempo)
+            if s.msc.tijd == 0 and s.msr.ixm == 0:      # first measure -> header
+                abcOut.tempo = tempo
+                abcOut.tempo_units = tempo_units
+            else:
+                # otherwise -> 1st voice
+                s.msc.appendElem(v1, '[Q:%d/%d=%s]' %
+                                 (tempo_units[0], tempo_units[1], tempo))
+        if wrdstxt:
+            s.msc.appendElem(vs, '"%s%s"' % (plc, wrdstxt),
+                             1)  # to voice, but after tempo
+
+    def doHarmony(s, e, i, es):    # parse a musicXMl harmony tag
+        _, vt, _ = s.findVoice(i, es)
+        short = {'major': '', 'minor': 'm', 'augmented': '+',
+                 'diminished': 'dim', 'dominant': '7', 'half-diminished': 'm7b5'}
+        accmap = {'major': 'maj', 'dominant': '', 'minor': 'm',
+                  'diminished': 'dim', 'augmented': '+', 'suspended': 'sus'}
+        modmap = {'second': '2', 'fourth': '4', 'seventh': '7',
+                  'sixth': '6', 'ninth': '9', '11th': '11', '13th': '13'}
+        altmap = {'1': '#', '0': '', '-1': 'b'}
+        root = e.findtext('root/root-step', '')
+        alt = altmap.get(e.findtext('root/root-alter'), '')
+        sus = ''
+        kind = e.findtext('kind', '')
+        if kind in short:
+            kind = short[kind]
+        elif '-' in kind:   # xml chord names: <triad name>-<modification>
+            triad, mod = kind.split('-')
+            kind = accmap.get(triad, '') + modmap.get(mod, '')
+            if kind.startswith('sus'):
+                kind, sus = '', kind    # sus-suffix goes to the end
+        elif kind == 'none':
+            kind = e.find('kind').get('text', '')
+        degrees = e.findall('degree')
+        for d in degrees:   # chord alterations
+            kind += altmap.get(d.findtext('degree-alter'),
+                               '') + d.findtext('degree-value', '')
+        kind = kind.replace('79', '9').replace(
+            '713', '13').replace('maj6', '6')
+        bass = e.findtext('bass/bass-step', '') + \
+            altmap.get(e.findtext('bass/bass-alter'), '')
+        s.msc.appendElem(vt, '"%s%s%s%s%s"' %
+                         (root, alt, kind, sus, bass and '/' + bass), 1)
+
+    def doBarline(s, e):       # 0 = no repeat, 1 = begin repeat, 2 = end repeat
+        rep = e.find('repeat')
+        if rep != None:
+            rep = rep.get('direction')
+        if s.unfold:            # unfold repeat, don't translate barlines
+            return rep and (rep == 'forward' and 1 or 2) or 0
+        loc = e.get('location', 'right')   # right is the default
+        if loc == 'right':      # only change style for the right side
+            style = e.findtext('bar-style')
+            if style == 'light-light':
+                s.msr.rline = '||'
+            elif style == 'light-heavy':
+                s.msr.rline = '|]'
+        if rep != None:         # repeat found
+            if rep == 'forward':
+                s.msr.lline = ':'
+            else:
+                s.msr.rline = ':|'  # override barline style
+        end = e.find('ending')
+        if end != None:
+            if end.get('type') == 'start':
+                n = end.get('number', '1').replace('.', '').replace(' ', '')
+                try:
+                    # should be a list of integers
+                    list(map(int, n.split(',')))
+                except:
+                    n = '"%s"' % n.strip()         # illegal musicXML
+                s.msr.lnum = n          # assume a start is always at the beginning of a measure
+            elif s.msr.rline == '|':    # stop and discontinue the same  in ABC ?
+                s.msr.rline = '||'      # to stop on a normal barline use || in ABC ?
+        return 0
+
+    def doPrint(s, e):     # print element, measure number -> insert a line break
+        if e.get('new-system') == 'yes' or e.get('new-page') == 'yes':
+            if not s.nolbrk:
+                return '$'  # a line break
+
+    def doPartList(s, e):  # translate the start/stop-event-based xml-partlist into proper tree
+        for sp in e.findall('part-list/score-part'):
+            midi = {}
+            for m in sp.findall('midi-instrument'):
+                x = [m.findtext(p, s.midDflt[i]) for i, p in enumerate(
+                    ['midi-channel', 'midi-program', 'volume', 'pan'])]
+                pan = float(x[3])
+                if pan >= -90 and pan <= 90:    # would be better to map behind-pannings
+                    pan = (float(x[3]) + 90) / 180 * \
+                        127   # xml between -90 and +90
+                midi[m.get('id')] = [int(x[0]), int(x[1]), float(
+                    x[2]) * 1.27, pan]    # volume 100 -> midi 127
+                up = m.findtext('midi-unpitched')
+                if up:
+                    # store midi-pitch for channel 10 notes
+                    s.drumInst[m.get('id')] = int(up) - 1
+            s.instMid.append(midi)
+        ps = e.find('part-list')               # partlist  = [groupelem]
+        # groupelem = partname | grouplist
+        xs = getPartlist(ps)
+        # grouplist = [groupelem, ..., groupdata]
+        partlist, _ = parseParts(xs, {}, [])
+        # groupdata = [group-symbol, group-barline, group-name, group-abbrev]
+        return partlist
+
+    def mkTitle(s, e):
+        def filterCredits(y):  # y == filter level, higher filters less
+            cs = []
+            for x in credits:   # skip redundant credit lines
+                if y < 6 and (x in title or x in mvttl):
+                    continue         # sure skip
+                if y < 5 and (x in composer or x in lyricist):
+                    continue   # almost sure skip
+                if y < 4 and ((title and title in x) or (mvttl and mvttl in x)):
+                    continue   # may skip too much
+                if y < 3 and ([1 for c in composer if c in x] or [1 for c in lyricist if c in x]):
+                    continue  # skips too much
+                if y < 2 and re.match(r'^[\d\W]*$', x):
+                    continue       # line only contains numbers and punctuation
+                cs.append(x)
+            if y == 0 and (title + mvttl):
+                cs = ''  # default: only credit when no title set
+            return cs
+        title = e.findtext('work/work-title', '').strip()
+        mvttl = e.findtext('movement-title', '').strip()
+        composer, lyricist, credits = [], [], []
+        for creator in e.findall('identification/creator'):
+            if creator.text:
+                if creator.get('type') == 'composer':
+                    composer += [line.strip()
+                                 for line in creator.text.split('\n')]
+                elif creator.get('type') in ('lyricist', 'transcriber'):
+                    lyricist += [line.strip()
+                                 for line in creator.text.split('\n')]
+        for rights in e.findall('identification/rights'):
+            if rights.text:
+                lyricist += [line.strip() for line in rights.text.split('\n')]
+        for credit in e.findall('credit'):
+            cs = ''.join(e.text or '' for e in credit.findall('credit-words'))
+            credits += [re.sub(r'\s*[\r\n]\s*', ' ', cs)]
+        credits = filterCredits(s.ctf)
+        if title:
+            title = 'T:%s\n' % title.replace('\n', '\nT:')
+        if mvttl:
+            title += 'T:%s\n' % mvttl.replace('\n', '\nT:')
+        if credits:
+            title += '\n'.join(['T:%s' % c for c in credits]) + '\n'
+        if composer:
+            title += '\n'.join(['C:%s' % c for c in composer]) + '\n'
+        if lyricist:
+            title += '\n'.join(['Z:%s' % c for c in lyricist]) + '\n'
+        if title:
+            abcOut.title = title[:-1]
+        s.isSib = 'Sibelius' in (e.findtext(
+            'identification/encoding/software') or '')
+        if s.isSib:
+            info('Sibelius MusicXMl is unreliable')
+
+    def doDefaults(s, e):
+        if not s.doPageFmt:
+            return  # return if -pf option absent
+        d = e.find('defaults')
+        if d == None:
+            return
+        mils = d.findtext('scaling/millimeters')   # mills == staff height (mm)
+        tenths = d.findtext('scaling/tenths')      # staff height in tenths
+        if not mils or not tenths:
+            return
+        xmlScale = float(mils) / float(tenths) / 10   # tenths -> mm
+        space = 10 * xmlScale       # space between staff lines == 10 tenths
+        # 0.2117 cm = 6pt = space between staff lines for scale = 1.0 in abcm2ps
+        abcScale = space / 0.2117
+        abcOut.pageFmt['scale'] = abcScale
+        eks = 2 * ['page-layout/'] + 4 * ['page-layout/page-margins/']
+        eks = [
+            a+b for a, b in zip(eks, 'page-height,page-width,left-margin,right-margin,top-margin,bottom-margin'.split(','))]
+        for i in range(6):
+            v = d.findtext(eks[i])
+            # pagekeys [0] == scale already done, skip it
+            k = abcOut.pagekeys[i+1]
+            if not abcOut.pageFmt[k] and v:
+                try:
+                    abcOut.pageFmt[k] = float(v) * xmlScale  # -> cm
+                except:
+                    info('illegal value %s for xml element %s', (v, eks[i]))
+                    continue    # just skip illegal values
+
+    def locStaffMap(s, part, maten):   # map voice to staff with majority voting
+        vmap = {}   # {voice -> {staff -> n}} count occurrences of voice in staff
+        s.vceInst = {}          # {voice -> instrument id} for this part
+        s.msc.vnums = {}        # voice id's
+        # XML voice nums with at least one note with a stem (for tab key)
+        s.hasStems = {}
+        s.stfMap, s.clefMap = {}, {}    # staff -> [voices], staff -> clef
+        ns = part.findall('measure/note')
+        for n in ns:            # count staff allocations for all notes
+            v = int(n.findtext('voice', '1'))
+            if s.isSib:
+                # repair bug in Sibelius
+                v += 100 * int(n.findtext('staff', '1'))
+            s.msc.vnums[v] = 1  # collect all used voice id's in this part
+            sn = int(n.findtext('staff', '1'))
+            s.stfMap[sn] = []
+            if v not in vmap:
+                vmap[v] = {sn: 1}
+            else:
+                d = vmap[v]     # counter for voice v
+                # ++ number of allocations for staff sn
+                d[sn] = d.get(sn, 0) + 1
+            x = n.find('instrument')
+            if x != None:
+                s.vceInst[v] = x.get('id')
+            x, noRest = n.findtext('stem'), n.find('rest') == None
+            if noRest and (not x or x != 'none'):
+                s.hasStems[v] = 1    # XML voice v has at least one stem
+        vks = list(vmap.keys())
+        if s.jscript or s.isSib:
+            vks.sort()
+        for v in vks:           # choose staff with most allocations for each voice
+            xs = [(n, sn) for sn, n in vmap[v].items()]
+            xs.sort()
+            stf = xs[-1][1]     # the winner: staff with most notes of voice v
+            s.stfMap[stf].append(v)
+            s.vce2stf[v] = stf  # reverse map
+            s.curStf[v] = stf  # current staff of XML voice v
+
+    def addStaffMap(s, vvmap):  # vvmap: xml voice number -> global abc voice number
+        part = []  # default: brace on staffs of one part
+        # s.stfMap has xml staff and voice numbers
+        for stf, voices in sorted(s.stfMap.items()):
+            locmap = [vvmap[iv] for iv in voices if iv in vvmap]
+            nostem = [(iv not in s.hasStems)
+                      for iv in voices if iv in vvmap]   # same order as locmap
+            if locmap:          # abc voice number of staff stf
+                part.append(locmap)
+                # {xml staff number -> clef}
+                clef = s.clefMap.get(stf, 'treble')
+                for i, iv in enumerate(locmap):
+                    clef_attr = ''
+                    if clef.startswith('tab'):
+                        if nostem[i] and 'nostems' not in clef:
+                            clef_attr = ' nostems'
+                        if s.diafret and 'diafret' not in clef:
+                            clef_attr += ' diafret'  # for all voices in the part
+                    # add nostems when all notes of voice had no stem
+                    abcOut.clefs[iv] = clef + clef_attr
+        s.gStfMap.append(part)
+
+    def addMidiMap(s, ip, vvmap):      # map abc voices to midi settings
+        instr = s.instMid[ip]          # get the midi settings for this part
+        if instr.values():
+            # default settings = first instrument
+            defInstr = list(instr.values())[0]
+        else:
+            defInstr = s.midDflt    # no instruments defined
+        xs = []
+        for v, vabc in vvmap.items():  # xml voice num, abc voice num
+            ks = sorted(s.drumNotes.items())
+            ds = [(nt, step, midi, head) for (vd, nt),
+                  (step, midi, head) in ks if v == vd]  # map perc notes
+            # get the instrument-id for part with multiple instruments
+            id = s.vceInst.get(v, '')
+            if id in instr:             # id is defined as midi-instrument in part-list
+                xs.append((vabc, instr[id] + ds))  # get midi settings for id
+            else:
+                # only one instrument for this part
+                xs.append((vabc, defInstr + ds))
+        xs.sort()  # put abc voices in order
+        s.midiMap.extend([midi for v, midi in xs])
+        snaarmap = ['E', 'G', 'B', 'd', 'f', 'a', "c'", "e'"]
+        diamap = '0,1-,1,1+,2,3,3,4,4,5,6,6+,7,8-,8,8+,9,10,10,11,11,12,13,13+,14'.split(
+            ',')
+        for k in sorted(s.tabmap.keys()):  # add %%map's for all tab voices
+            v, noot = k
+            snaar, fret = s.tabmap[k]
+            if s.diafret:
+                fret = diamap[int(fret)]
+            vabc = vvmap[v]
+            snaar = s.stafflines - int(snaar)
+            xs = s.tabVceMap.get(vabc, [])
+            xs.append('%%%%map tab%d %s print=%s heads=kop%s\n' %
+                      (vabc, noot, snaarmap[snaar], fret))
+            s.tabVceMap[vabc] = xs
+            s.koppen[fret] = 1  # collect noteheads for SVG defs
+
+    def parse(s, xmltxt):
+        vvmapAll = {}   # collect xml->abc voice maps (vvmap) of all parts
+        e = E.fromstring(xmltxt)
+        s.mkTitle(e)
+        s.doDefaults(e)
+        partlist = s.doPartList(e)
+        parts = e.findall('part')
+        for ip, p in enumerate(parts):
+            maten = p.findall('measure')
+            s.locStaffMap(p, maten)        # {voice -> staff} for this part
+            # (xml voice, abc note) -> (midi note, note head)
+            s.drumNotes = {}
+            s.clefOct = {}      # xml staff number -> current clef-octave-change
+            s.curClef = {}      # xml staff number -> current abc clef
+            s.stemDir = {}      # xml voice number -> current stem direction
+            s.tabmap = {}       # (xml voice, abc note) -> (string, fret)
+            s.diafret = 0       # use diatonic fretting
+            s.stafflines = 5
+            s.msc.initVoices(newPart=1)  # create all voices
+            aantalHerhaald = 0  # keep track of number of repititions
+            herhaalMaat = 0     # target measure of the repitition
+            divisions = []      # current value of <divisions> for each measure
+            s.msr = Measure(ip)   # various measure data
+            while s.msr.ixm < len(maten):
+                maat = maten[s.msr.ixm]
+                herhaal, lbrk = 0, ''
+                s.msr.reset()
+                s.curalts = {}  # passing accidentals are reset each measure
+                es = list(maat)
+                for i, e in enumerate(es):
+                    if e.tag == 'note':
+                        s.doNote(e)
+                    elif e.tag == 'attributes':
+                        s.doAttr(e)
+                    elif e.tag == 'direction':
+                        s.doDirection(e, i, es)
+                    elif e.tag == 'sound':
+                        # sound element directly in measure!
+                        s.doDirection(maat, i, es)
+                    elif e.tag == 'harmony':
+                        s.doHarmony(e, i, es)
+                    elif e.tag == 'barline':
+                        herhaal = s.doBarline(e)
+                    elif e.tag == 'backup':
+                        dt = int(e.findtext('duration'))
+                        if chkbug(dt, s.msr):
+                            s.msc.incTime(-dt)
+                    elif e.tag == 'forward':
+                        dt = int(e.findtext('duration'))
+                        if chkbug(dt, s.msr):
+                            s.msc.incTime(dt)
+                    elif e.tag == 'print':
+                        lbrk = s.doPrint(e)
+                s.msc.addBar(lbrk, s.msr)
+                divisions.append(s.msr.divs)
+                if herhaal == 1:
+                    herhaalMaat = s.msr.ixm
+                    s.msr.ixm += 1
+                elif herhaal == 2:
+                    if aantalHerhaald < 1:  # jump
+                        s.msr.ixm = herhaalMaat
+                        aantalHerhaald += 1
+                    else:
+                        aantalHerhaald = 0  # reset
+                        s.msr.ixm += 1      # just continue
+                else:
+                    s.msr.ixm += 1        # on to the next measure
+            for rv in s.repeat_str.values():   # close hanging measure-repeats without stop
+                rv[0] = '[I:repeat %s %d]' % (rv[1], 1)
+            vvmap = s.msc.outVoices(divisions, ip, s.isSib)
+            s.addStaffMap(vvmap)           # update global staff map
+            s.addMidiMap(ip, vvmap)
+            vvmapAll.update(vvmap)
+        if vvmapAll:            # skip output if no part has any notes
+            abcOut.mkHeader(s.gStfMap, partlist, s.midiMap,
+                            s.tabVceMap, s.koppen)
+        else:
+            info('nothing written, %s has no notes ...' % abcOut.fnmext)
+
+
+def vertaal(xmltxt, **options_parm):
+    class options:  # the default option values
+        u = 0
+        b = 0
+        n = 0
+        c = 0
+        v = 0
+        d = 0
+        m = 0
+        x = 0
+        t = 0
+        stm = 0
+        mnum = -1
+        p = 'f'
+        s = 0
+        j = 0
+        v1 = 0
+        ped = 0
+    global abcOut, info_list
+    info_list = []
+    str = ''
+    for opt in options_parm:        # assign the given options
+        setattr(options, opt, options_parm[opt])
+    options.p = options.p.split(',') if options.p else []  # [] | [string]
+    abcOut = ABCoutput('', '', 0, options)
+    psr = Parser(options)
+    try:
+        psr.parse(xmltxt)          # parse xmltxt
+        str = abcOut.getABC()      # ABC output
+        info('%s written with %d voices' %
+             (abcOut.fnmext, len(abcOut.clefs)), warn=0)
+    except:
+        etype, value, traceback = sys.exc_info()   # works in python 2 & 3
+        info('** %s occurred: %s' % (etype, value), 0)
+    return (str, ''.join(info_list))  # and the diagnostic messages
+
+
+# ----------------
+# Main Program
+# ----------------
+if __name__ == '__main__':
+    from optparse import OptionParser
+    from glob import glob
+    from zipfile import ZipFile
+    ustr = '%prog [-h] [-u] [-m] [-c C] [-d D] [-n CPL] [-b BPL] [-o DIR] [-v V]\n'
+    ustr += '[-x] [-p PFMT] [-t] [-s] [-i] [--v1] [--noped] [--stems] <file1> [<file2> ...]'
+    parser = OptionParser(usage=ustr, version=str(VERSION))
+    parser.add_option("-u", action="store_true", help="unfold simple repeats")
+    parser.add_option("-m", action="store",
+                      help="0 -> no %%MIDI, 1 -> minimal %%MIDI, 2-> all %%MIDI", default=0)
+    parser.add_option("-c", action="store", type="int",
+                      help="set credit text filter to C", default=0, metavar='C')
+    parser.add_option("-d", action="store", type="int",
+                      help="set L:1/D", default=0, metavar='D')
+    parser.add_option("-n", action="store", type="int",
+                      help="CPL: max number of characters per line (default 100)", default=0, metavar='CPL')
+    parser.add_option("-b", action="store", type="int",
+                      help="BPL: max number of bars per line", default=0, metavar='BPL')
+    parser.add_option("-o", action="store",
+                      help="store abc files in DIR", default='', metavar='DIR')
+    parser.add_option("-v", action="store", type="int",
+                      help="set volta typesetting behaviour to V", default=0, metavar='V')
+    parser.add_option("-x", action="store_true", help="output no line breaks")
+    parser.add_option("-p", action="store",
+                      help="pageformat PFMT (cm) = scale, pageheight, pagewidth, leftmargin, rightmargin, topmargin, botmargin", default='', metavar='PFMT')
+    parser.add_option("-j", action="store_true",
+                      help="switch for compatibility with javascript version")
+    parser.add_option("-t", action="store_true",
+                      help="translate perc- and tab-staff to ABC code with %%map, %%voicemap")
+    parser.add_option("-s", action="store_true",
+                      help="shift node heads 3 units left in a tab staff")
+    parser.add_option("--v1", action="store_true",
+                      help="start-stop directions allways to first voice of staff")
+    parser.add_option("--noped", action="store_false",
+                      help="skip all pedal directions", dest='ped', default=True)
+    parser.add_option("--stems", action="store_true",
+                      help="translate stem directions", dest='stm', default=False)
+    parser.add_option("-i", action="store_true",
+                      help="read xml file from standard input")
+    options, args = parser.parse_args()
+    if options.n < 0:
+        parser.error('only values >= 0')
+    if options.b < 0:
+        parser.error('only values >= 0')
+    if options.d and options.d not in [2**n for n in range(10)]:
+        parser.error('D should be on of %s' %
+                     ','.join([str(2**n) for n in range(10)]))
+    options.p = options.p and options.p.split(',') or []  # ==> [] | [string]
+    if len(args) == 0 and not options.i:
+        parser.error('no input file given')
+    pad = options.o
+    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)
+    fnmext_list = []
+    for i in args:
+        fnmext_list += glob(i)
+    if options.i:
+        fnmext_list = ['stdin.xml']
+    if not fnmext_list:
+        parser.error('none of the input files exist')
+    for X, fnmext in enumerate(fnmext_list):
+        fnm, ext = os.path.splitext(fnmext)
+        if ext.lower() not in ('.xml', '.mxl', '.musicxml'):
+            info('skipped input file %s, it should have extension .xml or .mxl' % fnmext)
+            continue
+        if os.path.isdir(fnmext):
+            info('skipped directory %s. Only files are accepted' % fnmext)
+            continue
+        if fnmext == 'stdin.xml':
+            fobj = sys.stdin
+        elif ext.lower() == '.mxl':        # extract .xml file from .mxl file
+            z = ZipFile(fnmext)
+            for n in z.namelist():          # assume there is always an xml file in a mxl archive !!
+                if (n[:4] != 'META') and (n[-4:].lower() == '.xml'):
+                    fobj = z.open(n)
+                    break   # assume only one MusicXML file per archive
+        else:
+            fobj = open(fnmext, 'rb')      # open regular xml file
+
+        # create global ABC output object
+        abcOut = ABCoutput(fnm + '.abc', pad, X, options)
+        psr = Parser(options)  # xml parser
+        try:
+            # parse file fobj and write abc to <fnm>.abc
+            psr.parse(fobj.read())
+            abcOut.writeall()
+        except:
+            etype, value, traceback = sys.exc_info()   # works in python 2 & 3
+            info('** %s occurred: %s in %s' % (etype, value, fnmext), 0)