Код.ц

взяти визначення МаМа;

секція МаМа {
  місцева дія виділити_код(М: адреса<Машина>, шлях_до_файлу: ю8): адреса<Код> {
    ціль код = виділити<Код>(М);
    якщо виділити_копію_ю8_цілі(М, шлях_до_файлу, код.шлях_до_файлу::адреса) == ні {
      ПОМЕРТИ(М, ю8"Не вдалося виділити копію Ю8");
    }
    код.накопичувач_вказівок = зробити_накопичувач<позитивне>(М);
    код.накопичувач_місцезнаходжень_вказівок = зробити_накопичувач<МісцезнаходженняВказівки>(М);
    вернути код;
  }

  місцева дія додати_вказівку_до_коду(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, вказівка: позитивне): позитивне {
    покласти_в_накопичувач<позитивне>(М, код.накопичувач_вказівок::адреса, вказівка);
    покласти_в_накопичувач<МісцезнаходженняВказівки>(М, код.накопичувач_місцезнаходжень_вказівок::адреса, МісцезнаходженняВказівки {
      позиція_вказівки = код.накопичувач_вказівок.розмір - 1,
      рядок = рядок
    });
    вернути код.накопичувач_вказівок.розмір - 1;
  }

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

  місцева дія додати_вказівку_до_коду_з_двома_аргументами(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, вказівка: позитивне, аргумент1: позитивне, аргумент2: позитивне): позитивне {
    покласти_в_накопичувач<позитивне>(М, код.накопичувач_вказівок::адреса, вказівка);
    покласти_в_накопичувач<позитивне>(М, код.накопичувач_вказівок::адреса, аргумент1);
    покласти_в_накопичувач<позитивне>(М, код.накопичувач_вказівок::адреса, аргумент2);
    покласти_в_накопичувач<МісцезнаходженняВказівки>(М, код.накопичувач_місцезнаходжень_вказівок::адреса, МісцезнаходженняВказівки {
      позиція_вказівки = код.накопичувач_вказівок.розмір - 1 - 1 - 1,
      рядок = рядок
    });
    вернути код.накопичувач_вказівок.розмір - 1 - 1 - 1;
  }

  місцева дія покласти_вказівку_ПокластиПусто(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВПокластиПусто);
  }

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

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

  місцева дія покласти_вказівку_ПокластиКонстанту(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, позиція_константи: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_аргументом(М, код, рядок, ВПокластиКонстанту, позиція_константи);
  }

  місцева дія покласти_вказівку_СтворитиДію(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, позиція_коду: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_аргументом(М, код, рядок, ВСтворитиДію, позиція_коду);
  }

  місцева дія покласти_вказівку_СтворитиСтруктуру(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВСтворитиСтруктуру);
  }

  місцева дія покласти_вказівку_СтворитиМодуль(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, позиція_коду: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_аргументом(М, код, рядок, ВСтворитиМодуль, позиція_коду);
  }

  місцева дія покласти_вказівку_СтворитиСписок(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, розмір: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_аргументом(М, код, рядок, ВСтворитиСписок, розмір);
  }

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

  місцева дія покласти_вказівку_СтворитиСловник(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, розмір: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_аргументом(М, код, рядок, ВСтворитиСловник, розмір);
  }

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

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

  місцева дія покласти_вказівку_ПокластиЯ(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВПокластиЯ);
  }

  місцева дія покласти_вказівку_ЗаписатиМетод(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, позиція_назви: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_аргументом(М, код, рядок, ВЗаписатиМетод, позиція_назви);
  }

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

  місцева дія покласти_вказівку_Звернутись(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, позиція_назви: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_аргументом(М, код, рядок, ВЗвернутись, позиція_назви);
  }

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

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

  місцева дія покласти_вказівку_ОтриматиВластивість(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, позиція_назви: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_аргументом(М, код, рядок, ВОтриматиВластивість, позиція_назви);
  }

  місцева дія покласти_вказівку_ЗмінитиВластивість(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, позиція_назви: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_аргументом(М, код, рядок, ВЗмінитиВластивість, позиція_назви);
  }

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

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

  місцева дія покласти_вказівку_ОтриматиЕлемент(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВОтриматиЕлемент);
  }

  місцева дія покласти_вказівку_ЗмінитиЕлемент(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВЗмінитиЕлемент);
  }

  місцева дія покласти_вказівку_ОтриматиПеребір(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВОтриматиПеребір);
  }

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

  місцева дія покласти_вказівку_ВиконатиЗПредка(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, позиція_назви: позитивне, кількість_аргументів: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_двома_аргументами(М, код, рядок, ВВиконатиЗПредка, позиція_назви, кількість_аргументів);
  }

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

  місцева дія покласти_вказівку_Видалити(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, позиція_назви: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_аргументом(М, код, рядок, ВВидалити, позиція_назви);
  }

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

  місцева дія покласти_вказівку_ВидалитиЕлемент(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВВидалитиЕлемент);
  }

  місцева дія покласти_вказівку_Додати(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВДодати);
  }

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

  місцева дія покласти_вказівку_Помножити(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВПомножити);
  }

  місцева дія покласти_вказівку_Поділити(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВПоділити);
  }

  місцева дія покласти_вказівку_ОтриматиОстачуДілення(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВОтриматиОстачуДілення);
  }

  місцева дія покласти_вказівку_ОтриматиНеповнуЧасткуДілення(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВОтриматиНеповнуЧасткуДілення);
  }

  місцева дія покласти_вказівку_ПіднестиДоСтепеня(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВПіднестиДоСтепеня);
  }

  місцева дія покласти_вказівку_ЗсунутиВліво(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВЗсунутиВліво);
  }

  місцева дія покласти_вказівку_ЗсунутиВправо(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВЗсунутиВправо);
  }

  місцева дія покласти_вказівку_ЗсунутиВправоЗіЗаповненням(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВЗсунутиВправоЗіЗаповненням);
  }

  місцева дія покласти_вказівку_ДвійковеІ(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВДвійковеІ);
  }

  місцева дія покласти_вказівку_ДвійковеАБО(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВДвійковеАБО);
  }

  місцева дія покласти_вказівку_ДвійковеВиключнеАБО(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВДвійковеВиключнеАБО);
  }

  місцева дія покласти_вказівку_ДвійковеНЕ(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВДвійковеНЕ);
  }

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

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

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

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

  місцева дія покласти_вказівку_Рівно(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВРівно);
  }

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

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

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

  місцева дія покласти_вказівку_Є(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВЄ);
  }

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

  місцева дія покласти_вказівку_Відʼємне(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВВідʼємне);
  }

  місцева дія покласти_вказівку_Числове(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВЧислове);
  }

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

  місцева дія покласти_вказівку_Збільшити(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВЗбільшити);
  }

  місцева дія покласти_вказівку_ЗбільшитиПопереднє(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВЗбільшитиПопереднє);
  }

  місцева дія покласти_вказівку_Зменшити(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВЗменшити);
  }

  місцева дія покласти_вказівку_ПочатиСпробу(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, позиція_вказівки_зловити: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_аргументом(М, код, рядок, ВПочатиСпробу, позиція_вказівки_зловити);
  }

  місцева дія покласти_вказівку_ПочатиСпробуЗНазвою(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, позиція_вказівки_зловити: позитивне, позиція_назви: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_двома_аргументами(М, код, рядок, ВПочатиСпробуЗНазвою, позиція_вказівки_зловити, позиція_назви);
  }

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

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

  місцева дія покласти_вказівку_ЗакінчитиСпробу(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, позиція_вказівки_виходу: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_аргументом(М, код, рядок, ВЗакінчитиСпробу, позиція_вказівки_виходу);
  }

  місцева дія покласти_вказівку_Взяти(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, позиція_назви: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_аргументом(М, код, рядок, ВВзяти, позиція_назви);
  }

  місцева дія покласти_вказівку_Дати(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, позиція_назви: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_аргументом(М, код, рядок, ВДати, позиція_назви);
  }

  місцева дія покласти_вказівку_ПокластиРеєстрАргументівЗНазвами(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВПокластиРеєстрАргументівЗНазвами);
  }

  місцева дія покласти_вказівку_ЗареєструватиАргументЗНазвою(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, позиція_назви: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_аргументом(М, код, рядок, ВЗареєструватиАргументЗНазвою, позиція_назви);
  }

  місцева дія покласти_вказівку_ПокластиРеєстрПараметрів(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВПокластиРеєстрПараметрів);
  }

  місцева дія покласти_вказівку_ЗареєструватиПараметр(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, позиція_назви: позитивне, кількість_типів: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_двома_аргументами(М, код, рядок, ВЗареєструватиПараметр, позиція_назви, кількість_типів);
  }

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

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

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

  місцева дія покласти_вказівку_Стрибнути(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, позиція_вказівки: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_аргументом(М, код, рядок, ВСтрибнути, позиція_вказівки);
  }

  місцева дія покласти_вказівку_СтрибнутиЯкщоНі(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, позиція_вказівки: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_аргументом(М, код, рядок, ВСтрибнутиЯкщоНі, позиція_вказівки);
  }

  місцева дія покласти_вказівку_СтрибнутиЯкщоНіЗалишивши(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, позиція_вказівки: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_аргументом(М, код, рядок, ВСтрибнутиЯкщоНіЗалишивши, позиція_вказівки);
  }

  місцева дія покласти_вказівку_СтрибнутиЯкщоТак(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, позиція_вказівки: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_аргументом(М, код, рядок, ВСтрибнутиЯкщоТак, позиція_вказівки);
  }

  місцева дія покласти_вказівку_СтрибнутиЯкщоТакЗалишивши(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне, позиція_вказівки: позитивне): позитивне {
    вернути додати_вказівку_до_коду_з_аргументом(М, код, рядок, ВСтрибнутиЯкщоТакЗалишивши, позиція_вказівки);
  }

  місцева дія покласти_вказівку_Дублювати(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВДублювати);
  }

  місцева дія покласти_вказівку_ДублюватиПопереднє(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВДублюватиПопереднє);
  }

  місцева дія покласти_вказівку_Забрати(М: адреса<Машина>, код: адреса<Код>, рядок: позитивне): позитивне {
    вернути додати_вказівку_до_коду(М, код, рядок, ВЗабрати);
  }

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

  місцева дія надрукувати_код(М: адреса<Машина>, код: адреса<Код>) {
    змінна ціль п: позитивне;
    надрукувати_Ю8(М, ю8"Вказівки:");
    п = 0;
    поки п < код.накопичувач_вказівок.розмір {
      вивести_Ю8(М, ю8" ");
      ціль вказівка = код.накопичувач_вказівок.дані[п];
      якщо вказівка == ВПокластиПусто {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ПокластиПусто");
      } інакше якщо вказівка == ВПокластиТак {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ПокластиТак");
      } інакше якщо вказівка == ВПокластиНі {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ПокластиНі");
      } інакше якщо вказівка == ВПокластиКонстанту {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ПокластиКонстанту");
        п += 1;
      } інакше якщо вказівка == ВСтворитиДію {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" СтворитиДію");
        п += 1;
      } інакше якщо вказівка == ВСтворитиСтруктуру {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" СтворитиСтруктуру");
      } інакше якщо вказівка == ВСтворитиМодуль {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" СтворитиМодуль");
        п += 1;
      } інакше якщо вказівка == ВСтворитиСписок {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" СтворитиСписок");
        п += 1;
      } інакше якщо вказівка == ВПокластиВСписок {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ПокластиВСписок");
      } інакше якщо вказівка == ВСтворитиСловник {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" СтворитиСловник");
        п += 1;
      } інакше якщо вказівка == ВПокластиВСловник {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ПокластиВСловник");
      } інакше якщо вказівка == ВПокластиСтруктуруПредмет {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ПокластиСтруктуруПредмет");
      } інакше якщо вказівка == ВПокластиЯ {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ПокластиЯ");
      } інакше якщо вказівка == ВЗаписатиМетод {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ЗаписатиМетод");
        п += 1;
      } інакше якщо вказівка == ВВизначити {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Визначити");
        п += 1;
      } інакше якщо вказівка == ВЗвернутись {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Звернутись");
        п += 1;
      } інакше якщо вказівка == ВВиконати {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Виконати");
        п += 1;
      } інакше якщо вказівка == ВВиконатиЗНазвами {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ВиконатиЗНазвами");
        п += 1;
      } інакше якщо вказівка == ВОтриматиВластивість {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ОтриматиВластивість");
        п += 1;
      } інакше якщо вказівка == ВЗмінитиВластивість {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ЗмінитиВластивість");
        п += 1;
      } інакше якщо вказівка == ВВиконатиВластивість {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ВиконатиВластивість");
        п += 1;
        п += 1;
      } інакше якщо вказівка == ВВиконатиВластивістьЗНазвами {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ВиконатиВластивістьЗНазвами");
        п += 1;
        п += 1;
      } інакше якщо вказівка == ВОтриматиЕлемент {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ОтриматиЕлемент");
      } інакше якщо вказівка == ВЗмінитиЕлемент {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ЗмінитиЕлемент");
      } інакше якщо вказівка == ВОтриматиПеребір {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ОтриматиПеребір");
      } інакше якщо вказівка == ВВизначитиЗзовні {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ВизначитиЗзовні");
        п += 1;
      } інакше якщо вказівка == ВВиконатиЗПредка {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ВиконатиЗПредка");
        п += 1;
        п += 1;
      } інакше якщо вказівка == ВВиконатиЗПредкаЗНазвами {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ВиконатиЗПредкаЗНазвами");
        п += 1;
        п += 1;
      } інакше якщо вказівка == ВВидалити {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Видалити");
        п += 1;
      } інакше якщо вказівка == ВВидалитиВластивість {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ВидалитиВластивість");
        п += 1;
      } інакше якщо вказівка == ВВидалитиЕлемент {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ВидалитиЕлемент");
      } інакше якщо вказівка == ВДодати {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Додати");
      } інакше якщо вказівка == ВВідняти {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Відняти");
      } інакше якщо вказівка == ВПомножити {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Помножити");
      } інакше якщо вказівка == ВПоділити {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Поділити");
      } інакше якщо вказівка == ВОтриматиОстачуДілення {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ОтриматиОстачуДілення");
      } інакше якщо вказівка == ВОтриматиНеповнуЧасткуДілення {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ОтриматиНеповнуЧасткуДілення");
      } інакше якщо вказівка == ВПіднестиДоСтепеня {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ПіднестиДоСтепеня");
      } інакше якщо вказівка == ВЗсунутиВліво {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ЗсунутиВліво");
      } інакше якщо вказівка == ВЗсунутиВправо {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ЗсунутиВправо");
      } інакше якщо вказівка == ВЗсунутиВправоЗіЗаповненням {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ЗсунутиВправоЗіЗаповненням");
      } інакше якщо вказівка == ВДвійковеІ {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ДвійковеІ");
      } інакше якщо вказівка == ВДвійковеАБО {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ДвійковеАБО");
      } інакше якщо вказівка == ВДвійковеВиключнеАБО {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ДвійковеВиключнеАБО");
      } інакше якщо вказівка == ВДвійковеНЕ {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ДвійковеНЕ");
      } інакше якщо вказівка == ВМенше {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Менше");
      } інакше якщо вказівка == ВБільше {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Більше");
      } інакше якщо вказівка == ВНеБільше {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" НеБільше");
      } інакше якщо вказівка == ВНеМенше {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" НеМенше");
      } інакше якщо вказівка == ВРівно {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Рівно");
      } інакше якщо вказівка == ВНеРівно {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" НеРівно");
      } інакше якщо вказівка == ВМістить {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Містить");
      } інакше якщо вказівка == ВНеМістить {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" НеМістить");
      } інакше якщо вказівка == ВЄ {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Є");
      } інакше якщо вказівка == ВНеЄ {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" НеЄ");
      } інакше якщо вказівка == ВВідʼємне {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Відʼємне");
      } інакше якщо вказівка == ВЧислове {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Числове");
      } інакше якщо вказівка == ВЗаперечити {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Заперечити");
      }  інакше якщо вказівка == ВЗбільшити {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Збільшити");
      }  інакше якщо вказівка == ВЗбільшитиПопереднє {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ЗбільшитиПопереднє");
      }  інакше якщо вказівка == ВЗменшити {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Зменшити");
      } інакше якщо вказівка == ВПочатиСпробу {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ПочатиСпробу");
        п += 1;
      } інакше якщо вказівка == ВПочатиСпробуЗНазвою {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ПочатиСпробуЗНазвою");
        п += 1;
        п += 1;
      } інакше якщо вказівка == ВПеребратиДалі {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ПеребратиДалі");
      } інакше якщо вказівка == ВВпасти {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Впасти");
      } інакше якщо вказівка == ВЗакінчитиСпробу {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ЗакінчитиСпробу");
        п += 1;
      } інакше якщо вказівка == ВВзяти {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Взяти");
        п += 1;
      } інакше якщо вказівка == ВДати {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Дати");
        п += 1;
      } інакше якщо вказівка == ВПокластиРеєстрАргументівЗНазвами {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ПокластиРеєстрАргументівЗНазвами");
      } інакше якщо вказівка == ВЗареєструватиАргументЗНазвою {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ЗареєструватиАргументЗНазвою");
        п += 1;
      } інакше якщо вказівка == ВПокластиРеєстрПараметрів {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ПокластиРеєстрПараметрів");
      } інакше якщо вказівка == ВЗареєструватиПараметр {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ЗареєструватиПараметр");
        п += 1;
        п += 1;
      } інакше якщо вказівка == ВТриматиКод {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ТриматиКод");
        п += 1;
      } інакше якщо вказівка == ВНакопичитиНазву {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" НакопичитиНазву");
        п += 1;
      } інакше якщо вказівка == ВТриматиНазву {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ТриматиНазву");
        п += 1;
      } інакше якщо вказівка == ВСтрибнути {
        вивести_п64(М, п64(п));
        вивести_Ю8(М, ю8" Стрибнути ");
        п += 1;
        надрукувати_п64(М, п64(код.накопичувач_вказівок.дані[п]));
      } інакше якщо вказівка == ВСтрибнутиЯкщоНі {
        вивести_п64(М, п64(п));
        вивести_Ю8(М, ю8" СтрибнутиЯкщоНі ");
        п += 1;
        надрукувати_п64(М, п64(код.накопичувач_вказівок.дані[п]));
      } інакше якщо вказівка == ВСтрибнутиЯкщоНіЗалишивши {
        вивести_п64(М, п64(п));
        вивести_Ю8(М, ю8" СтрибнутиЯкщоНіЗалишивши ");
        п += 1;
        надрукувати_п64(М, п64(код.накопичувач_вказівок.дані[п]));
      } інакше якщо вказівка == ВСтрибнутиЯкщоТак {
        вивести_п64(М, п64(п));
        вивести_Ю8(М, ю8" СтрибнутиЯкщоТак ");
        п += 1;
        надрукувати_п64(М, п64(код.накопичувач_вказівок.дані[п]));
      } інакше якщо вказівка == ВСтрибнутиЯкщоТакЗалишивши {
        вивести_п64(М, п64(п));
        вивести_Ю8(М, ю8" СтрибнутиЯкщоТакЗалишивши ");
        п += 1;
        надрукувати_п64(М, п64(код.накопичувач_вказівок.дані[п]));
      } інакше якщо вказівка == ВДублювати {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Дублювати");
      } інакше якщо вказівка == ВДублюватиПопереднє {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" ДублюватиПопереднє");
      } інакше якщо вказівка == ВЗабрати {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Забрати");
      } інакше якщо вказівка == ВВернути {
        вивести_п64(М, п64(п));
        надрукувати_Ю8(М, ю8" Вернути");
      } інакше {
        вивести_п64(М, п64(п));
        вивести_Ю8(М, ю8" Невідома вказівка ");
        надрукувати_п64(М, п64(вказівка));
      }
      п += 1;
    }
  }

  місцева дія знайти_місцезнаходження_вказівки(код: адреса<Код>, позиція_вказівки: позитивне): адреса<МісцезнаходженняВказівки> {
    змінна ціль позиція: позитивне = 0;
    поки позиція < код.накопичувач_місцезнаходжень_вказівок.розмір {
      якщо код.накопичувач_місцезнаходжень_вказівок.дані[позиція].позиція_вказівки == позиція_вказівки {
        вернути код.накопичувач_місцезнаходжень_вказівок.дані[позиція]::адреса;
      }
      позиція = позиція + 1;
    }
    вернути пусто;
  }
}