local ns = _G.WoWTranslate_UK_NS

local translator = setmetatable({}, { __index = ns.BaseTranslator })
translator.IsEnabled = translator.IsEnabled or function() return true end
ns.TranslationsManager:Add(translator)

local EN_PLURALS = {
    ["Bears"] = "Ведмеді", ["Wolves"] = "Вовки", ["Boars"] = "Кабани",
    ["Spiders"] = "Павуки", ["Crabs"] = "Краби", ["Bats"] = "Кажани",
    ["Foxes"] = "Лисиці", ["Raptors"] = "Раптори", ["Ravagers"] = "Спустошувачі",
    ["Serpents"] = "Змії", ["Turtles"] = "Черепахи", ["Birds"] = "Птахи",
    ["Owls"] = "Сови", ["Hounds"] = "Гончаки", ["Worgs"] = "Ворги",
    ["Dragons"] = "Дракони", ["Demons"] = "Демони", ["Giants"] = "Велетні",
    ["Elementals"] = "Стихійники", ["Undead"] = "Нежить", ["Beasts"] = "Звірі",
    ["Humanoids"] = "Гуманоїди", ["Murlocs"] = "Мурлоки", ["Gnolls"] = "Гноли",
    ["Kobolds"] = "Кобольди", ["Trolls"] = "Тролі", ["Ogres"] = "Огри",
    ["Naga"] = "Наги", ["Satyrs"] = "Сатири", ["Harpy"] = "Гарпії",
    ["Harpies"] = "Гарпії", ["Wyrm"] = "Черв", ["Wyrms"] = "Черв'яки",
    ["Whelps"] = "Змійченята", ["Drakes"] = "Дракони", ["Proto-Drakes"] = "Протодракони",
    ["Devilsaurs"] = "Дияволозаври", ["Silithids"] = "Силітіди",
    ["Scorpids"] = "Скорпіди", ["Crocolisks"] = "Кроколіски",
    ["Basilisks"] = "Василіски", ["Gorillas"] = "Горили", ["Monkeys"] = "Мавпи",
    ["Cats"] = "Коти", ["Dogs"] = "Собаки", ["Rats"] = "Щури",
    ["Mice"] = "Миші", ["Sheep"] = "Вівці", ["Cows"] = "Корови",
    ["Pigs"] = "Свині", ["Chickens"] = "Курки", ["Deer"] = "Олені",
    ["Elk"] = "Лосі", ["Mammoths"] = "Мамонти", ["Moths"] = "Молі",
    ["Wasps"] = "Оси", ["Toads"] = "Ропухи", ["Frogs"] = "Жаби",
    ["Lizards"] = "Ящірки", ["Goats"] = "Кози", ["Rams"] = "Барани",
    ["Horses"] = "Коні", ["Sloth"] = "Лінивці", ["Mastiffs"] = "Мастифи",
    ["Worms"] = "Хробаки", ["Beetles"] = "Жуки", ["Scorpions"] = "Скорпіони",
    ["Caribou"] = "Карибу", ["Courser"] = "Бігун", ["Coursers"] = "Бігуни",
    ["Eagles"] = "Орли", ["Hawks"] = "Яструби", ["Vultures"] = "Грифи",
    ["Stags"] = "Олені", ["Mushrooms"] = "Гриби", ["Sporebats"] = "Спорові кажани",
    ["Tallstriders"] = "Високоступи", ["Dragonhawks"] = "Драконячі яструби",
    ["Gryphons"] = "Грифони", ["Hippogryphs"] = "Гіпогриф",
    ["Wyverns"] = "Виверни", ["Pterrordax"] = "Птерордакси",
    ["Frostwyrms"] = "Крижані черв'яки",
}

local UK_PLURALS_GEN = {
    ["Ведмеді"] = "Ведмедів", ["Вовки"] = "Вовків", ["Кабани"] = "Кабанів",
    ["Павуки"] = "Павуків", ["Краби"] = "Крабів", ["Кажани"] = "Кажанів",
    ["Лисиці"] = "Лисиць", ["Раптори"] = "Рапторів", ["Спустошувачі"] = "Спустошувачів",
    ["Змії"] = "Змій", ["Черепахи"] = "Черепах", ["Птахи"] = "Птахів",
    ["Сови"] = "Сов", ["Гончаки"] = "Гончаків", ["Ворги"] = "Воргів",
    ["Дракони"] = "Драконів", ["Демони"] = "Демонів", ["Велетні"] = "Велетнів",
    ["Стихійники"] = "Стихійників", ["Звірі"] = "Звірів", ["Гуманоїди"] = "Гуманоїдів",
    ["Мурлоки"] = "Мурлоків", ["Гноли"] = "Гнолів", ["Кобольди"] = "Кобольдів",
    ["Тролі"] = "Тролів", ["Огри"] = "Огрів", ["Наги"] = "Наг",
    ["Сатири"] = "Сатирів", ["Гарпії"] = "Гарпій", ["Коти"] = "Котів",
    ["Собаки"] = "Собак", ["Щури"] = "Щурів", ["Миші"] = "Мишів",
    ["Горили"] = "Горил", ["Мавпи"] = "Мавп", ["Жуки"] = "Жуків",
    ["Скорпіони"] = "Скорпіонів", ["Хробаки"] = "Хробаків", ["Мастифи"] = "Мастифів",
    ["Василіски"] = "Василісків", ["Силітіди"] = "Силітідів", ["Скорпіди"] = "Скорпідів",
    ["Кроколіски"] = "Кроколісків", ["Дияволозаври"] = "Дияволозаврів",
    ["Протодракони"] = "Протодраконів", ["Змійченята"] = "Змійченят",
    ["Мамонти"] = "Мамонтів", ["Грифони"] = "Грифонів", ["Гіпогриф"] = "Гіпогрифів",
    ["Виверни"] = "Виверн", ["Високоступи"] = "Високоступів",
    ["Драконячі яструби"] = "Драконячих яструбів", ["Спорові кажани"] = "Спорових кажанів",
    ["Птерордакси"] = "Птерордаксів", ["Крижані черв'яки"] = "Крижаних черв'яків",
    ["Бігуни"] = "Бігунів", ["Орли"] = "Орлів", ["Яструби"] = "Яструбів",
    ["Грифи"] = "Грифів", ["Олені"] = "Оленів", ["Гриби"] = "Грибів",
    ["Лосі"] = "Лосів", ["Карибу"] = "Карибу", ["Барани"] = "Баранів",
    ["Коні"] = "Коней", ["Кози"] = "Кіз", ["Вівці"] = "Вівець",
    ["Курки"] = "Курок", ["Корови"] = "Корів", ["Свині"] = "Свиней",
    ["Ропухи"] = "Ропух", ["Жаби"] = "Жаб", ["Ящірки"] = "Ящірок",
    ["Молі"] = "Молі", ["Оси"] = "Ос", ["Вовк"] = "Вовка",
}

local function stripArticle(text)
    if not text or type(text) ~= "string" then return text end
    return text:match("^[Tt]he (.+)$") or text:match("^[Aa]n? (.+)$") or text
end

local EN_TITLES = {
    ["Lord"] = "Лорд", ["Lady"] = "Леді", ["Sir"] = "Сер",
    ["King"] = "Король", ["Queen"] = "Королева",
    ["Prince"] = "Принц", ["Princess"] = "Принцеса",
    ["Baron"] = "Барон", ["Baroness"] = "Баронеса",
    ["Count"] = "Граф", ["Countess"] = "Графиня",
    ["Duke"] = "Герцог", ["Duchess"] = "Герцогиня",
    ["Commander"] = "Командир", ["Captain"] = "Капітан",
    ["General"] = "Генерал", ["Admiral"] = "Адмірал",
    ["Major"] = "Майор", ["Sergeant"] = "Сержант",
    ["Corporal"] = "Капрал", ["Lieutenant"] = "Лейтенант",
    ["Magister"] = "Магістер", ["Archmage"] = "Архімаг",
    ["Highlord"] = "Верховний лорд", ["Warlord"] = "Воєначальник",
    ["Chieftain"] = "Вождь", ["Overlord"] = "Володар",
    ["Master"] = "Майстер", ["Grand Master"] = "Гранд майстер",
    ["Elder"] = "Старійшина", ["Archon"] = "Архонт",
    ["Justicar"] = "Юстицар", ["Inquisitor"] = "Інквізитор",
    ["Ambassador"] = "Посол", ["Emissary"] = "Емісар",
    ["Envoy"] = "Посланець", ["Herald"] = "Вісник",
    ["Warden"] = "Наглядач", ["Keeper"] = "Зберігач",
    ["Guardian"] = "Охоронець", ["Sentinel"] = "Вартова",
    ["Proctor"] = "Прокурор", ["Consul"] = "Консул",
    ["Prelate"] = "Прелат", ["Vicar"] = "Вікарій",
    ["Bishop"] = "Єпископ", ["Cardinal"] = "Кардинал",
    ["Exarch"] = "Екзарх", ["Paragon"] = "Парагон",
    ["Aspect"] = "Аспект", ["Prime"] = "Прайм",
    ["Regent"] = "Регент", ["Steward"] = "Дворецький",
    ["Seneschal"] = "Сенешаль", ["Chancellor"] = "Канцлер",
    ["Vizier"] = "Візир", ["Oracle"] = "Оракул",
    ["Seer"] = "Пророк", ["Sage"] = "Мудрець",
    ["Mystic"] = "Містик", ["Sorcerer"] = "Чаклун",
    ["Enchantress"] = "Чаклунка", ["Witch"] = "Відьма",
    ["Warlock"] = "Чорнокнижник", ["Necromancer"] = "Некромант",
    ["Spellblade"] = "Клинкомаг", ["Blademaster"] = "Майстер клинка",
    ["Shadowblade"] = "Тіньовий клинок", ["Deathstalker"] = "Сталкер смерті",
    ["Highlord"] = "Верховний лорд", ["Darkranger"] = "Темний рейнджер",
    ["Scalecommander"] = "Масштаб-командир",
}

local function transliterateName(name)
    if type(name) ~= "string" or name == "" then return name end
    if name:find("[\208-\211]") then return name end
    local uk = name:gsub("'", "''")
    uk = uk
        :gsub("tion$", "ціон")
        :gsub("sion$", "зіон")
        :gsub("ght$", "гт")
        :gsub("ph$", "ф")
        :gsub("ck$", "к")
        :gsub("Th", "Тх")
        :gsub("Ch", "Ч")
        :gsub("Sh", "Ш")
        :gsub("Zh", "Ж")
        :gsub("Kh", "Х")
        :gsub("Ts", "Ц")
        :gsub("Dz", "Дз")
        :gsub("Ya", "Я")
        :gsub("Yu", "Ю")
        :gsub("Ye", "Є")
        :gsub("Yi", "Ї")
        :gsub("th", "тх")
        :gsub("ch", "ч")
        :gsub("sh", "ш")
        :gsub("zh", "ж")
        :gsub("kh", "х")
        :gsub("ts", "ц")
        :gsub("dz", "дз")
        :gsub("ya", "я")
        :gsub("yu", "ю")
        :gsub("ye", "є")
        :gsub("yi", "ї")
    uk = uk
        :gsub("A", "А"):gsub("B", "Б"):gsub("C", "К"):gsub("D", "Д")
        :gsub("E", "Е"):gsub("F", "Ф"):gsub("G", "Г"):gsub("H", "Г")
        :gsub("I", "І"):gsub("J", "Й"):gsub("K", "К"):gsub("L", "Л")
        :gsub("M", "М"):gsub("N", "Н"):gsub("O", "О"):gsub("P", "П")
        :gsub("Q", "Кв"):gsub("R", "Р"):gsub("S", "С"):gsub("T", "Т")
        :gsub("U", "У"):gsub("V", "В"):gsub("W", "В"):gsub("X", "Кс")
        :gsub("Y", "И"):gsub("Z", "З")
        :gsub("a", "а"):gsub("b", "б"):gsub("c", "к"):gsub("d", "д")
        :gsub("e", "е"):gsub("f", "ф"):gsub("g", "г"):gsub("h", "г")
        :gsub("i", "і"):gsub("j", "й"):gsub("k", "к"):gsub("l", "л")
        :gsub("m", "м"):gsub("n", "н"):gsub("o", "о"):gsub("p", "п")
        :gsub("q", "кв"):gsub("r", "р"):gsub("s", "с"):gsub("t", "т")
        :gsub("u", "у"):gsub("v", "в"):gsub("w", "в"):gsub("x", "кс")
        :gsub("y", "и"):gsub("z", "з")
    return uk
end

local SPELL_WORDS = {
    ["of"] = true, ["the"] = true, ["and"] = true, ["from"] = true,
    ["to"] = true, ["in"] = true, ["with"] = true, ["for"] = true,
    ["on"] = true, ["at"] = true, ["by"] = true, ["into"] = true,
    ["upon"] = true, ["over"] = true, ["under"] = true, ["out"] = true,
    ["off"] = true, ["against"] = true, ["through"] = true, ["between"] = true,
    ["Bolt"] = true, ["Strike"] = true, ["Blast"] = true, ["Barrage"] = true,
    ["Rain"] = true, ["Storm"] = true, ["Wave"] = true, ["Burst"] = true,
    ["Shot"] = true, ["Arrow"] = true, ["Slash"] = true, ["Smash"] = true,
    ["Crush"] = true, ["Kick"] = true, ["Punch"] = true, ["Bite"] = true,
    ["Claw"] = true, ["Swipe"] = true, ["Rend"] = true, ["Touch"] = true,
    ["Mark"] = true, ["Seal"] = true, ["Aura"] = true, ["Shield"] = true,
    ["Barrier"] = true, ["Ward"] = true, ["Veil"] = true, ["Blessing"] = true,
    ["Curse"] = true, ["Hex"] = true, ["Hexes"] = true, ["Chant"] = true,
    ["Hymn"] = true, ["Song"] = true, ["Call"] = true, ["Cry"] = true,
    ["Shout"] = true, ["Roar"] = true, ["Howl"] = true, ["Wail"] = true,
    ["Beam"] = true, ["Ray"] = true, ["Nova"] = true, ["Explosion"] = true,
    ["Detonation"] = true, ["Eruption"] = true, ["Implosion"] = true,
    ["Aspect"] = true, ["Form"] = true, ["Stance"] = true, ["Presence"] = true,
    ["Glyph"] = true, ["Tome"] = true, ["Grimoire"] = true, ["Rune"] = true,
    ["Sigil"] = true, ["Ward"] = true, ["Circle"] = true, ["Ring"] = true,
    ["Binding"] = true, ["Summoning"] = true, ["Conjure"] = true,
    ["Enchant"] = true, ["Dispel"] = true, ["Purge"] = true, ["Cleanse"] = true,
    ["Heal"] = true, ["Mending"] = true, ["Restoration"] = true, ["Revive"] = true,
    ["Resurrect"] = true, ["Rebirth"] = true, ["Redemption"] = true,
    ["Fireball"] = true, ["Fireblast"] = true, ["Pyroblast"] = true,
    ["Shadowbolt"] = true, ["Frostbolt"] = true, ["Ice"] = true,
    ["Flame"] = true, ["Flames"] = true, ["Frost"] = true, ["Frostfire"] = true,
    ["Arcane"] = true, ["Shadow"] = true, ["Holy"] = true, ["Nature"] = true,
    ["Fury"] = true, ["Wrath"] = true, ["Smite"] = true, ["Judgement"] = true,
    ["Judgment"] = true, ["Exorcism"] = true, ["Avenger"] = true,
    ["Crusader"] = true, ["Consecration"] = true, ["Shock"] = true,
    ["Chain"] = true, ["Earth"] = true, ["Lightning"] = true, ["Thunder"] = true,
    ["Lava"] = true, ["Magma"] = true, ["Fire"] = true, ["Water"] = true,
    ["Air"] = true, ["Wind"] = true, ["Stone"] = true, ["Crystal"] = true,
    ["Essence"] = true, ["Extract"] = true, ["Drain"] = true, ["Siphon"] = true,
    ["Leech"] = true, ["Steal"] = true, ["Swap"] = true, ["Shift"] = true,
    ["Charge"] = true, ["Rush"] = true, ["Leap"] = true, ["Dash"] = true,
    ["Sprint"] = true, ["Blink"] = true, ["Teleport"] = true, ["Portal"] = true,
    ["Gate"] = true, ["Passage"] = true, ["Path"] = true, ["Step"] = true,
    ["Walk"] = true, ["Run"] = true, ["Fly"] = true, ["Ride"] = true,
    ["Sneak"] = true, ["Ambush"] = true, ["Backstab"] = true,
    ["Eviscerate"] = true, ["Envenom"] = true, ["Mutilate"] = true,
}

local function looksLikeProperName(text)
    if type(text) ~= "string" or text == "" then return false end
    if not text:find("^[A-Z]") then return false end
    if text:find("[\208-\211]") then return false end
    local wordCount = 0
    for _ in text:gmatch("%S+") do wordCount = wordCount + 1 end
    if wordCount == 1 then
        if #text <= 2 then return false end
        if #text > 12 then return false end
        if text:find("%l%l%l%l") then return false end
        return true
    end
    if wordCount == 2 then
        local first, second = text:match("^(%S+)%s+(%S+)$")
        if first and second and second:find("^[A-Z]") then return true end
        if first and EN_TITLES[first] then return true end
        return false
    end
    if wordCount >= 3 then
        local first = text:match("^(%S+)")
        if EN_TITLES[first] then return true end
        return false
    end
    return false
end

local isSpellLikePhrase

