---

# Задача 1
celsius_list = list(map(float, input().split()))
fahrenheit_list = [round(c * 1.8 + 32, 1) for c in celsius_list]
print(*fahrenheit_list)

# Задача 2
words = input().split()
filtered_words = [word for word in words if len(word) > 5]
print(*filtered_words)

# Задача 3
raw_names = input().split(',')
formatted_names = [name.strip().capitalize() for name in raw_names if name.strip()]
print(", ".join(formatted_names))

# Задача 4
numbers = list(map(int, input().split()))
squared_positives = [x**2 for x in numbers if x > 0]
print(*squared_positives)

# Задача 5
n = int(input())
points = []
for _ in range(n):
    x, y = map(float, input().split())
    points.append((x, y))
points.sort(key=lambda p: (p[0]**2 + p[1]**2))
for x, y in points:
    print(int(x) if x.is_integer() else x, int(y) if y.is_integer() else y)

# Задача 6
total_sum = 0
with open("matrix.txt", "r", encoding="utf-8") as f:
    for line in f:
        nums = list(map(int, line.split()))
        total_sum += sum(nums)
print(total_sum)

# Задача 7
n = int(input())
for _ in range(n):
    row = list(map(int, input().split()))
    if sum(row) % 2 == 0:
        print(*row)

# Задача 8
with open("data.txt", "r", encoding="utf-8") as f:
    for line in f:
        cleaned = line.strip()
        if cleaned:
            print(cleaned)

# Задача 9
vowels = set("аеёиоуыэюяАЕЁИОУЫЭЮЯ")
n, m = map(int, input().split())
for _ in range(n):
    row = input().split()
    row_sorted = sorted(row, key=lambda w: sum(1 for char in w if char in vowels))
    print(*row_sorted)

# Задача 10
with open("table.txt", "r", encoding="utf-8") as f:
    matrix = [list(map(float, f_line.split())) for f_line in f if f_line.strip()]
if matrix:
    num_cols = len(matrix[0])
    col_sums = [sum(row[j] for row in matrix) for j in range(num_cols)]
    col_sums_formatted = [int(s) if s.is_integer() else s for s in col_sums]
    print(*col_sums_formatted)

# Задача 11
import statistics

max_median = float('-inf')
best_line = -1
with open("scores.txt", "r", encoding="utf-8") as f:
    for line_idx, line in enumerate(f, start=1):
        if line.strip():
            scores = list(map(int, line.split()))
            med = statistics.median(scores)
            if med > max_median:
                max_median = med
                best_line = line_idx
print(best_line)

# Задача 12
n = int(input())
matrix = [list(map(int, input().split())) for _ in range(n)]
for i in range(n):
    if matrix[i][0] > matrix[i][i]:
        print(*matrix[i])

# Задача 13
response_times = []
with open("server.log", "r", encoding="utf-8") as f:
    for line in f:
        parts = [p.strip() for p in line.split("|")]
        if len(parts) == 3:
            code = parts[1]
            time_ms = float(parts[2])
            if code == "200":
                response_times.append(time_ms)
if response_times:
    print(round(sum(response_times) / len(response_times), 2))

# Задача 14
matrix = []
with open("input_grid.txt", "r", encoding="utf-8") as f:
    for line in f:
        if line.strip():
            matrix.append(list(map(int, line.split())))
n = len(matrix)
for i in range(n):
    row = []
    for j in range(n):
        if j == i or j == n - 1 - i:
            row.append(matrix[i][j] ** 2)
        else:
            row.append(0)
    print(*row)

# Задача 15
candidates = []
with open("results.txt", "r", encoding="utf-8") as f:
    for line in f:
        if line.strip():
            parts = line.strip().split(";")
            name_parts = parts[0].split()
            surname = name_parts[0]
            scores = list(map(int, parts[1:]))
            total = sum(scores)
            candidates.append((total, surname, parts[0]))
candidates.sort(key=lambda x: (-x[0], x[1]))
for cand in candidates[:3]:
    print(f"{cand[2]}: {cand[0]}")

# Задача 16
with open("payload.txt", "r", encoding="utf-8") as f:
    for line in f:
        cleaned = line.strip()
        if len(cleaned) >= 10:
            print(f"{cleaned[:5]}...{cleaned[-5:]}")

# Задача 17
cleaned_matrix = []
with open("raw_matrix.txt", "r", encoding="utf-8") as f:
    for line in f:
        if line.strip():
            row = []
            for val in line.split():
                if val == "NA" or not val.lstrip('-').isdigit():
                    row.append(0)
                else:
                    row.append(int(val))
            cleaned_matrix.append(row)
for row in cleaned_matrix:
    print(*row)

# Задача 18
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]
min_in_row = [min(row) for row in matrix]
max_in_col = [max(matrix[i][j] for i in range(n)) for j in range(m)]

