#include <algorithm>
#include <cmath>
#include <iostream>
#include <sstream>
#include <vector>

using namespace std;

static size_t g_count, g_count_2;
static double g_sum, g_min, g_max, g_Q1, g_Q2, g_Q3, g_mean, g_variance, g_SD;

static double sum(const vector<double> &ns)
{
	for(double n : ns)
		g_sum += n;

	return g_sum;
}

static double min(const vector<double> &ns)
{
	return g_min = ns.front();
}

static double max(const vector<double> &ns)
{
	return g_max = ns.back();
}

static double range()
{
	return g_max - g_min;
}

static double midRange()
{
	return (g_max + g_min) / 2;
}

static double Q1(vector<double> ns)
{
	ns.erase(ns.begin() + g_count_2, ns.end());

	if(g_count_2 % 2 == 0)
		return g_Q1 = (ns[g_count_2 / 2] + ns[g_count_2 / 2 - 1]) / 2;
	else
		return g_Q1 = ns[g_count_2 / 2];
}

static double Q2(const vector<double> &ns)
{
	if(g_count % 2 == 0)
		return g_Q2 = (ns[g_count / 2] + ns[g_count / 2 - 1]) / 2;
	else
		return g_Q2 = ns[g_count / 2];
}

static double Q3(vector<double> ns)
{
	ns.erase(ns.begin(), ns.end() - g_count_2);

	if(g_count_2 % 2 == 0)
		return g_Q3 = (ns[g_count_2 / 2] + ns[g_count_2 / 2 - 1]) / 2;
	else
		return g_Q3 = ns[g_count_2 / 2];
}

static double IQR()
{
	return g_Q3 - g_Q1;
}

static double midHinge()
{
	return (g_Q3 + g_Q1) / 2;
}

static double AM()
{
	return g_mean = g_sum / g_count;
}

static double QM(const vector<double> &ns)
{
	double sumOfSqrs = 0;

	for(double n : ns)
		sumOfSqrs += pow(n, 2);

	return sqrt(sumOfSqrs / g_count);
}

static double GM(const vector<double> &ns)
{
	double product = 1;

	for(double n : ns)
		product *= n;

	return pow(product, 1.0 / g_count);
}

static double HM(const vector<double> &ns)
{
	double reciprocalsSum = 0;

	for(double n : ns)
		reciprocalsSum += pow(n, -1);

	return pow(reciprocalsSum / g_count, -1);
}

static double variance(const vector<double> &ns)
{
	double sumOfSqrdDevs = 0;

	for(double n : ns)
		sumOfSqrdDevs += pow(n - g_mean, 2);

	return g_variance = sumOfSqrdDevs / g_count;
}

static double SD()
{
	return g_SD = sqrt(g_variance);
}

static double RSD()
{
	return g_SD / abs(g_mean);
}

static double skewness(const vector<double> &ns)
{
	double sumOfDevs = 0;

	for(double n : ns)
		sumOfDevs += pow(n - g_mean, 3);

	return (sumOfDevs / g_count) / pow(g_SD, 3);

}

static double kurtosis(const vector<double> &ns)
{
	double sumOfDevs = 0;

	for(double n : ns)
		sumOfDevs += pow(n - g_mean, 4);

	return (sumOfDevs / g_count) / pow(g_SD, 4);
}

int main()
{
	ios::sync_with_stdio(false);
	cout.precision(15);

	string inStr;
	getline(cin, inStr);
	istringstream iss(inStr);

	double inNum;
	vector<double> inNums;

	while(iss >> inNum)
		inNums.push_back(inNum);

	g_count = inNums.size();
	g_count_2 = g_count / 2;

	if(g_count < 2)
		return 1;

	sort(inNums.begin(), inNums.end());

	cout <<                                                            '\n';
	cout << "Count:                           " << g_count          << '\n';
	cout << "Sum:                             " << sum(inNums)      << '\n';
	cout << "Minimum:                         " << min(inNums)      << '\n';
	cout << "Maximum:                         " << max(inNums)      << '\n';
	cout << "Range:                           " << range()          << '\n';
	cout << "Mid-range:                       " << midRange()       << '\n';
	cout << "1st Quartile:                    " << Q1(inNums)       << '\n';
	cout << "2nd Quartile:                    " << Q2(inNums)       << '\n';
	cout << "3rd Quartile:                    " << Q3(inNums)       << '\n';
	cout << "Interquartile Range:             " << IQR()            << '\n';
	cout << "Mid-hinge:                       " << midHinge()       << '\n';
	cout << "Arithmetic Mean:                 " << AM()             << '\n';
	cout << "Quadratic Mean:                  " << QM(inNums)       << '\n';
	cout << "Geometric Mean:                  " << GM(inNums)       << '\n';
	cout << "Harmonic Mean:                   " << HM(inNums)       << '\n';
	cout << "Variance:                        " << variance(inNums) << '\n';
	cout << "Standard Deviation:              " << SD()             << '\n';
	cout << "Relative Standard Deviation:     " << RSD()            << '\n';
	cout << "Skewness:                        " << skewness(inNums) << '\n';
	cout << "Kurtosis:                        " << kurtosis(inNums) << '\n';

	return 0;
}