#include <bits/stdc++.h>

#include <utility>

using namespace std;

class ASCIIString {
public:
    ASCIIString();

    ASCIIString(basic_string<char> other);

    operator string();

    ASCIIString& operator += (const ASCIIString& other);

    void reverse(size_t lpos, size_t rpos);

    ASCIIString lastGreaterSecuence(size_t count);

    ASCIIString lastLessSecuence(size_t count);

    ASCIIString firstLessSecuence(size_t count);

    void capitaliseVowels();

    void capitaliseConsonants();

    void vowelsIntoHex();

    void romanDigits();

    void reverse();

    void reverseInWords();

    size_t vowels();

    size_t consonants();

    char minLetter();

    char maxLetter();

    void changeRegister();

    bool isPalindrome();

    size_t digits();

    size_t letters();

    map<char, int> dictOfElements();

    map<char, int> dictOfDigits();

    int sumOfDigits();

    size_t numberOfPunctuations();

    size_t posSubstring(ASCIIString sub);

    vector<size_t> positionsSubstring(ASCIIString sub);

    size_t numberOfWords();

    size_t numberOfNumbers();

    bool isRightBracketSecuence();

    ASCIIString palindromeString();

    ASCIIString capitalWords();

    ASCIIString digitsString();

    pair<ASCIIString, ASCIIString> notInThese(const ASCIIString &first, const ASCIIString &second);

    ASCIIString intersectionString(const ASCIIString &first, const ASCIIString &second);

    ASCIIString unionString(const ASCIIString &first, const ASCIIString &second);

private:
    string s;
};

ASCIIString::ASCIIString() {
    s = "";
}

ASCIIString::ASCIIString(basic_string<char> other) {
    s = std::move(other);
}

ASCIIString::operator string() {
    return s;
}

ASCIIString &ASCIIString::operator+=(const ASCIIString& other) {
    s += other.s;
    return *this;
}

void ASCIIString::reverse(size_t lpos, size_t rpos) {
    while (lpos < rpos) {
        swap(s[lpos++], s[rpos--]);
    }
}

ASCIIString ASCIIString::lastGreaterSecuence(size_t count) {
    if (count > s.size()) {
        return string();
    }

    int cnt = 0;
    for (int j = s.size() - 2; j >= s.size() - count; --j) {
        if (s[j] <= s[j + 1]) {
            cnt++;
        }
    }

    for (int i = s.size() - count; i >= 0; --i) {
        if (cnt == 0) {
            return s.substr(i, count);
        }
        if (i) {
            cnt += s[i - 1] <= s[i];
            cnt -= s[i + count - 2] <= s[i + count - 1];
        }
    }
    return string();
}

ASCIIString ASCIIString::lastLessSecuence(size_t count) {
    if (count > s.size()) {
        return string();
    }

    int cnt = 0;
    for (int j = s.size() - 2; j >= s.size() - count; --j) {
        if (s[j] >= s[j + 1]) {
            cnt++;
        }
    }

    for (int i = s.size() - count; i >= 0; --i) {
        if (cnt == 0) {
            return s.substr(i, count);
        }
        if (i) {
            cnt += s[i - 1] >= s[i];
            cnt -= s[i + count - 2] >= s[i + count - 1];
        }
    }
    return string();
}

ASCIIString ASCIIString::firstLessSecuence(size_t count) {
    if (count > s.size()) {
        return string();
    }

    int cnt = 0;
    for (int j = 0; j + 1 < count; ++j) {
        if (s[j] >= s[j + 1]) {
            cnt++;
        }
    }

    for (int i = 0; i + count - 1 < s.size(); ++i) {
        if (cnt == 0) {
            return s.substr(i, count);
        }
        if (i + count < s.size()) {
            cnt += s[i + count] >= s[i + count - 1];
            cnt -= s[i] >= s[i - 1];
        }
    }
    return string();
}

void ASCIIString::capitaliseVowels() {
    for (auto &i : s) {
        if (isalpha(i)) {
            i = static_cast<char>(toupper(i));
        }
    }
}

void ASCIIString::capitaliseConsonants() {
    for (auto &i : s) {
        if (isalpha(i)) {
            i = static_cast<char>(tolower(i));
        }
    }
}

string hex(char c) {
    std::stringstream sstream;
    sstream << std::hex << static_cast<int>(c);

    return sstream.str();
}

