// 2025-2026 Богданович Давид Когут Прихожденко (кдб.дійсність.укр)

взяти визначення мавка;

простір мавка {
  внутрішня дія звільнити_предмет(М: *Машина, значення: *Предмет);
  внутрішня дія звільнити_предмет_класу(М: *Машина, предмет_класу: *ПредметКласу);
  внутрішня дія звільнити_предмет_даних(М: *Машина, предмет_даних: *ПредметДаних);
  внутрішня дія звільнити_предмет_проміжка_чисел(М: *Машина, предмет_проміжка_чисел: *ПредметПроміжкаЧисел);
  внутрішня дія звільнити_предмет_дії(М: *Машина, предмет_дії: *ПредметДії);
  внутрішня дія звільнити_предмет_коду(М: *Машина, предмет_коду: *ПредметКоду);
  внутрішня дія звільнити_предмет_модуля(М: *Машина, предмет_модуля: *ПредметМодуля);
  внутрішня дія звільнити_предмет_параметра(М: *Машина, предмет_параметра: *ПредметПараметра);
  внутрішня дія звільнити_предмет_ознаки(М: *Машина, предмет_параметра: *ПредметОзнаки);
  внутрішня дія звільнити_предмет_перебору_даних(М: *Машина, предмет_перебору_даних: *ПредметПереборуДаних);
  внутрішня дія звільнити_предмет_перебору_проміжка_чисел(М: *Машина, предмет_перебору_проміжка_чисел: *ПредметПереборуПроміжкаЧисел);
  внутрішня дія звільнити_предмет_перебору_послідовності(М: *Машина, предмет_перебору_послідовності: *ПредметПереборуПослідовності);
  внутрішня дія звільнити_предмет_перебору_словника(М: *Машина, предмет_перебору_словника: *ПредметПереборуСловника);
  внутрішня дія звільнити_предмет_перебору_списку(М: *Машина, предмет_перебору_списку: *ПредметПереборуСписку);
  внутрішня дія звільнити_предмет_перебору_тексту(М: *Машина, предмет_перебору_тексту: *ПредметПереборуТексту);
  внутрішня дія звільнити_предмет_послідовності(М: *Машина, послідовність: *ПредметПослідовності);
  внутрішня дія звільнити_предмет_словника(М: *Машина, предмет_словника: *ПредметСловника);
  внутрішня дія звільнити_предмет_списку(М: *Машина, предмет_списку: *ПредметСписку);
  внутрішня дія звільнити_предмет_тексту(М: *Машина, предмет_тексту: *ПредметТексту);
  внутрішня дія звільнити_складений_предмет(М: *Машина, складений_предмет: *СкладенийПредмет);
  внутрішня дія звільнити_користувацькі_дані(М: *Машина, користувацькі_дані: *КористувацькіДані);
  внутрішня дія звільнити_методи(М: *Машина, методи: Методи);
  дія звільнити_призначення(М: *Машина, призначення: Призначення);
  внутрішня дія звільнити_притримувач(М: *Машина, притримувач: *Притримувач);

  // позначка: прохід по типах предметів
  внутрішня дія звільнити_предмет(
    М: *Машина,
    значення: *Предмет
  ) {
    якщо значення.клас == М.клас_Клас {
      // надрукувати_кд(М, "звільнення дійсного предмету структури");
      звільнити_предмет_класу(М, значення як *ПредметКласу);
      вернути;
    }

    якщо значення.клас == М.клас_Модуль {
      // надрукувати_кд(М, "звільнення дійсного предмету модуля");
      звільнити_предмет_модуля(М, значення як *ПредметМодуля);
      вернути;
    }

    якщо значення.клас == М.клас_Параметр {
      // надрукувати_кд(М, "звільнення дійсного предмету параметра");
      звільнити_предмет_параметра(М, значення як *ПредметПараметра);
      вернути;
    }

    якщо значення.клас == М.клас_Ознака {
      // надрукувати_кд(М, "звільнення дійсного предмету параметра");
      звільнити_предмет_ознаки(М, значення як *ПредметОзнаки);
      вернути;
    }

    якщо значення.клас == М.клас_Число {
      ЗАПАНІКУВАТИ(М, "[Помилка Машини][звільнити_предмет]: значення.клас == М.клас_Число");
      вернути;
    }

    якщо значення.клас == М.клас_Текст {
      // вивести_кд(М, "звільнення предмету тексту: ");
      // надрукувати_кд(М, (значення як *ПредметТексту).значення);
      звільнити_предмет_тексту(М, значення як *ПредметТексту);
      вернути;
    }

    якщо значення.клас == М.клас_Код {
      // надрукувати_кд(М, "звільнення предмету коду");
      звільнити_предмет_коду(М, значення як *ПредметКоду);
      вернути;
    }

    якщо значення.клас == М.клас_Дія {
      // вивести_кд(М, "звільнення предмету дії ");
      // змінна предмет_дії = значення як *ПредметДії;
      // якщо предмет_дії.назва != пусто {
      //   надрукувати_кд(М, предмет_дії.назва.значення);
      // } інакше {
      //   надрукувати_кд(М, "<без назви>");
      // }
      звільнити_предмет_дії(М, значення як *ПредметДії);
      вернути;
    }

    якщо значення.клас == М.клас_Список {
      // надрукувати_кд(М, "звільнення предмету списку");
      звільнити_предмет_списку(М, значення як *ПредметСписку);
      вернути;
    }

    якщо значення.клас == М.клас_Словник {
      // надрукувати_кд(М, "звільнення предмету словника");
      звільнити_предмет_словника(М, значення як *ПредметСловника);
      вернути;
    }

    якщо значення.клас == М.клас_Дані {
      // надрукувати_кд(М, "звільнення предмету даних");
      звільнити_предмет_даних(М, значення як *ПредметДаних);
      вернути;
    }

    якщо значення.клас == М.клас_ПроміжокЧисел {
      // надрукувати_кд(М, "звільнення предмету проміжка чисел");
      звільнити_предмет_проміжка_чисел(М, значення як *ПредметПроміжкаЧисел);
      вернути;
    }

    якщо значення.клас == М.клас_ПеребірПроміжкаЧисел {
      // надрукувати_кд(М, "звільнення предмету перебору проміжка чисел");
      звільнити_предмет_перебору_проміжка_чисел(М, значення як *ПредметПереборуПроміжкаЧисел);
      вернути;
    }

    якщо значення.клас == М.клас_ПеребірДаних {
      // надрукувати_кд(М, "звільнення предмету перебору даних");
      звільнити_предмет_перебору_даних(М, значення як *ПредметПереборуДаних);
      вернути;
    }

    якщо значення.клас == М.клас_ПеребірПослідовності {
      // надрукувати_кд(М, "звільнення предмету перебору послідовності");
      звільнити_предмет_перебору_послідовності(М, значення як *ПредметПереборуПослідовності);
      вернути;
    }

    якщо значення.клас == М.клас_ПеребірСловника {
      // надрукувати_кд(М, "звільнення предмету перебору словника");
      звільнити_предмет_перебору_словника(М, значення як *ПредметПереборуСловника);
      вернути;
    }

    якщо значення.клас == М.клас_ПеребірСписку {
      // надрукувати_кд(М, "звільнення предмету перебору списку");
      звільнити_предмет_перебору_списку(М, значення як *ПредметПереборуСписку);
      вернути;
    }

    якщо значення.клас == М.клас_ПеребірТексту {
      // надрукувати_кд(М, "звільнення предмету перебору тексту");
      звільнити_предмет_перебору_тексту(М, значення як *ПредметПереборуТексту);
      вернути;
    }

    якщо значення.клас == М.клас_Послідовність {
      // надрукувати_кд(М, "звільнення предмету послідовності");
      звільнити_предмет_послідовності(М, значення як *ПредметПослідовності);
      вернути;
    }

    // надрукувати_кд(М, "звільнення складеного предмету");

    звільнити_складений_предмет(М, значення як *СкладенийПредмет);
  }

  внутрішня дія звільнити_предмет_послідовності(
    М: *Машина,
    послідовність: *ПредметПослідовності
  ) {
    // надрукувати_кд(М, "звільнити_предмет_послідовності");
    якщо послідовність.користувацькі_дані != пусто {
      звільнити_користувацькі_дані(М, послідовність.користувацькі_дані);
    }
    звільнити(М, послідовність.елементи);
    звільнити(М, послідовність);
  }

  внутрішня дія звільнити_предмет_класу(
    М: *Машина,
    предмет_класу: *ПредметКласу
  ) {
    // надрукувати_кд(М, "звільнити_предмет_класу");
    якщо предмет_класу.користувацькі_дані != пусто {
      звільнити_користувацькі_дані(М, предмет_класу.користувацькі_дані);
    }
    звільнити_методи(М, предмет_класу.методи);
    звільнити_призначення(М, предмет_класу.властивості);
    звільнити(М, предмет_класу);
  }

  внутрішня дія звільнити_предмет_модуля(
    М: *Машина,
    предмет_модуля: *ПредметМодуля
  ) {
    // надрукувати_кд(М, "звільнити_предмет_модуля");
    якщо предмет_модуля.користувацькі_дані != пусто {
      звільнити_користувацькі_дані(М, предмет_модуля.користувацькі_дані);
    }
    звільнити_призначення(М, предмет_модуля.властивості);
    звільнити(М, предмет_модуля);
  }

  внутрішня дія звільнити_предмет_параметра(
    М: *Машина,
    предмет_параметра: *ПредметПараметра
  ) {
    // вивести_кд(М, "звільнити_предмет_параметра: ");
    // надрукувати_кд(М, предмет_параметра.назва.значення);
    якщо предмет_параметра.користувацькі_дані != пусто {
      звільнити_користувацькі_дані(М, предмет_параметра.користувацькі_дані);
    }
    звільнити(М, предмет_параметра);
  }

  внутрішня дія звільнити_предмет_ознаки(
    М: *Машина,
    предмет_ознаки: *ПредметОзнаки
  ) {
    // вивести_кд(М, "звільнити_предмет_ознаки: ");
    // надрукувати_кд(М, предмет_ознаки.назва.значення);
    якщо предмет_ознаки.користувацькі_дані != пусто {
      звільнити_користувацькі_дані(М, предмет_ознаки.користувацькі_дані);
    }
    звільнити(М, предмет_ознаки);
  }

  внутрішня дія звільнити_предмет_тексту(
    М: *Машина,
    предмет_тексту: *ПредметТексту
  ) {
    // надрукувати_кд(М, "звільнити_предмет_тексту");
    якщо предмет_тексту.користувацькі_дані != пусто {
      звільнити_користувацькі_дані(М, предмет_тексту.користувацькі_дані);
    }
    звільнити(М, предмет_тексту.значення.дані);
    звільнити(М, предмет_тексту);
  }

  внутрішня дія звільнити_предмет_коду(
    М: *Машина,
    предмет_коду: *ПредметКоду
  ) {
    // надрукувати_кд(М, "звільнити_предмет_коду");
    якщо предмет_коду.користувацькі_дані != пусто {
      звільнити_користувацькі_дані(М, предмет_коду.користувацькі_дані);
    }
    звільнити(М, предмет_коду.місцезнаходження_вказівок.дані);
    звільнити(М, предмет_коду);
  }

  внутрішня дія звільнити_предмет_дії(
    М: *Машина,
    предмет_дії: *ПредметДії
  ) {
    // надрукувати_кд(М, "звільнити_предмет_дії");
    якщо предмет_дії.користувацькі_дані != пусто {
      звільнити_користувацькі_дані(М, предмет_дії.користувацькі_дані);
    }

    якщо предмет_дії.середовище_створення != пусто {
      відпустити_середовище(М, предмет_дії.середовище_створення);
    }

    звільнити(М, предмет_дії);
  }

  внутрішня дія звільнити_предмет_списку(
    М: *Машина,
    предмет_списку: *ПредметСписку
  ) {
    // надрукувати_кд(М, "звільнити_предмет_списку");
    якщо предмет_списку.користувацькі_дані != пусто {
      звільнити_користувацькі_дані(М, предмет_списку.користувацькі_дані);
    }
    звільнити(М, предмет_списку.елементи);
    звільнити(М, предмет_списку);
  }

  внутрішня дія звільнити_предмет_словника(
    М: *Машина,
    предмет_словника: *ПредметСловника
  ) {
    // надрукувати_кд(М, "звільнити_предмет_словника");
    якщо предмет_словника.користувацькі_дані != пусто {
      звільнити_користувацькі_дані(М, предмет_словника.користувацькі_дані);
    }
    звільнити(М, предмет_словника.елементи);
    звільнити(М, предмет_словника);
  }

  внутрішня дія звільнити_предмет_даних(
    М: *Машина,
    предмет_даних: *ПредметДаних
  ) {
    // надрукувати_кд(М, "звільнити_предмет_даних");
    якщо предмет_даних.користувацькі_дані != пусто {
      звільнити_користувацькі_дані(М, предмет_даних.користувацькі_дані);
    }
    звільнити(М, предмет_даних.дані);
    звільнити(М, предмет_даних);
  }

  внутрішня дія звільнити_предмет_проміжка_чисел(
    М: *Машина,
    предмет_проміжка_чисел: *ПредметПроміжкаЧисел
  ) {
    // надрукувати_кд(М, "звільнити_предмет_проміжка_чисел");
    якщо предмет_проміжка_чисел.користувацькі_дані != пусто {
      звільнити_користувацькі_дані(М, предмет_проміжка_чисел.користувацькі_дані);
    }
    звільнити(М, предмет_проміжка_чисел);
  }

  внутрішня дія звільнити_предмет_перебору_проміжка_чисел(
    М: *Машина,
    предмет_перебору_проміжка_чисел: *ПредметПереборуПроміжкаЧисел
  ) {
    // надрукувати_кд(М, "звільнити_предмет_перебору_проміжка_чисел");
    якщо предмет_перебору_проміжка_чисел.користувацькі_дані != пусто {
      звільнити_користувацькі_дані(М, предмет_перебору_проміжка_чисел.користувацькі_дані);
    }
    звільнити(М, предмет_перебору_проміжка_чисел);
  }

  внутрішня дія звільнити_предмет_перебору_даних(
    М: *Машина,
    предмет_перебору_даних: *ПредметПереборуДаних
  ) {
    // надрукувати_кд(М, "звільнити_предмет_перебору_даних");
    якщо предмет_перебору_даних.користувацькі_дані != пусто {
      звільнити_користувацькі_дані(М, предмет_перебору_даних.користувацькі_дані);
    }
    звільнити(М, предмет_перебору_даних);
  }

  внутрішня дія звільнити_предмет_перебору_послідовності(
    М: *Машина,
    предмет_перебору_послідовності: *ПредметПереборуПослідовності
  ) {
    // надрукувати_кд(М, "звільнити_предмет_перебору_послідовності");
    якщо предмет_перебору_послідовності.користувацькі_дані != пусто {
      звільнити_користувацькі_дані(М, предмет_перебору_послідовності.користувацькі_дані);
    }
    звільнити(М, предмет_перебору_послідовності);
  }

  внутрішня дія звільнити_предмет_перебору_словника(
    М: *Машина,
    предмет_перебору_словника: *ПредметПереборуСловника
  ) {
    // надрукувати_кд(М, "звільнити_предмет_перебору_словника");
    якщо предмет_перебору_словника.користувацькі_дані != пусто {
      звільнити_користувацькі_дані(М, предмет_перебору_словника.користувацькі_дані);
    }
    звільнити(М, предмет_перебору_словника);
  }

  внутрішня дія звільнити_предмет_перебору_списку(
    М: *Машина,
    предмет_перебору_списку: *ПредметПереборуСписку
  ) {
    // надрукувати_кд(М, "звільнити_предмет_перебору_списку");
    якщо предмет_перебору_списку.користувацькі_дані != пусто {
      звільнити_користувацькі_дані(М, предмет_перебору_списку.користувацькі_дані);
    }
    звільнити(М, предмет_перебору_списку);
  }

  внутрішня дія звільнити_предмет_перебору_тексту(
    М: *Машина,
    предмет_перебору_тексту: *ПредметПереборуТексту
  ) {
    // надрукувати_кд(М, "звільнити_предмет_перебору_тексту");
    якщо предмет_перебору_тексту.користувацькі_дані != пусто {
      звільнити_користувацькі_дані(М, предмет_перебору_тексту.користувацькі_дані);
    }
    звільнити(М, предмет_перебору_тексту);
  }

  внутрішня дія звільнити_складений_предмет(
    М: *Машина,
    складений_предмет: *СкладенийПредмет
  ) {
    // надрукувати_кд(М, "звільнити_складений_предмет");
    якщо складений_предмет.користувацькі_дані != пусто {
      звільнити_користувацькі_дані(М, складений_предмет.користувацькі_дані);
    }
    звільнити_призначення(М, складений_предмет.властивості);
    звільнити(М, складений_предмет);
  }

  внутрішня дія звільнити_користувацькі_дані(
    М: *Машина,
    користувацькі_дані: *КористувацькіДані
  ) {
    // надрукувати_кд(М, "звільнити_користувацькі_дані");
    якщо користувацькі_дані.дія_перед_знищенням != пусто {
      користувацькі_дані.дія_перед_знищенням(М, користувацькі_дані);
    }

    звільнити(М, користувацькі_дані);
  }

  внутрішня дія звільнити_методи(
    М: *Машина,
    методи: Методи
  ) {
    // надрукувати_кд(М, "звільнити_методи");
    звільнити(М, методи.дані);
  }

  дія звільнити_призначення(
    М: *Машина,
    призначення: Призначення
  ) {
    // надрукувати_кд(М, "звільнити_призначення");
    змінна п: природне = 0;

    поки п < призначення.вмісткість {
      змінна призначене = призначення.дані[п];

      поки призначене != пусто {
        змінна наступний = призначене.наступний;

        звільнити(М, призначене);

        призначене = наступний;
      }

      п = п + 1;
    }

    звільнити(М, призначення.дані);
  }

  внутрішня дія звільнити_притримувач(
    М: *Машина,
    притримувач: *Притримувач
  ) {
    // надрукувати_кд(М, "звільнити_притримувач");

    змінна притриманий = притримувач.перший;

    поки притриманий != пусто {
      змінна наступний_притриманий = притриманий.наступний;

      звільнити(М, притриманий);

      притриманий = наступний_притриманий;
    }

    звільнити(М, притримувач);
  }

  внутрішня дія позначити_середовище(М: *Машина, середовище: *Середовище);
  внутрішня дія позначити_предмет(М: *Машина, значення: *Предмет);
  внутрішня дія позначити_предмет_послідовності(М: *Машина, послідовність: *ПредметПослідовності);
  внутрішня дія позначити_предмет_класу(М: *Машина, предмет_класу: *ПредметКласу);
  внутрішня дія позначити_предмет_модуля(М: *Машина, предмет_модуля: *ПредметМодуля);
  внутрішня дія позначити_предмет_параметра(М: *Машина, предмет_параметра: *ПредметПараметра);
  внутрішня дія позначити_предмет_ознаки(М: *Машина, предмет_параметра: *ПредметОзнаки);
  внутрішня дія позначити_предмет_тексту(М: *Машина, предмет_тексту: *ПредметТексту);
  внутрішня дія позначити_предмет_коду(М: *Машина, предмет_коду: *ПредметКоду);
  внутрішня дія позначити_предмет_дії(М: *Машина, предмет_дії: *ПредметДії);
  внутрішня дія позначити_предмет_списку(М: *Машина, предмет_списку: *ПредметСписку);
  внутрішня дія позначити_предмет_словника(М: *Машина, предмет_словника: *ПредметСловника);
  внутрішня дія позначити_предмет_даних(М: *Машина, предмет_даних: *ПредметДаних);
  внутрішня дія позначити_предмет_проміжка_чисел(М: *Машина, предмет_проміжка_чисел: *ПредметПроміжкаЧисел);
  внутрішня дія позначити_предмет_перебору_проміжка_чисел(М: *Машина, предмет_перебору_проміжка_чисел: *ПредметПереборуПроміжкаЧисел);
  внутрішня дія позначити_предмет_перебору_даних(М: *Машина, предмет_перебору_даних: *ПредметПереборуДаних);
  внутрішня дія позначити_предмет_перебору_послідовності(М: *Машина, предмет_перебору_послідовності: *ПредметПереборуПослідовності);
  внутрішня дія позначити_предмет_перебору_словника(М: *Машина, предмет_перебору_словника: *ПредметПереборуСловника);
  внутрішня дія позначити_предмет_перебору_списку(М: *Машина, предмет_перебору_списку: *ПредметПереборуСписку);
  внутрішня дія позначити_предмет_перебору_тексту(М: *Машина, предмет_перебору_тексту: *ПредметПереборуТексту);
  внутрішня дія позначити_складений_предмет(М: *Машина, складений_предмет: *СкладенийПредмет);
  внутрішня дія позначити_накопичувач_значень(М: *Машина, накопичувач_значень: НакопичувачЗначень);
  внутрішня дія позначити_спроби(М: *Машина, спроби: Спроби);
  внутрішня дія позначити_історію_здійснення(М: *Машина, історія_здійснення: ІсторіяЗдійснення);
  внутрішня дія позначити_місцезнаходження(М: *Машина, місцезнаходження: Місцезнаходження);
  внутрішня дія позначити_константи_назв(М: *Машина, константи_назв: КонстантиНазв);
  внутрішня дія позначити_взяті_значення(М: *Машина, взяті_значення: ВзятіЗначення);
  внутрішня дія позначити_методи(М: *Машина, методи: Методи);
  внутрішня дія позначити_властивості(М: *Машина, призначення: Призначення);
  внутрішня дія позначити_притримувач(М: *Машина, притримувач: *Притримувач);
  внутрішня дія позначити_чергу_здійснення(М: *Машина, черга_здійснення: ЧергаЗдійснення);
  внутрішня дія позначити_задіяні(М: *Машина, задіяні: Задіяні);

  внутрішня дія позначити_середовище(
    М: *Машина,
    середовище: *Середовище
  ) {
    якщо середовище.позначено {
      вернути;
    }

    середовище.позначено = так;

    якщо середовище.зовні != пусто {
      позначити_середовище(М, середовище.зовні);
    }

    позначити_властивості(М, середовище.призначення);
  }

  // позначка: прохід по типах предметів
  внутрішня дія позначити_предмет(
    М: *Машина,
    предмет: *Предмет
  ) {
    якщо предмет.позначено {
      вернути;
    }

    якщо предмет.клас == М.клас_Клас {
      позначити_предмет_класу(М, предмет як *ПредметКласу);
      вернути;
    }

    якщо предмет.клас == М.клас_Модуль {
      позначити_предмет_модуля(М, предмет як *ПредметМодуля);
      вернути;
    }

    якщо предмет.клас == М.клас_Параметр {
      позначити_предмет_параметра(М, предмет як *ПредметПараметра);
      вернути;
    }

    якщо предмет.клас == М.клас_Ознака {
      позначити_предмет_ознаки(М, предмет як *ПредметОзнаки);
      вернути;
    }

    якщо предмет.клас == М.клас_Число {
      ЗАПАНІКУВАТИ(М, "[Помилка Машини][позначити_предмет]: предмет.клас == М.клас_Число");
      вернути;
    }

    якщо предмет.клас == М.клас_Текст {
      позначити_предмет_тексту(М, предмет як *ПредметТексту);
      вернути;
    }

    якщо предмет.клас == М.клас_Код {
      позначити_предмет_коду(М, предмет як *ПредметКоду);
      вернути;
    }

    якщо предмет.клас == М.клас_Дія {
      позначити_предмет_дії(М, предмет як *ПредметДії);
      вернути;
    }

    якщо предмет.клас == М.клас_Список {
      позначити_предмет_списку(М, предмет як *ПредметСписку);
      вернути;
    }

    якщо предмет.клас == М.клас_Словник {
      позначити_предмет_словника(М, предмет як *ПредметСловника);
      вернути;
    }

    якщо предмет.клас == М.клас_Дані {
      позначити_предмет_даних(М, предмет як *ПредметДаних);
      вернути;
    }

    якщо предмет.клас == М.клас_ПроміжокЧисел {
      позначити_предмет_проміжка_чисел(М, предмет як *ПредметПроміжкаЧисел);
      вернути;
    }

    якщо предмет.клас == М.клас_ПеребірПроміжкаЧисел {
      позначити_предмет_перебору_проміжка_чисел(М, предмет як *ПредметПереборуПроміжкаЧисел);
      вернути;
    }

    якщо предмет.клас == М.клас_ПеребірДаних {
      позначити_предмет_перебору_даних(М, предмет як *ПредметПереборуДаних);
      вернути;
    }

    якщо предмет.клас == М.клас_ПеребірПослідовності {
      позначити_предмет_перебору_послідовності(М, предмет як *ПредметПереборуПослідовності);
      вернути;
    }

    якщо предмет.клас == М.клас_ПеребірСловника {
      позначити_предмет_перебору_словника(М, предмет як *ПредметПереборуСловника);
      вернути;
    }

    якщо предмет.клас == М.клас_ПеребірСписку {
      позначити_предмет_перебору_списку(М, предмет як *ПредметПереборуСписку);
      вернути;
    }

    якщо предмет.клас == М.клас_ПеребірТексту {
      позначити_предмет_перебору_тексту(М, предмет як *ПредметПереборуТексту);
      вернути;
    }

    якщо предмет.клас == М.клас_Послідовність {
      позначити_предмет_послідовності(М, предмет як *ПредметПослідовності);
      вернути;
    }

    позначити_складений_предмет(М, предмет як *СкладенийПредмет);
  }

  внутрішня дія позначити_предмет_послідовності(
    М: *Машина,
    послідовність: *ПредметПослідовності
  ) {
    якщо послідовність.позначено {
      вернути;
    }

    послідовність.позначено = так;

    змінна п: природне = 0;

    поки п < послідовність.розмір {
      якщо послідовність.елементи[п].вид == ЗПредмет {
        позначити_предмет(М, послідовність.елементи[п].дані як *Предмет);
      }

      п += 1;
    }
  }

  внутрішня дія позначити_предмет_класу(
    М: *Машина,
    предмет_класу: *ПредметКласу
  ) {
    якщо предмет_класу.позначено {
      вернути;
    }

    предмет_класу.позначено = так;

    якщо предмет_класу.назва != пусто {
      позначити_предмет_тексту(М, предмет_класу.назва);
    }

    якщо предмет_класу.ознаки != пусто {
      позначити_предмет_послідовності(М, предмет_класу.ознаки як *ПредметПослідовності);
    }

    позначити_методи(М, предмет_класу.методи);
    позначити_властивості(М, предмет_класу.властивості);
  }

  внутрішня дія позначити_предмет_модуля(
    М: *Машина,
    предмет_модуля: *ПредметМодуля
  ) {
    якщо предмет_модуля.позначено {
      вернути;
    }

    предмет_модуля.позначено = так;

    якщо предмет_модуля.назва != пусто {
      позначити_предмет_тексту(М, предмет_модуля.назва);
    }

    позначити_властивості(М, предмет_модуля.властивості);
  }

  внутрішня дія позначити_предмет_параметра(
    М: *Машина,
    предмет_параметра: *ПредметПараметра
  ) {
    якщо предмет_параметра.позначено {
      вернути;
    }

    // вивести_кд(М, "позначити_предмет_параметра: ");
    // надрукувати_кд(М, предмет_параметра.назва.значення);

    предмет_параметра.позначено = так;

    якщо предмет_параметра.назва != пусто {
      позначити_предмет_тексту(М, предмет_параметра.назва);
    }

    якщо предмет_параметра.тип != пусто {
      // ...
    }

    якщо предмет_параметра.значення.вид == ЗПредмет {
      позначити_предмет(М, предмет_параметра.значення.дані як *Предмет);
    }
  }

  внутрішня дія позначити_предмет_ознаки(
    М: *Машина,
    предмет_ознаки: *ПредметОзнаки
  ) {
    якщо предмет_ознаки.позначено {
      вернути;
    }

    // вивести_кд(М, "позначити_предмет_ознаки: ");
    // надрукувати_кд(М, предмет_ознаки.назва.значення);

    предмет_ознаки.позначено = так;

    якщо предмет_ознаки.назва != пусто {
      позначити_предмет_тексту(М, предмет_ознаки.назва);
    }

    якщо предмет_ознаки.тип != пусто {
      // ...
    }

    якщо предмет_ознаки.значення.вид == ЗПредмет {
      позначити_предмет(М, предмет_ознаки.значення.дані як *Предмет);
    }
  }

  внутрішня дія позначити_предмет_тексту(
    М: *Машина,
    предмет_тексту: *ПредметТексту
  ) {
    якщо предмет_тексту.позначено {
      вернути;
    }

    предмет_тексту.позначено = так;
  }

  внутрішня дія позначити_предмет_коду(
    М: *Машина,
    предмет_коду: *ПредметКоду
  ) {
    якщо предмет_коду.позначено {
      вернути;
    }

    предмет_коду.позначено = так;

    якщо предмет_коду.константи != пусто {
      позначити_предмет_послідовності(М, предмет_коду.константи);
    }

    якщо предмет_коду.вказівки != пусто {
      позначити_предмет_даних(М, предмет_коду.вказівки);
    }

    якщо предмет_коду.шлях != пусто {
      позначити_предмет_даних(М, предмет_коду.шлях);
    }
  }

  внутрішня дія позначити_предмет_дії(
    М: *Машина,
    предмет_дії: *ПредметДії
  ) {
    якщо предмет_дії.позначено {
      вернути;
    }

    // вивести_кд(М, "позначити_предмет_дії: ");
    // надрукувати_кд(М, предмет_дії.назва.значення);

    предмет_дії.позначено = так;

    якщо предмет_дії.середовище_створення != пусто {
      позначити_середовище(М, предмет_дії.середовище_створення);
    }

    позначити_предмет_послідовності(М, предмет_дії.параметри як *ПредметПослідовності);

    якщо предмет_дії.назва != пусто {
      позначити_предмет_тексту(М, предмет_дії.назва);
    }

    // якщо предмет_дії.тип_результату != пусто {
    //   позначити_предмет(М, предмет_дії.тип_результату);
    // }

    якщо не предмет_дії.рідна {
      позначити_предмет_коду(М, предмет_дії.код як *ПредметКоду);
    }

    якщо предмет_дії.метод_класу != пусто {
      позначити_предмет_класу(М, предмет_дії.метод_класу);
    }

    якщо предмет_дії.шлях_до_теки_модулів != пусто {
      позначити_предмет_даних(М, предмет_дії.шлях_до_теки_модулів);
    }
  }

  внутрішня дія позначити_предмет_списку(
    М: *Машина,
    предмет_списку: *ПредметСписку
  ) {
    якщо предмет_списку.позначено {
      вернути;
    }

    предмет_списку.позначено = так;

    змінна п: природне = 0;

    поки п < предмет_списку.розмір {
      якщо предмет_списку.елементи[п].вид == ЗПредмет {
        позначити_предмет(М, предмет_списку.елементи[п].дані як *Предмет);
      }

      п += 1;
    }
  }

  внутрішня дія позначити_предмет_словника(
    М: *Машина,
    предмет_словника: *ПредметСловника
  ) {
    якщо предмет_словника.позначено {
      вернути;
    }

    предмет_словника.позначено = так;

    змінна п: природне = 0;

    поки п < предмет_словника.розмір {
      якщо предмет_словника.елементи[п].ключ.вид == ЗПредмет {
        позначити_предмет(М, предмет_словника.елементи[п].ключ.дані як *Предмет);
      }

      якщо предмет_словника.елементи[п].значення.вид == ЗПредмет {
        позначити_предмет(М, предмет_словника.елементи[п].значення.дані як *Предмет);
      }

      п += 1;
    }
  }

  внутрішня дія позначити_предмет_даних(
    М: *Машина,
    предмет_даних: *ПредметДаних
  ) {
    якщо предмет_даних.позначено {
      вернути;
    }

    предмет_даних.позначено = так;
  }

  внутрішня дія позначити_предмет_проміжка_чисел(
    М: *Машина,
    предмет_проміжка_чисел: *ПредметПроміжкаЧисел
  ) {
    якщо предмет_проміжка_чисел.позначено {
      вернути;
    }

    предмет_проміжка_чисел.позначено = так;
  }

  внутрішня дія позначити_предмет_перебору_проміжка_чисел(
    М: *Машина,
    предмет_перебору_проміжка_чисел: *ПредметПереборуПроміжкаЧисел
  ) {
    якщо предмет_перебору_проміжка_чисел.позначено {
      вернути;
    }

    предмет_перебору_проміжка_чисел.позначено = так;

    якщо предмет_перебору_проміжка_чисел.предмет_проміжка != пусто {
      позначити_предмет_проміжка_чисел(М, предмет_перебору_проміжка_чисел.предмет_проміжка);
    }
  }

  внутрішня дія позначити_предмет_перебору_даних(
    М: *Машина,
    предмет_перебору_даних: *ПредметПереборуДаних
  ) {
    якщо предмет_перебору_даних.позначено {
      вернути;
    }

    предмет_перебору_даних.позначено = так;

    якщо предмет_перебору_даних.предмет_даних != пусто {
      позначити_предмет_даних(М, предмет_перебору_даних.предмет_даних);
    }
  }

  внутрішня дія позначити_предмет_перебору_послідовності(
    М: *Машина,
    предмет_перебору_послідовності: *ПредметПереборуПослідовності
  ) {
    якщо предмет_перебору_послідовності.позначено {
      вернути;
    }

    предмет_перебору_послідовності.позначено = так;

    якщо предмет_перебору_послідовності.предмет_послідовності != пусто {
      позначити_предмет_послідовності(М, предмет_перебору_послідовності.предмет_послідовності);
    }

    якщо предмет_перебору_послідовності.поточне_значення.вид == ЗПредмет {
      позначити_предмет(М, предмет_перебору_послідовності.поточне_значення.дані як *Предмет);
    }
  }

  внутрішня дія позначити_предмет_перебору_словника(
    М: *Машина,
    предмет_перебору_словника: *ПредметПереборуСловника
  ) {
    якщо предмет_перебору_словника.позначено {
      вернути;
    }

    предмет_перебору_словника.позначено = так;

    якщо предмет_перебору_словника.предмет_словника != пусто {
      позначити_предмет_словника(М, предмет_перебору_словника.предмет_словника);
    }

    якщо предмет_перебору_словника.поточне_значення.вид == ЗПредмет {
      позначити_предмет(М, предмет_перебору_словника.поточне_значення.дані як *Предмет);
    }
  }

  внутрішня дія позначити_предмет_перебору_списку(
    М: *Машина,
    предмет_перебору_списку: *ПредметПереборуСписку
  ) {
    якщо предмет_перебору_списку.позначено {
      вернути;
    }

    предмет_перебору_списку.позначено = так;

    якщо предмет_перебору_списку.предмет_списку != пусто {
      позначити_предмет_списку(М, предмет_перебору_списку.предмет_списку);
    }

    якщо предмет_перебору_списку.поточне_значення.вид == ЗПредмет {
      позначити_предмет(М, предмет_перебору_списку.поточне_значення.дані як *Предмет);
    }
  }

  внутрішня дія позначити_предмет_перебору_тексту(
    М: *Машина,
    предмет_перебору_тексту: *ПредметПереборуТексту
  ) {
    якщо предмет_перебору_тексту.позначено {
      вернути;
    }

    предмет_перебору_тексту.позначено = так;

    якщо предмет_перебору_тексту.предмет_тексту != пусто {
      позначити_предмет_тексту(М, предмет_перебору_тексту.предмет_тексту);
    }
  }

  внутрішня дія позначити_складений_предмет(
    М: *Машина,
    складений_предмет: *СкладенийПредмет
  ) {
    якщо складений_предмет.позначено {
      вернути;
    }

    складений_предмет.позначено = так;

    позначити_властивості(М, складений_предмет.властивості);
  }

  внутрішня дія позначити_накопичувач_значень(
    М: *Машина,
    накопичувач_значень: НакопичувачЗначень
  ) {
    змінна п: природне = 0;

    // вивести_кд(М, "пвизначення накопичувача значень... розмір: ");
    // надрукувати_п64(М, накопичувач_значень.розмір);

    поки п < накопичувач_значень.розмір {
      якщо накопичувач_значень.дані[п].вид == ЗПредмет {
        позначити_предмет(М, накопичувач_значень.дані[п].дані як *Предмет);
      }

      п += 1;
    }
  }

  внутрішня дія позначити_спроби(
    М: *Машина,
    спроби: Спроби
  ) {
    змінна п: природне = 0;

    поки п < спроби.розмір {
      змінна спроба = спроби.дані[п];

      якщо спроба.назва_зловити != пусто {
        позначити_предмет_тексту(М, спроба.назва_зловити);
      }

      п += 1;
    }
  }

  внутрішня дія позначити_історію_здійснення(
    М: *Машина,
    історія_здійснення: ІсторіяЗдійснення
  ) {
    змінна п: природне = 0;

    // вивести_кд(М, "пвизначення історії здійснення... розмір: ");
    // надрукувати_п64(М, історія_здійснення.розмір);

    поки п < історія_здійснення.розмір {
      змінна елемент = історія_здійснення.дані[п];

      позначити_спроби(М, елемент.спроби);

      якщо елемент.середовище != пусто {
        позначити_середовище(М, елемент.середовище);
      }

      якщо елемент.здійснювач.вид == ЗПредмет {
        позначити_предмет(М, елемент.здійснювач.дані як *Предмет);
      }

      якщо елемент.предмет_дії != пусто {
        позначити_предмет_дії(М, елемент.предмет_дії);
      }

      позначити_задіяні(М, елемент.задіяні);

      позначити_місцезнаходження(М, елемент.місцезнаходження);

      п += 1;
    }
  }

  внутрішня дія позначити_місцезнаходження(
    М: *Машина,
    місцезнаходження: Місцезнаходження
  ) {
    змінна шлях = місцезнаходження.шлях_або_код як *ПредметДаних як *Предмет;

    якщо шлях != пусто {
      позначити_предмет(М, шлях);
    }
  }

  внутрішня дія позначити_константи_назв(
    М: *Машина,
    константи_назв: КонстантиНазв
  ) {
    позначити_предмет_тексту(М, М.константи_назв._значення);
    позначити_предмет_тексту(М, М.константи_назв._дійсне);
    позначити_предмет_тексту(М, М.константи_назв._Послідовність);
    позначити_предмет_тексту(М, М.константи_назв._середовище);
    позначити_предмет_тексту(М, М.константи_назв._Предмет);
    позначити_предмет_тексту(М, М.константи_назв._Структура);
    позначити_предмет_тексту(М, М.константи_назв._Модуль);
    позначити_предмет_тексту(М, М.константи_назв._Параметр);
    позначити_предмет_тексту(М, М.константи_назв._Ознака);
    позначити_предмет_тексту(М, М.константи_назв._Число);
    позначити_предмет_тексту(М, М.константи_назв._Текст);
    позначити_предмет_тексту(М, М.константи_назв._Код);
    позначити_предмет_тексту(М, М.константи_назв._Дія);
    позначити_предмет_тексту(М, М.константи_назв._Список);
    позначити_предмет_тексту(М, М.константи_назв._Словник);
    позначити_предмет_тексту(М, М.константи_назв._Дані);
    позначити_предмет_тексту(М, М.константи_назв._ПроміжокЧисел);
    позначити_предмет_тексту(М, М.константи_назв._ПеребірПроміжкаЧисел);
    позначити_предмет_тексту(М, М.константи_назв._ПеребірСписку);
    позначити_предмет_тексту(М, М.константи_назв._далі);
    позначити_предмет_тексту(М, М.константи_назв._з);
    позначити_предмет_тексту(М, М.константи_назв._довжина);
    позначити_предмет_тексту(М, М.константи_назв._0);
    позначити_предмет_тексту(М, М.константи_назв._1);
    позначити_предмет_тексту(М, М.константи_назв._модуль);
    позначити_предмет_тексту(М, М.константи_назв._пак);
    позначити_предмет_тексту(М, М.константи_назв._біб);
    позначити_предмет_тексту(М, М.константи_назв._читати);
    позначити_предмет_тексту(М, М.константи_назв._перед);
    позначити_предмет_тексту(М, М.константи_назв._розмір);
    позначити_предмет_тексту(М, М.константи_назв._чародія);
    позначити_предмет_тексту(М, М.константи_назв._чародія_число);
    позначити_предмет_тексту(М, М.константи_назв._чародія_текст);
    позначити_предмет_тексту(М, М.константи_назв._чародія_межа);
    позначити_предмет_тексту(М, М.константи_назв._чародія_перебір);
    позначити_предмет_тексту(М, М.константи_назв._чародія_послідовність);
    позначити_предмет_тексту(М, М.константи_назв._дія_перевірки);
    позначити_предмет_тексту(М, М.константи_назв._дія_перетворення);
    позначити_предмет_тексту(М, М.константи_назв._додати);
    позначити_предмет_тексту(М, М.константи_назв._забрати);
    позначити_предмет_тексту(М, М.константи_назв._знайти);
    позначити_предмет_тексту(М, М.константи_назв._знайти_позицію);
    позначити_предмет_тексту(М, М.константи_назв._відібрати);
    позначити_предмет_тексту(М, М.константи_назв._перетворити);
    позначити_предмет_тексту(М, М.константи_назв._обернути);
    позначити_предмет_тексту(М, М.константи_назв._містить);
    позначити_предмет_тексту(М, М.константи_назв._ключ);
    позначити_предмет_тексту(М, М.константи_назв._ключі);
    позначити_предмет_тексту(М, М.константи_назв._список);
    позначити_предмет_тексту(М, М.константи_назв._словник);
    позначити_предмет_тексту(М, М.константи_назв._послідовність);
    позначити_предмет_тексту(М, М.константи_назв._дані);
    позначити_предмет_тексту(М, М.константи_назв._проміжок);
    позначити_предмет_тексту(М, М.константи_назв._ПеребірПослідовності);
    позначити_предмет_тексту(М, М.константи_назв._ПеребірДаних);
    позначити_предмет_тексту(М, М.константи_назв._назва);
    позначити_предмет_тексту(М, М.константи_назв._параметри);
    позначити_предмет_тексту(М, М.константи_назв._ознаки);
    позначити_предмет_тексту(М, М.константи_назв._тип_результату);
    позначити_предмет_тексту(М, М.константи_назв._код);
    позначити_предмет_тексту(М, М.константи_назв._константи);
    позначити_предмет_тексту(М, М.константи_назв._вказівки);
    позначити_предмет_тексту(М, М.константи_назв._шлях);
    позначити_предмет_тексту(М, М.константи_назв._ПеребірСловника);
    позначити_предмет_тексту(М, М.константи_назв._ПеребірТексту);
    позначити_предмет_тексту(М, М.константи_назв._текст);
    позначити_предмет_тексту(М, М.константи_назв._система);
    позначити_предмет_тексту(М, М.константи_назв._прочитати);
    позначити_предмет_тексту(М, М.константи_назв._тип);
    позначити_предмет_тексту(М, М.константи_назв._записати);
    позначити_предмет_тексту(М, М.константи_назв._куди);
    позначити_предмет_тексту(М, М.константи_назв._дописати);
    позначити_предмет_тексту(М, М.константи_назв._видалити);
    позначити_предмет_тексту(М, М.константи_назв._створити_папку);
    позначити_предмет_тексту(М, М.константи_назв._виконати);
    позначити_предмет_тексту(М, М.константи_назв._аргументи);
    позначити_предмет_тексту(М, М.константи_назв._стдвив);
    позначити_предмет_тексту(М, М.константи_назв._стдпом);
    позначити_предмет_тексту(М, М.константи_назв._команда);
    позначити_предмет_тексту(М, М.константи_назв._с);
    позначити_предмет_тексту(М, М.константи_назв._місцезнаходження_вказівок);
    позначити_предмет_тексту(М, М.константи_назв._від);
    позначити_предмет_тексту(М, М.константи_назв._до);
    позначити_предмет_тексту(М, М.константи_назв._включно);
    позначити_предмет_тексту(М, М.константи_назв._дія_значення);
    позначити_предмет_тексту(М, М.константи_назв._позиція);
    позначити_предмет_тексту(М, М.константи_назв._Клас);
    позначити_предмет_тексту(М, М.константи_назв._предок);
    позначити_предмет_тексту(М, М.константи_назв._Перебір);
    позначити_предмет_тексту(М, М.константи_назв._виділити);
    позначити_предмет_тексту(М, М.константи_назв._обнулено);
    позначити_предмет_тексту(М, М.константи_назв._отримати_назву);
    позначити_предмет_тексту(М, М.константи_назв._афс);
    позначити_предмет_тексту(М, М.константи_назв._мат);
    позначити_предмет_тексту(М, М.константи_назв._Е);
    позначити_предмет_тексту(М, М.константи_назв._ПІ);
    позначити_предмет_тексту(М, М.константи_назв._ЛОГ2Е);
    позначити_предмет_тексту(М, М.константи_назв._ЛОГ10Е);
    позначити_предмет_тексту(М, М.константи_назв._ЛОГ2);
    позначити_предмет_тексту(М, М.константи_назв._ЛОГ10);
    позначити_предмет_тексту(М, М.константи_назв._КОРІНЬ2);
    позначити_предмет_тексту(М, М.константи_назв._КОРІНЬ1_2);
    позначити_предмет_тексту(М, М.константи_назв._син);
    позначити_предмет_тексту(М, М.константи_назв._кос);
    позначити_предмет_тексту(М, М.константи_назв._тан);
    позначити_предмет_тексту(М, М.константи_назв._асин);
    позначити_предмет_тексту(М, М.константи_назв._акос);
    позначити_предмет_тексту(М, М.константи_назв._атан);
    позначити_предмет_тексту(М, М.константи_назв._абс);
    позначити_предмет_тексту(М, М.константи_назв._експ);
    позначити_предмет_тексту(М, М.константи_назв._кор2);
    позначити_предмет_тексту(М, М.константи_назв._стеля);
    позначити_предмет_тексту(М, М.константи_назв._підлога);
    позначити_предмет_тексту(М, М.константи_назв._округлити);
    позначити_предмет_тексту(М, М.константи_назв._аввід);
    позначити_предмет_тексту(М, М.константи_назв._відклик);
    позначити_предмет_тексту(М, М.константи_назв._повідомлення);
    позначити_предмет_тексту(М, М.константи_назв._запитати);
    позначити_предмет_тексту(М, М.константи_назв._інет);
    позначити_предмет_тексту(М, М.константи_назв._іа);
    позначити_предмет_тексту(М, М.константи_назв._порт);
    позначити_предмет_тексту(М, М.константи_назв._служити);
    позначити_предмет_тексту(М, М.константи_назв._обробник_даних);
    позначити_предмет_тексту(М, М.константи_назв._обробник_підключення);
    позначити_предмет_тексту(М, М.константи_назв._обробник_відключення);
    позначити_предмет_тексту(М, М.константи_назв._обробник_стікання);
    позначити_предмет_тексту(М, М.константи_назв._обробник_помилки);
    позначити_предмет_тексту(М, М.константи_назв._надіслати);
    позначити_предмет_тексту(М, М.константи_назв._Звʼязок);
    позначити_предмет_тексту(М, М.константи_назв._Слуга);
    позначити_предмет_тексту(М, М.константи_назв._формат);
    позначити_предмет_тексту(М, М.константи_назв._закрити_підключення);
    позначити_предмет_тексту(М, М.константи_назв._зупинити);
    позначити_предмет_тексту(М, М.константи_назв._Клієнт);
    позначити_предмет_тексту(М, М.константи_назв._підключитись);
    позначити_предмет_тексту(М, М.константи_назв._обробник_закінчення);
    позначити_предмет_тексту(М, М.константи_назв._Помилка);
    позначити_предмет_тексту(М, М.константи_назв._обробник_запуску);
    позначити_предмет_тексту(М, М.константи_назв._обробник_зупинки);
    позначити_предмет_тексту(М, М.константи_назв._закінчити);
    позначити_предмет_тексту(М, М.константи_назв._знищити);
    позначити_предмет_тексту(М, М.константи_назв._обробник_підключення_звʼязку);
    позначити_предмет_тексту(М, М.константи_назв._обробник_даних_звʼязку);
    позначити_предмет_тексту(М, М.константи_назв._обробник_стікання_звʼязку);
    позначити_предмет_тексту(М, М.константи_назв._обробник_закінчення_звʼязку);
    позначити_предмет_тексту(М, М.константи_назв._обробник_помилки_звʼязку);
    позначити_предмет_тексту(М, М.константи_назв._обробник_відключення_звʼязку);
    позначити_предмет_тексту(М, М.константи_назв._зріз);
  }

  внутрішня дія позначити_взяті_значення(
    М: *Машина,
    взяті_значення: ВзятіЗначення
  ) {
    змінна п: природне = 0;

    поки п < взяті_значення.розмір {
      змінна взяте_значення = взяті_значення.дані[п]::адреса;

      якщо взяте_значення.шлях != пусто {
        позначити_предмет_даних(М, взяте_значення.шлях);
      }

      якщо взяте_значення.значення.вид == ЗПредмет {
        позначити_предмет(М, взяте_значення.значення.дані як *Предмет);
      }

      п += 1;
    }
  }

  внутрішня дія позначити_методи(
    М: *Машина,
    методи: Методи
  ) {
    змінна п: природне = 0;

    поки п < методи.розмір {
      змінна метод = методи.дані[п];

      позначити_предмет_тексту(М, метод.назва);

      якщо метод.значення != пусто {
        позначити_предмет_дії(М, метод.значення);
      }

      п += 1;
    }
  }

  внутрішня дія позначити_властивості(
    М: *Машина,
    призначення: Призначення
  ) {
    змінна п: природне = 0;

    поки п < призначення.вмісткість {
      змінна призначене = призначення.дані[п];

      поки призначене != пусто {
        позначити_предмет_тексту(М, призначене.назва);

        якщо призначене.значення.вид == ЗПредмет {
          позначити_предмет(М, призначене.значення.дані як *Предмет);
        }

        призначене = призначене.наступний;
      }

      п += 1;
    }
  }

  внутрішня дія позначити_притримувач(
    М: *Машина,
    притримувач: *Притримувач
  ) {
    змінна притриманий = притримувач.перший;

    поки притриманий != пусто {
      якщо притриманий.предмет != пусто {
        позначити_предмет(М, притриманий.предмет);
      }

      притриманий = притриманий.наступний;
    }
  }

  внутрішня дія позначити_чергу_здійснення(
    М: *Машина,
    черга_здійснення: ЧергаЗдійснення
  ) {
    змінна елемент = черга_здійснення.перший;

    поки елемент != пусто {
      якщо елемент.значення.вид == ЗПредмет {
        позначити_предмет(М, елемент.значення.дані як *Предмет);
      }
      позначити_задіяні(М, елемент.задіяні);
      елемент = елемент.наступний;
    }
  }

  внутрішня дія позначити_задіяні(
    М: *Машина,
    задіяні: Задіяні
  ) {
    якщо задіяні.вид == ВидЗадіяних1 {
      вернути; // задіяні з накопичувача діяльності будуть позначені під час позначення самого накопичувача
    }

    змінна п: п32 = 0;

    поки п < задіяні.розмір {
      якщо задіяні.дані[п].вид == ЗПредмет {
        позначити_предмет(М, задіяні.дані[п].дані як *Предмет);
      }

      п += 1;
    }
  }

  // позначка: прохід по типах предметів
  внутрішня дія позначити(
    М: *Машина
  ) {
    якщо М.шлях_до_теки_модулів != пусто {
      позначити_предмет_даних(М, М.шлях_до_теки_модулів);
    }
    якщо М.шлях_до_теки_паків != пусто {
      позначити_предмет_даних(М, М.шлях_до_теки_паків);
    }
    позначити_предмет_класу(М, М.клас_Клас);
    позначити_предмет_класу(М, М.клас_Дані);
    позначити_предмет_класу(М, М.клас_ПроміжокЧисел);
    позначити_предмет_класу(М, М.клас_Дія);
    позначити_предмет_класу(М, М.клас_Код);
    позначити_предмет_класу(М, М.клас_Модуль);
    позначити_предмет_класу(М, М.клас_Параметр);
    позначити_предмет_класу(М, М.клас_Ознака);
    позначити_предмет_класу(М, М.клас_ПеребірДаних);
    позначити_предмет_класу(М, М.клас_ПеребірПроміжкаЧисел);
    позначити_предмет_класу(М, М.клас_ПеребірПослідовності);
    позначити_предмет_класу(М, М.клас_ПеребірСловника);
    позначити_предмет_класу(М, М.клас_ПеребірСписку);
    позначити_предмет_класу(М, М.клас_ПеребірТексту);
    позначити_предмет_класу(М, М.клас_Послідовність);
    позначити_предмет_класу(М, М.клас_Словник);
    позначити_предмет_класу(М, М.клас_Список);
    позначити_предмет_класу(М, М.клас_Текст);
    позначити_предмет_класу(М, М.клас_Число);
    позначити_предмет_класу(М, М.клас_Помилка);

    позначити_предмет_послідовності(М, М.пуста_послідовність);

    позначити_середовище(М, М.глобальне_середовище);
    позначити_накопичувач_значень(М, М.накопичувач_значень);
    позначити_історію_здійснення(М, М.історія_здійснення);
    якщо М.значення_падіння.вид == ЗПредмет {
      позначити_предмет(М, М.значення_падіння.дані як *Предмет);
    }
    позначити_місцезнаходження(М, М.місцезнаходження_падіння);
    позначити_константи_назв(М, М.константи_назв);
    позначити_взяті_значення(М, М.взяті_значення);
    позначити_чергу_здійснення(М, М.черга_здійснення);

    змінна притримувач = М.глобальний_притримувач;

    поки притримувач != пусто {
      позначити_притримувач(М, притримувач);

      притримувач = притримувач.наступний;
    }

    якщо М.розмова != пусто {
      позначити_предмет_даних(М, М.розмова.шлях_до_стандартного_вводу);
      позначити_предмет_модуля(М, М.розмова.предмет_модуля);
      позначити_середовище(М, М.розмова.середовище);
    }
  }

  дія запустити_очищувач(
    М: *Машина
  ) {
    //  надрукувати_кд(М, "очищува запущено");

    позначити(М);

    змінна попередній_предмет: *Предмет = пусто;
    змінна предмет = М.перший_предмет;

    поки предмет != пусто {
      якщо предмет.позначено {
        предмет.позначено = ні;

        попередній_предмет = предмет;

        предмет = предмет.наступний;
      } інакше {
        змінна предмет_до_знищення = предмет;

        предмет = предмет.наступний;

        попередній_предмет.наступний = предмет;

        звільнити_предмет(М, предмет_до_знищення);

        М.кількість_дійсних -= 1;
      }
    }

    М.останній_предмет = попередній_предмет;

    М.кількість_дійсних_для_очищення = (М.кількість_дійсних * 5) + 1;

    М.потребує_очищення = ні;

    змінна середовище = М.перша_середовище;

    поки середовище != пусто {
      середовище.позначено = ні;

      середовище = середовище.наступна;
    }
  }
}