/* Машина Мавки */

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

  стала ЗНедійсне = 0;
  стала ЗДійсне = 1;
  стала ЗЧисло = 2;
  стала ЗМашиннийПредмет = 3;
  стала ЗСкладенийПредмет = 4;

  структура Значення {
    дані: адреса<Предмет> | д64;
    вид: п8;
  }

  стала НЕДІЙСНЕ = Значення { дані = пусто як адреса<Предмет>, вид = ЗНедійсне };
  стала ДІЙСНЕ = Значення { дані = пусто як адреса<Предмет>, вид = ЗДійсне };

  внутрішня дія ЧИ(значення: логічне) -> Значення {
    якщо значення {
      вернути ДІЙСНЕ;
    } інакше {
      вернути НЕДІЙСНЕ;
    }
  }

  внутрішня дія ЧИСЛО(значення: д64) -> Значення {
    вернути Значення { дані = значення, вид = ЗЧисло };
  }

  внутрішня дія МАШИННИЙ_ПРЕДМЕТ(предмет: невідома_адреса) -> Значення {
    вернути Значення { дані = предмет як адреса<Предмет>, вид = ЗМашиннийПредмет };
  }

  внутрішня дія СКЛАДЕНИЙ_ПРЕДМЕТ(предмет: невідома_адреса) -> Значення {
    вернути Значення { дані = предмет як адреса<Предмет>, вид = ЗСкладенийПредмет };
  }

  синонім ЗначенняАбоСтанПадіння = Значення;
  синонім СтанПадіння = ніщо;

  стала ВПокластиНедійсне = 0; // []() -> [недійсне]
  стала ВПокластиДійсне = 1; // []() -> [дійсне]
  стала ВПокластиПредмет = 3; // []() -> [Предмет]
  стала ВПокластиЯ = 4; // []() -> [значення_я]
  стала ВПокластиКонстанту = 5; // [](позиція_константи) -> [константа]
  стала ВСтворитиПослідовність = 6; // [...](кількість_елементів) -> [значення_послідовності]
  стала ВСтворитиДію = 7; // [назва, ..., тип_результату, код](кількість_параметрів) -> [предмет_дії]
  стала ВСтворитиСтруктуру = 8; // [назва, ...](кількість_параметрів) -> [предмет_структури]
  стала ВСтворитиМодуль = 9; // [назва, код]() -> [предмет_модуля]
  стала ВСтворитиСписок = 10; // [...](кількість_елементів) -> [предмет_списку]
  стала ВСтворитиСловник = 11; // [...](кількість_елементів) -> [предмет_словника]
  стала ВСтворитиДіапазон = 12; // [від, включно, до]() -> [предмет_діапазону]
  стала ВСтворитиПараметр = 13; // [назва, тип, дія_значення]() -> [параметр]
  стала ВСтворитиТип = 14; // [...](кількість_структур) -> [тип]
  стала ВЗаписатиМетод = 15; // [значення_власна, предмет_структури, назва, предмет_дії]() -> [предмет_дії]
  стала ВВизначити = 16; // [назва, значення]() -> []
  стала ВЗвернутись = 17; // [назва]() -> [предмет]
  стала ВЗдійснити = 18; // [предмет_дії, ..., ...](кількість_аргументів, кількість_іменованих_аргументів) -> [результат]
  стала ВОтриматиВластивість = 19; // [предмет, назва]() -> [предмет_властивості]
  стала ВЗмінитиВластивість = 20; // [предмет, назва, значення]() -> []
  стала ВЗдійснитиВластивість = 21; // [предмет, назва, ..., ...](кількість_аргументів, кількість_іменованих_аргументів) -> [результат]
  стала ВОтриматиЕлемент = 22; // [предмет, ключ]() -> [елемент]
  стала ВЗмінитиЕлемент = 23; // [предмет, ключ, значення]() -> []
  стала ВОтриматиПеребір = 24; // [предмет]() -> [предмет_перебору]
  стала ВДодати = 25; // [а, б]() -> [результат]
  стала ВВідняти = 26; // [а, б]() -> [результат]
  стала ВПомножити = 27; // [а, б]() -> [результат]
  стала ВПоділити = 28; // [а, б]() -> [результат]
  стала ВОтриматиОстачуДілення = 29; // [а, б]() -> [результат]
  стала ВОтриматиНеповнуЧасткуДілення = 30; // [а, б]() -> [результат]
  стала ВПіднестиДоСтепеня = 31; // [а, б]() -> [результат]
  стала ВЗсунутиВліво = 32; // [а, б]() -> [результат]
  стала ВЗсунутиВправо = 33; // [а, б]() -> [результат]
  стала ВЗсунутиВправо2 = 34; // [а, б]() -> [результат]
  стала ВДвійковеІ = 35; // [а, б]() -> [результат]
  стала ВДвійковеАБО = 36; // [а, б]() -> [результат]
  стала ВДвійковеВиключнеАБО = 37; // [а, б]() -> [результат]
  стала ВМенше = 38; // [а, б]() -> [результат]
  стала ВБільше = 39; // [а, б]() -> [результат]
  стала ВНеБільше = 40; // [а, б]() -> [результат]
  стала ВНеМенше = 41; // [а, б]() -> [результат]
  стала ВРівно = 42; // [а, б]() -> [результат]
  стала ВНеРівно = 43; // [а, б]() -> [результат]
  стала ВЄ = 46; // [а, б]() -> [результат]
  стала ВНеЄ = 47; // [а, б]() -> [результат]
  стала ВДвійковеНЕ = 48; // [а]() -> [результат]
  стала ВВідʼємне = 49; // [а]() -> [результат]
  стала ВЗаперечити = 51; // [а]() -> [результат]
  стала ВПочатиСпробу = 52; // [назва](позиція_вказівки_зловити) -> []
  стала ВВпасти = 53; // [предмет_помилки]() -> []
  стала ВЗакінчитиСпробу = 54; // [](позиція_вказівки_виходу) -> []
  стала ВВзяти = 55; // [назва, ...](кількість_назв) -> [предмет_модуля]
  стала ВДати = 56; // [предмет, назва]() -> []
  стала ВПеребратиДалі = 57; // [предмет_перебору]() -> [предмет_перебору, результат_виконання]
  стала ВЗбитиТекст = 58; // [...](кількість_предметів) -> [збитий_текст]
  стала ВСтрибнути = 59; // [](позиція_вказівки) -> []
  стала ВСтрибнутиЯкщоНедійсне = 60; // [предмет](позиція_вказівки) -> []
  стала ВЗабрати = 61; // [предмет]() -> []
  стала ВВернути = 62; // [предмет]() -> []
  стала ВСтрибнутиЯкщоДійсне = 63; // [предмет](позиція_вказівки) -> [предмет]
  стала ВДублювати = 64; // [предмет]() -> [предмет, предмет]
  стала ВВизначитиНавпаки = 65; // [значення, назва]() -> []
  стала ВВизначитиШвидко = 66; // [значення](позиція_в_дійсності) -> []
  стала ВЗвернутисьШвидко = 67; // [](позиція_в_дійсності) -> [предмет]

  структура Шлях {
    розмір: природне;
    дані: памʼять<п8>;
  }

  структура Місцезнаходження {
    шлях_або_код: адреса<ПредметДаних> | адреса<ПредметКоду>;
    рядок_або_позиція_вказівки: природне;
  }

  структура Притриманий {
    попередній: адреса<Притриманий>;
    наступний: адреса<Притриманий>;
    предмет: адреса<Предмет>;
  }

  структура Притримувач {
    наступний: адреса<Притримувач>;
    попередній: адреса<Притримувач>;
    перший: адреса<Притриманий>;
    останній: адреса<Притриманий>;
  }

  синонім ДіяПередЗнищеннямКористувацькихДаних = (М: адреса<Машина>, користувацькі_дані: адреса<КористувацькіДані>) -> ніщо;

  структура КористувацькіДані {
    значення: невідома_адреса;
    дія_перед_знищенням: ДіяПередЗнищеннямКористувацькихДаних;
  }

  структура НакопичувачТексту {
    розмір: природне;
    дані: памʼять<п8>;
    вмісткість: природне;
  }

  структура Предмет {
    наступний: адреса<Предмет>;
    позначено: логічне;
    тип: адреса<ПредметСтруктури>;
    користувацькі_дані: адреса<КористувацькіДані>;
  }

  структура ПредметПослідовності {
    наступний: адреса<Предмет>;
    позначено: логічне;
    тип: адреса<ПредметСтруктури>;
    користувацькі_дані: адреса<КористувацькіДані>;
    розмір: природне;
    елементи: памʼять<Значення>;
  }

  структура Призначене;

  структура Призначене {
    наступний: адреса<Призначене>;
    назва: адреса<ПредметТексту>;
    значення: Значення;
  }

  структура Призначення {
    розмір: природне;
    дані: памʼять<адреса<Призначене>>;
    вмісткість: природне;
  }

  структура Дійсність {
    попередня: адреса<Дійсність>;
    наступна: адреса<Дійсність>;
    позначено: логічне;
    кількість_запозичень: природне;
    зовні: адреса<Дійсність>;
    призначення: Призначення;
  }

  структура Метод {
    назва: адреса<ПредметТексту>;
    значення: адреса<ПредметДії>;
  }

  структура Методи {
    розмір: природне;
    дані: памʼять<Метод>;
  }

  структура ІменованоЗадіяне {
    назва: адреса<ПредметТексту>;
    значення: Значення;
  }

  структура ІменованіЗадіяні {
    розмір: природне;
    елементи: памʼять<ІменованоЗадіяне>;
  }

  структура Задіяні {
    розмір: природне;
    дані: памʼять<Значення>;
    розмір_імен: природне;
    дані_імен: памʼять<адреса<ПредметТексту>>;
  }

  структура Діяльність;

  синонім РіднаДія = (
    М: адреса<Машина>,
    діяльність: адреса<Діяльність>
  ) -> ЗначенняАбоСтанПадіння;

  структура ЕлементСловника {
    ключ: Значення;
    значення: Значення;
  }

  структура ПредметСтруктури {
    наступний: адреса<Предмет>;
    позначено: логічне;
    тип: адреса<ПредметСтруктури>;
    користувацькі_дані: адреса<КористувацькіДані>;
    заборонити_наслідування: логічне;
    назва: адреса<ПредметТексту>;
    параметри: адреса<ПредметПослідовності>;
    методи: Методи;
    властивості: Призначення;
  }

  структура ПредметДії {
    наступний: адреса<Предмет>;
    позначено: логічне;
    тип: адреса<ПредметСтруктури>;
    користувацькі_дані: адреса<КористувацькіДані>;
    дійсність_створення: адреса<Дійсність>;
    рідна: логічне;
    назва: адреса<ПредметТексту>;
    параметри: адреса<ПредметПослідовності>;
    тип_результату: адреса<Предмет>;
    код: адреса<ПредметКоду> | РіднаДія;
    метод_структури: адреса<ПредметСтруктури>;
    шлях_до_теки_модулів: адреса<ПредметДаних>;
  }

  структура ПредметСписку {
    наступний: адреса<Предмет>;
    позначено: логічне;
    тип: адреса<ПредметСтруктури>;
    користувацькі_дані: адреса<КористувацькіДані>;
    розмір: природне;
    елементи: памʼять<Значення>;
  }

  структура ПредметСловника {
    наступний: адреса<Предмет>;
    позначено: логічне;
    тип: адреса<ПредметСтруктури>;
    користувацькі_дані: адреса<КористувацькіДані>;
    розмір: природне;
    елементи: памʼять<ЕлементСловника>;
  }

  структура ПредметМодуля {
    наступний: адреса<Предмет>;
    позначено: логічне;
    тип: адреса<ПредметСтруктури>;
    користувацькі_дані: адреса<КористувацькіДані>;
    готовий: логічне;
    назва: адреса<ПредметТексту>;
    властивості: Призначення;
  }

  структура ПредметПараметра {
    наступний: адреса<Предмет>;
    позначено: логічне;
    тип: адреса<ПредметСтруктури>;
    користувацькі_дані: адреса<КористувацькіДані>;
    назва: адреса<ПредметТексту>;
    тип_: невідома_адреса;
    дія_значення: адреса<ПредметДії>;
  }

  структура ПредметТексту {
    наступний: адреса<Предмет>;
    позначено: логічне;
    тип: адреса<ПредметСтруктури>;
    користувацькі_дані: адреса<КористувацькіДані>;
    значення: кд;
  }

  структура МісцезнаходженняВказівки {
    початок: п32;
    кінець: п32;
    рядок: п32;
  }

  структура МісцезнаходженняВказівок {
    розмір: природне;
    дані: памʼять<МісцезнаходженняВказівки>;
  }

  структура ПредметКоду {
    наступний: адреса<Предмет>;
    позначено: логічне;
    тип: адреса<ПредметСтруктури>;
    користувацькі_дані: адреса<КористувацькіДані>;
    константи: адреса<ПредметПослідовності>;
    вказівки: адреса<ПредметДаних>;
    шлях: адреса<ПредметДаних>;
    місцезнаходження_вказівок: МісцезнаходженняВказівок;
  }

  структура ПредметДаних {
    наступний: адреса<Предмет>;
    позначено: логічне;
    тип: адреса<ПредметСтруктури>;
    користувацькі_дані: адреса<КористувацькіДані>;
    розмір: природне;
    дані: памʼять<п8>;
  }

  структура ПредметДіапазонуЧисел {
    наступний: адреса<Предмет>;
    позначено: логічне;
    тип: адреса<ПредметСтруктури>;
    користувацькі_дані: адреса<КористувацькіДані>;
    від: д64;
    до: д64;
    включно: логічне;
  }

  структура ПредметПереборуДаних {
    наступний: адреса<Предмет>;
    позначено: логічне;
    тип: адреса<ПредметСтруктури>;
    користувацькі_дані: адреса<КористувацькіДані>;
    предмет_даних: адреса<ПредметДаних>;
    почато: логічне;
    позиція: природне;
    поточне_значення: д64;
  }

  структура ПредметПереборуДіапазонуЧисел {
    наступний: адреса<Предмет>;
    позначено: логічне;
    тип: адреса<ПредметСтруктури>;
    користувацькі_дані: адреса<КористувацькіДані>;
    предмет_діапазону: адреса<ПредметДіапазонуЧисел>;
    почато: логічне;
    поточне_значення: д64;
  }

  структура ПредметПереборуПослідовності {
    наступний: адреса<Предмет>;
    позначено: логічне;
    тип: адреса<ПредметСтруктури>;
    користувацькі_дані: адреса<КористувацькіДані>;
    предмет_послідовності: адреса<ПредметПослідовності>;
    почато: логічне;
    позиція: природне;
    поточне_значення: Значення;
  }

  структура ПредметПереборуСловника {
    наступний: адреса<Предмет>;
    позначено: логічне;
    тип: адреса<ПредметСтруктури>;
    користувацькі_дані: адреса<КористувацькіДані>;
    предмет_словника: адреса<ПредметСловника>;
    почато: логічне;
    позиція: природне;
    поточне_значення: Значення;
  }

  структура ПредметПереборуСписку {
    наступний: адреса<Предмет>;
    позначено: логічне;
    тип: адреса<ПредметСтруктури>;
    користувацькі_дані: адреса<КористувацькіДані>;
    предмет_списку: адреса<ПредметСписку>;
    почато: логічне;
    позиція: природне;
    поточне_значення: Значення;
  }

  структура ПредметПереборуТексту {
    наступний: адреса<Предмет>;
    позначено: логічне;
    тип: адреса<ПредметСтруктури>;
    користувацькі_дані: адреса<КористувацькіДані>;
    предмет_тексту: адреса<ПредметТексту>;
    почато: логічне;
    позиція: природне;
    поточне_значення: д64;
  }

  структура СкладенийПредмет {
    наступний: адреса<Предмет>;
    позначено: логічне;
    тип: адреса<ПредметСтруктури>;
    користувацькі_дані: адреса<КористувацькіДані>;
    властивості: Призначення;
  }

  структура Налаштування {
    виділити_сиру_памʼять: (М: адреса<Машина>, розмір: природне) -> памʼять<п8>;
    перевиділити_сиру_памʼять: (М: адреса<Машина>, значення: памʼять<п8>, новий_розмір: природне) -> памʼять<п8>;
    звільнити_сиру_памʼять: (М: адреса<Машина>, значення: памʼять<п8>) -> ніщо;
    запанікувати: (М: адреса<Машина>, повідомлення: кд) -> ніщо;
    вивести_кд: (М: адреса<Машина>, значення: кд) -> ніщо;
    перетворити_п64_в_кд: (М: адреса<Машина>, значення: п64, вихід_текстового_значення: адреса<кд>) -> логічне;
    перетворити_ц64_в_кд: (М: адреса<Машина>, значення: ц64, вихід_текстового_значення: адреса<кд>) -> логічне;
    перетворити_д64_в_кд: (М: адреса<Машина>, значення: д64, вихід_текстового_значення: адреса<кд>) -> логічне;
    піднести_до_степеня_п64: (М: адреса<Машина>, значення: п64, степінь: п64) -> п64;
    піднести_до_степеня_ц64: (М: адреса<Машина>, значення: ц64, степінь: ц64) -> ц64;
    піднести_до_степеня_д64: (М: адреса<Машина>, значення: д64, степінь: д64) -> д64;
    взяти_модуль: (М: адреса<Машина>, шлях_до_теки_модулів: адреса<ПредметДаних>, відносно: логічне, довжина_шляху: природне, шлях: памʼять<адреса<ПредметТексту>>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
    взяти_пак: (М: адреса<Машина>, довжина_шляху: природне, шлях: памʼять<адреса<ПредметТексту>>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
    взяти_біб: (М: адреса<Машина>, довжина_шляху: природне, шлях: памʼять<адреса<ПредметТексту>>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  }

  структура НакопичувачЗначень {
    розмір: природне;
    дані: памʼять<Значення>;
    вмісткість: природне;
  }

  структура Спроба {
    назва_зловити: адреса<ПредметТексту>;
    позиція_вказівки_зловити: природне;
    розмір_історії_здійснення: природне;
    розмір_накопичувача_значень: природне;
  }

  структура Спроби {
    розмір: природне;
    дані: памʼять<Спроба>;
  }

  структура Діяльність {
    дійсність: адреса<Дійсність>;
    здійснювач: Значення;
    предмет_дії: адреса<ПредметДії>;
    задіяні: Задіяні;
    місцезнаходження: Місцезнаходження;
    спроби: Спроби;
  }

  структура ІсторіяЗдійснення {
    розмір: природне;
    дані: памʼять<Діяльність>;
    вмісткість: природне;
  }

  структура МісцезнаходженняІнформаціїПадіння {
    шлях: адреса<ПредметДаних>;
    рядок: природне;
  }

  структура ЕлементІсторіїЗдійсненняІнформаціїПадіння {
    місцезнаходження: МісцезнаходженняІнформаціїПадіння;
    назва: адреса<ПредметТексту>;
  }

  структура ІнформаціяПадіння {
    значення: Значення;
    місцезнаходження: МісцезнаходженняІнформаціїПадіння;
    розмір_історії: природне;
    історія: памʼять<ЕлементІсторіїЗдійсненняІнформаціїПадіння>;
  }

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

  структура ВзятеЗначення {
    шлях: адреса<ПредметДаних>;
    значення: Значення;
  }

  структура ВзятіЗначення {
    розмір: природне;
    дані: памʼять<ВзятеЗначення>;
  }

  структура ЕлементЧергиЗдійснення;

  структура ЕлементЧергиЗдійснення {
    наступний: адреса<ЕлементЧергиЗдійснення>;
    значення: Значення;
    задіяні: Задіяні;
  }

  структура ЧергаЗдійснення {
    перший: адреса<ЕлементЧергиЗдійснення>;
    останній: адреса<ЕлементЧергиЗдійснення>;
  }

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

  внутрішня дія ЗАПАНІКУВАТИ(М: адреса<Машина>, повідомлення: кд) {
    М.налаштування.запанікувати(М, повідомлення);
  }

  внутрішня дія виділити<Т>(М: адреса<Машина>) -> адреса<Т> {
    вернути М.налаштування.виділити_сиру_памʼять(М, Т.розмір) як адреса<Т>;
  }

  внутрішня дія виділити_памʼять<Т>(М: адреса<Машина>, кількість: природне) -> памʼять<Т> {
    вернути М.налаштування.виділити_сиру_памʼять(М, кількість * Т.розмір) як памʼять<Т>;
  }

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

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

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

  внутрішня дія вивести_кд(М: адреса<Машина>, значення: кд) {
    М.налаштування.вивести_кд(М, значення);
  }

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

  внутрішня дія перетворити_п64_в_кд(М: адреса<Машина>, значення: п64, вихід_текстового_значення: адреса<кд>) -> логічне {
    вернути М.налаштування.перетворити_п64_в_кд(М, значення, вихід_текстового_значення);
  }

  внутрішня дія перетворити_ц64_в_кд(М: адреса<Машина>, значення: ц64, вихід_текстового_значення: адреса<кд>) -> логічне {
    вернути М.налаштування.перетворити_ц64_в_кд(М, значення, вихід_текстового_значення);
  }

  внутрішня дія перетворити_д64_в_кд(М: адреса<Машина>, значення: д64, вихід_текстового_значення: адреса<кд>) -> логічне {
    вернути М.налаштування.перетворити_д64_в_кд(М, значення, вихід_текстового_значення);
  }

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

    якщо перетворити_п64_в_кд(М, значення, текстове_значення::адреса) {
      вивести_кд(М, текстове_значення);

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

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

  внутрішня дія вивести_ц64(М: адреса<Машина>, значення: ц64) {
    змінна текстове_значення: кд;

    якщо перетворити_ц64_в_кд(М, значення, текстове_значення::адреса) {
      вивести_кд(М, текстове_значення);

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

  внутрішня дія надрукувати_ц64(М: адреса<Машина>, значення: ц64) {
    вивести_ц64(М, значення);
    вивести_кд(М, "\р");
  }

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

    якщо перетворити_д64_в_кд(М, значення, текстове_значення::адреса) {
      вивести_кд(М, текстове_значення);

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

  внутрішня дія надрукувати_д64(М: адреса<Машина>, значення: д64) {
    вивести_д64(М, значення);
    вивести_кд(М, "\р");
  }

  внутрішня дія піднести_до_степеня_п64(М: адреса<Машина>, значення: п64, степінь: п64) -> п64 {
    вернути М.налаштування.піднести_до_степеня_п64(М, значення, степінь);
  }

  внутрішня дія піднести_до_степеня_ц64(М: адреса<Машина>, значення: ц64, степінь: ц64) -> ц64 {
    вернути М.налаштування.піднести_до_степеня_ц64(М, значення, степінь);
  }

  внутрішня дія піднести_до_степеня_д64(М: адреса<Машина>, значення: д64, степінь: д64) -> д64 {
    вернути М.налаштування.піднести_до_степеня_д64(М, значення, степінь);
  }
}

простір мавка {
  структура Накопичувач<Т> {
    розмір: природне;
    дані: памʼять<Т>;
    вмісткість: природне;
  }

  внутрішня дія виділити_накопичувач<Т>(М: адреса<Машина>, початкова_вмісткість: природне) -> адреса<Накопичувач<Т>> {
    змінна накопичувач = виділити<Накопичувач<Т>>();

    накопичувач.розмір = 0;
    якщо початкова_вмісткість > 0 {
      накопичувач.дані = виділити_памʼять<Т>(М, початкова_вмісткість);
    } інакше {
      накопичувач.дані = пусто;
    }
    накопичувач.вмісткість = початкова_вмісткість;

    вернути накопичувач;
  }

  внутрішня дія зробити_накопичувач<Т>(М: адреса<Машина>, початкова_вмісткість: природне) -> Накопичувач<Т> {
    змінна накопичувач: Накопичувач<Т>;

    накопичувач.розмір = 0;
    якщо початкова_вмісткість > 0 {
      накопичувач.дані = виділити_памʼять<Т>(М, початкова_вмісткість);
    } інакше {
      накопичувач.дані = пусто;
    }
    накопичувач.вмісткість = початкова_вмісткість;

    вернути накопичувач;
  }

  внутрішня дія покласти_в_накопичувач<Т>(М: адреса<Машина>, накопичувач: адреса<Накопичувач<Т>>, значення: Т) {
    якщо накопичувач.розмір == накопичувач.вмісткість {
      накопичувач.вмісткість += 1;
      накопичувач.дані = перевиділити_памʼять<Т>(М, накопичувач.дані, накопичувач.вмісткість);
    }

    накопичувач.дані[накопичувач.розмір] = значення;
    накопичувач.розмір += 1;
  }

  внутрішня дія змінити_в_накопичувачі<Т>(М: адреса<Машина>, накопичувач: адреса<Накопичувач<Т>>, позиція: природне, значення: Т) {
    якщо позиція >= накопичувач.вмісткість {
      накопичувач.вмісткість = позиція + 1;
      накопичувач.дані = перевиділити_памʼять<Т>(М, накопичувач.дані, накопичувач.вмісткість);
    }

    накопичувач.дані[позиція] = значення;
    накопичувач.розмір = позиція + 1;
  }

  внутрішня дія змінити_в_накопичувачі_без_розширення<Т>(М: адреса<Машина>, накопичувач: адреса<Накопичувач<Т>>, позиція: природне, значення: Т) {
    накопичувач.дані[позиція] = значення;
  }

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

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

      накопичувач.дані[п] = накопичувач.дані[накопичувач.розмір - п - 1];
      накопичувач.дані[накопичувач.розмір - п - 1] = тимчасове;

      п += 1;
    }
  }

  внутрішня дія звільнити_значення_накопичувача<Т>(М: адреса<Машина>, накопичувач: Накопичувач<Т>) {
    звільнити_памʼять(М, накопичувач.дані);
  }

  внутрішня дія звільнити_накопичувач<Т>(М: адреса<Машина>, накопичувач: адреса<Накопичувач<Т>>) {
    звільнити_значення_накопичувача<Т>(М, накопичувач::вміст);
    звільнити(М, накопичувач);
  }
}

простір мавка {
  внутрішня дія виділити_дійсність(М: адреса<Машина>) -> адреса<Дійсність> {
    змінна дійсність = виділити<Дійсність>(М);

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

    М.остання_дійсність.наступна = дійсність;
    М.остання_дійсність = дійсність;

    вернути дійсність;
  }

  дія звільнити_призначення(М: адреса<Машина>, призначення: Призначення);

  внутрішня дія відпустити_дійсність(М: адреса<Машина>, дійсність: адреса<Дійсність>) -> ніщо {
    дійсність.кількість_запозичень -= 1;

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

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

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

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

  внутрішня дія виділити_предмет<Т>(М: адреса<Машина>, тип: адреса<ПредметСтруктури>) -> адреса<Т> {
    змінна предмет = виділити<Т>(М);

    предмет.наступний = пусто;
    предмет.позначено = ні;
    предмет.тип = тип;
    предмет.користувацькі_дані = пусто;

    М.останній_предмет.наступний = предмет як адреса<Предмет>;
    М.останній_предмет = предмет як адреса<Предмет>;
    М.кількість_дійсних += 1;
    М.потребує_очищення = М.кількість_дійсних >= М.кількість_дійсних_для_очищення;

    вернути предмет;
  }

  // ВзятіЗначення
  дія записати_взяте_значення(М: адреса<Машина>, шлях: адреса<ПредметДаних>, значення: Значення);
  дія знайти_взяте_значення(М: адреса<Машина>, шлях: адреса<ПредметДаних>, вихід_значення: адреса<Значення>) -> логічне;
  дія видалити_взяте_значення(М: адреса<Машина>, шлях: адреса<ПредметДаних>) -> логічне;

  // Дійсність
  дія створити_дійсність(М: адреса<Машина>, зовні: адреса<Дійсність>) -> адреса<Дійсність>;
  дія записати_в_дійсність(М: адреса<Машина>, дійсність: адреса<Дійсність>, назва: адреса<ПредметТексту>, значення: Значення);
  дія знайти_в_дійсності(М: адреса<Машина>, дійсність: адреса<Дійсність>, назва: адреса<ПредметТексту>, вихід_значення: адреса<Значення>) -> логічне;

  // Призначення
  дія призначити(М: адреса<Машина>, призначення: адреса<Призначення>, назва: адреса<ПредметТексту>, значення: Значення);
  дія знайти_призначене(М: адреса<Машина>, призначення: Призначення, назва: адреса<ПредметТексту>, вихід: адреса<Значення>) -> логічне;

  // Допоміжне
  дія надрукувати_код(М: адреса<Машина>, розмір: природне, дані: памʼять<п8>, дія_виводу: (М: адреса<Машина>, значення: кд) -> ніщо);

  // Задіяні
  синонім ДіяПереборуПозиційнихЗадіяних = (М: адреса<Машина>, позиція: природне, значення: Значення, аргумент: невідома_адреса) -> ніщо;
  синонім ДіяПереборуІменованихЗадіяних = (М: адреса<Машина>, позиція: природне, назва: адреса<ПредметТексту>, значення: Значення, аргумент: невідома_адреса) -> ніщо;
  дія знайти_задіяне(М: адреса<Машина>, задіяні: Задіяні, позиція: природне, назва: адреса<ПредметТексту>, вихід_значення: адреса<Значення>) -> логічне;
  дія перебрати_позиційні_задіяні(М: адреса<Машина>, задіяні: Задіяні, дія_перебору: ДіяПереборуПозиційнихЗадіяних, аргумент: невідома_адреса);
  дія перебрати_іменовані_задіяні(М: адреса<Машина>, задіяні: Задіяні, дія_перебору: ДіяПереборуІменованихЗадіяних, аргумент: невідома_адреса);
  дія звільнити_задіяні(М: адреса<Машина>, задіяні: Задіяні);

  // Значення
  дія здійснити(М: адреса<Машина>, здійснювач: Значення, значення: Значення, задіяні: Задіяні, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія отримати_властивість(М: адреса<Машина>, предмет: Значення, назва: адреса<ПредметТексту>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія змінити_властивість(М: адреса<Машина>, предмет: Значення, назва: адреса<ПредметТексту>, значення: Значення, місцезнаходження: Місцезнаходження) -> СтанПадіння;
  дія здійснити_властивість(М: адреса<Машина>, предмет: Значення, назва: адреса<ПредметТексту>, задіяні: Задіяні, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія отримати_елемент(М: адреса<Машина>, предмет: Значення, ключ: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія змінити_елемент(М: адреса<Машина>, предмет: Значення, ключ: Значення, значення: Значення, місцезнаходження: Місцезнаходження) -> СтанПадіння;
  дія отримати_текст(М: адреса<Машина>, значення: Значення, місцезнаходження: Місцезнаходження) -> адреса<ПредметТексту>;
  дія отримати_діапазон(М: адреса<Машина>, від: Значення, до: Значення, включно: логічне, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія отримати_перебір(М: адреса<Машина>, предмет: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія виконати_додати(М: адреса<Машина>, ліво: Значення, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія виконати_відняти(М: адреса<Машина>, ліво: Значення, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія виконати_помножити(М: адреса<Машина>, ліво: Значення, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія виконати_поділити(М: адреса<Машина>, ліво: Значення, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія виконати_остача(М: адреса<Машина>, ліво: Значення, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія виконати_степінь(М: адреса<Машина>, ліво: Значення, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія виконати_вліво(М: адреса<Машина>, ліво: Значення, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія виконати_вправо(М: адреса<Машина>, ліво: Значення, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія виконати_двійкове_і(М: адреса<Машина>, ліво: Значення, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія виконати_двійкове_або(М: адреса<Машина>, ліво: Значення, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія виконати_двійкове_вабо(М: адреса<Машина>, ліво: Значення, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія виконати_менше(М: адреса<Машина>, ліво: Значення, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія виконати_більше(М: адреса<Машина>, ліво: Значення, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія виконати_двійкове_не(М: адреса<Машина>, значення: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія виконати_змінити_знак(М: адреса<Машина>, значення: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія перевірити_чи_значення_рівні(М: адреса<Машина>, а: Значення, б: Значення) -> логічне;
  дія перевірити_чи_предмет_є(М: адреса<Машина>, а: адреса<Предмет>, б: адреса<ПредметСтруктури>) -> логічне;

  // ІменованіЗадіяні
  дія створити_іменовано_задіяні(М: адреса<Машина>) -> адреса<ІменованіЗадіяні>;
  дія знищити_іменовано_задіяні(М: адреса<Машина>, іменовано_задіяні: адреса<ІменованіЗадіяні>) -> ніщо;
  дія покласти_іменовано_задіяне(М: адреса<Машина>, іменовано_задіяні: адреса<ІменованіЗадіяні>, назва: адреса<ПредметТексту>, значення: Значення);

  // ІнформаціяПадіння
  дія отримати_інформацію_падіння(М: адреса<Машина>, вихід: адреса<ІнформаціяПадіння>) -> логічне;
  дія знищити_інформацію_падіння(М: адреса<Машина>, інформація_падіння: ІнформаціяПадіння) -> ніщо;

  // КористувацькіДані
  дія створити_користувацькі_дані(М: адреса<Машина>, значення: невідома_адреса, дія_перед_знищенням: ДіяПередЗнищеннямКористувацькихДаних) -> адреса<КористувацькіДані>;

  // Машина
  дія налаштувати_машину(М: адреса<Машина>, налаштування: Налаштування);
  дія розлаштувати_машину(М: адреса<Машина>);
  дія увімкнути_стан_падіння(М: адреса<Машина>, значення_падіння: Значення, місцезнаходження_падіння: Місцезнаходження);
  дія вимкнути_стан_падіння(М: адреса<Машина>);
  дія покласти_в_історію_здійснення(М: адреса<Машина>, дійсність: адреса<Дійсність>, здійснювач: Значення, предмет_дії: адреса<ПредметДії>, задіяні: Задіяні, місцезнаходження: Місцезнаходження) -> адреса<Діяльність>;
  дія видалити_з_історії_здійснення(М: адреса<Машина>, кількість: природне);
  дія покласти_в_чергу_здійснення(М: адреса<Машина>, предмет_дії: адреса<ПредметДії>, задіяні: Задіяні);
  дія забрати_з_черги_здійснення(М: адреса<Машина>, вихід: адреса<ЕлементЧергиЗдійснення>) -> логічне;
  дія взяти_модуль(М: адреса<Машина>, шлях_до_теки_модулів: адреса<ПредметДаних>, відносно: логічне, довжина_шляху: природне, шлях: памʼять<адреса<ПредметТексту>>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія взяти_пак(М: адреса<Машина>, довжина_шляху: природне, шлях: памʼять<адреса<ПредметТексту>>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія взяти_біб(М: адреса<Машина>, довжина_шляху: природне, шлях: памʼять<адреса<ПредметТексту>>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія виконати_код(М: адреса<Машина>, накопичувач_значень: адреса<НакопичувачЗначень>, спроби: адреса<Спроби>, дійсність: адреса<Дійсність>, здійснювач: Значення, предмет_коду: адреса<ПредметКоду>, початкова_позиція_вказівки: природне, шлях_до_теки_модулів: адреса<ПредметДаних>) -> ЗначенняАбоСтанПадіння;

  // МісцезнаходженняВказівок
  дія покласти_місцезнаходження_вказівки(М: адреса<Машина>, місцезнаходження_вказівок: адреса<МісцезнаходженняВказівок>, рядок: п32, позиція_вказівки: п32);

  // НакопичувачТексту
  дія зробити_накопичувач_тексту(М: адреса<Машина>, вмісткість: природне) -> НакопичувачТексту;
  дія покласти_в_накопичувач_тексту(М: адреса<Машина>, накопичувач: адреса<НакопичувачТексту>, значення: кд);

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

  // Притримувач
  дія створити_притримувач(М: адреса<Машина>) -> адреса<Притримувач>;
  дія притримати(М: адреса<Машина>, притримувач: адреса<Притримувач>, предмет: адреса<Предмет>) -> адреса<Притриманий>;
  дія відпустити_притриманий(М: адреса<Машина>, притримувач: адреса<Притримувач>, притриманий: адреса<Притриманий>);
  дія притримати_глобально(М: адреса<Машина>, предмет: адреса<Предмет>) -> адреса<Притриманий>;
  дія відпустити_притриманий_глобально(М: адреса<Машина>, притриманий: адреса<Притриманий>);

  // Спроби
  дія покласти_спробу(М: адреса<Машина>, спроби: адреса<Спроби>, назва_зловити: адреса<ПредметТексту>, позиція_вказівки_зловити: природне) -> адреса<Спроба>;
  дія видалити_останню_спробу(М: адреса<Машина>, спроби: адреса<Спроби>);
}

простір мавка {
  // ПредметДаних
  дія заповнити_структуру_Дані(М: адреса<Машина>);
  дія створити_дані(М: адреса<Машина>, розмір: природне, дані: памʼять<п8>) -> адреса<ПредметДаних>;
  дія створити_дані_без_копіювання(М: адреса<Машина>, розмір: природне, дані: памʼять<п8>) -> адреса<ПредметДаних>;
  дія предмет_даних_отримати_властивість(М: адреса<Машина>, предмет_даних: адреса<ПредметДаних>, назва: адреса<ПредметТексту>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_даних_отримати_елемент(М: адреса<Машина>, предмет_даних: адреса<ПредметДаних>, ключ: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;

  // ПредметДіапазонуЧисел
  дія заповнити_структуру_ДіапазонЧисел(М: адреса<Машина>);
  дія створити_діапазон_чисел(М: адреса<Машина>, від: д64, до: д64, включно: логічне) -> адреса<ПредметДіапазонуЧисел>;
  дія предмет_діапазону_чисел_отримати_властивість(М: адреса<Машина>, предмет_діапазону_чисел: адреса<ПредметДіапазонуЧисел>, назва: адреса<ПредметТексту>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;

  // ПредметДії
  дія заповнити_структуру_Дія(М: адреса<Машина>);
  дія створити_дію(М: адреса<Машина>, дійсність_створення: адреса<Дійсність>, назва: адреса<ПредметТексту>, параметри: адреса<ПредметПослідовності>, тип_результату: адреса<Предмет>, код: адреса<ПредметКоду>, шлях_до_теки_модулів: адреса<ПредметДаних>) -> адреса<ПредметДії>;
  дія створити_рідну_дію(М: адреса<Машина>, назва: адреса<ПредметТексту>, параметри: адреса<ПредметПослідовності>, тип_результату: адреса<Предмет>, рідна_дія: РіднаДія, шлях_до_теки_модулів: адреса<ПредметДаних>) -> адреса<ПредметДії>;
  дія предмет_дії_здійснити(М: адреса<Машина>, здійснювач: Значення, предмет_дії: адреса<ПредметДії>, задіяні: Задіяні, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_дії_отримати_властивість(М: адреса<Машина>, предмет_дії: адреса<ПредметДії>, назва: адреса<ПредметТексту>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;

  // ПредметКоду
  дія заповнити_структуру_Код(М: адреса<Машина>);
  дія створити_код(М: адреса<Машина>, константи: адреса<ПредметПослідовності>, вказівки: адреса<ПредметДаних>, шлях: адреса<ПредметДаних>, місцезнаходження_вказівок: МісцезнаходженняВказівок) -> адреса<ПредметКоду>;
  дія предмет_коду_отримати_властивість(М: адреса<Машина>, предмет_коду: адреса<ПредметКоду>, назва: адреса<ПредметТексту>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія знайти_рядок_вказівки(місцезнаходження_вказівок: МісцезнаходженняВказівок, позиція_вказівки: п32) -> п32;

  // ПредметМодуля
  дія заповнити_структуру_Модуль(М: адреса<Машина>);
  дія створити_модуль(М: адреса<Машина>, назва: адреса<ПредметТексту>) -> адреса<ПредметМодуля>;
  дія предмет_модуля_отримати_властивість(М: адреса<Машина>, предмет_модуля: адреса<ПредметМодуля>, назва: адреса<ПредметТексту>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_модуля_змінити_властивість(М: адреса<Машина>, предмет_модуля: адреса<ПредметМодуля>, назва: адреса<ПредметТексту>, значення: Значення, місцезнаходження: Місцезнаходження);

  // ПредметПараметра
  дія заповнити_структуру_Параметр(М: адреса<Машина>);
  дія створити_параметр(М: адреса<Машина>, назва: адреса<ПредметТексту>, тип: адреса<Предмет>, дія_значення: адреса<ПредметДії>) -> адреса<ПредметПараметра>;
  дія предмет_параметра_отримати_властивість(М: адреса<Машина>, предмет_параметра: адреса<ПредметПараметра>, назва: адреса<ПредметТексту>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;

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

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

  // ПредметПереборуПослідовності
  дія заповнити_структуру_ПеребірПослідовності(М: адреса<Машина>);
  дія створити_перебір_послідовності(М: адреса<Машина>, предмет_послідовності: адреса<ПредметПослідовності>) -> адреса<ПредметПереборуПослідовності>;
  дія предмет_перебору_послідовності_отримати_властивість(М: адреса<Машина>, предмет_перебору_послідовності: адреса<ПредметПереборуПослідовності>, назва: адреса<ПредметТексту>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;

  // ПредметПереборуСловника
  дія заповнити_структуру_ПеребірСловника(М: адреса<Машина>);
  дія створити_перебір_словника(М: адреса<Машина>, предмет_словника: адреса<ПредметСловника>) -> адреса<ПредметПереборуСловника>;
  дія предмет_перебору_словника_отримати_властивість(М: адреса<Машина>, предмет_перебору_словника: адреса<ПредметПереборуСловника>, назва: адреса<ПредметТексту>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;

  // ПредметПереборуСписку
  дія заповнити_структуру_ПеребірСписку(М: адреса<Машина>);
  дія створити_перебір_списку(М: адреса<Машина>, предмет_списку: адреса<ПредметСписку>) -> адреса<ПредметПереборуСписку>;
  дія предмет_перебору_списку_отримати_властивість(М: адреса<Машина>, предмет_перебору_списку: адреса<ПредметПереборуСписку>, назва: адреса<ПредметТексту>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;

  // ПредметПереборуТексту
  дія заповнити_структуру_ПеребірТексту(М: адреса<Машина>);
  дія створити_перебір_тексту(М: адреса<Машина>, предмет_тексту: адреса<ПредметТексту>) -> адреса<ПредметПереборуТексту>;
  дія предмет_перебору_тексту_отримати_властивість(М: адреса<Машина>, предмет_перебору_тексту: адреса<ПредметПереборуТексту>, назва: адреса<ПредметТексту>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;

  // ПредметПослідовності
  дія заповнити_структуру_Послідовність(М: адреса<Машина>);
  дія створити_послідовність(М: адреса<Машина>, розмір: природне, елементи: памʼять<Значення>) -> адреса<ПредметПослідовності>;
  дія створити_послідовність_без_копіювання(М: адреса<Машина>, розмір: природне, елементи: памʼять<Значення>) -> адреса<ПредметПослідовності>;
  дія створити_сиру_послідовність(М: адреса<Машина>, розмір: природне) -> адреса<ПредметПослідовності>;
  дія предмет_послідовності_отримати_властивість(М: адреса<Машина>, предмет_послідовності: адреса<ПредметПослідовності>, назва: адреса<ПредметТексту>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_послідовності_отримати_елемент(М: адреса<Машина>, предмет_послідовності: адреса<ПредметПослідовності>, ключ: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;

  // ПредметСловника
  дія заповнити_структуру_Словник(М: адреса<Машина>);
  дія створити_словник(М: адреса<Машина>) -> адреса<ПредметСловника>;
  дія предмет_словника_отримати_властивість(М: адреса<Машина>, предмет_словника: адреса<ПредметСловника>, назва: адреса<ПредметТексту>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_словника_отримати_елемент(М: адреса<Машина>, предмет_словника: адреса<ПредметСловника>, ключ: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_словника_змінити_елемент(М: адреса<Машина>, предмет_словника: адреса<ПредметСловника>, ключ: Значення, значення_елемента: Значення, місцезнаходження: Місцезнаходження) -> СтанПадіння;
  дія записати_в_словник(М: адреса<Машина>, словник: адреса<ПредметСловника>, ключ: Значення, значення: Значення);

  // ПредметСписку
  дія заповнити_структуру_Список(М: адреса<Машина>);
  дія створити_список(М: адреса<Машина>, розмір: природне) -> адреса<ПредметСписку>;
  дія предмет_списку_отримати_властивість(М: адреса<Машина>, предмет_списку: адреса<ПредметСписку>, назва: адреса<ПредметТексту>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_списку_отримати_елемент(М: адреса<Машина>, предмет_списку: адреса<ПредметСписку>, ключ: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_списку_змінити_елемент(М: адреса<Машина>, предмет_списку: адреса<ПредметСписку>, ключ: Значення, значення_елемента: Значення, місцезнаходження: Місцезнаходження) -> СтанПадіння;
  дія записати_в_список(М: адреса<Машина>, предмет_списку: адреса<ПредметСписку>, позиція: природне, значення: Значення);

  // ПредметСтруктури
  дія заповнити_структуру_Структура(М: адреса<Машина>);
  дія створити_структуру(М: адреса<Машина>, назва: адреса<ПредметТексту>, параметри: адреса<ПредметПослідовності>) -> адреса<ПредметСтруктури>;
  дія предмет_структури_здійснити(М: адреса<Машина>, значення: адреса<ПредметСтруктури>, задіяні: Задіяні, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія знайти_метод_в_структурі(М: адреса<Машина>, предмет_структури: адреса<ПредметСтруктури>, назва: адреса<ПредметТексту>) -> адреса<ПредметДії>;
  дія записати_метод_структури(М: адреса<Машина>, предмет_структури: адреса<ПредметСтруктури>, назва: адреса<ПредметТексту>, значення_дії: адреса<ПредметДії>);
  дія предмет_структури_отримати_властивість(М: адреса<Машина>, предмет_структури: адреса<ПредметСтруктури>, назва: адреса<ПредметТексту>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_структури_змінити_властивість(М: адреса<Машина>, предмет_структури: адреса<ПредметСтруктури>, назва: адреса<ПредметТексту>, значення: Значення, місцезнаходження: Місцезнаходження);

  // ПредметТексту
  дія заповнити_структуру_Текст(М: адреса<Машина>);
  дія створити_текст(М: адреса<Машина>, значення: кд) -> адреса<ПредметТексту>;
  дія створити_текст_без_копіювання(М: адреса<Машина>, розмір: природне, дані: памʼять<п8>) -> адреса<ПредметТексту>;
  дія предмет_тексту_отримати_властивість(М: адреса<Машина>, предмет_тексту: адреса<ПредметТексту>, назва: адреса<ПредметТексту>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_тексту_отримати_елемент(М: адреса<Машина>, предмет_тексту: адреса<ПредметТексту>, ключ: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія перевірити_чи_предмети_тексту_рівні(М: адреса<Машина>, а: адреса<ПредметТексту>, б: адреса<ПредметТексту>) -> логічне;

  // ПредметЧисла
  дія заповнити_структуру_Число(М: адреса<Машина>);
  дія створити_число(М: адреса<Машина>, значення: д64) -> Значення;
  дія предмет_числа_додати(М: адреса<Машина>, значення: д64, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_числа_відняти(М: адреса<Машина>, значення: д64, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_числа_помножити(М: адреса<Машина>, значення: д64, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_числа_поділити(М: адреса<Машина>, значення: д64, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_числа_остача(М: адреса<Машина>, значення: д64, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_числа_степінь(М: адреса<Машина>, значення: д64, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_числа_вліво(М: адреса<Машина>, значення: д64, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_числа_вправо(М: адреса<Машина>, значення: д64, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_числа_двійкове_і(М: адреса<Машина>, значення: д64, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_числа_двійкове_або(М: адреса<Машина>, значення: д64, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_числа_двійкове_вабо(М: адреса<Машина>, значення: д64, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_числа_менше(М: адреса<Машина>, значення: д64, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_числа_більше(М: адреса<Машина>, значення: д64, право: Значення, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_числа_двійкове_не(М: адреса<Машина>, значення: д64, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_числа_змінити_знак(М: адреса<Машина>, значення: д64, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія предмет_числа_отримати_властивість(М: адреса<Машина>, значення: д64, назва: адреса<ПредметТексту>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;

  // СкладенийПредмет
  дія створити_складений_предмет(М: адреса<Машина>, значення_структури: адреса<ПредметСтруктури>) -> адреса<СкладенийПредмет>;
  дія складений_предмет_отримати_властивість(М: адреса<Машина>, складений_предмет: адреса<СкладенийПредмет>, назва: адреса<ПредметТексту>, місцезнаходження: Місцезнаходження) -> ЗначенняАбоСтанПадіння;
  дія складений_предмет_змінити_властивість(М: адреса<Машина>, складений_предмет: адреса<СкладенийПредмет>, назва: адреса<ПредметТексту>, значення: Значення, місцезнаходження: Місцезнаходження) -> СтанПадіння;
}

простір мавка {
  внутрішня дія ПРЕДМЕТ(М: адреса<Машина>, невідомий_предмет: невідома_адреса) -> Значення {
    змінна предмет = невідомий_предмет як адреса<Предмет>;

    якщо предмет.тип == М.предмет_структури_Структура {
      вернути МАШИННИЙ_ПРЕДМЕТ(предмет);
    }

    якщо предмет.тип == М.предмет_структури_Модуль {
      вернути МАШИННИЙ_ПРЕДМЕТ(предмет);
    }

    якщо предмет.тип == М.предмет_структури_Параметр {
      вернути МАШИННИЙ_ПРЕДМЕТ(предмет);
    }

    якщо предмет.тип == М.предмет_структури_Число {
      вернути МАШИННИЙ_ПРЕДМЕТ(предмет);
    }

    якщо предмет.тип == М.предмет_структури_Текст {
      вернути МАШИННИЙ_ПРЕДМЕТ(предмет);
    }

    якщо предмет.тип == М.предмет_структури_Код {
      вернути МАШИННИЙ_ПРЕДМЕТ(предмет);
    }

    якщо предмет.тип == М.предмет_структури_Дія {
      вернути МАШИННИЙ_ПРЕДМЕТ(предмет);
    }

    якщо предмет.тип == М.предмет_структури_Список {
      вернути МАШИННИЙ_ПРЕДМЕТ(предмет);
    }

    якщо предмет.тип == М.предмет_структури_Словник {
      вернути МАШИННИЙ_ПРЕДМЕТ(предмет);
    }

    якщо предмет.тип == М.предмет_структури_Дані {
      вернути МАШИННИЙ_ПРЕДМЕТ(предмет);
    }

    якщо предмет.тип == М.предмет_структури_ДіапазонЧисел {
      вернути МАШИННИЙ_ПРЕДМЕТ(предмет);
    }

    якщо предмет.тип == М.предмет_структури_ПеребірДіапазонуЧисел {
      вернути МАШИННИЙ_ПРЕДМЕТ(предмет);
    }

    якщо предмет.тип == М.предмет_структури_ПеребірДаних {
      вернути МАШИННИЙ_ПРЕДМЕТ(предмет);
    }

    якщо предмет.тип == М.предмет_структури_ПеребірПослідовності {
      вернути МАШИННИЙ_ПРЕДМЕТ(предмет);
    }

    якщо предмет.тип == М.предмет_структури_ПеребірСловника {
      вернути МАШИННИЙ_ПРЕДМЕТ(предмет);
    }

    якщо предмет.тип == М.предмет_структури_ПеребірСписку {
      вернути МАШИННИЙ_ПРЕДМЕТ(предмет);
    }

    якщо предмет.тип == М.предмет_структури_ПеребірТексту {
      вернути МАШИННИЙ_ПРЕДМЕТ(предмет);
    }

    якщо предмет.тип == М.предмет_структури_Послідовність {
      вернути МАШИННИЙ_ПРЕДМЕТ(предмет);
    }

    вернути СКЛАДЕНИЙ_ПРЕДМЕТ(предмет);
  }

  внутрішня дія ПАДІННЯ(М: адреса<Машина>, предмет_тексту: адреса<ПредметТексту>) -> Значення {
    увімкнути_стан_падіння(
      М,
      МАШИННИЙ_ПРЕДМЕТ(предмет_тексту),
      Місцезнаходження { пусто, 0 }
    );

    вернути НЕДІЙСНЕ;
  }

  внутрішня дія МІСЦЕПАДІННЯ(М: адреса<Машина>, предмет_тексту: адреса<ПредметТексту>, місцезнаходження: Місцезнаходження) -> Значення {
    увімкнути_стан_падіння(
      М,
      МАШИННИЙ_ПРЕДМЕТ(предмет_тексту),
      місцезнаходження
    );

    вернути НЕДІЙСНЕ;
  }
}