--lua
-- Скрипт для перевода английской раскладки в русскую
-- Hfcrkflrf -> Раскладка
local file= io.open([[C:\123.txt]], "r")          -- файл с текстом
local result_file = io.open([[C:\456.txt]], "w")  -- куда сохранить результат

local t={}
t["a"]="ф"  t["b"]="и"  t["c"]="с"  t["d"]="в"  t["e"]="у"  t["f"]="а"
t["g"]="п"  t["h"]="р"  t["i"]="ш"  t["j"]="о"  t["k"]="л"  t["l"]="д"
t["m"]="ь"  t["n"]="т"  t["o"]="щ"  t["p"]="з"  t["q"]="й"  t["r"]="к"
t["s"]="ы"  t["t"]="е"  t["u"]="г"  t["v"]="м"  t["w"]="ц"  t["x"]="ч"
t["y"]="н"  t["z"]="я"  t["`"]="ё"  t["["]="х"  t["]"]="ъ"  t[";"]="ж"
t["'"]="э"  t[","]="б"  t["."]="ю"  t["/"]="."  t["A"]="Ф"  t["B"]="И"
t["C"]="С"  t["D"]="В"  t["E"]="У"  t["F"]="А"  t["G"]="П"  t["H"]="Р"
t["I"]="Ш"  t["J"]="О"  t["K"]="Л"  t["L"]="Д"  t["M"]="Ь"  t["N"]="Т"
t["O"]="Щ"  t["P"]="З"  t["Q"]="Й"  t["R"]="К"  t["S"]="Ы"  t["T"]="Е"
t["U"]="Г"  t["V"]="М"  t["W"]="Ц"  t["X"]="Ч"  t["Y"]="Н"  t["Z"]="Я"
t["{"]="Х"  t["}"]="Ъ"  t[":"]="Ж"  t['"']="Э"  t["<"]="Б"  t[">"]="Ю"
t["?"]=","  t["~"]="Ё"  t["@"]='"'  t["#"]="№"  t["$"]=";"  t["^"]=":"
t["&"]="?"

if file and result_file then     -- если файлы открылись
    for v in file:lines() do
        result_file:write(string.gsub(v, ".", t).."\r\n")  -- поиск и замена текста из таблицы 't'
    end

    file:close()
    result_file:close()
else
    log ("Файлы отсутствуют или недоступны для чтения/записи")
end

--lua
log "clear"   log "mode compact"

local s="Вставить свой код URL"   -- << Для декодирования вставить url-код между ""
log(s)

local t={}
t["%D0%90"]="А" t["%D0%91"]="Б" t["%D0%92"]="В" t["%D0%93"]="Г" t["%D0%94"]="Д" t["%D0%95"]="Е" t["%D0%81"]="Ё" t["%D0%96"]="Ж" t["%D0%97"]="З" t["%D0%98"]="И" t["%D0%99"]="Й"
t["%D0%9A"]="К" t["%D0%9B"]="Л" t["%D0%9C"]="М" t["%D0%9D"]="Н" t["%D0%9E"]="О" t["%D0%9F"]="П" t["%D0%A0"]="Р" t["%D0%A1"]="С" t["%D0%A2"]="Т" t["%D0%A3"]="У" t["%D0%A4"]="Ф"
t["%D0%A5"]="Х" t["%D0%A6"]="Ц" t["%D0%A7"]="Ч" t["%D0%A8"]="Ш" t["%D0%A9"]="Щ" t["%D0%AA"]="Ъ" t["%D0%AB"]="Ы" t["%D0%AC"]="Ь" t["%D0%AD"]="Э" t["%D0%AE"]="Ю" t["%D0%AF"]="Я"
t["%D0%B0"]="а" t["%D0%B1"]="б" t["%D0%B2"]="в" t["%D0%B3"]="г" t["%D0%B4"]="д" t["%D0%B5"]="е" t["%D1%91"]="ё" t["%D0%B6"]="ж" t["%D0%B7"]="з" t["%D0%B8"]="и" t["%D0%B9"]="й"
t["%D0%BA"]="к" t["%D0%BB"]="л" t["%D0%BC"]="м" t["%D0%BD"]="н" t["%D0%BE"]="о" t["%D0%BF"]="п" t["%D1%80"]="р" t["%D1%81"]="с" t["%D1%82"]="т" t["%D1%83"]="у" t["%D1%84"]="ф"
t["%D1%85"]="х" t["%D1%86"]="ц" t["%D1%87"]="ч" t["%D1%88"]="ш" t["%D1%89"]="щ" t["%D1%8A"]="ъ" t["%D1%8B"]="ы" t["%D1%8C"]="ь" t["%D1%8D"]="э" t["%D1%8E"]="ю" t["%D1%8F"]="я"

