using System;
using System.Collections.Generic;
using System.Linq;
using AaDS.Combinatorics;

// Номер 7
/*var splits = Console.ReadLine()!.Split(" ", StringSplitOptions.RemoveEmptyEntries);
int n = int.Parse(splits[0]);
int k = int.Parse(splits[1]);

const int MOD = 998244353;

var nums = Console.ReadLine()!.Split().Select(int.Parse).ToArray();

var listPairs = GeneratePairs(nums);
int[] pairsSum = listPairs.Select(pair => pair.first + pair.second).ToArray();

for (int i = 1; i <= k; i++)
{
    long currentSum = 0;
    for (int j = 0; j < pairsSum.Length; j++)
    {
        currentSum += (long)Math.Pow(pairsSum[j], i) % MOD;
    }
    Console.WriteLine(currentSum % MOD);
}

(int first, int second)[] GeneratePairs(IList<int> elements)
{
    int count = elements.Count;
    List<(int first, int second)> result = new List<(int first, int second)>();

    for (int i = 0; i < count - 1; i++)
    {
        for (int j = i + 1; j < count; j++)
        {
            result.Add((elements[i], elements[j]));
        }
    }

    return result.ToArray();
}*/

// Номер 6

// Ввод данных
/*int n = int.Parse(Console.ReadLine()!);
(int x, int y)[] points = new (int, int)[n];

for (int i = 0; i < n; i++)
{
    var splits = Console.ReadLine()!.Split(" ", StringSplitOptions.RemoveEmptyEntries);
    points[i] = (int.Parse(splits[0]), int.Parse(splits[1]));
}

int maxTriangles = 0;
var used = new bool[n]; // Массив для отслеживания использованных точек

    // Проверка всех троек точек
for (int i = 0; i < n - 2; i++)
{
    for (int j = i + 1; j < n - 1; j++)
    {
        for (int k = j + 1; k < n; k++)
        {
            if (!used[i] && !used[j] && !used[k] &&
                IsNonDegenerate(points[i], points[j], points[k]))
            {
                used[i] = true;
                used[j] = true;
                used[k] = true;
                maxTriangles++;
            }
        }
    }
}

Console.WriteLine(maxTriangles);

bool IsNonDegenerate((int x, int y) p1, (int x, int y) p2, (int x, int y) p3)
{
    // Вычисляем определитель для трех точек
    int det = p1.x * (p2.y - p3.y) + p2.x * (p3.y - p1.y) + p3.x * (p1.y - p2.y);
    return det != 0; // Если определитель не равен нулю, то треугольник невырожденный
}*/

// Номер 5


//Номер 4
/*string[] splits = Console.ReadLine()!.Split(" ", StringSplitOptions.RemoveEmptyEntries);

int n = int.Parse(splits[0]);
ulong x = ulong.Parse(splits[1]);
ulong y = ulong.Parse(splits[2]);
ulong z = ulong.Parse(splits[3]);


ulong[] nums = Console.ReadLine()!.Split().Select(ulong.Parse).ToArray();

(ulong minX, int index) xTuple = (ulong.MaxValue, -1);
(ulong minY, int index) yTuple = (ulong.MaxValue, -1);
(ulong minZ, int index) zTuple = (ulong.MaxValue, -1);

for (int i = 0; i < nums.Length; i++)
{
    var diffX = CalculateDifference(nums[i], x);
    var diffY = CalculateDifference(nums[i], y);
    var diffZ = CalculateDifference(nums[i], z);

    if (xTuple.minX > diffX)
    {
        xTuple.minX = diffX;
        xTuple.index = i;
    }

    if (yTuple.minY > diffY)
    {
        yTuple.minY = diffY;
        yTuple.index = i;
    }

    if (zTuple.minZ > diffZ)
    {
        zTuple.minZ = diffZ;
        zTuple.index = i;
    }
}

if (xTuple.index == yTuple.index && yTuple.index == zTuple.index)
{
    Console.WriteLine(xTuple.minX);
}
else if (xTuple.index == yTuple.index)
{
    Console.WriteLine(xTuple.minX + zTuple.minZ);
}
else if (yTuple.index == zTuple.index)
{
    Console.WriteLine(xTuple.minX + yTuple.minY);
}
else if (xTuple.index == zTuple.index)
{
    Console.WriteLine(xTuple.minX + yTuple.minY);
}
else
{
    Console.WriteLine(xTuple.minX + yTuple.minY + zTuple.minZ);
}

ulong CalculateDifference(ulong divider, ulong division)
{
    return divider % division > division - (divider % division)
        ? division - (divider % division)
        : divider % division;
}*/

// Номер 3
/*string[] splits = Console.ReadLine()!.Split(" ", StringSplitOptions.RemoveEmptyEntries);

int n = int.Parse(splits[0]);
int m = int.Parse(splits[1]);

int[] schedule = Console.ReadLine()!.Split().Select(int.Parse).ToArray();
int firstDay = schedule[0];
int secondDay = schedule[1];

int minGood = Math.Min(firstDay, secondDay);
int maxGood = Math.Max(firstDay, secondDay);

int goodDays = 0;
int changes = 0;

int[] adjustments = new int[n];

for (int i = 2; i < n; i++)
{
    var currentTime = schedule[i];
    if (currentTime >= minGood && currentTime <= maxGood)
    {
        goodDays++;
    }
    else
    {
        if (currentTime < minGood)
            adjustments[i] = minGood - currentTime;
        else
            adjustments[i] = currentTime - maxGood;
    }
}

if (goodDays >= m)
{
    Console.WriteLine(0);
    return;
}

Array.Sort(adjustments);

for (int i = 0; i < n && goodDays < m; i++)
{
    if (adjustments[i] > 0)
    {
        changes += adjustments[i];
        goodDays++;
    }
}

Console.WriteLine(changes);*/

// Номер 2
/*int n = int.Parse(Console.ReadLine()!);

ulong[] days = new ulong[n];

for (int i = 0; i < days.Length; i++)
{
    days[i] = ulong.Parse(Console.ReadLine()!);
    var powers = GetPowersOfTwo(days[i]);

    if (powers.Count < 3)
    {
        Console.WriteLine(-1);
    }
    else
    {
        Console.WriteLine(powers[0] + powers[1] + powers[2]);
    }
}

List<ulong> GetPowersOfTwo(ulong budget)
{
    List<ulong> powers = new List<ulong>();

    for (int i = 63; i > -1; i--)
    {
        ulong power = 1UL << i;
        if (budget >= power)
        {
            powers.Add(power);
            budget -= power;
        }
    }

    return powers;
}*/

// Номер 1
/*
Dictionary<char, int> dictionary = new Dictionary<char, int>();

string s = Console.ReadLine()!;

for (int i = 0; i < s.Length; i++)
{
    dictionary[s[i]] = i;
}

Console.WriteLine(dictionary['R'] < dictionary['M'] ? "Yes" : "No");
*/