ПредметЮнікоду.ц

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

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

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

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

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

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

    предмет_юнікоду.довжина = порахувати_розмір_Ю32(значення);
    предмет_юнікоду.значення = пусто;
    виділити_копію_Ю32(М, значення, предмет_юнікоду.довжина, предмет_юнікоду.значення::адреса);
    якщо предмет_юнікоду.значення == пусто {
      ПОМЕРТИ(М, ю8"Помилка виділення копії Ю32");
    }

    вернути предмет_юнікоду;
  }

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

    ціль предмет_юнікоду = виділити_предмет<ПредметЮнікоду>(М, М.предмет_структури_юнікод);

    предмет_юнікоду.довжина = розмір_Ю32;
    предмет_юнікоду.значення = ю32;

    вернути предмет_юнікоду;
  }

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

    ціль предмет_юнікоду = виділити_предмет<ПредметЮнікоду>(М, М.предмет_структури_юнікод);

    предмет_юнікоду.довжина = розмір_Ю32;
    предмет_юнікоду.значення = ю32;

    вернути предмет_юнікоду;
  }

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

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

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

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

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

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

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

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

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

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

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

  місцева дія предмет_юнікоду_додати(предмет_юнікоду: адреса<ПредметЮнікоду>, М: адреса<Машина>, аргумент: адреса<Предмет>): предмет_або_стан_падіння {
    якщо аргумент == пусто {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"Неможливо додати пусто до юнікоду") як адреса<Предмет>;
    }
    якщо аргумент.тип != М.предмет_структури_юнікод {
      увімкнути_стан_падіння(М, пусто);
      вернути виділити_предмет_тексту_з_ю8(М, ю8"До юнікоду можна додати лише юнікод") як адреса<Предмет>;
    }
    ціль предмет_юнікоду_аргумента = аргумент як адреса<ПредметЮнікоду>;
    ціль розмір_значення_1 = предмет_юнікоду.довжина;
    ціль розмір_значення_2 = предмет_юнікоду_аргумента.довжина;
    ціль новий_розмір = розмір_значення_1 + розмір_значення_2;
    ціль нове_значення = виділити<п32>(М, новий_розмір + 1);
    змінна ціль позиція: позитивне = 0;
    поки позиція < розмір_значення_1 {
      нове_значення[позиція] = предмет_юнікоду.значення[позиція];
      позиція += 1;
    }
    позиція = 0;
    поки позиція < розмір_значення_2 {
      нове_значення[розмір_значення_1 + позиція] = предмет_юнікоду_аргумента.значення[позиція];
      позиція += 1;
    }
    нове_значення[новий_розмір] = 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"Неможливо виконати двійкове НЕ для юнікоду") як адреса<Предмет>;
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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