for v in pairs(t) do   -- добавление ключей в таблицу, если был "%D0%9A", то добавляется "%d0%9a"
    t[v:lower()]=t[v]
end

for i=32, 127 do t["%" .. string.format("%X", i)]=string.char(i) end   -- добавление ключей в таблицу, все символы ascii с 32 по 127

s=s:gsub("%%[Dd][01]%%%x%x", t)   -- замена кириллицы
s=s:gsub("%%..", t)               -- замена спецсимволов
log(s)                            -- результат

--lua
log "clear"  log "mode compact"
local s="Текст который нужно отзеркалить."
log (s)
log (s:reverse())

--lua
log "clear"  log "mode compact"
-- Скрипт для конвертерования текста(ЛАТИНИЦА)в Азбуку Морзе или наоборот.
local text=[[Text or - . -..- -]]-- << Введите исходный текст на латинице или код Морзе и запустите скрипт.

log(text)

local t, t1, temp = {}, {}, {}
t["A"]=".-"     t["B"]="-..."   t["C"]="-.-."   t["D"]="-.."    t["E"]="."      t["F"]="..-."   t["G"]="--."
t["H"]="...."   t["I"]=".."     t["J"]=".---"   t["K"]="-.-"    t["L"]=".-.."   t["M"]="--"     t["N"]="-."
t["O"]="---"    t["P"]=".--."   t["Q"]="--.-"   t["R"]=".-."    t["S"]="..."    t["T"]="-"      t["U"]="..-"
t["V"]="...-"   t["W"]=".--"    t["X"]="-..-"   t["Y"]="-.--"   t["Z"]="--.."
for v in pairs(t) do temp[string_lower(v)]=t[v] end
for v in pairs(temp) do t[v]=temp[v] end
t["1"]=".----"  t["2"]="..---"  t["3"]="...--"  t["4"]="....-"  t["5"]="....."  t["6"]="-...."  t["7"]="--..."
t["8"]="---.."  t["9"]="----."  t["0"]="-----"  t["."]="......" t[":"]="---..." t[";"]="-.-.-." t["("]="-.--.-"
t[")"]="-.--.-" t["'"]=".----." t['"']=".-..-." t["-"]="-....-" t["/"]="-..-."  t["?"]="..--.." t["!"]="--..--"
t[","]=".-.-.-"
for v in pairs(t) do t1[t[v]]=v end   -- таблица для дешифровки, копия 't' только ключи и значения ключей поменяны местами

local x=0
for v in text:gmatch("[%.%- ]") do x=x+1 end  -- подсчёт точек, тире и слешей в строке

if x > #text*50/100 then   -- если их больше 50%, считаем что передана шифрованная строка
    text=string.gsub((text .. " "):gsub("(.-) ", t1), "  ", " ")    -- дешифруем
else
    text=string.gsub(text:gsub("(.)", "%1 "), "[^ ]", t)  -- иначе шифруем
end
log (text)

--lua
log "clear"  log "mode compact"

-- Скрипт для конвертирования текста(КИРИЛЛИЦА)в Азбуку Морзе или наоборот.
local text=[[Текст или - . -.- ... -]]-- << Введите исходный текст на кириллице или код Морзе и запустите скрипт.

log(text)

