/* Дієкод */

взяти означення КД;

простір КД {
  дія отримати_символ_кд_з_ю32(символ_Ю32: п32, вихід_першого_байта: адреса<п8>, вихід_другого_байта: адреса<п8>, вихід_третього_байта: адреса<п8>, вихід_четвертого_байта: адреса<п8>, вихід_розміру: адреса<п8>) -> логічне {
    якщо символ_Ю32 == відповідні_символи_юнікоду::Недійсний {
      вихід_першого_байта::вміст = символи::Недійсний;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Дія {
      вихід_першого_байта::вміст = символи::Дія;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    // 2 невизначено
    // 3 невизначено
    // 4 невизначено
    // 5 невизначено
    // 6 невизначено
    якщо символ_Ю32 == відповідні_символи_юнікоду::Відсоток {
      вихід_першого_байта::вміст = символи::Відсоток;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Долар {
      вихід_першого_байта::вміст = символи::Долар;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мітка {
      вихід_першого_байта::вміст = символи::Мітка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Адреса {
      вихід_першого_байта::вміст = символи::Адреса;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Обернена_похила {
      вихід_першого_байта::вміст = символи::Обернена_похила;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Підриска {
      вихід_першого_байта::вміст = символи::Підриска;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Циркумфлекс {
      вихід_першого_байта::вміст = символи::Циркумфлекс;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Хвиляста {
      вихід_першого_байта::вміст = символи::Хвиляста;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Двориска {
      вихід_першого_байта::вміст = символи::Двориска;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Нуль {
      вихід_першого_байта::вміст = символи::Нуль;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Один {
      вихід_першого_байта::вміст = символи::Один;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Два {
      вихід_першого_байта::вміст = символи::Два;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Три {
      вихід_першого_байта::вміст = символи::Три;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Чотири {
      вихід_першого_байта::вміст = символи::Чотири;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Пʼять {
      вихід_першого_байта::вміст = символи::Пʼять;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Шість {
      вихід_першого_байта::вміст = символи::Шість;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Сім {
      вихід_першого_байта::вміст = символи::Сім;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Вісім {
      вихід_першого_байта::вміст = символи::Вісім;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Девʼять {
      вихід_першого_байта::вміст = символи::Девʼять;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Хрестик {
      вихід_першого_байта::вміст = символи::Хрестик;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Риска {
      вихід_першого_байта::вміст = символи::Риска;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Зірочка {
      вихід_першого_байта::вміст = символи::Зірочка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Похила {
      вихід_першого_байта::вміст = символи::Похила;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::І {
      вихід_першого_байта::вміст = символи::І;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Стояча {
      вихід_першого_байта::вміст = символи::Стояча;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_А {
      вихід_першого_байта::вміст = символи::Велика_буква_А;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Б {
      вихід_першого_байта::вміст = символи::Велика_буква_Б;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Г {
      вихід_першого_байта::вміст = символи::Велика_буква_Г;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Д {
      вихід_першого_байта::вміст = символи::Велика_буква_Д;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Е {
      вихід_першого_байта::вміст = символи::Велика_буква_Е;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_З {
      вихід_першого_байта::вміст = символи::Велика_буква_З;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_И {
      вихід_першого_байта::вміст = символи::Велика_буква_И;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_І {
      вихід_першого_байта::вміст = символи::Велика_буква_І;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Й {
      вихід_першого_байта::вміст = символи::Велика_буква_Й;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_К {
      вихід_першого_байта::вміст = символи::Велика_буква_К;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Л {
      вихід_першого_байта::вміст = символи::Велика_буква_Л;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_М {
      вихід_першого_байта::вміст = символи::Велика_буква_М;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Н {
      вихід_першого_байта::вміст = символи::Велика_буква_Н;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_О {
      вихід_першого_байта::вміст = символи::Велика_буква_О;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_П {
      вихід_першого_байта::вміст = символи::Велика_буква_П;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Р {
      вихід_першого_байта::вміст = символи::Велика_буква_Р;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_С {
      вихід_першого_байта::вміст = символи::Велика_буква_С;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Т {
      вихід_першого_байта::вміст = символи::Велика_буква_Т;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_У {
      вихід_першого_байта::вміст = символи::Велика_буква_У;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_В {
      вихід_першого_байта::вміст = символи::Велика_буква_В;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Ф {
      вихід_першого_байта::вміст = символи::Велика_буква_Ф;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Х {
      вихід_першого_байта::вміст = символи::Велика_буква_Х;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Ш {
      вихід_першого_байта::вміст = символи::Велика_буква_Ш;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Ж {
      вихід_першого_байта::вміст = символи::Велика_буква_Ж;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Ц {
      вихід_першого_байта::вміст = символи::Велика_буква_Ц;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Ч {
      вихід_першого_байта::вміст = символи::Велика_буква_Ч;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Щ {
      вихід_першого_байта::вміст = символи::Велика_буква_Щ;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Я {
      вихід_першого_байта::вміст = символи::Велика_буква_Я;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Є {
      вихід_першого_байта::вміст = символи::Велика_буква_Є;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Ї {
      вихід_першого_байта::вміст = символи::Велика_буква_Ї;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Ю {
      вихід_першого_байта::вміст = символи::Велика_буква_Ю;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Ь {
      вихід_першого_байта::вміст = символи::Велика_буква_Ь;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_а {
      вихід_першого_байта::вміст = символи::Мала_буква_а;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_б {
      вихід_першого_байта::вміст = символи::Мала_буква_б;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_г {
      вихід_першого_байта::вміст = символи::Мала_буква_г;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_д {
      вихід_першого_байта::вміст = символи::Мала_буква_д;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_е {
      вихід_першого_байта::вміст = символи::Мала_буква_е;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_з {
      вихід_першого_байта::вміст = символи::Мала_буква_з;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_и {
      вихід_першого_байта::вміст = символи::Мала_буква_и;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_і {
      вихід_першого_байта::вміст = символи::Мала_буква_і;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_й {
      вихід_першого_байта::вміст = символи::Мала_буква_й;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_к {
      вихід_першого_байта::вміст = символи::Мала_буква_к;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_л {
      вихід_першого_байта::вміст = символи::Мала_буква_л;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_м {
      вихід_першого_байта::вміст = символи::Мала_буква_м;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_н {
      вихід_першого_байта::вміст = символи::Мала_буква_н;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_о {
      вихід_першого_байта::вміст = символи::Мала_буква_о;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_п {
      вихід_першого_байта::вміст = символи::Мала_буква_п;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_р {
      вихід_першого_байта::вміст = символи::Мала_буква_р;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_с {
      вихід_першого_байта::вміст = символи::Мала_буква_с;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_т {
      вихід_першого_байта::вміст = символи::Мала_буква_т;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_у {
      вихід_першого_байта::вміст = символи::Мала_буква_у;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_в {
      вихід_першого_байта::вміст = символи::Мала_буква_в;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_ф {
      вихід_першого_байта::вміст = символи::Мала_буква_ф;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_х {
      вихід_першого_байта::вміст = символи::Мала_буква_х;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_ш {
      вихід_першого_байта::вміст = символи::Мала_буква_ш;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_ж {
      вихід_першого_байта::вміст = символи::Мала_буква_ж;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_ц {
      вихід_першого_байта::вміст = символи::Мала_буква_ц;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_ч {
      вихід_першого_байта::вміст = символи::Мала_буква_ч;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_щ {
      вихід_першого_байта::вміст = символи::Мала_буква_щ;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_я {
      вихід_першого_байта::вміст = символи::Мала_буква_я;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_є {
      вихід_першого_байта::вміст = символи::Мала_буква_є;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_ї {
      вихід_першого_байта::вміст = символи::Мала_буква_ї;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_ю {
      вихід_першого_байта::вміст = символи::Мала_буква_ю;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_ь {
      вихід_першого_байта::вміст = символи::Мала_буква_ь;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Ґ {
      вихід_першого_байта::вміст = символи::Велика_буква_Ґ;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    // 97 невизначено
    // 98 невизначено
    // 99 невизначено
    якщо символ_Ю32 == відповідні_символи_юнікоду::Велика_буква_Ъ {
      вихід_першого_байта::вміст = символи::Велика_буква_Ъ;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_ґ {
      вихід_першого_байта::вміст = символи::Мала_буква_ґ;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    // 102 невизначено
    // 103 невизначено
    // 104 невизначено
    якщо символ_Ю32 == відповідні_символи_юнікоду::Мала_буква_ъ {
      вихід_першого_байта::вміст = символи::Мала_буква_ъ;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Апостроф {
      вихід_першого_байта::вміст = символи::Апостроф;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Кома {
      вихід_першого_байта::вміст = символи::Кома;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Двокрапка {
      вихід_першого_байта::вміст = символи::Двокрапка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Крапкакома {
      вихід_першого_байта::вміст = символи::Крапкакома;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Крапка {
      вихід_першого_байта::вміст = символи::Крапка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Питання {
      вихід_першого_байта::вміст = символи::Питання;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Оклик {
      вихід_першого_байта::вміст = символи::Оклик;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Дволапка {
      вихід_першого_байта::вміст = символи::Дволапка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Однолапка {
      вихід_першого_байта::вміст = символи::Однолапка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Косолапка {
      вихід_першого_байта::вміст = символи::Косолапка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Відкрита_квадратна_дужка {
      вихід_першого_байта::вміст = символи::Відкрита_квадратна_дужка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Закрита_квадратна_дужка {
      вихід_першого_байта::вміст = символи::Закрита_квадратна_дужка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Відкрита_дужка {
      вихід_першого_байта::вміст = символи::Відкрита_дужка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Закрита_дужка {
      вихід_першого_байта::вміст = символи::Закрита_дужка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Відкрита_фігурна_дужка {
      вихід_першого_байта::вміст = символи::Відкрита_фігурна_дужка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Закрита_фігурна_дужка {
      вихід_першого_байта::вміст = символи::Закрита_фігурна_дужка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Менше {
      вихід_першого_байта::вміст = символи::Менше;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Більше {
      вихід_першого_байта::вміст = символи::Більше;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    // 124 невизначено
    // 125 невизначено
    якщо символ_Ю32 == відповідні_символи_юнікоду::Пропуск {
      вихід_першого_байта::вміст = символи::Пропуск;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_Ю32 == відповідні_символи_юнікоду::Міжряд {
      вихід_першого_байта::вміст = символи::Міжряд;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    вернути ні;
  }

  дія перекодувати_з_ю8(система: адреса<Система>, вхід: ю8, екранувати_невідомі: логічне, з_нульовим_байтом_в_кінці: логічне, вихід: адреса<кд>, вихід_позиції_помилки: адреса<природне>) -> логічне {
    змінна дані_виходу = виділити<п8>(система, вхід.розмір * 4 + 1);
    змінна розмір_виходу: природне = 0;
    змінна п: природне = 0;
    поки п < вхід.розмір {
      змінна перший_байт = вхід.дані[п];
      змінна розмір_символа = дізнатись_розмір_символа_ю8(перший_байт);
      якщо розмір_символа == 1 {
        змінна символ_кд_0: п8 = 0;
        змінна символ_кд_1: п8 = 0;
        змінна символ_кд_2: п8 = 0;
        змінна символ_кд_3: п8 = 0;
        змінна символ_кд_розмір: п8 = 0;
        змінна успіх_отримання_кд_з_ю32 = отримати_символ_кд_з_ю32(п32(перший_байт), символ_кд_0::адреса, символ_кд_1::адреса, символ_кд_2::адреса, символ_кд_3::адреса, символ_кд_розмір::адреса);
        якщо не успіх_отримання_кд_з_ю32 {
          якщо екранувати_невідомі {
            // потім: втілити
          }
          звільнити(система, дані_виходу);
          вихід_позиції_помилки::вміст = п;
          вернути ні;
        }
        якщо символ_кд_розмір == 1 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
        } інакше якщо символ_кд_розмір == 2 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_1;
          розмір_виходу += 1;
        } інакше якщо символ_кд_розмір == 3 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_1;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_2;
          розмір_виходу += 1;
        } інакше якщо символ_кд_розмір == 4 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_1;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_3;
          розмір_виходу += 1;
        }
      } інакше якщо розмір_символа == 2 {
        п += 1;
        змінна другий_байт = вхід.дані[п];
        змінна символ_ю16 = п16((п16(перший_байт & 31) << 6) | п16(другий_байт & 63));
        змінна символ_кд_0: п8 = 0;
        змінна символ_кд_1: п8 = 0;
        змінна символ_кд_2: п8 = 0;
        змінна символ_кд_3: п8 = 0;
        змінна символ_кд_розмір: п8 = 0;
        змінна успіх_отримання_кд_з_ю32 = отримати_символ_кд_з_ю32(п32(символ_ю16), символ_кд_0::адреса, символ_кд_1::адреса, символ_кд_2::адреса, символ_кд_3::адреса, символ_кд_розмір::адреса);
        якщо не успіх_отримання_кд_з_ю32 {
          якщо екранувати_невідомі {
            // потім: втілити
          }
          звільнити(система, дані_виходу);
          вихід_позиції_помилки::вміст = п - 1;
          вернути ні;
        }
        якщо символ_кд_розмір == 1 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
        } інакше якщо символ_кд_розмір == 2 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_1;
          розмір_виходу += 1;
        } інакше якщо символ_кд_розмір == 3 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_1;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_2;
          розмір_виходу += 1;
        } інакше якщо символ_кд_розмір == 4 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_1;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_3;
          розмір_виходу += 1;
        }
      } інакше якщо розмір_символа == 3 {
        п += 1;
        змінна другий_байт = вхід.дані[п];
        п += 1;
        змінна третій_байт = вхід.дані[п];
        змінна символ_ю32 = п32((п32(перший_байт & 15) << 12) | (п32(другий_байт & 63) << 6) | п32(третій_байт & 63));
        змінна символ_кд_0: п8 = 0;
        змінна символ_кд_1: п8 = 0;
        змінна символ_кд_2: п8 = 0;
        змінна символ_кд_3: п8 = 0;
        змінна символ_кд_розмір: п8 = 0;
        змінна успіх_отримання_кд_з_ю32 = отримати_символ_кд_з_ю32(символ_ю32, символ_кд_0::адреса, символ_кд_1::адреса, символ_кд_2::адреса, символ_кд_3::адреса, символ_кд_розмір::адреса);
        якщо не успіх_отримання_кд_з_ю32 {
          якщо екранувати_невідомі {
            // потім: втілити
          }
          звільнити(система, дані_виходу);
          вихід_позиції_помилки::вміст = п - 2;
          вернути ні;
        }
        якщо символ_кд_розмір == 1 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
        } інакше якщо символ_кд_розмір == 2 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_1;
          розмір_виходу += 1;
        } інакше якщо символ_кд_розмір == 3 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_1;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_2;
          розмір_виходу += 1;
        } інакше якщо символ_кд_розмір == 4 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_1;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_3;
          розмір_виходу += 1;
        }
      } інакше {
        якщо екранувати_невідомі {
          // потім: втілити
        }
        звільнити(система, дані_виходу);
        вихід_позиції_помилки::вміст = п;
        вернути ні;
      }
      п += 1;
    }
    якщо з_нульовим_байтом_в_кінці {
      дані_виходу[розмір_виходу] = 0;
    }
    вихід::вміст = кд {
      розмір_виходу,
      дані_виходу
    };
    вернути так;
  }

  дія перекодувати_ю8_в_ю32(система: адреса<Система>, вхід: ю8, з_нульовим_байтом_в_кінці: логічне, вихід: адреса<ю32>, вихід_позиції_помилки: адреса<природне>) -> логічне {
    змінна дані_виходу = виділити<п32>(система, вхід.розмір + 1);
    змінна розмір_виходу: природне = 0;
    змінна п: природне = 0;
    поки п < вхід.розмір {
      змінна перший_байт = вхід.дані[п];
      змінна розмір_символа = дізнатись_розмір_символа_ю8(перший_байт);
      якщо розмір_символа == 1 {
        дані_виходу[розмір_виходу] = п32(перший_байт & 127);
        розмір_виходу += 1;
      }
      якщо розмір_символа == 2 {
        змінна другий_байт = вхід.дані[п + 1];
        дані_виходу[розмір_виходу] = (п32(перший_байт & 31) << 6) | п32(другий_байт & 63);
        розмір_виходу += 1;
        п += 1;
      }
      якщо розмір_символа == 3 {
        змінна другий_байт = вхід.дані[п + 1];
        змінна третій_байт = вхід.дані[п + 2];
        дані_виходу[розмір_виходу] = (п32(перший_байт & 15) << 12) | (п32(другий_байт & 63) << 6) | п32(третій_байт & 63);
        розмір_виходу += 1;
        п += 2;
      }
      якщо розмір_символа == 4 {
        змінна другий_байт = вхід.дані[п + 1];
        змінна третій_байт = вхід.дані[п + 2];
        змінна четвертий_байт = вхід.дані[п + 3];
        дані_виходу[розмір_виходу] = (п32(перший_байт & 15) << 18) | (п32(другий_байт & 63) << 12) | (п32(третій_байт & 63) << 6) | п32(четвертий_байт & 63);
        розмір_виходу += 1;
        п += 3;
      }
      п += 1;
    }
    якщо з_нульовим_байтом_в_кінці {
      дані_виходу[розмір_виходу] = 0;
    }
    вихід::вміст = ю32 {
      розмір_виходу,
      дані_виходу
    };
    вернути так;
  }

  дія перекодувати_ю32_в_ю8(система: адреса<Система>, вхід: ю32, з_нульовим_байтом_в_кінці: логічне, вихід: адреса<ю8>, вихід_позиції_помилки: адреса<природне>) -> логічне {
    змінна дані_виходу = виділити<п8>(система, вхід.розмір * 4 + 1);
    змінна розмір_виходу: природне = 0;
    змінна п: природне = 0;
    поки п < вхід.розмір {
      змінна с = вхід.дані[п];
      якщо с < 128 {
        дані_виходу[розмір_виходу] = п8(с);
        розмір_виходу += 1;
      } інакше якщо с < 2048 {
        дані_виходу[розмір_виходу] = п8(п32(192) | (с >> 6));
        розмір_виходу += 1;
        дані_виходу[розмір_виходу] = п8(п32(128) | (с & 63));
        розмір_виходу += 1;
      } інакше якщо с < 65536 {
        дані_виходу[розмір_виходу] = п8(п32(224) | (с >> 12));
        розмір_виходу += 1;
        дані_виходу[розмір_виходу] = п8(п32(128) | ((с >> 6) & 63));
        розмір_виходу += 1;
        дані_виходу[розмір_виходу] = п8(п32(128) | (с & 63));
        розмір_виходу += 1;
      } інакше {
        дані_виходу[розмір_виходу] = п8(п32(240) | (с >> 18));
        розмір_виходу += 1;
        дані_виходу[розмір_виходу] = п8(п32(128) | ((с >> 12) & 63));
        розмір_виходу += 1;
        дані_виходу[розмір_виходу] = п8(п32(128) | ((с >> 6) & 63));
        розмір_виходу += 1;
        дані_виходу[розмір_виходу] = п8(п32(128) | (с & 63));
        розмір_виходу += 1;
      }
      п += 1;
    }
    якщо з_нульовим_байтом_в_кінці {
      дані_виходу[розмір_виходу] = 0;
    }
    вихід::вміст = ю8 {
      розмір_виходу,
      дані_виходу
    };
    вернути так;
  }

  дія отримати_символ_ю8_з_т32(символ_КД: п32, вихід_першого_байта: адреса<п8>, вихід_другого_байта: адреса<п8>, вихід_третього_байта: адреса<п8>, вихід_четвертого_байта: адреса<п8>, вихід_розміру: адреса<п8>) -> логічне {
    якщо символ_КД == символи::Недійсний {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Недійсний;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Дія {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Дія;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    // 2 невизначено
    // 3 невизначено
    // 4 невизначено
    // 5 невизначено
    // 6 невизначено
    якщо символ_КД == символи::Відсоток {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Відсоток;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Долар {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Долар;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Мітка {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Мітка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Адреса {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Адреса;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Обернена_похила {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Обернена_похила;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Підриска {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Підриска;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Циркумфлекс {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Циркумфлекс;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Хвиляста {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Хвиляста;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Двориска {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Двориска;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Нуль {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Нуль;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Один {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Один;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Два {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Два;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Три {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Три;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Чотири {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Чотири;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Пʼять {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Пʼять;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Шість {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Шість;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Сім {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Сім;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Вісім {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Вісім;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Девʼять {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Девʼять;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Хрестик {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Хрестик;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Риска {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Риска;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Зірочка {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Зірочка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Похила {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Похила;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::І {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::І;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Стояча {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Стояча;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_А {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_А) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_А) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Б {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Б) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Б) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Г {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Г) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Г) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Д {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Д) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Д) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Е {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Е) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Е) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_З {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_З) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_З) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_И {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_И) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_И) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_І {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_І) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_І) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Й {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Й) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Й) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_К {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_К) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_К) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Л {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Л) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Л) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_М {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_М) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_М) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Н {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Н) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Н) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_О {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_О) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_О) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_П {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_П) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_П) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Р {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Р) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Р) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_С {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_С) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_С) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Т {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Т) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Т) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_У {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_У) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_У) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_В {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_В) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_В) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Ф {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Ф) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Ф) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Х {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Х) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Х) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Ш {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Ш) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Ш) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Ж {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Ж) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Ж) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Ц {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Ц) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Ц) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Ч {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Ч) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Ч) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Щ {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Щ) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Щ) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Я {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Я) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Я) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Є {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Є) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Є) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Ї {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Ї) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Ї) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Ю {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Ю) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Ю) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Ь {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Ь) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Ь) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_а {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_а) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_а) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_б {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_б) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_б) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_г {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_г) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_г) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_д {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_д) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_д) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_е {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_е) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_е) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_з {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_з) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_з) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_и {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_и) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_и) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_і {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_і) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_і) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_й {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_й) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_й) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_к {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_к) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_к) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_л {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_л) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_л) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_м {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_м) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_м) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_н {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_н) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_н) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_о {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_о) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_о) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_п {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_п) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_п) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_р {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_р) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_р) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_с {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_с) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_с) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_т {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_т) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_т) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_у {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_у) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_у) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_в {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_в) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_в) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_ф {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_ф) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_ф) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_х {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_х) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_х) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_ш {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_ш) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_ш) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_ж {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_ж) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_ж) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_ц {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_ц) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_ц) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_ч {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_ч) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_ч) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_щ {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_щ) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_щ) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_я {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_я) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_я) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_є {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_є) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_є) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_ї {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_ї) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_ї) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_ю {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_ю) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_ю) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_ь {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_ь) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_ь) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Велика_буква_Ґ {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Ґ) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Ґ) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    // 97 невизначено
    // 98 невизначено
    // 99 невизначено
    якщо символ_КД == символи::Велика_буква_Ъ {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Велика_буква_Ъ) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Велика_буква_Ъ) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Мала_буква_ґ {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_ґ) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_ґ) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    // 102 невизначено
    // 103 невизначено
    // 104 невизначено
    якщо символ_КД == символи::Мала_буква_ъ {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Мала_буква_ъ) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Мала_буква_ъ) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Апостроф {
      вихід_першого_байта::вміст = п8(п32(192) | (п32(відповідні_символи_юнікоду::Апостроф) >> 6));
      вихід_другого_байта::вміст = п8(п32(128) | (п32(відповідні_символи_юнікоду::Апостроф) & 63));
      вихід_розміру::вміст = 2;
      вернути так;
    }
    якщо символ_КД == символи::Кома {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Кома;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Двокрапка {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Двокрапка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Крапкакома {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Крапкакома;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Крапка {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Крапка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Питання {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Питання;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Оклик {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Оклик;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Дволапка {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Дволапка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Однолапка {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Однолапка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Косолапка {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Косолапка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Відкрита_квадратна_дужка {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Відкрита_квадратна_дужка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Закрита_квадратна_дужка {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Закрита_квадратна_дужка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Відкрита_дужка {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Відкрита_дужка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Закрита_дужка {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Закрита_дужка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Відкрита_фігурна_дужка {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Відкрита_фігурна_дужка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Закрита_фігурна_дужка {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Закрита_фігурна_дужка;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Менше {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Менше;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Більше {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Більше;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    // 124 невизначено
    // 125 невизначено
    якщо символ_КД == символи::Пропуск {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Пропуск;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    якщо символ_КД == символи::Міжряд {
      вихід_першого_байта::вміст = відповідні_символи_юнікоду::Міжряд;
      вихід_розміру::вміст = 1;
      вернути так;
    }
    вернути ні;
  }

  дія порахувати_розмір_ю8сі(значення: адреса<п8>) -> природне {
    змінна п: природне = 0;
    поки значення[п] != 0 {
      п += 1;
    }
    вернути п;
  }

  дія перевірити_чи_ю8_рівні(а: ю8, б: ю8) -> логічне {
    якщо а.розмір != б.розмір {
      вернути ні;
    }
    змінна п: природне = 0;
    поки п < а.розмір {
      якщо а.дані[п] != б.дані[п] {
        вернути ні;
      }
      п += 1;
    }
    вернути так;
  }

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

  дія перевірити_чи_кд_рівні(а: кд, б: кд) -> логічне {
    якщо а.розмір != б.розмір {
      вернути ні;
    }
    змінна п: природне = 0;
    поки п < а.розмір {
      якщо а.дані[п] != б.дані[п] {
        вернути ні;
      }
      п += 1;
    }
    вернути так;
  }

  дія перекодувати_в_ю8(система: адреса<Система>, вхід: кд, з_нульовим_байтом_в_кінці: логічне, вихід: адреса<ю8>, вихід_позиції_помилки: адреса<природне>) -> логічне {
    змінна дані_виходу = виділити<п8>(система, вхід.розмір * 4 + 1);
    змінна розмір_виходу: природне = 0;
    змінна п: природне = 0;
    поки п < вхід.розмір {
      змінна перший_байт = вхід.дані[п];
      змінна розмір_символа = дізнатись_розмір_символа_кд(перший_байт);
      якщо розмір_символа == 1 {
        змінна символ_ю8_0: п8 = 0;
        змінна символ_ю8_1: п8 = 0;
        змінна символ_ю8_2: п8 = 0;
        змінна символ_ю8_3: п8 = 0;
        змінна символ_ю8_розмір: п8 = 0;
        змінна успіх_отримання_ю8_з_т32 = отримати_символ_ю8_з_т32(п32(перший_байт), символ_ю8_0::адреса, символ_ю8_1::адреса, символ_ю8_2::адреса, символ_ю8_3::адреса, символ_ю8_розмір::адреса);
        якщо не успіх_отримання_ю8_з_т32 {
          вернути ні;
        }
        якщо символ_ю8_розмір == 1 {
          дані_виходу[розмір_виходу] = символ_ю8_0;
          розмір_виходу += 1;
        } інакше якщо символ_ю8_розмір == 2 {
          дані_виходу[розмір_виходу] = символ_ю8_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_ю8_1;
          розмір_виходу += 1;
        } інакше якщо символ_ю8_розмір == 3 {
          дані_виходу[розмір_виходу] = символ_ю8_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_ю8_1;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_ю8_2;
          розмір_виходу += 1;
        } інакше якщо символ_ю8_розмір == 4 {
          дані_виходу[розмір_виходу] = символ_ю8_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_ю8_1;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_ю8_3;
          розмір_виходу += 1;
        }
      } інакше якщо розмір_символа == 2 {
        п += 1;
        змінна другий_байт = вхід.дані[п];
        змінна символ_т16 = п16((п16(перший_байт & 31) << 6) | п16(другий_байт & 63));
        змінна символ_ю8_0: п8 = 0;
        змінна символ_ю8_1: п8 = 0;
        змінна символ_ю8_2: п8 = 0;
        змінна символ_ю8_3: п8 = 0;
        змінна символ_ю8_розмір: п8 = 0;
        змінна успіх_отримання_ю8_з_т32 = отримати_символ_ю8_з_т32(п32(символ_т16), символ_ю8_0::адреса, символ_ю8_1::адреса, символ_ю8_2::адреса, символ_ю8_3::адреса, символ_ю8_розмір::адреса);
        якщо не успіх_отримання_ю8_з_т32 {
          вернути ні;
        }
        якщо символ_ю8_розмір == 1 {
          дані_виходу[розмір_виходу] = символ_ю8_0;
          розмір_виходу += 1;
        } інакше якщо символ_ю8_розмір == 2 {
          дані_виходу[розмір_виходу] = символ_ю8_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_ю8_1;
          розмір_виходу += 1;
        } інакше якщо символ_ю8_розмір == 3 {
          дані_виходу[розмір_виходу] = символ_ю8_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_ю8_1;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_ю8_2;
          розмір_виходу += 1;
        } інакше якщо символ_ю8_розмір == 4 {
          дані_виходу[розмір_виходу] = символ_ю8_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_ю8_1;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_ю8_3;
          розмір_виходу += 1;
        }
      } інакше якщо розмір_символа == 3 {
        п += 1;
        змінна другий_байт = вхід.дані[п];
        п += 1;
        змінна третій_байт = вхід.дані[п];
        змінна символ_т32 = п32((п32(перший_байт & 15) << 12) | (п32(другий_байт & 63) << 6) | п32(третій_байт & 63));
        змінна символ_ю8_0: п8 = 0;
        змінна символ_ю8_1: п8 = 0;
        змінна символ_ю8_2: п8 = 0;
        змінна символ_ю8_3: п8 = 0;
        змінна символ_ю8_розмір: п8 = 0;
        змінна успіх_отримання_ю8_з_т32 = отримати_символ_ю8_з_т32(символ_т32, символ_ю8_0::адреса, символ_ю8_1::адреса, символ_ю8_2::адреса, символ_ю8_3::адреса, символ_ю8_розмір::адреса);
        якщо не успіх_отримання_ю8_з_т32 {
          вернути ні;
        }
        якщо символ_ю8_розмір == 1 {
          дані_виходу[розмір_виходу] = символ_ю8_0;
          розмір_виходу += 1;
        } інакше якщо символ_ю8_розмір == 2 {
          дані_виходу[розмір_виходу] = символ_ю8_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_ю8_1;
          розмір_виходу += 1;
        } інакше якщо символ_ю8_розмір == 3 {
          дані_виходу[розмір_виходу] = символ_ю8_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_ю8_1;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_ю8_2;
          розмір_виходу += 1;
        } інакше якщо символ_ю8_розмір == 4 {
          дані_виходу[розмір_виходу] = символ_ю8_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_ю8_1;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_ю8_3;
          розмір_виходу += 1;
        }
      } інакше {
        вернути ні;
      }
      п += 1;
    }
    якщо з_нульовим_байтом_в_кінці {
      дані_виходу[розмір_виходу] = 0;
    }
    вихід::вміст = ю8 {
      розмір_виходу,
      дані_виходу
    };
    вернути так;
  }

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

    змінна дані_виходу = виділити<п8>(система, вхід.розмір * 4 + 1);
    змінна розмір_виходу: природне = 0;

    змінна п: природне = 0;

    поки п < вхід.розмір {
      змінна перший_байт = вхід.дані[п];
      змінна розмір_символа = дізнатись_розмір_символа_ю8(перший_байт);
      якщо розмір_символа == 1 {
        змінна символ_кд_0: п8 = 0;
        змінна символ_кд_1: п8 = 0;
        змінна символ_кд_2: п8 = 0;
        змінна символ_кд_3: п8 = 0;
        змінна символ_кд_розмір: п8 = 0;
        змінна успіх_отримання_кд_з_ю32 = отримати_символ_кд_з_ю32(п32(перший_байт), символ_кд_0::адреса, символ_кд_1::адреса, символ_кд_2::адреса, символ_кд_3::адреса, символ_кд_розмір::адреса);
        якщо не успіх_отримання_кд_з_ю32 {
          якщо екранувати_невідомі {
            // потім: втілити
          }
          звільнити(система, дані_виходу);
          вихід_позиції_помилки::вміст = п;
          вернути ні;
        }
        якщо символ_кд_розмір == 1 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
          покласти_в_місцезнаходження(система, місцезнаходження::адреса, п32(п));
        } інакше якщо символ_кд_розмір == 2 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_1;
          розмір_виходу += 1;
          покласти_в_місцезнаходження(система, місцезнаходження::адреса, п32(п));
        } інакше якщо символ_кд_розмір == 3 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_1;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_2;
          розмір_виходу += 1;
          покласти_в_місцезнаходження(система, місцезнаходження::адреса, п32(п));
        } інакше якщо символ_кд_розмір == 4 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_1;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_3;
          розмір_виходу += 1;
          покласти_в_місцезнаходження(система, місцезнаходження::адреса, п32(п));
        }
      } інакше якщо розмір_символа == 2 {
        п += 1;
        змінна другий_байт = вхід.дані[п];
        змінна символ_ю16 = п16((п16(перший_байт & 31) << 6) | п16(другий_байт & 63));
        змінна символ_кд_0: п8 = 0;
        змінна символ_кд_1: п8 = 0;
        змінна символ_кд_2: п8 = 0;
        змінна символ_кд_3: п8 = 0;
        змінна символ_кд_розмір: п8 = 0;
        змінна успіх_отримання_кд_з_ю32 = отримати_символ_кд_з_ю32(п32(символ_ю16), символ_кд_0::адреса, символ_кд_1::адреса, символ_кд_2::адреса, символ_кд_3::адреса, символ_кд_розмір::адреса);
        якщо не успіх_отримання_кд_з_ю32 {
          якщо екранувати_невідомі {
            // потім: втілити
          }
          звільнити(система, дані_виходу);
          вихід_позиції_помилки::вміст = п - 1;
          вернути ні;
        }
        якщо символ_кд_розмір == 1 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
          покласти_в_місцезнаходження(система, місцезнаходження::адреса, п32(п - 1));
        } інакше якщо символ_кд_розмір == 2 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_1;
          розмір_виходу += 1;
          покласти_в_місцезнаходження(система, місцезнаходження::адреса, п32(п - 1));
        } інакше якщо символ_кд_розмір == 3 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_1;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_2;
          розмір_виходу += 1;
          покласти_в_місцезнаходження(система, місцезнаходження::адреса, п32(п - 1));
        } інакше якщо символ_кд_розмір == 4 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_1;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_3;
          розмір_виходу += 1;
          покласти_в_місцезнаходження(система, місцезнаходження::адреса, п32(п - 1));
        }
      } інакше якщо розмір_символа == 3 {
        п += 1;
        змінна другий_байт = вхід.дані[п];
        п += 1;
        змінна третій_байт = вхід.дані[п];
        змінна символ_ю32 = п32((п32(перший_байт & 15) << 12) | (п32(другий_байт & 63) << 6) | п32(третій_байт & 63));
        змінна символ_кд_0: п8 = 0;
        змінна символ_кд_1: п8 = 0;
        змінна символ_кд_2: п8 = 0;
        змінна символ_кд_3: п8 = 0;
        змінна символ_кд_розмір: п8 = 0;
        змінна успіх_отримання_кд_з_ю32 = отримати_символ_кд_з_ю32(символ_ю32, символ_кд_0::адреса, символ_кд_1::адреса, символ_кд_2::адреса, символ_кд_3::адреса, символ_кд_розмір::адреса);
        якщо не успіх_отримання_кд_з_ю32 {
          якщо екранувати_невідомі {
            // потім: втілити
          }
          звільнити(система, дані_виходу);
          вихід_позиції_помилки::вміст = п - 2;
          вернути ні;
        }
        якщо символ_кд_розмір == 1 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
          покласти_в_місцезнаходження(система, місцезнаходження::адреса, п32(п - 2));
        } інакше якщо символ_кд_розмір == 2 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_1;
          розмір_виходу += 1;
          покласти_в_місцезнаходження(система, місцезнаходження::адреса, п32(п - 2));
        } інакше якщо символ_кд_розмір == 3 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_1;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_2;
          розмір_виходу += 1;
          покласти_в_місцезнаходження(система, місцезнаходження::адреса, п32(п - 2));
        } інакше якщо символ_кд_розмір == 4 {
          дані_виходу[розмір_виходу] = символ_кд_0;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_1;
          розмір_виходу += 1;
          дані_виходу[розмір_виходу] = символ_кд_3;
          розмір_виходу += 1;
          покласти_в_місцезнаходження(система, місцезнаходження::адреса, п32(п - 2));
        }
      } інакше {
        якщо екранувати_невідомі {
          // потім: втілити
        }
        звільнити(система, дані_виходу);
        вихід_позиції_помилки::вміст = п;
        вернути ні;
      }
      п += 1;
    }

    якщо з_нульовим_байтом_в_кінці {
      дані_виходу[розмір_виходу] = 0;
    }

    вихід::вміст = кд {
      розмір_виходу,
      дані_виходу
    };

    вихід_місцезнаходжень::вміст = місцезнаходження;

    вернути так;
  }

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

  дія обробити_екранізації_в_кд(система: адреса<Система>, вхід: кд, з_нульовим_байтом_в_кінці: логічне, вихід: адреса<кд>) -> логічне {
    змінна розмір_виходу: природне = 0;
    змінна дані_виходу = виділити<п8>(система, вхід.розмір + 1);

    змінна п: природне = 0;

    поки п < вхід.розмір {
      змінна символ = вхід.дані[п];
      змінна розмір_символа = дізнатись_розмір_символа_кд(символ);

      якщо розмір_символа == 1 {
        якщо символ == символи::Обернена_похила {
          якщо (п + 1) < вхід.розмір {
            змінна наступний_символ = вхід.дані[п + 1];
            змінна розмір_наступного_символа = дізнатись_розмір_символа_кд(наступний_символ);

            якщо розмір_наступного_символа == 1 {
              якщо наступний_символ == символи::Обернена_похила {
                дані_виходу[розмір_виходу] = символи::Обернена_похила;
                розмір_виходу += 1;
                п += 1;
              } інакше якщо наступний_символ == символи::Дволапка {
                дані_виходу[розмір_виходу] = символи::Дволапка;
                розмір_виходу += 1;
                п += 1;
              } інакше якщо наступний_символ == символи::Однолапка {
                дані_виходу[розмір_виходу] = символи::Однолапка;
                розмір_виходу += 1;
                п += 1;
              } інакше якщо наступний_символ == символи::Мала_буква_р {
                дані_виходу[розмір_виходу] = символи::Міжряд;
                розмір_виходу += 1;
                п += 1;
              } інакше {
                дані_виходу[розмір_виходу] = вхід.дані[п];
                розмір_виходу += 1;
              }
            } інакше {
              дані_виходу[розмір_виходу] = вхід.дані[п];
              розмір_виходу += 1;
            }
          } інакше {
            дані_виходу[розмір_виходу] = вхід.дані[п];
            розмір_виходу += 1;
          }
        } інакше {
          дані_виходу[розмір_виходу] = вхід.дані[п];
          розмір_виходу += 1;
        }
      } інакше якщо розмір_символа == 2 {
        дані_виходу[розмір_виходу] = вхід.дані[п];
        розмір_виходу += 1;
        п += 1;
        дані_виходу[розмір_виходу] = вхід.дані[п];
        розмір_виходу += 1;
      } інакше якщо розмір_символа == 3 {
        дані_виходу[розмір_виходу] = вхід.дані[п];
        розмір_виходу += 1;
        п += 1;
        дані_виходу[розмір_виходу] = вхід.дані[п];
        розмір_виходу += 1;
        п += 1;
        дані_виходу[розмір_виходу] = вхід.дані[п];
        розмір_виходу += 1;
      } інакше якщо розмір_символа == 4 {
        дані_виходу[розмір_виходу] = вхід.дані[п];
        розмір_виходу += 1;
        п += 1;
        дані_виходу[розмір_виходу] = вхід.дані[п];
        розмір_виходу += 1;
        п += 1;
        дані_виходу[розмір_виходу] = вхід.дані[п];
        розмір_виходу += 1;
        п += 1;
        дані_виходу[розмір_виходу] = вхід.дані[п];
        розмір_виходу += 1;
      }

      п += 1;
    }

    якщо з_нульовим_байтом_в_кінці {
      дані_виходу[розмір_виходу] = 0;
    }

    вихід::вміст = кд {
      розмір_виходу,
      дані_виходу
    };

    вернути так;

  }

  дія обробити_екранізації_в_ю8(система: адреса<Система>, вхід: ю8, з_нульовим_байтом_в_кінці: логічне, вихід: адреса<ю8>) -> логічне {
    змінна розмір_виходу: природне = 0;
    змінна дані_виходу = виділити<п8>(система, вхід.розмір);

    змінна п: природне = 0;

    поки п < вхід.розмір {
      змінна символ = вхід.дані[п];
      змінна розмір_символа = дізнатись_розмір_символа_ю8(символ);

      якщо розмір_символа == 1 {
        якщо символ == відповідні_символи_юнікоду::Обернена_похила {
          якщо (п + 1) < вхід.розмір {
            змінна наступний_символ = вхід.дані[п + 1];
            змінна розмір_наступного_символа = дізнатись_розмір_символа_ю8(наступний_символ);

            якщо розмір_наступного_символа == 1 {
              якщо наступний_символ == відповідні_символи_юнікоду::Обернена_похила {
                дані_виходу[розмір_виходу] = відповідні_символи_юнікоду::Обернена_похила;
                розмір_виходу += 1;
                п += 1;
              } інакше якщо наступний_символ == відповідні_символи_юнікоду::Дволапка {
                дані_виходу[розмір_виходу] = відповідні_символи_юнікоду::Дволапка;
                розмір_виходу += 1;
                п += 1;
              } інакше якщо наступний_символ == відповідні_символи_юнікоду::Однолапка {
                дані_виходу[розмір_виходу] = відповідні_символи_юнікоду::Однолапка;
                розмір_виходу += 1;
                п += 1;
              } інакше якщо наступний_символ == 110 {
                дані_виходу[розмір_виходу] = відповідні_символи_юнікоду::Міжряд;
                розмір_виходу += 1;
                п += 1;
              } інакше {
                дані_виходу[розмір_виходу] = вхід.дані[п];
                розмір_виходу += 1;
              }
            } інакше якщо розмір_наступного_символа == 2 {
              якщо (п + 2) < вхід.розмір {
                // р
                якщо вхід.дані[п + 1] == 209 {
                  якщо вхід.дані[п + 2] == 128 {
                    дані_виходу[розмір_виходу] = відповідні_символи_юнікоду::Міжряд;
                    розмір_виходу += 1;
                    п += 1;
                    п += 1;
                  } інакше {
                    дані_виходу[розмір_виходу] = вхід.дані[п];
                    розмір_виходу += 1;
                  }
                } інакше {
                  дані_виходу[розмір_виходу] = вхід.дані[п];
                  розмір_виходу += 1;
                }
              } інакше {
                дані_виходу[розмір_виходу] = вхід.дані[п];
                розмір_виходу += 1;
              }
            } інакше {
              дані_виходу[розмір_виходу] = вхід.дані[п];
              розмір_виходу += 1;
            }
          } інакше {
            дані_виходу[розмір_виходу] = вхід.дані[п];
            розмір_виходу += 1;
          }
        } інакше {
          дані_виходу[розмір_виходу] = вхід.дані[п];
          розмір_виходу += 1;
        }
      } інакше якщо розмір_символа == 2 {
        дані_виходу[розмір_виходу] = вхід.дані[п];
        розмір_виходу += 1;
        п += 1;
        дані_виходу[розмір_виходу] = вхід.дані[п];
        розмір_виходу += 1;
      } інакше якщо розмір_символа == 3 {
        дані_виходу[розмір_виходу] = вхід.дані[п];
        розмір_виходу += 1;
        п += 1;
        дані_виходу[розмір_виходу] = вхід.дані[п];
        розмір_виходу += 1;
        п += 1;
        дані_виходу[розмір_виходу] = вхід.дані[п];
        розмір_виходу += 1;
      } інакше якщо розмір_символа == 4 {
        дані_виходу[розмір_виходу] = вхід.дані[п];
        розмір_виходу += 1;
        п += 1;
        дані_виходу[розмір_виходу] = вхід.дані[п];
        розмір_виходу += 1;
        п += 1;
        дані_виходу[розмір_виходу] = вхід.дані[п];
        розмір_виходу += 1;
        п += 1;
        дані_виходу[розмір_виходу] = вхід.дані[п];
        розмір_виходу += 1;
      }

      п += 1;
    }

    вихід::вміст = ю8 {
      розмір_виходу,
      дані_виходу
    };

    вернути так;
  }

  дія дізнатись_розмір_символа_кд(перший_байт: п8) -> п8 {
    якщо (перший_байт & 128) == 0 {
      вернути 1;
    }
    якщо (перший_байт & 224) == 192 {
      вернути 2;
    }
    якщо (перший_байт & 240) == 224 {
      вернути 3;
    }
    якщо (перший_байт & 248) == 240 {
      вернути 4;
    }
    вернути 0;
  }

  дія дізнатись_розмір_символа_ю8(перший_байт: п8) -> п8 {
    якщо (перший_байт & 128) == 0 {
      вернути 1;
    }
    якщо (перший_байт & 224) == 192 {
      вернути 2;
    }
    якщо (перший_байт & 240) == 224 {
      вернути 3;
    }
    якщо (перший_байт & 248) == 240 {
      вернути 4;
    }
    вернути 0;
  }
}