local function tr(part)
    if not part or part == "" then return part end
    local bare = stripArticle(part)
    local clean = bare:gsub("%.%.%.$", ""):gsub("%s+$", "")
    local hit = ns.GetTranslation and ns.GetTranslation(clean)
    if hit then return hit end
    hit = ns.GetTranslation and ns.GetTranslation(bare)
    if hit then return hit end
    if bare ~= part then
        hit = ns.GetTranslation and ns.GetTranslation(part)
        if hit then return hit end
    end
    local firstSpace = part:find(" ")
    if firstSpace then
        local firstWord = part:sub(1, firstSpace - 1)
        local ukTitle = EN_TITLES[firstWord]
        if ukTitle then
            local rest = part:sub(firstSpace + 1)
            local secondSpace = rest:find(" ")
            if secondSpace then
                local secondWord = rest:sub(1, secondSpace - 1)
                local ukTitle2 = EN_TITLES[secondWord]
                if ukTitle2 then
                    local rest2 = rest:sub(secondSpace + 1)
                    return ukTitle .. " " .. ukTitle2 .. " " .. transliterateName(rest2)
                end
            end
            return ukTitle .. " " .. transliterateName(rest)
        end
    end
    if looksLikeProperName(part) and not isSpellLikePhrase(part) then
        return transliterateName(part)
    end
    return part
end

local function isSpellLikePhrase(text)
    if type(text) ~= "string" then return false end
    for word in text:gmatch("%S+") do
        if SPELL_WORDS[word] then return true end
    end
    if text:find(" of ") or text:find(" the ") then return true end
    return false
end

local function trCase(part, case)
    if not part or part == "" then return part end
    local translated = tr(part)
    if ns.Inflect then
        local inflected = ns.Inflect(translated, case)
        if inflected and inflected ~= translated then return inflected end
        return inflected or translated
    end
    return translated
end

local function trPluralGen(englishPlural)
    if not englishPlural then return nil end
    local uk = EN_PLURALS[englishPlural]
    if uk then
        return UK_PLURALS_GEN[uk] or uk
    end
    return nil
end

