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 = 'import re\n\ndef transpose(amount, tab):\n    \n    # get start and end of all frets\n    fret_pos = get_all_fret_positions(tab)\n    # process each column that contains frets\n    pos = 0\n    tab_new = [\'\' for string in tab]\n    for fret_start in sorted(fret_pos):\n        fret_end = fret_pos[fret_start]\n        # get all sub strings from one column\n        col = [string[fret_start:fret_end] for string in tab]\n        # apply amount to all frets\n        col, col_width = apply_amount(col, amount)\n        if col == \'Out of frets!\':\n            return \'Out of frets!\'\n        # adjust column width\n        col = adjust_column_width(col, col_width)\n        # add modified column back to tablature\n        for i, row in enumerate(col):\n            tab_new[i] = tab_new[i] + tab[i][pos:fret_start] + row\n        pos = fret_end\n        # add the part after the final fret\n    for i, row in enumerate(col):\n        tab_new[i] = tab_new[i] + tab[i][fret_end:]\n\n    return tab_new\n\ndef get_all_fret_positions(tab):\n    fret_pos = {}\n    for string in tab:\n        for match in re.finditer(\'[0-9]+\', string):\n            if match.start() in fret_pos.keys():\n                if fret_pos[match.start()] < match.end():\n                    fret_pos[match.start()] = match.end()\n            else:\n                fret_pos[match.start()] = match.end()\n    return fret_pos\n\ndef apply_amount(col, amount):\n    col_width = 0\n    for i, fret in enumerate(col):\n        new_fret = re.search(\'[0-9]+\', fret)\n        if new_fret:\n            new_fret = int(new_fret.group(0)) + amount\n            if new_fret > 22 or new_fret < 0:\n                return \'Out of frets!\', None\n            if len(str(new_fret)) > col_width:\n                col_width = len(str(new_fret))\n            col[i] = str(new_fret)\n    return col, col_width\n\ndef adjust_column_width(col, col_width):\n    for i, row in enumerate(col):\n        if len(row) < col_width:\n            col[i] = col[i] + \'-\' * (col_width - len(row))\n        if len(row) > col_width:\n            col[i] = col[i][:col_width - len(row)]\n    return col\n\n\nt = transpose(2, [\n\'e|--------5-7-----7-|-8-----8-2-----2-|-0---------0-----|-----------------|\',\n\'B|-10---5-----5-----|---5-------3-----|---1---1-----1---|-0-1-1-----------|\',\n\'G|----5---------5---|-----5-------2---|-----2---------2-|-0-2-2-----------|\',\n\'D|-12-------6-------|-5-------4-------|-3---------------|-----------------|\',\n\'A|------------------|-----------------|-----------------|-2-0-0---0--/8-7-|\',\n\'E|------------------|-----------------|-----------------|-----------------|\'])        \n\nprint(t)\n\n"""\nt = transpose(-1, [\n\'e|-----------------|---------------|----------------|------------------|\',\n\'B|-----------------|---------------|----------------|------------------|\',\n\'G|--0---3---5----0-|---3---6-5-----|-0---3---5----3-|---0----(0)-------|\',\n\'D|--0---3---5----0-|---3---6-5-----|-0---3---5----3-|---0----(0)-------|\',\n\'A|-----------------|---------------|----------------|------------------|\',\n\'E|-----------------|---------------|----------------|------------------|\'])\nt = transpose(+2, [\n\'e|----------5/6-6-6-5/6-6-6-6-6-6------------------------------------|\',\n\'B|-------6--5/6-6-6-5/6-6-6-6-6-6-9-8-6-6----------------------------|\',\n\'G|---6h7--------------------------------6h7--------------------------|\',\n\'D|-8----------------------------------------8-6--8-8-8-8-8-8-8-8-----|\',\n\'A|-----------------------------------------------8-8-8-8-8-8-8-8-----|\',\n\'E|-------------------------------------------------------------------|\'])\nprint(t)\n"""\n\n"""\n\'e|-----------7/8-8-8-7/8-8-8-8-8-8-----------------------------------------------|\',\n\'B|--------8--7/8-8-8-7/8-8-8-8-8-8-11-10-8-8-------------------------------------|\',\n\'G|----8h9----------------------------------8h9-----------------------------------|\',\n\'D|-10------------------------------------------10-8--10-10-10-10-10-10-10-10-----|\',\n\'A|---------------------------------------------------10-10-10-10-10-10-10-10-----|\',\n\'E|-------------------------------------------------------------------------------|\'\n"""'
_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: 12063