diff --git a/src/part1/constants.py b/src/part1/constants.py
index 9abfbba2..ddc08257 100644
--- a/src/part1/constants.py
+++ b/src/part1/constants.py
@@ -19,20 +19,24 @@
 # Все константы, зависящие от ёмкостей *_BITS, должны вычисляться из них.
 
 # Twitter's original Snowflake epoch: 2010-11-04 01:42:54.657 UTC.
-EPOCH_MS_DEFAULT: Final[int] = 0
+EPOCH_MS_DEFAULT: Final[int] = 1288834974657
 
 # Node identifier used when the caller does not supply one.
-NODE_ID_DEFAULT: Final[int] = 0
+NODE_ID_DEFAULT: Final[int] = 1
 
 # Width of each field, in bits.
-TIMESTAMP_BITS: Final[int] = 0
-NODE_ID_BITS: Final[int] = 0
-SEQUENCE_ID_BITS: Final[int] = 0
+TIMESTAMP_BITS: Final[int] = 41
+NODE_ID_BITS: Final[int] = 10
+SEQUENCE_ID_BITS: Final[int] = 12
 
 # Largest value each field can hold.
-TIMESTAMP_MS_MAX: Final[int] = 0
-NODE_ID_MAX: Final[int] = 0
-SEQUENCE_ID_MAX: Final[int] = 0
+TIMESTAMP_MS_MAX: Final[int] = 2**TIMESTAMP_BITS - 1
+NODE_ID_MAX: Final[int] = 2**NODE_ID_BITS - 1
+SEQUENCE_ID_MAX: Final[int] = 2**SEQUENCE_ID_BITS - 1
 
 # Здесь можно добавить собственные вспомогательные константы
 # (например, сдвиги полей при сборке идентификатора).