local objectiveRules = {
    { "^Talk to (.+) in the (.+)$", "Поговоріть з", "ins", "у", "loc" },
    { "^Talk to (.+) at the (.+)$", "Поговоріть з", "ins", "біля", "loc" },
    { "^Talk to (.+) on the (.+)$", "Поговоріть з", "ins", "на", "loc" },
    { "^Talk to (.+) near the (.+)$", "Поговоріть з", "ins", "біля", "gen" },
    { "^Talk to (.+) in (.+)$", "Поговоріть з", "ins", "у", "loc" },
    { "^Talk to (.+) at (.+)$", "Поговоріть з", "ins", "біля", "loc" },
    { "^Talk to (.+)$", "Поговоріть з", "ins" },
    { "^Talk with (.+) in (.+)$", "Поговоріть з", "ins", "у", "loc" },
    { "^Talk with (.+)$", "Поговоріть з", "ins" },
    { "^Speak to (.+) in the (.+)$", "Поговоріть з", "ins", "у", "loc" },
    { "^Speak to (.+) at the (.+)$", "Поговоріть з", "ins", "біля", "loc" },
    { "^Speak to (.+) on the (.+)$", "Поговоріть з", "ins", "на", "loc" },
    { "^Speak to (.+) near the (.+)$", "Поговоріть з", "ins", "біля", "gen" },
    { "^Speak to (.+) in (.+)$", "Поговоріть з", "ins", "у", "loc" },
    { "^Speak to (.+) at (.+)$", "Поговоріть з", "ins", "біля", "loc" },
    { "^Speak to (.+)$", "Поговоріть з", "ins" },
    { "^Speak with (.+) in the (.+)$", "Поговоріть з", "ins", "у", "loc" },
    { "^Speak with (.+) at the (.+)$", "Поговоріть з", "ins", "біля", "loc" },
    { "^Speak with (.+) in (.+)$", "Поговоріть з", "ins", "у", "loc" },
    { "^Speak with (.+)$", "Поговоріть з", "ins" },
    { "^Meet (.+) at the (.+)$", "Зустріньте", "acc", "біля", "loc" },
    { "^Meet (.+) in the (.+)$", "Зустріньте", "acc", "у", "loc" },
    { "^Meet (.+) in (.+)$", "Зустріньте", "acc", "у", "loc" },
    { "^Meet (.+) at (.+)$", "Зустріньте", "acc", "біля", "loc" },
    { "^Meet (.+)$", "Зустріньте", "acc" },
    { "^Meet up with (.+) in (.+)$", "Зустріньтеся з", "ins", "у", "loc" },
    { "^Meet up with (.+)$", "Зустріньтеся з", "ins" },
    { "^Find (.+) in the (.+)$", "Знайдіть", "acc", "у", "loc" },
    { "^Find (.+) at the (.+)$", "Знайдіть", "acc", "біля", "loc" },
    { "^Find (.+) on the (.+)$", "Знайдіть", "acc", "на", "loc" },
    { "^Find (.+) in (.+)$", "Знайдіть", "acc", "у", "loc" },
    { "^Find (.+) at (.+)$", "Знайдіть", "acc", "біля", "loc" },
    { "^Find (.+)$", "Знайдіть", "acc" },
    { "^Find and return (.+) to (.+)$", "Знайдіть та поверніть", "acc", "до", "gen" },
    { "^Find and befriend (.+)$", "Знайдіть та подружіть з", "ins" },
    { "^Deliver (.+) to (.+) in the (.+)$", "Доставте", "acc", "до", "gen", "у", "loc" },
    { "^Deliver (.+) to (.+) in (.+)$", "Доставте", "acc", "до", "gen", "у", "loc" },
    { "^Deliver (.+) to (.+) at the (.+)$", "Доставте", "acc", "до", "gen", "біля", "loc" },
    { "^Deliver (.+) to (.+)$", "Доставте", "acc", "до", "gen" },
    { "^Deliver (.+)$", "Доставте", "acc" },
    { "^Bring (.+) to (.+) in (.+)$", "Принесіть", "acc", "до", "gen", "у", "loc" },
    { "^Bring (.+) to (.+)$", "Принесіть", "acc", "до", "gen" },
    { "^Bring (.+)$", "Принесіть", "acc" },
    { "^Return to (.+) in the (.+)$", "Поверніться до", "gen", "у", "acc" },
    { "^Return to (.+) in (.+)$", "Поверніться до", "gen", "у", "acc" },
    { "^Return to (.+)$", "Поверніться до", "gen" },
    { "^Return (.+) to (.+)$", "Поверніть", "acc", "до", "gen" },
    { "^Report to (.+) in the (.+)$", "Доповідьте", "dat", "у", "loc" },
    { "^Report to (.+) at the (.+)$", "Доповідьте", "dat", "біля", "loc" },
    { "^Report to (.+) in (.+)$", "Доповідьте", "dat", "у", "loc" },
    { "^Report to (.+)$", "Доповідьте", "dat" },
    { "^Collect (.+) from (.+) in (.+)$", "Зберіть", "acc", "від", "gen", "у", "loc" },
    { "^Collect (.+) from (.+) at (.+)$", "Зберіть", "acc", "від", "gen", "біля", "loc" },
    { "^Collect (.+) from the (.+)$", "Зберіть", "acc", "від", "gen" },
    { "^Collect (.+) from (.+)$", "Зберіть", "acc", "від", "gen" },
    { "^Collect (.+) in the (.+)$", "Зберіть", "acc", "у", "loc" },
    { "^Collect (.+) in (.+)$", "Зберіть", "acc", "у", "loc" },
    { "^Collect (.+)$", "Зберіть", "acc" },
    { "^Gather (.+) from (.+) in (.+)$", "Зберіть", "acc", "від", "gen", "у", "loc" },
    { "^Gather (.+) from the (.+)$", "Зберіть", "acc", "із", "gen" },
    { "^Gather (.+) from (.+)$", "Зберіть", "acc", "від", "gen" },
    { "^Gather (.+) in (.+)$", "Зберіть", "acc", "у", "loc" },
    { "^Gather (.+)$", "Зберіть", "acc" },
    { "^Obtain (.+) from (.+)$", "Здобудьте", "acc", "від", "gen" },
    { "^Obtain (.+) in (.+)$", "Здобудьте", "acc", "у", "loc" },
    { "^Obtain (.+)$", "Здобудьте", "acc" },
    { "^Kill (.+) in the (.+)$", "Вбийте", "acc", "у", "loc" },
    { "^Kill (.+) at the (.+)$", "Вбийте", "acc", "біля", "loc" },
    { "^Kill (.+) in (.+)$", "Вбийте", "acc", "у", "loc" },
    { "^Kill (.+) or (.+) at (.+)$", "Вбийте", "acc", "або", "acc", "біля", "loc" },
    { "^Kill (.+) or (.+)$", "Вбийте", "acc", "або", "acc" },
    { "^Kill (.+)$", "Вбийте", "acc" },
    { "^Slay (.+) in the (.+)$", "Вбийте", "acc", "у", "loc" },
    { "^Slay (.+) in (.+)$", "Вбийте", "acc", "у", "loc" },
    { "^Slay (.+) to (.+)$", "Вбийте", "acc", "щоб", "acc" },
    { "^Slay (.+)$", "Вбийте", "acc" },
    { "^Defeat (.+) in (.+)$", "Переможіть", "acc", "у", "loc" },
    { "^Defeat (.+) in the (.+)$", "Переможіть", "acc", "у", "loc" },
    { "^Defeat (.+) in a Pet Battle$", "Переможіть", "acc", "у битві петів" },
    { "^Defeat (.+)$", "Переможіть", "acc" },
    { "^Destroy (.+) in the (.+)$", "Знищте", "acc", "у", "loc" },
    { "^Destroy (.+) in (.+)$", "Знищте", "acc", "у", "loc" },
    { "^Destroy (.+) at the (.+)$", "Знищте", "acc", "біля", "loc" },
    { "^Destroy (.+) or (.+) at (.+)$", "Знищте", "acc", "або", "acc", "біля", "loc" },
    { "^Destroy (.+)$", "Знищте", "acc" },
    { "^Escort (.+) to (.+) in (.+)$", "Супроводжуйте", "acc", "до", "gen", "у", "loc" },
    { "^Escort (.+) to (.+)$", "Супроводжуйте", "acc", "до", "gen" },
    { "^Escort (.+) through (.+)$", "Супроводжуйте", "acc", "крізь", "acc" },
    { "^Escort (.+)$", "Супроводжуйте", "acc" },
    { "^Rescue (.+) from (.+)$", "Врятуйте", "acc", "від", "gen" },
    { "^Rescue (.+) from the (.+)$", "Врятуйте", "acc", "із", "gen" },
    { "^Rescue (.+) in (.+)$", "Врятуйте", "acc", "у", "loc" },
    { "^Rescue (.+)$", "Врятуйте", "acc" },
    { "^Free (.+) from (.+)$", "Звільніть", "acc", "від", "gen" },
    { "^Free (.+) from the (.+)$", "Звільніть", "acc", "із", "gen" },
    { "^Free (.+) in (.+)$", "Звільніть", "acc", "у", "loc" },
    { "^Free (.+)$", "Звільніть", "acc" },
    { "^Search (.+) for (.+)$", "Шукайте", "acc", "у", "loc", true },
    { "^Search the (.+) for (.+)$", "Шукайте", "acc", "у", "loc", true },
    { "^Search for (.+) in (.+)$", "Шукайте", "acc", "у", "loc" },
    { "^Search for (.+)$", "Шукайте", "acc" },
    { "^Search (.+)$", "Обшукайте", "acc" },
    { "^Investigate the (.+)$", "Дослідіть", "acc" },
    { "^Investigate (.+)$", "Дослідіть", "acc" },
    { "^Explore the (.+)$", "Дослідіть", "acc" },
    { "^Explore (.+)$", "Дослідіть", "acc" },
    { "^Use (.+) to (.+)$", "Використайте", "acc", "щоб" },
    { "^Use (.+) on (.+)$", "Використайте", "acc", "на", "loc" },
    { "^Use the (.+)$", "Використайте", "acc" },
    { "^Use (.+)$", "Використайте", "acc" },
    { "^Ask (.+) about (.+)$", "Запитайте", "acc", "про", "acc" },
    { "^Ask (.+) to (.+)$", "Попрохайте", "acc", "щоб" },
    { "^Ask (.+) for (.+)$", "Попросіть у", "gen", "", "acc" },
    { "^Ask (.+)$", "Запитайте", "acc" },
    { "^Question (.+) about (.+)$", "Розпитайте", "acc", "про", "acc" },
    { "^Help (.+) in (.+)$", "Допоможіть", "dat", "у", "loc" },
    { "^Help (.+) with (.+)$", "Допоможіть", "dat", "з", "ins" },
    { "^Help (.+)$", "Допоможіть", "dat" },
    { "^Aid (.+) in (.+)$", "Допоможіть", "dat", "у", "loc" },
    { "^Aid (.+)$", "Допоможіть", "dat" },
    { "^Assist (.+) in (.+)$", "Допоможіть", "dat", "у", "loc" },
    { "^Assist (.+) with (.+)$", "Допоможіть", "dat", "з", "ins" },
    { "^Assist (.+)$", "Допоможіть", "dat" },
    { "^Consult (.+)$", "Зверніться до", "gen" },
    { "^Consult (.+) in (.+)$", "Зверніться до", "gen", "у", "loc" },
    { "^Ride (.+) to (.+)$", "Проїдьте на", "loc", "до", "gen" },
    { "^Ride the (.+)$", "Осідлайте", "acc" },
    { "^Ride (.+)$", "Осідлайте", "acc" },
    { "^Ride any mount to reach (.+)$", "Осідлайте будь-якого скакуна, щоб дістатися до", "gen" },
    { "^Swim to (.+)$", "Допливіть до", "gen" },
    { "^Fly to (.+)$", "Летіть до", "gen" },
    { "^Fly the (.+) to (.+)$", "Відлетіть на", "loc", "до", "gen" },
    { "^Travel to (.+)$", "Відправтеся до", "gen" },
    { "^Travel with (.+)$", "Подорожуйте з", "ins" },
    { "^Go to (.+)$", "Відправтеся до", "gen" },
    { "^Go behind (.+)$", "Пройдіть за", "acc" },
    { "^Head to (.+)$", "Спрямуйте до", "gen" },
    { "^Take the flight path to (.+)$", "Скористайтеся шляхом польоту до", "gen" },
    { "^Enter the (.+)$", "Увійдіть до", "gen" },
    { "^Enter (.+)$", "Увійдіть до", "gen" },
    { "^Escape the (.+)$", "Втечіть з", "gen" },
    { "^Escape (.+)$", "Втечіть з", "gen" },
    { "^Defend (.+) from (.+)$", "Захистіть", "acc", "від", "gen" },
    { "^Defend the (.+)$", "Захистіть", "acc" },
    { "^Defend (.+) in (.+)$", "Захистіть", "acc", "у", "loc" },
    { "^Defend (.+)$", "Захистіть", "acc" },
    { "^Protect (.+) from (.+)$", "Захистіть", "acc", "від", "gen" },
    { "^Protect (.+)$", "Захистіть", "acc" },
    { "^Repel (.+) from (.+)$", "Відкиньте", "acc", "від", "gen" },
    { "^Repel the (.+)$", "Відкиньте", "acc" },
    { "^Repel (.+) in (.+)$", "Відкиньте", "acc", "у", "loc" },
    { "^Repel (.+)$", "Відкиньте", "acc" },
    { "^Drive back (.+) in (.+)$", "Відкиньте", "acc", "у", "loc" },
    { "^Drive back the (.+)$", "Відкиньте", "acc" },
    { "^Drive back (.+)$", "Відкиньте", "acc" },
    { "^Push back (.+)$", "Відкиньте", "acc" },
    { "^Push back the (.+)$", "Відкиньте", "acc" },
    { "^Subdue (.+) or (.+)$", "Заспокойте", "acc", "або", "acc" },
    { "^Subdue (.+)$", "Заспокойте", "acc" },
    { "^Disrupt (.+) in (.+)$", "Зірвіть", "acc", "у", "loc" },
    { "^Disrupt the (.+)$", "Зірвіть", "acc" },
    { "^Disrupt (.+)$", "Зірвіть", "acc" },
    { "^Purge the (.+)$", "Очистіть", "acc" },
    { "^Purge (.+) from (.+)$", "Очистіть", "acc", "від", "gen" },
    { "^Purge (.+)$", "Очистіть", "acc" },
    { "^Cleanse the (.+)$", "Очистіть", "acc" },
    { "^Cleanse (.+) of (.+)$", "Очистіть", "acc", "від", "gen" },
    { "^Cleanse (.+)$", "Очистіть", "acc" },
    { "^Purify the (.+)$", "Очистіть", "acc" },
    { "^Purify (.+)$", "Очистіть", "acc" },
    { "^Release (.+) from (.+)$", "Випустіть", "acc", "із", "gen" },
    { "^Release the (.+)$", "Випустіть", "acc" },
    { "^Release (.+)$", "Випустіть", "acc" },
    { "^Guide (.+) to (.+)$", "Супроводьте", "acc", "до", "gen" },
    { "^Guide (.+)$", "Супроводьте", "acc" },
    { "^Craft (.+)$", "Складіть", "acc" },
    { "^Craft a (.+)$", "Складіть", "acc" },
    { "^Craft an (.+)$", "Складіть", "acc" },
    { "^Burn (.+) in (.+)$", "Спаліть", "acc", "у", "loc" },
    { "^Burn the (.+)$", "Спаліть", "acc" },
    { "^Burn (.+)$", "Спаліть", "acc" },
    { "^Skin the (.+)$", "Здіріть шкіру з", "gen" },
    { "^Skin (.+)$", "Здіріть шкіру з", "gen" },
    { "^Poison (.+) in (.+)$", "Отруйте", "acc", "у", "loc" },
    { "^Poison the (.+)$", "Отруйте", "acc" },
    { "^Poison (.+)$", "Отруйте", "acc" },
    { "^Cull (.+) in (.+)$", "Винищте", "acc", "у", "loc" },
    { "^Cull (.+) and (.+)$", "Винищте", "acc", "та", "acc" },
    { "^Cull (.+)$", "Винищте", "acc" },
    { "^Disarm (.+)$", "Збройте", "acc" },
    { "^Disarm the (.+)$", "Збройте", "acc" },
    { "^Disable (.+)$", "Вимкніть", "acc" },
    { "^Disable the (.+)$", "Вимкніть", "acc" },
    { "^Heal (.+)$", "Зціліть", "acc" },
    { "^Heal the (.+)$", "Зціліть", "acc" },
    { "^Mend (.+)$", "Полагодьте", "acc" },
    { "^Repair (.+)$", "Відремонтуйте", "acc" },
    { "^Repair the (.+)$", "Відремонтуйте", "acc" },
    { "^Feed (.+) to (.+)$", "Годайте", "acc", "", "dat" },
    { "^Feed (.+)$", "Годайте", "acc" },
    { "^Give (.+) to (.+)$", "Віддайте", "acc", "", "dat" },
    { "^Give (.+)$", "Віддайте", "acc" },
    { "^Open the (.+)$", "Відкрийте", "acc" },
    { "^Open (.+)$", "Відкрийте", "acc" },
    { "^Close the (.+)$", "Закрийте", "acc" },
    { "^Close (.+)$", "Закрийте", "acc" },
    { "^Unlock (.+)$", "Відкрийте", "acc" },
    { "^Unlock the (.+)$", "Відкрийте", "acc" },
    { "^Lock (.+)$", "Замкніть", "acc" },
    { "^Activate (.+)$", "Активуйте", "acc" },
    { "^Activate the (.+)$", "Активуйте", "acc" },
    { "^Deactivate (.+)$", "Деактивуйте", "acc" },
    { "^Deactivate the (.+)$", "Деактивуйте", "acc" },
    { "^Place (.+) on (.+)$", "Розмістіть", "acc", "на", "loc" },
    { "^Place (.+) at (.+)$", "Розмістіть", "acc", "біля", "loc" },
    { "^Place the (.+)$", "Розмістіть", "acc" },
    { "^Place (.+)$", "Розмістіть", "acc" },
    { "^Plant (.+) in (.+)$", "Посадіть", "acc", "у", "loc" },
    { "^Plant (.+) at (.+)$", "Посадіть", "acc", "біля", "loc" },
    { "^Plant (.+)$", "Посадіть", "acc" },
    { "^Pick (.+) from (.+)$", "Зберіть", "acc", "від", "gen" },
    { "^Pick up (.+) from (.+)$", "Підніміть", "acc", "від", "gen" },
    { "^Pick up (.+)$", "Підніміть", "acc" },
    { "^Pick (.+)$", "Виберіть", "acc" },
    { "^Catch (.+) in (.+)$", "Спіймайте", "acc", "у", "loc" },
    { "^Catch (.+)$", "Спіймайте", "acc" },
    { "^Break (.+)$", "Розбийте", "acc" },
    { "^Break the (.+)$", "Розбийте", "acc" },
    { "^Cut (.+)$", "Відріжте", "acc" },
    { "^Cut a (.+)$", "Огрануйте", "acc" },
    { "^Save (.+) from (.+)$", "Врятуйте", "acc", "від", "gen" },
    { "^Save the (.+)$", "Врятуйте", "acc" },
    { "^Save (.+)$", "Врятуйте", "acc" },
    { "^Stop (.+) from (.+)$", "Зупиніть", "acc", "від", "gen" },
    { "^Stop the (.+)$", "Зупиніть", "acc" },
    { "^Stop (.+)$", "Зупиніть", "acc" },
    { "^Complete the (.+)$", "Завершіть", "acc" },
    { "^Complete (.+)$", "Завершіть", "acc" },
    { "^Clear (.+) of (.+)$", "Очистіть", "acc", "від", "gen" },
    { "^Clear the (.+)$", "Очистіть", "acc" },
    { "^Clear (.+)$", "Очистіть", "acc" },
    { "^Charge at (.+)$", "Риньте на", "acc" },
    { "^Charge (.+)$", "Риньте на", "acc" },
    { "^Take (.+) from (.+)$", "Візьміть", "acc", "від", "gen" },
    { "^Take (.+) to (.+)$", "Візьміть", "acc", "до", "gen" },
    { "^Take control of (.+)$", "Перехопіть контроль над", "ins" },
    { "^Take (.+)$", "Візьміть", "acc" },
    { "^Steal (.+) from (.+)$", "Вкрадіть", "acc", "від", "gen" },
    { "^Steal (.+)$", "Вкрадіть", "acc" },
    { "^Lift (.+)$", "Підніміть", "acc" },
    { "^Drop (.+) at (.+)$", "Скиньте", "acc", "біля", "loc" },
    { "^Drop (.+)$", "Скиньте", "acc" },
    { "^Pour (.+) on (.+)$", "Вилийте", "acc", "на", "acc" },
    { "^Pour (.+) into (.+)$", "Вилийте", "acc", "до", "gen" },
    { "^Pour (.+)$", "Вилийте", "acc" },
    { "^Fill (.+) at (.+)$", "Наповніть", "acc", "біля", "loc" },
    { "^Fill (.+) with (.+)$", "Наповніть", "acc", "", "ins" },
    { "^Fill (.+)$", "Наповніть", "acc" },
    { "^Empty (.+)$", "Спорожніть", "acc" },
    { "^Mix (.+) with (.+)$", "Змішайте", "acc", "з", "ins" },
    { "^Mix (.+)$", "Змішайте", "acc" },
    { "^Combine (.+) with (.+)$", "Об'єднайте", "acc", "з", "ins" },
    { "^Combine (.+)$", "Об'єднайте", "acc" },
    { "^Attach (.+) to (.+)$", "Прикріпіть", "acc", "до", "gen" },
    { "^Attach (.+)$", "Прикріпіть", "acc" },
    { "^Detach (.+) from (.+)$", "Відкріпіть", "acc", "від", "gen" },
    { "^Connect (.+) to (.+)$", "З'єднайте", "acc", "з", "ins" },
    { "^Paint (.+)$", "Фарбуйте", "acc" },
    { "^Draw (.+)$", "Намалюйте", "acc" },
    { "^Read (.+)$", "Прочитайте", "acc" },
    { "^Write (.+) in (.+)$", "Напишіть", "acc", "у", "loc" },
    { "^Write (.+)$", "Напишіть", "acc" },
    { "^Sing (.+)$", "Заспівайте", "acc" },
    { "^Dance (.+)$", "Станцюйте", "acc" },
    { "^Play (.+)$", "Зіграйте", "acc" },
    { "^Send (.+) to (.+)$", "Відправте", "acc", "до", "gen" },
    { "^Send (.+)$", "Відправте", "acc" },
    { "^Receive (.+) from (.+)$", "Отримайте", "acc", "від", "gen" },
    { "^Receive (.+)$", "Отримайте", "acc" },
    { "^Accept (.+) from (.+)$", "Прийміть", "acc", "від", "gen" },
    { "^Accept (.+)$", "Прийміть", "acc" },
    { "^Choose (.+)$", "Оберіть", "acc" },
    { "^Vote for (.+)$", "Проголосуйте за", "acc" },
    { "^Nominate (.+)$", "Номінуйте", "acc" },
    { "^Elect (.+)$", "Оберіть", "acc" },
    { "^Challenge (.+)$", "Викличте", "acc" },
    { "^Challenge (.+) to (.+)$", "Викличте", "acc", "на", "acc" },
    { "^Watch (.+)$", "Слідкуйте за", "ins" },
    { "^Learn (.+) from (.+)$", "Навчіться", "gen", "від", "gen" },
    { "^Learn (.+)$", "Навчіться", "gen" },
    { "^Teach (.+) to (.+)$", "Навчіть", "acc", "", "dat" },
    { "^Teach (.+)$", "Навчіть", "acc" },
    { "^Summon (.+)$", "Призвіть", "acc" },
    { "^Summon (.+) near (.+)$", "Призвіть", "acc", "біля", "loc" },
    { "^Dismiss (.+)$", "Звільніть", "acc" },
    { "^Banish (.+) to (.+)$", "Вигнайте", "acc", "до", "gen" },
    { "^Banish (.+)$", "Вигнайте", "acc" },
    { "^Exile (.+)$", "Вигнайте", "acc" },
    { "^Corrupt (.+)$", "Спотворіть", "acc" },
    { "^Bless (.+)$", "Благословіть", "acc" },
    { "^Curse (.+)$", "Прокленіть", "acc" },
    { "^Enchant (.+)$", "Зачаруйте", "acc" },
    { "^Disenchant (.+)$", "Розчаруйте", "acc" },
    { "^Transmute (.+) into (.+)$", "Трансмутуйте", "acc", "на", "acc" },
    { "^Transmute (.+)$", "Трансмутуйте", "acc" },
    { "^Transform (.+) into (.+)$", "Трансформуйте", "acc", "на", "acc" },
    { "^Transform into (.+)$", "Трансформуйтеся у", "acc" },
    { "^Shapeshift into (.+)$", "Оберніться на", "acc" },
    { "^Absorb (.+) from (.+)$", "Абсорбуйте", "acc", "від", "gen" },
    { "^Absorb (.+)$", "Абсорбуйте", "acc" },
    { "^Consume (.+)$", "Спожийте", "acc" },
    { "^Harvest (.+) from (.+)$", "Зберіть", "acc", "від", "gen" },
    { "^Harvest (.+)$", "Зберіть", "acc" },
    { "^Mine (.+) in (.+)$", "Видобудьте", "acc", "у", "loc" },
    { "^Mine (.+)$", "Видобудьте", "acc" },
    { "^Fish (.+) in (.+)$", "Виловіть", "acc", "у", "loc" },
    { "^Fish (.+)$", "Виловіть", "acc" },
    { "^Cook (.+)$", "Приготуйте", "acc" },
    { "^Brew (.+)$", "Зваріть", "acc" },
    { "^Buy (.+) from (.+)$", "Купіть", "acc", "від", "gen" },
    { "^Buy (.+)$", "Купіть", "acc" },
    { "^Sell (.+) to (.+)$", "Продайте", "acc", "", "dat" },
    { "^Sell (.+)$", "Продайте", "acc" },
    { "^Trade (.+) with (.+)$", "Обміняйте", "acc", "з", "ins" },
    { "^Exchange (.+) for (.+)$", "Обміняйте", "acc", "на", "acc" },
    { "^Capture (.+)$", "Спіймайте", "acc" },
    { "^Capture (.+) in (.+)$", "Спіймайте", "acc", "у", "loc" },
    { "^Tame (.+)$", "Приручіть", "acc" },
    { "^Befriend (.+)$", "Подружіть з", "ins" },
    { "^Interact with (.+)$", "Взаємодієте з", "ins" },
    { "^Interact (.+)$", "Взаємодієте з", "ins" },
    { "^Rally (.+)$", "Згуртуйте", "acc" },
    { "^Rally (.+) in (.+)$", "Згуртуйте", "acc", "у", "loc" },
    { "^Plunder (.+)$", "Розграбуйте", "acc" },
    { "^Plunder (.+) in (.+)$", "Розграбуйте", "acc", "у", "loc" },
    { "^Excavate (.+) from (.+)$", "Видобудьте", "acc", "із", "gen" },
    { "^Excavate (.+) in (.+)$", "Видобудьте", "acc", "у", "loc" },
    { "^Excavate (.+)$", "Видобудьте", "acc" },
    { "^Hide (.+) from (.+)$", "Сховайте", "acc", "від", "gen" },
    { "^Hide (.+)$", "Сховайте", "acc" },
    { "^Hide in (.+)$", "Сховайтеся у", "loc" },
    { "^Welcome (.+)$", "Вітайте", "acc" },
    { "^Arrived at (.+)$", "Прибули до", "gen" },
    { "^Arrived at the (.+)$", "Прибули до", "gen" },
    { "^Participate in (.+)$", "Візьміть участь у", "loc" },
    { "^Excavate (.+)$", "Видобудьте", "acc" },
    { "^Sabotage the (.+)$", "Саботуйте", "acc" },
    { "^Sabotage (.+)$", "Саботуйте", "acc" },
    { "^Assault (.+) in the (.+)$", "Штурмуйте", "acc", "у", "loc" },
    { "^Assault (.+) in (.+)$", "Штурмуйте", "acc", "у", "loc" },
    { "^Assault the (.+)$", "Штурмуйте", "acc" },
    { "^Assault (.+)$", "Штурмуйте", "acc" },
    { "^Assault on (.+)$", "Штурм на", "acc" },
    { "^Hold (.+)$", "Утримайте", "acc" },
    { "^Hold the (.+)$", "Утримайте", "acc" },
    { "^Secure (.+)$", "Забезпечте", "acc" },
    { "^Secure the (.+)$", "Забезпечте", "acc" },
    { "^Recover (.+) from (.+)$", "Відновіть", "acc", "від", "gen" },
    { "^Recover (.+)$", "Відновіть", "acc" },
    { "^Reclaim (.+)$", "Відвойуйте", "acc" },
    { "^Reclaim the (.+)$", "Відвойуйте", "acc" },
    { "^Reclaim (.+) from (.+)$", "Відвойуйте", "acc", "від", "gen" },
    { "^Retrieve (.+) from (.+)$", "Дістаньте", "acc", "від", "gen" },
    { "^Retrieve (.+)$", "Дістаньте", "acc" },
    { "^Construct (.+)$", "Побудуйте", "acc" },
    { "^Build (.+)$", "Побудуйте", "acc" },
    { "^Grow (.+)$", "Виростіть", "acc" },
    { "^Paint (.+) on (.+)$", "Намалюйте", "acc", "на", "loc" },
    { "^Target (.+)$", "Ціліть у", "acc" },
    { "^Mark (.+)$", "Позначте", "acc" },
    { "^Lure (.+) to (.+)$", "Заманьте", "acc", "до", "gen" },
    { "^Lure (.+)$", "Заманьте", "acc" },
    { "^Attract (.+)$", "Приверніть", "acc" },
    { "^Scare (.+)$", "Налякайте", "acc" },
    { "^Chase (.+)$", "Погоняйте", "acc" },
    { "^Follow (.+)$", "Стежте за", "ins" },
    { "^Follow (.+) to (.+)$", "Стежте за", "ins", "до", "gen" },
    { "^Track (.+)$", "Відстежте", "acc" },
    { "^Track (.+) in (.+)$", "Відстежте", "acc", "у", "loc" },
    { "^Observe (.+)$", "Спостерігайте за", "ins" },
    { "^Examine (.+)$", "Огляньте", "acc" },
    { "^Inspect (.+)$", "Огляньте", "acc" },
    { "^Prove (.+)$", "Доведіть", "acc" },
    { "^Test (.+)$", "Перевірте", "acc" },
    { "^Repair (.+)$", "Полагодьте", "acc" },
    { "^Mount (.+)$", "Осідлайте", "acc" },
    { "^Dismount (.+)$", "Злізьте з", "gen" },
    { "^Jump (.+)$", "Стрибніть", "acc" },
    { "^Jump over (.+)$", "Перестрибніть", "acc" },
    { "^Jump into (.+)$", "Стрибніть у", "acc" },
    { "^Climb (.+)$", "Злізьте на", "acc" },
    { "^Climb the (.+)$", "Злізьте на", "acc" },
    { "^Swim through (.+)$", "Пропливіть крізь", "acc" },
    { "^Dive into (.+)$", "Пірніть у", "acc" },
    { "^Sail (.+) to (.+)$", "Відпливіть на", "loc", "до", "gen" },
    { "^Sail to (.+)$", "Відпливіть до", "gen" },
    { "^Walk (.+)$", "Пройдіть", "acc" },
    { "^Walk to (.+)$", "Пройдіть до", "gen" },
    { "^Run (.+)$", "Пробіжіть", "acc" },
    { "^Run to (.+)$", "Пробіжіть до", "gen" },
    { "^Carry (.+) to (.+)$", "Перенесіть", "acc", "до", "gen" },
    { "^Carry (.+)$", "Перенесіть", "acc" },
    { "^Drag (.+) to (.+)$", "Перетягніть", "acc", "до", "gen" },
    { "^Drag (.+)$", "Перетягніть", "acc" },
    { "^Push (.+) to (.+)$", "Штовхніть", "acc", "до", "gen" },
    { "^Push (.+)$", "Штовхніть", "acc" },
    { "^Pull (.+)$", "Потягніть", "acc" },
    { "^Throw (.+) at (.+)$", "Киньте", "acc", "у", "acc" },
    { "^Throw (.+)$", "Киньте", "acc" },
    { "^Catch (.+) for (.+)$", "Спіймайте", "acc", "для", "gen" },
    { "^Collect (.+) for (.+)$", "Зберіть", "acc", "для", "gen" },
    { "^Prepare (.+)$", "Приготуйте", "acc" },
    { "^Perform (.+)$", "Виконайте", "acc" },
    { "^Complete the (.+)$", "Завершіть", "acc" },
    { "^Capture (.+) and (.+)$", "Спіймайте", "acc", "та", "acc" },
    { "^Defeat (.+) and (.+)$", "Переможіть", "acc", "та", "acc" },
    { "^Kill (.+) and (.+)$", "Вбийте", "acc", "та", "acc" },
    { "^Destroy (.+) and (.+)$", "Знищте", "acc", "та", "acc" },
    { "^Rescue (.+) and (.+)$", "Врятуйте", "acc", "та", "acc" },
    { "^Find (.+) and (.+)$", "Знайдіть", "acc", "та", "acc" },
    { "^Convince (.+) to (.+)$", "Переконайте", "acc", "щоб" },
    { "^Convince (.+)$", "Переконайте", "acc" },
    { "^Persuade (.+) to (.+)$", "Переконайте", "acc", "щоб" },
    { "^Persuade (.+)$", "Переконайте", "acc" },
    { "^Warn (.+) about (.+)$", "Попередьте", "acc", "про", "acc" },
    { "^Warn (.+)$", "Попередьте", "acc" },
    { "^Inform (.+) of (.+)$", "Повідомте", "acc", "про", "acc" },
    { "^Inform (.+) about (.+)$", "Повідомте", "acc", "про", "acc" },
    { "^Inform (.+)$", "Повідомте", "acc" },
    { "^Notify (.+) of (.+)$", "Сповістіть", "acc", "про", "acc" },
    { "^Notify (.+)$", "Сповістіть", "acc" },
    { "^Alert (.+) of (.+)$", "Сповістіть", "acc", "про", "acc" },
    { "^Alert (.+)$", "Сповістіть", "acc" },
    { "^Confront (.+) in (.+)$", "Зіткніться з", "ins", "у", "loc" },
    { "^Confront (.+) at (.+)$", "Зіткніться з", "ins", "біля", "loc" },
    { "^Confront (.+)$", "Зіткніться з", "ins" },
    { "^Challenge (.+) in (.+)$", "Викличте", "acc", "у", "loc" },
    { "^Negotiate with (.+) in (.+)$", "Ведіть переговори з", "ins", "у", "loc" },
    { "^Negotiate with (.+)$", "Ведіть переговори з", "ins" },
    { "^Negotiate (.+)$", "Обговоріть", "acc" },
    { "^Bargain with (.+)$", "Поторгуйтеся з", "ins" },
    { "^Trade with (.+) in (.+)$", "Поторгуйте з", "ins", "у", "loc" },
    { "^Trade with (.+)$", "Поторгуйте з", "ins" },
    { "^Barter with (.+)$", "Обміняйте з", "ins" },
    { "^Conspire with (.+)$", "Змовтеся з", "ins" },
    { "^Ally with (.+)$", "Союзжете з", "ins" },
    { "^Befriend (.+) in (.+)$", "Подружіть з", "ins", "у", "loc" },
    { "^Swear fealty to (.+)$", "Присягніть на вірність", "dat" },
    { "^Swear to (.+)$", "Присягніть", "dat" },
    { "^Pledge to (.+)$", "Зобов'яжіться перед", "ins" },
    { "^Serve (.+)$", "Служіть", "dat" },
    { "^Obey (.+)$", "Підкоряйтеся", "dat" },
    { "^Pray to (.+)$", "Помоліться", "dat" },
    { "^Offer (.+) to (.+)$", "Запропонуйте", "acc", "", "dat" },
    { "^Offer (.+)$", "Запропонуйте", "acc" },
    { "^Present (.+) to (.+)$", "Представте", "acc", "", "dat" },
    { "^Present (.+)$", "Представте", "acc" },
    { "^Surrender (.+) to (.+)$", "Здайте", "acc", "", "dat" },
    { "^Surrender to (.+)$", "Здайтеся", "dat" },
    { "^Surrender (.+)$", "Здайте", "acc" },
    { "^Yield (.+) to (.+)$", "Віддайте", "acc", "", "dat" },
    { "^Betray (.+)$", "Зрадьте", "acc" },
    { "^Betray (.+) to (.+)$", "Зрадьте", "acc", "", "dat" },
    { "^Corrupt (.+) in (.+)$", "Спотворіть", "acc", "у", "loc" },
    { "^Corrupt the (.+)$", "Спотворіть", "acc" },
    { "^Soothe (.+)$", "Заспокойте", "acc" },
    { "^Soothe the (.+)$", "Заспокойте", "acc" },
    { "^Calm (.+)$", "Заспокойте", "acc" },
    { "^Calm the (.+)$", "Заспокойте", "acc" },
    { "^Comfort (.+)$", "Утіште", "acc" },
    { "^Comfort the (.+)$", "Утіште", "acc" },
    { "^Convince (.+) in the (.+)$", "Переконайте", "acc", "у", "loc" },
    { "^Persuade (.+) in the (.+)$", "Переконайте", "acc", "у", "loc" },
    { "^Convince (.+) in (.+)$", "Переконайте", "acc", "у", "loc" },
    { "^Persuade (.+) in (.+)$", "Переконайте", "acc", "у", "loc" },
    { "^Pay (.+)$", "Сплатіть", "acc" },
    { "^Pay (.+) to (.+)$", "Сплатіть", "acc", "", "dat" },
    { "^Buy (.+) from (.+) in (.+)$", "Купіть", "acc", "від", "gen", "у", "loc" },
    { "^Purchase (.+) from (.+)$", "Придбайте", "acc", "від", "gen" },
    { "^Purchase (.+)$", "Придбайте", "acc" },
    { "^Acquire (.+) from (.+)$", "Здобудьте", "acc", "від", "gen" },
    { "^Acquire (.+) in (.+)$", "Здобудьте", "acc", "у", "loc" },
    { "^Acquire (.+)$", "Здобудьте", "acc" },
    { "^Procure (.+) from (.+)$", "Роздобудьте", "acc", "від", "gen" },
    { "^Procure (.+)$", "Роздобудьте", "acc" },
    { "^Seek (.+) in (.+)$", "Шукайте", "acc", "у", "loc" },
    { "^Seek (.+) at (.+)$", "Шукайте", "acc", "біля", "loc" },
    { "^Seek (.+)$", "Шукайте", "acc" },
    { "^Seek out (.+) in (.+)$", "Розшукайте", "acc", "у", "loc" },
    { "^Seek out (.+)$", "Розшукайте", "acc" },
    { "^Locate (.+) in (.+)$", "Відшукайте", "acc", "у", "loc" },
    { "^Locate (.+)$", "Відшукайте", "acc" },
    { "^Uncover (.+) in (.+)$", "Розкрийте", "acc", "у", "loc" },
    { "^Uncover (.+)$", "Розкрийте", "acc" },
    { "^Reveal (.+)$", "Розкрийте", "acc" },
    { "^Discover (.+) in (.+)$", "Відкрийте", "acc", "у", "loc" },
    { "^Discover (.+)$", "Відкрийте", "acc" },
    { "^Listen to (.+)$", "Послухайте", "acc" },
    { "^Listen to (.+) in (.+)$", "Послухайте", "acc", "у", "loc" },
    { "^Wait for (.+) at (.+)$", "Дочекайтеся", "gen", "біля", "loc" },
    { "^Wait for (.+) in (.+)$", "Дочекайтеся", "gen", "у", "loc" },
    { "^Wait for (.+)$", "Дочекайтеся", "gen" },
    { "^Wait at (.+)$", "Дочекайтеся біля", "loc" },
    { "^Wait in (.+)$", "Дочекайтеся у", "loc" },
    { "^Gather at the (.+)$", "Зберіться біля", "loc" },
    { "^Gather at (.+)$", "Зберіться біля", "loc" },
    { "^Gather in the (.+)$", "Зберіться у", "loc" },
    { "^Rendezvous with (.+) at (.+)$", "Зустріньтеся з", "ins", "біля", "loc" },
    { "^Rendezvous with (.+)$", "Зустріньтеся з", "ins" },
    { "^Ambush (.+) in (.+)$", "Улаштуйте засідку на", "acc", "у", "loc" },
    { "^Ambush (.+)$", "Улаштуйте засідку на", "acc" },
    { "^Sneak into (.+)$", "Прослизніть у", "acc" },
    { "^Sneak past (.+)$", "Прослизніть повз", "acc" },
    { "^Sneak through (.+)$", "Прослизніть крізь", "acc" },
    { "^Infiltrate the (.+)$", "Інфільтруйте", "acc" },
    { "^Infiltrate (.+)$", "Інфільтруйте", "acc" },
    { "^Sneak into the (.+)$", "Прослизніть до", "gen" },
    { "^Break into (.+)$", "Проникніть у", "acc" },
    { "^Break into the (.+)$", "Проникніть до", "gen" },
    { "^Penetrate (.+)$", "Проникніть у", "acc" },
    { "^Overwhelm (.+)$", "Подолайте", "acc" },
    { "^Overwhelm the (.+)$", "Подолайте", "acc" },
    { "^Subjugate (.+)$", "Підкоріть", "acc" },
    { "^Subjugate the (.+)$", "Підкоріть", "acc" },
    { "^Dominate (.+)$", "Домінуйте над", "ins" },
    { "^Dominate the (.+)$", "Домінуйте над", "ins" },
    { "^Overpower (.+)$", "Переможіть силою", "acc" },
    { "^Overpower the (.+)$", "Переможіть силою", "acc" },
    { "^Empower (.+)$", "Посиліть", "acc" },
    { "^Empower the (.+)$", "Посиліть", "acc" },
    { "^Strengthen (.+)$", "Посиліть", "acc" },
    { "^Weaken (.+)$", "Ослабте", "acc" },
    { "^Weaken the (.+)$", "Ослабте", "acc" },
    { "^Drain (.+) from (.+)$", "Вичерпайте", "acc", "від", "gen" },
    { "^Drain the (.+)$", "Вичерпайте", "acc" },
    { "^Drain (.+)$", "Вичерпайте", "acc" },
    { "^Siphon (.+) from (.+)$", "Викачайте", "acc", "від", "gen" },
    { "^Siphon (.+)$", "Викачайте", "acc" },
    { "^Extract (.+) from (.+)$", "Витягніть", "acc", "від", "gen" },
    { "^Extract (.+)$", "Витягніть", "acc" },
    { "^Seal (.+)$", "Запечатайте", "acc" },
    { "^Seal the (.+)$", "Запечатайте", "acc" },
    { "^Unseal (.+)$", "Розпечатайте", "acc" },
    { "^Unseal the (.+)$", "Розпечатайте", "acc" },
    { "^Unlock (.+) in (.+)$", "Відкрийте", "acc", "у", "loc" },
    { "^Unlock (.+) with (.+)$", "Відкрийте", "acc", "за допомогою", "gen" },
    { "^Lock (.+) with (.+)$", "Замкніть", "acc", "за допомогою", "gen" },
    { "^Speak to (.+) about the (.+)$", "Поговоріть з", "ins", "про", "acc" },
    { "^Talk to (.+) about the (.+)$", "Поговоріть з", "ins", "про", "acc" },
    { "^Speak with (.+) about (.+)$", "Поговоріть з", "ins", "про", "acc" },
    { "^Talk with (.+) about (.+)$", "Поговоріть з", "ins", "про", "acc" },
    { "^Ask (.+) about the (.+)$", "Запитайте", "acc", "про", "acc" },
    { "^Question (.+) about the (.+)$", "Розпитайте", "acc", "про", "acc" },
    { "^Speak to (.+) near (.+)$", "Поговоріть з", "ins", "біля", "gen" },
    { "^Speak with (.+) near (.+)$", "Поговоріть з", "ins", "біля", "gen" },
    { "^Talk to (.+) near (.+)$", "Поговоріть з", "ins", "біля", "gen" },
    { "^Return to (.+) in the (.+) with (.+)$", "Поверніться до", "gen", "у", "acc", "з", "ins" },
    { "^Return to (.+) at the (.+) with (.+)$", "Поверніться до", "gen", "біля", "loc", "з", "ins" },
    { "^Give (.+) to (.+) in (.+)$", "Віддайте", "acc", "", "dat", "у", "loc" },
    { "^Deliver (.+) to (.+) at the (.+)$", "Доставте", "acc", "до", "gen", "біля", "loc" },
    { "^Hand (.+) to (.+)$", "Вручіть", "acc", "", "dat" },
    { "^Hand in (.+) to (.+)$", "Здайте", "acc", "", "dat" },
    { "^Hand over (.+) to (.+)$", "Передайте", "acc", "", "dat" },
    { "^Turn in (.+) to (.+)$", "Здайте", "acc", "", "dat" },
    { "^Turn in (.+) to (.+) in (.+)$", "Здайте", "acc", "", "dat", "у", "loc" },
    { "^Turn in (.+)$", "Здайте", "acc" },
    { "^Submit (.+) to (.+)$", "Подайте", "acc", "", "dat" },
    { "^Submit (.+)$", "Подайте", "acc" },
    { "^Pick up (.+) from (.+) in (.+)$", "Підніміть", "acc", "від", "gen", "у", "loc" },
    { "^Grab (.+) from (.+)$", "Вхопіть", "acc", "від", "gen" },
    { "^Grab (.+)$", "Вхопіть", "acc" },
    { "^Seize (.+) from (.+)$", "Оволодійте", "ins", "від", "gen" },
    { "^Seize (.+)$", "Оволодійте", "ins" },
    { "^Claim (.+) from (.+)$", "Заячтєте", "acc", "від", "gen" },
    { "^Claim (.+)$", "Заячтєте", "acc" },
    { "^Loot (.+) from (.+)$", "Вилучіть", "acc", "від", "gen" },
    { "^Loot (.+)$", "Вилучіть", "acc" },
    { "^Pillage (.+) in (.+)$", "Пограбуйте", "acc", "у", "loc" },
    { "^Pillage (.+)$", "Пограбуйте", "acc" },
    { "^Salvage (.+) from (.+)$", "Відновіть", "acc", "із", "gen" },
    { "^Salvage (.+)$", "Відновіть", "acc" },
    { "^Restore (.+) to (.+)$", "Відновіть", "acc", "до", "gen" },
    { "^Restore the (.+)$", "Відновіть", "acc" },
    { "^Restore (.+)$", "Відновіть", "acc" },
    { "^Rebuild (.+)$", "Відбудуйте", "acc" },
    { "^Rebuild the (.+)$", "Відбудуйте", "acc" },
    { "^Reconstruct (.+)$", "Відбудуйте", "acc" },
    { "^Refurbish (.+)$", "Оновіть", "acc" },
    { "^Renovate (.+)$", "Відремонтуйте", "acc" },
    { "^Maintain (.+)$", "Підтримайте", "acc" },
    { "^Equip (.+)$", "Спорядьте", "acc" },
    { "^Equip the (.+)$", "Спорядьте", "acc" },
    { "^Outfit (.+) with (.+)$", "Спорядьте", "acc", "", "ins" },
    { "^Dismantle (.+)$", "Розберіть", "acc" },
    { "^Dismantle the (.+)$", "Розберіть", "acc" },
    { "^Demolish (.+)$", "Зруйнуйте", "acc" },
    { "^Demolish the (.+)$", "Зруйнуйте", "acc" },
    { "^Shatter (.+)$", "Розбийте", "acc" },
    { "^Shatter the (.+)$", "Розбийте", "acc" },
    { "^Smash (.+)$", "Розбийте", "acc" },
    { "^Smash the (.+)$", "Розбийте", "acc" },
    { "^Crush (.+)$", "Роздавіть", "acc" },
    { "^Crush the (.+)$", "Роздавіть", "acc" },
    { "^Shatter (.+) in (.+)$", "Розбийте", "acc", "у", "loc" },
    { "^Collect (.+) near (.+)$", "Зберіть", "acc", "біля", "gen" },
    { "^Gather (.+) near (.+)$", "Зберіть", "acc", "біля", "gen" },
    { "^Pick (.+) near (.+)$", "Зберіть", "acc", "біля", "gen" },
    { "^Harvest (.+) near (.+)$", "Зберіть", "acc", "біля", "gen" },
    { "^Mine (.+) near (.+)$", "Видобудьте", "acc", "біля", "gen" },
    { "^Excavate (.+) near (.+)$", "Видобудьте", "acc", "біля", "gen" },
    { "^Fish near (.+)$", "Виловіть біля", "gen" },
    { "^Fish at (.+)$", "Виловіть біля", "loc" },
    { "^Cook (.+) for (.+)$", "Приготуйте", "acc", "для", "gen" },
    { "^Brew (.+) for (.+)$", "Зваріть", "acc", "для", "gen" },
    { "^Speak to (.+) inside (.+)$", "Поговоріть з", "ins", "усередині", "gen" },
    { "^Speak with (.+) inside (.+)$", "Поговоріть з", "ins", "усередині", "gen" },
    { "^Talk to (.+) inside (.+)$", "Поговоріть з", "ins", "усередині", "gen" },
    { "^Find (.+) inside (.+)$", "Знайдіть", "acc", "усередині", "gen" },
    { "^Meet (.+) inside (.+)$", "Зустріньте", "acc", "усередині", "gen" },
    { "^Enter the (.+) and (.+)$", "Увійдіть до", "gen", "та" },
    { "^Cross the (.+)$", "Перейдіть", "acc" },
    { "^Cross (.+)$", "Перейдіть", "acc" },
    { "^Pass through (.+)$", "Пройдіть крізь", "acc" },
    { "^Pass the (.+)$", "Пройдіть повз", "acc" },
    { "^Navigate (.+)$", "Навігуйте", "acc" },
    { "^Navigate through (.+)$", "Навігуйте крізь", "acc" },
    { "^Reach the (.+)$", "Досягніть", "gen" },
    { "^Reach (.+)$", "Досягніть", "gen" },
    { "^Arrive at (.+)$", "Прибули до", "gen" },
    { "^Arrive at the (.+)$", "Прибули до", "gen" },
    { "^Depart from (.+)$", "Відправтеся від", "gen" },
    { "^Depart (.+)$", "Відправтеся з", "gen" },
    { "^Embark on the (.+)$", "Підніміться на", "acc" },
    { "^Embark (.+)$", "Сядьте на", "acc" },
    { "^Disembark at (.+)$", "Зійдіть у", "acc" },
    { "^Board the (.+)$", "Підніміться на борт", "gen" },
    { "^Hail (.+)$", "Привітайте", "acc" },
    { "^Greet (.+)$", "Привітайте", "acc" },
    { "^Bow to (.+)$", "Поклоніться", "dat" },
    { "^Kneel before (.+)$", "Станьте на коліна перед", "ins" },
    { "^Pay respects to (.+)$", "Віддайте шану", "dat" },
    { "^Pay tribute to (.+)$", "Віддайте данину", "dat" },
    { "^Honor (.+)$", "Віддайте шану", "dat" },
    { "^Mourn (.+)$", "Оплакайте", "acc" },
    { "^Bury (.+)$", "Поховайте", "acc" },
    { "^Mourn the (.+)$", "Оплакайте", "acc" },
    { "^Bury the (.+)$", "Поховайте", "acc" },
    { "^Avenge (.+)$", "Відмстіть за", "acc" },
    { "^Avenge the (.+)$", "Відмстіть за", "acc" },
    { "^Kill (.+) near the (.+)$", "Вбийте", "acc", "біля", "gen" },
    { "^Kill (.+) near (.+)$", "Вбийте", "acc", "біля", "gen" },
    { "^Slay (.+) near the (.+)$", "Вбийте", "acc", "біля", "gen" },
    { "^Slay (.+) at the (.+)$", "Вбийте", "acc", "біля", "loc" },
    { "^Defeat (.+) near the (.+)$", "Переможіть", "acc", "біля", "gen" },
    { "^Destroy (.+) near the (.+)$", "Знищте", "acc", "біля", "gen" },
    { "^Search for (.+) near (.+)$", "Шукайте", "acc", "біля", "gen" },
    { "^Collect (.+) around (.+)$", "Зберіть", "acc", "навколо", "gen" },
    { "^Gather (.+) around (.+)$", "Зберіть", "acc", "навколо", "gen" },
    { "^Gather (.+) from the (.+) in (.+)$", "Зберіть", "acc", "із", "gen", "у", "loc" },
    { "^Pick up (.+) in (.+)$", "Підніміть", "acc", "у", "loc" },
    { "^Pick up (.+) at (.+)$", "Підніміть", "acc", "біля", "loc" },
    { "^Rescue (.+) from (.+) in (.+)$", "Врятуйте", "acc", "від", "gen", "у", "loc" },
    { "^Free (.+) from (.+) in (.+)$", "Звільніть", "acc", "від", "gen", "у", "loc" },
    { "^Speak with (.+) at the (.+)$", "Поговоріть з", "ins", "біля", "loc" },
    { "^Talk to (.+) at the (.+)$", "Поговоріть з", "ins", "біля", "loc" },
    { "^Speak to (.+) at the (.+)$", "Поговоріть з", "ins", "біля", "loc" },
    { "^Meet (.+) near the (.+)$", "Зустріньте", "acc", "біля", "gen" },
    { "^Find (.+) near the (.+)$", "Знайдіть", "acc", "біля", "gen" },
    { "^Deliver (.+) to (.+) near (.+)$", "Доставте", "acc", "до", "gen", "біля", "gen" },
    { "^Report to (.+) at the (.+)$", "Доповідьте", "dat", "біля", "loc" },
    { "^Report to (.+) near (.+)$", "Доповідьте", "dat", "біля", "gen" },
    { "^Help (.+) rescue (.+)$", "Допоможіть", "dat", "врятувати", "acc" },
    { "^Help (.+) defend (.+)$", "Допоможіть", "dat", "захистити", "acc" },
    { "^Help (.+) defeat (.+)$", "Допоможіть", "dat", "перемогти", "acc" },
    { "^Help (.+) collect (.+)$", "Допоможіть", "dat", "зібрати", "acc" },
    { "^Help (.+) find (.+)$", "Допоможіть", "dat", "знайти", "acc" },
    { "^Help (.+) destroy (.+)$", "Допоможіть", "dat", "знищити", "acc" },
    { "^Work with (.+) to (.+)$", "Працюйте з", "ins", "щоб" },
    { "^Team up with (.+) to (.+)$", "Об'єднайтеся з", "ins", "щоб" },
    { "^Join (.+) in (.+)$", "Приєднайтеся до", "gen", "у", "loc" },
    { "^Join (.+) at (.+)$", "Приєднайтеся до", "gen", "біля", "loc" },
    { "^Join (.+)$", "Приєднайтеся до", "gen" },
    { "^Accompany (.+) to (.+)$", "Супроводжуйте", "acc", "до", "gen" },
    { "^Accompany (.+)$", "Супроводжуйте", "acc" },
    { "^Follow (.+) to (.+) in (.+)$", "Стежте за", "ins", "до", "gen", "у", "loc" },
    { "^Follow (.+) through (.+)$", "Стежте за", "ins", "крізь", "acc" },
    { "^Escort (.+) safely to (.+)$", "Супроводжуйте", "acc", "безпечно до", "gen" },
    { "^Watch over (.+)$", "Наглядайте за", "ins" },
    { "^Watch over (.+) in (.+)$", "Наглядайте за", "ins", "у", "loc" },
    { "^Guard (.+) in (.+)$", "Охороняйте", "acc", "у", "loc" },
    { "^Guard (.+)$", "Охороняйте", "acc" },
    { "^Guard the (.+)$", "Охороняйте", "acc" },
    { "^Patrol (.+)$", "Патрулюйте", "acc" },
    { "^Patrol the (.+)$", "Патрулюйте", "acc" },
    { "^Patrol (.+) in (.+)$", "Патрулюйте", "acc", "у", "loc" },
    { "^Scout (.+) in (.+)$", "Розвідайте", "acc", "у", "loc" },
    { "^Scout (.+)$", "Розвідайте", "acc" },
    { "^Scout the (.+)$", "Розвідайте", "acc" },
    { "^Survey (.+)$", "Обстежте", "acc" },
    { "^Survey the (.+)$", "Обстежте", "acc" },
    { "^Map the (.+)$", "Нанесіть на карту", "acc" },
    { "^Chart the (.+)$", "Нанесіть на карту", "acc" },
    { "^Mark the (.+)$", "Позначте", "acc" },
    { "^Tag (.+)$", "Позначте", "acc" },
    { "^Flag (.+)$", "Позначте", "acc" },
    { "^Signal (.+)$", "Сигналізуйте", "acc" },
    { "^Signal the (.+)$", "Сигналізуйте", "acc" },
    { "^Communicate with (.+)$", "Зв'яжіться з", "ins" },
    { "^Communicate with (.+) at (.+)$", "Зв'яжіться з", "ins", "біля", "loc" },
    { "^Contact (.+)$", "Зв'яжіться з", "ins" },
    { "^Contact (.+) in (.+)$", "Зв'яжіться з", "ins", "у", "loc" },
    { "^Reach out to (.+)$", "Зверніться до", "gen" },
    { "^Reach out to (.+) in (.+)$", "Зверніться до", "gen", "у", "loc" },
    { "^Return to (.+) with (.+)$", "Поверніться до", "gen", "з", "ins" },
    { "^Return (.+) to (.+) in (.+)$", "Поверніть", "acc", "до", "gen", "у", "loc" },
    { "^Return (.+) to (.+) at (.+)$", "Поверніть", "acc", "до", "gen", "біля", "loc" },
    { "^Bring (.+) to (.+) at (.+)$", "Принесіть", "acc", "до", "gen", "біля", "loc" },
    { "^Carry (.+) into (.+)$", "Перенесіть", "acc", "до", "gen" },
    { "^Take (.+) into (.+)$", "Візьміть", "acc", "до", "gen" },
    { "^Lead (.+) to (.+)$", "Приведіть", "acc", "до", "gen" },
    { "^Lead (.+) through (.+)$", "Проведіть", "acc", "крізь", "acc" },
    { "^Lead (.+)$", "Проведіть", "acc" },
    { "^Conduct (.+) to (.+)$", "Проведіть", "acc", "до", "gen" },
    { "^Direct (.+) to (.+)$", "Спрямувати", "acc", "до", "gen" },
    { "^Show (.+) to (.+)$", "Покажіть", "acc", "", "dat" },
    { "^Show (.+)$", "Покажіть", "acc" },
    { "^Point out (.+) to (.+)$", "Вкажіть", "acc", "", "dat" },
    { "^Explain (.+) to (.+)$", "Поясніть", "acc", "", "dat" },
    { "^Describe (.+) to (.+)$", "Опишіть", "acc", "", "dat" },
    { "^Describe (.+)$", "Опишіть", "acc" },
    { "^Document (.+)$", "Задокументуйте", "acc" },
    { "^Record (.+)$", "Запишіть", "acc" },
    { "^Log (.+)$", "Зафіксуйте", "acc" },
    { "^Note (.+)$", "Зауважте", "acc" },
    { "^Memorialize (.+)$", "Вшануйте", "acc" },
    { "^Commemorate (.+)$", "Відзначте", "acc" },
    { "^Celebrate (.+)$", "Святкуйте", "acc" },
    { "^Witness (.+)$", "Засвідчіть", "acc" },
    { "^Witness the (.+)$", "Засвідчіть", "acc" },
    { "^Attend the (.+)$", "Відвідайте", "acc" },
    { "^Attend (.+)$", "Відвідайте", "acc" },
    { "^Visit (.+)$", "Відвідайте", "acc" },
    { "^Visit the (.+)$", "Відвідайте", "acc" },
    { "^Visit (.+) in (.+)$", "Відвідайте", "acc", "у", "loc" },
    { "^Inspect the (.+)$", "Огляньте", "acc" },
    { "^Inspect (.+) in (.+)$", "Огляньте", "acc", "у", "loc" },
    { "^Examine the (.+)$", "Огляньте", "acc" },
    { "^Examine (.+) in (.+)$", "Огляньте", "acc", "у", "loc" },
    { "^Investigate (.+) in (.+)$", "Дослідіть", "acc", "у", "loc" },
    { "^Investigate the (.+) in (.+)$", "Дослідіть", "acc", "у", "loc" },
    { "^Analyze (.+)$", "Проаналізуйте", "acc" },
    { "^Analyze the (.+)$", "Проаналізуйте", "acc" },
    { "^Study (.+)$", "Вивчіть", "acc" },
    { "^Study the (.+)$", "Вивчіть", "acc" },
    { "^Research (.+)$", "Дослідіть", "acc" },
    { "^Research the (.+)$", "Дослідіть", "acc" },
    { "^Decipher (.+)$", "Розшифруйте", "acc" },
    { "^Decipher the (.+)$", "Розшифруйте", "acc" },
    { "^Translate (.+)$", "Перекладіть", "acc" },
    { "^Translate the (.+)$", "Перекладіть", "acc" },
    { "^Interpret (.+)$", "Інтерпретуйте", "acc" },
    { "^Decode (.+)$", "Декодуйте", "acc" },
    { "^Decode the (.+)$", "Декодуйте", "acc" },
    { "^Collect data on (.+)$", "Зберіть дані про", "acc" },
    { "^Gather information on (.+)$", "Зберіть інформацію про", "acc" },
    { "^Gather intel on (.+)$", "Зберіть розвідку про", "acc" },
    { "^Gather evidence of (.+)$", "Зберіть докази", "gen" },
    { "^Collect evidence of (.+)$", "Зберіть докази", "gen" },
    { "^Obtain information from (.+)$", "Здобудьте інформацію від", "gen" },
    { "^Obtain intel from (.+)$", "Здобудьте розвідку від", "gen" },
    { "^Slay (.+) and (.+)$", "Вбийте", "acc", "та", "acc" },
    { "^Kill (.+) and (.+)$", "Вбийте", "acc", "та", "acc" },
    { "^Defeat (.+) and (.+)$", "Переможіть", "acc", "та", "acc" },
    { "^Destroy (.+) and (.+)$", "Знищте", "acc", "та", "acc" },
    { "^Rescue (.+) and (.+)$", "Врятуйте", "acc", "та", "acc" },
    { "^Collect (.+) and (.+)$", "Зберіть", "acc", "та", "acc" },
    { "^Gather (.+) and (.+)$", "Зберіть", "acc", "та", "acc" },
    { "^Deliver (.+) and (.+)$", "Доставте", "acc", "та", "acc" },
    { "^Find (.+) and (.+) in (.+)$", "Знайдіть", "acc", "та", "acc", "у", "loc" },
    { "^Kill (.+) and (.+) in (.+)$", "Вбийте", "acc", "та", "acc", "у", "loc" },
    { "^Defeat (.+) and (.+) in (.+)$", "Переможіть", "acc", "та", "acc", "у", "loc" },
    { "^Destroy (.+) and (.+) in (.+)$", "Знищте", "acc", "та", "acc", "у", "loc" },
    { "^Speak with (.+) then (.+)$", "Поговоріть з", "ins", "потім" },
    { "^Talk to (.+) then (.+)$", "Поговоріть з", "ins", "потім" },
    { "^Speak to (.+) and (.+)$", "Поговоріть з", "ins", "та з", "ins" },
    { "^Talk to (.+) and (.+)$", "Поговоріть з", "ins", "та з", "ins" },
    { "^Meet (.+) and (.+)$", "Зустріньте", "acc", "та", "acc" },
    { "^Help (.+) and (.+)$", "Допоможіть", "dat", "та", "dat" },
    { "^Assist (.+) and (.+)$", "Допоможіть", "dat", "та", "dat" },
    { "^Collect (.+) for (.+) in (.+)$", "Зберіть", "acc", "для", "gen", "у", "loc" },
    { "^Gather (.+) for (.+) in (.+)$", "Зберіть", "acc", "для", "gen", "у", "loc" },
    { "^Pick up (.+) for (.+)$", "Підніміть", "acc", "для", "gen" },
    { "^Buy (.+) for (.+)$", "Купіть", "acc", "для", "gen" },
    { "^Craft (.+) for (.+)$", "Складіть", "acc", "для", "gen" },
    { "^Cook (.+) on the (.+)$", "Приготуйте", "acc", "на", "loc" },
    { "^Cook (.+) at the (.+)$", "Приготуйте", "acc", "біля", "loc" },
    { "^Brew (.+) at the (.+)$", "Зваріть", "acc", "біля", "loc" },
    { "^Brew (.+) on the (.+)$", "Зваріть", "acc", "на", "loc" },
    { "^Speak to (.+) in (.+) and (.+)$", "Поговоріть з", "ins", "у", "loc", "та" },
    { "^Talk to (.+) in (.+) and (.+)$", "Поговоріть з", "ins", "у", "loc", "та" },
    { "^Go to (.+) and (.+)$", "Відправтеся до", "gen", "та" },
    { "^Go to (.+) then (.+)$", "Відправтеся до", "gen", "потім" },
    { "^Travel to (.+) and (.+)$", "Відправтеся до", "gen", "та" },
    { "^Travel to (.+) then (.+)$", "Відправтеся до", "gen", "потім" },
    { "^Fly to (.+) then (.+)$", "Відлетіть до", "gen", "потім" },
    { "^Ride to (.+)$", "Доїдьте до", "gen" },
    { "^Ride the (.+) to (.+)$", "Проїдьте на", "loc", "до", "gen" },
    { "^Sail the (.+) to (.+)$", "Відпливіть на", "loc", "до", "gen" },
    { "^Swim to (.+) and (.+)$", "Допливіть до", "gen", "та" },
    { "^Run to (.+)$", "Пробіжіть до", "gen" },
    { "^Walk to (.+) and (.+)$", "Пройдіть до", "gen", "та" },
    { "^Drive (.+) to (.+) in (.+)$", "Ведіть", "acc", "до", "gen", "у", "loc" },
    { "^Capture (.+) for (.+)$", "Спіймайте", "acc", "для", "gen" },
    { "^Tame (.+) in (.+)$", "Приручіть", "acc", "у", "loc" },
    { "^Tame (.+) near (.+)$", "Приручіть", "acc", "біля", "gen" },
    { "^Train (.+) at (.+)$", "Тренуйте", "acc", "біля", "loc" },
    { "^Train with (.+)$", "Тренуйтеся з", "ins" },
    { "^Practice (.+) with (.+)$", "Потренуйте", "acc", "з", "ins" },
    { "^Sharpen (.+)$", "Загостріть", "acc" },
    { "^Polish (.+)$", "Поліруйте", "acc" },
    { "^Engrave (.+)$", "Гравіюйте", "acc" },
    { "^Inscribe (.+)$", "Напишіть на", "loc" },
    { "^Inscribe (.+) on (.+)$", "Напишіть", "acc", "на", "loc" },
    { "^Carve (.+)$", "Виріжте", "acc" },
    { "^Carve (.+) into (.+)$", "Виріжте", "acc", "на", "loc" },
    { "^Sculpt (.+)$", "Скульптуруйте", "acc" },
    { "^Mold (.+)$", "Сформуйте", "acc" },
    { "^Forge (.+)$", "Куйте", "acc" },
    { "^Forge the (.+)$", "Куйте", "acc" },
    { "^Smelt (.+)$", "Плавте", "acc" },
    { "^Refine (.+)$", "Очистіть", "acc" },
    { "^Refine the (.+)$", "Очистіть", "acc" },
    { "^Process (.+)$", "Обробіть", "acc" },
    { "^Process the (.+)$", "Обробіть", "acc" },
    { "^Grind (.+)$", "Змеліть", "acc" },
    { "^Crush (.+) into (.+)$", "Роздавіть", "acc", "на", "acc" },
    { "^Mill (.+)$", "Змеліть", "acc" },
    { "^Prospect (.+)$", "Пропектуйте", "acc" },
    { "^Disenchant the (.+)$", "Розчаруйте", "acc" },
    { "^Picklock (.+)$", "Зламайте замок на", "loc" },
    { "^Pickpocket (.+)$", "Обкрадіть", "acc" },
    { "^Spy on (.+)$", "Спигуйте на", "acc" },
    { "^Eavesdrop on (.+)$", "Підслухайте", "acc" },
    { "^Interrogate (.+)$", "Допитайте", "acc" },
    { "^Interrogate (.+) in (.+)$", "Допитайте", "acc", "у", "loc" },
    { "^Torture (.+)$", "Катуйте", "acc" },
    { "^Imprison (.+)$", "Ув'язніть", "acc" },
    { "^Imprison (.+) in (.+)$", "Ув'язніть", "acc", "у", "loc" },
    { "^Jail (.+)$", "Ув'язніть", "acc" },
    { "^Capture (.+) alive$", "Спіймайте", "acc", "живим" },
    { "^Bring (.+) back to (.+)$", "Поверніть", "acc", "до", "gen" },
    { "^Bring (.+) back to (.+) in (.+)$", "Поверніть", "acc", "до", "gen", "у", "loc" },
    { "^Bring (.+) back$", "Поверніть", "acc" },
    { "^Return back to (.+)$", "Поверніться до", "gen" },
    { "^Go back to (.+)$", "Поверніться до", "gen" },
    { "^Head back to (.+)$", "Поверніться до", "gen" },
    { "^Come back to (.+)$", "Поверніться до", "gen" },
    { "^Get (.+) from (.+)$", "Візьміть", "acc", "від", "gen" },
    { "^Get (.+) from (.+) in (.+)$", "Візьміть", "acc", "від", "gen", "у", "loc" },
    { "^Get (.+)$", "Візьміть", "acc" },
    { "^Fetch (.+) from (.+)$", "Принесіть", "acc", "від", "gen" },
    { "^Fetch (.+)$", "Принесіть", "acc" },
    { "^Fetch (.+) for (.+)$", "Принесіть", "acc", "для", "gen" },
    { "^Retrieve (.+) from (.+) in (.+)$", "Дістаньте", "acc", "від", "gen", "у", "loc" },
    { "^Retrieve (.+) from (.+) at (.+)$", "Дістаньте", "acc", "від", "gen", "біля", "loc" },
    { "^Grab (.+) from (.+) in (.+)$", "Вхопіть", "acc", "від", "gen", "у", "loc" },
    { "^Grab (.+) in (.+)$", "Вхопіть", "acc", "у", "loc" },
    { "^Pick up (.+) from (.+) at (.+)$", "Підніміть", "acc", "від", "gen", "біля", "loc" },
    { "^Buy (.+) from (.+) at (.+)$", "Купіть", "acc", "від", "gen", "біля", "loc" },
    { "^Speak to (.+) at (.+) in the (.+)$", "Поговоріть з", "ins", "біля", "loc", "у", "loc" },
    { "^Slay (.+) in the (.+)$", "Вбийте", "acc", "у", "loc" },
    { "^Slay (.+) near the (.+)$", "Вбийте", "acc", "біля", "gen" },
    { "^Escort (.+) from (.+)$", "Супроводжуйте", "acc", "від", "gen" },
    { "^Escort (.+) from (.+) to (.+)$", "Супроводжуйте", "acc", "від", "gen", "до", "gen" },
    { "^Escort (.+) safely from (.+) to (.+)$", "Супроводжуйте", "acc", "безпечно від", "gen", "до", "gen" },
    { "^Protect (.+) from (.+) in (.+)$", "Захистіть", "acc", "від", "gen", "у", "loc" },
    { "^Defend (.+) from (.+) in (.+)$", "Захистіть", "acc", "від", "gen", "у", "loc" },
    { "^Defend the (.+) from (.+)$", "Захистіть", "acc", "від", "gen" },
    { "^Protect the (.+) from (.+)$", "Захистіть", "acc", "від", "gen" },
    { "^Watch (.+) fight (.+)$", "Спостерігайте як", "nom", "б'ється з", "ins" },
    { "^Cheer for (.+)$", "Вітайте", "acc" },
    { "^Cheer on (.+)$", "Підтримайте", "acc" },
    { "^Root for (.+)$", "Вболівайте за", "acc" },
    { "^Encourage (.+)$", "Підбадьорте", "acc" },
    { "^Motivate (.+)$", "Мотивуйте", "acc" },
    { "^Inspire (.+)$", "Надихніть", "acc" },
    { "^Teach (.+) about (.+)$", "Навчіть", "acc", "про", "acc" },
    { "^Learn about (.+)$", "Дізнайтеся про", "acc" },
    { "^Learn about (.+) from (.+)$", "Дізнайтеся про", "acc", "від", "gen" },
    { "^Learn the (.+)$", "Навчіться", "gen" },
    { "^Listen to (.+) about (.+)$", "Послухайте", "acc", "про", "acc" },
    { "^Receive (.+) from (.+) in (.+)$", "Отримайте", "acc", "від", "gen", "у", "loc" },
    { "^Accept (.+) from (.+) in (.+)$", "Прийміть", "acc", "від", "gen", "у", "loc" },
    { "^Take (.+) from (.+) in (.+)$", "Візьміть", "acc", "від", "gen", "у", "loc" },
    { "^Steal (.+) from (.+) in (.+)$", "Вкрадіть", "acc", "від", "gen", "у", "loc" },
    { "^Steal (.+) for (.+)$", "Вкрадіть", "acc", "для", "gen" },
    { "^Loot (.+) from (.+) in (.+)$", "Вилучіть", "acc", "від", "gen", "у", "loc" },
    { "^Salvage (.+) from (.+) in (.+)$", "Відновіть", "acc", "із", "gen", "у", "loc" },
    { "^Harvest (.+) from (.+) in (.+)$", "Зберіть", "acc", "від", "gen", "у", "loc" },
    { "^Mine (.+) from (.+)$", "Видобудьте", "acc", "із", "gen" },
    { "^Mine (.+) in the (.+)$", "Видобудьте", "acc", "у", "loc" },
    { "^Fish (.+) from (.+)$", "Виловіть", "acc", "із", "gen" },
    { "^Fish (.+) at (.+)$", "Виловіть", "acc", "біля", "loc" },
    { "^Cook (.+) for (.+) in (.+)$", "Приготуйте", "acc", "для", "gen", "у", "loc" },
    { "^Craft (.+) for (.+)$", "Складіть", "acc", "для", "gen" },
    { "^Craft (.+) at (.+)$", "Складіть", "acc", "біля", "loc" },
    { "^Craft (.+) in (.+)$", "Складіть", "acc", "у", "loc" },
    { "^Enchant (.+) for (.+)$", "Зачаруйте", "acc", "для", "gen" },
    { "^Disenchant (.+) for (.+)$", "Розчаруйте", "acc", "для", "gen" },
    { "^Alchemize (.+)$", "Створіть алхімією", "acc" },
    { "^Scribe (.+)$", "Напишіть", "acc" },
    { "^Inscribe (.+) for (.+)$", "Напишіть", "acc", "для", "gen" },
    { "^Apply (.+) to (.+)$", "Застосуйте", "acc", "до", "gen" },
    { "^Apply (.+)$", "Застосуйте", "acc" },
    { "^Apply the (.+)$", "Застосуйте", "acc" },
    { "^Coat (.+) with (.+)$", "Покрийте", "acc", "", "ins" },
    { "^Soak (.+) in (.+)$", "Замочіть", "acc", "у", "loc" },
    { "^Dip (.+) in (.+)$", "Занурте", "acc", "у", "acc" },
    { "^Drench (.+) in (.+)$", "Змочіть", "acc", "у", "loc" },
    { "^Sprinkle (.+) on (.+)$", "Посипте", "acc", "на", "acc" },
    { "^Scatter (.+) around (.+)$", "Розкидайте", "acc", "навколо", "gen" },
    { "^Spread (.+) on (.+)$", "Розподіліть", "acc", "на", "loc" },
    { "^Spread (.+) around (.+)$", "Розподіліть", "acc", "навколо", "gen" },
    { "^Drop (.+) into (.+)$", "Скиньте", "acc", "до", "gen" },
    { "^Pour (.+) into the (.+)$", "Вилийте", "acc", "до", "gen" },
    { "^Toss (.+) into (.+)$", "Киньте", "acc", "до", "gen" },
    { "^Throw (.+) into (.+)$", "Киньте", "acc", "до", "gen" },
    { "^Hurl (.+) at (.+)$", "Запустіть", "acc", "у", "acc" },
    { "^Launch (.+) at (.+)$", "Запустіть", "acc", "у", "acc" },
    { "^Shoot (.+) at (.+)$", "Вистріліть", "acc", "у", "acc" },
    { "^Fire (.+) at (.+)$", "Випустіть", "acc", "у", "acc" },
    { "^Aim (.+) at (.+)$", "Ціліть", "ins", "у", "acc" },
    { "^Wield (.+)$", "Скористайте", "ins" },
    { "^Wield the (.+)$", "Скористайте", "ins" },
    { "^Equip (.+) and (.+)$", "Спорядьте", "ins", "та", "ins" },
    { "^Put on (.+)$", "Одягніть", "acc" },
    { "^Take off (.+)$", "Зніміть", "acc" },
    { "^Remove (.+)$", "Видаліть", "acc" },
    { "^Remove the (.+)$", "Видаліть", "acc" },
    { "^Dispose of (.+)$", "Позбавтеся", "gen" },
    { "^Discard (.+)$", "Викиньте", "acc" },
    { "^Sacrifice (.+)$", "Принесіть у жертву", "acc" },
    { "^Sacrifice (.+) to (.+)$", "Принесіть у жертву", "acc", "", "dat" },
    { "^Offer (.+) as tribute to (.+)$", "Запропонуйте", "acc", "як данину", "dat" },
    { "^Feed (.+) to (.+) in (.+)$", "Годайте", "acc", "", "dat", "у", "loc" },
    { "^Feed (.+) at (.+)$", "Годайте", "acc", "біля", "loc" },
    { "^Give (.+) to (.+) in (.+)$", "Віддайте", "acc", "", "dat", "у", "loc" },
    { "^Give (.+) to (.+) at (.+)$", "Віддайте", "acc", "", "dat", "біля", "loc" },
    { "^Speak to (.+) about (.+) in (.+)$", "Поговоріть з", "ins", "про", "acc", "у", "loc" },
    { "^Talk to (.+) about (.+) in (.+)$", "Поговоріть з", "ins", "про", "acc", "у", "loc" },
    { "^Speak with (.+) about (.+) at (.+)$", "Поговоріть з", "ins", "про", "acc", "біля", "loc" },
    { "^Talk with (.+) about (.+) at (.+)$", "Поговоріть з", "ins", "про", "acc", "біля", "loc" },
    { "^Report to (.+) about (.+)$", "Доповідьте", "dat", "про", "acc" },
    { "^Ask (.+) in (.+) about (.+)$", "Запитайте", "acc", "у", "loc", "про", "acc" },
    { "^Question (.+) in (.+) about (.+)$", "Розпитайте", "acc", "у", "loc", "про", "acc" },
    { "^Consult (.+) about (.+)$", "Зверніться до", "gen", "щодо", "gen" },
    { "^Consult (.+) about (.+) in (.+)$", "Зверніться до", "gen", "щодо", "gen", "у", "loc" },
    { "^Obtain (.+) from (.+) in (.+)$", "Здобудьте", "acc", "від", "gen", "у", "loc" },
    { "^Obtain (.+) from (.+) at (.+)$", "Здобудьте", "acc", "від", "gen", "біля", "loc" },
    { "^Acquire (.+) from (.+) in (.+)$", "Здобудьте", "acc", "від", "gen", "у", "loc" },
    { "^Collect (.+) for (.+) from (.+)$", "Зберіть", "acc", "для", "gen", "від", "gen" },
    { "^Gather (.+) for (.+) from (.+)$", "Зберіть", "acc", "для", "gen", "від", "gen" },
    { "^Deliver (.+) from (.+) to (.+)$", "Доставте", "acc", "від", "gen", "до", "gen" },
    { "^Deliver (.+) to (.+) for (.+)$", "Доставте", "acc", "до", "gen", "для", "gen" },
    { "^Bring (.+) from (.+) to (.+)$", "Принесіть", "acc", "від", "gen", "до", "gen" },
    { "^Bring (.+) to (.+) for (.+)$", "Принесіть", "acc", "до", "gen", "для", "gen" },
    { "^Carry (.+) from (.+) to (.+)$", "Перенесіть", "acc", "від", "gen", "до", "gen" },
    { "^Return (.+) to (.+) for (.+)$", "Поверніть", "acc", "до", "gen", "для", "gen" },
    { "^Send (.+) from (.+) to (.+)$", "Відправте", "acc", "від", "gen", "до", "gen" },
    { "^Search (.+) for (.+) in (.+)$", "Обшукайте", "acc", "у", "loc", "щоб знайти", "acc" },
    { "^Search the (.+) for (.+) in (.+)$", "Обшукайте", "acc", "у", "loc", "щоб знайти", "acc" },
}

