Intermediate changes

commit_hash:1f9110413b1655b37aa301b93c0f03f212db79be

21 files changed, 1516 insertions, 1288 deletions

diff --git a/contrib/python/anyio/.dist-info/METADATA b/contrib/python/anyio/.dist-info/METADATA
index be13c8aa0f..3fee32ffa3 100644
--- a/contrib/python/anyio/.dist-info/METADATA
+++ b/contrib/python/anyio/.dist-info/METADATA
@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: anyio
-Version: 4.4.0
+Version: 4.5.0
 Summary: High level compatibility layer for multiple asynchronous event loop implementations
 Author-email: Alex Grönholm <alex.gronholm@nextday.fi>
 License: MIT
@@ -20,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 License-File: LICENSE
@@ -29,7 +30,7 @@ Requires-Dist: exceptiongroup >=1.0.2 ; python_version < "3.11"
 Requires-Dist: typing-extensions >=4.1 ; python_version < "3.11"
 Provides-Extra: doc
 Requires-Dist: packaging ; extra == 'doc'
-Requires-Dist: Sphinx >=7 ; extra == 'doc'
+Requires-Dist: Sphinx ~=7.4 ; extra == 'doc'
 Requires-Dist: sphinx-rtd-theme ; extra == 'doc'
 Requires-Dist: sphinx-autodoc-typehints >=1.2.0 ; extra == 'doc'
 Provides-Extra: test
@@ -41,9 +42,9 @@ Requires-Dist: psutil >=5.9 ; extra == 'test'
 Requires-Dist: pytest >=7.0 ; extra == 'test'
 Requires-Dist: pytest-mock >=3.6.1 ; extra == 'test'
 Requires-Dist: trustme ; extra == 'test'
-Requires-Dist: uvloop >=0.17 ; (platform_python_implementation == "CPython" and platform_system != "Windows") and extra == 'test'
+Requires-Dist: uvloop >=0.21.0b1 ; (platform_python_implementation == "CPython" and platform_system != "Windows") and extra == 'test'
 Provides-Extra: trio
-Requires-Dist: trio >=0.23 ; extra == 'trio'
+Requires-Dist: trio >=0.26.1 ; extra == 'trio'
 
 .. image:: https://github.com/agronholm/anyio/actions/workflows/test.yml/badge.svg
   :target: https://github.com/agronholm/anyio/actions/workflows/test.yml
diff --git a/contrib/python/anyio/anyio/__init__.py b/contrib/python/anyio/anyio/__init__.py
index 7bfe231645..fd9fe06bcf 100644
--- a/contrib/python/anyio/anyio/__init__.py
+++ b/contrib/python/anyio/anyio/__init__.py
@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Any
-
 from ._core._eventloop import current_time as current_time
 from ._core._eventloop import get_all_backends as get_all_backends
 from ._core._eventloop import get_cancelled_exc_class as get_cancelled_exc_class
@@ -69,8 +67,8 @@ from ._core._typedattr import TypedAttributeSet as TypedAttributeSet
 from ._core._typedattr import typed_attribute as typed_attribute
 
 # Re-export imports so they look like they live directly in this package
-key: str
-value: Any
-for key, value in list(locals().items()):
-    if getattr(value, "__module__", "").startswith("anyio."):
-        value.__module__ = __name__
+for __value in list(locals().values()):
+    if getattr(__value, "__module__", "").startswith("anyio."):
+        __value.__module__ = __name__
+
+del __value
diff --git a/contrib/python/anyio/anyio/_backends/_asyncio.py b/contrib/python/anyio/anyio/_backends/_asyncio.py
index 43b7cb0e0c..0d4cdf650d 100644
--- a/contrib/python/anyio/anyio/_backends/_asyncio.py
+++ b/contrib/python/anyio/anyio/_backends/_asyncio.py
@@ -4,6 +4,7 @@ import array
 import asyncio
 import concurrent.futures
 import math
+import os
 import socket
 import sys
 import threading
@@ -19,7 +20,7 @@ from asyncio import (
 )
 from asyncio.base_events import _run_until_complete_cb  # type: ignore[attr-defined]
 from collections import OrderedDict, deque
-from collections.abc import AsyncIterator, Generator, Iterable
+from collections.abc import AsyncIterator, Iterable
 from concurrent.futures import Future
 from contextlib import suppress
 from contextvars import Context, copy_context
@@ -47,7 +48,6 @@ from typing import (
     Collection,
     ContextManager,
     Coroutine,
-    Mapping,
     Optional,
     Sequence,
     Tuple,
@@ -58,7 +58,13 @@ from weakref import WeakKeyDictionary
 
 import sniffio
 
-from .. import CapacityLimiterStatistics, EventStatistics, TaskInfo, abc
+from .. import (
+    CapacityLimiterStatistics,
+    EventStatistics,
+    LockStatistics,
+    TaskInfo,
+    abc,
+)
 from .._core._eventloop import claim_worker_thread, threadlocals
 from .._core._exceptions import (
     BrokenResourceError,
@@ -66,12 +72,20 @@ from .._core._exceptions import (
     ClosedResourceError,
     EndOfStream,
     WouldBlock,
+    iterate_exceptions,
 )
 from .._core._sockets import convert_ipv6_sockaddr
 from .._core._streams import create_memory_object_stream
-from .._core._synchronization import CapacityLimiter as BaseCapacityLimiter
+from .._core._synchronization import (
+    CapacityLimiter as BaseCapacityLimiter,
+)
 from .._core._synchronization import Event as BaseEvent
-from .._core._synchronization import ResourceGuard
+from .._core._synchronization import Lock as BaseLock
+from .._core._synchronization import (
+    ResourceGuard,
+    SemaphoreStatistics,
+)
+from .._core._synchronization import Semaphore as BaseSemaphore
 from .._core._tasks import CancelScope as BaseCancelScope
 from ..abc import (
     AsyncBackend,
@@ -80,6 +94,7 @@ from ..abc import (
     UDPPacketType,
     UNIXDatagramPacketType,
 )
+from ..abc._eventloop import StrOrBytesPath
 from ..lowlevel import RunVar
 from ..streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
 
@@ -630,16 +645,6 @@ class _AsyncioTaskStatus(abc.TaskStatus):
         _task_states[task].parent_id = self._parent_id
 
 
-def iterate_exceptions(
-    exception: BaseException,
-) -> Generator[BaseException, None, None]:
-    if isinstance(exception, BaseExceptionGroup):
-        for exc in exception.exceptions:
-            yield from iterate_exceptions(exc)
-    else:
-        yield exception
-
-
 class TaskGroup(abc.TaskGroup):
     def __init__(self) -> None:
         self.cancel_scope: CancelScope = CancelScope()
@@ -925,7 +930,7 @@ class StreamReaderWrapper(abc.ByteReceiveStream):
             raise EndOfStream
 
     async def aclose(self) -> None:
-        self._stream.feed_eof()
+        self._stream.set_exception(ClosedResourceError())
         await AsyncIOBackend.checkpoint()
 
 
@@ -1073,7 +1078,8 @@ class StreamProtocol(asyncio.Protocol):
         self.write_event.set()
 
     def data_received(self, data: bytes) -> None:
-        self.read_queue.append(data)
+        # ProactorEventloop sometimes sends bytearray instead of bytes
+        self.read_queue.append(bytes(data))
         self.read_event.set()
 
     def eof_received(self) -> bool | None:
@@ -1665,6 +1671,154 @@ class Event(BaseEvent):
         return EventStatistics(len(self._event._waiters))
 
 
+class Lock(BaseLock):
+    def __new__(cls, *, fast_acquire: bool = False) -> Lock:
+        return object.__new__(cls)
+
+    def __init__(self, *, fast_acquire: bool = False) -> None:
+        self._fast_acquire = fast_acquire
+        self._owner_task: asyncio.Task | None = None
+        self._waiters: deque[tuple[asyncio.Task, asyncio.Future]] = deque()
+
+    async def acquire(self) -> None:
+        if self._owner_task is None and not self._waiters:
+            await AsyncIOBackend.checkpoint_if_cancelled()
+            self._owner_task = current_task()
+
+            # Unless on the "fast path", yield control of the event loop so that other
+            # tasks can run too
+            if not self._fast_acquire:
+                try:
+                    await AsyncIOBackend.cancel_shielded_checkpoint()
+                except CancelledError:
+                    self.release()
+                    raise
+
+            return
+
+        task = cast(asyncio.Task, current_task())
+        fut: asyncio.Future[None] = asyncio.Future()
+        item = task, fut
+        self._waiters.append(item)
+        try:
+            await fut
+        except CancelledError:
+            self._waiters.remove(item)
+            if self._owner_task is task:
+                self.release()
+
+            raise
+
+        self._waiters.remove(item)
+
+    def acquire_nowait(self) -> None:
+        if self._owner_task is None and not self._waiters:
+            self._owner_task = current_task()
+            return
+
+        raise WouldBlock
+
+    def locked(self) -> bool:
+        return self._owner_task is not None
+
+    def release(self) -> None:
+        if self._owner_task != current_task():
+            raise RuntimeError("The current task is not holding this lock")
+
+        for task, fut in self._waiters:
+            if not fut.cancelled():
+                self._owner_task = task
+                fut.set_result(None)
+                return
+
+        self._owner_task = None
+
+    def statistics(self) -> LockStatistics:
+        task_info = AsyncIOTaskInfo(self._owner_task) if self._owner_task else None
+        return LockStatistics(self.locked(), task_info, len(self._waiters))
+
+
+class Semaphore(BaseSemaphore):
+    def __new__(
+        cls,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ) -> Semaphore:
+        return object.__new__(cls)
+
+    def __init__(
+        self,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ):
+        super().__init__(initial_value, max_value=max_value)
+        self._value = initial_value
+        self._max_value = max_value
+        self._fast_acquire = fast_acquire
+        self._waiters: deque[asyncio.Future[None]] = deque()
+
+    async def acquire(self) -> None:
+        if self._value > 0 and not self._waiters:
+            await AsyncIOBackend.checkpoint_if_cancelled()
+            self._value -= 1
+
+            # Unless on the "fast path", yield control of the event loop so that other
+            # tasks can run too
+            if not self._fast_acquire:
+                try:
+                    await AsyncIOBackend.cancel_shielded_checkpoint()
+                except CancelledError:
+                    self.release()
+                    raise
+
+            return
+
+        fut: asyncio.Future[None] = asyncio.Future()
+        self._waiters.append(fut)
+        try:
+            await fut
+        except CancelledError:
+            try:
+                self._waiters.remove(fut)
+            except ValueError:
+                self.release()
+
+            raise
+
+    def acquire_nowait(self) -> None:
+        if self._value == 0:
+            raise WouldBlock
+
+        self._value -= 1
+
+    def release(self) -> None:
+        if self._max_value is not None and self._value == self._max_value:
+            raise ValueError("semaphore released too many times")
+
+        for fut in self._waiters:
+            if not fut.cancelled():
+                fut.set_result(None)
+                self._waiters.remove(fut)
+                return
+
+        self._value += 1
+
+    @property
+    def value(self) -> int:
+        return self._value
+
+    @property
+    def max_value(self) -> int | None:
+        return self._max_value
+
+    def statistics(self) -> SemaphoreStatistics:
+        return SemaphoreStatistics(len(self._waiters))
+
+
 class CapacityLimiter(BaseCapacityLimiter):
     _total_tokens: float = 0
 
@@ -1861,7 +2015,9 @@ class AsyncIOTaskInfo(TaskInfo):
 
         if task_state := _task_states.get(task):
             if cancel_scope := task_state.cancel_scope:
-                return cancel_scope.cancel_called or cancel_scope._parent_cancelled()
+                return cancel_scope.cancel_called or (
+                    not cancel_scope.shield and cancel_scope._parent_cancelled()
+                )
 
         return False
 
@@ -1926,13 +2082,23 @@ class TestRunner(abc.TestRunner):
             tuple[Awaitable[T_Retval], asyncio.Future[T_Retval]]
         ],
     ) -> None:
+        from _pytest.outcomes import OutcomeException
+
         with receive_stream, self._send_stream:
             async for coro, future in receive_stream:
                 try:
                     retval = await coro
+                except CancelledError as exc:
+                    if not future.cancelled():
+                        future.cancel(*exc.args)
+
+                    raise
                 except BaseException as exc:
                     if not future.cancelled():
                         future.set_exception(exc)
+
+                    if not isinstance(exc, (Exception, OutcomeException)):
+                        raise
                 else:
                     if not future.cancelled():
                         future.set_result(retval)
@@ -2114,6 +2280,20 @@ class AsyncIOBackend(AsyncBackend):
         return Event()
 
     @classmethod
+    def create_lock(cls, *, fast_acquire: bool) -> abc.Lock:
+        return Lock(fast_acquire=fast_acquire)
+
+    @classmethod
+    def create_semaphore(
+        cls,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ) -> abc.Semaphore:
+        return Semaphore(initial_value, max_value=max_value, fast_acquire=fast_acquire)
+
+    @classmethod
     def create_capacity_limiter(cls, total_tokens: float) -> abc.CapacityLimiter:
         return CapacityLimiter(total_tokens)
 
@@ -2245,26 +2425,24 @@ class AsyncIOBackend(AsyncBackend):
     @classmethod
     async def open_process(
         cls,
-        command: str | bytes | Sequence[str | bytes],
+        command: StrOrBytesPath | Sequence[StrOrBytesPath],
         *,
-        shell: bool,
         stdin: int | IO[Any] | None,
         stdout: int | IO[Any] | None,
         stderr: int | IO[Any] | None,
-        cwd: str | bytes | PathLike | None = None,
-        env: Mapping[str, str] | None = None,
-        start_new_session: bool = False,
+        **kwargs: Any,
     ) -> Process:
         await cls.checkpoint()
-        if shell:
+        if isinstance(command, PathLike):
+            command = os.fspath(command)
+
+        if isinstance(command, (str, bytes)):
             process = await asyncio.create_subprocess_shell(
-                cast("str | bytes", command),
+                command,
                 stdin=stdin,
                 stdout=stdout,
                 stderr=stderr,
-                cwd=cwd,
-                env=env,
-                start_new_session=start_new_session,
+                **kwargs,
             )
         else:
             process = await asyncio.create_subprocess_exec(
@@ -2272,9 +2450,7 @@ class AsyncIOBackend(AsyncBackend):
                 stdin=stdin,
                 stdout=stdout,
                 stderr=stderr,
-                cwd=cwd,
-                env=env,
-                start_new_session=start_new_session,
+                **kwargs,
             )
 
         stdin_stream = StreamWriterWrapper(process.stdin) if process.stdin else None
@@ -2289,7 +2465,7 @@ class AsyncIOBackend(AsyncBackend):
             name="AnyIO process pool shutdown task",
         )
         find_root_task().add_done_callback(
-            partial(_forcibly_shutdown_process_pool_on_exit, workers)
+            partial(_forcibly_shutdown_process_pool_on_exit, workers)  # type:ignore[arg-type]
         )
 
     @classmethod
diff --git a/contrib/python/anyio/anyio/_backends/_trio.py b/contrib/python/anyio/anyio/_backends/_trio.py
index cf6f3db789..9b8369d4c5 100644
--- a/contrib/python/anyio/anyio/_backends/_trio.py
+++ b/contrib/python/anyio/anyio/_backends/_trio.py
@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import array
 import math
+import os
 import socket
 import sys
 import types