local t, t1, temp = {}, {}, {}
t["А"]=".-"     t["Б"]="-..."   t["В"]=".--"    t["Г"]="--."    t["Д"]="-.."    t["Е"]="."    t["Ё"]="."
t["Ж"]="...-"   t["З"]="--.."   t["И"]=".."     t["Й"]=".---"   t["К"]="-.-"    t["Л"]=".-.." t["М"]="--"
t["Н"]="-."     t["О"]="---"    t["П"]=".--."   t["Р"]=".-."    t["С"]="..."    t["Т"]="-"    t["У"]="..-"
t["Ф"]="..-."   t["Х"]="...."   t["Ц"]="-.-."   t["Ч"]="---."   t["Ш"]="----"   t["Щ"]="--.-" t["Ь"]="-..-"
t["Ъ"]="-..-"   t["Ы"]="-.--"   t["Э"]="..-.."  t["Ю"]="..--"   t["Я"]=".-.-"
for v in pairs(t) do temp[string_lower(v)]=t[v] end
for v in pairs(temp) do t[v]=temp[v] end
t["1"]=".----"  t["2"]="..---"  t["3"]="...--"  t["4"]="....-"  t["5"]="....."  t["6"]="-...."  t["7"]="--..."
t["8"]="---.."  t["9"]="----."  t["0"]="-----"  t["."]="......" t[":"]="---..." t[";"]="-.-.-." t["("]="-.--.-"
t[")"]="-.--.-" t["'"]=".----." t['"']=".-..-." t["-"]="-....-" t["/"]="-..-."  t["?"]="..--.." t["!"]="--..--"
t[","]=".-.-.-"
for v in pairs(t) do t1[t[v]]=v end   -- таблица для дешифровки, копия 't' только ключи и значения ключей поменяны местами

local x=0
for v in text:gmatch("[%.%- ]") do x=x+1 end  -- подсчёт точек, тире и слешей в строке

if x > #text*50/100 then   -- если их больше 50%, считаем что передана шифрованная строка
    text=string.gsub((text .. " "):gsub("(.-) ", t1), "  ", " ")    -- дешифруем
else
    text=string.gsub(text:gsub("(.)", "%1 "), "[^ ]", t)  -- иначе шифруем
end
log (text)

c("label1")->text;
$find_and_repeat = array (
'0' => 'Привет',
'1' => ' Максим',
'23' => ' как дела',
'45' => ' нормально реально не реально',
);
$test = 'test.txt';
$test = file_get_contents($test);
$test = explode (',', $test); // , - символ которым разделены слова!
foreach ($find_and_repeat as $key => $v)
{
    $test = str_replace($key, $v, $test);
    $newTest = fopen('new_test.txt', 'w');
    $check = fwrite($newTest , implode($test));
    fclose($newTest);
}
//print_r($test);
if($check = true)
{echo 'Заменил!!!';}

<?php
/**
 * Created by PhpStorm.
 * User: karamush
 * Date: 13.07.2018
 * Time: 23:08
 */

class MorseCoder_Class {

    public $MORSE_CHAR_DELIMITER = ' ';            // разделитель между символами в обычной морзянке
    public $UNKNOWN_CHAR = '?';                    // это если перевести не удалось. неизвестный символ
    public $MORSE_DOT = '.';                       // точка
    public $MORSE_DASH = '-';                      // тире
    public $MORSE_BIN_DOT = '1';                   // бинарная точка
    public $MORSE_BIN_DASH ='111';                 // бинарное тире
    public $MORSE_BIN_DELIMITER = '0';             // разделитель между знаками одного символа
    public $MORSE_BIN_CHAR_DELIMITER = '00';       // разделитель между символами
    public $MORSE_BIN_WORD_DELIMITER = '000';      // разделитель между словами (эм. пробел?)

    const MORSE_TYPE_SIMPLE = 0;
    const MORSE_TYPE_BINARY = 1;
    const MORSE_LANGUAGE_LATIN = 1;
    const MORSE_LANGUAGE_CYRILLIC = 0;

    public $morse_type = self::MORSE_TYPE_BINARY;
    public $morse_language = self::MORSE_LANGUAGE_CYRILLIC;
    public $morse_capital = true;

