ПредметЧисла.ц

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    вернути предмет_числа;
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  місцева дія предмет_числа_двійкове_і(предмет_числа: адреса<ПредметЧисла>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    якщо аргумент == пусто {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати двійкове І числа і пусто") як адреса<Предмет>;
    }
    якщо аргумент.тип != М.предмет_структури_число {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Виконати двійкове І для числа можна лише з числом") як адреса<Предмет>;
    }
    ціль предмет_аргумента = аргумент як адреса<ПредметЧисла>;
    вернути виділити_предмет_числа(М, д64(ц32(предмет_числа.значення) & ц32(предмет_аргумента.значення))) як адреса<Предмет>;
  }

  місцева дія предмет_числа_двійкове_або(предмет_числа: адреса<ПредметЧисла>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    якщо аргумент == пусто {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати двійкове АБО числа і пусто") як адреса<Предмет>;
    }
    якщо аргумент.тип != М.предмет_структури_число {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Виконати двійкове АБО для числа можна лише з числом") як адреса<Предмет>;
    }
    ціль предмет_аргумента = аргумент як адреса<ПредметЧисла>;
    вернути виділити_предмет_числа(М, д64(ц32(предмет_числа.значення) | ц32(предмет_аргумента.значення))) як адреса<Предмет>;
  }

  місцева дія предмет_числа_двійкове_виключне_або(предмет_числа: адреса<ПредметЧисла>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    якщо аргумент == пусто {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо виконати двійкове ВИКЛЮЧНЕ АБО числа і пусто") як адреса<Предмет>;
    }
    якщо аргумент.тип != М.предмет_структури_число {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Виконати двійкове ВИКЛЮЧНЕ АБО для числа можна лише з числом") як адреса<Предмет>;
    }
    ціль предмет_аргумента = аргумент як адреса<ПредметЧисла>;
    вернути виділити_предмет_числа(М, д64(ц32(предмет_числа.значення) ^ ц32(предмет_аргумента.значення))) як адреса<Предмет>;
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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