@@ -25,7 +26,6 @@ from typing import (
     ContextManager,
     Coroutine,
     Generic,
-    Mapping,
     NoReturn,
     Sequence,
     TypeVar,
@@ -45,7 +45,14 @@ from trio.lowlevel import (
 from trio.socket import SocketType as TrioSocketType
 from trio.to_thread import run_sync
 
-from .. import CapacityLimiterStatistics, EventStatistics, TaskInfo, abc
+from .. import (
+    CapacityLimiterStatistics,
+    EventStatistics,
+    LockStatistics,
+    TaskInfo,
+    WouldBlock,
+    abc,
+)
 from .._core._eventloop import claim_worker_thread
 from .._core._exceptions import (
     BrokenResourceError,
@@ -55,12 +62,19 @@ from .._core._exceptions import (
 )
 from .._core._sockets import convert_ipv6_sockaddr
 from .._core._streams import create_memory_object_stream
-from .._core._synchronization import CapacityLimiter as BaseCapacityLimiter
+from .._core._synchronization import (
+    CapacityLimiter as BaseCapacityLimiter,
+)
 from .._core._synchronization import Event as BaseEvent
-from .._core._synchronization import ResourceGuard
+from .._core._synchronization import Lock as BaseLock
+from .._core._synchronization import (
+    ResourceGuard,
+    SemaphoreStatistics,
+)
+from .._core._synchronization import Semaphore as BaseSemaphore
 from .._core._tasks import CancelScope as BaseCancelScope
 from ..abc import IPSockAddrType, UDPPacketType, UNIXDatagramPacketType
-from ..abc._eventloop import AsyncBackend
+from ..abc._eventloop import AsyncBackend, StrOrBytesPath
 from ..streams.memory import MemoryObjectSendStream
 
 if sys.version_info >= (3, 10):
@@ -637,6 +651,100 @@ class Event(BaseEvent):
         self.__original.set()
 
 
+class Lock(BaseLock):
+    def __new__(cls, *, fast_acquire: bool = False) -> Lock:
+        return object.__new__(cls)
+
+    def __init__(self, *, fast_acquire: bool = False) -> None:
+        self._fast_acquire = fast_acquire
+        self.__original = trio.Lock()
+
+    async def acquire(self) -> None:
+        if not self._fast_acquire:
+            await self.__original.acquire()
+            return
+
+        # This is the "fast path" where we don't let other tasks run
+        await trio.lowlevel.checkpoint_if_cancelled()
+        try:
+            self.__original.acquire_nowait()
+        except trio.WouldBlock:
+            await self.__original._lot.park()
+
+    def acquire_nowait(self) -> None:
+        try:
+            self.__original.acquire_nowait()
+        except trio.WouldBlock:
+            raise WouldBlock from None
+
+    def locked(self) -> bool:
+        return self.__original.locked()
+
+    def release(self) -> None:
+        self.__original.release()
+
+    def statistics(self) -> LockStatistics:
+        orig_statistics = self.__original.statistics()
+        owner = TrioTaskInfo(orig_statistics.owner) if orig_statistics.owner else None
+        return LockStatistics(
+            orig_statistics.locked, owner, orig_statistics.tasks_waiting
+        )
+
+
+class Semaphore(BaseSemaphore):
+    def __new__(
+        cls,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ) -> Semaphore:
+        return object.__new__(cls)
+
+    def __init__(
+        self,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ) -> None:
+        super().__init__(initial_value, max_value=max_value, fast_acquire=fast_acquire)
+        self.__original = trio.Semaphore(initial_value, max_value=max_value)
+
+    async def acquire(self) -> None:
+        if not self._fast_acquire:
+            await self.__original.acquire()
+            return
+
+        # This is the "fast path" where we don't let other tasks run
+        await trio.lowlevel.checkpoint_if_cancelled()
+        try:
+            self.__original.acquire_nowait()
+        except trio.WouldBlock:
+            await self.__original._lot.park()
+
+    def acquire_nowait(self) -> None:
+        try:
+            self.__original.acquire_nowait()
+        except trio.WouldBlock:
+            raise WouldBlock from None
+
+    @property
+    def max_value(self) -> int | None:
+        return self.__original.max_value
+
+    @property
+    def value(self) -> int:
+        return self.__original.value
+
+    def release(self) -> None:
+        self.__original.release()
+
+    def statistics(self) -> SemaphoreStatistics:
+        orig_statistics = self.__original.statistics()
+        return SemaphoreStatistics(orig_statistics.tasks_waiting)
+
+
 class CapacityLimiter(BaseCapacityLimiter):
     def __new__(
         cls,
@@ -916,6 +1024,20 @@ class TrioBackend(AsyncBackend):
         return Event()
 
     @classmethod
+    def create_lock(cls, *, fast_acquire: bool) -> Lock:
+        return Lock(fast_acquire=fast_acquire)
+
+    @classmethod
+    def create_semaphore(
+        cls,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ) -> abc.Semaphore:
+        return Semaphore(initial_value, max_value=max_value, fast_acquire=fast_acquire)
+
+    @classmethod
     def create_capacity_limiter(cls, total_tokens: float) -> CapacityLimiter:
         return CapacityLimiter(total_tokens)
 
@@ -967,26 +1089,39 @@ class TrioBackend(AsyncBackend):
     @classmethod
     async def open_process(
         cls,
-        command: str | bytes | Sequence[str | bytes],
+        command: StrOrBytesPath | Sequence[StrOrBytesPath],
         *,
-        shell: bool,
         stdin: int | IO[Any] | None,
         stdout: int | IO[Any] | None,
         stderr: int | IO[Any] | None,
-        cwd: str | bytes | PathLike | None = None,
-        env: Mapping[str, str] | None = None,
-        start_new_session: bool = False,
+        **kwargs: Any,
     ) -> Process:
-        process = await trio.lowlevel.open_process(  # type: ignore[misc]
-            command,  # type: ignore[arg-type]
-            stdin=stdin,
-            stdout=stdout,
-            stderr=stderr,
-            shell=shell,
-            cwd=cwd,
-            env=env,
-            start_new_session=start_new_session,
-        )
+        def convert_item(item: StrOrBytesPath) -> str:
+            str_or_bytes = os.fspath(item)
+            if isinstance(str_or_bytes, str):
+                return str_or_bytes
+            else:
+                return os.fsdecode(str_or_bytes)
+
+        if isinstance(command, (str, bytes, PathLike)):
+            process = await trio.lowlevel.open_process(
+                convert_item(command),
+                stdin=stdin,
+                stdout=stdout,
+                stderr=stderr,
+                shell=True,
+                **kwargs,
+            )
+        else:
+            process = await trio.lowlevel.open_process(
+                [convert_item(item) for item in command],
+                stdin=stdin,
+                stdout=stdout,
+                stderr=stderr,
+                shell=False,
+                **kwargs,
+            )
+
         stdin_stream = SendStreamWrapper(process.stdin) if process.stdin else None
         stdout_stream = ReceiveStreamWrapper(process.stdout) if process.stdout else None
         stderr_stream = ReceiveStreamWrapper(process.stderr) if process.stderr else None
diff --git a/contrib/python/anyio/anyio/_core/_exceptions.py b/contrib/python/anyio/anyio/_core/_exceptions.py
index 571c3b8531..6e3f8ccc67 100644
--- a/contrib/python/anyio/anyio/_core/_exceptions.py
+++ b/contrib/python/anyio/anyio/_core/_exceptions.py
@@ -1,5 +1,11 @@
 from __future__ import annotations
 
+import sys
+from collections.abc import Generator
+
+if sys.version_info < (3, 11):
+    from exceptiongroup import BaseExceptionGroup
+
 
 class BrokenResourceError(Exception):
     """
@@ -71,3 +77,13 @@ class TypedAttributeLookupError(LookupError):
 
 class WouldBlock(Exception):
     """Raised by ``X_nowait`` functions if ``X()`` would block."""
+
+
+def iterate_exceptions(
+    exception: BaseException,
+) -> Generator[BaseException, None, None]:
+    if isinstance(exception, BaseExceptionGroup):
+        for exc in exception.exceptions:
+            yield from iterate_exceptions(exc)
+    else:
+        yield exception
diff --git a/contrib/python/anyio/anyio/_core/_fileio.py b/contrib/python/anyio/anyio/_core/_fileio.py
index df2057fe34..9503d944bb 100644
--- a/contrib/python/anyio/anyio/_core/_fileio.py
+++ b/contrib/python/anyio/anyio/_core/_fileio.py
@@ -358,8 +358,26 @@ class Path:
     def as_uri(self) -> str:
         return self._path.as_uri()
 
-    def match(self, path_pattern: str) -> bool:
-        return self._path.match(path_pattern)
+    if sys.version_info >= (3, 13):
+        parser = pathlib.Path.parser
+
+        @classmethod
+        def from_uri(cls, uri: str) -> Path:
+            return Path(pathlib.Path.from_uri(uri))
+
+        def full_match(
+            self, path_pattern: str, *, case_sensitive: bool | None = None
+        ) -> bool:
+            return self._path.full_match(path_pattern, case_sensitive=case_sensitive)
+
+        def match(
+            self, path_pattern: str, *, case_sensitive: bool | None = None
+        ) -> bool:
+            return self._path.match(path_pattern, case_sensitive=case_sensitive)
+    else:
+
+        def match(self, path_pattern: str) -> bool:
+            return self._path.match(path_pattern)
 
     def is_relative_to(self, other: str | PathLike[str]) -> bool:
         try:
diff --git a/contrib/python/anyio/anyio/_core/_sockets.py b/contrib/python/anyio/anyio/_core/_sockets.py
index 5e09cdbf0f..6070c647fd 100644
--- a/contrib/python/anyio/anyio/_core/_sockets.py
+++ b/contrib/python/anyio/anyio/_core/_sockets.py
@@ -680,19 +680,26 @@ async def setup_unix_local_socket(
     :param socktype: socket.SOCK_STREAM or socket.SOCK_DGRAM
 
     """
-    path_str: str | bytes | None
+    path_str: str | None
     if path is not None:
-        path_str = os.fspath(path)
-
-        # Copied from pathlib...
-        try:
-            stat_result = os.stat(path)
-        except OSError as e:
-            if e.errno not in (errno.ENOENT, errno.ENOTDIR, errno.EBADF, errno.ELOOP):
-                raise
-        else:
-            if stat.S_ISSOCK(stat_result.st_mode):
-                os.unlink(path)
+        path_str = os.fsdecode(path)
+
+        # Linux abstract namespace sockets aren't backed by a concrete file so skip stat call
+        if not path_str.startswith("\0"):
+            # Copied from pathlib...
+            try:
+                stat_result = os.stat(path)
+            except OSError as e:
+                if e.errno not in (
+                    errno.ENOENT,
+                    errno.ENOTDIR,
+                    errno.EBADF,
+                    errno.ELOOP,
+                ):
+                    raise
+            else:
+                if stat.S_ISSOCK(stat_result.st_mode):
+                    os.unlink(path)
     else:
         path_str = None
 
diff --git a/contrib/python/anyio/anyio/_core/_subprocesses.py b/contrib/python/anyio/anyio/_core/_subprocesses.py
index 5d5d7b768a..1ac2d549df 100644
--- a/contrib/python/anyio/anyio/_core/_subprocesses.py
+++ b/contrib/python/anyio/anyio/_core/_subprocesses.py
@@ -1,26 +1,41 @@
 from __future__ import annotations
 
-from collections.abc import AsyncIterable, Mapping, Sequence
+import sys
+from collections.abc import AsyncIterable, Iterable, Mapping, Sequence
 from io import BytesIO
 from os import PathLike
 from subprocess import DEVNULL, PIPE, CalledProcessError, CompletedProcess
-from typing import IO, Any, cast
+from typing import IO, Any, Union, cast
 
 from ..abc import Process
 from ._eventloop import get_async_backend
 from ._tasks import create_task_group
 
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
+
+StrOrBytesPath: TypeAlias = Union[str, bytes, "PathLike[str]", "PathLike[bytes]"]
+
 
 async def run_process(
-    command: str | bytes | Sequence[str | bytes],
+    command: StrOrBytesPath | Sequence[StrOrBytesPath],
     *,
     input: bytes | None = None,
     stdout: int | IO[Any] | None = PIPE,
     stderr: int | IO[Any] | None = PIPE,
     check: bool = True,
-    cwd: str | bytes | PathLike[str] | None = None,
+    cwd: StrOrBytesPath | None = None,
     env: Mapping[str, str] | None = None,
+    startupinfo: Any = None,
+    creationflags: int = 0,
     start_new_session: bool = False,
+    pass_fds: Sequence[int] = (),
+    user: str | int | None = None,
+    group: str | int | None = None,
+    extra_groups: Iterable[str | int] | None = None,
+    umask: int = -1,
 ) -> CompletedProcess[bytes]:
     """
     Run an external command in a subprocess and wait until it completes.
@@ -40,8 +55,20 @@ async def run_process(
         command
     :param env: if not ``None``, this mapping replaces the inherited environment
         variables from the parent process
+    :param startupinfo: an instance of :class:`subprocess.STARTUPINFO` that can be used
+        to specify process startup parameters (Windows only)
+    :param creationflags: flags that can be used to control the creation of the
+        subprocess (see :class:`subprocess.Popen` for the specifics)
     :param start_new_session: if ``true`` the setsid() system call will be made in the
         child process prior to the execution of the subprocess. (POSIX only)
+    :param pass_fds: sequence of file descriptors to keep open between the parent and
+        child processes. (POSIX only)
+    :param user: effective user to run the process as (Python >= 3.9, POSIX only)
+    :param group: effective group to run the process as (Python >= 3.9, POSIX only)
+    :param extra_groups: supplementary groups to set in the subprocess (Python >= 3.9,
+        POSIX only)
+    :param umask: if not negative, this umask is applied in the child process before
+        running the given command (Python >= 3.9, POSIX only)
     :return: an object representing the completed process
     :raises ~subprocess.CalledProcessError: if ``check`` is ``True`` and the process
         exits with a nonzero return code
@@ -62,7 +89,14 @@ async def run_process(
         stderr=stderr,
         cwd=cwd,
         env=env,
+        startupinfo=startupinfo,
+        creationflags=creationflags,
         start_new_session=start_new_session,
+        pass_fds=pass_fds,
+        user=user,
+        group=group,
+        extra_groups=extra_groups,
+        umask=umask,
     ) as process:
         stream_contents: list[bytes | None] = [None, None]
         async with create_task_group() as tg:
@@ -86,14 +120,21 @@ async def run_process(
 
 
 async def open_process(
-    command: str | bytes | Sequence[str | bytes],
+    command: StrOrBytesPath | Sequence[StrOrBytesPath],
     *,
     stdin: int | IO[Any] | None = PIPE,
     stdout: int | IO[Any] | None = PIPE,
     stderr: int | IO[Any] | None = PIPE,
-    cwd: str | bytes | PathLike[str] | None = None,
+    cwd: StrOrBytesPath | None = None,
     env: Mapping[str, str] | None = None,
+    startupinfo: Any = None,
+    creationflags: int = 0,
     start_new_session: bool = False,
+    pass_fds: Sequence[int] = (),
+    user: str | int | None = None,
+    group: str | int | None = None,
+    extra_groups: Iterable[str | int] | None = None,
+    umask: int = -1,
 ) -> Process:
     """
     Start an external command in a subprocess.
@@ -111,30 +152,58 @@ async def open_process(
     :param cwd: If not ``None``, the working directory is changed before executing
     :param env: If env is not ``None``, it must be a mapping that defines the
         environment variables for the new process
+    :param creationflags: flags that can be used to control the creation of the
+        subprocess (see :class:`subprocess.Popen` for the specifics)
+    :param startupinfo: an instance of :class:`subprocess.STARTUPINFO` that can be used
+        to specify process startup parameters (Windows only)
     :param start_new_session: if ``true`` the setsid() system call will be made in the
         child process prior to the execution of the subprocess. (POSIX only)
+    :param pass_fds: sequence of file descriptors to keep open between the parent and
+        child processes. (POSIX only)
+    :param user: effective user to run the process as (Python >= 3.9; POSIX only)
+    :param group: effective group to run the process as (Python >= 3.9; POSIX only)
+    :param extra_groups: supplementary groups to set in the subprocess (Python >= 3.9;
+        POSIX only)
+    :param umask: if not negative, this umask is applied in the child process before
+        running the given command (Python >= 3.9; POSIX only)
     :return: an asynchronous process object
 
     """
-    if isinstance(command, (str, bytes)):
-        return await get_async_backend().open_process(
-            command,
-            shell=True,
-            stdin=stdin,
-            stdout=stdout,
-            stderr=stderr,
-            cwd=cwd,
-            env=env,
-            start_new_session=start_new_session,
-        )
-    else:
-        return await get_async_backend().open_process(
-            command,
-            shell=False,
-            stdin=stdin,
-            stdout=stdout,
-            stderr=stderr,
-            cwd=cwd,
-            env=env,
-            start_new_session=start_new_session,
-        )
+    kwargs: dict[str, Any] = {}
+    if user is not None:
+        if sys.version_info < (3, 9):
+            raise TypeError("the 'user' argument requires Python 3.9 or later")
+
+        kwargs["user"] = user
+
+    if group is not None:
+        if sys.version_info < (3, 9):
+            raise TypeError("the 'group' argument requires Python 3.9 or later")
+
+        kwargs["group"] = group
+
+    if extra_groups is not None:
+        if sys.version_info < (3, 9):
+            raise TypeError("the 'extra_groups' argument requires Python 3.9 or later")
+
+        kwargs["extra_groups"] = group
+
+    if umask >= 0:
+        if sys.version_info < (3, 9):
+            raise TypeError("the 'umask' argument requires Python 3.9 or later")
+
+        kwargs["umask"] = umask
+
+    return await get_async_backend().open_process(
+        command,
+        stdin=stdin,
+        stdout=stdout,
+        stderr=stderr,
+        cwd=cwd,
+        env=env,
+        startupinfo=startupinfo,
+        creationflags=creationflags,
+        start_new_session=start_new_session,
+        pass_fds=pass_fds,
+        **kwargs,
+    )
diff --git a/contrib/python/anyio/anyio/_core/_synchronization.py b/contrib/python/anyio/anyio/_core/_synchronization.py
index b274a31ea2..023ab73370 100644
--- a/contrib/python/anyio/anyio/_core/_synchronization.py
+++ b/contrib/python/anyio/anyio/_core/_synchronization.py
@@ -7,9 +7,9 @@ from types import TracebackType
 
 from sniffio import AsyncLibraryNotFoundError
 
-from ..lowlevel import cancel_shielded_checkpoint, checkpoint, checkpoint_if_cancelled
+from ..lowlevel import checkpoint
 from ._eventloop import get_async_backend
-from ._exceptions import BusyResourceError, WouldBlock
+from ._exceptions import BusyResourceError
 from ._tasks import CancelScope
 from ._testing import TaskInfo, get_current_task
 
@@ -137,10 +137,11 @@ class EventAdapter(Event):
 
 
 class Lock:
-    _owner_task: TaskInfo | None = None
-
-    def __init__(self) -> None:
-        self._waiters: deque[tuple[TaskInfo, Event]] = deque()
+    def __new__(cls, *, fast_acquire: bool = False) -> Lock:
+        try:
+            return get_async_backend().create_lock(fast_acquire=fast_acquire)
+        except AsyncLibraryNotFoundError:
+            return LockAdapter(fast_acquire=fast_acquire)
 
     async def __aenter__(self) -> None:
         await self.acquire()
@@ -155,31 +156,7 @@ class Lock:
 
     async def acquire(self) -> None:
         """Acquire the lock."""
-        await checkpoint_if_cancelled()
-        try:
-            self.acquire_nowait()
-        except WouldBlock:
-            task = get_current_task()
-            event = Event()
-            token = task, event
-            self._waiters.append(token)
-            try:
-                await event.wait()
-            except BaseException:
-                if not event.is_set():
-                    self._waiters.remove(token)
-                elif self._owner_task == task:
-                    self.release()
-
-                raise
-
-            assert self._owner_task == task
-        else:
-            try:
-                await cancel_shielded_checkpoint()
-            except BaseException:
-                self.release()
-                raise
+        raise NotImplementedError
 
     def acquire_nowait(self) -> None:
         """
@@ -188,37 +165,87 @@ class Lock:
         :raises ~anyio.WouldBlock: if the operation would block
 
         """
-        task = get_current_task()
-        if self._owner_task == task:
-            raise RuntimeError("Attempted to acquire an already held Lock")
+        raise NotImplementedError
+
+    def release(self) -> None:
+        """Release the lock."""
+        raise NotImplementedError
+
+    def locked(self) -> bool:
+        """Return True if the lock is currently held."""
+        raise NotImplementedError
+
+    def statistics(self) -> LockStatistics:
+        """
+        Return statistics about the current state of this lock.
+
+        .. versionadded:: 3.0
+        """
+        raise NotImplementedError
+
+
+class LockAdapter(Lock):
+    _internal_lock: Lock | None = None
+
+    def __new__(cls, *, fast_acquire: bool = False) -> LockAdapter:
+        return object.__new__(cls)
+
+    def __init__(self, *, fast_acquire: bool = False):
+        self._fast_acquire = fast_acquire
+
+    @property
+    def _lock(self) -> Lock:
+        if self._internal_lock is None:
+            self._internal_lock = get_async_backend().create_lock(
+                fast_acquire=self._fast_acquire
+            )
+
+        return self._internal_lock
+
+    async def __aenter__(self) -> None:
+        await self._lock.acquire()
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        if self._internal_lock is not None:
+            self._internal_lock.release()
+
+    async def acquire(self) -> None:
+        """Acquire the lock."""
+        await self._lock.acquire()
+
+    def acquire_nowait(self) -> None:
+        """
+        Acquire the lock, without blocking.
 
-        if self._owner_task is not None:
-            raise WouldBlock
+        :raises ~anyio.WouldBlock: if the operation would block
 
-        self._owner_task = task
+        """
+        self._lock.acquire_nowait()
 
     def release(self) -> None:
         """Release the lock."""
-        if self._owner_task != get_current_task():
-            raise RuntimeError("The current task is not holding this lock")
-
-        if self._waiters:
-            self._owner_task, event = self._waiters.popleft()
-            event.set()
-        else:
-            del self._owner_task
+        self._lock.release()
 
     def locked(self) -> bool:
         """Return True if the lock is currently held."""
-        return self._owner_task is not None
+        return self._lock.locked()
 
     def statistics(self) -> LockStatistics:
         """
         Return statistics about the current state of this lock.
 
         .. versionadded:: 3.0
+
         """
-        return LockStatistics(self.locked(), self._owner_task, len(self._waiters))
+        if self._internal_lock is None:
+            return LockStatistics(False, None, 0)
+
+        return self._internal_lock.statistics()
 
 
 class Condition:
@@ -312,7 +339,27 @@ class Condition:
 
 
 class Semaphore:
-    def __init__(self, initial_value: int, *, max_value: int | None = None):
+    def __new__(
+        cls,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ) -> Semaphore:
+        try:
+            return get_async_backend().create_semaphore(
+                initial_value, max_value=max_value, fast_acquire=fast_acquire
+            )
+        except AsyncLibraryNotFoundError:
+            return SemaphoreAdapter(initial_value, max_value=max_value)
+
+    def __init__(
+        self,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ):
         if not isinstance(initial_value, int):
             raise TypeError("initial_value must be an integer")
         if initial_value < 0:
@@ -325,9 +372,7 @@ class Semaphore:
                     "max_value must be equal to or higher than initial_value"
                 )
 
-        self._value = initial_value
-        self._max_value = max_value
-        self._waiters: deque[Event] = deque()
+        self._fast_acquire = fast_acquire
 
     async def __aenter__(self) -> Semaphore:
         await self.acquire()
@@ -343,27 +388,7 @@ class Semaphore:
 
     async def acquire(self) -> None:
         """Decrement the semaphore value, blocking if necessary."""
-        await checkpoint_if_cancelled()
-        try:
-            self.acquire_nowait()
-        except WouldBlock:
-            event = Event()
-            self._waiters.append(event)
-            try:
-                await event.wait()
-            except BaseException:
-                if not event.is_set():
-                    self._waiters.remove(event)
-                else:
-                    self.release()
-
-                raise
-        else:
-            try:
-                await cancel_shielded_checkpoint()
-            except BaseException:
-                self.release()
-                raise
+        raise NotImplementedError
 
     def acquire_nowait(self) -> None:
         """
@@ -372,30 +397,21 @@ class Semaphore:
         :raises ~anyio.WouldBlock: if the operation would block
 
         """
-        if self._value == 0:
-            raise WouldBlock
-
-        self._value -= 1
+        raise NotImplementedError
 
     def release(self) -> None:
         """Increment the semaphore value."""
-        if self._max_value is not None and self._value == self._max_value:
-            raise ValueError("semaphore released too many times")
-
-        if self._waiters:
-            self._waiters.popleft().set()
-        else:
-            self._value += 1
+        raise NotImplementedError
 
     @property
     def value(self) -> int:
         """The current value of the semaphore."""
-        return self._value
+        raise NotImplementedError
 
     @property
     def max_value(self) -> int | None:
         """The maximum value of the semaphore."""
-        return self._max_value
+        raise NotImplementedError
 
     def statistics(self) -> SemaphoreStatistics:
         """
@@ -403,7 +419,66 @@ class Semaphore:
 
         .. versionadded:: 3.0
         """
-        return SemaphoreStatistics(len(self._waiters))
+        raise NotImplementedError
+
+
+class SemaphoreAdapter(Semaphore):
+    _internal_semaphore: Semaphore | None = None
+
+    def __new__(
+        cls,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ) -> SemaphoreAdapter:
+        return object.__new__(cls)
+
+    def __init__(
+        self,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ) -> None:
+        super().__init__(initial_value, max_value=max_value, fast_acquire=fast_acquire)
+        self._initial_value = initial_value
+        self._max_value = max_value
+
+    @property
+    def _semaphore(self) -> Semaphore:
+        if self._internal_semaphore is None:
+            self._internal_semaphore = get_async_backend().create_semaphore(
+                self._initial_value, max_value=self._max_value
+            )
+
+        return self._internal_semaphore
+
+    async def acquire(self) -> None:
+        await self._semaphore.acquire()
+
+    def acquire_nowait(self) -> None:
+        self._semaphore.acquire_nowait()
+
+    def release(self) -> None:
+        self._semaphore.release()
+
+    @property
+    def value(self) -> int:
+        if self._internal_semaphore is None:
+            return self._initial_value
+
+        return self._semaphore.value
+
+    @property
+    def max_value(self) -> int | None:
+        return self._max_value
+
+    def statistics(self) -> SemaphoreStatistics:
+        if self._internal_semaphore is None:
+            return SemaphoreStatistics(tasks_waiting=0)
+
+        return self._semaphore.statistics()
 
 
 class CapacityLimiter:
diff --git a/contrib/python/anyio/anyio/abc/_eventloop.py b/contrib/python/anyio/anyio/abc/_eventloop.py
index a50afefaa0..2c73bb9ffb 100644
--- a/contrib/python/anyio/anyio/abc/_eventloop.py
+++ b/contrib/python/anyio/anyio/abc/_eventloop.py
@@ -3,7 +3,7 @@ from __future__ import annotations
 import math
 import sys
 from abc import ABCMeta, abstractmethod
-from collections.abc import AsyncIterator, Awaitable, Mapping
+from collections.abc import AsyncIterator, Awaitable
 from os import PathLike
 from signal import Signals
 from socket import AddressFamily, SocketKind, socket
@@ -15,6 +15,7 @@ from typing import (
     ContextManager,
     Sequence,
     TypeVar,
+    Union,
     overload,
 )
 
@@ -23,10 +24,13 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import TypeVarTuple, Unpack
 
-if TYPE_CHECKING:
-    from typing import Literal
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
 
-    from .._core._synchronization import CapacityLimiter, Event
+if TYPE_CHECKING:
+    from .._core._synchronization import CapacityLimiter, Event, Lock, Semaphore
     from .._core._tasks import CancelScope
     from .._core._testing import TaskInfo
     from ..from_thread import BlockingPortal
@@ -46,6 +50,7 @@ if TYPE_CHECKING:
 
 T_Retval = TypeVar("T_Retval")
 PosArgsT = TypeVarTuple("PosArgsT")
+StrOrBytesPath: TypeAlias = Union[str, bytes, "PathLike[str]", "PathLike[bytes]"]
 
 
 class AsyncBackend(metaclass=ABCMeta):
@@ -169,6 +174,22 @@ class AsyncBackend(metaclass=ABCMeta):
 
     @classmethod
     @abstractmethod
+    def create_lock(cls, *, fast_acquire: bool) -> Lock:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def create_semaphore(
+        cls,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ) -> Semaphore:
+        pass
+
+    @classmethod
+    @abstractmethod
     def create_capacity_limiter(cls, total_tokens: float) -> CapacityLimiter:
         pass
 
@@ -214,50 +235,15 @@ class AsyncBackend(metaclass=ABCMeta):
         pass
 
     @classmethod
-    @overload
-    async def open_process(
-        cls,
-        command: str | bytes,
-        *,
-        shell: Literal[True],
-        stdin: int | IO[Any] | None,
-        stdout: int | IO[Any] | None,
-        stderr: int | IO[Any] | None,
-        cwd: str | bytes | PathLike[str] | None = None,
-        env: Mapping[str, str] | None = None,
-        start_new_session: bool = False,
-    ) -> Process:
-        pass
-
-    @classmethod
-    @overload
-    async def open_process(
-        cls,
-        command: Sequence[str | bytes],
-        *,
-        shell: Literal[False],
-        stdin: int | IO[Any] | None,
-        stdout: int | IO[Any] | None,
-        stderr: int | IO[Any] | None,
-        cwd: str | bytes | PathLike[str] | None = None,
-        env: Mapping[str, str] | None = None,
-        start_new_session: bool = False,
-    ) -> Process:
-        pass
-
-    @classmethod
     @abstractmethod
     async def open_process(
         cls,
-        command: str | bytes | Sequence[str | bytes],
+        command: StrOrBytesPath | Sequence[StrOrBytesPath],
         *,
-        shell: bool,
         stdin: int | IO[Any] | None,
         stdout: int | IO[Any] | None,
         stderr: int | IO[Any] | None,
-        cwd: str | bytes | PathLike[str] | None = None,
-        env: Mapping[str, str] | None = None,
-        start_new_session: bool = False,
+        **kwargs: Any,
     ) -> Process:
         pass
 
diff --git a/contrib/python/anyio/anyio/from_thread.py b/contrib/python/anyio/anyio/from_thread.py
index 88a854bb91..b8785845ba 100644
--- a/contrib/python/anyio/anyio/from_thread.py
+++ b/contrib/python/anyio/anyio/from_thread.py
@@ -1,19 +1,18 @@
 from __future__ import annotations
 
 import sys
-import threading
 from collections.abc import Awaitable, Callable, Generator
-from concurrent.futures import FIRST_COMPLETED, Future, ThreadPoolExecutor, wait
+from concurrent.futures import Future
 from contextlib import AbstractContextManager, contextmanager
 from dataclasses import dataclass, field
 from inspect import isawaitable
+from threading import Lock, Thread, get_ident
 from types import TracebackType
 from typing import (
     Any,
     AsyncContextManager,
     ContextManager,
     Generic,
-    Iterable,
     TypeVar,
     cast,
     overload,
@@ -146,7 +145,7 @@ class BlockingPortal:
         return get_async_backend().create_blocking_portal()
 
     def __init__(self) -> None:
-        self._event_loop_thread_id: int | None = threading.get_ident()
+        self._event_loop_thread_id: int | None = get_ident()
         self._stop_event = Event()
         self._task_group = create_task_group()
         self._cancelled_exc_class = get_cancelled_exc_class()
@@ -167,7 +166,7 @@ class BlockingPortal:
     def _check_running(self) -> None:
         if self._event_loop_thread_id is None:
             raise RuntimeError("This portal is not running")
-        if self._event_loop_thread_id == threading.get_ident():
+        if self._event_loop_thread_id == get_ident():
             raise RuntimeError(
                 "This method cannot be called from the event loop thread"
             )
@@ -202,7 +201,7 @@ class BlockingPortal:
         def callback(f: Future[T_Retval]) -> None:
             if f.cancelled() and self._event_loop_thread_id not in (
                 None,
-                threading.get_ident(),
+                get_ident(),
             ):
                 self.call(scope.cancel)
 
@@ -411,7 +410,7 @@ class BlockingPortalProvider:
 
     backend: str = "asyncio"
     backend_options: dict[str, Any] | None = None
-    _lock: threading.Lock = field(init=False, default_factory=threading.Lock)
+    _lock: Lock = field(init=False, default_factory=Lock)
     _leases: int = field(init=False, default=0)
     _portal: BlockingPortal = field(init=False)
     _portal_cm: AbstractContextManager[BlockingPortal] | None = field(
@@ -469,43 +468,37 @@ def start_blocking_portal(
 
     async def run_portal() -> None:
         async with BlockingPortal() as portal_:
-            if future.set_running_or_notify_cancel():
-                future.set_result(portal_)
-                await portal_.sleep_until_stopped()
+            future.set_result(portal_)
+            await portal_.sleep_until_stopped()
+
+    def run_blocking_portal() -> None:
+        if future.set_running_or_notify_cancel():
+            try:
+                _eventloop.run(
+                    run_portal, backend=backend, backend_options=backend_options
+                )
+            except BaseException as exc:
+                if not future.done():
+                    future.set_exception(exc)
 
     future: Future[BlockingPortal] = Future()
-    with ThreadPoolExecutor(1) as executor:
-        run_future = executor.submit(
-            _eventloop.run,  # type: ignore[arg-type]
-            run_portal,
-            backend=backend,
-            backend_options=backend_options,
-        )
+    thread = Thread(target=run_blocking_portal, daemon=True)
+    thread.start()
+    try:
+        cancel_remaining_tasks = False
+        portal = future.result()
         try:
-            wait(
-                cast(Iterable[Future], [run_future, future]),
-                return_when=FIRST_COMPLETED,
-            )
+            yield portal
         except BaseException:
-            future.cancel()
-            run_future.cancel()
+            cancel_remaining_tasks = True
             raise
-
-        if future.done():
-            portal = future.result()
-            cancel_remaining_tasks = False
+        finally:
             try:
-                yield portal
-            except BaseException:
-                cancel_remaining_tasks = True
-                raise
-            finally:
-                try:
-                    portal.call(portal.stop, cancel_remaining_tasks)
-                except RuntimeError:
-                    pass
-
-        run_future.result()
+                portal.call(portal.stop, cancel_remaining_tasks)
+            except RuntimeError:
+                pass
+    finally:
+        thread.join()
 
 
 def check_cancelled() -> None:
diff --git a/contrib/python/anyio/anyio/pytest_plugin.py b/contrib/python/anyio/anyio/pytest_plugin.py
index a8dd6f3e3f..558c72ec28 100644
--- a/contrib/python/anyio/anyio/pytest_plugin.py
+++ b/contrib/python/anyio/anyio/pytest_plugin.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import sys
 from collections.abc import Iterator
 from contextlib import ExitStack, contextmanager
 from inspect import isasyncgenfunction, iscoroutinefunction
@@ -7,10 +8,15 @@ from typing import Any, Dict, Tuple, cast
 
 import pytest
 import sniffio
+from _pytest.outcomes import Exit
 
 from ._core._eventloop import get_all_backends, get_async_backend
+from ._core._exceptions import iterate_exceptions
 from .abc import TestRunner
 
+if sys.version_info < (3, 11):
+    from exceptiongroup import ExceptionGroup
+
 _current_runner: TestRunner | None = None
 _runner_stack: ExitStack | None = None
 _runner_leases = 0
@@ -121,7 +127,14 @@ def pytest_pyfunc_call(pyfuncitem: Any) -> bool | None:
             funcargs = pyfuncitem.funcargs
             testargs = {arg: funcargs[arg] for arg in pyfuncitem._fixtureinfo.argnames}
             with get_runner(backend_name, backend_options) as runner:
-                runner.run_test(pyfuncitem.obj, testargs)
+                try:
+                    runner.run_test(pyfuncitem.obj, testargs)
+                except ExceptionGroup as excgrp:
+                    for exc in iterate_exceptions(excgrp):
+                        if isinstance(exc, (Exit, KeyboardInterrupt, SystemExit)):
+                            raise exc from excgrp
+
+                    raise
 
             return True
 
diff --git a/contrib/python/anyio/anyio/streams/memory.py b/contrib/python/anyio/anyio/streams/memory.py
index 6840e6242f..b547aa6a48 100644
--- a/contrib/python/anyio/anyio/streams/memory.py
+++ b/contrib/python/anyio/anyio/streams/memory.py
@@ -38,6 +38,12 @@ class MemoryObjectItemReceiver(Generic[T_Item]):
     task_info: TaskInfo = field(init=False, default_factory=get_current_task)
     item: T_Item = field(init=False)
 
+    def __repr__(self) -> str:
+        # When item is not defined, we get following error with default __repr__:
+        # AttributeError: 'MemoryObjectItemReceiver' object has no attribute 'item'
+        item = getattr(self, "item", None)
+        return f"{self.__class__.__name__}(task_info={self.task_info}, item={item!r})"
+
 
 @dataclass(eq=False)
 class MemoryObjectStreamState(Generic[T_Item]):
@@ -175,7 +181,7 @@ class MemoryObjectReceiveStream(Generic[T_co], ObjectReceiveStream[T_co]):
     def __del__(self) -> None:
         if not self._closed:
             warnings.warn(
-                f"Unclosed <{self.__class__.__name__}>",
+                f"Unclosed <{self.__class__.__name__} at {id(self):x}>",
                 ResourceWarning,
                 source=self,
             )
@@ -305,7 +311,7 @@ class MemoryObjectSendStream(Generic[T_contra], ObjectSendStream[T_contra]):
     def __del__(self) -> None:
         if not self._closed:
             warnings.warn(
-                f"Unclosed <{self.__class__.__name__}>",
+                f"Unclosed <{self.__class__.__name__} at {id(self):x}>",
                 ResourceWarning,
                 source=self,
             )
diff --git a/contrib/python/anyio/anyio/to_process.py b/contrib/python/anyio/anyio/to_process.py
index 1ff06f0b25..5050dee21e 100644
--- a/contrib/python/anyio/anyio/to_process.py
+++ b/contrib/python/anyio/anyio/to_process.py
@@ -223,7 +223,7 @@ def process_worker() -> None:
                 main_module_path: str | None
                 sys.path, main_module_path = args
                 del sys.modules["__main__"]
-                if main_module_path:
+                if main_module_path and os.path.isfile(main_module_path):
                     # Load the parent's main module but as __mp_main__ instead of
                     # __main__ (like multiprocessing does) to avoid infinite recursion
                     try:
@@ -234,7 +234,6 @@ def process_worker() -> None:
                             sys.modules["__main__"] = main
                     except BaseException as exc:
                         exception = exc
-
         try:
             if exception is not None:
                 status = b"EXCEPTION"
diff --git a/contrib/python/anyio/ya.make b/contrib/python/anyio/ya.make
index 9062121337..c166d2627f 100644
--- a/contrib/python/anyio/ya.make
+++ b/contrib/python/anyio/ya.make
@@ -2,7 +2,7 @@
 
 PY3_LIBRARY()
 
-VERSION(4.4.0)
+VERSION(4.5.0)
 
 LICENSE(MIT)
 
diff --git a/contrib/python/idna/py3/.dist-info/METADATA b/contrib/python/idna/py3/.dist-info/METADATA
index f7a5e62e40..c42623e942 100644
--- a/contrib/python/idna/py3/.dist-info/METADATA
+++ b/contrib/python/idna/py3/.dist-info/METADATA
@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: idna
-Version: 3.9
+Version: 3.10
 Summary: Internationalized Domain Names in Applications (IDNA)
 Author-email: Kim Davies <kim+pypi@gumleaf.org>
 Requires-Python: >=3.6
diff --git a/contrib/python/idna/py3/idna/core.py b/contrib/python/idna/py3/idna/core.py
index d303b3835b..9115f123f0 100644
--- a/contrib/python/idna/py3/idna/core.py
+++ b/contrib/python/idna/py3/idna/core.py
@@ -9,45 +9,6 @@ from .intranges import intranges_contain
 _virama_combining_class = 9
 _alabel_prefix = b"xn--"
 _unicode_dots_re = re.compile("[\u002e\u3002\uff0e\uff61]")
-_ldh = (
-    48,
-    49,
-    50,
-    51,
-    52,
-    53,
-    54,
-    55,
-    56,
-    57,
-    95,
-    97,
-    98,
-    99,
-    100,
-    101,
-    102,
-    103,
-    104,
-    105,
-    106,
-    107,
-    108,
-    109,
-    110,
-    111,
-    112,
-    113,
-    114,
-    115,
-    116,
-    117,
-    118,
-    119,
-    120,
-    121,
-    122,
-)
 
 
 class IDNAError(UnicodeError):
@@ -380,16 +341,17 @@ def uts46_remap(domain: str, std3_rules: bool = True, transitional: bool = False
             uts46row = uts46data[code_point if code_point < 256 else bisect.bisect_left(uts46data, (code_point, "Z")) - 1]
             status = uts46row[1]
             replacement: Optional[str] = None
-            if std3_rules and code_point <= 0x7F:
-                if code_point not in _ldh:
-                    raise InvalidCodepoint(
-                        "Codepoint {} at position {} does not follow STD3 rules".format(_unot(code_point), pos + 1)
-                    )
             if len(uts46row) == 3:
                 replacement = uts46row[2]
-            if status == "V" or (status == "D" and not transitional):
+            if (
+                status == "V"
+                or (status == "D" and not transitional)
+                or (status == "3" and not std3_rules and replacement is None)
+            ):
                 output += char
-            elif replacement is not None and (status == "M" or (status == "D" and transitional)):
+            elif replacement is not None and (
+                status == "M" or (status == "3" and not std3_rules) or (status == "D" and transitional)
+            ):
                 output += replacement
             elif status != "I":
                 raise IndexError()
diff --git a/contrib/python/idna/py3/idna/idnadata.py b/contrib/python/idna/py3/idna/idnadata.py
index ded47cae0b..4be6004622 100644
--- a/contrib/python/idna/py3/idna/idnadata.py
+++ b/contrib/python/idna/py3/idna/idnadata.py
@@ -1,7 +1,6 @@
 # This file is automatically generated by tools/idna-data
 
-__version__ = "16.0.0"
-
+__version__ = "15.1.0"
 scripts = {
     "Greek": (
         0x37000000374,
@@ -728,7 +727,6 @@ joining_types = {
     0x88C: 68,
     0x88D: 68,
     0x88E: 82,
-    0x897: 84,
     0x898: 84,
     0x899: 84,
     0x89A: 84,
@@ -1875,17 +1873,8 @@ joining_types = {
     0x10D25: 84,
     0x10D26: 84,
     0x10D27: 84,
-    0x10D69: 84,
-    0x10D6A: 84,
-    0x10D6B: 84,
-    0x10D6C: 84,
-    0x10D6D: 84,
     0x10EAB: 84,
     0x10EAC: 84,
-    0x10EC2: 82,
-    0x10EC3: 68,
-    0x10EC4: 68,
-    0x10EFC: 84,
     0x10EFD: 84,
     0x10EFE: 84,
     0x10EFF: 84,
@@ -2064,17 +2053,6 @@ joining_types = {
     0x11372: 84,
     0x11373: 84,
     0x11374: 84,
-    0x113BB: 84,
-    0x113BC: 84,
-    0x113BD: 84,
-    0x113BE: 84,
-    0x113BF: 84,
-    0x113C0: 84,
-    0x113CE: 84,
-    0x113D0: 84,
-    0x113D2: 84,
-    0x113E1: 84,
-    0x113E2: 84,
     0x11438: 84,
     0x11439: 84,
     0x1143A: 84,
@@ -2130,6 +2108,7 @@ joining_types = {
     0x116B5: 84,
     0x116B7: 84,
     0x1171D: 84,
+    0x1171E: 84,
     0x1171F: 84,
     0x11722: 84,
     0x11723: 84,
@@ -2286,7 +2265,6 @@ joining_types = {
     0x11F3A: 84,
     0x11F40: 84,
     0x11F42: 84,
-    0x11F5A: 84,
     0x13430: 84,
     0x13431: 84,
     0x13432: 84,
@@ -2319,21 +2297,6 @@ joining_types = {
     0x13453: 84,
     0x13454: 84,
     0x13455: 84,
-    0x1611E: 84,
-    0x1611F: 84,
-    0x16120: 84,
-    0x16121: 84,
-    0x16122: 84,
-    0x16123: 84,
-    0x16124: 84,
-    0x16125: 84,
-    0x16126: 84,
-    0x16127: 84,
-    0x16128: 84,
-    0x16129: 84,
-    0x1612D: 84,
-    0x1612E: 84,
-    0x1612F: 84,
     0x16AF0: 84,
     0x16AF1: 84,
     0x16AF2: 84,
@@ -2642,8 +2605,6 @@ joining_types = {
     0x1E4ED: 84,
     0x1E4EE: 84,
     0x1E4EF: 84,
-    0x1E5EE: 84,
-    0x1E5EF: 84,
     0x1E8D0: 84,
     0x1E8D1: 84,
     0x1E8D2: 84,
@@ -3367,7 +3328,7 @@ codepoint_classes = {
         0x8600000086B,
         0x87000000888,
         0x8890000088F,
-        0x897000008E2,
+        0x898000008E2,
         0x8E300000958,
         0x96000000964,
         0x96600000970,
@@ -3602,7 +3563,6 @@ codepoint_classes = {
         0x1C0000001C38,
         0x1C4000001C4A,
         0x1C4D00001C7E,
-        0x1C8A00001C8B,
         0x1CD000001CD3,
         0x1CD400001CFB,
         0x1D0000001D2C,
@@ -3966,13 +3926,11 @@ codepoint_classes = {
         0xA7C30000A7C4,
         0xA7C80000A7C9,
         0xA7CA0000A7CB,
-        0xA7CD0000A7CE,
         0xA7D10000A7D2,
         0xA7D30000A7D4,
         0xA7D50000A7D6,
         0xA7D70000A7D8,
         0xA7D90000A7DA,
-        0xA7DB0000A7DC,
         0xA7F60000A7F8,
         0xA7FA0000A828,
         0xA82C0000A82D,
@@ -4042,7 +4000,6 @@ codepoint_classes = {
         0x105A3000105B2,
         0x105B3000105BA,
         0x105BB000105BD,
-        0x105C0000105F4,
         0x1060000010737,
         0x1074000010756,
         0x1076000010768,
@@ -4080,14 +4037,10 @@ codepoint_classes = {
         0x10CC000010CF3,
         0x10D0000010D28,
         0x10D3000010D3A,
-        0x10D4000010D50,
-        0x10D6900010D6E,
-        0x10D6F00010D86,
         0x10E8000010EAA,
         0x10EAB00010EAD,
         0x10EB000010EB2,
-        0x10EC200010EC5,
-        0x10EFC00010F1D,
+        0x10EFD00010F1D,
         0x10F2700010F28,
         0x10F3000010F51,
         0x10F7000010F86,
@@ -4133,16 +4086,6 @@ codepoint_classes = {
         0x1135D00011364,
         0x113660001136D,
         0x1137000011375,
-        0x113800001138A,
-        0x1138B0001138C,
-        0x1138E0001138F,
-        0x11390000113B6,
-        0x113B7000113C1,
-        0x113C2000113C3,
-        0x113C5000113C6,
-        0x113C7000113CB,
-        0x113CC000113D4,
-        0x113E1000113E3,
         0x114000001144B,
         0x114500001145A,
         0x1145E00011462,
@@ -4157,7 +4100,6 @@ codepoint_classes = {
         0x116500001165A,
         0x11680000116B9,
         0x116C0000116CA,
-        0x116D0000116E4,
         0x117000001171B,
         0x1171D0001172C,
         0x117300001173A,
@@ -4181,8 +4123,6 @@ codepoint_classes = {
         0x11A5000011A9A,
         0x11A9D00011A9E,
         0x11AB000011AF9,
-        0x11BC000011BE1,
-        0x11BF000011BFA,
         0x11C0000011C09,
         0x11C0A00011C37,
         0x11C3800011C41,
@@ -4207,16 +4147,14 @@ codepoint_classes = {
         0x11F0000011F11,
         0x11F1200011F3B,
         0x11F3E00011F43,
-        0x11F5000011F5B,
+        0x11F5000011F5A,
         0x11FB000011FB1,
         0x120000001239A,
         0x1248000012544,
         0x12F9000012FF1,
         0x1300000013430,
         0x1344000013456,
-        0x13460000143FB,
         0x1440000014647,
-        0x161000001613A,
         0x1680000016A39,
         0x16A4000016A5F,
         0x16A6000016A6A,
@@ -4229,8 +4167,6 @@ codepoint_classes = {
         0x16B5000016B5A,
         0x16B6300016B78,
         0x16B7D00016B90,
-        0x16D4000016D6D,
-        0x16D7000016D7A,
         0x16E6000016E80,
         0x16F0000016F4B,
         0x16F4F00016F88,
@@ -4240,7 +4176,7 @@ codepoint_classes = {
         0x16FF000016FF2,
         0x17000000187F8,
         0x1880000018CD6,
-        0x18CFF00018D09,
+        0x18D0000018D09,
         0x1AFF00001AFF4,
         0x1AFF50001AFFC,
         0x1AFFD0001AFFF,
@@ -4255,7 +4191,6 @@ codepoint_classes = {
         0x1BC800001BC89,
         0x1BC900001BC9A,
         0x1BC9D0001BC9F,
-        0x1CCF00001CCFA,
         0x1CF000001CF2E,
         0x1CF300001CF47,
         0x1DA000001DA37,
@@ -4279,7 +4214,6 @@ codepoint_classes = {
         0x1E2900001E2AF,
         0x1E2C00001E2FA,
         0x1E4D00001E4FA,
-        0x1E5D00001E5FB,
         0x1E7E00001E7E7,
         0x1E7E80001E7EC,
         0x1E7ED0001E7EF,
diff --git a/contrib/python/idna/py3/idna/package_data.py b/contrib/python/idna/py3/idna/package_data.py
index ddd1e6912e..514ff7e2e6 100644
--- a/contrib/python/idna/py3/idna/package_data.py
+++ b/contrib/python/idna/py3/idna/package_data.py
@@ -1 +1 @@
-__version__ = "3.9"
+__version__ = "3.10"
diff --git a/contrib/python/idna/py3/idna/uts46data.py b/contrib/python/idna/py3/idna/uts46data.py
index 4610b71dad..eb89432741 100644
--- a/contrib/python/idna/py3/idna/uts46data.py
+++ b/contrib/python/idna/py3/idna/uts46data.py
@@ -6,59 +6,59 @@ from typing import List, Tuple, Union
 """IDNA Mapping Table from UTS46."""
 
 
-__version__ = "16.0.0"
+__version__ = "15.1.0"
 
 
 def _seg_0() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
     return [
-        (0x0, "V"),
-        (0x1, "V"),
-        (0x2, "V"),
-        (0x3, "V"),
-        (0x4, "V"),
-        (0x5, "V"),
-        (0x6, "V"),
-        (0x7, "V"),
-        (0x8, "V"),
-        (0x9, "V"),
-        (0xA, "V"),
-        (0xB, "V"),
-        (0xC, "V"),
-        (0xD, "V"),
-        (0xE, "V"),
-        (0xF, "V"),
-        (0x10, "V"),
-        (0x11, "V"),
-        (0x12, "V"),
-        (0x13, "V"),
-        (0x14, "V"),
-        (0x15, "V"),
-        (0x16, "V"),
-        (0x17, "V"),
-        (0x18, "V"),
-        (0x19, "V"),
-        (0x1A, "V"),
-        (0x1B, "V"),
-        (0x1C, "V"),
-        (0x1D, "V"),
-        (0x1E, "V"),
-        (0x1F, "V"),
-        (0x20, "V"),
-        (0x21, "V"),
-        (0x22, "V"),
-        (0x23, "V"),
-        (0x24, "V"),
-        (0x25, "V"),
-        (0x26, "V"),
-        (0x27, "V"),
-        (0x28, "V"),
-        (0x29, "V"),
-        (0x2A, "V"),
-        (0x2B, "V"),
-        (0x2C, "V"),
+        (0x0, "3"),
+        (0x1, "3"),
+        (0x2, "3"),
+        (0x3, "3"),
+        (0x4, "3"),
+        (0x5, "3"),
+        (0x6, "3"),
+        (0x7, "3"),
+        (0x8, "3"),
+        (0x9, "3"),
+        (0xA, "3"),
+        (0xB, "3"),
+        (0xC, "3"),
+        (0xD, "3"),
+        (0xE, "3"),
+        (0xF, "3"),
+        (0x10, "3"),
+        (0x11, "3"),
+        (0x12, "3"),
+        (0x13, "3"),
+        (0x14, "3"),
+        (0x15, "3"),
+        (0x16, "3"),
+        (0x17, "3"),
+        (0x18, "3"),
+        (0x19, "3"),
+        (0x1A, "3"),
+        (0x1B, "3"),
+        (0x1C, "3"),
+        (0x1D, "3"),
+        (0x1E, "3"),
+        (0x1F, "3"),
+        (0x20, "3"),
+        (0x21, "3"),
+        (0x22, "3"),
+        (0x23, "3"),
+        (0x24, "3"),
+        (0x25, "3"),
+        (0x26, "3"),
+        (0x27, "3"),
+        (0x28, "3"),
+        (0x29, "3"),
+        (0x2A, "3"),
+        (0x2B, "3"),
+        (0x2C, "3"),
         (0x2D, "V"),
         (0x2E, "V"),
-        (0x2F, "V"),
+        (0x2F, "3"),
         (0x30, "V"),
         (0x31, "V"),
         (0x32, "V"),
@@ -69,13 +69,13 @@ def _seg_0() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x37, "V"),
         (0x38, "V"),
         (0x39, "V"),
-        (0x3A, "V"),
-        (0x3B, "V"),
-        (0x3C, "V"),
-        (0x3D, "V"),
-        (0x3E, "V"),
-        (0x3F, "V"),
-        (0x40, "V"),
+        (0x3A, "3"),
+        (0x3B, "3"),
+        (0x3C, "3"),
+        (0x3D, "3"),
+        (0x3E, "3"),
+        (0x3F, "3"),
+        (0x40, "3"),
         (0x41, "M", "a"),
         (0x42, "M", "b"),
         (0x43, "M", "c"),
@@ -102,12 +102,12 @@ def _seg_0() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x58, "M", "x"),
         (0x59, "M", "y"),
         (0x5A, "M", "z"),
-        (0x5B, "V"),
-        (0x5C, "V"),
-        (0x5D, "V"),
-        (0x5E, "V"),
-        (0x5F, "V"),
-        (0x60, "V"),
+        (0x5B, "3"),
+        (0x5C, "3"),
+        (0x5D, "3"),
+        (0x5E, "3"),
+        (0x5F, "3"),
+        (0x60, "3"),
         (0x61, "V"),
         (0x62, "V"),
         (0x63, "V"),
@@ -139,11 +139,11 @@ def _seg_1() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x78, "V"),
         (0x79, "V"),
         (0x7A, "V"),
-        (0x7B, "V"),
-        (0x7C, "V"),
-        (0x7D, "V"),
-        (0x7E, "V"),
-        (0x7F, "V"),
+        (0x7B, "3"),
+        (0x7C, "3"),
+        (0x7D, "3"),
+        (0x7E, "3"),
+        (0x7F, "3"),
         (0x80, "X"),
         (0x81, "X"),
         (0x82, "X"),
@@ -176,7 +176,7 @@ def _seg_1() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x9D, "X"),
         (0x9E, "X"),
         (0x9F, "X"),
-        (0xA0, "M", " "),
+        (0xA0, "3", " "),
         (0xA1, "V"),
         (0xA2, "V"),
         (0xA3, "V"),
@@ -184,23 +184,23 @@ def _seg_1() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xA5, "V"),
         (0xA6, "V"),
         (0xA7, "V"),
-        (0xA8, "M", " ̈"),
+        (0xA8, "3", " ̈"),
         (0xA9, "V"),
         (0xAA, "M", "a"),
         (0xAB, "V"),
         (0xAC, "V"),
         (0xAD, "I"),
         (0xAE, "V"),
-        (0xAF, "M", " ̄"),
+        (0xAF, "3", " ̄"),
         (0xB0, "V"),
         (0xB1, "V"),
         (0xB2, "M", "2"),
         (0xB3, "M", "3"),
-        (0xB4, "M", " ́"),
+        (0xB4, "3", " ́"),
         (0xB5, "M", "μ"),
         (0xB6, "V"),
         (0xB7, "V"),
-        (0xB8, "M", " ̧"),
+        (0xB8, "3", " ̧"),
         (0xB9, "M", "1"),
         (0xBA, "M", "o"),
         (0xBB, "V"),
@@ -606,12 +606,12 @@ def _seg_5() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2B7, "M", "w"),
         (0x2B8, "M", "y"),
         (0x2B9, "V"),
-        (0x2D8, "M", " ̆"),
-        (0x2D9, "M", " ̇"),
-        (0x2DA, "M", " ̊"),
-        (0x2DB, "M", " ̨"),
-        (0x2DC, "M", " ̃"),
-        (0x2DD, "M", " ̋"),
+        (0x2D8, "3", " ̆"),
+        (0x2D9, "3", " ̇"),
+        (0x2DA, "3", " ̊"),
+        (0x2DB, "3", " ̨"),
+        (0x2DC, "3", " ̃"),
+        (0x2DD, "3", " ̋"),
         (0x2DE, "V"),
         (0x2E0, "M", "ɣ"),
         (0x2E1, "M", "l"),
@@ -642,13 +642,13 @@ def _seg_5() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
 def _seg_6() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
     return [
         (0x378, "X"),
-        (0x37A, "M", " ι"),
+        (0x37A, "3", " ι"),
         (0x37B, "V"),
-        (0x37E, "M", ";"),
+        (0x37E, "3", ";"),
         (0x37F, "M", "ϳ"),
         (0x380, "X"),
-        (0x384, "M", " ́"),
-        (0x385, "M", " ̈́"),
+        (0x384, "3", " ́"),
+        (0x385, "3", " ̈́"),
         (0x386, "M", "ά"),
         (0x387, "M", "·"),
         (0x388, "M", "έ"),
@@ -885,7 +885,7 @@ def _seg_8() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x4BD, "V"),
         (0x4BE, "M", "ҿ"),
         (0x4BF, "V"),
-        (0x4C0, "M", "ӏ"),
+        (0x4C0, "X"),
         (0x4C1, "M", "ӂ"),
         (0x4C2, "V"),
         (0x4C3, "M", "ӄ"),
@@ -1087,7 +1087,7 @@ def _seg_10() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x86B, "X"),
         (0x870, "V"),
         (0x88F, "X"),
-        (0x897, "V"),
+        (0x898, "V"),
         (0x8E2, "X"),
         (0x8E3, "V"),
         (0x958, "M", "क़"),
@@ -1438,50 +1438,7 @@ def _seg_13() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFCE, "V"),
         (0xFDB, "X"),
         (0x1000, "V"),
-        (0x10A0, "M", "ⴀ"),
-        (0x10A1, "M", "ⴁ"),
-        (0x10A2, "M", "ⴂ"),
-        (0x10A3, "M", "ⴃ"),
-        (0x10A4, "M", "ⴄ"),
-        (0x10A5, "M", "ⴅ"),
-        (0x10A6, "M", "ⴆ"),
-        (0x10A7, "M", "ⴇ"),
-        (0x10A8, "M", "ⴈ"),
-        (0x10A9, "M", "ⴉ"),
-        (0x10AA, "M", "ⴊ"),
-        (0x10AB, "M", "ⴋ"),
-        (0x10AC, "M", "ⴌ"),
-        (0x10AD, "M", "ⴍ"),
-        (0x10AE, "M", "ⴎ"),
-        (0x10AF, "M", "ⴏ"),
-        (0x10B0, "M", "ⴐ"),
-        (0x10B1, "M", "ⴑ"),
-        (0x10B2, "M", "ⴒ"),
-        (0x10B3, "M", "ⴓ"),
-        (0x10B4, "M", "ⴔ"),
-        (0x10B5, "M", "ⴕ"),
-        (0x10B6, "M", "ⴖ"),
-        (0x10B7, "M", "ⴗ"),
-        (0x10B8, "M", "ⴘ"),
-        (0x10B9, "M", "ⴙ"),
-        (0x10BA, "M", "ⴚ"),
-        (0x10BB, "M", "ⴛ"),
-        (0x10BC, "M", "ⴜ"),
-        (0x10BD, "M", "ⴝ"),
-        (0x10BE, "M", "ⴞ"),
-        (0x10BF, "M", "ⴟ"),
-        (0x10C0, "M", "ⴠ"),
-        (0x10C1, "M", "ⴡ"),
-        (0x10C2, "M", "ⴢ"),
-        (0x10C3, "M", "ⴣ"),
-        (0x10C4, "M", "ⴤ"),
-        (0x10C5, "M", "ⴥ"),
-    ]
-
-
-def _seg_14() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
-        (0x10C6, "X"),
+        (0x10A0, "X"),
         (0x10C7, "M", "ⴧ"),
         (0x10C8, "X"),
         (0x10CD, "M", "ⴭ"),
@@ -1489,7 +1446,7 @@ def _seg_14() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x10D0, "V"),
         (0x10FC, "M", "ნ"),
         (0x10FD, "V"),
-        (0x115F, "I"),
+        (0x115F, "X"),
         (0x1161, "V"),
         (0x1249, "X"),
         (0x124A, "V"),
@@ -1519,6 +1476,11 @@ def _seg_14() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x12D8, "V"),
         (0x1311, "X"),
         (0x1312, "V"),
+    ]
+
+
+def _seg_14() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1316, "X"),
         (0x1318, "V"),
         (0x135B, "X"),
@@ -1554,7 +1516,7 @@ def _seg_14() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1772, "V"),
         (0x1774, "X"),
         (0x1780, "V"),
-        (0x17B4, "I"),
+        (0x17B4, "X"),
         (0x17B6, "V"),
         (0x17DE, "X"),
         (0x17E0, "V"),
@@ -1562,7 +1524,11 @@ def _seg_14() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x17F0, "V"),
         (0x17FA, "X"),
         (0x1800, "V"),
+        (0x1806, "X"),
+        (0x1807, "V"),
         (0x180B, "I"),
+        (0x180E, "X"),
+        (0x180F, "I"),
         (0x1810, "V"),
         (0x181A, "X"),
         (0x1820, "V"),
@@ -1581,11 +1547,6 @@ def _seg_14() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1941, "X"),
         (0x1944, "V"),
         (0x196E, "X"),
-    ]
-
-
-def _seg_15() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1970, "V"),
         (0x1975, "X"),
         (0x1980, "V"),
@@ -1610,7 +1571,9 @@ def _seg_15() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1ACF, "X"),
         (0x1B00, "V"),
         (0x1B4D, "X"),
-        (0x1B4E, "V"),
+        (0x1B50, "V"),
+        (0x1B7F, "X"),
+        (0x1B80, "V"),
         (0x1BF4, "X"),
         (0x1BFC, "V"),
         (0x1C38, "X"),
@@ -1618,6 +1581,11 @@ def _seg_15() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1C4A, "X"),
         (0x1C4D, "V"),
         (0x1C80, "M", "в"),
+    ]
+
+
+def _seg_15() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1C81, "M", "д"),
         (0x1C82, "M", "о"),
         (0x1C83, "M", "с"),
@@ -1625,9 +1593,7 @@ def _seg_15() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1C86, "M", "ъ"),
         (0x1C87, "M", "ѣ"),
         (0x1C88, "M", "ꙋ"),
-        (0x1C89, "M", "ᲊ"),
-        (0x1C8A, "V"),
-        (0x1C8B, "X"),
+        (0x1C89, "X"),
         (0x1C90, "M", "ა"),
         (0x1C91, "M", "ბ"),
         (0x1C92, "M", "გ"),
@@ -1686,11 +1652,6 @@ def _seg_15() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D2F, "V"),
         (0x1D30, "M", "d"),
         (0x1D31, "M", "e"),
-    ]
-
-
-def _seg_16() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1D32, "M", "ǝ"),
         (0x1D33, "M", "g"),
         (0x1D34, "M", "h"),
@@ -1725,6 +1686,11 @@ def _seg_16() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D51, "M", "ŋ"),
         (0x1D52, "M", "o"),
         (0x1D53, "M", "ɔ"),
+    ]
+
+
+def _seg_16() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1D54, "M", "ᴖ"),
         (0x1D55, "M", "ᴗ"),
         (0x1D56, "M", "p"),
@@ -1791,11 +1757,6 @@ def _seg_16() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1DC0, "V"),
         (0x1E00, "M", "ḁ"),
         (0x1E01, "V"),
-    ]
-
-
-def _seg_17() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1E02, "M", "ḃ"),
         (0x1E03, "V"),
         (0x1E04, "M", "ḅ"),
@@ -1830,6 +1791,11 @@ def _seg_17() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1E21, "V"),
         (0x1E22, "M", "ḣ"),
         (0x1E23, "V"),
+    ]
+
+
+def _seg_17() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1E24, "M", "ḥ"),
         (0x1E25, "V"),
         (0x1E26, "M", "ḧ"),
@@ -1896,11 +1862,6 @@ def _seg_17() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1E63, "V"),
         (0x1E64, "M", "ṥ"),
         (0x1E65, "V"),
-    ]
-
-
-def _seg_18() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1E66, "M", "ṧ"),
         (0x1E67, "V"),
         (0x1E68, "M", "ṩ"),
@@ -1935,6 +1896,11 @@ def _seg_18() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1E85, "V"),
         (0x1E86, "M", "ẇ"),
         (0x1E87, "V"),
+    ]
+
+
+def _seg_18() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1E88, "M", "ẉ"),
         (0x1E89, "V"),
         (0x1E8A, "M", "ẋ"),
@@ -2001,11 +1967,6 @@ def _seg_18() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1ECC, "M", "ọ"),
         (0x1ECD, "V"),
         (0x1ECE, "M", "ỏ"),
-    ]
-
-
-def _seg_19() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1ECF, "V"),
         (0x1ED0, "M", "ố"),
         (0x1ED1, "V"),
@@ -2040,6 +2001,11 @@ def _seg_19() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1EEE, "M", "ữ"),
         (0x1EEF, "V"),
         (0x1EF0, "M", "ự"),
+    ]
+
+
+def _seg_19() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1EF1, "V"),
         (0x1EF2, "M", "ỳ"),
         (0x1EF3, "V"),
@@ -2106,11 +2072,6 @@ def _seg_19() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1F5B, "M", "ὓ"),
         (0x1F5C, "X"),
         (0x1F5D, "M", "ὕ"),
-    ]
-
-
-def _seg_20() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1F5E, "X"),
         (0x1F5F, "M", "ὗ"),
         (0x1F60, "V"),
@@ -2145,6 +2106,11 @@ def _seg_20() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1F85, "M", "ἅι"),
         (0x1F86, "M", "ἆι"),
         (0x1F87, "M", "ἇι"),
+    ]
+
+
+def _seg_20() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1F88, "M", "ἀι"),
         (0x1F89, "M", "ἁι"),
         (0x1F8A, "M", "ἂι"),
@@ -2197,11 +2163,11 @@ def _seg_20() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1FBA, "M", "ὰ"),
         (0x1FBB, "M", "ά"),
         (0x1FBC, "M", "αι"),
-        (0x1FBD, "M", " ̓"),
+        (0x1FBD, "3", " ̓"),
         (0x1FBE, "M", "ι"),
-        (0x1FBF, "M", " ̓"),
-        (0x1FC0, "M", " ͂"),
-        (0x1FC1, "M", " ̈͂"),
+        (0x1FBF, "3", " ̓"),
+        (0x1FC0, "3", " ͂"),
+        (0x1FC1, "3", " ̈͂"),
         (0x1FC2, "M", "ὴι"),
         (0x1FC3, "M", "ηι"),
         (0x1FC4, "M", "ήι"),
@@ -2211,16 +2177,11 @@ def _seg_20() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1FC8, "M", "ὲ"),
         (0x1FC9, "M", "έ"),
         (0x1FCA, "M", "ὴ"),
-    ]
-
-
-def _seg_21() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1FCB, "M", "ή"),
         (0x1FCC, "M", "ηι"),
-        (0x1FCD, "M", " ̓̀"),
-        (0x1FCE, "M", " ̓́"),
-        (0x1FCF, "M", " ̓͂"),
+        (0x1FCD, "3", " ̓̀"),
+        (0x1FCE, "3", " ̓́"),
+        (0x1FCF, "3", " ̓͂"),
         (0x1FD0, "V"),
         (0x1FD3, "M", "ΐ"),
         (0x1FD4, "X"),
@@ -2230,9 +2191,9 @@ def _seg_21() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1FDA, "M", "ὶ"),
         (0x1FDB, "M", "ί"),
         (0x1FDC, "X"),
-        (0x1FDD, "M", " ̔̀"),
-        (0x1FDE, "M", " ̔́"),
-        (0x1FDF, "M", " ̔͂"),
+        (0x1FDD, "3", " ̔̀"),
+        (0x1FDE, "3", " ̔́"),
+        (0x1FDF, "3", " ̔͂"),
         (0x1FE0, "V"),
         (0x1FE3, "M", "ΰ"),
         (0x1FE4, "V"),
@@ -2241,37 +2202,42 @@ def _seg_21() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1FEA, "M", "ὺ"),
         (0x1FEB, "M", "ύ"),
         (0x1FEC, "M", "ῥ"),
-        (0x1FED, "M", " ̈̀"),
-        (0x1FEE, "M", " ̈́"),
-        (0x1FEF, "M", "`"),
+        (0x1FED, "3", " ̈̀"),
+        (0x1FEE, "3", " ̈́"),
+        (0x1FEF, "3", "`"),
         (0x1FF0, "X"),
         (0x1FF2, "M", "ὼι"),
         (0x1FF3, "M", "ωι"),
         (0x1FF4, "M", "ώι"),
         (0x1FF5, "X"),
         (0x1FF6, "V"),
+    ]
+
+
+def _seg_21() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1FF7, "M", "ῶι"),
         (0x1FF8, "M", "ὸ"),
         (0x1FF9, "M", "ό"),
         (0x1FFA, "M", "ὼ"),
         (0x1FFB, "M", "ώ"),
         (0x1FFC, "M", "ωι"),
-        (0x1FFD, "M", " ́"),
-        (0x1FFE, "M", " ̔"),
+        (0x1FFD, "3", " ́"),
+        (0x1FFE, "3", " ̔"),
         (0x1FFF, "X"),
-        (0x2000, "M", " "),
+        (0x2000, "3", " "),
         (0x200B, "I"),
         (0x200C, "D", ""),
         (0x200E, "X"),
         (0x2010, "V"),
         (0x2011, "M", "‐"),
         (0x2012, "V"),
-        (0x2017, "M", " ̳"),
+        (0x2017, "3", " ̳"),
         (0x2018, "V"),
         (0x2024, "X"),
         (0x2027, "V"),
         (0x2028, "X"),
-        (0x202F, "M", " "),
+        (0x202F, "3", " "),
         (0x2030, "V"),
         (0x2033, "M", "′′"),
         (0x2034, "M", "′′′"),
@@ -2279,20 +2245,21 @@ def _seg_21() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2036, "M", "‵‵"),
         (0x2037, "M", "‵‵‵"),
         (0x2038, "V"),
-        (0x203C, "M", "!!"),
+        (0x203C, "3", "!!"),
         (0x203D, "V"),
-        (0x203E, "M", " ̅"),
+        (0x203E, "3", " ̅"),
         (0x203F, "V"),
-        (0x2047, "M", "??"),
-        (0x2048, "M", "?!"),
-        (0x2049, "M", "!?"),
+        (0x2047, "3", "??"),
+        (0x2048, "3", "?!"),
+        (0x2049, "3", "!?"),
         (0x204A, "V"),
         (0x2057, "M", "′′′′"),
         (0x2058, "V"),
-        (0x205F, "M", " "),
+        (0x205F, "3", " "),
         (0x2060, "I"),
+        (0x2061, "X"),
+        (0x2064, "I"),
         (0x2065, "X"),
-        (0x206A, "I"),
         (0x2070, "M", "0"),
         (0x2071, "M", "i"),
         (0x2072, "X"),
@@ -2302,11 +2269,11 @@ def _seg_21() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2077, "M", "7"),
         (0x2078, "M", "8"),
         (0x2079, "M", "9"),
-        (0x207A, "M", "+"),
+        (0x207A, "3", "+"),
         (0x207B, "M", "−"),
-        (0x207C, "M", "="),
-        (0x207D, "M", "("),
-        (0x207E, "M", ")"),
+        (0x207C, "3", "="),
+        (0x207D, "3", "("),
+        (0x207E, "3", ")"),
         (0x207F, "M", "n"),
         (0x2080, "M", "0"),
         (0x2081, "M", "1"),
@@ -2316,18 +2283,13 @@ def _seg_21() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2085, "M", "5"),
         (0x2086, "M", "6"),
         (0x2087, "M", "7"),
-    ]
-
-
-def _seg_22() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x2088, "M", "8"),
         (0x2089, "M", "9"),
-        (0x208A, "M", "+"),
+        (0x208A, "3", "+"),
         (0x208B, "M", "−"),
-        (0x208C, "M", "="),
-        (0x208D, "M", "("),
-        (0x208E, "M", ")"),
+        (0x208C, "3", "="),
+        (0x208D, "3", "("),
+        (0x208E, "3", ")"),
         (0x208F, "X"),
         (0x2090, "M", "a"),
         (0x2091, "M", "e"),
@@ -2349,13 +2311,18 @@ def _seg_22() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x20C1, "X"),
         (0x20D0, "V"),
         (0x20F1, "X"),
-        (0x2100, "M", "a/c"),
-        (0x2101, "M", "a/s"),
+        (0x2100, "3", "a/c"),
+        (0x2101, "3", "a/s"),
         (0x2102, "M", "c"),
         (0x2103, "M", "°c"),
         (0x2104, "V"),
-        (0x2105, "M", "c/o"),
-        (0x2106, "M", "c/u"),
+    ]
+
+
+def _seg_22() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x2105, "3", "c/o"),
+        (0x2106, "3", "c/u"),
         (0x2107, "M", "ɛ"),
         (0x2108, "V"),
         (0x2109, "M", "°f"),
@@ -2389,7 +2356,7 @@ def _seg_22() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x212E, "V"),
         (0x212F, "M", "e"),
         (0x2131, "M", "f"),
-        (0x2132, "M", "ⅎ"),
+        (0x2132, "X"),
         (0x2133, "M", "m"),
         (0x2134, "M", "o"),
         (0x2135, "M", "א"),
@@ -2421,11 +2388,6 @@ def _seg_22() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2159, "M", "1⁄6"),
         (0x215A, "M", "5⁄6"),
         (0x215B, "M", "1⁄8"),
-    ]
-
-
-def _seg_23() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x215C, "M", "3⁄8"),
         (0x215D, "M", "5⁄8"),
         (0x215E, "M", "7⁄8"),
@@ -2459,11 +2421,16 @@ def _seg_23() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x217A, "M", "xi"),
         (0x217B, "M", "xii"),
         (0x217C, "M", "l"),
+    ]
+
+
+def _seg_23() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x217D, "M", "c"),
         (0x217E, "M", "d"),
         (0x217F, "M", "m"),
         (0x2180, "V"),
-        (0x2183, "M", "ↄ"),
+        (0x2183, "X"),
         (0x2184, "V"),
         (0x2189, "M", "0⁄3"),
         (0x218A, "V"),
@@ -2478,7 +2445,7 @@ def _seg_23() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2329, "M", "〈"),
         (0x232A, "M", "〉"),
         (0x232B, "V"),
-        (0x242A, "X"),
+        (0x2427, "X"),
         (0x2440, "V"),
         (0x244B, "X"),
         (0x2460, "M", "1"),
@@ -2501,58 +2468,53 @@ def _seg_23() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2471, "M", "18"),
         (0x2472, "M", "19"),
         (0x2473, "M", "20"),
-        (0x2474, "M", "(1)"),
-        (0x2475, "M", "(2)"),
-        (0x2476, "M", "(3)"),
-        (0x2477, "M", "(4)"),
-        (0x2478, "M", "(5)"),
-        (0x2479, "M", "(6)"),
-        (0x247A, "M", "(7)"),
-        (0x247B, "M", "(8)"),
-        (0x247C, "M", "(9)"),
-        (0x247D, "M", "(10)"),
-        (0x247E, "M", "(11)"),
-        (0x247F, "M", "(12)"),
-        (0x2480, "M", "(13)"),
-        (0x2481, "M", "(14)"),
-        (0x2482, "M", "(15)"),
-        (0x2483, "M", "(16)"),
-        (0x2484, "M", "(17)"),
-        (0x2485, "M", "(18)"),
-        (0x2486, "M", "(19)"),
-        (0x2487, "M", "(20)"),
+        (0x2474, "3", "(1)"),
+        (0x2475, "3", "(2)"),
+        (0x2476, "3", "(3)"),
+        (0x2477, "3", "(4)"),
+        (0x2478, "3", "(5)"),
+        (0x2479, "3", "(6)"),
+        (0x247A, "3", "(7)"),
+        (0x247B, "3", "(8)"),
+        (0x247C, "3", "(9)"),
+        (0x247D, "3", "(10)"),
+        (0x247E, "3", "(11)"),
+        (0x247F, "3", "(12)"),
+        (0x2480, "3", "(13)"),
+        (0x2481, "3", "(14)"),
+        (0x2482, "3", "(15)"),
+        (0x2483, "3", "(16)"),
+        (0x2484, "3", "(17)"),
+        (0x2485, "3", "(18)"),
+        (0x2486, "3", "(19)"),
+        (0x2487, "3", "(20)"),
         (0x2488, "X"),
-        (0x249C, "M", "(a)"),
-        (0x249D, "M", "(b)"),
-        (0x249E, "M", "(c)"),
-        (0x249F, "M", "(d)"),
-    ]
-
-
-def _seg_24() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
-        (0x24A0, "M", "(e)"),
-        (0x24A1, "M", "(f)"),
-        (0x24A2, "M", "(g)"),
-        (0x24A3, "M", "(h)"),
-        (0x24A4, "M", "(i)"),
-        (0x24A5, "M", "(j)"),
-        (0x24A6, "M", "(k)"),
-        (0x24A7, "M", "(l)"),
-        (0x24A8, "M", "(m)"),
-        (0x24A9, "M", "(n)"),
-        (0x24AA, "M", "(o)"),
-        (0x24AB, "M", "(p)"),
-        (0x24AC, "M", "(q)"),
-        (0x24AD, "M", "(r)"),
-        (0x24AE, "M", "(s)"),
-        (0x24AF, "M", "(t)"),
-        (0x24B0, "M", "(u)"),
-        (0x24B1, "M", "(v)"),
-        (0x24B2, "M", "(w)"),
-        (0x24B3, "M", "(x)"),
-        (0x24B4, "M", "(y)"),
-        (0x24B5, "M", "(z)"),
+        (0x249C, "3", "(a)"),
+        (0x249D, "3", "(b)"),
+        (0x249E, "3", "(c)"),
+        (0x249F, "3", "(d)"),
+        (0x24A0, "3", "(e)"),
+        (0x24A1, "3", "(f)"),
+        (0x24A2, "3", "(g)"),
+        (0x24A3, "3", "(h)"),
+        (0x24A4, "3", "(i)"),
+        (0x24A5, "3", "(j)"),
+        (0x24A6, "3", "(k)"),
+        (0x24A7, "3", "(l)"),
+        (0x24A8, "3", "(m)"),
+        (0x24A9, "3", "(n)"),
+        (0x24AA, "3", "(o)"),
+        (0x24AB, "3", "(p)"),
+        (0x24AC, "3", "(q)"),
+        (0x24AD, "3", "(r)"),
+        (0x24AE, "3", "(s)"),
+        (0x24AF, "3", "(t)"),
+        (0x24B0, "3", "(u)"),
+        (0x24B1, "3", "(v)"),
+        (0x24B2, "3", "(w)"),
+        (0x24B3, "3", "(x)"),
+        (0x24B4, "3", "(y)"),
+        (0x24B5, "3", "(z)"),
         (0x24B6, "M", "a"),
         (0x24B7, "M", "b"),
         (0x24B8, "M", "c"),
@@ -2564,6 +2526,11 @@ def _seg_24() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x24BE, "M", "i"),
         (0x24BF, "M", "j"),
         (0x24C0, "M", "k"),
+    ]
+
+
+def _seg_24() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x24C1, "M", "l"),
         (0x24C2, "M", "m"),
         (0x24C3, "M", "n"),
@@ -2609,9 +2576,9 @@ def _seg_24() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x24EB, "V"),
         (0x2A0C, "M", "∫∫∫∫"),
         (0x2A0D, "V"),
-        (0x2A74, "M", "::="),
-        (0x2A75, "M", "=="),
-        (0x2A76, "M", "==="),
+        (0x2A74, "3", "::="),
+        (0x2A75, "3", "=="),
+        (0x2A76, "3", "==="),
         (0x2A77, "V"),
         (0x2ADC, "M", "⫝̸"),
         (0x2ADD, "V"),
@@ -2631,11 +2598,6 @@ def _seg_24() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2C09, "M", "ⰹ"),
         (0x2C0A, "M", "ⰺ"),
         (0x2C0B, "M", "ⰻ"),
-    ]
-
-
-def _seg_25() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x2C0C, "M", "ⰼ"),
         (0x2C0D, "M", "ⰽ"),
         (0x2C0E, "M", "ⰾ"),
@@ -2669,6 +2631,11 @@ def _seg_25() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2C2A, "M", "ⱚ"),
         (0x2C2B, "M", "ⱛ"),
         (0x2C2C, "M", "ⱜ"),
+    ]
+
+
+def _seg_25() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x2C2D, "M", "ⱝ"),
         (0x2C2E, "M", "ⱞ"),
         (0x2C2F, "M", "ⱟ"),
@@ -2736,11 +2703,6 @@ def _seg_25() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2CA3, "V"),
         (0x2CA4, "M", "ⲥ"),
         (0x2CA5, "V"),
-    ]
-
-
-def _seg_26() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x2CA6, "M", "ⲧ"),
         (0x2CA7, "V"),
         (0x2CA8, "M", "ⲩ"),
@@ -2774,6 +2736,11 @@ def _seg_26() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2CC4, "M", "ⳅ"),
         (0x2CC5, "V"),
         (0x2CC6, "M", "ⳇ"),
+    ]
+
+
+def _seg_26() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x2CC7, "V"),
         (0x2CC8, "M", "ⳉ"),
         (0x2CC9, "V"),
@@ -2841,11 +2808,6 @@ def _seg_26() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2DDF, "X"),
         (0x2DE0, "V"),
         (0x2E5E, "X"),
-    ]
-
-
-def _seg_27() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x2E80, "V"),
         (0x2E9A, "X"),
         (0x2E9B, "V"),
@@ -2879,6 +2841,11 @@ def _seg_27() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2F17, "M", "十"),
         (0x2F18, "M", "卜"),
         (0x2F19, "M", "卩"),
+    ]
+
+
+def _seg_27() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x2F1A, "M", "厂"),
         (0x2F1B, "M", "厶"),
         (0x2F1C, "M", "又"),
@@ -2946,11 +2913,6 @@ def _seg_27() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2F5A, "M", "片"),
         (0x2F5B, "M", "牙"),
         (0x2F5C, "M", "牛"),
-    ]
-
-
-def _seg_28() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x2F5D, "M", "犬"),
         (0x2F5E, "M", "玄"),
         (0x2F5F, "M", "玉"),
@@ -2984,6 +2946,11 @@ def _seg_28() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2F7B, "M", "羽"),
         (0x2F7C, "M", "老"),
         (0x2F7D, "M", "而"),
+    ]
+
+
+def _seg_28() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x2F7E, "M", "耒"),
         (0x2F7F, "M", "耳"),
         (0x2F80, "M", "聿"),
@@ -3051,11 +3018,6 @@ def _seg_28() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2FBE, "M", "鬥"),
         (0x2FBF, "M", "鬯"),
         (0x2FC0, "M", "鬲"),
-    ]
-
-
-def _seg_29() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x2FC1, "M", "鬼"),
         (0x2FC2, "M", "魚"),
         (0x2FC3, "M", "鳥"),
@@ -3078,7 +3040,7 @@ def _seg_29() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2FD4, "M", "龜"),
         (0x2FD5, "M", "龠"),
         (0x2FD6, "X"),
-        (0x3000, "M", " "),
+        (0x3000, "3", " "),
         (0x3001, "V"),
         (0x3002, "M", "."),
         (0x3003, "V"),
@@ -3089,11 +3051,16 @@ def _seg_29() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x303A, "M", "卅"),
         (0x303B, "V"),
         (0x3040, "X"),
+    ]
+
+
+def _seg_29() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x3041, "V"),
         (0x3097, "X"),
         (0x3099, "V"),
-        (0x309B, "M", " ゙"),
-        (0x309C, "M", " ゚"),
+        (0x309B, "3", " ゙"),
+        (0x309C, "3", " ゚"),
         (0x309D, "V"),
         (0x309F, "M", "より"),
         (0x30A0, "V"),
@@ -3152,15 +3119,10 @@ def _seg_29() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x3161, "M", "ᅳ"),
         (0x3162, "M", "ᅴ"),
         (0x3163, "M", "ᅵ"),
-        (0x3164, "I"),
+        (0x3164, "X"),
         (0x3165, "M", "ᄔ"),
         (0x3166, "M", "ᄕ"),
         (0x3167, "M", "ᇇ"),
-    ]
-
-
-def _seg_30() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x3168, "M", "ᇈ"),
         (0x3169, "M", "ᇌ"),
         (0x316A, "M", "ᇎ"),
@@ -3194,6 +3156,11 @@ def _seg_30() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x3186, "M", "ᅙ"),
         (0x3187, "M", "ᆄ"),
         (0x3188, "M", "ᆅ"),
+    ]
+
+
+def _seg_30() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x3189, "M", "ᆈ"),
         (0x318A, "M", "ᆑ"),
         (0x318B, "M", "ᆒ"),
@@ -3217,81 +3184,76 @@ def _seg_30() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x319E, "M", "地"),
         (0x319F, "M", "人"),
         (0x31A0, "V"),
-        (0x31E6, "X"),
+        (0x31E4, "X"),
         (0x31F0, "V"),
-        (0x3200, "M", "(ᄀ)"),
-        (0x3201, "M", "(ᄂ)"),
-        (0x3202, "M", "(ᄃ)"),
-        (0x3203, "M", "(ᄅ)"),
-        (0x3204, "M", "(ᄆ)"),
-        (0x3205, "M", "(ᄇ)"),
-        (0x3206, "M", "(ᄉ)"),
-        (0x3207, "M", "(ᄋ)"),
-        (0x3208, "M", "(ᄌ)"),
-        (0x3209, "M", "(ᄎ)"),
-        (0x320A, "M", "(ᄏ)"),
-        (0x320B, "M", "(ᄐ)"),
-        (0x320C, "M", "(ᄑ)"),
-        (0x320D, "M", "(ᄒ)"),
-        (0x320E, "M", "(가)"),
-        (0x320F, "M", "(나)"),
-        (0x3210, "M", "(다)"),
-        (0x3211, "M", "(라)"),
-        (0x3212, "M", "(마)"),
-        (0x3213, "M", "(바)"),
-        (0x3214, "M", "(사)"),
-        (0x3215, "M", "(아)"),
-        (0x3216, "M", "(자)"),
-        (0x3217, "M", "(차)"),
-        (0x3218, "M", "(카)"),
-        (0x3219, "M", "(타)"),
-        (0x321A, "M", "(파)"),
-        (0x321B, "M", "(하)"),
-        (0x321C, "M", "(주)"),
-        (0x321D, "M", "(오전)"),
-        (0x321E, "M", "(오후)"),
+        (0x3200, "3", "(ᄀ)"),
+        (0x3201, "3", "(ᄂ)"),
+        (0x3202, "3", "(ᄃ)"),
+        (0x3203, "3", "(ᄅ)"),
+        (0x3204, "3", "(ᄆ)"),
+        (0x3205, "3", "(ᄇ)"),
+        (0x3206, "3", "(ᄉ)"),
+        (0x3207, "3", "(ᄋ)"),
+        (0x3208, "3", "(ᄌ)"),
+        (0x3209, "3", "(ᄎ)"),
+        (0x320A, "3", "(ᄏ)"),
+        (0x320B, "3", "(ᄐ)"),
+        (0x320C, "3", "(ᄑ)"),
+        (0x320D, "3", "(ᄒ)"),
+        (0x320E, "3", "(가)"),
+        (0x320F, "3", "(나)"),
+        (0x3210, "3", "(다)"),
+        (0x3211, "3", "(라)"),
+        (0x3212, "3", "(마)"),
+        (0x3213, "3", "(바)"),
+        (0x3214, "3", "(사)"),
+        (0x3215, "3", "(아)"),
+        (0x3216, "3", "(자)"),
+        (0x3217, "3", "(차)"),
+        (0x3218, "3", "(카)"),
+        (0x3219, "3", "(타)"),
+        (0x321A, "3", "(파)"),
+        (0x321B, "3", "(하)"),
+        (0x321C, "3", "(주)"),
+        (0x321D, "3", "(오전)"),
+        (0x321E, "3", "(오후)"),
         (0x321F, "X"),
-        (0x3220, "M", "(一)"),
-        (0x3221, "M", "(二)"),
-        (0x3222, "M", "(三)"),
-        (0x3223, "M", "(四)"),
-        (0x3224, "M", "(五)"),
-        (0x3225, "M", "(六)"),
-        (0x3226, "M", "(七)"),
-        (0x3227, "M", "(八)"),
-        (0x3228, "M", "(九)"),
-        (0x3229, "M", "(十)"),
-    ]
-
-
-def _seg_31() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
-        (0x322A, "M", "(月)"),
-        (0x322B, "M", "(火)"),
-        (0x322C, "M", "(水)"),
-        (0x322D, "M", "(木)"),
-        (0x322E, "M", "(金)"),
-        (0x322F, "M", "(土)"),
-        (0x3230, "M", "(日)"),
-        (0x3231, "M", "(株)"),
-        (0x3232, "M", "(有)"),
-        (0x3233, "M", "(社)"),
-        (0x3234, "M", "(名)"),
-        (0x3235, "M", "(特)"),
-        (0x3236, "M", "(財)"),
-        (0x3237, "M", "(祝)"),
-        (0x3238, "M", "(労)"),
-        (0x3239, "M", "(代)"),
-        (0x323A, "M", "(呼)"),
-        (0x323B, "M", "(学)"),
-        (0x323C, "M", "(監)"),
-        (0x323D, "M", "(企)"),
-        (0x323E, "M", "(資)"),
-        (0x323F, "M", "(協)"),
-        (0x3240, "M", "(祭)"),
-        (0x3241, "M", "(休)"),
-        (0x3242, "M", "(自)"),
-        (0x3243, "M", "(至)"),
+        (0x3220, "3", "(一)"),
+        (0x3221, "3", "(二)"),
+        (0x3222, "3", "(三)"),
+        (0x3223, "3", "(四)"),
+        (0x3224, "3", "(五)"),
+        (0x3225, "3", "(六)"),
+        (0x3226, "3", "(七)"),
+        (0x3227, "3", "(八)"),
+        (0x3228, "3", "(九)"),
+        (0x3229, "3", "(十)"),
+        (0x322A, "3", "(月)"),
+        (0x322B, "3", "(火)"),
+        (0x322C, "3", "(水)"),
+        (0x322D, "3", "(木)"),
+        (0x322E, "3", "(金)"),
+        (0x322F, "3", "(土)"),
+        (0x3230, "3", "(日)"),
+        (0x3231, "3", "(株)"),
+        (0x3232, "3", "(有)"),
+        (0x3233, "3", "(社)"),
+        (0x3234, "3", "(名)"),
+        (0x3235, "3", "(特)"),
+        (0x3236, "3", "(財)"),
+        (0x3237, "3", "(祝)"),
+        (0x3238, "3", "(労)"),
+        (0x3239, "3", "(代)"),
+        (0x323A, "3", "(呼)"),
+        (0x323B, "3", "(学)"),
+        (0x323C, "3", "(監)"),
+        (0x323D, "3", "(企)"),
+        (0x323E, "3", "(資)"),
+        (0x323F, "3", "(協)"),
+        (0x3240, "3", "(祭)"),
+        (0x3241, "3", "(休)"),
+        (0x3242, "3", "(自)"),
+        (0x3243, "3", "(至)"),
         (0x3244, "M", "問"),
         (0x3245, "M", "幼"),
         (0x3246, "M", "文"),
@@ -3299,6 +3261,11 @@ def _seg_31() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x3248, "V"),
         (0x3250, "M", "pte"),
         (0x3251, "M", "21"),
+    ]
+
+
+def _seg_31() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x3252, "M", "22"),
         (0x3253, "M", "23"),
         (0x3254, "M", "24"),
@@ -3366,11 +3333,6 @@ def _seg_31() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x3292, "M", "有"),
         (0x3293, "M", "社"),
         (0x3294, "M", "名"),
-    ]
-
-
-def _seg_32() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x3295, "M", "特"),
         (0x3296, "M", "財"),
         (0x3297, "M", "祝"),
@@ -3404,6 +3366,11 @@ def _seg_32() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x32B3, "M", "38"),
         (0x32B4, "M", "39"),
         (0x32B5, "M", "40"),
+    ]
+
+
+def _seg_32() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x32B6, "M", "41"),
         (0x32B7, "M", "42"),
         (0x32B8, "M", "43"),
@@ -3471,11 +3438,6 @@ def _seg_32() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x32F6, "M", "ラ"),
         (0x32F7, "M", "リ"),
         (0x32F8, "M", "ル"),
-    ]
-
-
-def _seg_33() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x32F9, "M", "レ"),
         (0x32FA, "M", "ロ"),
         (0x32FB, "M", "ワ"),
@@ -3509,6 +3471,11 @@ def _seg_33() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x3317, "M", "キロワット"),
         (0x3318, "M", "グラム"),
         (0x3319, "M", "グラムトン"),
+    ]
+
+
+def _seg_33() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x331A, "M", "クルゼイロ"),
         (0x331B, "M", "クローネ"),
         (0x331C, "M", "ケース"),
@@ -3576,11 +3543,6 @@ def _seg_33() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x335A, "M", "2点"),
         (0x335B, "M", "3点"),
         (0x335C, "M", "4点"),
-    ]
-
-
-def _seg_34() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x335D, "M", "5点"),
         (0x335E, "M", "6点"),
         (0x335F, "M", "7点"),
@@ -3614,6 +3576,11 @@ def _seg_34() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x337B, "M", "平成"),
         (0x337C, "M", "昭和"),
         (0x337D, "M", "大正"),
+    ]
+
+
+def _seg_34() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x337E, "M", "明治"),
         (0x337F, "M", "株式会社"),
         (0x3380, "M", "pa"),
@@ -3681,11 +3648,6 @@ def _seg_34() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x33BE, "M", "kw"),
         (0x33BF, "M", "mw"),
         (0x33C0, "M", "kω"),
-    ]
-
-
-def _seg_35() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x33C1, "M", "mω"),
         (0x33C2, "X"),
         (0x33C3, "M", "bq"),
@@ -3719,6 +3681,11 @@ def _seg_35() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x33DF, "M", "a∕m"),
         (0x33E0, "M", "1日"),
         (0x33E1, "M", "2日"),
+    ]
+
+
+def _seg_35() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x33E2, "M", "3日"),
         (0x33E3, "M", "4日"),
         (0x33E4, "M", "5日"),
@@ -3786,11 +3753,6 @@ def _seg_35() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xA65C, "M", "ꙝ"),
         (0xA65D, "V"),
         (0xA65E, "M", "ꙟ"),
-    ]
-
-
-def _seg_36() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0xA65F, "V"),
         (0xA660, "M", "ꙡ"),
         (0xA661, "V"),
@@ -3824,6 +3786,11 @@ def _seg_36() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xA68F, "V"),
         (0xA690, "M", "ꚑ"),
         (0xA691, "V"),
+    ]
+
+
+def _seg_36() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0xA692, "M", "ꚓ"),
         (0xA693, "V"),
         (0xA694, "M", "ꚕ"),
@@ -3891,11 +3858,6 @@ def _seg_36() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xA755, "V"),
         (0xA756, "M", "ꝗ"),
         (0xA757, "V"),
-    ]
-
-
-def _seg_37() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0xA758, "M", "ꝙ"),
         (0xA759, "V"),
         (0xA75A, "M", "ꝛ"),
@@ -3929,6 +3891,11 @@ def _seg_37() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xA77D, "M", "ᵹ"),
         (0xA77E, "M", "ꝿ"),
         (0xA77F, "V"),
+    ]
+
+
+def _seg_37() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0xA780, "M", "ꞁ"),
         (0xA781, "V"),
         (0xA782, "M", "ꞃ"),
@@ -3996,17 +3963,9 @@ def _seg_37() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xA7C6, "M", "ᶎ"),
         (0xA7C7, "M", "ꟈ"),
         (0xA7C8, "V"),
-    ]
-
-
-def _seg_38() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0xA7C9, "M", "ꟊ"),
         (0xA7CA, "V"),
-        (0xA7CB, "M", "ɤ"),
-        (0xA7CC, "M", "ꟍ"),
-        (0xA7CD, "V"),
-        (0xA7CE, "X"),
+        (0xA7CB, "X"),
         (0xA7D0, "M", "ꟑ"),
         (0xA7D1, "V"),
         (0xA7D2, "X"),
@@ -4017,10 +3976,7 @@ def _seg_38() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xA7D7, "V"),
         (0xA7D8, "M", "ꟙ"),
         (0xA7D9, "V"),
-        (0xA7DA, "M", "ꟛ"),
-        (0xA7DB, "V"),
-        (0xA7DC, "M", "ƛ"),
-        (0xA7DD, "X"),
+        (0xA7DA, "X"),
         (0xA7F2, "M", "c"),
         (0xA7F3, "M", "f"),
         (0xA7F4, "M", "q"),
@@ -4040,6 +3996,11 @@ def _seg_38() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xA8DA, "X"),
         (0xA8E0, "V"),
         (0xA954, "X"),
+    ]
+
+
+def _seg_38() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0xA95F, "V"),
         (0xA97D, "X"),
         (0xA980, "V"),
@@ -4101,11 +4062,6 @@ def _seg_38() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xAB85, "M", "Ꮅ"),
         (0xAB86, "M", "Ꮆ"),
         (0xAB87, "M", "Ꮇ"),
-    ]
-
-
-def _seg_39() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0xAB88, "M", "Ꮈ"),
         (0xAB89, "M", "Ꮉ"),
         (0xAB8A, "M", "Ꮊ"),
@@ -4145,6 +4101,11 @@ def _seg_39() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xABAC, "M", "Ꮬ"),
         (0xABAD, "M", "Ꮭ"),
         (0xABAE, "M", "Ꮮ"),
+    ]
+
+
+def _seg_39() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0xABAF, "M", "Ꮯ"),
         (0xABB0, "M", "Ꮰ"),
         (0xABB1, "M", "Ꮱ"),
@@ -4206,11 +4167,6 @@ def _seg_39() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xF920, "M", "鸞"),
         (0xF921, "M", "嵐"),
         (0xF922, "M", "濫"),
-    ]
-
-
-def _seg_40() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0xF923, "M", "藍"),
         (0xF924, "M", "襤"),
         (0xF925, "M", "拉"),
@@ -4250,6 +4206,11 @@ def _seg_40() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xF947, "M", "磊"),
         (0xF948, "M", "賂"),
         (0xF949, "M", "雷"),
+    ]
+
+
+def _seg_40() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0xF94A, "M", "壘"),
         (0xF94B, "M", "屢"),
         (0xF94C, "M", "樓"),
@@ -4311,11 +4272,6 @@ def _seg_40() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xF984, "M", "濾"),
         (0xF985, "M", "礪"),
         (0xF986, "M", "閭"),
-    ]
-
-
-def _seg_41() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0xF987, "M", "驪"),
         (0xF988, "M", "麗"),
         (0xF989, "M", "黎"),
@@ -4355,6 +4311,11 @@ def _seg_41() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xF9AB, "M", "嶺"),
         (0xF9AC, "M", "怜"),
         (0xF9AD, "M", "玲"),
+    ]
+
+
+def _seg_41() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0xF9AE, "M", "瑩"),
         (0xF9AF, "M", "羚"),
         (0xF9B0, "M", "聆"),
@@ -4416,11 +4377,6 @@ def _seg_41() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xF9E8, "M", "裡"),
         (0xF9E9, "M", "里"),
         (0xF9EA, "M", "離"),
-    ]
-
-
-def _seg_42() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0xF9EB, "M", "匿"),
         (0xF9EC, "M", "溺"),
         (0xF9ED, "M", "吝"),
@@ -4460,6 +4416,11 @@ def _seg_42() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFA10, "M", "塚"),
         (0xFA11, "V"),
         (0xFA12, "M", "晴"),
+    ]
+
+
+def _seg_42() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0xFA13, "V"),
         (0xFA15, "M", "凞"),
         (0xFA16, "M", "猪"),
@@ -4521,11 +4482,6 @@ def _seg_42() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFA51, "M", "祝"),
         (0xFA52, "M", "禍"),
         (0xFA53, "M", "禎"),
-    ]
-
-
-def _seg_43() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0xFA54, "M", "穀"),
         (0xFA55, "M", "突"),
         (0xFA56, "M", "節"),
@@ -4565,6 +4521,11 @@ def _seg_43() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFA7A, "M", "喙"),
         (0xFA7B, "M", "嗢"),
         (0xFA7C, "M", "塚"),
+    ]
+
+
+def _seg_43() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0xFA7D, "M", "墳"),
         (0xFA7E, "M", "奄"),
         (0xFA7F, "M", "奔"),
@@ -4626,11 +4587,6 @@ def _seg_43() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFAB7, "M", "覆"),
         (0xFAB8, "M", "視"),
         (0xFAB9, "M", "調"),
-    ]
-
-
-def _seg_44() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0xFABA, "M", "諸"),
         (0xFABB, "M", "請"),
         (0xFABC, "M", "謁"),
@@ -4670,6 +4626,11 @@ def _seg_44() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFB03, "M", "ffi"),
         (0xFB04, "M", "ffl"),
         (0xFB05, "M", "st"),
+    ]
+
+
+def _seg_44() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0xFB07, "X"),
         (0xFB13, "M", "մն"),
         (0xFB14, "M", "մե"),
@@ -4689,7 +4650,7 @@ def _seg_44() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFB26, "M", "ם"),
         (0xFB27, "M", "ר"),
         (0xFB28, "M", "ת"),
-        (0xFB29, "M", "+"),
+        (0xFB29, "3", "+"),
         (0xFB2A, "M", "שׁ"),
         (0xFB2B, "M", "שׂ"),
         (0xFB2C, "M", "שּׁ"),
@@ -4731,11 +4692,6 @@ def _seg_44() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFB50, "M", "ٱ"),
         (0xFB52, "M", "ٻ"),
         (0xFB56, "M", "پ"),
-    ]
-
-
-def _seg_45() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0xFB5A, "M", "ڀ"),
         (0xFB5E, "M", "ٺ"),
         (0xFB62, "M", "ٿ"),
@@ -4775,6 +4731,11 @@ def _seg_45() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFBE2, "M", "ۉ"),
         (0xFBE4, "M", "ې"),
         (0xFBE8, "M", "ى"),
+    ]
+
+
+def _seg_45() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0xFBEA, "M", "ئا"),
         (0xFBEC, "M", "ئە"),
         (0xFBEE, "M", "ئو"),
@@ -4836,11 +4797,6 @@ def _seg_45() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFC31, "M", "فى"),
         (0xFC32, "M", "في"),
         (0xFC33, "M", "قح"),
-    ]
-
-
-def _seg_46() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0xFC34, "M", "قم"),
         (0xFC35, "M", "قى"),
         (0xFC36, "M", "قي"),
@@ -4880,15 +4836,20 @@ def _seg_46() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFC58, "M", "يم"),
         (0xFC59, "M", "يى"),
         (0xFC5A, "M", "يي"),
+    ]
+
+
+def _seg_46() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0xFC5B, "M", "ذٰ"),
         (0xFC5C, "M", "رٰ"),
         (0xFC5D, "M", "ىٰ"),
-        (0xFC5E, "M", " ٌّ"),
-        (0xFC5F, "M", " ٍّ"),
-        (0xFC60, "M", " َّ"),
-        (0xFC61, "M", " ُّ"),
-        (0xFC62, "M", " ِّ"),
-        (0xFC63, "M", " ّٰ"),
+        (0xFC5E, "3", " ٌّ"),
+        (0xFC5F, "3", " ٍّ"),
+        (0xFC60, "3", " َّ"),
+        (0xFC61, "3", " ُّ"),
+        (0xFC62, "3", " ِّ"),
+        (0xFC63, "3", " ّٰ"),
         (0xFC64, "M", "ئر"),
         (0xFC65, "M", "ئز"),
         (0xFC66, "M", "ئم"),
@@ -4941,11 +4902,6 @@ def _seg_46() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFC95, "M", "يى"),
         (0xFC96, "M", "يي"),
         (0xFC97, "M", "ئج"),
-    ]
-
-
-def _seg_47() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0xFC98, "M", "ئح"),
         (0xFC99, "M", "ئخ"),
         (0xFC9A, "M", "ئم"),
@@ -4985,6 +4941,11 @@ def _seg_47() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFCBC, "M", "غج"),
         (0xFCBD, "M", "غم"),
         (0xFCBE, "M", "فج"),
+    ]
+
+
+def _seg_47() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0xFCBF, "M", "فح"),
         (0xFCC0, "M", "فخ"),
         (0xFCC1, "M", "فم"),
@@ -5046,11 +5007,6 @@ def _seg_47() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFCF9, "M", "غى"),
         (0xFCFA, "M", "غي"),
         (0xFCFB, "M", "سى"),
-    ]
-
-
-def _seg_48() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0xFCFC, "M", "سي"),
         (0xFCFD, "M", "شى"),
         (0xFCFE, "M", "شي"),
@@ -5090,6 +5046,11 @@ def _seg_48() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFD20, "M", "خي"),
         (0xFD21, "M", "صى"),
         (0xFD22, "M", "صي"),
+    ]
+
+
+def _seg_48() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0xFD23, "M", "ضى"),
         (0xFD24, "M", "ضي"),
         (0xFD25, "M", "شج"),
@@ -5151,11 +5112,6 @@ def _seg_48() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFD7A, "M", "غمي"),
         (0xFD7B, "M", "غمى"),
         (0xFD7C, "M", "فخم"),
-    ]
-
-
-def _seg_49() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0xFD7E, "M", "قمح"),
         (0xFD7F, "M", "قمم"),
         (0xFD80, "M", "لحم"),
@@ -5195,6 +5151,11 @@ def _seg_49() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFDA8, "M", "سخى"),
         (0xFDA9, "M", "صحي"),
         (0xFDAA, "M", "شحي"),
+    ]
+
+
+def _seg_49() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0xFDAB, "M", "ضحي"),
         (0xFDAC, "M", "لجي"),
         (0xFDAD, "M", "لمي"),
@@ -5237,18 +5198,18 @@ def _seg_49() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFDF7, "M", "عليه"),
         (0xFDF8, "M", "وسلم"),
         (0xFDF9, "M", "صلى"),
-        (0xFDFA, "M", "صلى الله عليه وسلم"),
-        (0xFDFB, "M", "جل جلاله"),
+        (0xFDFA, "3", "صلى الله عليه وسلم"),
+        (0xFDFB, "3", "جل جلاله"),
         (0xFDFC, "M", "ریال"),
         (0xFDFD, "V"),
         (0xFE00, "I"),
-        (0xFE10, "M", ","),
+        (0xFE10, "3", ","),
         (0xFE11, "M", "、"),
         (0xFE12, "X"),
-        (0xFE13, "M", ":"),
-        (0xFE14, "M", ";"),
-        (0xFE15, "M", "!"),
-        (0xFE16, "M", "?"),
+        (0xFE13, "3", ":"),
+        (0xFE14, "3", ";"),
+        (0xFE15, "3", "!"),
+        (0xFE16, "3", "?"),
         (0xFE17, "M", "〖"),
         (0xFE18, "M", "〗"),
         (0xFE19, "X"),
@@ -5256,16 +5217,11 @@ def _seg_49() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFE30, "X"),
         (0xFE31, "M", "—"),
         (0xFE32, "M", "–"),
-    ]
-
-
-def _seg_50() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
-        (0xFE33, "M", "_"),
-        (0xFE35, "M", "("),
-        (0xFE36, "M", ")"),
-        (0xFE37, "M", "{"),
-        (0xFE38, "M", "}"),
+        (0xFE33, "3", "_"),
+        (0xFE35, "3", "("),
+        (0xFE36, "3", ")"),
+        (0xFE37, "3", "{"),
+        (0xFE38, "3", "}"),
         (0xFE39, "M", "〔"),
         (0xFE3A, "M", "〕"),
         (0xFE3B, "M", "【"),
@@ -5279,53 +5235,58 @@ def _seg_50() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFE43, "M", "『"),
         (0xFE44, "M", "』"),
         (0xFE45, "V"),
-        (0xFE47, "M", "["),
-        (0xFE48, "M", "]"),
-        (0xFE49, "M", " ̅"),
-        (0xFE4D, "M", "_"),
-        (0xFE50, "M", ","),
+        (0xFE47, "3", "["),
+        (0xFE48, "3", "]"),
+        (0xFE49, "3", " ̅"),
+        (0xFE4D, "3", "_"),
+        (0xFE50, "3", ","),
         (0xFE51, "M", "、"),
         (0xFE52, "X"),
-        (0xFE54, "M", ";"),
-        (0xFE55, "M", ":"),
-        (0xFE56, "M", "?"),
-        (0xFE57, "M", "!"),
+        (0xFE54, "3", ";"),
+        (0xFE55, "3", ":"),
+        (0xFE56, "3", "?"),
+        (0xFE57, "3", "!"),
         (0xFE58, "M", "—"),
-        (0xFE59, "M", "("),
-        (0xFE5A, "M", ")"),
-        (0xFE5B, "M", "{"),
-        (0xFE5C, "M", "}"),
+        (0xFE59, "3", "("),
+        (0xFE5A, "3", ")"),
+        (0xFE5B, "3", "{"),
+        (0xFE5C, "3", "}"),
         (0xFE5D, "M", "〔"),
         (0xFE5E, "M", "〕"),
-        (0xFE5F, "M", "#"),
-        (0xFE60, "M", "&"),
-        (0xFE61, "M", "*"),
-        (0xFE62, "M", "+"),
+        (0xFE5F, "3", "#"),
+        (0xFE60, "3", "&"),
+        (0xFE61, "3", "*"),
+    ]
+
+
+def _seg_50() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xFE62, "3", "+"),
         (0xFE63, "M", "-"),
-        (0xFE64, "M", "<"),
-        (0xFE65, "M", ">"),
-        (0xFE66, "M", "="),
+        (0xFE64, "3", "<"),
+        (0xFE65, "3", ">"),
+        (0xFE66, "3", "="),
         (0xFE67, "X"),
-        (0xFE68, "M", "\\"),
-        (0xFE69, "M", "$"),
-        (0xFE6A, "M", "%"),
-        (0xFE6B, "M", "@"),
+        (0xFE68, "3", "\\"),
+        (0xFE69, "3", "$"),
+        (0xFE6A, "3", "%"),
+        (0xFE6B, "3", "@"),
         (0xFE6C, "X"),
-        (0xFE70, "M", " ً"),
+        (0xFE70, "3", " ً"),
         (0xFE71, "M", "ـً"),
-        (0xFE72, "M", " ٌ"),
+        (0xFE72, "3", " ٌ"),
         (0xFE73, "V"),
-        (0xFE74, "M", " ٍ"),
+        (0xFE74, "3", " ٍ"),
         (0xFE75, "X"),
-        (0xFE76, "M", " َ"),
+        (0xFE76, "3", " َ"),
         (0xFE77, "M", "ـَ"),
-        (0xFE78, "M", " ُ"),
+        (0xFE78, "3", " ُ"),
         (0xFE79, "M", "ـُ"),
-        (0xFE7A, "M", " ِ"),
+        (0xFE7A, "3", " ِ"),
         (0xFE7B, "M", "ـِ"),
-        (0xFE7C, "M", " ّ"),
+        (0xFE7C, "3", " ّ"),
         (0xFE7D, "M", "ـّ"),
-        (0xFE7E, "M", " ْ"),
+        (0xFE7E, "3", " ْ"),
         (0xFE7F, "M", "ـْ"),
         (0xFE80, "M", "ء"),
         (0xFE81, "M", "آ"),
@@ -5361,11 +5322,6 @@ def _seg_50() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFEE5, "M", "ن"),
         (0xFEE9, "M", "ه"),
         (0xFEED, "M", "و"),
-    ]
-
-
-def _seg_51() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0xFEEF, "M", "ى"),
         (0xFEF1, "M", "ي"),
         (0xFEF5, "M", "لآ"),
@@ -5375,21 +5331,21 @@ def _seg_51() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFEFD, "X"),
         (0xFEFF, "I"),
         (0xFF00, "X"),
-        (0xFF01, "M", "!"),
-        (0xFF02, "M", '"'),
-        (0xFF03, "M", "#"),
-        (0xFF04, "M", "$"),
-        (0xFF05, "M", "%"),
-        (0xFF06, "M", "&"),
-        (0xFF07, "M", "'"),
-        (0xFF08, "M", "("),
-        (0xFF09, "M", ")"),
-        (0xFF0A, "M", "*"),
-        (0xFF0B, "M", "+"),
-        (0xFF0C, "M", ","),
+        (0xFF01, "3", "!"),
+        (0xFF02, "3", '"'),
+        (0xFF03, "3", "#"),
+        (0xFF04, "3", "$"),
+        (0xFF05, "3", "%"),
+        (0xFF06, "3", "&"),
+        (0xFF07, "3", "'"),
+        (0xFF08, "3", "("),
+        (0xFF09, "3", ")"),
+        (0xFF0A, "3", "*"),
+        (0xFF0B, "3", "+"),
+        (0xFF0C, "3", ","),
         (0xFF0D, "M", "-"),
         (0xFF0E, "M", "."),
-        (0xFF0F, "M", "/"),
+        (0xFF0F, "3", "/"),
         (0xFF10, "M", "0"),
         (0xFF11, "M", "1"),
         (0xFF12, "M", "2"),
@@ -5400,13 +5356,18 @@ def _seg_51() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFF17, "M", "7"),
         (0xFF18, "M", "8"),
         (0xFF19, "M", "9"),
-        (0xFF1A, "M", ":"),
-        (0xFF1B, "M", ";"),
-        (0xFF1C, "M", "<"),
-        (0xFF1D, "M", "="),
-        (0xFF1E, "M", ">"),
-        (0xFF1F, "M", "?"),
-        (0xFF20, "M", "@"),
+        (0xFF1A, "3", ":"),
+        (0xFF1B, "3", ";"),
+        (0xFF1C, "3", "<"),
+        (0xFF1D, "3", "="),
+        (0xFF1E, "3", ">"),
+    ]
+
+
+def _seg_51() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xFF1F, "3", "?"),
+        (0xFF20, "3", "@"),
         (0xFF21, "M", "a"),
         (0xFF22, "M", "b"),
         (0xFF23, "M", "c"),
@@ -5433,12 +5394,12 @@ def _seg_51() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFF38, "M", "x"),
         (0xFF39, "M", "y"),
         (0xFF3A, "M", "z"),
-        (0xFF3B, "M", "["),
-        (0xFF3C, "M", "\\"),
-        (0xFF3D, "M", "]"),
-        (0xFF3E, "M", "^"),
-        (0xFF3F, "M", "_"),
-        (0xFF40, "M", "`"),
+        (0xFF3B, "3", "["),
+        (0xFF3C, "3", "\\"),
+        (0xFF3D, "3", "]"),
+        (0xFF3E, "3", "^"),
+        (0xFF3F, "3", "_"),
+        (0xFF40, "3", "`"),
         (0xFF41, "M", "a"),
         (0xFF42, "M", "b"),
         (0xFF43, "M", "c"),
@@ -5465,15 +5426,10 @@ def _seg_51() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFF58, "M", "x"),
         (0xFF59, "M", "y"),
         (0xFF5A, "M", "z"),
-        (0xFF5B, "M", "{"),
-    ]
-
-
-def _seg_52() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
-        (0xFF5C, "M", "|"),
-        (0xFF5D, "M", "}"),
-        (0xFF5E, "M", "~"),
+        (0xFF5B, "3", "{"),
+        (0xFF5C, "3", "|"),
+        (0xFF5D, "3", "}"),
+        (0xFF5E, "3", "~"),
         (0xFF5F, "M", "⦅"),
         (0xFF60, "M", "⦆"),
         (0xFF61, "M", "."),
@@ -5510,6 +5466,11 @@ def _seg_52() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFF80, "M", "タ"),
         (0xFF81, "M", "チ"),
         (0xFF82, "M", "ツ"),
+    ]
+
+
+def _seg_52() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0xFF83, "M", "テ"),
         (0xFF84, "M", "ト"),
         (0xFF85, "M", "ナ"),
@@ -5539,7 +5500,7 @@ def _seg_52() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFF9D, "M", "ン"),
         (0xFF9E, "M", "゙"),
         (0xFF9F, "M", "゚"),
-        (0xFFA0, "I"),
+        (0xFFA0, "X"),
         (0xFFA1, "M", "ᄀ"),
         (0xFFA2, "M", "ᄁ"),
         (0xFFA3, "M", "ᆪ"),
@@ -5571,11 +5532,6 @@ def _seg_52() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFFBD, "M", "ᄑ"),
         (0xFFBE, "M", "ᄒ"),
         (0xFFBF, "X"),
-    ]
-
-
-def _seg_53() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0xFFC2, "M", "ᅡ"),
         (0xFFC3, "M", "ᅢ"),
         (0xFFC4, "M", "ᅣ"),
@@ -5604,7 +5560,7 @@ def _seg_53() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFFE0, "M", "¢"),
         (0xFFE1, "M", "£"),
         (0xFFE2, "M", "¬"),
-        (0xFFE3, "M", " ̄"),
+        (0xFFE3, "3", " ̄"),
         (0xFFE4, "M", "¦"),
         (0xFFE5, "M", "¥"),
         (0xFFE6, "M", "₩"),
@@ -5615,6 +5571,11 @@ def _seg_53() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0xFFEB, "M", "→"),
         (0xFFEC, "M", "↓"),
         (0xFFED, "M", "■"),
+    ]
+
+
+def _seg_53() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0xFFEE, "M", "○"),
         (0xFFEF, "X"),
         (0x10000, "V"),
@@ -5676,11 +5637,6 @@ def _seg_53() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1040C, "M", "𐐴"),
         (0x1040D, "M", "𐐵"),
         (0x1040E, "M", "𐐶"),
-    ]
-
-
-def _seg_54() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1040F, "M", "𐐷"),
         (0x10410, "M", "𐐸"),
         (0x10411, "M", "𐐹"),
@@ -5720,6 +5676,11 @@ def _seg_54() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x104B7, "M", "𐓟"),
         (0x104B8, "M", "𐓠"),
         (0x104B9, "M", "𐓡"),
+    ]
+
+
+def _seg_54() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x104BA, "M", "𐓢"),
         (0x104BB, "M", "𐓣"),
         (0x104BC, "M", "𐓤"),
@@ -5781,11 +5742,6 @@ def _seg_54() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x10588, "M", "𐖯"),
         (0x10589, "M", "𐖰"),
         (0x1058A, "M", "𐖱"),
-    ]
-
-
-def _seg_55() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1058B, "X"),
         (0x1058C, "M", "𐖳"),
         (0x1058D, "M", "𐖴"),
@@ -5806,8 +5762,6 @@ def _seg_55() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x105BA, "X"),
         (0x105BB, "V"),
         (0x105BD, "X"),
-        (0x105C0, "V"),
-        (0x105F4, "X"),
         (0x10600, "V"),
         (0x10737, "X"),
         (0x10740, "V"),
@@ -5827,6 +5781,11 @@ def _seg_55() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1078A, "M", "ʤ"),
         (0x1078B, "M", "ɖ"),
         (0x1078C, "M", "ɗ"),
+    ]
+
+
+def _seg_55() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1078D, "M", "ᶑ"),
         (0x1078E, "M", "ɘ"),
         (0x1078F, "M", "ɞ"),
@@ -5886,11 +5845,6 @@ def _seg_55() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1083D, "X"),
         (0x1083F, "V"),
         (0x10856, "X"),
-    ]
-
-
-def _seg_56() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x10857, "V"),
         (0x1089F, "X"),
         (0x108A7, "V"),
@@ -5932,6 +5886,11 @@ def _seg_56() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x10AEB, "V"),
         (0x10AF7, "X"),
         (0x10B00, "V"),
+    ]
+
+
+def _seg_56() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x10B36, "X"),
         (0x10B39, "V"),
         (0x10B56, "X"),
@@ -5991,11 +5950,6 @@ def _seg_56() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x10CAB, "M", "𐳫"),
         (0x10CAC, "M", "𐳬"),
         (0x10CAD, "M", "𐳭"),
-    ]
-
-
-def _seg_57() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x10CAE, "M", "𐳮"),
         (0x10CAF, "M", "𐳯"),
         (0x10CB0, "M", "𐳰"),
@@ -6008,34 +5962,6 @@ def _seg_57() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x10D28, "X"),
         (0x10D30, "V"),
         (0x10D3A, "X"),
-        (0x10D40, "V"),
-        (0x10D50, "M", "𐵰"),
-        (0x10D51, "M", "𐵱"),
-        (0x10D52, "M", "𐵲"),
-        (0x10D53, "M", "𐵳"),
-        (0x10D54, "M", "𐵴"),
-        (0x10D55, "M", "𐵵"),
-        (0x10D56, "M", "𐵶"),
-        (0x10D57, "M", "𐵷"),
-        (0x10D58, "M", "𐵸"),
-        (0x10D59, "M", "𐵹"),
-        (0x10D5A, "M", "𐵺"),
-        (0x10D5B, "M", "𐵻"),
-        (0x10D5C, "M", "𐵼"),
-        (0x10D5D, "M", "𐵽"),
-        (0x10D5E, "M", "𐵾"),
-        (0x10D5F, "M", "𐵿"),
-        (0x10D60, "M", "𐶀"),
-        (0x10D61, "M", "𐶁"),
-        (0x10D62, "M", "𐶂"),
-        (0x10D63, "M", "𐶃"),
-        (0x10D64, "M", "𐶄"),
-        (0x10D65, "M", "𐶅"),
-        (0x10D66, "X"),
-        (0x10D69, "V"),
-        (0x10D86, "X"),
-        (0x10D8E, "V"),
-        (0x10D90, "X"),
         (0x10E60, "V"),
         (0x10E7F, "X"),
         (0x10E80, "V"),
@@ -6044,9 +5970,7 @@ def _seg_57() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x10EAE, "X"),
         (0x10EB0, "V"),
         (0x10EB2, "X"),
-        (0x10EC2, "V"),
-        (0x10EC5, "X"),
-        (0x10EFC, "V"),
+        (0x10EFD, "V"),
         (0x10F28, "X"),
         (0x10F30, "V"),
         (0x10F5A, "X"),
@@ -6067,6 +5991,11 @@ def _seg_57() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x110D0, "V"),
         (0x110E9, "X"),
         (0x110F0, "V"),
+    ]
+
+
+def _seg_57() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x110FA, "X"),
         (0x11100, "V"),
         (0x11135, "X"),
@@ -6096,11 +6025,6 @@ def _seg_57() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x112EB, "X"),
         (0x112F0, "V"),
         (0x112FA, "X"),
-    ]
-
-
-def _seg_58() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x11300, "V"),
         (0x11304, "X"),
         (0x11305, "V"),
@@ -6131,28 +6055,6 @@ def _seg_58() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1136D, "X"),
         (0x11370, "V"),
         (0x11375, "X"),
-        (0x11380, "V"),
-        (0x1138A, "X"),
-        (0x1138B, "V"),
-        (0x1138C, "X"),
-        (0x1138E, "V"),
-        (0x1138F, "X"),
-        (0x11390, "V"),
-        (0x113B6, "X"),
-        (0x113B7, "V"),
-        (0x113C1, "X"),
-        (0x113C2, "V"),
-        (0x113C3, "X"),
-        (0x113C5, "V"),
-        (0x113C6, "X"),
-        (0x113C7, "V"),
-        (0x113CB, "X"),
-        (0x113CC, "V"),
-        (0x113D6, "X"),
-        (0x113D7, "V"),
-        (0x113D9, "X"),
-        (0x113E1, "V"),
-        (0x113E3, "X"),
         (0x11400, "V"),
         (0x1145C, "X"),
         (0x1145D, "V"),
@@ -6175,8 +6077,6 @@ def _seg_58() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x116BA, "X"),
         (0x116C0, "V"),
         (0x116CA, "X"),
-        (0x116D0, "V"),
-        (0x116E4, "X"),
         (0x11700, "V"),
         (0x1171B, "X"),
         (0x1171D, "V"),
@@ -6196,16 +6096,16 @@ def _seg_58() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x118A8, "M", "𑣈"),
         (0x118A9, "M", "𑣉"),
         (0x118AA, "M", "𑣊"),
+    ]
+
+
+def _seg_58() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x118AB, "M", "𑣋"),
         (0x118AC, "M", "𑣌"),
         (0x118AD, "M", "𑣍"),
         (0x118AE, "M", "𑣎"),
         (0x118AF, "M", "𑣏"),
-    ]
-
-
-def _seg_59() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x118B0, "M", "𑣐"),
         (0x118B1, "M", "𑣑"),
         (0x118B2, "M", "𑣒"),
@@ -6254,10 +6154,6 @@ def _seg_59() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x11AF9, "X"),
         (0x11B00, "V"),
         (0x11B0A, "X"),
-        (0x11BC0, "V"),
-        (0x11BE2, "X"),
-        (0x11BF0, "V"),
-        (0x11BFA, "X"),
         (0x11C00, "V"),
         (0x11C09, "X"),
         (0x11C0A, "V"),
@@ -6305,12 +6201,12 @@ def _seg_59() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x11F12, "V"),
         (0x11F3B, "X"),
         (0x11F3E, "V"),
-        (0x11F5B, "X"),
     ]
 
 
-def _seg_60() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+def _seg_59() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
     return [
+        (0x11F5A, "X"),
         (0x11FB0, "V"),
         (0x11FB1, "X"),
         (0x11FC0, "V"),
@@ -6329,12 +6225,8 @@ def _seg_60() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x13430, "X"),
         (0x13440, "V"),
         (0x13456, "X"),
-        (0x13460, "V"),
-        (0x143FB, "X"),
         (0x14400, "V"),
         (0x14647, "X"),
-        (0x16100, "V"),
-        (0x1613A, "X"),
         (0x16800, "V"),
         (0x16A39, "X"),
         (0x16A40, "V"),
@@ -6359,8 +6251,6 @@ def _seg_60() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x16B78, "X"),
         (0x16B7D, "V"),
         (0x16B90, "X"),
-        (0x16D40, "V"),
-        (0x16D7A, "X"),
         (0x16E40, "M", "𖹠"),
         (0x16E41, "M", "𖹡"),
         (0x16E42, "M", "𖹢"),
@@ -6409,18 +6299,18 @@ def _seg_60() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x187F8, "X"),
         (0x18800, "V"),
         (0x18CD6, "X"),
-        (0x18CFF, "V"),
+        (0x18D00, "V"),
         (0x18D09, "X"),
-    ]
-
-
-def _seg_61() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1AFF0, "V"),
         (0x1AFF4, "X"),
         (0x1AFF5, "V"),
         (0x1AFFC, "X"),
         (0x1AFFD, "V"),
+    ]
+
+
+def _seg_60() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1AFFF, "X"),
         (0x1B000, "V"),
         (0x1B123, "X"),
@@ -6445,46 +6335,6 @@ def _seg_61() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1BC9C, "V"),
         (0x1BCA0, "I"),
         (0x1BCA4, "X"),
-        (0x1CC00, "V"),
-        (0x1CCD6, "M", "a"),
-        (0x1CCD7, "M", "b"),
-        (0x1CCD8, "M", "c"),
-        (0x1CCD9, "M", "d"),
-        (0x1CCDA, "M", "e"),
-        (0x1CCDB, "M", "f"),
-        (0x1CCDC, "M", "g"),
-        (0x1CCDD, "M", "h"),
-        (0x1CCDE, "M", "i"),
-        (0x1CCDF, "M", "j"),
-        (0x1CCE0, "M", "k"),
-        (0x1CCE1, "M", "l"),
-        (0x1CCE2, "M", "m"),
-        (0x1CCE3, "M", "n"),
-        (0x1CCE4, "M", "o"),
-        (0x1CCE5, "M", "p"),
-        (0x1CCE6, "M", "q"),
-        (0x1CCE7, "M", "r"),
-        (0x1CCE8, "M", "s"),
-        (0x1CCE9, "M", "t"),
-        (0x1CCEA, "M", "u"),
-        (0x1CCEB, "M", "v"),
-        (0x1CCEC, "M", "w"),
-        (0x1CCED, "M", "x"),
-        (0x1CCEE, "M", "y"),
-        (0x1CCEF, "M", "z"),
-        (0x1CCF0, "M", "0"),
-        (0x1CCF1, "M", "1"),
-        (0x1CCF2, "M", "2"),
-        (0x1CCF3, "M", "3"),
-        (0x1CCF4, "M", "4"),
-        (0x1CCF5, "M", "5"),
-        (0x1CCF6, "M", "6"),
-        (0x1CCF7, "M", "7"),
-        (0x1CCF8, "M", "8"),
-        (0x1CCF9, "M", "9"),
-        (0x1CCFA, "X"),
-        (0x1CD00, "V"),
-        (0x1CEB4, "X"),
         (0x1CF00, "V"),
         (0x1CF2E, "X"),
         (0x1CF30, "V"),
@@ -6504,7 +6354,7 @@ def _seg_61() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D163, "M", "𝅘𝅥𝅱"),
         (0x1D164, "M", "𝅘𝅥𝅲"),
         (0x1D165, "V"),
-        (0x1D173, "I"),
+        (0x1D173, "X"),
         (0x1D17B, "V"),
         (0x1D1BB, "M", "𝆹𝅥"),
         (0x1D1BC, "M", "𝆺𝅥"),
@@ -6516,11 +6366,6 @@ def _seg_61() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D1EB, "X"),
         (0x1D200, "V"),
         (0x1D246, "X"),
-    ]
-
-
-def _seg_62() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1D2C0, "V"),
         (0x1D2D4, "X"),
         (0x1D2E0, "V"),
@@ -6566,6 +6411,11 @@ def _seg_62() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D422, "M", "i"),
         (0x1D423, "M", "j"),
         (0x1D424, "M", "k"),
+    ]
+
+
+def _seg_61() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1D425, "M", "l"),
         (0x1D426, "M", "m"),
         (0x1D427, "M", "n"),
@@ -6621,11 +6471,6 @@ def _seg_62() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D459, "M", "l"),
         (0x1D45A, "M", "m"),
         (0x1D45B, "M", "n"),
-    ]
-
-
-def _seg_63() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1D45C, "M", "o"),
         (0x1D45D, "M", "p"),
         (0x1D45E, "M", "q"),
@@ -6671,6 +6516,11 @@ def _seg_63() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D486, "M", "e"),
         (0x1D487, "M", "f"),
         (0x1D488, "M", "g"),
+    ]
+
+
+def _seg_62() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1D489, "M", "h"),
         (0x1D48A, "M", "i"),
         (0x1D48B, "M", "j"),
@@ -6726,11 +6576,6 @@ def _seg_63() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D4C0, "M", "k"),
         (0x1D4C1, "M", "l"),
         (0x1D4C2, "M", "m"),
-    ]
-
-
-def _seg_64() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1D4C3, "M", "n"),
         (0x1D4C4, "X"),
         (0x1D4C5, "M", "p"),
@@ -6776,6 +6621,11 @@ def _seg_64() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D4ED, "M", "d"),
         (0x1D4EE, "M", "e"),
         (0x1D4EF, "M", "f"),
+    ]
+
+
+def _seg_63() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1D4F0, "M", "g"),
         (0x1D4F1, "M", "h"),
         (0x1D4F2, "M", "i"),
@@ -6831,11 +6681,6 @@ def _seg_64() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D525, "M", "h"),
         (0x1D526, "M", "i"),
         (0x1D527, "M", "j"),
-    ]
-
-
-def _seg_65() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1D528, "M", "k"),
         (0x1D529, "M", "l"),
         (0x1D52A, "M", "m"),
@@ -6881,6 +6726,11 @@ def _seg_65() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D554, "M", "c"),
         (0x1D555, "M", "d"),
         (0x1D556, "M", "e"),
+    ]
+
+
+def _seg_64() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1D557, "M", "f"),
         (0x1D558, "M", "g"),
         (0x1D559, "M", "h"),
@@ -6936,11 +6786,6 @@ def _seg_65() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D58B, "M", "f"),
         (0x1D58C, "M", "g"),
         (0x1D58D, "M", "h"),
-    ]
-
-
-def _seg_66() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1D58E, "M", "i"),
         (0x1D58F, "M", "j"),
         (0x1D590, "M", "k"),
@@ -6986,6 +6831,11 @@ def _seg_66() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D5B8, "M", "y"),
         (0x1D5B9, "M", "z"),
         (0x1D5BA, "M", "a"),
+    ]
+
+
+def _seg_65() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1D5BB, "M", "b"),
         (0x1D5BC, "M", "c"),
         (0x1D5BD, "M", "d"),
@@ -7041,11 +6891,6 @@ def _seg_66() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D5EF, "M", "b"),
         (0x1D5F0, "M", "c"),
         (0x1D5F1, "M", "d"),
-    ]
-
-
-def _seg_67() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1D5F2, "M", "e"),
         (0x1D5F3, "M", "f"),
         (0x1D5F4, "M", "g"),
@@ -7091,6 +6936,11 @@ def _seg_67() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D61C, "M", "u"),
         (0x1D61D, "M", "v"),
         (0x1D61E, "M", "w"),
+    ]
+
+
+def _seg_66() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1D61F, "M", "x"),
         (0x1D620, "M", "y"),
         (0x1D621, "M", "z"),
@@ -7146,11 +6996,6 @@ def _seg_67() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D653, "M", "x"),
         (0x1D654, "M", "y"),
         (0x1D655, "M", "z"),
-    ]
-
-
-def _seg_68() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1D656, "M", "a"),
         (0x1D657, "M", "b"),
         (0x1D658, "M", "c"),
@@ -7196,6 +7041,11 @@ def _seg_68() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D680, "M", "q"),
         (0x1D681, "M", "r"),
         (0x1D682, "M", "s"),
+    ]
+
+
+def _seg_67() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1D683, "M", "t"),
         (0x1D684, "M", "u"),
         (0x1D685, "M", "v"),
@@ -7251,11 +7101,6 @@ def _seg_68() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D6B8, "M", "ρ"),
         (0x1D6B9, "M", "θ"),
         (0x1D6BA, "M", "σ"),
-    ]
-
-
-def _seg_69() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1D6BB, "M", "τ"),
         (0x1D6BC, "M", "υ"),
         (0x1D6BD, "M", "φ"),
@@ -7301,6 +7146,11 @@ def _seg_69() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D6E6, "M", "ε"),
         (0x1D6E7, "M", "ζ"),
         (0x1D6E8, "M", "η"),
+    ]
+
+
+def _seg_68() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1D6E9, "M", "θ"),
         (0x1D6EA, "M", "ι"),
         (0x1D6EB, "M", "κ"),
@@ -7356,11 +7206,6 @@ def _seg_69() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D71E, "M", "γ"),
         (0x1D71F, "M", "δ"),
         (0x1D720, "M", "ε"),
-    ]
-
-
-def _seg_70() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1D721, "M", "ζ"),
         (0x1D722, "M", "η"),
         (0x1D723, "M", "θ"),
@@ -7406,6 +7251,11 @@ def _seg_70() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D74C, "M", "χ"),
         (0x1D74D, "M", "ψ"),
         (0x1D74E, "M", "ω"),
+    ]
+
+
+def _seg_69() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1D74F, "M", "∂"),
         (0x1D750, "M", "ε"),
         (0x1D751, "M", "θ"),
@@ -7461,11 +7311,6 @@ def _seg_70() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D784, "M", "υ"),
         (0x1D785, "M", "φ"),
         (0x1D786, "M", "χ"),
-    ]
-
-
-def _seg_71() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1D787, "M", "ψ"),
         (0x1D788, "M", "ω"),
         (0x1D789, "M", "∂"),
@@ -7511,6 +7356,11 @@ def _seg_71() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D7B1, "M", "θ"),
         (0x1D7B2, "M", "ι"),
         (0x1D7B3, "M", "κ"),
+    ]
+
+
+def _seg_70() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1D7B4, "M", "λ"),
         (0x1D7B5, "M", "μ"),
         (0x1D7B6, "M", "ν"),
@@ -7566,11 +7416,6 @@ def _seg_71() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1D7EB, "M", "9"),
         (0x1D7EC, "M", "0"),
         (0x1D7ED, "M", "1"),
-    ]
-
-
-def _seg_72() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1D7EE, "M", "2"),
         (0x1D7EF, "M", "3"),
         (0x1D7F0, "M", "4"),
@@ -7616,6 +7461,11 @@ def _seg_72() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1E034, "M", "д"),
         (0x1E035, "M", "е"),
         (0x1E036, "M", "ж"),
+    ]
+
+
+def _seg_71() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1E037, "M", "з"),
         (0x1E038, "M", "и"),
         (0x1E039, "M", "к"),
@@ -7671,11 +7521,6 @@ def _seg_72() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1E06B, "M", "ҫ"),
         (0x1E06C, "M", "ꙑ"),
         (0x1E06D, "M", "ұ"),
-    ]
-
-
-def _seg_73() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1E06E, "X"),
         (0x1E08F, "V"),
         (0x1E090, "X"),
@@ -7695,10 +7540,6 @@ def _seg_73() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1E300, "X"),
         (0x1E4D0, "V"),
         (0x1E4FA, "X"),
-        (0x1E5D0, "V"),
-        (0x1E5FB, "X"),
-        (0x1E5FF, "V"),
-        (0x1E600, "X"),
         (0x1E7E0, "V"),
         (0x1E7E7, "X"),
         (0x1E7E8, "V"),
@@ -7725,6 +7566,11 @@ def _seg_73() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1E90B, "M", "𞤭"),
         (0x1E90C, "M", "𞤮"),
         (0x1E90D, "M", "𞤯"),
+    ]
+
+
+def _seg_72() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1E90E, "M", "𞤰"),
         (0x1E90F, "M", "𞤱"),
         (0x1E910, "M", "𞤲"),
@@ -7776,11 +7622,6 @@ def _seg_73() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1EE12, "M", "ق"),
         (0x1EE13, "M", "ر"),
         (0x1EE14, "M", "ش"),
-    ]
-
-
-def _seg_74() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1EE15, "M", "ت"),
         (0x1EE16, "M", "ث"),
         (0x1EE17, "M", "خ"),
@@ -7830,6 +7671,11 @@ def _seg_74() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1EE4C, "X"),
         (0x1EE4D, "M", "ن"),
         (0x1EE4E, "M", "س"),
+    ]
+
+
+def _seg_73() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1EE4F, "M", "ع"),
         (0x1EE50, "X"),
         (0x1EE51, "M", "ص"),
@@ -7881,11 +7727,6 @@ def _seg_74() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1EE81, "M", "ب"),
         (0x1EE82, "M", "ج"),
         (0x1EE83, "M", "د"),
-    ]
-
-
-def _seg_75() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1EE84, "M", "ه"),
         (0x1EE85, "M", "و"),
         (0x1EE86, "M", "ز"),
@@ -7935,6 +7776,11 @@ def _seg_75() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1EEB6, "M", "ث"),
         (0x1EEB7, "M", "خ"),
         (0x1EEB8, "M", "ذ"),
+    ]
+
+
+def _seg_74() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1EEB9, "M", "ض"),
         (0x1EEBA, "M", "ظ"),
         (0x1EEBB, "M", "غ"),
@@ -7953,48 +7799,43 @@ def _seg_75() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1F0D0, "X"),
         (0x1F0D1, "V"),
         (0x1F0F6, "X"),
-        (0x1F101, "M", "0,"),
-        (0x1F102, "M", "1,"),
-        (0x1F103, "M", "2,"),
-        (0x1F104, "M", "3,"),
-        (0x1F105, "M", "4,"),
-        (0x1F106, "M", "5,"),
-        (0x1F107, "M", "6,"),
-        (0x1F108, "M", "7,"),
-        (0x1F109, "M", "8,"),
-        (0x1F10A, "M", "9,"),
+        (0x1F101, "3", "0,"),
+        (0x1F102, "3", "1,"),
+        (0x1F103, "3", "2,"),
+        (0x1F104, "3", "3,"),
+        (0x1F105, "3", "4,"),
+        (0x1F106, "3", "5,"),
+        (0x1F107, "3", "6,"),
+        (0x1F108, "3", "7,"),
+        (0x1F109, "3", "8,"),
+        (0x1F10A, "3", "9,"),
         (0x1F10B, "V"),
-        (0x1F110, "M", "(a)"),
-        (0x1F111, "M", "(b)"),
-        (0x1F112, "M", "(c)"),
-        (0x1F113, "M", "(d)"),
-        (0x1F114, "M", "(e)"),
-        (0x1F115, "M", "(f)"),
-        (0x1F116, "M", "(g)"),
-        (0x1F117, "M", "(h)"),
-        (0x1F118, "M", "(i)"),
-        (0x1F119, "M", "(j)"),
-        (0x1F11A, "M", "(k)"),
-        (0x1F11B, "M", "(l)"),
-        (0x1F11C, "M", "(m)"),
-        (0x1F11D, "M", "(n)"),
-        (0x1F11E, "M", "(o)"),
-        (0x1F11F, "M", "(p)"),
-        (0x1F120, "M", "(q)"),
-        (0x1F121, "M", "(r)"),
-        (0x1F122, "M", "(s)"),
-        (0x1F123, "M", "(t)"),
-        (0x1F124, "M", "(u)"),
-        (0x1F125, "M", "(v)"),
-    ]
-
-
-def _seg_76() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
-        (0x1F126, "M", "(w)"),
-        (0x1F127, "M", "(x)"),
-        (0x1F128, "M", "(y)"),
-        (0x1F129, "M", "(z)"),
+        (0x1F110, "3", "(a)"),
+        (0x1F111, "3", "(b)"),
+        (0x1F112, "3", "(c)"),
+        (0x1F113, "3", "(d)"),
+        (0x1F114, "3", "(e)"),
+        (0x1F115, "3", "(f)"),
+        (0x1F116, "3", "(g)"),
+        (0x1F117, "3", "(h)"),
+        (0x1F118, "3", "(i)"),
+        (0x1F119, "3", "(j)"),
+        (0x1F11A, "3", "(k)"),
+        (0x1F11B, "3", "(l)"),
+        (0x1F11C, "3", "(m)"),
+        (0x1F11D, "3", "(n)"),
+        (0x1F11E, "3", "(o)"),
+        (0x1F11F, "3", "(p)"),
+        (0x1F120, "3", "(q)"),
+        (0x1F121, "3", "(r)"),
+        (0x1F122, "3", "(s)"),
+        (0x1F123, "3", "(t)"),
+        (0x1F124, "3", "(u)"),
+        (0x1F125, "3", "(v)"),
+        (0x1F126, "3", "(w)"),
+        (0x1F127, "3", "(x)"),
+        (0x1F128, "3", "(y)"),
+        (0x1F129, "3", "(z)"),
         (0x1F12A, "M", "〔s〕"),
         (0x1F12B, "M", "c"),
         (0x1F12C, "M", "r"),
@@ -8040,6 +7881,11 @@ def _seg_76() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1F16D, "V"),
         (0x1F190, "M", "dj"),
         (0x1F191, "V"),
+    ]
+
+
+def _seg_75() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x1F1AE, "X"),
         (0x1F1E6, "V"),
         (0x1F200, "M", "ほか"),
@@ -8091,11 +7937,6 @@ def _seg_76() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1F23A, "M", "営"),
         (0x1F23B, "M", "配"),
         (0x1F23C, "X"),
-    ]
-
-
-def _seg_77() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x1F240, "M", "〔本〕"),
         (0x1F241, "M", "〔三〕"),
         (0x1F242, "M", "〔二〕"),
@@ -8136,9 +7977,7 @@ def _seg_77() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1F890, "V"),
         (0x1F8AE, "X"),
         (0x1F8B0, "V"),
-        (0x1F8BC, "X"),
-        (0x1F8C0, "V"),
-        (0x1F8C2, "X"),
+        (0x1F8B2, "X"),
         (0x1F900, "V"),
         (0x1FA54, "X"),
         (0x1FA60, "V"),
@@ -8146,18 +7985,26 @@ def _seg_77() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x1FA70, "V"),
         (0x1FA7D, "X"),
         (0x1FA80, "V"),
-        (0x1FA8A, "X"),
-        (0x1FA8F, "V"),
-        (0x1FAC7, "X"),
+        (0x1FA89, "X"),
+    ]
+
+
+def _seg_76() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1FA90, "V"),
+        (0x1FABE, "X"),
+        (0x1FABF, "V"),
+        (0x1FAC6, "X"),
         (0x1FACE, "V"),
-        (0x1FADD, "X"),
-        (0x1FADF, "V"),
-        (0x1FAEA, "X"),
+        (0x1FADC, "X"),
+        (0x1FAE0, "V"),
+        (0x1FAE9, "X"),
         (0x1FAF0, "V"),
         (0x1FAF9, "X"),
         (0x1FB00, "V"),
         (0x1FB93, "X"),
         (0x1FB94, "V"),
+        (0x1FBCB, "X"),
         (0x1FBF0, "M", "0"),
         (0x1FBF1, "M", "1"),
         (0x1FBF2, "M", "2"),
@@ -8196,11 +8043,6 @@ def _seg_77() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2F80C, "M", "㒞"),
         (0x2F80D, "M", "𠘺"),
         (0x2F80E, "M", "免"),
-    ]
-
-
-def _seg_78() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x2F80F, "M", "兔"),
         (0x2F810, "M", "兤"),
         (0x2F811, "M", "具"),
@@ -8249,6 +8091,11 @@ def _seg_78() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2F83E, "M", "呈"),
         (0x2F83F, "M", "周"),
         (0x2F840, "M", "咢"),
+    ]
+
+
+def _seg_77() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x2F841, "M", "哶"),
         (0x2F842, "M", "唐"),
         (0x2F843, "M", "啓"),
@@ -8287,7 +8134,7 @@ def _seg_78() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2F865, "M", "姘"),
         (0x2F866, "M", "婦"),
         (0x2F867, "M", "㛮"),
-        (0x2F868, "M", "㛼"),
+        (0x2F868, "X"),
         (0x2F869, "M", "嬈"),
         (0x2F86A, "M", "嬾"),
         (0x2F86C, "M", "𡧈"),
@@ -8298,14 +8145,9 @@ def _seg_78() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2F871, "M", "𡬘"),
         (0x2F872, "M", "寿"),
         (0x2F873, "M", "将"),
-        (0x2F874, "M", "当"),
+        (0x2F874, "X"),
         (0x2F875, "M", "尢"),
         (0x2F876, "M", "㞁"),
-    ]
-
-
-def _seg_79() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x2F877, "M", "屠"),
         (0x2F878, "M", "屮"),
         (0x2F879, "M", "峀"),
@@ -8354,6 +8196,11 @@ def _seg_79() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2F8A6, "M", "慈"),
         (0x2F8A7, "M", "慌"),
         (0x2F8A8, "M", "慎"),
+    ]
+
+
+def _seg_78() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x2F8A9, "M", "慌"),
         (0x2F8AA, "M", "慺"),
         (0x2F8AB, "M", "憎"),
@@ -8406,11 +8253,6 @@ def _seg_79() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2F8DA, "M", "朡"),
         (0x2F8DB, "M", "杞"),
         (0x2F8DC, "M", "杓"),
-    ]
-
-
-def _seg_80() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x2F8DD, "M", "𣏃"),
         (0x2F8DE, "M", "㭉"),
         (0x2F8DF, "M", "柺"),
@@ -8459,6 +8301,11 @@ def _seg_80() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2F90A, "M", "㴳"),
         (0x2F90B, "M", "滋"),
         (0x2F90C, "M", "滇"),
+    ]
+
+
+def _seg_79() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x2F90D, "M", "𣻑"),
         (0x2F90E, "M", "淹"),
         (0x2F90F, "M", "潮"),
@@ -8477,7 +8324,7 @@ def _seg_80() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2F91C, "M", "煅"),
         (0x2F91D, "M", "𤉣"),
         (0x2F91E, "M", "熜"),
-        (0x2F91F, "M", "𤎫"),
+        (0x2F91F, "X"),
         (0x2F920, "M", "爨"),
         (0x2F921, "M", "爵"),
         (0x2F922, "M", "牐"),
@@ -8511,11 +8358,6 @@ def _seg_80() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2F93F, "M", "䀈"),
         (0x2F940, "M", "直"),
         (0x2F941, "M", "𥃳"),
-    ]
-
-
-def _seg_81() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x2F942, "M", "𥃲"),
         (0x2F943, "M", "𥄙"),
         (0x2F944, "M", "𥄳"),
@@ -8543,7 +8385,7 @@ def _seg_81() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2F95B, "M", "穏"),
         (0x2F95C, "M", "𥥼"),
         (0x2F95D, "M", "𥪧"),
-        (0x2F95F, "M", "竮"),
+        (0x2F95F, "X"),
         (0x2F960, "M", "䈂"),
         (0x2F961, "M", "𥮫"),
         (0x2F962, "M", "篆"),
@@ -8564,6 +8406,11 @@ def _seg_81() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2F971, "M", "䌴"),
         (0x2F972, "M", "𦈨"),
         (0x2F973, "M", "𦉇"),
+    ]
+
+
+def _seg_80() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x2F974, "M", "䍙"),
         (0x2F975, "M", "𦋙"),
         (0x2F976, "M", "罺"),
@@ -8616,11 +8463,6 @@ def _seg_81() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2F9A5, "M", "𦵫"),
         (0x2F9A6, "M", "𦳕"),
         (0x2F9A7, "M", "䔫"),
-    ]
-
-
-def _seg_82() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x2F9A8, "M", "蓱"),
         (0x2F9A9, "M", "蓳"),
         (0x2F9AA, "M", "蔖"),
@@ -8644,7 +8486,7 @@ def _seg_82() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2F9BC, "M", "蜨"),
         (0x2F9BD, "M", "蝫"),
         (0x2F9BE, "M", "螆"),
-        (0x2F9BF, "M", "䗗"),
+        (0x2F9BF, "X"),
         (0x2F9C0, "M", "蟡"),
         (0x2F9C1, "M", "蠁"),
         (0x2F9C2, "M", "䗹"),
@@ -8669,6 +8511,11 @@ def _seg_82() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2F9D5, "M", "賁"),
         (0x2F9D6, "M", "贛"),
         (0x2F9D7, "M", "起"),
+    ]
+
+
+def _seg_81() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
         (0x2F9D8, "M", "𧼯"),
         (0x2F9D9, "M", "𠠄"),
         (0x2F9DA, "M", "跋"),
@@ -8721,11 +8568,6 @@ def _seg_82() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
         (0x2FA0A, "M", "鬒"),
         (0x2FA0B, "M", "鱀"),
         (0x2FA0C, "M", "鳽"),
-    ]
-
-
-def _seg_83() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
-    return [
         (0x2FA0D, "M", "䳎"),
         (0x2FA0E, "M", "䳭"),
         (0x2FA0F, "M", "鵧"),
@@ -8836,6 +8678,4 @@ uts46data = tuple(
     + _seg_79()
     + _seg_80()
     + _seg_81()
-    + _seg_82()
-    + _seg_83()
 )  # type: Tuple[Union[Tuple[int, str], Tuple[int, str, str]], ...]
diff --git a/contrib/python/idna/py3/ya.make b/contrib/python/idna/py3/ya.make
index 98acf283f7..24aa33c733 100644
--- a/contrib/python/idna/py3/ya.make
+++ b/contrib/python/idna/py3/ya.make
@@ -2,7 +2,7 @@
 
 PY3_LIBRARY()
 
-VERSION(3.9)
+VERSION(3.10)
 
 LICENSE(BSD-3-Clause)