    // символы и цифры
    private $codes_symbols = [
        '1' => '.----',
        '2' => '..---',
        '3' => '...--',
        '4' => '....-',
        '5' => '.....',
        '6' => '-....',
        '7' => '--...',
        '8' => '---..',
        '9' => '----.',
        '0' => '-----',
        '.' => '......',
        ',' => '.-.-.-',
        ':' => '---...',
        ';' => '-.-.-.',
        '(' => '-.--.-',
        ')' => '-.--..', // TODO: использовал собственный символ для закрывающей скобки. опасно :)
        '\'' => '.----.',
        '`' => '.----.',
        '"' => '.-..-.',
        '-' => '-....-',
        '/' => '-..-.',
        '?' => '..--..',
        '!' => '--..--',
        ' ' => '-...-', // знак раздела, пробел, короче, WTF?!
        "\n" => '-.-..',    // TODO: ещё один добавленный символ. Символ переноса строки!
        "\r" => '-.-..-',   // TODO: ай-ай-ай!
        '@' => '.--.-.',
        '[END]' => '..-.-'
    ];

    // латинский алфавит
    private $codes_latin = [
        'A' => '.-',
        'B' => '-...',
        'C' => '-.-.',
        'D' => '-..',
        'E' => '.',
        'F' => '..-.',
        'G' => '--.',
        'H' => '....',
        'I' => '..',
        'J' => '.---',
        'K' => '-.-',
        'L' => '.-..',
        'M' => '--',
        'N' => '-.',
        'O' => '---',
        'P' => '.--.',
        'Q' => '--.-',
        'R' => '.-.',
        'S' => '...',
        'T' => '-',
        'U' => '..-',
        'W' => '.--',
        'X' => '-..-',
        'Y' => '-.--',
        'Z' => '--..',
        'V' => '...-',
        'CH' => '---.',
        'SH' => '----',
        'Ñ' => '-..-',
        'É' => '..-..',
        'Ü' => '..--',
        'Ä' => '.-.-'
    ];

    // кириллический алфавит
    private $codes_cyrillic = [
        'А' => '.-',
        'Б' => '-...',
        'В' => '.--',
        'Г' => '--.',
        'Д' => '-..',
        'Е' => '.',     'Ё' => '.',
        'Ж' => '...-',
        'З' => '--..',
        'И' => '..',
        'Й' => '.---',
        'К' => '-.-',
        'Л' => '.-..',
        'М' => '--',
        'Н' => '-.',
        'О' => '---',
        'П' => '.--.',
        'Р' => '.-.',
        'С' => '...',
        'Т' => '-',
        'У' => '..-',
        'Ф' => '..-.',
        'Х' => '....',
        'Ц' => '-.-.',
        'Ч' => '---.',
        'Ш' => '----',
        'Щ' => '--.-',
        'Ь' => '-..-',  'Ъ' => '-..-',
        'Ы' => '-.--',
        'Э' => '..-..',
        'Ю' => '..--',
        'Я' => '.-.-',
    ];

    public function __construct() {

    }

    /**
     * Получить текущий полный алфавит, но с приоритетом языка,
     * чтоб в первую очередь шифровалось или дешифровалось на текущем языке,
     * но отсутствующие символы чтобы тоже были. Плюс цифры и другие символы.
     *
     * @return array
     */
    private function get_current_full_alphabet() {
        $alphabet = ($this->morse_language == self::MORSE_LANGUAGE_CYRILLIC) ? array_merge($this->codes_cyrillic, $this->codes_latin) : array_merge($this->codes_latin, $this->codes_cyrillic);
        return array_merge($alphabet, $this->codes_symbols);
    }

    /**
     * Переводит обычный символ в его Морзе-символ
     * @param $char
     *
     * @return mixed|string
     */
    function char_to_morse($char) {
        $char = mb_strtoupper($char);
        return array_key_exists($char, $this->get_current_full_alphabet()) ? $this->get_current_full_alphabet()[$char] : $this->UNKNOWN_CHAR;
    }

    /**
     * Приводит строку с морзянкой к общему формату, заменяя звёздочки на точки и т.д.
     * @param $morse_text
     *
     * @return string
     */
    function prepare_morse_text($morse_text) {
        $morse_text = str_replace('*', '.', $morse_text);
        $morse_text = str_replace('_', '-', $morse_text);
        return $morse_text;
    }

