# 1 лаба
# 1 задание
def CountNucleotides(dna):
    a = 0
    c = 0
    g = 0
    t = 0

    for symbol in dna:
        if symbol == 'A':
            a += 1
        elif symbol == 'C':
            c += 1
        elif symbol == 'G':
            g += 1
        else:
            t += 1

    return str.format("{} {} {} {}", a, c, g, t)


print(CountNucleotides(input()))

# 2 задание
def PatternCount(text, pattern):
    match = 0
    len_pattern = len(pattern)
    len_text = len(text)

    if len_pattern > len_text:
            return match

    for i in range(len_text-len_pattern+1):
        if text[i:i+len_pattern] == pattern:
            match += 1

    return match


print(PatternCount(input(), input()))


# 3 задание
def count(text, pattern):
    k = len(pattern)
    matches = 0

    for i in range(len(text)-k+1):
        if text[i:i+k] == pattern:
            matches += 1

    return matches


def frequent_words(text, k):
    k = min(len(text), k)

    patterns = set()
    matches = 0
    for i in range(len(text)-k+1):
        substr = text[i:i+k]
        cur_matches = count(text, substr)
        if matches < cur_matches:
            patterns.clear()
            matches = cur_matches

        if matches == cur_matches:
            patterns.add(substr)

    patterns = list(patterns)
    patterns.sort()
    return patterns


print(" ".join(word for word in frequent_words(input(), int(input()))))


# 4 задание
def reverse_complement(dna):
    alphabet = {'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C'}
    chars = list(dna)
    for i in range(len(chars)):
        chars[i] = alphabet[chars[i]]

    chars.reverse()
    return ''.join(chars)


print(reverse_complement(input()))


# 5 задание
def pattern_matching(text, pattern):
    k = len(pattern)
    res = []

    for i in range(len(text)-k+1):
        if text[i:i+k] == pattern:
            res.append(i)

    return res


pattern = input()
text = input()
print(' '.join(str(val) for val in pattern_matching(text, pattern)))


# 2 лаба
# 1 задание
def pattern_to_number(dna):
    res = ""
    arr = {'A': '0', 'C': '1', 'G': '2', 'T': '3'}
    for symbol in dna:
        res += arr[symbol]

    return int(res, 4)

print(pattern_to_number(input()))


