event-reduce 7.4.2__tar.gz

event_reduce-7.4.2/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: event-reduce
+Version: 7.4.2
+Summary: Update live query results from database change events without re-running the query.
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pubkey/event-reduce
+Project-URL: Repository, https://github.com/pubkey/event-reduce
+Keywords: live-query,reactive,realtime,database,bdd
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# event-reduce (Python)
+
+Python implementation of the [EventReduce algorithm](https://github.com/pubkey/event-reduce).
+It takes the previous results of a query and a change event of the database
+and calculates the new results **in memory, without running the query over the database again**.
+
+It uses the BDD that the [JavaScript implementation](../javascript/) created,
+so both always decide on the same action. It needs Python 3.10 or newer and has no dependencies.
+
+## Installation
+
+```sh
+pip install event-reduce
+```
+
+## Usage
+
+```python
+from event_reduce import (
+    ActionName,
+    ChangeEvent,
+    StateResolveFunctionInput,
+    calculate_action_name,
+    dict_query_params,
+    run_action,
+)
+
+
+def compare(a, b):
+    # must never return 0 for two different documents, so sort by the primary key last
+    if a["age"] != b["age"]:
+        return -1 if a["age"] < b["age"] else 1
+    return -1 if a["id"] < b["id"] else 1
+
+
+# SELECT * FROM users WHERE age > 18 ORDER BY age, id LIMIT 10
+query_params = dict_query_params(
+    primary_key="id",
+    sort_fields=["age", "id"],
+    query_matcher=lambda doc: doc["age"] > 18,
+    sort_comparator=compare,
+    limit=10,
+)
+
+results = [{"id": "a", "age": 20}, {"id": "b", "age": 30}]
+
+# a change event from the change stream of your database
+change_event = ChangeEvent.insert("c", {"id": "c", "age": 25})
+
+action = calculate_action_name(StateResolveFunctionInput(query_params, change_event, results))
+if action == ActionName.RUN_FULL_QUERY_AGAIN:
+    results = run_query_on_database()  # EventReduce could not optimize this event
+else:
+    run_action(action, query_params, change_event, results)
+    # -> [a, c, b]
+```
+
+`dict_query_params()` is for dict documents, like the `primaryKey` and `sortFields` of the JavaScript implementation.
+The sort fields can be dot-separated paths like `"address.city"`.
+For other documents, create the `QueryParams` with a `get_document_id` function
+and a `sort_fields_changed(previous, doc)` function that returns true if a sort field changed.
+
+### Key document map
+
+For big result sets, pass a dict from the id to the document as `key_document_map`
+to both `StateResolveFunctionInput` and `run_action()`.
+It is used to check whether a document is in the results without scanning them,
+and `run_action()` keeps it in sync with the results.
+
+### Differences to the JavaScript implementation
+
+- Change events are created with `ChangeEvent.insert()`, `ChangeEvent.update()` and `ChangeEvent.delete()`.
+- The names are snake_case, `ActionName` and `StateName` are enums whose values are the JavaScript names.
+- `run_action()` raises an `EventReduceError` for `RUN_FULL_QUERY_AGAIN` and `UNKNOWN_ACTION`.
+  `ALWAYS_WRONG` is only used by the truth-table generator and raises like `UNKNOWN_ACTION`.
+
+## Result window buffer
+
+For a query with a limit or a skip, EventReduce returns `RUN_FULL_QUERY_AGAIN` when a row has to move into the result window that is not in the previous results:
+the row after the window (when a row leaves a full window) or the last skipped row (when a row is added in front of the window).
+The result window buffer avoids most of these full queries: it keeps `limit_buffer_size` rows after the window and `skip_buffer_size` skipped rows before it in memory.
+It works like the [result window buffer of the JavaScript implementation](../docs/result-window-buffer.md),
+which explains how it works, how to choose the buffer sizes and has measurements.
+
+```python
+from event_reduce import ResultWindowBuffer, get_recommended_result_window_buffer_size
+
+# recommended size: about log2(limit), at most 30
+size = get_recommended_result_window_buffer_size(query_params.limit)
+buffer = ResultWindowBuffer(query_params, limit_buffer_size=size, skip_buffer_size=size)
+# run the query with the skip and limit of the buffer
+buffer.reset(run_query(buffer.query()))
+# the rows of the original skip and limit
+results = buffer.results()
+
+# on new change events
+result = buffer.apply_change_events(change_events)
+if result.run_full_query_again:
+    buffer.reset(run_query(buffer.query()))
+    results = buffer.results()
+elif result.changed:
+    results = result.results
+```
+
+`query()` returns the `skip` and `limit` to run the query with, `limit` is None if all rows after the skip are needed.
+`math.inf` as a buffer size keeps all rows on that side, like `Infinity` in JavaScript.
+
+## Development
+
+```sh
+pip install pytest ruff mypy
+pytest
+ruff check . && ruff format --check . && mypy src
+```
+
+The BDD is generated by the truth-table generator of the JavaScript implementation,
+which also writes `src/event_reduce/bdd_generated.py`.
+The tests run the [shared test suite](../test-suite/), the same tests as all other implementations.
+
+## Who uses EventReduce
+
+[RxDB](https://rxdb.info/), the local-first database, uses EventReduce for its live queries since [version 9.0.0](https://rxdb.info/releases/9.0.0.html), where it is enabled by default.
+When an app subscribes to a query, RxDB keeps the results up to date by running each write event through EventReduce,
+and only queries the storage again when EventReduce returns `RUN_FULL_QUERY_AGAIN`.

event_reduce-7.4.2/README.md

@@ -0,0 +1,124 @@
+# event-reduce (Python)
+
+Python implementation of the [EventReduce algorithm](https://github.com/pubkey/event-reduce).
+It takes the previous results of a query and a change event of the database
+and calculates the new results **in memory, without running the query over the database again**.
+
+It uses the BDD that the [JavaScript implementation](../javascript/) created,
+so both always decide on the same action. It needs Python 3.10 or newer and has no dependencies.
+
+## Installation
+
+```sh
+pip install event-reduce
+```
+
+## Usage
+
+```python
+from event_reduce import (
+    ActionName,
+    ChangeEvent,
+    StateResolveFunctionInput,
+    calculate_action_name,
+    dict_query_params,
+    run_action,
+)
+
+
+def compare(a, b):
+    # must never return 0 for two different documents, so sort by the primary key last
+    if a["age"] != b["age"]:
+        return -1 if a["age"] < b["age"] else 1
+    return -1 if a["id"] < b["id"] else 1
+
+
+# SELECT * FROM users WHERE age > 18 ORDER BY age, id LIMIT 10
+query_params = dict_query_params(
+    primary_key="id",
+    sort_fields=["age", "id"],
+    query_matcher=lambda doc: doc["age"] > 18,
+    sort_comparator=compare,
+    limit=10,
+)
+
+results = [{"id": "a", "age": 20}, {"id": "b", "age": 30}]
+
+# a change event from the change stream of your database
+change_event = ChangeEvent.insert("c", {"id": "c", "age": 25})
+
+action = calculate_action_name(StateResolveFunctionInput(query_params, change_event, results))
+if action == ActionName.RUN_FULL_QUERY_AGAIN:
+    results = run_query_on_database()  # EventReduce could not optimize this event
+else:
+    run_action(action, query_params, change_event, results)
+    # -> [a, c, b]
+```
+
+`dict_query_params()` is for dict documents, like the `primaryKey` and `sortFields` of the JavaScript implementation.
+The sort fields can be dot-separated paths like `"address.city"`.
+For other documents, create the `QueryParams` with a `get_document_id` function
+and a `sort_fields_changed(previous, doc)` function that returns true if a sort field changed.
+
+### Key document map
+
+For big result sets, pass a dict from the id to the document as `key_document_map`
+to both `StateResolveFunctionInput` and `run_action()`.
+It is used to check whether a document is in the results without scanning them,
+and `run_action()` keeps it in sync with the results.
+
+### Differences to the JavaScript implementation
+
+- Change events are created with `ChangeEvent.insert()`, `ChangeEvent.update()` and `ChangeEvent.delete()`.
+- The names are snake_case, `ActionName` and `StateName` are enums whose values are the JavaScript names.
+- `run_action()` raises an `EventReduceError` for `RUN_FULL_QUERY_AGAIN` and `UNKNOWN_ACTION`.
+  `ALWAYS_WRONG` is only used by the truth-table generator and raises like `UNKNOWN_ACTION`.
+
+## Result window buffer
+
+For a query with a limit or a skip, EventReduce returns `RUN_FULL_QUERY_AGAIN` when a row has to move into the result window that is not in the previous results:
+the row after the window (when a row leaves a full window) or the last skipped row (when a row is added in front of the window).
+The result window buffer avoids most of these full queries: it keeps `limit_buffer_size` rows after the window and `skip_buffer_size` skipped rows before it in memory.
+It works like the [result window buffer of the JavaScript implementation](../docs/result-window-buffer.md),
+which explains how it works, how to choose the buffer sizes and has measurements.
+
+```python
+from event_reduce import ResultWindowBuffer, get_recommended_result_window_buffer_size
+
+# recommended size: about log2(limit), at most 30
+size = get_recommended_result_window_buffer_size(query_params.limit)
+buffer = ResultWindowBuffer(query_params, limit_buffer_size=size, skip_buffer_size=size)
+# run the query with the skip and limit of the buffer
+buffer.reset(run_query(buffer.query()))
+# the rows of the original skip and limit
+results = buffer.results()
+
+# on new change events
+result = buffer.apply_change_events(change_events)
+if result.run_full_query_again:
+    buffer.reset(run_query(buffer.query()))
+    results = buffer.results()
+elif result.changed:
+    results = result.results
+```
+
+`query()` returns the `skip` and `limit` to run the query with, `limit` is None if all rows after the skip are needed.
+`math.inf` as a buffer size keeps all rows on that side, like `Infinity` in JavaScript.
+
+## Development
+
+```sh
+pip install pytest ruff mypy
+pytest
+ruff check . && ruff format --check . && mypy src
+```
+
+The BDD is generated by the truth-table generator of the JavaScript implementation,
+which also writes `src/event_reduce/bdd_generated.py`.
+The tests run the [shared test suite](../test-suite/), the same tests as all other implementations.
+
+## Who uses EventReduce
+
+[RxDB](https://rxdb.info/), the local-first database, uses EventReduce for its live queries since [version 9.0.0](https://rxdb.info/releases/9.0.0.html), where it is enabled by default.
+When an app subscribes to a query, RxDB keeps the results up to date by running each write event through EventReduce,
+and only queries the storage again when EventReduce returns `RUN_FULL_QUERY_AGAIN`.

event_reduce-7.4.2/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=69"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "event-reduce"
+version = "7.4.2"
+description = "Update live query results from database change events without re-running the query."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+keywords = ["live-query", "reactive", "realtime", "database", "bdd"]
+
+[project.urls]
+Homepage = "https://github.com/pubkey/event-reduce"
+Repository = "https://github.com/pubkey/event-reduce"
+
+[tool.setuptools.package-data]
+event_reduce = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP", "B"]
+
+[tool.ruff.lint.per-file-ignores]
+# generated, the packed BDD string is one long line
+"src/event_reduce/bdd_generated.py" = ["E501"]
+
+[tool.mypy]
+strict = true
+python_version = "3.10"

event_reduce-7.4.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

event_reduce-7.4.2/src/event_reduce/__init__.py

@@ -0,0 +1,89 @@
+"""
+EventReduce: update live query results from change events without re-running the query.
+
+Only the BDD that the JavaScript implementation generated is used, it is not created or optimized here.
+"""
+
+from __future__ import annotations
+
+from typing import Any, TypeVar
+
+from .actions import ACTION_FUNCTION_LIST, ORDERED_ACTION_LIST, ActionFunction
+from .bdd import resolve_input
+from .bdd_generated import PACKED_BDD
+from .result_window_buffer import (
+    ResultWindowBuffer,
+    ResultWindowBufferChangeResult,
+    ResultWindowBufferQuery,
+    ResultWindowBufferResult,
+    get_recommended_result_window_buffer_size,
+)
+from .states import ORDERED_STATE_LIST, get_state_set, resolve_state
+from .types import (
+    ActionName,
+    ChangeEvent,
+    EventReduceError,
+    QueryParams,
+    ResultKeyDocumentMap,
+    StateName,
+    StateResolveFunctionInput,
+    WriteOperation,
+)
+from .util import dict_query_params, get_property
+
+D = TypeVar("D")
+
+
+def calculate_action_name(input: StateResolveFunctionInput[Any]) -> ActionName:
+    """
+    Returns the action that transforms the previous results into the new results.
+    If it is RUN_FULL_QUERY_AGAIN, the query must be run over the database again.
+    """
+    return ORDERED_ACTION_LIST[resolve_input(input)]
+
+
+def run_action(
+    action: ActionName,
+    query_params: QueryParams[D],
+    change_event: ChangeEvent[D],
+    previous_results: list[D],
+    key_document_map: dict[str, D] | None = None,
+) -> list[D]:
+    """
+    Applies the action to the results.
+    For performance reasons, it mutates previous_results and the key_document_map
+    and returns the mutated results.
+    Raises an EventReduceError for RUN_FULL_QUERY_AGAIN and UNKNOWN_ACTION.
+    """
+    ACTION_FUNCTION_LIST[ORDERED_ACTION_LIST.index(action)](
+        StateResolveFunctionInput(query_params, change_event, previous_results, key_document_map)
+    )
+    return previous_results
+
+
+__all__ = [
+    "ORDERED_ACTION_LIST",
+    "ORDERED_STATE_LIST",
+    "PACKED_BDD",
+    "ActionFunction",
+    "ActionName",
+    "ChangeEvent",
+    "EventReduceError",
+    "QueryParams",
+    "ResultKeyDocumentMap",
+    "ResultWindowBuffer",
+    "ResultWindowBufferChangeResult",
+    "ResultWindowBufferQuery",
+    "ResultWindowBufferResult",
+    "StateName",
+    "StateResolveFunctionInput",
+    "WriteOperation",
+    "calculate_action_name",
+    "dict_query_params",
+    "get_property",
+    "get_recommended_result_window_buffer_size",
+    "get_state_set",
+    "resolve_input",
+    "resolve_state",
+    "run_action",
+]

event_reduce-7.4.2/src/event_reduce/actions.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from .types import ActionName, EventReduceError, StateResolveFunctionInput
+from .util import index_of_document_id, push_at_sort_position
+
+ActionFunction = Callable[[StateResolveFunctionInput[Any]], None]
+"""For performance reasons, action functions mutate the results and the key document map of the input."""
+
+ORDERED_ACTION_LIST: list[ActionName] = list(ActionName)
+"""All actions, in the same order as the JavaScript implementation. The BDD references the actions by their index."""
+
+
+def _find_index_of_changed_doc(input: StateResolveFunctionInput[Any]) -> int:
+    """Returns the index of the changed document inside of the previous results or -1."""
+    id = input.change_event.id
+    if input.key_document_map is not None and id not in input.key_document_map:
+        return -1
+    return index_of_document_id(input.query_params, input.previous_results, id)
+
+
+def _changed_doc(input: StateResolveFunctionInput[Any]) -> Any:
+    """The new document of the change event. Only the BDD knows that it exists for the given action."""
+    doc = input.change_event.doc
+    if doc is None:
+        raise EventReduceError("UNK_ACT")
+    return doc
+
+
+def _add_to_map(input: StateResolveFunctionInput[Any], doc: Any) -> None:
+    if input.key_document_map is not None:
+        input.key_document_map[input.change_event.id] = doc
+
+
+def _remove_from_map(input: StateResolveFunctionInput[Any], id: str) -> None:
+    if input.key_document_map is not None:
+        input.key_document_map.pop(id, None)
+
+
+def do_nothing(input: StateResolveFunctionInput[Any]) -> None:
+    pass
+
+
+def insert_first(input: StateResolveFunctionInput[Any]) -> None:
+    doc = _changed_doc(input)
+    input.previous_results.insert(0, doc)
+    _add_to_map(input, doc)
+
+
+def insert_last(input: StateResolveFunctionInput[Any]) -> None:
+    doc = _changed_doc(input)
+    input.previous_results.append(doc)
+    _add_to_map(input, doc)
+
+
+def remove_first_item(input: StateResolveFunctionInput[Any]) -> None:
+    if not input.previous_results:
+        return
+    first = input.previous_results.pop(0)
+    _remove_from_map(input, input.query_params.get_document_id(first))
+
+
+def remove_last_item(input: StateResolveFunctionInput[Any]) -> None:
+    if not input.previous_results:
+        return
+    last = input.previous_results.pop()
+    _remove_from_map(input, input.query_params.get_document_id(last))
+
+
+def remove_first_insert_last(input: StateResolveFunctionInput[Any]) -> None:
+    remove_first_item(input)
+    insert_last(input)
+
+
+def remove_last_insert_first(input: StateResolveFunctionInput[Any]) -> None:
+    remove_last_item(input)
+    insert_first(input)
+
+
+def remove_first_insert_first(input: StateResolveFunctionInput[Any]) -> None:
+    remove_first_item(input)
+    insert_first(input)
+
+
+def remove_last_insert_last(input: StateResolveFunctionInput[Any]) -> None:
+    remove_last_item(input)
+    insert_last(input)
+
+
+def remove_existing(input: StateResolveFunctionInput[Any]) -> None:
+    index = _find_index_of_changed_doc(input)
+    _remove_from_map(input, input.change_event.id)
+    if index >= 0:
+        del input.previous_results[index]
+
+
+def replace_existing(input: StateResolveFunctionInput[Any]) -> None:
+    index = _find_index_of_changed_doc(input)
+    if index >= 0:
+        doc = _changed_doc(input)
+        input.previous_results[index] = doc
+        _add_to_map(input, doc)
+
+
+def insert_at_sort_position(input: StateResolveFunctionInput[Any]) -> None:
+    doc = _changed_doc(input)
+    id = input.change_event.id
+    key_document_map = input.key_document_map
+    # If document is already in results,
+    # we cannot add it again because it would throw on non-deterministic ordering.
+    if key_document_map is not None:
+        if id in key_document_map:
+            return
+        key_document_map[id] = doc
+    elif index_of_document_id(input.query_params, input.previous_results, id) >= 0:
+        return
+    push_at_sort_position(input.previous_results, doc, input.query_params.sort_comparator)
+
+
+def remove_existing_and_insert_at_sort_position(input: StateResolveFunctionInput[Any]) -> None:
+    remove_existing(input)
+    insert_at_sort_position(input)
+
+
+def _insert_at_sort_position_and_remove(input: StateResolveFunctionInput[Any], remove: ActionFunction) -> None:
+    length_before = len(input.previous_results)
+    insert_at_sort_position(input)
+    # insert_at_sort_position() does nothing if the document is already in the results
+    if len(input.previous_results) > length_before:
+        remove(input)
+
+
+def insert_at_sort_position_remove_last(input: StateResolveFunctionInput[Any]) -> None:
+    """
+    Inserts the document at its sort position and then removes the last document.
+    Used when the limit was reached and the new document
+    sorts in between the first and the last document,
+    so the previous last document is pushed out of the results.
+    """
+    _insert_at_sort_position_and_remove(input, remove_last_item)
+
+
+def insert_at_sort_position_remove_first(input: StateResolveFunctionInput[Any]) -> None:
+    """
+    Inserts the document at its sort position and then removes the first document.
+    Used when a document moves out of the skipped documents into the results,
+    so the previous first document is pushed into the skipped documents.
+    """
+    _insert_at_sort_position_and_remove(input, remove_first_item)
+
+
+def run_full_query_again(input: StateResolveFunctionInput[Any]) -> None:
+    raise EventReduceError("RUN_FULL")
+
+
+def unknown_action(input: StateResolveFunctionInput[Any]) -> None:
+    raise EventReduceError("UNK_ACT")
+
+
+ACTION_FUNCTION_LIST: list[ActionFunction] = [
+    do_nothing,
+    insert_first,
+    insert_last,
+    remove_first_item,
+    remove_last_item,
+    remove_first_insert_last,
+    remove_last_insert_first,
+    remove_first_insert_first,
+    remove_last_insert_last,
+    remove_existing,
+    replace_existing,
+    # alwaysWrong is only used by the truth-table generator and never returned by the BDD
+    unknown_action,
+    insert_at_sort_position,
+    remove_existing_and_insert_at_sort_position,
+    insert_at_sort_position_remove_last,
+    insert_at_sort_position_remove_first,
+    run_full_query_again,
+    unknown_action,
+]
+"""The action functions in the same order as ORDERED_ACTION_LIST."""

event_reduce-7.4.2/src/event_reduce/bdd.py

@@ -0,0 +1,38 @@
+"""
+Resolves the action with the BDD of the JavaScript implementation.
+Only the already generated BDD is used, it is not created or optimized here.
+
+The BDD is a PackedBdd of the binary-decision-diagram npm package,
+bdd_generated.PACKED_BDD holds its decoded entries.
+
+Layout of the entries:
+- Every non-leaf node takes three consecutive entries: [level, ref0, ref1]
+  - level is the index of the state function in ORDERED_STATE_LIST
+  - ref0 is followed when the state is false, ref1 when it is true
+- The node with the id x starts at index 3 * x, the root node has the id 0.
+- With n = len(entries) / 3, a reference r < n points to the node with the id r,
+  r >= n is a leaf with the action index r - n in ORDERED_ACTION_LIST.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .bdd_generated import PACKED_BDD
+from .states import STATE_RESOLVE_FUNCTION_BY_INDEX
+from .types import StateResolveFunctionInput
+
+_NODE_COUNT = len(PACKED_BDD) // 3
+
+
+def resolve_input(input: StateResolveFunctionInput[Any]) -> int:
+    """Walks the BDD and returns the index of the action in ORDERED_ACTION_LIST."""
+    bdd = PACKED_BDD
+    fns = STATE_RESOLVE_FUNCTION_BY_INDEX
+    n = _NODE_COUNT
+    i = 0
+    while True:
+        ref = bdd[i + 2] if fns[bdd[i]](input) else bdd[i + 1]
+        if ref >= n:
+            return ref - n
+        i = ref * 3

event_reduce-7.4.2/src/event_reduce/bdd_generated.py

@@ -0,0 +1,4 @@
+# Code generated by the truth-table-generator of the JavaScript implementation. DO NOT EDIT.
+# Run `npm run optimize-bdd` in ./javascript instead.
+
+PACKED_BDD: tuple[int, ...] = (1, 1, 2, 0, 3, 4, 17, 5, 6, 6, 7, 92, 17, 92, 8, 6, 9, 92, 6, 10, 11, 11, 12, 13, 6, 14, 15, 11, 16, 13, 11, 17, 18, 5, 93, 19, 5, 92, 20, 7, 21, 108, 5, 22, 23, 5, 93, 108, 5, 92, 24, 5, 22, 25, 5, 26, 27, 16, 108, 92, 12, 92, 28, 8, 29, 95, 7, 30, 31, 7, 32, 33, 10, 34, 20, 10, 35, 36, 10, 37, 38, 10, 37, 39, 7, 40, 41, 9, 101, 96, 15, 42, 94, 15, 43, 92, 15, 44, 94, 15, 45, 92, 7, 46, 47, 7, 48, 49, 12, 23, 50, 8, 51, 52, 7, 53, 54, 7, 55, 56, 16, 92, 95, 16, 92, 108, 14, 104, 93, 4, 57, 97, 14, 104, 108, 4, 58, 108, 15, 59, 92, 15, 60, 92, 15, 61, 94, 15, 62, 92, 7, 63, 64, 9, 102, 100, 9, 99, 97, 8, 65, 66, 8, 67, 68, 8, 69, 70, 8, 71, 72, 14, 106, 98, 14, 106, 108, 14, 92, 40, 4, 73, 41, 14, 104, 19, 4, 74, 19, 15, 75, 76, 15, 77, 41, 9, 105, 78, 9, 79, 97, 9, 80, 81, 9, 82, 108, 9, 83, 84, 9, 85, 108, 15, 86, 108, 9, 71, 108, 14, 92, 41, 14, 106, 19, 14, 87, 19, 16, 94, 97, 4, 88, 19, 15, 89, 100, 15, 90, 97, 15, 105, 108, 15, 89, 108, 15, 90, 108, 15, 86, 105, 15, 86, 100, 15, 86, 97, 14, 105, 108, 16, 104, 107, 14, 91, 19, 14, 105, 98, 14, 105, 99, 16, 106, 107)  # fmt: skip