for i in range(n):
    for j in range(m):
        val = matrix[i][j]
        if val == min_in_row[i] and val == max_in_col[j]:
            print(f"({i}, {j}) = {val}")

# Задача 19
stopwords = {"и", "в", "на", "с", "по", "что"}
words = []
with open("story.txt", "r", encoding="utf-8") as f:
    text = f.read()
    raw_words = text.split()
    for w in raw_words:
        cleaned = "".join(c for c in w if c.isalnum()).lower()
        if cleaned and cleaned not in stopwords:
            words.append(cleaned)
words.sort(key=lambda x: (-len(x), x))
print(*words)

# Задача 20*
matrix = []
with open("input_matrix.txt", "r", encoding="utf-8") as f:
    for line in f:
        if line.strip():
            matrix.append(list(map(int, line.split())))
n = len(matrix)
m = len(matrix[0]) if n > 0 else 0
rotated = [[matrix[n - 1 - i][j] for i in range(n)] for j in range(m)]
for row in rotated:
    print(*row)

# Задача 21*
image = []
with open("image.txt", "r", encoding="utf-8") as f:
    for line in f:
        if line.strip():
            image.append(list(map(int, line.split())))
n = len(image)
m = len(image[0]) if n > 0 else 0
blurred = [[0] * m for _ in range(n)]
for i in range(n):
    for j in range(m):
        neighbors = []
        for di in (-1, 0, 1):
            for dj in (-1, 0, 1):
                ni, nj = i + di, j + dj
                if 0 <= ni < n and 0 <= nj < m:
                    neighbors.append(image[ni][nj])
        blurred[i][j] = round(sum(neighbors) / len(neighbors))
for row in blurred:
    print(*row)

# Задача 22*
balances = {}
with open("transactions.txt", "r", encoding="utf-8") as f:
    for line in f:
        parts = line.strip().split()
        if len(parts) == 3:
            user_id, op_type, amount_str = parts
            try:
                amount = float(amount_str)
                if amount > 0:
                    if user_id not in balances:
                        balances[user_id] = 0.0
                    if op_type == "IN":
                        balances[user_id] += amount
                    elif op_type == "OUT":
                        balances[user_id] -= amount
            except ValueError:
                continue

positive_balances = [(uid, bal) for uid, bal in balances.items() if bal > 0]
positive_balances.sort(key=lambda x: -x[1])
for uid, bal in positive_balances:
    formatted_bal = int(bal) if bal.is_integer() else bal
    print(f"{uid}: {formatted_bal}")

# Задача 23*
events = []
with open("events.txt", "r", encoding="utf-8") as f:
    for line in f:
        if line.strip():
            parts = line.strip().rsplit(" ", 1)
            name = parts[0]
            times = parts[1].split("-")
            start = times[0]
            end = times[1]
            events.append((name, start, end))

events.sort(key=lambda x: x[2])
selected = []
last_end = "00:00"
for name, start, end in events:
    if start >= last_end:
        selected.append(name)
        last_end = end

for name in selected:
    print(name)

# Задача 24*
matrix = []
with open("matrix.txt", "r", encoding="utf-8") as f:
    for line in f:
        if line.strip():
            matrix.append(list(map(int, line.split())))

n = len(matrix)
is_magic = True
all_elements = [elem for row in matrix for elem in row]

if len(all_elements) != len(set(all_elements)):
    is_magic = False
else:
    target_sum = sum(matrix[0])
    for row in matrix:
        if sum(row) != target_sum:
            is_magic = False
            break
    if is_magic:
        for j in range(n):
            if sum(matrix[i][j] for i in range(n)) != target_sum:
                is_magic = False
                break
    if is_magic:
        if sum(matrix[i][i] for i in range(n)) != target_sum:
            is_magic = False
    if is_magic:
        if sum(matrix[i][n - 1 - i] for i in range(n)) != target_sum:
            is_magic = False

print("YES" if is_magic else "NO")

# Задача 25*
n = int(input())
matrix = [[0] * n for _ in range(n)]
top, bottom, left, right = 0, n - 1, 0, n - 1
val = 1
while top <= bottom and left <= right:
    for j in range(left, right + 1):
        matrix[top][j] = val
        val += 1
    top += 1
    for i in range(top, bottom + 1):
        matrix[i][right] = val
        val += 1
    right -= 1
    if top <= bottom:
        for j in range(right, left - 1, -1):
            matrix[bottom][j] = val
            val += 1
        bottom -= 1
    if left <= right:
        for i in range(bottom, top - 1, -1):
            matrix[i][left] = val
            val += 1
        left += 1

def is_prime(num):
    if num < 2:
        return False
    for d in range(2, int(num**0.5) + 1):
        if num % d == 0:
            return False
    return True

