// 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;
    }
  }

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

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

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

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

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

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

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

      п += 1;
    }

    п = 0;

    поки п < задіяні.розмір_імен {
      позначити_предмет_тексту(М, задіяні.дані_імен[п]);

      п += 1;
    }
  }

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

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

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

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

      п += 1;
    }
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      дійсність = дійсність.наступна;
    }
  }
}