    function mbStringToArray($string, $encoding = 'UTF-8') {
        $strlen = mb_strlen($string);
        $str_array = [];
        while ($strlen) {
            $str_array[] = mb_substr($string, 0, 1, $encoding);
            $string = mb_substr($string, 1, $strlen, $encoding);
            $strlen = mb_strlen($string, $encoding);
        }
        return $str_array;
    }

    /**
     * Переводит Морзе-код символа в его обычный символ
     * @param $morse_char
     *
     * @return string
     */
    function morse_to_char($morse_char) {
        // сначала к единому формату тире и точек привести нужно символ
        $morse_char = $this->prepare_morse_text($morse_char);
        return in_array($morse_char, $this->get_current_full_alphabet()) ? array_search($morse_char, $this->get_current_full_alphabet()) : $this->UNKNOWN_CHAR;
    }

    /**
     * Переводит строку обычного текста в морзянку, ставя также разделитель после каждого символа.
     * @param $plain_text
     *
     * @return string
     */
    function text_to_morse($plain_text) {
        $plain_text = $this->mbStringToArray(mb_strtoupper($plain_text));
        $result = '';
        foreach ($plain_text as $char) {
            $result .= $this->char_to_morse($char) . $this->MORSE_CHAR_DELIMITER;
        }
        return $result;
    }

    /**
     * Переводит морзянку в обычный человеческий текст.
     *
     * @param      $morse_text
     *
     * @return string
     */
    function morse_to_text($morse_text) {
        $morse_chars = explode($this->MORSE_CHAR_DELIMITER, $morse_text);
        $result = '';
        foreach($morse_chars as $char) {
            $result .= $this->morse_to_char($char);
        }

        return $this->morse_capital ? $result : mb_strtolower($result);
    }

    /**
     * Переводит бинарную морзянку в морзянку обычную.
     * @param $morse_bin_text
     *
     * @return string
     */
    function morse_bin_to_morse($morse_bin_text) {
        $result = '';
        $bin_morse_chars = explode($this->MORSE_BIN_CHAR_DELIMITER, $morse_bin_text);
        foreach ($bin_morse_chars as $bin_morse_char) {
            $bin_morse_char = str_replace($this->MORSE_BIN_DASH, $this->MORSE_DASH, $bin_morse_char);
            $bin_morse_char = str_replace($this->MORSE_BIN_DOT, $this->MORSE_DOT, $bin_morse_char);
            $bin_morse_char = str_replace($this->MORSE_BIN_DELIMITER, '', $bin_morse_char);
            $result .= $bin_morse_char . $this->MORSE_CHAR_DELIMITER;
        }
        return rtrim($result, $this->MORSE_CHAR_DELIMITER);
    }

    /**
     * Переводит морзянку в бинарную морзянку.
     * @param $morse_text
     *
     * @return string
     */
    function morse_to_morse_bin($morse_text) {
        $result = '';
        $morse_text = $this->prepare_morse_text($morse_text);
        for($i=0; $i<strlen($morse_text);$i++) {
            switch ($morse_text[$i]) {
                case $this->MORSE_DOT: $result .= $this->MORSE_BIN_DOT . $this->MORSE_BIN_DELIMITER; break;
                case $this->MORSE_DASH: $result .= $this->MORSE_BIN_DASH . $this->MORSE_BIN_DELIMITER; break;
                case $this->MORSE_CHAR_DELIMITER: $result .= $this->MORSE_BIN_DELIMITER; break; // добавляем ещё один нолик, а не два нуля. Потому что с предыдущего символа нолик ещё есть
            }
        }
        return $result;
    }

    /**
     * Текст в бинарную морзянку
     * @param $plaint_text
     *
     * @return string
     */
    function text_to_morse_bin($plaint_text) {
        return $this->morse_to_morse_bin($this->text_to_morse($plaint_text));
    }

    /**
     * Бинарную морзянку в текст
     *
     * @param      $morse_bin
     *
     * @return string
     */
    function morse_bin_to_text($morse_bin) {
        return $this->morse_to_text($this->morse_bin_to_morse($morse_bin));
    }

