You are to write a function to transpose a guitar tab up or down a number of semitones. The amount to transpose is a number, positive or negative. The tab is given as an array, with six elements for each guitar string (fittingly passed as strings). Output your tab in a similar form.

Guitar tablature (or 'tab') is an alternative to sheet music, where notes are replaced by fret numbers and the five lines of the staff are replaced by six lines to represent each of the guitar's strings. It is still read from left to right like sheet music, and notes written directly above each other are played at the same time.

For example, Led Zeppelin's Stairway to Heaven begins:
```
e|-------5-7-----7-|-8-----8-2-----2-|-0---------0-----|-----------------|
B|-----5-----5-----|---5-------3-----|---1---1-----1---|-0-1-1-----------|
G|---5---------5---|-----5-------2---|-----2---------2-|-0-2-2-----------|
D|-7-------6-------|-5-------4-------|-3---------------|-----------------|
A|-----------------|-----------------|-----------------|-2-0-0---0--/8-7-|
E|-----------------|-----------------|-----------------|-----------------|
```
Transposed up two semitones, it would look like this:
```
e|-------7-9-----9-|-10-----10-4-----4-|-2---------2-----|------------------|
B|-----7-----7-----|----7--------5-----|---3---3-----3---|-2-3-3------------|
G|---7---------7---|------7--------4---|-----4---------4-|-2-4-4------------|
D|-9-------8-------|-7---------6-------|-5---------------|------------------|
A|-----------------|-------------------|-----------------|-4-2-2---2--/10-9-|
E|-----------------|-------------------|-----------------|------------------|
```
Note how when the 8th fret note on the top string in bar 2 gets transposed to the 10th fret, extra '-' are added on the other strings below so as to retain the single '-' that originally separated that beat (i.e. column) from the following note – fret 7 on the B string.

Each beat must retain at least one '-' separator before the next, to keep the tab legible. The inputted test tabs all obey this convention.

Electric guitars usually have 22 frets, with the 0th fret being an open string. If your fret numbers transpose to either negative values or values over 22, you should return 'Out of frets!' (and probably detune your guitar).

Tests include some randomly generated guitar tabs, which come with no guarantee of musical quality and/or playability...!

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

def _disabled_input(*args, **kwargs):
    raise RuntimeError("input() is disabled in callable mode")
builtins.input = _disabled_input

ns = {"__name__": "__judge__"}  # prevent if __name__ == "__main__" blocks
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = "def write_bar(new_bar, beat, amount):                                               \n    new_beat = [str(int(fret) + amount) if fret.isnumeric() else fret for fret in beat]\n    values = [int(fret) for fret in new_beat if fret.lstrip('-').isnumeric()]       \n    if values and (max(values) > 22 or min(values) <= 0):                           \n        raise ValueError('Out of frets!')                                           \n    formatted_beat = [beat.ljust(len(max(new_beat, key=len)), '-') for beat in new_beat]\n    for beat in range(len(formatted_beat)):                                         \n        new_bar[beat] += formatted_beat[beat]                                       \n    return new_bar                                                                  \n                                                                                    \ndef transpose_bar(amount, bar):                                                     \n    new_bar = [''] * 6                                                              \n    frets = [''] * 6                                                                \n    joined = False                                                                  \n    for beat in range(len(bar[0])):                                                 \n        if not joined:                                                              \n            previous_beat = frets                                                   \n        else:                                                                       \n            previous_beat = [''] * 6                                                \n        joined = False                                                              \n        frets = [gen[beat] for gen in bar]                                          \n        for fret in range(len(frets)):                                              \n            if frets[fret].isnumeric() and previous_beat[fret].isnumeric():         \n                previous_beat[fret] += frets[fret]                                  \n                joined = True                                                       \n        new_bar = write_bar(new_bar, previous_beat, amount)                         \n                                                                                    \n    if not joined:                                                                  \n        new_bar = write_bar(new_bar, frets, amount)                                 \n                                                                                    \n    return new_bar                                                                  \n                                                                                    \n                                                                                    \ndef transpose(amount, tab):                                                         \n    string_bars = [gen.split('|')[1:-1] for gen in tab]                             \n    bars = list(zip(*string_bars))                                                  \n    new_bars = [('e','B','G','D','A','E'),]                                         \n    try:                                                                            \n        for bar in bars:                                                            \n            new_bars.append(transpose_bar(amount, bar))                             \n        new_bars.append([''] * 6)                                                   \n        transposed = list(zip(*new_bars))                                           \n        return ['|'.join(gen) for gen in transposed]                                \n    except ValueError as e:                                                         \n        return str(e)   "
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

_target = None
_fn_name = 'transpose'
if _fn_name:
    if "Solution" in ns:
        try:
            _obj = ns["Solution"]()
            if hasattr(_obj, _fn_name):
                _target = getattr(_obj, _fn_name)
        except Exception:
            _target = None
    if _target is None and _fn_name in ns and callable(ns[_fn_name]):
        _target = ns[_fn_name]
# Fallback: if there's exactly one user-defined function, use it
if _target is None:
    _cands = [v for k, v in ns.items() if callable(v) and getattr(v, "__module__", "") in ("__judge__", "__main__")]
    _user_funcs = [c for c in _cands if getattr(c, "__name__", "").startswith("_") is False]
    if len(_user_funcs) == 1:
        _target = _user_funcs[0]
if _target is None:
    raise RuntimeError(f"Could not resolve callable '{_fn_name}'")

_raw = sys.stdin.read().strip()
if _raw:
    _parsed = json.loads(_raw)
    if isinstance(_parsed, dict):
        _kwargs = _parsed.get("kwargs", {})
        _args = _parsed.get("args", [])
    else:
        _args, _kwargs = _parsed, {}
else:
    _args, _kwargs = [], {}
if not isinstance(_args, (list, tuple)):
    _args = [_args]
_res = _target(*_args, **_kwargs)
try:
    sys.stdout.write(repr(_res) + "\n")
except Exception:
    pass

```

Measured memory_bytes: 13848