`uuid.uuid1()` returns corrupted uuids if called concurrently on free-threaded builds

import os
import platform
import subprocess
import sys
import threading
import time
import uuid

THREADS = 32
SECONDS = 0.01
BATCH = 1024
RUNS = 1000

def valid_bytes(data):
    return (data[6] >> 4) == 1 and (data[8] & 0xC0) == 0x80


def print_corrupted(data, call_number):
    masked = data[:10] + b"\xcc" * 6
    v = uuid.UUID(bytes=masked)
    label = "FIRST CALL" if call_number == 1 else f"call #{call_number}"
    print(
        f"Bug reproduced on {label}:\n"
        f"  {v = !r}\n"
        f"  {v.bytes.hex() = !r}\n"
        f"  {v.clock_seq_hi_variant = }\n"
        f"  {v.version = !r}\n"
        f"  {v.variant = !r}\n"
        f"  variant_bits: {bin(masked[8] >> 6) = }\n"
        f"  {v.is_safe = !r}\n"
    )


def worker_main(mode):
    generate_time_safe = getattr(uuid, "_generate_time_safe", None)
    if generate_time_safe is None:
        print("uuid._generate_time_safe is not available")
        raise SystemExit(2)

    raw_mode = mode == "uuid._generate_time_safe"
    stop = threading.Event()
    barrier = threading.Barrier(THREADS + 1)
    corrupted = []

    def thread_main():
        barrier.wait()
        call_number = 0
        end = time.perf_counter() + SECONDS

        while time.perf_counter() < end and not stop.is_set():
            for _ in range(BATCH):
                call_number += 1
                if raw_mode:
                    data, _ = generate_time_safe()
                    ok = valid_bytes(data)
                else:
                    v = uuid.uuid1()
                    data = v.bytes
                    ok = v.version == 1 and v.variant == uuid.RFC_4122 and v.is_safe

                if not ok:
                    corrupted.append((data, call_number))
                    stop.set()
                    break

    threads = [threading.Thread(target=thread_main) for _ in range(THREADS)]
    any(t.start() for t in threads)
    barrier.wait()
    any(t.join() for t in threads)
    if corrupted:
        data, call_number = corrupted[0]
        print_corrupted(data, call_number)
        raise SystemExit(1)


def run_mode(mode):
    env = {**os.environ, "PYTHON_GIL": "0"}

    print(f"\nTrying: {mode}")
    for run in range(1, RUNS + 1):
        result = subprocess.run(
            [sys.executable, __file__, "worker", mode],
            env=env,
            text=True,
            capture_output=True,
        )
        if result.returncode:
            print()
            print(result.stdout.strip())
            if result.stderr.strip():
                print(result.stderr.strip())
            return result.returncode
        print("Run: ", run, end="\r")

    print("No failure after", RUNS, "runs")
    return 0


def master_main():
    print(f"Python: {sys.version.replace(chr(10), ' ')}")
    print(f"GIL: {getattr(sys, '_is_gil_enabled', lambda: 'unknown')()}")
    print(f"Platform: {platform.platform()}")
    print(f"Machine: {platform.machine()}")
    print(f"CPU: {platform.processor()}")
    print(f"CPU_COUNT: {os.cpu_count()}")
    print(f"uuid._generate_time_safe: {getattr(uuid, '_generate_time_safe', None)}")

    r1 = run_mode("uuid._generate_time_safe")
    if not r1:
        print(f"\nplain `_generate_time_safe` did not reproduce")
    else:
        print(f"\nplain `_generate_time_safe` reproduced; now checking public uuid.uuid1()")

    r2 = run_mode("uuid1")
    raise SystemExit(r1 or r2)


if __name__ == "__main__":
    if len(sys.argv) > 1 and sys.argv[1] == "worker":
        worker_main(sys.argv[2])
    else:
        master_main()