ПредметМодуля.ц

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

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

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

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

    предмет_модуля.властивості = зробити_реєстр<адреса<Назва>, адреса<Предмет>>(М, перевірити_чи_назви_рівні);
    предмет_модуля.назва = назва;
    предмет_модуля.назва_паку = пусто;

    вернути предмет_модуля;
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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