primes = []
for row in matrix:
    for x in row:
        if is_prime(x):
            primes.append(x)

primes.sort(reverse=True)
print(*primes)

# Задача 26*
grid = []
with open("grid.txt", "r", encoding="utf-8") as f:
    for line in f:
        if line.strip():
            grid.append(list(map(int, line.split())))

n = len(grid)
m = len(grid[0]) if n > 0 else 0
next_grid = [[0] * m for _ in range(n)]

for i in range(n):
    for j in range(m):
        live_neighbors = 0
        for di in (-1, 0, 1):
            for dj in (-1, 0, 1):
                if di == 0 and dj == 0:
                    continue
                ni, nj = i + di, j + dj
                if 0 <= ni < n and 0 <= nj < m and grid[ni][nj] == 1:
                    live_neighbors += 1
        if grid[i][j] == 1:
            if live_neighbors in (2, 3):
                next_grid[i][j] = 1
            else:
                next_grid[i][j] = 0
        else:
            if live_neighbors == 3:
                next_grid[i][j] = 1

for row in next_grid:
    print(*row)

# Задача 27*
terrain = []
with open("terrain.txt", "r", encoding="utf-8") as f:
    for line in f:
        if line.strip():
            terrain.append(list(map(int, line.split())))

max_len = -1
max_val = float('-inf')
best_info = None

for line_idx, row in enumerate(terrain):
    if not row:
        continue
    i = 0
    while i < len(row):
        j = i
        while j < len(row) and row[j] == row[i]:
            j += 1
        length = j - i
        val = row[i]
        start_idx = i
        end_idx = j - 1
        if length > max_len or (length == max_len and val > max_val):
            max_len = length
            max_val = val
            best_info = (line_idx + 1, start_idx, end_idx, val)
        i = j

if best_info:
    print(f"Строка {best_info[0]}, индексы {best_info[1]}-{best_info[2]}, высота {best_info[3]}")

# Задача 28*
word_docs = {}
with open("files_list.txt", "r", encoding="utf-8") as f:
    file_names = [line.strip() for line in f if line.strip()]

for fname in file_names:
    try:
        with open(fname, "r", encoding="utf-8") as doc:
            text = doc.read()
            raw_words = text.split()
            unique_words = set("".join(c for c in w if c.isalnum()).lower() for w in raw_words)
            for w in unique_words:
                if w:
                    word_docs[w] = word_docs.get(w, 0) + 1
    except FileNotFoundError:
        continue

sorted_words = sorted(word_docs.items(), key=lambda x: (-x[1], x[0]))
for word, count in sorted_words:
    print(f"{word}: {count}")

# Задача 29*
key_matrix = []
with open("key.txt", "r", encoding="utf-8") as f:
    for line in f:
        if line.strip():
            key_matrix.append(list(map(int, line.split())))

k = len(key_matrix)
with open("secret.txt", "r", encoding="utf-8") as f:
    text = f.read()

ascii_codes = [ord(c) for c in text]
while len(ascii_codes) % k != 0:
    ascii_codes.append(32)

encrypted = []
for i in range(0, len(ascii_codes), k):
    block = ascii_codes[i:i + k]
    for row in key_matrix:
        dot_product = sum(row[j] * block[j] for j in range(k))
        encrypted.append(dot_product)

print(*encrypted)

# Задача 30*
points = []
with open("points.txt", "r", encoding="utf-8") as f:
    for line in f:
        if line.strip():
            parts = line.replace("[", "").replace("]", "").replace(",", " ").split()
            if len(parts) >= 2:
                points.append((float(parts[0]), float(parts[1])))

centroids = []
with open("centroids.txt", "r", encoding="utf-8") as f:
    for line in f:
        if line.strip():
            parts = line.replace("[", "").replace("]", "").replace(",", " ").split()
            if len(parts) >= 2:
                centroids.append((float(parts[0]), float(parts[1])))

clusters = [[] for _ in range(len(centroids))]
for px, py in points:
    best_dist = float('inf')
    best_c_idx = 0
    for c_idx, (cx, cy) in enumerate(centroids):
        dist = (px - cx) ** 2 + (py - cy) ** 2
        if dist < best_dist:
            best_dist = dist
            best_c_idx = c_idx
    clusters[best_c_idx].append((px, py))

new_centroids = []
for c_idx, group in enumerate(clusters):
    if group:
        avg_x = sum(pt[0] for pt in group) / len(group)
        avg_y = sum(pt[1] for pt in group) / len(group)
        new_centroids.append((avg_x, avg_y))
    else:
        new_centroids.append(centroids[c_idx])

for cx, cy in new_centroids:
    formatted_x = int(cx) if cx.is_integer() else round(cx, 2)
    formatted_y = int(cy) if cy.is_integer() else round(cy, 2)
    print(f"[{formatted_x}, {formatted_y}]")