+
+TIMESTAMP_SHIFT: Final[int] = SEQUENCE_ID_BITS + NODE_ID_BITS
+
+NODE_ID_SHIFT: Final[int] = SEQUENCE_ID_BITS
diff --git a/src/part1/snowflake.py b/src/part1/snowflake.py
old mode 100644
new mode 100755
index d3abf050..5fa359d8
--- a/src/part1/snowflake.py
+++ b/src/part1/snowflake.py
@@ -1,85 +1,36 @@
-"""Twitter Snowflake identifier generator.
+#!/usr/bin/env python3
 
-Snowflake produces roughly time-ordered 64-bit integer identifiers without
-coordination between nodes. Each identifier packs the milliseconds elapsed
-since a custom epoch, a node identifier and a per-millisecond sequence counter
-into a single 63-bit positive integer (see ``constants`` for the layout).
+import time
 
-The public entry point is :func:`generate_snowflake_id`. It is stateless: the
-caller passes the sequence counter on every call and is responsible for
-advancing it within a millisecond and resetting it when the clock ticks over.
-
-Each packed field can be read back on its own with :func:`decode_timestamp_ms`,
-:func:`decode_node_id` and :func:`decode_sequence_id`.
-"""
-
-import time  # noqa: F401
-
-from .constants import (  # noqa: F401
+from .constants import (
     EPOCH_MS_DEFAULT,
+    NODE_ID_BITS,
     NODE_ID_DEFAULT,
     NODE_ID_MAX,
+    NODE_ID_SHIFT,
+    SEQUENCE_ID_BITS,
     SEQUENCE_ID_MAX,
     TIMESTAMP_MS_MAX,
+    TIMESTAMP_SHIFT,
 )
 
 
 def read_current_millis(epoch_ms: int) -> int:
-    """Read the number of milliseconds elapsed since the custom epoch.
-
-    Args:
-        epoch_ms: The custom epoch expressed as Unix milliseconds.
-
-    Returns:
-        The count of whole milliseconds between ``epoch_ms`` and now. May be
-        negative if ``epoch_ms`` lies in the future.
-    """
-    # TODO: реализуйте функцию
-    return 0
+    return int(time.time() * 1000) - epoch_ms
 
 
 def decode_timestamp_ms(snowflake_id: int, epoch_ms: int = EPOCH_MS_DEFAULT) -> int:
-    """Read the timestamp field out of a Snowflake identifier.
-
-    Args:
-        snowflake_id: An identifier produced against the same epoch.
-        epoch_ms: The epoch the identifier was generated against. Defaults to
-            the original Twitter epoch (2010-11-04 01:42:54.657 UTC).
-
-    Returns:
-        The absolute Unix time in milliseconds at which the identifier was
-        generated.
-    """
-    # TODO: реализуйте функцию
-    return 0
+    return (snowflake_id >> (TIMESTAMP_SHIFT)) + epoch_ms
 
 
 def decode_node_id(snowflake_id: int) -> int:
-    """Read the node identifier field out of a Snowflake identifier.
-
-    Args:
-        snowflake_id: An identifier produced by :func:`generate_snowflake_id`.
-
-    Returns:
-        The node identifier packed into ``snowflake_id``, in the range
-        ``[0, NODE_ID_MAX]``.
-    """
-    # TODO: реализуйте функцию
-    return 0
+    mask = (1 << NODE_ID_BITS) - 1
+    return (snowflake_id >> NODE_ID_SHIFT) & mask
 
 
 def decode_sequence_id(snowflake_id: int) -> int:
-    """Read the sequence counter field out of a Snowflake identifier.
-
-    Args:
-        snowflake_id: An identifier produced by :func:`generate_snowflake_id`.
-
-    Returns:
-        The per-millisecond sequence counter packed into ``snowflake_id``, in
-        the range ``[0, SEQUENCE_ID_MAX]``.
-    """
-    # TODO: реализуйте функцию
-    return 0
+    mask = (1 << SEQUENCE_ID_BITS) - 1
+    return snowflake_id & mask
 
 
 def generate_snowflake_id(
@@ -87,28 +38,22 @@ def generate_snowflake_id(
     node_id: int = NODE_ID_DEFAULT,
     epoch_ms: int = EPOCH_MS_DEFAULT,
 ) -> int | None:
-    """Build and return a Snowflake identifier for the current millisecond.
-
-    The function is stateless: the caller passes the per-millisecond sequence
-    counter explicitly. It is the caller's responsibility to increment
-    ``sequence_id`` for identifiers minted within the same millisecond and to
-    reset it once the clock advances.
-
-    Args:
-        sequence_id: The per-millisecond sequence counter, in the range
-            ``[0, SEQUENCE_ID_MAX]``.
-        node_id: The identifier of this node, in the range ``[0, NODE_ID_MAX]``.
-            Optional; defaults to ``NODE_ID_DEFAULT``.
-        epoch_ms: The start of the epoch as Unix milliseconds. Optional;
-            defaults to the original Twitter epoch (2010-11-04 01:42:54.657
-            UTC).
-
-    Returns:
-        The Snowflake identifier as a positive 63-bit integer, or ``None`` if
-        ``node_id`` is outside ``[0, NODE_ID_MAX]``, ``sequence_id`` is outside
-        ``[0, SEQUENCE_ID_MAX]``, or the elapsed time no longer fits in the
-        timestamp field (roughly 69 years after ``epoch_ms``). In each of those
-        cases an explanatory message is printed to stdout first.
-    """
-    # TODO: реализуйте функцию
-    return 0
+
+    if not (0 <= node_id <= NODE_ID_MAX):
+        print(f"node_id must be in [0, {NODE_ID_MAX}], got {node_id}")
+        return None
+
+    if not (0 <= sequence_id <= SEQUENCE_ID_MAX):
+        print(f"sequence_id must be in [0, {SEQUENCE_ID_MAX}], got {sequence_id}")
+        return None
+
+    current_millis = read_current_millis(epoch_ms)
+
+    if not (0 <= current_millis <= TIMESTAMP_MS_MAX):
+        print("overflows")
+        return None
+    return (
+        (current_millis << (TIMESTAMP_SHIFT))
+        | (node_id << NODE_ID_SHIFT)
+        | (sequence_id)
+    )
diff --git a/src/part2/cart.py b/src/part2/cart.py
index 063f9aea..83acd049 100644
--- a/src/part2/cart.py
+++ b/src/part2/cart.py
@@ -1,18 +1,10 @@
-"""Shopping-cart operations layered on top of the product store.
-
-The cart is a plain list of tuples, one :data:`CartLine` --
-``(product_id, quantity)`` -- per distinct product. Moving units between the
-store and the cart keeps the two sides in balance: :func:`add_to_cart` takes
-units out of stock, :func:`remove_from_cart` puts them back.
-
-Like the CRUD layer, the failure path never raises -- the operation prints
-an explanatory message to stdout and returns ``None``.
-"""
+# Shopping-cart operations layered on top of the product store.
 
+import sys
 from typing import Final
 
-from .crud import read_product, update_product  # noqa: F401
-from .storage import (  # noqa: F401
+from .crud import read_product, update_product
+from .storage import (
     NAME_INDEX,
     PRICE_INDEX,
     QUANTITY_INDEX,
@@ -24,7 +16,17 @@
 
 # TODO: задайте позиции полей внутри кортежа CartLine
 LINE_PRODUCT_ID_INDEX: Final = 0
-LINE_QUANTITY_INDEX: Final = 0
+LINE_QUANTITY_INDEX: Final = 1
+
+
+def find_cart_line(
+    cart: list[CartLine], product_id: int
+) -> tuple[int, CartLine] | None:
+    # Вспомогательная функция для поиска строки в корзине и её индекса.
+    for i, line in enumerate(cart):
+        if line[LINE_PRODUCT_ID_INDEX] == product_id:
+            return i, line
+    return None
 
 
 def add_to_cart(
@@ -33,28 +35,33 @@ def add_to_cart(
     product_id: int,
     quantity: int,
 ) -> CartLine | None:
-    """Move ``quantity`` units of ``product_id`` from the store into ``cart``.
-
-    The product is looked up in ``storage``. If it is missing, a message is
-    printed (by :func:`~src.part2.crud.read_product`) and nothing
-    changes. If the store holds fewer units than requested, an explanatory
-    message is printed and nothing changes. Otherwise the store record is
-    decremented by ``quantity`` and the cart line for ``product_id`` gains
-    ``quantity`` units -- a new line is created when the cart had none.
-
-    Args:
-        storage: The product store to draw stock from; modified in place on
-            success.
-        cart: The cart to add the units to; modified in place on success.
-        product_id: The identifier of the product to add.
-        quantity: Number of units to move into the cart.
-
-    Returns:
-        The cart line for ``product_id`` after the addition, or ``None``
-        when the product is unknown or the store cannot cover the request.
-    """
-    # TODO: реализуйте функцию
-    return (0, 0)
+    # Move ``quantity`` units of ``product_id`` from the store into ``cart``.
+    # 1. Поиск товара на складе
+    product = read_product(storage, product_id)
+    if product is None:
+        return None
+    # 2. Проверка доступного количества
+    available = product[QUANTITY_INDEX]
+    if available < quantity:
+        print(
+            f"not enough stock for product {product_id}: "
+            f"{available} available, {quantity} requested",
+            file=sys.stdout,
+        )
+        return None
+    # 3. Обновление склада
+    new_fields = (product[NAME_INDEX], product[PRICE_INDEX], available - quantity)
+    update_product(storage, product_id, new_fields)
+    # 4. Обновление корзины
+    cart_search = find_cart_line(cart, product_id)
+    if cart_search:
+        idx, old_line = cart_search
+        new_line: CartLine = (product_id, old_line[LINE_QUANTITY_INDEX] + quantity)
+        cart[idx] = new_line
+    else:
+        new_line = (product_id, quantity)
+        cart.append(new_line)
+    return new_line
 
 
 def remove_from_cart(
@@ -63,27 +70,36 @@ def remove_from_cart(
     product_id: int,
     quantity: int,
 ) -> CartLine | None:
-    """Move ``quantity`` units of ``product_id`` from ``cart`` back to the store.
-
-    The cart line for ``product_id`` is looked up. If there is none, a
-    message is printed and nothing changes. If the line holds fewer units
-    than requested, an explanatory message is printed and nothing changes.
-    Otherwise the cart line loses ``quantity`` units -- the line is dropped
-    when it reaches zero -- and the store record gains ``quantity`` units
-    back.
-
-    Args:
-        storage: The product store to return stock to; modified in place on
-            success.
-        cart: The cart to take the units from; modified in place on
-            success.
-        product_id: The identifier of the product to remove.
-        quantity: Number of units to move back into the store.
-
-    Returns:
-        The cart line for ``product_id`` after the removal (a quantity of
-        zero means the line was dropped), or ``None`` when the cart has no
-        line for the product or holds too few units.
-    """
-    # TODO: реализуйте функцию
-    return (0, 0)
+    # Move ``quantity`` units of ``product_id`` from ``cart`` back to the store.
+    # 1. Поиск строки в корзине
+    cart_search = find_cart_line(cart, product_id)
+    if not cart_search:
+        print(f"product {product_id} is not in the cart", file=sys.stdout)
+        return None
+
+    idx, line = cart_search
+    in_cart = line[LINE_QUANTITY_INDEX]
+    # 2. Проверка количества в корзине
+    if in_cart < quantity:
+        print(
+            f"cart holds only {in_cart} unit(s) of product {product_id}, "
+            f"cannot remove {quantity}",
+            file=sys.stdout,
+        )
+        return None
+    # 3. Проверка существования товара на складе
+    product = read_product(storage, product_id)
+    if product is None:
+        return None
+    # 4. Обновление склада и корзины
+    available = product[QUANTITY_INDEX]
+    new_fields = (product[NAME_INDEX], product[PRICE_INDEX], available + quantity)
+    update_product(storage, product_id, new_fields)
+    remaining_quantity = in_cart - quantity
+    if remaining_quantity == 0:
+        cart.pop(idx)
+        return (product_id, 0)
+    else:
+        new_line: CartLine = (product_id, remaining_quantity)
+        cart[idx] = new_line
+        return new_line
diff --git a/src/part2/crud.py b/src/part2/crud.py
index d026cbcb..ac43d730 100644
--- a/src/part2/crud.py
+++ b/src/part2/crud.py
@@ -1,79 +1,52 @@
-"""Create/read/update/delete operations over the in-memory product store.
-
-Every operation takes the store -- a list of
-:data:`~src.part2.storage.Product` tuples -- as its first argument and
-works on it in place. The failure path never raises: the operation prints
-an explanatory message to stdout and returns ``None``.
-
-The identifier of a new product is derived from the store itself
-(:func:`generate_product_id`): one past the greatest identifier in use, or
-:data:`~src.part2.storage.PRODUCT_ID_MIN` when the store is empty.
-Product names are kept unique -- :func:`create_product` refuses a name that
-is already taken.
-"""
+# Create/read/update/delete operations over the in-memory product store.
 
+import sys
 from decimal import Decimal
 
-from .storage import (  # noqa: F401
+from .storage import (
     NAME_INDEX,
     PRODUCT_ID_INDEX,
     PRODUCT_ID_MIN,
     Product,
 )
-from .utils import normalize_price  # noqa: F401
+from .utils import normalize_price
 
 
 def generate_product_id(storage: list[Product]) -> int:
-    """Choose the identifier for the next product added to ``storage``.
-
-    Args:
-        storage: The product store to inspect.
-
-    Returns:
-        One past the greatest identifier currently held in ``storage``, or
-        :data:`~src.part2.storage.PRODUCT_ID_MIN` when ``storage`` is
-        empty.
-    """
-    # TODO: реализуйте функцию
-    return 0
+    # Choose the identifier for the next product added to ``storage``.
+    if not storage:
+        return PRODUCT_ID_MIN
+    return max(p[PRODUCT_ID_INDEX] for p in storage) + 1
 
 
 def create_product(
     storage: list[Product], fields: tuple[str, Decimal, int]
 ) -> int | None:
-    """Append a new product to ``storage`` and return its new identifier.
+    # Append a new product to ``storage`` and return its new identifier.
+    name, price, quantity = fields
 
-    Args:
-        storage: The product store to append to; modified in place on
-            success.
-        fields: A ``(name, price, quantity)`` tuple describing the product.
-            ``price`` is a :class:`~decimal.Decimal` amount and is rounded
-            to the stored money precision before it is saved.
+    # Проверка уникальности имени
+    for product in storage:
+        if product[NAME_INDEX] == name:
+            print(f"product name '{name}' is already taken", file=sys.stdout)
+            return None
 
-    Returns:
-        The identifier generated for the new product, or ``None`` when a
-        product with the same name already exists. In the ``None`` case
-        ``storage`` is left unchanged and a message naming the clashing
-        name is printed.
-    """
-    # TODO: реализуйте функцию
-    return 0
+    product_id = generate_product_id(storage)
+    norm_price = normalize_price(price)
 
+    new_product: Product = (product_id, name, norm_price, quantity)
+    storage.append(new_product)
+    return product_id
 
-def read_product(storage: list[Product], product_id: int) -> Product | None:
-    """Return the product stored under ``product_id``.
 
-    Args:
-        storage: The product store to search.
-        product_id: The identifier to look up.
+def read_product(storage: list[Product], product_id: int) -> Product | None:
+    # Return the product stored under ``product_id``.
+    for product in storage:
+        if product[PRODUCT_ID_INDEX] == product_id:
+            return product
 
-    Returns:
-        The matching ``(product_id, name, price, quantity)`` record, or
-        ``None`` when no product carries that identifier (a message is
-        printed in that case).
-    """
-    # TODO: реализуйте функцию
-    return (0, "", Decimal(0), 0)
+    print(f"no product with id {product_id}", file=sys.stdout)
+    return None
 
 
 def update_product(
@@ -81,40 +54,26 @@ def update_product(
     product_id: int,
     fields: tuple[str, Decimal, int],
 ) -> Product | None:
-    """Overwrite the fields of the product stored under ``product_id``.
-
-    The identifier itself is preserved; only ``name``, ``price`` and
-    ``quantity`` are replaced.
+    # Overwrite the fields of the product stored under ``product_id``.
+    name, price, quantity = fields
 
-    Args:
-        storage: The product store to modify; the matching record is
-            replaced in place on success.
-        product_id: The identifier of the product to change.
-        fields: A ``(name, price, quantity)`` tuple with the new values.
-            ``price`` is a :class:`~decimal.Decimal` amount and is rounded
-            to the stored money precision before it is saved.
+    for i, product in enumerate(storage):
+        if product[PRODUCT_ID_INDEX] == product_id:
+            norm_price = normalize_price(price)
+            updated_product: Product = (product_id, name, norm_price, quantity)
+            storage[i] = updated_product
+            return updated_product
 
-    Returns:
-        The updated ``(product_id, name, price, quantity)`` record, or
-        ``None`` when no product carries that identifier (``storage`` is
-        left unchanged and a message is printed).
-    """
-    # TODO: реализуйте функцию
-    return (0, "", Decimal(0), 0)
+    print(f"no product with id {product_id}", file=sys.stdout)
+    return None
 
 
 def delete_product(storage: list[Product], product_id: int) -> int | None:
-    """Remove the product stored under ``product_id`` from ``storage``.
-
-    Args:
-        storage: The product store to remove from; modified in place on
-            success.
-        product_id: The identifier of the product to remove.
-
-    Returns:
-        ``product_id`` when a product was removed, or ``None`` when no
-        product carried that identifier (``storage`` is left unchanged and
-        a message is printed).
-    """
-    # TODO: реализуйте функцию
-    return 0
+    # Remove the product stored under ``product_id`` from ``storage``.
+    for i, product in enumerate(storage):
+        if product[PRODUCT_ID_INDEX] == product_id:
+            storage.pop(i)
+            return product_id
+
+    print(f"no product with id {product_id}", file=sys.stdout)
+    return None
diff --git a/src/part2/storage.py b/src/part2/storage.py
index b63d5fc7..c69abc65 100644
--- a/src/part2/storage.py
+++ b/src/part2/storage.py
@@ -1,22 +1,4 @@
-"""In-memory product store for the shop CRUD exercise.
-
-The store is deliberately primitive: a plain list of tuples, with no
-persistence, no indexing and no schema enforcement. Each element is a
-:data:`Product` record -- a ``(product_id, name, price, quantity)`` tuple
-where:
-
-* ``product_id`` -- unique positive integer key, assigned by the create
-  operation in :mod:`src.part2.crud`;
-* ``name`` -- human-readable product name, unique across the store;
-* ``price`` -- price of a single unit, held as a :class:`~decimal.Decimal`
-  amount rounded to a fixed number of decimal places (see
-  :func:`src.part2.utils.normalize_price`) so that money is never
-  subject to binary floating-point error;
-* ``quantity`` -- number of units currently in stock.
-
-Field positions are exposed as ``*_INDEX`` constants so callers never
-hard-code tuple offsets.
-"""
+# In-memory product store for the shop CRUD exercise.
 
 from decimal import Decimal
 from typing import Final
@@ -26,9 +8,9 @@
 
 # TODO: задайте позиции полей внутри кортежа Product
 PRODUCT_ID_INDEX: Final = 0
-NAME_INDEX: Final = 0
-PRICE_INDEX: Final = 0
-QUANTITY_INDEX: Final = 0
+NAME_INDEX: Final = 1
+PRICE_INDEX: Final = 2
+QUANTITY_INDEX: Final = 3
 
 # TODO: задайте идентификатор первого товара в пустом хранилище
-PRODUCT_ID_MIN: Final[int] = 0
+PRODUCT_ID_MIN: Final[int] = 1
diff --git a/src/part2/utils.py b/src/part2/utils.py
index 11bd7a76..c47b5e2b 100644
--- a/src/part2/utils.py
+++ b/src/part2/utils.py
@@ -1,29 +1,13 @@
-"""Standalone helpers shared by the part2 storage and CRUD modules.
+"""Standalone helpers shared by the hw4 storage and CRUD modules.
 
-For now this is limited to money handling: :func:`normalize_price` rounds a
-raw :class:`~decimal.Decimal` amount to the fixed number of fractional
-digits (:data:`PRICE_PRECISION`) that every stored price uses, keeping
-currency values free of binary floating-point error.
-"""
-
-from decimal import ROUND_HALF_UP, Decimal  # noqa: F401
+from decimal import ROUND_HALF_UP, Decimal
 from typing import Final
 
 
-# TODO: задайте число знаков после запятой и шаг квантования
-PRICE_PRECISION: Final[int] = 0
-PRICE_STEP: Final = Decimal(0)
+PRICE_PRECISION: Final[int] = 2
+PRICE_STEP: Final = Decimal(1).scaleb(-PRICE_PRECISION)
 
 
 def normalize_price(price: Decimal) -> Decimal:
-    """Round a price to the precision every stored record uses.
-
-    Args:
-        price: The raw price amount.
-
-    Returns:
-        ``price`` quantised to :data:`PRICE_PRECISION` fractional digits,
-        with halves rounded up.
-    """
-    # TODO: реализуйте функцию
-    return Decimal(0)
+    # Round a price to the precision every stored record uses.
+    return price.quantize(PRICE_STEP, rounding=ROUND_HALF_UP)
diff --git a/src/part3/crud.py b/src/part3/crud.py
index 68811d7e..b181e525 100644
--- a/src/part3/crud.py
+++ b/src/part3/crud.py
@@ -1,87 +1,53 @@
-"""Create/read/update/delete operations over the in-memory product store.
-
-Every operation takes the store -- a list of
-:data:`~src.part3.storage.Product` tuples -- as its first argument and
-works on it in place. The failure path never raises: the operation prints
-an explanatory message to stdout and returns ``None``.
-
-The identifier of a new product is derived from the store itself
-(:func:`generate_product_id`): one past the greatest identifier in use, or
-:data:`~src.part3.storage.PRODUCT_ID_MIN` when the store is empty.
-
-Every product name that reaches the store is passed through
-:func:`~src.part3.utils.normalize_product_name` first. A name that
-normalises to an empty string is rejected -- the operation prints a
-message and changes nothing. Names are also kept unique --
-:func:`create_product` refuses a normalised name that is already taken,
-and :func:`update_product` refuses one that is already taken by another
-product.
-"""
+"""Create/read/update/delete operations over the in-memory product store."""
 
 from decimal import Decimal
 
-from .storage import (  # noqa: F401
+from .storage import (
     NAME_INDEX,
     PRODUCT_ID_INDEX,
     PRODUCT_ID_MIN,
     Product,
 )
-from .utils import normalize_price, normalize_product_name  # noqa: F401
+from .utils import normalize_price, normalize_product_name
 
 
 def generate_product_id(storage: list[Product]) -> int:
-    """Choose the identifier for the next product added to ``storage``.
-
-    Args:
-        storage: The product store to inspect.
-
-    Returns:
-        One past the greatest identifier currently held in ``storage``, or
-        :data:`~src.part3.storage.PRODUCT_ID_MIN` when ``storage`` is
-        empty.
-    """
-    # TODO: реализуйте функцию (используйте своё решение части 2)
-    return 0
+    """Choose the identifier for the next product added to ``storage``."""
+    if not storage:
+        return PRODUCT_ID_MIN
+    return max(p[PRODUCT_ID_INDEX] for p in storage) + 1
 
 
 def create_product(
     storage: list[Product], fields: tuple[str, Decimal, int]
 ) -> int | None:
-    """Append a new product to ``storage`` and return its new identifier.
-
-    Args:
-        storage: The product store to append to; modified in place on
-            success.
-        fields: A ``(name, price, quantity)`` tuple describing the product.
-            ``name`` is normalised (surrounding whitespace stripped,
-            lower-cased) before it is stored or compared. ``price`` is a
-            :class:`~decimal.Decimal` amount and is rounded to the stored
-            money precision before it is saved.
-
-    Returns:
-        The identifier generated for the new product, or ``None`` when
-        ``name`` is blank once normalised or a product with the same
-        normalised name already exists. In the ``None`` case ``storage``
-        is left unchanged and an explanatory message is printed.
-    """
-    # TODO: реализуйте функцию
-    return 0
+    """Append a new product to ``storage`` and return its new identifier."""
+    name, price, quantity = fields
+    norm_name = normalize_product_name(name)
 
+    if not norm_name:
+        print("product name must not be blank")
+        return None
 
-def read_product(storage: list[Product], product_id: int) -> Product | None:
-    """Return the product stored under ``product_id``.
+    for p in storage:
+        if p[NAME_INDEX] == norm_name:
+            print(f"product name '{norm_name}' is already taken")
+            return None
 
-    Args:
-        storage: The product store to search.
-        product_id: The identifier to look up.
+    product_id = generate_product_id(storage)
+    norm_price = normalize_price(price)
+    
+    storage.append((product_id, norm_name, norm_price, quantity))
+    return product_id
 
-    Returns:
-        The matching ``(product_id, name, price, quantity)`` record, or
-        ``None`` when no product carries that identifier (a message is
-        printed in that case).
-    """
-    # TODO: реализуйте функцию (используйте своё решение части 2)
-    return (0, "", Decimal(0), 0)
+
+def read_product(storage: list[Product], product_id: int) -> Product | None:
+    """Return the product stored under ``product_id``."""
+    for p in storage:
+        if p[PRODUCT_ID_INDEX] == product_id:
+            return p
+    print(f"no product with id {product_id}")
+    return None
 
 
 def update_product(
@@ -89,43 +55,40 @@ def update_product(
     product_id: int,
     fields: tuple[str, Decimal, int],
 ) -> Product | None:
-    """Overwrite the fields of the product stored under ``product_id``.
-
-    The identifier itself is preserved; only ``name``, ``price`` and
-    ``quantity`` are replaced.
-
-    Args:
-        storage: The product store to modify; the matching record is
-            replaced in place on success.
-        product_id: The identifier of the product to change.
-        fields: A ``(name, price, quantity)`` tuple with the new values.
-            ``price`` is a :class:`~decimal.Decimal` amount and is rounded
-            to the stored money precision before it is saved.
-
-    Returns:
-        The updated ``(product_id, name, price, quantity)`` record, or
-        ``None`` when ``name`` is blank once normalised, no product
-        carries that identifier, or the normalised name is already taken
-        by another product. In every ``None`` case ``storage`` is left
-        unchanged and an explanatory message is printed. Renaming a
-        product to its own current name is allowed.
-    """
-    # TODO: реализуйте функцию
-    return (0, "", Decimal(0), 0)
+    """Overwrite the fields of the product stored under ``product_id``."""
+    name, price, quantity = fields
+    norm_name = normalize_product_name(name)
+
+    if not norm_name:
+        print("product name must not be blank")
+        return None
+
+    target_idx = -1
+    for i, p in enumerate(storage):
+        if p[PRODUCT_ID_INDEX] == product_id:
+            target_idx = i
+            break
+
+    if target_idx == -1:
+        print(f"no product with id {product_id}")
+        return None
+
+    for i, p in enumerate(storage):
+        if i != target_idx and p[NAME_INDEX] == norm_name:
+            print(f"product name '{norm_name}' is already taken")
+            return None
+
+    norm_price = normalize_price(price)
+    updated_product = (product_id, norm_name, norm_price, quantity)
+    storage[target_idx] = updated_product
+    return updated_product
 
 
 def delete_product(storage: list[Product], product_id: int) -> int | None:
-    """Remove the product stored under ``product_id`` from ``storage``.
-
-    Args:
-        storage: The product store to remove from; modified in place on
-            success.
-        product_id: The identifier of the product to remove.
-
-    Returns:
-        ``product_id`` when a product was removed, or ``None`` when no
-        product carried that identifier (``storage`` is left unchanged and
-        a message is printed).
-    """
-    # TODO: реализуйте функцию (используйте своё решение части 2)
-    return 0
+    """Remove the product stored under ``product_id`` from ``storage``."""
+    for i, p in enumerate(storage):
+        if p[PRODUCT_ID_INDEX] == product_id:
+            storage.pop(i)
+            return product_id
+    print(f"no product with id {product_id}")
+    return None
diff --git a/src/part3/run_admin.py b/src/part3/run_admin.py
index c5feeb0b..15f96bc2 100644
--- a/src/part3/run_admin.py
+++ b/src/part3/run_admin.py
@@ -1,116 +1,134 @@
-"""Interactive admin console for the part3 in-memory product store.
-
-Running this module starts a read-eval-print loop over a single product
-store that lives in memory for the lifetime of the process. Every line
-typed at the prompt is stripped of surrounding whitespace and matched
-against the set of known commands:
-
-* ``help`` -- print the list of commands and what each one does;
-* ``exit`` -- leave the loop and end the program;
-* ``show`` -- print the whole store as a text table;
-* ``create <name...> <price> <quantity>`` -- add a product;
-* ``read <id>`` -- print one product;
-* ``update <id> <name...> <price> <quantity>`` -- overwrite a product;
-* ``delete <id>`` -- remove a product.
-
-For ``create`` and ``update`` the price and quantity are always the last
-two words of the line; everything between the verb (and, for ``update``,
-the id) and those two words is joined with single spaces into the
-product name, so a multi-word name such as ``Gibson SG Junior`` needs no
-quoting.
-
-The four CRUD commands forward to :mod:`src.part3.crud`; whatever
-that call returns is printed unless it is ``None``. A line whose first
-word is not a known verb, or that carries the wrong number of arguments
-for its verb, prints an "is not a command" notice. A line that names a
-command correctly but whose id, price or quantity argument will not
-parse prints a distinct "arguments are invalid" notice. Either way the
-store is left untouched and the loop keeps running; only ``exit`` stops
-it.
-"""
-
-from decimal import Decimal, InvalidOperation  # noqa: F401
+"""Interactive admin console for the part3 in-memory product store."""
+
+from decimal import Decimal, InvalidOperation
 from typing import Final
 
-from .crud import (  # noqa: F401
+from .crud import (
     create_product,
     delete_product,
     read_product,
     update_product,
 )
 from .storage import Product
-from .utils import get_storage_str_representation  # noqa: F401
-
-
-# TODO: задайте приглашение и текст справки
-PROMPT: Final[str] = ""
-HELP_TEXT: Final[str] = ""
+from .utils import get_storage_str_representation
+
+PROMPT: Final[str] = "admin> "
+HELP_TEXT: Final[str] = (
+    "Available commands:\n"
+    "  help                                       show this message\n"
+    "  exit                                       leave the console\n"
+    "  show                                       print the whole store as a table\n"
+    "  create <name...> <price> <quantity>        add a product, print its new id\n"
+    "  read <id>                                  print the product with that id\n"
+    "  update <id> <name...> <price> <quantity>   overwrite that product's fields\n"
+    "  delete <id>                                remove the product with that id\n\n"
+    "For create and update the price and quantity are the last two words of the\n"
+    "line; everything before them is the product name, so it may contain spaces\n"
+    '(for example "Gibson SG Junior") and needs no quoting.'
+)
 
 
 def show_help() -> None:
-    """Print the command reference to stdout.
-
-    The text is the module-level :data:`HELP_TEXT` constant, printed as
-    is: a heading, one line per command with a short description, and a
-    note on how multi-word names are parsed.
-    """
-    # TODO: реализуйте функцию
+    """Print the command reference to stdout."""
+    print(HELP_TEXT)
 
 
 def print_result(result: object) -> None:
-    """Print a CRUD result to stdout unless it is ``None``.
-
-    Args:
-        result: The value returned by a CRUD operation. ``None`` means the
-            operation already reported its own failure, so nothing is
-            printed in that case.
-    """
-    # TODO: реализуйте функцию
+    """Print a CRUD result to stdout unless it is ``None``."""
+    if result is not None:
+        print(result)
 
 
 def run_command(storage: list[Product], line: str) -> bool:
-    """Parse one console line and carry out the command it names.
-
-    Args:
-        storage: The product store shared across the session; mutated in
-            place by the ``create``, ``update`` and ``delete`` commands.
-        line: One line of console input, already stripped of surrounding
-            whitespace.
-
-    Returns:
-        ``True`` to keep the read-eval-print loop running, or ``False``
-        once the ``exit`` command has been seen. A line that is not a
-        known command prints a notice and still returns ``True``.
-
-    Raises:
-        ValueError: If an id or quantity argument of a CRUD command does
-            not parse as a base-10 integer.
-        decimal.InvalidOperation: If the price argument of ``create`` or
-            ``update`` does not parse as a decimal number.
-    """
-    # TODO: реализуйте функцию
-    return False
+    """Parse one console line and carry out the command it names."""
+    words = line.split()
+    if not words:
+        print(f"'{line}' is not a command")
+        return True
+
+    command = words[0]
+
+    if command == "exit":
+        if len(words) != 1:
+            print(f"'{line}' is not a command")
+            return True
+        return False
+
+    elif command == "help":
+        if len(words) != 1:
+            print(f"'{line}' is not a command")
+            return True
+        show_help()
+        return True
+
+    elif command == "show":
+        if len(words) != 1:
+            print(f"'{line}' is not a command")
+            return True
+        print(get_storage_str_representation(storage))
+        return True
+
+    elif command == "read":
+        if len(words) != 2:
+            print(f"'{line}' is not a command")
+            return True
+        product_id = int(words[1])
+        res = read_product(storage, product_id)
+        print_result(res)
+        return True
+
+    elif command == "delete":
+        if len(words) != 2:
+            print(f"'{line}' is not a command")
+            return True
+        product_id = int(words[1])
+        res = delete_product(storage, product_id)
+        print_result(res)
+        return True
+
+    elif command == "create":
+        # Минимум: 'create', одно слово имени, цена, количество (итого 4 слова)
+        if len(words) < 4:
+            print(f"'{line}' is not a command")
+            return True
+        quantity = int(words[-1])
+        price = Decimal(words[-2])
+        name = " ".join(words[1:-2])
+        res = create_product(storage, (name, price, quantity))
+        print_result(res)
+        return True
+
+    elif command == "update":
+        # Минимум: 'update', id, одно слово имени, цена, количество (итого 5 слов)
+        if len(words) < 5:
+            print(f"'{line}' is not a command")
+            return True
+        product_id = int(words[1])
+        quantity = int(words[-1])
+        price = Decimal(words[-2])
+        name = " ".join(words[2:-2])
+        res = update_product(storage, product_id, (name, price, quantity))
+        print_result(res)
+        return True
+
+    else:
+        print(f"'{line}' is not a command")
+        return True
 
 
 def main() -> None:
-    """Run the admin console until the ``exit`` command is entered.
-
-    A single product store is created empty and kept in memory for the
-    whole session. Each iteration reads one line from stdin, strips its
-    surrounding whitespace and hands it to :func:`run_command`. A line
-    that names a command but whose id, price or quantity argument does
-    not parse is caught here and reported without stopping the loop; only
-    ``exit`` ends it.
-    """
+    """Run the admin console until the ``exit`` command is entered."""
     storage: list[Product] = []
     running = True
 
     while running:
-        line = input(PROMPT).strip()
+        try:
+            line = input(PROMPT).strip()
+        except EOFError:
+            break
 
         try:
             running = run_command(storage, line)
-
         except (ValueError, InvalidOperation):
             print(f"{line!r} names a command but its arguments are invalid")
 
diff --git a/src/part3/storage.py b/src/part3/storage.py
index c5e34be5..b8acf919 100644
--- a/src/part3/storage.py
+++ b/src/part3/storage.py
@@ -1,22 +1,4 @@
-"""In-memory product store for the shop CRUD exercise.
-
-The store is deliberately primitive: a plain list of tuples, with no
-persistence, no indexing and no schema enforcement. Each element is a
-:data:`Product` record -- a ``(product_id, name, price, quantity)`` tuple
-where:
-
-* ``product_id`` -- unique positive integer key, assigned by the create
-  operation in :mod:`src.part3.crud`;
-* ``name`` -- human-readable product name, unique across the store;
-* ``price`` -- price of a single unit, held as a :class:`~decimal.Decimal`
-  amount rounded to a fixed number of decimal places (see
-  :func:`src.part3.utils.normalize_price`) so that money is never
-  subject to binary floating-point error;
-* ``quantity`` -- number of units currently in stock.
-
-Field positions are exposed as ``*_INDEX`` constants so callers never
-hard-code tuple offsets.
-"""
+"""In-memory product store for the shop CRUD exercise."""
 
 from decimal import Decimal
 from typing import Final
@@ -24,12 +6,11 @@
 
 type Product = tuple[int, str, Decimal, int]
 
-# TODO: задайте позиции полей внутри кортежа Product (используйте своё решение
-# части 2)
+# Позиции полей внутри кортежа Product
 PRODUCT_ID_INDEX: Final = 0
-NAME_INDEX: Final = 0
-PRICE_INDEX: Final = 0
-QUANTITY_INDEX: Final = 0
+NAME_INDEX: Final = 1
+PRICE_INDEX: Final = 2
+QUANTITY_INDEX: Final = 3
 
-# TODO: задайте идентификатор первого товара в пустом хранилище
-PRODUCT_ID_MIN: Final[int] = 0
+# Идентификатор первого товара в пустом хранилище
+PRODUCT_ID_MIN: Final[int] = 1
diff --git a/src/part3/utils.py b/src/part3/utils.py
index 318ded0b..5d0f65c9 100644
--- a/src/part3/utils.py
+++ b/src/part3/utils.py
@@ -1,95 +1,57 @@
-"""Standalone helpers shared by the part3 storage and CRUD modules.
+"""Standalone helpers shared by the part3 storage and CRUD modules."""
 
-Normalisation:
-
-* :func:`normalize_price` rounds a raw :class:`~decimal.Decimal` amount to
-  the fixed number of fractional digits (:data:`PRICE_PRECISION`) that
-  every stored price uses, keeping currency values free of binary
-  floating-point error.
-* :func:`normalize_product_name` strips surrounding whitespace from a
-  product name, collapses every internal run of whitespace to a single
-  space and lower-cases it, giving every stored name a single canonical
-  form.
-
-Presentation:
-
-* :func:`get_storage_str_representation` renders the whole store as a
-  text table meant to be printed to a terminal; each column is sized to
-  the longest value it holds in that particular call.
-"""
-
-from decimal import ROUND_HALF_UP, Decimal  # noqa: F401
+from decimal import ROUND_HALF_UP, Decimal
 from typing import Final
 
 from .storage import Product
 
+# Округление цен
+PRICE_PRECISION: Final[int] = 2
+PRICE_STEP: Final = Decimal("0.01")
 
-# Number of fractional digits every stored price is rounded to.
-# Quantisation step derived from PRICE_PRECISION, e.g. Decimal("0.01").
-# TODO: задайте число знаков после запятой и шаг квантования (используйте своё
-# решение части 2)
-PRICE_PRECISION: Final[int] = 0
-PRICE_STEP: Final = Decimal(0)
-
-# Column headers of the table produced by get_storage_str_representation,
-# left to right. The width of each column is not fixed here -- it is
-# measured per call from the data (see the function).
-# TODO: задайте заголовки столбцов таблицы
-TABLE_HEADERS: Final[tuple[str, ...]] = ()
+# Заголовки столбцов таблицы
+TABLE_HEADERS: Final[tuple[str, ...]] = ("ID", "name", "price", "quantity")
 
 
 def normalize_price(price: Decimal) -> Decimal:
-    """Round a price to the precision every stored record uses.
-
-    Args:
-        price: The raw price amount.
-
-    Returns:
-        ``price`` quantised to :data:`PRICE_PRECISION` fractional digits,
-        with halves rounded up.
-    """
-    # TODO: реализуйте функцию (используйте своё решение части 2)
-    return Decimal(0)
+    """Round a price to the precision every stored record uses."""
+    return price.quantize(PRICE_STEP, rounding=ROUND_HALF_UP)
 
 
 def normalize_product_name(name: str) -> str:
-    """Reduce a product name to the canonical form the store keeps.
-
-    Args:
-        name: The raw product name.
-
-    Returns:
-        ``name`` with every leading and trailing whitespace character
-        removed, every internal run of whitespace (spaces, tabs and the
-        like) collapsed to a single space, and the rest lower-cased. For
-        example ``"abc    def\tghi\tjkl"`` becomes ``"abc def ghi jkl"``.
-        The result is an empty string when ``name`` holds nothing but
-        whitespace.
-    """
-    # TODO: реализуйте функцию
-    return ""
-
-
-# TODO: при необходимости добавьте свои вспомогательные функции
+    """Reduce a product name to the canonical form the store keeps."""
+    words = name.split()
+    if not words:
+        return ""
+    return " ".join(words).lower()
 
 
 def get_storage_str_representation(storage: list[Product]) -> str:
-    """Render the product store as a text table with data-sized columns.
-
-    The table has the columns named by :data:`TABLE_HEADERS` -- id, name,
-    price and quantity. Each column is made exactly as wide as the longest
-    value it carries in this call (its header counted), so the columns
-    line up when the string is printed to a terminal and no value is ever
-    truncated.
-
-    Args:
-        storage: The product store to render.
-
-    Returns:
-        A multi-line string: a header row, a dashed separator row, then
-        one row per product in ``storage`` in list order. When ``storage``
-        is empty only the header and separator rows are returned, sized to
-        the header labels.
-    """
-    # TODO: реализуйте функцию
-    return ""
+    """Render the product store as a text table with data-sized columns."""
+    # Собираем все строки таблицы (сначала заголовки)
+    rows_data = [TABLE_HEADERS]
+    for p in storage:
+        rows_data.append((str(p[0]), p[1], str(p[2]), str(p[3])))
+
+    # Вычисляем максимальную ширину для каждого столбца
+    col_widths = []
+    for col_idx in range(len(TABLE_HEADERS)):
+        max_w = max(len(row[col_idx]) for row in rows_data)
+        col_widths.append(max_w)
+
+    # Строим строку заголовков
+    header_parts = [f" {TABLE_HEADERS[i].ljust(col_widths[i])} " for i in range(len(TABLE_HEADERS))]
+    header_row = f"|{'|'.join(header_parts)}|"
+
+    # Строим разделительную строку
+    sep_parts = ["-" * (w + 2) for w in col_widths]
+    sep_row = f"|{'|'.join(sep_parts)}|"
+
+    result_lines = [header_row, sep_row]
+
+    # Строим строки с данными товаров
+    for row in rows_data[1:]:
+        row_parts = [f" {row[i].ljust(col_widths[i])} " for i in range(len(TABLE_HEADERS))]
+        result_lines.append(f"|{'|'.join(row_parts)}|")
+
+    return "\n".join(result_lines)