# 2 задание
def convert_base(num):
    # now convert decimal to 'to_base' base
    alphabet = "0123"
    if num < 4:
        return alphabet[num]
    else:
        return convert_base(num // 4) + alphabet[num % 4]


def number_to_pattern(index, k):
    str_val = convert_base(index)
    offset = k-len(str_val)
    if offset < 0:
        return None
    str_val = ('0' * offset) + str_val

    res = ""
    arr = {'0': 'A', '1': 'C', '2': 'G', '3': 'T'}
    for symbol in str_val:
        res += arr[symbol]

    return res


arg = input()
args = arg.split(' ')
print(number_to_pattern(int(args[0]), int(args[1])))


# 3 задание
def pattern_to_number(dna):
    res = ""
    arr = {'A': '0', 'C': '1', 'G': '2', 'T': '3'}
    for symbol in dna:
        res += arr[symbol]

    return int(res, 4)


def computing_frequencies(text, k):
    frequency_array = [0] * (4**k)  # а не 4**k-1?
    for i in range(len(text)-k+1):
        pattern = text[i:i+k]
        j = pattern_to_number(pattern)
        frequency_array[j] += 1

    return frequency_array


print(' '.join(str(val) for val in computing_frequencies(input(), int(input()))))


# 4 задание
def pattern_to_number(dna):
    res = ""
    arr = {'A': '0', 'C': '1', 'G': '2', 'T': '3'}
    for symbol in dna:
        res += arr[symbol]

    return int(res, 4)


def convert_base(num):
    # now convert decimal to 'to_base' base
    alphabet = "0123"
    if num < 4:
        return alphabet[num]
    else:
        return convert_base(num // 4) + alphabet[num % 4]


def number_to_pattern(index, k):
    str_val = convert_base(index)
    offset = k-len(str_val)
    if offset < 0:
        return None
    str_val = ('0' * offset) + str_val

    res = ""
    arr = {'0': 'A', '1': 'C', '2': 'G', '3': 'T'}
    for symbol in str_val:
        res += arr[symbol]

    return res


def computing_frequencies(text, k):
    frequency_array = [0] * (4**k)
    for i in range(len(text)-k+1):
        pattern = text[i:i+k]
        j = pattern_to_number(pattern)
        frequency_array[j] += 1

    return frequency_array


def faster_frequent_words(text, k):
    f_patterns = []
    f_arr = computing_frequencies(text, k)

    max_val = f_arr[0]
    for i in range(1, len(f_arr)):
        if max_val < f_arr[i]:
            f_patterns.clear()
            max_val = f_arr[i]

        if max_val == f_arr[i]:
            f_patterns.append(number_to_pattern(i, k))

    return f_patterns


print(' '.join(str(val) for val in faster_frequent_words(input(), int(input()))))


# 5 задание
def pattern_to_number(dna):
    res = ""
    arr = {'A': '0', 'C': '1', 'G': '2', 'T': '3'}
    for symbol in dna:
        res += arr[symbol]

    return int(res, 4)


def convert_base(num):
    # now convert decimal to 'to_base' base
    alphabet = "0123"
    if num < 4:
        return alphabet[num]
    else:
        return convert_base(num // 4) + alphabet[num % 4]


def number_to_pattern(index, k):
    str_val = convert_base(index)
    offset = k-len(str_val)
    if offset < 0:
        return None
    str_val = ('0' * offset) + str_val

    res = ""
    arr = {'0': 'A', '1': 'C', '2': 'G', '3': 'T'}
    for symbol in str_val:
        res += arr[symbol]

    return res


def computing_frequencies(text, k):
    frequency_array = [0] * (4**k)
    for i in range(len(text)-k+1):
        pattern = text[i:i+k]
        j = pattern_to_number(pattern)
        frequency_array[j] += 1

    return frequency_array


def get_groups(text, k, l, t):
    clumps = []
    is_clump = [False] * (4**k)

    substr = text[0:l]
    f_arr = computing_frequencies(substr, k)
    for i in range(len(f_arr)):
        if f_arr[i] >= t:
            is_clump[i] = True

    for i in range(1, len(text)-l+1):
        first_pattern = text[i-1:i+k-1]
        f_arr[pattern_to_number(first_pattern)] -= 1

        last_pattern = text[i+l-k:i+l]
        last_index = pattern_to_number(last_pattern)
        f_arr[last_index] += 1
        if f_arr[last_index] >= t:
            is_clump[last_index] = True

    for i in range(len(is_clump)):
        if is_clump[i]:
            clumps.append(number_to_pattern(i, k))

    return clumps


arg_text = input()
args = input().split(' ')
print(' '.join(e for e in get_groups(arg_text, int(args[0]), int(args[1]), int(args[2]))))


# 3 лаба
# 1 задание
def min_skew(text):
    results = []
    _skew = 1 if (text[0] == 'G') else -1 if (text[0] == 'C') else 0
    _min = _skew
    results.append(1)

    for i in range(1, len(text)):
        char = text[i]

        _skew += 1 if (char == 'G') else -1 if (char == 'C') else 0

        if _min > _skew:
            results.clear()
            _min = _skew

        if _min == _skew:
            results.append(i+1)

    return results


print(" ".join(str(i) for i in min_skew(input())))


# 2 задание
def hamming(text1, text2):
    errors = 0
    for char1, char2 in zip(text1, text2):
        if char1 != char2:
            errors += 1

    return errors

print(hamming(input(), input()))


# 3 задание
def hamming(text1, text2):
    errors = 0
    for char1, char2 in zip(text1, text2):
        if char1 != char2:
            errors += 1

    return errors


def approximate_pattern_matching(pattern, text, d):
    res = []
    k = len(pattern)
    for i in range(len(text)-k+1):
        if hamming(text[i:i+k], pattern) <= d:
            res.append(i)

    return res


print(" ".join(str(val) for val in approximate_pattern_matching(input(), input(), int(input()))))


# 4 задания у меня нет