local patternRoutes = {}
do
    local _m1, _m2
    for _, rule in ipairs(objectiveRules) do
        local pat = rule[1]
        _m1 = pat:match("^%^([%w']+) ")
        if _m1 then
            patternRoutes[_m1] = patternRoutes[_m1] or {}
            patternRoutes[_m1][#patternRoutes[_m1] + 1] = rule
        else
            _m2 = pat:match("^%^([%w']+)")
            if _m2 then
                patternRoutes[_m2] = patternRoutes[_m2] or {}
                patternRoutes[_m2][#patternRoutes[_m2] + 1] = rule
            else
                patternRoutes["__default"] = patternRoutes["__default"] or {}
                patternRoutes["__default"][#patternRoutes["__default"] + 1] = rule
            end
        end
    end
    for _, rules in pairs(patternRoutes) do
        table.sort(rules, function(a, b) return #a[1] > #b[1] end)
    end
end

local DynamicCache = {}
local DYNAMIC_CACHE_MAX = 4096
local DynamicCacheCount = 0

local function cacheGet(text)
    return DynamicCache[text]
end

local function cacheSet(text, result)
    if DynamicCacheCount >= DYNAMIC_CACHE_MAX then
        wipe(DynamicCache)
        DynamicCacheCount = 0
    end
    DynamicCache[text] = result
    DynamicCacheCount = DynamicCacheCount + 1
end

local _matchBuf = {}

local progressPatterns = {
    { "^(%d+/%d+) (.+) slain$", function(count, what)
        local uk = trPluralGen(what)
        if uk then return count .. " " .. uk .. " вбито" end
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " вбито" end
        return nil
    end },
    { "^(%d+/%d+) (.+) killed$", function(count, what)
        local uk = trPluralGen(what)
        if uk then return count .. " " .. uk .. " вбито" end
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " вбито" end
        return nil
    end },
    { "^(%d+/%d+) (.+) defeated$", function(count, what)
        local uk = trPluralGen(what)
        if uk then return count .. " " .. uk .. " переможено" end
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " переможено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) destroyed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " знищено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) collected$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " зібрано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) gathered$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " зібрано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) delivered$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " доставлено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) rescued$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " врятовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) freed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " звільнено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) found$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " знайдено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) completed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " завершено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) saved$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " врятовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) recovered$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " відновлено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) cleansed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " очищено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) purified$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " очищено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) burned$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " спалено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) repelled$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " відкинуто" end
        return nil
    end },
    { "^(%d+/%d+) (.+) subdued$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " заспокоєно" end
        return nil
    end },
    { "^(%d+/%d+) (.+) disrupted$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " зірвано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) crafted$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " складено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) opened$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " відкрито" end
        return nil
    end },
    { "^(%d+/%d+) (.+) activated$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " активовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) placed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " розміщено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) planted$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " посаджено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) mined$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " видобуто" end
        return nil
    end },
    { "^(%d+/%d+) (.+) excavated$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " видобуто" end
        return nil
    end },
    { "^(%d+/%d+) (.+) captured$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " захоплено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) tamed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " приручено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) healed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " зцілено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) repaired$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " відремонтовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) calmed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " заспокоєно" end
        return nil
    end },
    { "^(%d+/%d+) (.+) released$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " випущено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) retrieved$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " дістано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) obtained$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " здобуто" end
        return nil
    end },
    { "^(%d+/%d+) (.+) secured$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " забезпечено" end
        return nil
    end },
    { "^(%d+/%d+) (.+)$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat end
        return nil
    end },
    { "^(%d+/%d+) (.+) wounded$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " поранено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) injured$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " поранено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) corrupted$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " спотворено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) cursed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " проклято" end
        return nil
    end },
    { "^(%d+/%d+) (.+) blessed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " благословено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) enchanted$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " зачаровано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) disenchanted$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " розчаровано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) transformed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " трансформовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) transmuted$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " трансмутовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) consumed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " спожито" end
        return nil
    end },
    { "^(%d+/%d+) (.+) absorbed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " абсорбовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) siphoned$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " викачано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) drained$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " вичерпано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) extracted$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " витягнуто" end
        return nil
    end },
    { "^(%d+/%d+) (.+) smelted$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " переплавлено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) milled$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " змелено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) prospected$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " пропектовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) forged$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " викуто" end
        return nil
    end },
    { "^(%d+/%d+) (.+) brewed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " зварено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) cooked$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " приготовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) fished$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " виловлено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) mined$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " видобуто" end
        return nil
    end },
    { "^(%d+/%d+) (.+) harvested$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " зібрано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) picked$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " зібрано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) disarmed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " роззброєно" end
        return nil
    end },
    { "^(%d+/%d+) (.+) disabled$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " вимкнено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) sabotaged$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " саботовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) sealed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " запечатано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) unsealed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " розпечатано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) locked$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " замкнено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) unlocked$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " відкрито" end
        return nil
    end },
    { "^(%d+/%d+) (.+) escorted$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " супроводжено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) guided$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " проведено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) fed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " нагодовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) poisoned$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " отруєно" end
        return nil
    end },
    { "^(%d+/%d+) (.+) cursed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " проклято" end
        return nil
    end },
    { "^(%d+/%d+) (.+) banished$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " вигнано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) exiled$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " вигнано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) summoned$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " призвано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) dismissed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " звільнено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) smitten$", function(count, what)
        local uk = trPluralGen(what)
        if uk then return count .. " " .. uk .. " вбито" end
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " вбито" end
        return nil
    end },
    { "^(%d+/%d+) (.+) massacred$", function(count, what)
        local uk = trPluralGen(what)
        if uk then return count .. " " .. uk .. " вирізано" end
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " вирізано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) annihilated$", function(count, what)
        local uk = trPluralGen(what)
        if uk then return count .. " " .. uk .. " знищено" end
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " знищено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) decimated$", function(count, what)
        local uk = trPluralGen(what)
        if uk then return count .. " " .. uk .. " винищено" end
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " винищено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) executed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " страчено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) neutralized$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " нейтралізовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) subjugated$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " підкорено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) tamed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " приручено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) befriended$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " подружено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) recruited$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " завербовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) rallied$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " згуртовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) rallied$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " згуртовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) plundered$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " розграбовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) looted$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " розграбовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) pillaged$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " пограбовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) salvaged$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " відновлено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) refurbished$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " оновлено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) renovated$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " відремонтовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) rebuilt$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " відбудовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) reconstructed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " відбудовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) mended$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " полагоджено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) repaired$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " відремонтовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) restored$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " відновлено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) reclaimed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " відвойовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) retrieved$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " дістано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) obtained$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " здобуто" end
        return nil
    end },
    { "^(%d+/%d+) (.+) acquired$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " здобуто" end
        return nil
    end },
    { "^(%d+/%d+) (.+) procured$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " роздобуто" end
        return nil
    end },
    { "^(%d+/%d+) (.+) purchased$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " придбано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) bought$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " куплено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) sold$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " продано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) traded$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " обміняно" end
        return nil
    end },
    { "^(%d+/%d+) (.+) exchanged$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " обміняно" end
        return nil
    end },
    { "^(%d+/%d+) (.+) constructed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " побудовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) built$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " побудовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) erected$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " зведено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) dismantled$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " розібрано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) demolished$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " зруйновано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) shattered$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " розбито" end
        return nil
    end },
    { "^(%d+/%d+) (.+) smashed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " розбито" end
        return nil
    end },
    { "^(%d+/%d+) (.+) crushed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " роздавлено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) broken$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " розбито" end
        return nil
    end },
    { "^(%d+/%d+) (.+) secured$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " забезпечено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) defended$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " захищено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) protected$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " захищено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) held$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " утримано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) captured$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " захоплено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) seized$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " захоплено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) conquered$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " завойовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) liberated$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " визволено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) surrendered$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " здано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) betrayed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .." зраджено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) corrupted$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " спотворено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) calmed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " заспокоєно" end
        return nil
    end },
    { "^(%d+/%d+) (.+) soothed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " заспокоєно" end
        return nil
    end },
    { "^(%d+/%d+) (.+) comforted$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " утішено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) reassured$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " заспокоєно" end
        return nil
    end },
    { "^(%d+/%d+) (.+) inspired$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " надихнено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) motivated$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .." мотивовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) encouraged$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " підбадьорено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) empowered$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " посилено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) strengthened$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " посилено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) weakened$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " ослаблено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) purged$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " очищено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) redeemed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " викуплено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) consecrated$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .." освячено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) desecrated$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .." осквернено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) scouted$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " розвідано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) surveyed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " обстежено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) explored$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .." досліджено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) investigated$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " досліджено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) examined$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " оглянуто" end
        return nil
    end },
    { "^(%d+/%d+) (.+) inspected$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " оглянуто" end
        return nil
    end },
    { "^(%d+/%d+) (.+) observed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " спостережено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) patrolled$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " патрульовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) visited$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " відвідано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) discovered$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .." відкрито" end
        return nil
    end },
    { "^(%d+/%d+) (.+) uncovered$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .." розкрито" end
        return nil
    end },
    { "^(%d+/%d+) (.+) revealed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " розкрито" end
        return nil
    end },
    { "^(%d+/%d+) (.+) deciphered$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " розшифровано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) decoded$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " декодовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) translated$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " перекладено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) learned$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " вивчено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) taught$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " навчено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) trained$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " натреновано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) practiced$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .." відпрацьовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) mastered$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " опановано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) interacted$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " взаємодіяно" end
        return nil
    end },
    { "^(%d+/%d+) (.+) met$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " зустрінуто" end
        return nil
    end },
    { "^(%d+/%d+) (.+) spoken to$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .." відвідано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) contacted$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " зв'язано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) convinced$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .." переконано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) persuaded$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " переконано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) warned$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " попереджено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) informed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " повідомлено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) notified$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " сповіщено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) alerted$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " сповіщено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) reported to$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " доповіжено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) joined$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " приєднано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) recruited$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .." завербовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) enlisted$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .." завербовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) enlisted$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " завербовано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) allied$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " союзжено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) united$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .." об'єднано" end
        return nil
    end },
    { "^(%d+/%d+) (.+) equipped$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " споряджено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) armed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .." озброєно" end
        return nil
    end },
    { "^(%d+/%d+) (.+) disarmed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " роззброєно" end
        return nil
    end },
    { "^(%d+/%d+) (.+) empowered$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .." посилено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) blessed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .." благословено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) consecrated$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .." освячено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) resurrected$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .." воскресено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) revived$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " відроджено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) awakened$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " пробуджено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) enlightened$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " просвітлено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) illuminated$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " освітлено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) darkened$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .." затемнено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) shadowed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " затінено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) cleansed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .. " очищено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) sanctified$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .." освячено" end
        return nil
    end },
    { "^(%d+/%d+) (.+) hallowed$", function(count, what)
        local trWhat = tr(what)
        if trWhat ~= what then return count .. " " .. trWhat .." освячено" end
        return nil
    end },
}