void ASCIIString::vowelsIntoHex() {
    string upd;

    for (auto &i : s) {
        char cur = tolower(i);
        set<int> vowels = {'a', 'e', 'y', 'i', 'o', 'u'};
        if (vowels.find(cur) != vowels.end()) {
            upd += hex(i);
        } else {
            upd += i;
        }
    }

    s = std::move(upd);
}

string roman(char c) {
    int cur = c - '0';

    switch (cur) {
        case 1:
            return "1";
        case 2:
            return "11";
        case 3:
            return "111";
        case 4:
            return "15";
        case 5:
            return "5";
        case 6:
            return "51";
        case 7:
            return "511";
        case 8:
            return "5111";
        case 9:
            return "110";
    }
}

void ASCIIString::romanDigits() {
    string upd;

    for (auto &i : s) {
        if (isdigit(i) && i != '0') {
            upd += roman(i);
        } else {
            upd += i;
        }
    }

    s = std::move(upd);
}

void ASCIIString::reverse() {
    reverse(0, s.size() - 1);
}

void ASCIIString::reverseInWords() {
    int lb = 0, rb = 0;

    while (lb < s.size()) {
        while (rb < s.size() && isalpha(s[rb])) {
            ++rb;
        }
        reverse(lb, rb - 1);
        lb = rb;
    }
}

size_t ASCIIString::vowels() {
    set<int> vowels = {'a', 'e', 'i', 'o', 'u', 'y'};

    int cnt = 0;
    for (auto i : s) {
        i = tolower(i);
        if (vowels.count(i)) {
            ++cnt;
        }
    }
    return cnt;
}

size_t ASCIIString::consonants() {
    set<int> consonants = {'B', 'C', 'D', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'X', 'Z'};

    int cnt = 0;
    for (auto i : s) {
        i = toupper(i);
        if (consonants.count(i)) {
            ++cnt;
        }
    }
    return cnt;
}

char ASCIIString::minLetter() {
    char ans = numeric_limits<char>::max();
    for (auto i : s) {
        ans = min(ans, i);
    }
    return ans;
}

char ASCIIString::maxLetter() {
    char ans = 0;
    for (auto i : s) {
        ans = max(ans, i);
    }
    return ans;
}

void ASCIIString::changeRegister() {
    for (auto &i : s) {
        if (islower(i)) {
            i = toupper(i);
        } else if (isupper(i)) {
            i = tolower(i);
        }
    }
}

bool ASCIIString::isPalindrome() {
    for (int i = 0; i < s.size(); ++i) {
        if (s[i] != s[s.size() - i - 1]) {
            return false;
        }
    }
    return true;
}

size_t ASCIIString::digits() {
    int cnt = 0;
    for (auto i : s) {
        if (isdigit(i)) {
            ++cnt;
        }
    }
    return cnt;
}

size_t ASCIIString::letters() {
    int cnt = 0;
    for (auto i : s) {
        if (isalpha(i)) {
            ++cnt;
        }
    }
    return cnt;
}

map<char, int> ASCIIString::dictOfElements() {
    map<char, int> cnt;

    for (auto i : s) {
        ++cnt[i];
    }

    return cnt;
}

map<char, int> ASCIIString::dictOfDigits() {
    map<char, int> cnt;

    for (auto i : s) {
        if (isdigit(i)) {
            ++cnt[i];
        }
    }

    return cnt;
}

int ASCIIString::sumOfDigits() {
    int sum = 0;

    for (auto i : s) {
        if (isdigit(i)) {
            sum += i;
        }
    }

    return sum;
}

size_t ASCIIString::numberOfPunctuations() {
    size_t cnt = 0;

    for (auto i : s) {
        if (i == ',' || i == '.' || i == '?' || i == '!') {
            ++cnt;
        }
    }

    return cnt;
}

vector<size_t> ASCIIString::positionsSubstring(ASCIIString sub) {
    string cur = sub.s + '#' + s;

    vector<int> z (cur.size());
    for (int i = 1, l = 0, r = 0; i < cur.size(); ++i) {
        if (i <= r) {
            z[i] = min(r - i + 1, z[i - l]);
        }
        while (i+z[i] < cur.size() && cur[z[i]] == cur[i+z[i]]) {
            ++z[i];
        }
        if (i+z[i]-1 > r) {
            l = i, r = i + z[i] - 1;
        }
    }

    vector<size_t> ans;
    for (int i = 0; i + sub.s.size() + 1 < cur.size(); ++i) {
        if (z[i + sub.s.size() + 1] == sub.s.size()) {
            ans.push_back(i);
        }
    }
    return ans;
}

