#define _USE_MATH_DEFINES

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

class Figure
{
public:
    virtual double get_square() const = 0;

    virtual ~Figure() = default;
};

class Circle : public Figure
{
private:
    double r = 0;
public:
    Circle(double r) : r(r) {}

    static Circle *make(const std::string &str)
    {
        std::stringstream ss;
        ss << str;
        double r;
        ss >> r;
        Circle *tmp = new Circle(r);
        return tmp;
    }

    double get_square() const override
    {
        return r * r * M_PI;
    }
};

class Rectangle : public Figure
{
private:
    double a = 0;
    double b = 0;
public:
    Rectangle(double a, double b) : a(a), b(b) {}

    static Rectangle *make(const std::string &str)
    {
        std::stringstream ss;
        ss << str;
        double a, b;
        ss >> a >> b;
        Rectangle *tmp = new Rectangle(a, b);
        return tmp;
    }

    double get_square() const override
    {
        return a * b;
    }
};

class Square : public Figure
{
private:
    double a = 0;
public:
    explicit Square(double a) : a(a) {}

    static Square *make(const std::string &str)
    {
        std::stringstream ss;
        ss << str;
        double a = 0;
        ss >> a;
        Square *tmp = new Square(a);
        return tmp;
    }

    double get_square() const override
    {
        return a * a;
    }
};


class FigCreator
{
public:
    virtual Figure *create(const std::string &str) = 0;

    virtual ~FigCreator() = default;
};

class CircleCreator : public FigCreator
{
public:
    Figure *create(const std::string &str) override
    {
        return Circle::make(str);
    }

};

class RectangleCreator : public FigCreator
{
public:
    Figure *create(const std::string &str) override
    {
        return Rectangle::make(str);
    }
};

class SquareCreator : public FigCreator
{
public:
    Figure *create(const std::string &str) override
    {
        return Square::make(str);
    }
};


class AbstractFactory
{
public:

    static AbstractFactory &factory_instance()//Создаю синглтон - объект, к которому можно обращаться через
    {                                         //AbstractFactory::factory_instance()
        static AbstractFactory s;
        return s;
    }

    Figure *create(const std::string &type, const std::string &params)//Просто функция, создающая объекты поклассов
    {                                                                 // Figure
        return disc[type]->create(params);
    }

private:
    std::map<std::string, FigCreator *> disc = {//FigCreator - это некий абстрактый класс, который выступает в роли абстрактного класса
            {"C", new CircleCreator()},         //для классов-создателей круга, квадрата и прямоугольника(код их очень прост)
            {"S", new SquareCreator()},
            {"R", new RectangleCreator()},
    };

    AbstractFactory() = default;

    ~AbstractFactory()
    {
        for (auto &c:disc) {// надо правильно удалить map, потому что его значения выделены в динамической памяти
            delete c.second;
        }
    }

    AbstractFactory(AbstractFactory const &) = delete;

    AbstractFactory &operator=(AbstractFactory const &) = delete;
};

int main()
{
    std::vector<Figure *> figures;
    std::string tmp;
    while (!std::getline(std::cin, tmp).eof()) {
        std::stringstream s;
        s << tmp;
        std::string type, param1, param2;
        s >> type >> param1 >> param2;
        figures.push_back(AbstractFactory::factory_instance().create(type, param1 + " " + param2));
    }

    std::stable_sort(figures.begin(), figures.end(),
                     [](Figure *a, Figure *b) { return a->get_square() < b->get_square(); });

    for (auto &c:figures) {
        std::cout << c->to_string() << std::endl;
        delete c;
    }
}