local passiveRules = {
    { "^(.+) met outside of the (.+)$", "acc", "зустрінуто поза", "ins" },
    { "^(.+) met outside of (.+)$", "acc", "зустрінуто поза", "ins" },
    { "^(.+) met outside the (.+)$", "acc", "зустрінуто поза", "ins" },
    { "^(.+) met outside (.+)$", "acc", "зустрінуто поза", "ins" },
    { "^(.+) met at the (.+)$", "acc", "зустрінуто біля", "loc" },
    { "^(.+) met at (.+)$", "acc", "зустрінуто біля", "loc" },
    { "^(.+) met in the (.+)$", "acc", "зустрінуто у", "loc" },
    { "^(.+) met in (.+)$", "acc", "зустрінуто у", "loc" },
    { "^(.+) met near the (.+)$", "acc", "зустрінуто біля", "gen" },
    { "^(.+) met near (.+)$", "acc", "зустрінуто біля", "gen" },
    { "^(.+) met on the (.+)$", "acc", "зустрінуто на", "loc" },
    { "^(.+) met on (.+)$", "acc", "зустрінуто на", "loc" },
    { "^(.+) met inside (.+)$", "acc", "зустрінуто усередині", "gen" },
    { "^(.+) met$", "acc", "зустрінуто" },
    { "^(.+) spoken to in the (.+)$", "acc", "відвідано у", "loc" },
    { "^(.+) spoken to in (.+)$", "acc", "відвідано у", "loc" },
    { "^(.+) spoken to at the (.+)$", "acc", "відвідано біля", "loc" },
    { "^(.+) spoken to at (.+)$", "acc", "відвідано біля", "loc" },
    { "^(.+) spoken to near (.+)$", "acc", "відвідано біля", "gen" },
    { "^(.+) spoken to outside (.+)$", "acc", "відвідано поза", "ins" },
    { "^(.+) spoken to inside (.+)$", "acc", "відвідано усередині", "gen" },
    { "^(.+) spoken to$", "acc", "відвідано" },
    { "^(.+) found outside of the (.+)$", "acc", "знайдено поза", "ins" },
    { "^(.+) found outside of (.+)$", "acc", "знайдено поза", "ins" },
    { "^(.+) found outside the (.+)$", "acc", "знайдено поза", "ins" },
    { "^(.+) found outside (.+)$", "acc", "знайдено поза", "ins" },
    { "^(.+) found at the (.+)$", "acc", "знайдено біля", "loc" },
    { "^(.+) found at (.+)$", "acc", "знайдено біля", "loc" },
    { "^(.+) found in the (.+)$", "acc", "знайдено у", "loc" },
    { "^(.+) found in (.+)$", "acc", "знайдено у", "loc" },
    { "^(.+) found near the (.+)$", "acc", "знайдено біля", "gen" },
    { "^(.+) found near (.+)$", "acc", "знайдено біля", "gen" },
    { "^(.+) found inside (.+)$", "acc", "знайдено усередині", "gen" },
    { "^(.+) found$", "acc", "знайдено" },
    { "^(.+) encountered outside (.+)$", "acc", "зустрінуто поза", "ins" },
    { "^(.+) encountered in the (.+)$", "acc", "зустрінуто у", "loc" },
    { "^(.+) encountered in (.+)$", "acc", "зустрінуто у", "loc" },
    { "^(.+) encountered at (.+)$", "acc", "зустрінуто біля", "loc" },
    { "^(.+) encountered near (.+)$", "acc", "зустрінуто біля", "gen" },
    { "^(.+) encountered$", "acc", "зустрінуто" },
    { "^(.+) slain outside (.+)$", "acc", "вбито поза", "ins" },
    { "^(.+) slain in the (.+)$", "acc", "вбито у", "loc" },
    { "^(.+) slain in (.+)$", "acc", "вбито у", "loc" },
    { "^(.+) slain at (.+)$", "acc", "вбито біля", "loc" },
    { "^(.+) slain near (.+)$", "acc", "вбито біля", "gen" },
    { "^(.+) killed outside (.+)$", "acc", "вбито поза", "ins" },
    { "^(.+) killed in the (.+)$", "acc", "вбито у", "loc" },
    { "^(.+) killed in (.+)$", "acc", "вбито у", "loc" },
    { "^(.+) killed at (.+)$", "acc", "вбито біля", "loc" },
    { "^(.+) killed near (.+)$", "acc", "вбито біля", "gen" },
    { "^(.+) discovered in (.+)$", "acc", "відкрито у", "loc" },
    { "^(.+) discovered at (.+)$", "acc", "відкрито біля", "loc" },
    { "^(.+) discovered near (.+)$", "acc", "відкрито біля", "gen" },
    { "^(.+) discovered$", "acc", "відкрито" },
    { "^(.+) investigated in (.+)$", "acc", "досліджено у", "loc" },
    { "^(.+) investigated$", "acc", "досліджено" },
    { "^(.+) explored in (.+)$", "acc", "досліджено у", "loc" },
    { "^(.+) explored$", "acc", "досліджено" },
    { "^(.+) contacted in (.+)$", "acc", "зв'язано у", "loc" },
    { "^(.+) contacted at (.+)$", "acc", "зв'язано біля", "loc" },
    { "^(.+) contacted$", "acc", "зв'язано" },
    { "^(.+) warned about (.+)$", "acc", "попереджено про", "acc" },
    { "^(.+) warned$", "acc", "попереджено" },
    { "^(.+) informed of (.+)$", "acc", "повідомлено про", "acc" },
    { "^(.+) informed about (.+)$", "acc", "повідомлено про", "acc" },
    { "^(.+) informed$", "acc", "повідомлено" },
    { "^(.+) convinced to (.+)$", "acc", "переконано" },
    { "^(.+) convinced$", "acc", "переконано" },
    { "^(.+) persuaded to (.+)$", "acc", "переконано" },
    { "^(.+) persuaded$", "acc", "переконано" },
    { "^(.+) joined at (.+)$", "acc", "приєднано біля", "loc" },
    { "^(.+) joined in (.+)$", "acc", "приєднано у", "loc" },
    { "^(.+) joined$", "acc", "приєднано" },
    { "^(.+) consulted in (.+)$", "acc", "проконсультуйтеся з", "ins", "у", "loc" },
    { "^(.+) consulted at (.+)$", "acc", "проконсультуйтеся з", "ins", "біля", "loc" },
    { "^(.+) consulted$", "acc", "проконсультуйтеся з", "ins" },
    { "^(.+) defeated in the (.+)$", "acc", "переможено у", "loc" },
    { "^(.+) defeated in (.+)$", "acc", "переможено у", "loc" },
    { "^(.+) defeated at (.+)$", "acc", "переможено біля", "loc" },
    { "^(.+) defeated near (.+)$", "acc", "переможено біля", "gen" },
    { "^(.+) defeated outside (.+)$", "acc", "переможено поза", "ins" },
    { "^(.+) defeated$", "acc", "переможено" },
    { "^(.+) collected from the (.+)$", "acc", "зібрано від", "gen" },
    { "^(.+) collected from (.+)$", "acc", "зібрано від", "gen" },
    { "^(.+) collected in the (.+)$", "acc", "зібрано у", "loc" },
    { "^(.+) collected in (.+)$", "acc", "зібрано у", "loc" },
    { "^(.+) collected at (.+)$", "acc", "зібрано біля", "loc" },
    { "^(.+) collected$", "acc", "зібрано" },
    { "^(.+) bribed in (.+)$", "acc", "підкуплено у", "loc" },
    { "^(.+) bribed at (.+)$", "acc", "підкуплено біля", "loc" },
    { "^(.+) bribed$", "acc", "підкуплено" },
    { "^(.+) sworn in (.+)$", "acc", "присяжено у", "loc" },
    { "^(.+) sworn at (.+)$", "acc", "присяжено біля", "loc" },
    { "^(.+) sworn$", "acc", "присяжено" },
    { "^(.+) appointed in (.+)$", "acc", "призначено у", "loc" },
    { "^(.+) appointed at (.+)$", "acc", "призначено біля", "loc" },
    { "^(.+) appointed$", "acc", "призначено" },
    { "^(.+) anointed in (.+)$", "acc", "помазано у", "loc" },
    { "^(.+) anointed$", "acc", "помазано" },
    { "^(.+) ordained in (.+)$", "acc", "рукопокладено у", "loc" },
    { "^(.+) ordained$", "acc", "рукопокладено" },
    { "^(.+) honored in (.+)$", "acc", "вшановано у", "loc" },
    { "^(.+) honored at (.+)$", "acc", "вшановано біля", "loc" },
    { "^(.+) honored$", "acc", "вшановано" },
    { "^(.+) elected in (.+)$", "acc", "обрано у", "loc" },
    { "^(.+) elected$", "acc", "обрано" },
    { "^(.+) rescued from the (.+)$", "acc", "врятовано від", "gen" },
    { "^(.+) rescued from (.+)$", "acc", "врятовано від", "gen" },
    { "^(.+) rescued in (.+)$", "acc", "врятовано у", "loc" },
    { "^(.+) rescued at (.+)$", "acc", "врятовано біля", "loc" },
    { "^(.+) rescued$", "acc", "врятовано" },
    { "^(.+) freed from the (.+)$", "acc", "звільнено від", "gen" },
    { "^(.+) freed from (.+)$", "acc", "звільнено від", "gen" },
    { "^(.+) freed in (.+)$", "acc", "звільнено у", "loc" },
    { "^(.+) freed$", "acc", "звільнено" },
    { "^(.+) captured in (.+)$", "acc", "захоплено у", "loc" },
    { "^(.+) captured at (.+)$", "acc", "захоплено біля", "loc" },
    { "^(.+) captured near (.+)$", "acc", "захоплено біля", "gen" },
    { "^(.+) captured$", "acc", "захоплено" },
    { "^(.+) released in (.+)$", "acc", "звільнено у", "loc" },
    { "^(.+) released from (.+)$", "acc", "звільнено від", "gen" },
    { "^(.+) released$", "acc", "звільнено" },
    { "^(.+) returned to the (.+)$", "acc", "повернено до", "gen" },
    { "^(.+) returned to (.+)$", "acc", "повернено до", "gen" },
    { "^(.+) returned in (.+)$", "acc", "повернено у", "loc" },
    { "^(.+) returned$", "acc", "повернено" },
    { "^(.+) stolen by (.+)$", "acc", "вкрадено", "ins" },
    { "^(.+) stolen in (.+)$", "acc", "вкрадено у", "loc" },
    { "^(.+) stolen from (.+)$", "acc", "вкрадено від", "gen" },
    { "^(.+) stolen$", "acc", "вкрадено" },
    { "^(.+) recovered from the (.+)$", "acc", "відновлено від", "gen" },
    { "^(.+) recovered from (.+)$", "acc", "відновлено від", "gen" },
    { "^(.+) recovered in (.+)$", "acc", "відновлено у", "loc" },
    { "^(.+) recovered$", "acc", "відновлено" },
    { "^(.+) delivered to (.+)$", "acc", "доставлено", "dat" },
    { "^(.+) delivered in (.+)$", "acc", "доставлено у", "loc" },
    { "^(.+) delivered$", "acc", "доставлено" },
    { "^(.+) brought to (.+)$", "acc", "принесено", "dat" },
    { "^(.+) brought in (.+)$", "acc", "принесено у", "loc" },
    { "^(.+) brought$", "acc", "принесено" },
    { "^(.+) handed to (.+)$", "acc", "передано", "dat" },
    { "^(.+) handed in (.+)$", "acc", "передано у", "loc" },
    { "^(.+) handed$", "acc", "передано" },
    { "^(.+) turned in to (.+)$", "acc", "здано", "dat" },
    { "^(.+) turned in$", "acc", "здано" },
    { "^(.+) submitted to (.+)$", "acc", "подано", "dat" },
    { "^(.+) submitted$", "acc", "подано" },
    { "^(.+) reported to (.+)$", "acc", "доповіжено", "dat" },
    { "^(.+) reported at (.+)$", "acc", "доповіжено біля", "loc" },
    { "^(.+) reported in (.+)$", "acc", "доповіжено у", "loc" },
    { "^(.+) reported$", "acc", "доповіжено" },
}