size_t ASCIIString::posSubstring(ASCIIString sub) {
    auto ans = positionsSubstring(sub);
    return ans.empty() ? -1 : ans[0];
}

size_t ASCIIString::numberOfWords() {
    int lb = 0, rb = 0, cnt = 0;

    while (lb < s.size()) {
        while (rb < s.size() && isalpha(s[rb])) {
            ++rb;
        }
        lb = rb;
        ++cnt;
    }
    return cnt;
}

bool ASCIIString::isRightBracketSecuence() {
    int bln = 0;

    for (auto i : s) {
        if (i == '(') {
            ++bln;
        } else if (i == ')') {
            --bln;
        }
        if (bln < 0) {
            return false;
        }
    }
    return bln == 0;
}

size_t ASCIIString::numberOfNumbers() {
    int lb = 0, rb = 0, cnt = 0;

    while (lb < s.size()) {
        while (rb < s.size() && isdigit(s[rb])) {
            ++rb;
        }
        lb = rb;
        ++cnt;
    }
    return cnt;
}

ASCIIString ASCIIString::palindromeString() {
    ASCIIString ans;

    int lb = 0, rb = 0, cnt = 0;

    while (lb < s.size()) {
        while (rb < s.size() && isalpha(s[rb])) {
            ++rb;
        }
        if (ASCIIString(s.substr(lb, rb - 1)).isPalindrome()) {
            ans += s.substr(lb, rb - 1);
        }

        lb = rb;
        ++cnt;
    }

    return ans;
}

ASCIIString ASCIIString::capitalWords() {
    ASCIIString ans;

    int lb = 0, rb = 0, cnt = 0;

    while (lb < s.size()) {
        while (rb < s.size() && isalpha(s[rb])) {
            ++rb;
        }
        if (lb < rb && isupper(s[lb])) {
            ans += s.substr(lb, rb - 1);
        }

        lb = rb;
        ++cnt;
    }

    return ans;
}

ASCIIString ASCIIString::digitsString() {
    ASCIIString ans;

    int lb = 0, rb = 0, cnt = 0;

    while (lb < s.size()) {
        while (rb < s.size() && isdigit(s[rb])) {
            ++rb;
        }
        if (lb < rb) {
            ans += s.substr(lb, rb - 1);
        }

        lb = rb;
        ++cnt;
    }

    return ans;
}

pair<ASCIIString, ASCIIString> ASCIIString::notInThese(const ASCIIString &first, const ASCIIString &second) {
    ASCIIString f_ans, s_ans;

    for (char c = 0; c <= numeric_limits<char>::max(); ++c) {
        if (!first.s.contains(c)) {
            f_ans += string(&"" [c]);
        }
    }

    for (char c = 0; c <= numeric_limits<char>::max(); ++c) {
        if (!second.s.contains(c)) {
            s_ans += string(&"" [c]);
        }
    }

    return {f_ans, s_ans};
}

ASCIIString ASCIIString::intersectionString(const ASCIIString &first, const ASCIIString &second) {
    map<char, int> cl, cr;

    for (auto i : first.s) {
        ++cl[i];
    }
    for (auto i : second.s) {
        ++cr[i];
    }

    ASCIIString ans;
    for (auto i : cl) {
        if (cr[i.first]) {
            ans += string(&"" [ i.first]);
        }
    }
    return ans;
}

ASCIIString ASCIIString::unionString(const ASCIIString &first, const ASCIIString &second) {
    map<char, int> cl, cr;

    for (auto i : first.s) {
        ++cl[i];
    }
    for (auto i : second.s) {
        ++cr[i];
    }

    ASCIIString ans;
    for (auto i : cl) {
        ans += string(&"" [ i.first]);
    }
    for (auto i : cr) {
        if (!cl[i.first]) {
            ans += string(&""[i.first]);
        }
    }
    return ans;
}

int32_t main() {
    ASCIIString lol ("dc");
}