class Bolsa {
public:
    int Esta(int i); // # de veces que "i" Está() en la Bolsa
    void Agrega(int i);  // incrementa "Esta(i)"
//  ...
}; // Bolsa

// lab11.cpp  (c) 2000 adolfo@di-mare.com

/*  resultado:
    Este programa implementa y usa la clase Bolsa para contar
    números.
    - La implementaci›n se hace usando una lista con punteros.
*/

#include <iostream> // #include <iostream.h>
#include <climits>
#include <bool.h>

class ostream;

class Bolsa {
    class nodo {
        nodo *_next;  // apuntador al siguiente nodo
        long  _val;   // valor almacenado
        int   _cont;  // cantidad de veces que _val está en la bolsa
        friend class Bolsa;
    }; // nodo
public:
    Bolsa() : _prm(0) {}
    int  Esta(long n); // # de veces que "i" Est () en la Bolsa
    void Agrega(long i);   // incrementa "Esta(i)"
    void Graba(ostream&);  // graba todos los valores
private:
    nodo *_prm; // primer nodo de la lista
}; // Bolsa


void Bolsa::Agrega(long n) {
/*  resultado
    Agrega el valor "n" a la bolsa. Si ya estaba, se
    incremente en uno el valor que "Esta()" retorna.
*/
    Bolsa::nodo *p, *q;  // "q" va detr s de "p"
    p = _prm;  // p = this->_prm;

    // recorre la lista para encontrar el valor "n"
    while (p !=0) {
        q = p;  // recuerda el anterior

        if (n == p->_val) { // lo encontró
            (p->_cont)++;
            return;
        }
        p = p->_next;
    }

    // crea un nuevo nodo para "n"
    Bolsa::nodo *nuevo = new Bolsa::nodo;
    nuevo->_val  = n;
    nuevo->_cont = 1;
    nuevo->_next = 0;

    // enlaza el nodo
    if (_prm == 0) {
        _prm = nuevo; // agrega el primer nodo de la lista
    }
    else {
        q->_next = nuevo;  // conecta después del último nodo
    }
    return;
} // Bolsa::Agrega()


int Bolsa::Esta(long n) {
/*  resultado
    Retorna la cantidad de veces que el valor "n" ha sido
    agregado a la bolsa.
    - Retorna cero si "n" nunca ha sido agregado.
*/
    Bolsa::nodo *p;  // "p" recorre la lista
    p = this->_prm;  // p = _prm;

    // recorre la lista para encontrar el valor "n"
    while (p !=0) {
        if (n == p->_val) { // lo encontró
            return p->_cont;
        }
        p = p->_next;
    }
    return 0;
} // Bolsa::Esta()

void Bolsa::Graba(ostream& COUT) {
/*  resultado
    Graba todos los valores almacenados en la bolsa,
    en orden creciente. */

    for (long n=0; n<LONG_MAX; ++n) {
        if (0 != Esta(n)) {
            COUT << n << " está " << Esta(n);
            COUT << " veces en al bolsa" << endl;
        }
    }
} // Bolsa::Graba()


int main() {
    Bolsa B;
    long n;

    // lee todos los valores
    while (cin >> n) {
        B.Agrega(n);
    }

    // despliega los valores
    B.Graba(cout);

    return 0;
} // main()

// EOF: lab11.cpp