    /**
     * Закодировать открытый текст в бинарную морзянку или в обычную
     * (зависит от параметра morse_type)
     * @param $plain_text
     *
     * @return string
     */
    function morse_encode($plain_text) {
        return ($this->morse_type == self::MORSE_TYPE_BINARY) ? $this->text_to_morse_bin($plain_text) : $this->text_to_morse($plain_text);
    }

    /**
     * Раскодировать закодированный текст из бинарной морзянки или из обычной
     * (зависит от параметра morse_type)
     * @param $encoded_text
     *
     * @return string
     */
    function morse_decode($encoded_text) {
        return ($this->morse_type == self::MORSE_TYPE_BINARY) ? $this->morse_bin_to_text($encoded_text) : $this->morse_to_text($encoded_text);
    }


}

--lua
log "clear"  log "mode compact"
local t={}  -- таблица с символами
t[".-"]="A"
t["-..."]="B"
t["-.-."]="C"

local x="ACDBA"   -- строка для шифровки, буквы 'D' в таблице нет, поэтому она останётся как есть
log("Строка для шифрования:\r\n" .. x)
log()

-- текст в Азбуку Морзе в бинарном виде:
--    A           B             C               -- символы
--    .-00        -...00        -.-.00          -- между символами 00
--    .0-00       -0.0.0.00     -0.0-0.00       -- между точкой и тире 0
--    10-00       -01010100     -010-0100       -- точки меняются на 1
--    1011100     11101010100   1110101110100   -- тире на 111

local s=""
for w in x:gmatch(".") do         -- поиск любого символа
    local break_=0
    for i, value in pairs(t) do   -- обход массива в посках ключа
        if value == w then        -- если нашлось
            s=s .. string.gsub(string.gsub(string.gsub(i, "(.)", "%10") .. "0", "%.", "1"), "%-", "111")  -- замена символа, к примеру 'A' на 1011100
            break_ = 1    -- флаг что символ зашифрован
            break
        end
    end
    if break_ == 0 then s=s .. w .. "00" end   -- если символа нет в таблице, то он остаётся как есть, т. е. не шифруется
end
log ("Строка в бинарном виде:\r\n" .. s)   -- строка в бинарном виде
log()

local ss=""
for w in s:gmatch("(.-)00") do  -- поиск символа, помним что между символами 00
    if w:match("[01]+") then    -- если символ шифрованный
       ss=ss .. string.gsub(string.gsub(string.gsub(w:gsub("111", "-"), "1", "."), "0", ""), ".+", t)
    else
       ss=ss .. w   -- иначе не шифрованный, дописываем как есть
    end
end
log ("Расшифрованная строка:\r\n" .. ss)

--lua
-- Скрипт для перевода английской раскладки в русскую
-- Hfcrkflrf -> Раскладка
local file= io.open([[C:\123.txt]], "r")          -- файл с текстом
local result_file = io.open([[C:\456.txt]], "w")  -- куда сохранить результат