local function stripCounter(text)
    return text:match("^(%d+/%d+)%s+(.+)$")
end

local function translateObjectiveLine(text)
    if type(text) ~= "string" or text == "" then return nil end

    local cached = cacheGet(text)
    if cached ~= nil then return cached end

    local optionalSuffix = ""
    local mainText = text
    local optIdx = text:find("%(Optional%)")
    if optIdx then
        optionalSuffix = " (Необов'язково)"
        mainText = text:sub(1, optIdx - 1):gsub("%s+$", "")
    end

    local count, rest = stripCounter(mainText)
    local textToMatch = rest or mainText

    local firstWord = textToMatch:match("^([%w']+)")
    local route = firstWord and patternRoutes[firstWord] or nil

    if route then
        for ri = 1, #route do
            local rule = route[ri]
            local pattern = rule[1]
            wipe(_matchBuf)
            local m1, m2, m3, m4 = textToMatch:match(pattern)
            if m1 then
                if m1 then _matchBuf[1] = m1 end
                if m2 then _matchBuf[2] = m2 end
                if m3 then _matchBuf[3] = m3 end
                if m4 then _matchBuf[4] = m4 end
                local numParts = m4 and 4 or (m3 and 3 or (m2 and 2 or 1))

                local result = rule[2]
                local i = 3
                local p = 1
                while i <= #rule and p <= numParts do
                    local prepOrCase = rule[i]
                    if p == 1 and #rule > 3 and rule[#rule] == true then
                        local case2 = rule[4]
                        local case1 = rule[3]
                        result = result .. " " .. trCase(_matchBuf[2], case1) .. " " .. prepOrCase .. " " .. trCase(_matchBuf[1], case2 or "acc")
                        p = p + 2
                        i = i + 3
                    else
                        if prepOrCase == "ins" or prepOrCase == "acc" or prepOrCase == "gen"
                        or prepOrCase == "dat" or prepOrCase == "loc" then
                            result = result .. " " .. trCase(_matchBuf[p], prepOrCase)
                            p = p + 1
                            i = i + 1
                        else
                            local nextCase = rule[i + 1]
                            if nextCase and (nextCase == "ins" or nextCase == "acc" or nextCase == "gen"
                            or nextCase == "dat" or nextCase == "loc") then
                                result = result .. " " .. prepOrCase .. " " .. trCase(_matchBuf[p], nextCase)
                                p = p + 1
                                i = i + 2
                            else
                                result = result .. " " .. prepOrCase .. " " .. trCase(_matchBuf[p], "acc")
                                p = p + 1
                                i = i + 1
                            end
                        end
                    end
                end
                if count then result = count .. " " .. result end
                result = result .. optionalSuffix
                cacheSet(text, result)
                return result
            end
        end
    end

    local defaultRoute = patternRoutes["__default"]
    if defaultRoute then
        for ri = 1, #defaultRoute do
            local rule = defaultRoute[ri]
            local m1, m2, m3, m4 = textToMatch:match(rule[1])
            if m1 then
                wipe(_matchBuf)
                _matchBuf[1] = m1; if m2 then _matchBuf[2] = m2 end; if m3 then _matchBuf[3] = m3 end; if m4 then _matchBuf[4] = m4 end
                local numParts = m4 and 4 or (m3 and 3 or (m2 and 2 or 1))
                local result = rule[2]
                local i, p = 3, 1
                while i <= #rule and p <= numParts do
                    local prepOrCase = rule[i]
                    if prepOrCase == "ins" or prepOrCase == "acc" or prepOrCase == "gen" or prepOrCase == "dat" or prepOrCase == "loc" then
                        result = result .. " " .. trCase(_matchBuf[p], prepOrCase); p = p + 1; i = i + 1
                    else
                        local nc = rule[i+1]
                        if nc and (nc=="ins" or nc=="acc" or nc=="gen" or nc=="dat" or nc=="loc") then
                            result = result .. " " .. prepOrCase .. " " .. trCase(_matchBuf[p], nc); p = p + 1; i = i + 2
                        else
                            result = result .. " " .. prepOrCase .. " " .. trCase(_matchBuf[p], "acc"); p = p + 1; i = i + 1
                        end
                    end
                end
                if count then result = count .. " " .. result end
                result = result .. optionalSuffix
                cacheSet(text, result)
                return result
            end
        end
    end

    for _, pr in ipairs(passiveRules) do
        local m1, m2 = textToMatch:match(pr[1])
        if m1 then
            local result = trCase(m1, pr[2])
            if m2 and pr[4] then
                result = result .. " " .. pr[3] .. " " .. trCase(m2, pr[4])
            elseif pr[3] then
                result = result .. " " .. pr[3]
            end
            if count then result = count .. " " .. result end
            result = result .. optionalSuffix
            cacheSet(text, result)
            return result
        end
    end

    for _, pp in ipairs(progressPatterns) do
        local pat, fn = pp[1], pp[2]
        local a1, a2, a3 = textToMatch:match(pat)
        if a1 then
            local result
            if a3 then result = fn(a1, a2, a3)
            elseif a2 then result = fn(a1, a2)
            else result = fn(a1) end
            if result then
                if count then result = count .. " " .. result end
                result = result .. optionalSuffix
                cacheSet(text, result)
                return result
            end
        end
    end

    if count then
        local trRest = tr(textToMatch)
        if trRest ~= textToMatch then
            local result = count .. " " .. trRest .. optionalSuffix
            cacheSet(text, result)
            return result
        end
    end

    cacheSet(text, false)
    return nil
