#include <iostream.h> 
#include <string.h> 
const double pi = 3.14159;
class box {
  public: double height, width, length;
    // Default constructor:
    box ( ) { }
    // Argument-bearing constructor:
    box (double h, double w, double l) {
      height = h; width = w; length = l;
    }
    // Volume member function:
    double volume ( ) {
      return height * width * length;
    }
};
class cylinder {
  public: double radius, length;
    // Default Constructor:
    cylinder ( ) { }
    // Argument-bearing constructor:
    cylinder (double r, double l) {
      radius = r; length = l;
    }
    // Volume member function:
    double volume ( ) {
      return pi * radius * radius * length;
    }
};
class railroad_car {
  public: char *serial_number;
          // Constructors:
          railroad_car ( ) { }
          railroad_car (char *input_buffer) {
            // Create new array just long enough:
            serial_number = new char[strlen(input_buffer) + 1];
            // Copy string into new array:
            strcpy (serial_number, input_buffer);
          }
          // Other:
          virtual char* short_name ( ) {return "rrc";}
          virtual double capacity ( ) {return 0.0;}
};
class box_car : public railroad_car, public box {
  public: // Constructors:
          box_car ( ) : box (10.5, 9.5, 40.0) { }
          box_car (char *input_buffer) : railroad_car (input_buffer),
                                   box (10.5, 9.5, 40.0)
            { }
          // Displayers:
          virtual char* short_name ( ) {
            return "box";
          }
          virtual double capacity ( ) {
            return volume ( );
          }
};
class tank_car : public railroad_car, public cylinder {
  public: // Constructors:
          tank_car ( ) : cylinder (3.5, 40.0) { }
          tank_car (char *input_buffer) : railroad_car (input_buffer),
                                    cylinder (3.5, 40.0)
            { }
          // Displayers:
          virtual char* short_name ( ) {
            return "tnk";
          }
          virtual double capacity ( ) {
            return volume ( );
          }
};
class engine : public railroad_car {
  public: engine ( ) { }
          // New:
          engine (char *input_buffer) : railroad_car (input_buffer) { }
          virtual char* short_name ( ) {
            return "eng";
          }
};
class caboose : public railroad_car {
  public: caboose ( ) { }
          caboose (char *input_buffer) : railroad_car (input_buffer) { }
          virtual char* short_name ( ) {
            return "cab";
          }
};
// Define list classes:
template <class link_parameter>
class link {
  friend class header<link_parameter>;
  friend class iterator<link_parameter>;
  private:
    link *next_link_pointer;
    link_parameter *element_pointer;
    link (link_parameter *e, link *l) {
      element_pointer = e;
      next_link_pointer = l;
    }
};
template <class header_parameter>
class header {
  friend class iterator<header_parameter>;
  public:
    header ( ) {
      first_link_pointer = NULL;
    }
    void add (header_parameter *new_element) {
      first_link_pointer =
        new link<header_parameter> (new_element, first_link_pointer);
    }
  private:
    link<header_parameter> *first_link_pointer;
};
template <class iterator_parameter>
class iterator {
  public:
    iterator (header<iterator_parameter>& header) {
      first_link_pointer = header.first_link_pointer;
      current_link_pointer = first_link_pointer;
    }
    iterator_parameter* access ( ) {
      return current_link_pointer -> element_pointer;
    }
    void advance ( ) {
      current_link_pointer = current_link_pointer -> next_link_pointer;
    }
    int endp ( ) {
      return ! current_link_pointer;
    }
    void reset ( ) {
      current_link_pointer = first_link_pointer;
    }
  private: link<iterator_parameter>* current_link_pointer;
           link<iterator_parameter>* first_link_pointer;
};
// Define list header:
header<railroad_car> train;
char input_buffer[100];
enum {eng_code = 'E', box_code = 'B', tnk_code = 'T', cab_code = 'C'};
char extract_car_code (char *input_buffer) {return input_buffer[4];}
main ( ) {
  for (; cin >> input_buffer;) 
    switch (extract_car_code (input_buffer)) {
      case eng_code: train.add (new engine (input_buffer));   break;
      case box_code: train.add (new box_car (input_buffer));  break;
      case tnk_code: train.add (new tank_car (input_buffer)); break;
      case cab_code: train.add (new caboose (input_buffer));  break;
    }
  // Define and initialize iterator class object:
  iterator<railroad_car> train_iterator (train);
  // Iterate:
  train_iterator.reset ( );
  for (; !train_iterator.endp ( ) ; train_iterator.advance ( )) 
    // Display number, short name, and capacity and terminate the line: 
    cout << train_iterator.access ( ) -> serial_number << "     "
         << train_iterator.access ( ) -> short_name ( ) << "     "
         << train_iterator.access ( ) -> capacity ( ) << endl;
}