local t={}
t["a"]="ф"          -- все 'a' заменит на 'ф'
t["b"]="и"
t["c"]="с"
t["d"]="в"
t["e"]="у"
t["f"]="а"
t["g"]="п"
t["h"]="р"
t["i"]="ш"
t["j"]="о"
t["k"]="л"
t["l"]="д"
t["m"]="ь"
t["n"]="т"
t["o"]="щ"
t["p"]="з"
t["q"]="й"
t["r"]="к"
t["s"]="ы"
t["t"]="е"
t["u"]="г"
t["v"]="м"
t["w"]="ц"
t["x"]="ч"
t["y"]="н"
t["z"]="я"
t["`"]="ё"
t["["]="х"
t["]"]="ъ"
t[";"]="ж"
t["'"]="э"
t[","]="б"
t["."]="ю"
t["/"]="."
t["A"]="Ф"
t["B"]="И"
t["C"]="С"
t["D"]="В"
t["E"]="У"
t["F"]="А"
t["G"]="П"
t["H"]="Р"
t["I"]="Ш"
t["J"]="О"
t["K"]="Л"
t["L"]="Д"
t["M"]="Ь"
t["N"]="Т"
t["O"]="Щ"
t["P"]="З"
t["Q"]="Й"
t["R"]="К"
t["S"]="Ы"
t["T"]="Е"
t["U"]="Г"
t["V"]="М"
t["W"]="Ц"
t["X"]="Ч"
t["Y"]="Н"
t["Z"]="Я"
t["{"]="Х"
t["}"]="Ъ"
t[":"]="Ж"
--t["""]="Э"
t["<"]="Б"
t[">"]="Ю"
t["?"]=","
t["~"]="Ё"
--t["@"]="""
t["#"]="№"
t["$"]=";"
t["^"]=":"
t["&"]="?"

if file and result_file then     -- если файлы открылись
    for v in file:lines() do
        result_file:write(string.gsub(v, ".", t).."\r\n")  -- поиск и замена текста из таблицы 't'
    end

    file:close()
    result_file:close()
else
    log ("Файлы отсутствуют или недоступны для чтения/записи")
end

--lua
log "clear"   log "mode compact"

local s="Cirus-code-master%20%D0%B1%D0%BE%D0%B6%D1%8D%D0%BD%D1%8C%D0%BA%D0%B0!:)"   -- Код {english text} Код lua!!!
log(s)

local t={}
t["%D0%90"]="А" t["%D0%91"]="Б" t["%D0%92"]="В" t["%D0%93"]="Г" t["%D0%94"]="Д" t["%D0%95"]="Е" t["%D0%81"]="Ё" t["%D0%96"]="Ж" t["%D0%97"]="З" t["%D0%98"]="И" t["%D0%99"]="Й"
t["%D0%9A"]="К" t["%D0%9B"]="Л" t["%D0%9C"]="М" t["%D0%9D"]="Н" t["%D0%9E"]="О" t["%D0%9F"]="П" t["%D0%A0"]="Р" t["%D0%A1"]="С" t["%D0%A2"]="Т" t["%D0%A3"]="У" t["%D0%A4"]="Ф"
t["%D0%A5"]="Х" t["%D0%A6"]="Ц" t["%D0%A7"]="Ч" t["%D0%A8"]="Ш" t["%D0%A9"]="Щ" t["%D0%AA"]="Ъ" t["%D0%AB"]="Ы" t["%D0%AC"]="Ь" t["%D0%AD"]="Э" t["%D0%AE"]="Ю" t["%D0%AF"]="Я"
t["%D0%B0"]="а" t["%D0%B1"]="б" t["%D0%B2"]="в" t["%D0%B3"]="г" t["%D0%B4"]="д" t["%D0%B5"]="е" t["%D1%91"]="ё" t["%D0%B6"]="ж" t["%D0%B7"]="з" t["%D0%B8"]="и" t["%D0%B9"]="й"
t["%D0%BA"]="к" t["%D0%BB"]="л" t["%D0%BC"]="м" t["%D0%BD"]="н" t["%D0%BE"]="о" t["%D0%BF"]="п" t["%D1%80"]="р" t["%D1%81"]="с" t["%D1%82"]="т" t["%D1%83"]="у" t["%D1%84"]="ф"
t["%D1%85"]="х" t["%D1%86"]="ц" t["%D1%87"]="ч" t["%D1%88"]="ш" t["%D1%89"]="щ" t["%D1%8A"]="ъ" t["%D1%8B"]="ы" t["%D1%8C"]="ь" t["%D1%8D"]="э" t["%D1%8E"]="ю" t["%D1%8F"]="я"

for v in pairs(t) do   -- добавление ключей в таблицу, если был "%D0%9A", то добавляется "%d0%9a"
    t[v:lower()]=t[v]
end

for i=32, 127 do t["%" .. string.format("%X", i)]=string.char(i) end   -- добавление ключей в таблицу, все символы ascii с 32 по 127


s=s:gsub("%%[Dd][01]%%%x%x", t)   -- замена кириллицы
s=s:gsub("%%..", t)               -- замена спецсимволов
log(s)                            -- результат