if "size" in pax_headers:
                # If the extended header replaces the size field,
                # we need to recalculate the offset where the next
                # header starts.
                offset = next.offset + BLOCKSIZE
                if next.isreg() or next.type not in SUPPORTED_TYPES:
                    try:
                        size = PAX_NUMBER_FIELDS["size"](pax_headers["size"])
                    except ValueError:
                        size = 0
                    offset += next._block(size)
                tarfile.offset = offset

            next.offset = self.offset

"""tarfile: a pax header carrying 'size', followed by a GNU long-name header.
Builds tiny archives in memory from raw 512-byte blocks (stdlib only) and
prints what tarfile lists and extracts."""
import gzip, io, os, sys, tarfile, tempfile, time

B = 512
LONG = "long-name-" * 12 + "file.txt"         # 128 chars: needs a GNU 'L' header

def hdr(name, size, type=b"0", mode=0o644):    # one ustar header block, valid checksum
    b = bytearray(B)
    b[0:len(name)] = name.encode()
    b[100:108] = b"%07o\0" % mode
    b[108:116] = b[116:124] = b"%07o\0" % 0
    b[124:136] = b"%011o\0" % size
    b[136:148] = b"%011o\0" % 0
    b[148:156] = b" " * 8
    b[156:157] = type
    b[257:265] = b"ustar\x0000"
    b[148:156] = b"%06o\0 " % sum(b)
    return bytes(b)

def blk(data):                                 # pad to whole blocks
    return data + b"\0" * (-len(data) % B)

def pax(**kv):                                 # 'x' extended header + records
    body = b""
    for k, v in kv.items():
        rec = f" {k}={v}\n".encode()
        n = len(rec) + 1
        while n != len(rec) + len(str(n)):
            n = len(rec) + len(str(n))
        body += str(n).encode() + rec
    return hdr("././@PaxHeader", len(body), b"x") + blk(body)

def longname(name, extra=b""):                 # GNU 'L' header + body (+ bytes planted after the name)
    body = blk(name.encode() + b"\0") + extra
    return hdr("././@LongLink", len(body), b"L") + body

def reg(name, data):                           # regular file member
    return hdr(name, len(data)) + blk(data)

EOF = b"\0" * (2 * B)
cases = {
    "A: x(size=5) L member next":
        pax(size=5) + longname(LONG) + reg("member-short", b"hello") + reg("next.txt", b"bye") + EOF,
    "B: same with size=1536":
        pax(size=1536) + longname(LONG) + reg("member-short", b"z" * 1536) + reg("next.txt", b"bye") + EOF,
    "C: A with a header block planted in the long-name body":
        pax(size=5) + longname(LONG, extra=hdr("PLANTED", 0, mode=0o4755))
        + reg("member-short", b"hello") + reg("next.txt", b"bye") + EOF,
}

def show(names):
    return ["LONG" if n == LONG else n for n in names]

print("Python", sys.version.split()[0])
for label, buf in cases.items():
    print(label)
    for mode in ("r:", "r|"):
        try:
            with tarfile.open(fileobj=io.BytesIO(buf), mode=mode) as tf:
                names = show(ti.name for ti in tf)
            print(f"   list {mode}  {names}")
        except tarfile.TarError as e:
            print(f"   list {mode}  {type(e).__name__}: {e}")
    with tempfile.TemporaryDirectory() as d:
        with tarfile.open(fileobj=io.BytesIO(buf), mode="r:") as tf:
            tf.extractall(d, filter="data")
        print(f"   extractall  {show(sorted(os.listdir(d)))}")

# D: listing time. n nested levels, each = x(size=0) + an 'L' header whose
# body claims everything up to the final member's header.
def nested(n):
    out = b""
    for i in range(n):
        out += pax(size=0) + hdr("././@LongLink", (n - 1 - i) * 1536 + B, b"L")
    return out + blk(b"name\0") + reg("last", b"") + EOF

def timed(label, buf):
    t = time.perf_counter()
    with tarfile.open(fileobj=io.BytesIO(buf), mode="r:*") as tf:
        count = len(tf.getmembers())
    print(f"D: {label}, {len(buf) / 1e6:.2f} MB: {count} member(s) in {time.perf_counter() - t:.2f} s")

for n in (1000, 2000, 4000):
    timed(f"{n} levels", nested(n))
timed("4000 levels gzipped", gzip.compress(nested(4000)))