end

local _prefixLookup = nil

local function buildPrefixLookup()
    if _prefixLookup then return _prefixLookup end
    if not ns.DB or not ns.DB.Lookup then return nil end
    _prefixLookup = {}
    for key, val in pairs(ns.DB.Lookup) do
        if type(key) == "string" and #key >= 30 then
            _prefixLookup[#_prefixLookup + 1] = { key, val }
        end
    end
    table.sort(_prefixLookup, function(a, b) return #a[1] > #b[1] end)
    if #_prefixLookup > 500 then
        local trimmed = {}
        for i = 1, 500 do trimmed[i] = _prefixLookup[i] end
        _prefixLookup = trimmed
    end
    return _prefixLookup
end

local function prefixTranslate(text)
    if type(text) ~= "string" or #text < 30 then return nil end
    local prefixes = buildPrefixLookup()
    if not prefixes then return nil end
    for i = 1, #prefixes do
        local key, val = prefixes[i][1], prefixes[i][2]
        if text:find(key, 1, true) then
            local escaped = key:gsub("([%^%$%(%)%%%.%[%]%*%+%-%?])", "%%%1")
            return text:gsub(escaped, val)
        end
    end
    return nil
end

local function translateFS(obj)
    if not obj or obj._wt_updating then return end
    if InCombatLockdown and InCombatLockdown() then return end
    if ns.isProtectedFrame and ns.isProtectedFrame(obj) then return end
    pcall(function()
        local text = obj:GetText()
        if type(text) ~= "string" or text == "" then return end
        local ok_cmp_tr, already = pcall(function() return obj._wt_tr == text end)
        if ok_cmp_tr and already then return end
        local ok_cmp_orig, orig_match = pcall(function() return obj._wt_orig == text end)
        if ok_cmp_orig and orig_match and obj._wt_tr then
            obj._wt_updating = true
            pcall(obj.SetText, obj, obj._wt_tr)
            obj._wt_updating = nil
            return
        end
        local translated = translateObjectiveLine(text)
        if not translated then
            translated = ns.GetTranslation and ns.GetTranslation(text)
        end
        if not translated then
            translated = prefixTranslate(text)
        end
        if not translated then return end
        local ok_cmp, same = pcall(function() return translated == text end)
        if ok_cmp and same then return end
        translated = ns.resolvePlaceholders and ns.resolvePlaceholders(translated) or translated
        obj._wt_updating = true
        pcall(obj.SetText, obj, translated)
        obj._wt_updating = nil
        obj._wt_tr = translated
        obj._wt_orig = text
    end)
end

local function iterBlocks(module)
    if not module then return function() end end
    local blocks = module.usedBlocks
    if not blocks then return function() end end
    if type(blocks.EnumerateActive) == "function" then
        return blocks:EnumerateActive()
    end
    if type(blocks) == "table" then
        local k, v
        return function()
            k, v = next(blocks, k)
            return v
        end
    end
    return function() end
end

local function translateTracker()
    if not ObjectiveTrackerFrame then return end
    for _, module in pairs(ObjectiveTrackerFrame.MODULES or {}) do
        if module.Header then
            pcall(function()
                local text = nil
                if module.Header.GetString then text = module.Header:GetString() end
                if not text and module.Header.Text and module.Header.Text.GetText then
                    text = module.Header.Text:GetText()
                end
                if not text and module.Header.Name and module.Header.Name.GetText then
                    text = module.Header.Name:GetText()
                end
                if type(text) ~= "string" or text == "" then return end
                local ok_cmp_tr, already = pcall(function() return module.Header._wt_orig == text end)
                if ok_cmp_tr and already and module.Header._wt_tr then
                    module.Header._wt_updating = true
                    module.Header:SetText(module.Header._wt_tr)
                    module.Header._wt_updating = nil
                    return
                end
                local tr = translateObjectiveLine(text) or (ns.GetTranslation and ns.GetTranslation(text)) or prefixTranslate(text)
                if tr then
                    tr = ns.resolvePlaceholders and ns.resolvePlaceholders(tr) or tr
                    local ok_cmp, same = pcall(function() return tr == text end)
                    if not (ok_cmp and same) then
                        module.Header._wt_updating = true
                        pcall(module.Header.SetText, module.Header, tr)
                        module.Header._wt_updating = nil
                        module.Header._wt_tr = tr
                        module.Header._wt_orig = text
                    end
                end
            end)
            local headerFS = module.Header.Text or module.Header.Name or module.Header.text
            if headerFS and type(headerFS) == "userdata" and headerFS.GetText then
                translateFS(headerFS)
            end
        end
        for block in iterBlocks(module) do
            if block.HeaderText then translateFS(block.HeaderText) end
            if block.lines then
                for _, line in pairs(block.lines) do
                    if line.Text then translateFS(line.Text) end
                end
            end
            if block.currentLine and block.currentLine.Text then
                translateFS(block.currentLine.Text)
            end
            for i = 1, 5 do
                local line = block["Line" .. i]
                if line and line.Text then translateFS(line.Text) end
            end
        end
    end

    local function translateTrackerHeader(header)
        if not header then return end
        pcall(function()
            local text = nil
            if header.GetString then text = header:GetString() end
            if not text and header.Text and header.Text.GetText then
                text = header.Text:GetText()
            end
            if not text and header.Name and header.Name.GetText then
                text = header.Name:GetText()
            end
            if type(text) ~= "string" or text == "" then return end
            local ok_cmp_tr, already = pcall(function() return header._wt_orig == text end)
            if ok_cmp_tr and already and header._wt_tr then
                header._wt_updating = true
                header:SetText(header._wt_tr)
                header._wt_updating = nil
                return
            end
            local tr = ns.GetTranslation and ns.GetTranslation(text)
            if not tr then tr = translateObjectiveLine(text) end
            if not tr then tr = prefixTranslate(text) end
            if tr and tr ~= text then
                tr = ns.resolvePlaceholders and ns.resolvePlaceholders(tr) or tr
                header._wt_updating = true
                pcall(header.SetText, header, tr)
                header._wt_updating = nil
                header._wt_tr = tr
                header._wt_orig = text
            end
        end)
    end

    translateTrackerHeader(ObjectiveTrackerFrame.CampaignHeader)
    translateTrackerHeader(ObjectiveTrackerFrame.ScenarioHeader)
    translateTrackerHeader(ObjectiveTrackerFrame.Header)
end

local _trackerTimerPending = false

ns.translateObjectiveLine = function(text)
    local ok, result = pcall(translateObjectiveLine, text)
    if ok then return result end
    return nil
end

local function scheduleTracker(delay)
    if _trackerTimerPending then return end
    _trackerTimerPending = true
    C_Timer.After(delay or 0.1, function()
        _trackerTimerPending = false
        translateTracker()
    end)
end

function translator:Init()
    pcall(hooksecurefunc, "ObjectiveTracker_Update", function()
        scheduleTracker(0.05)
    end)

    if ObjectiveTrackerFrame then
        pcall(hooksecurefunc, ObjectiveTrackerFrame, "Show", function()
            scheduleTracker(0.1)
        end)
    end

    local frame = CreateFrame("Frame")
    frame:RegisterEvent("QUEST_LOG_UPDATE")
    frame:RegisterEvent("QUEST_WATCH_LIST_CHANGED")
    frame:RegisterEvent("QUEST_POI_UPDATE")
    frame:RegisterEvent("SUPER_TRACKING_CHANGED")
    frame:RegisterEvent("QUEST_TURNED_IN")
    frame:RegisterEvent("SUPER_TRACKING_PATH_UPDATED")
    frame:RegisterEvent("TRACKED_ACHIEVEMENT_UPDATE")
    frame:RegisterEvent("SCENARIO_CRITERIA_UPDATE")
    frame:RegisterEvent("ZONE_CHANGED")
    frame:RegisterEvent("ZONE_CHANGED_NEW_AREA")
    frame:RegisterEvent("PLAYER_ENTERING_WORLD")
    frame:RegisterEvent("CAMPAIGN_QUEST_UPDATE")
    frame:RegisterEvent("CAMPAIGN_UPDATE")
    frame:SetScript("OnEvent", function()
        scheduleTracker(0.1)
    end)

    local function hookTrackerFontStrings()
        if not ObjectiveTrackerFrame then return end
        for _, module in pairs(ObjectiveTrackerFrame.MODULES or {}) do
            for block in iterBlocks(module) do
                if block.HeaderText and not block.HeaderText._wt_tracked then
                    block.HeaderText._wt_tracked = true
                    pcall(hooksecurefunc, block.HeaderText, "SetText", function(self, txt)
                        if self._wt_updating then return end
                        pcall(function()
                            if type(txt) ~= "string" or txt == "" then return end
                            local ok_cmp_tr, already = pcall(function() return self._wt_orig == txt end)
                            if ok_cmp_tr and already and self._wt_tr then
                                self._wt_updating = true
                                self:SetText(self._wt_tr)
                                self._wt_updating = nil
                                return
                            end
                            local tr = translateObjectiveLine(txt) or (ns.GetTranslation and ns.GetTranslation(txt))
                            if tr then
                                tr = ns.resolvePlaceholders and ns.resolvePlaceholders(tr) or tr
                                local ok_cmp, same = pcall(function() return tr == txt end)
                                if ok_cmp and same then return end
                                self._wt_updating = true
                                self:SetText(tr)
                                self._wt_updating = nil
                                self._wt_tr = tr
                                self._wt_orig = txt
                            end
                        end)
                    end)
                end
                if block.lines then
                    for _, line in pairs(block.lines) do
                        if line.Text and not line.Text._wt_tracked then
                            line.Text._wt_tracked = true
                            pcall(hooksecurefunc, line.Text, "SetText", function(self, txt)
                                if self._wt_updating then return end
                                pcall(function()
                                    if type(txt) ~= "string" or txt == "" then return end
                                    local ok_cmp_tr, already = pcall(function() return self._wt_orig == txt end)
                                    if ok_cmp_tr and already and self._wt_tr then
                                        self._wt_updating = true
                                        self:SetText(self._wt_tr)
                                        self._wt_updating = nil
                                        return
                                    end
                                    local tr = translateObjectiveLine(txt) or (ns.GetTranslation and ns.GetTranslation(txt))
                                    if tr then
                                        tr = ns.resolvePlaceholders and ns.resolvePlaceholders(tr) or tr
                                        local ok_cmp, same = pcall(function() return tr == txt end)
                                        if ok_cmp and same then return end
                                        self._wt_updating = true
                                        self:SetText(tr)
                                        self._wt_updating = nil
                                        self._wt_tr = tr
                                        self._wt_orig = txt
                                    end
                                end)
                            end)
                        end
                    end
                end
            end
        end
    end

    C_Timer.After(3, hookTrackerFontStrings)
    C_Timer.After(10, hookTrackerFontStrings)

    local hookFrame = CreateFrame("Frame")
    hookFrame:RegisterEvent("QUEST_WATCH_LIST_CHANGED")
    hookFrame:RegisterEvent("QUEST_LOG_UPDATE")
    hookFrame:SetScript("OnEvent", function()
        C_Timer.After(0.5, hookTrackerFontStrings)
    end)
end