#ifndef __PROGTEST__
#include <cassert>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <iostream>
#include <iomanip>
using namespace std;
#endif /* __PROGTEST__ */



class CRegister
 {
   public:
    // copy cons, op=, dtor ...
       CRegister (void);
       CRegister(const CRegister & x);

       CRegister & operator =          ( CRegister x );
       ~CRegister (void);
    bool           AddCar       ( const char      * rz,
                                  const char      * name,
                                  const char      * surname );
    bool           DelCar       ( const char      * rz );
    bool           Transfer     ( const char      * rz,
                                  const char      * nName,
                                  const char      * nSurname );
    CCarList       ListCars     ( const char      * name,
                                  const char      * surname ) const;
    int            CountCars    ( const char      * name,
                                  const char      * surname ) const;
    COwnerList     ListOwners   ( const char      * RZ ) const;
    int            CountOwners  ( const char      * RZ ) const;
    void                     SetCharAt           ( int idx, char X );

    void Print(void) const;


   private:


         struct TData
     {
                             TData               ( int reserve );
                             TData               ( const TData & src,
                                                   int reserve );
                            ~TData               ( void );
       void                  Append              ( const char * src,
                                                   int srcLen );

       int                   m_RefCnt;
       int                   m_Len;
       int                   m_Max;
       //char                * m_Str;
         char * m_name;
         char * m_surname;
         char * m_RZ;
         int majitel;
     };
    void                     append              ( const char * src, int srclen );
    void                     detach              ( int newMaxSize );


       TData *m_Cars;
       int m_CarsNr;
 };





  CRegister::TData::TData        ( int reserve )
 {
   m_RefCnt  = 1;
//   m_Len1     = strlen (rz);
//   m_Len2     = strlen (name);
//   m_Len3     = strlen (surname);
   m_Len=100;


   m_Max     = 100;
   m_name     = new char[m_Max];
   m_surname     = new char[m_Max];
   m_RZ     = new char[m_Max];
//   memcpy ( m_name, name, m_Len + 1 );
//   memcpy ( m_RZ, rz, m_Len + 1 );
//   memcpy ( m_surname, surname, m_Len + 1 );
  }
  // memcpy    ( m_name, str, m_Len + 1 );// + 1 = zero terminating character

    CRegister::TData::TData        ( const TData & src,
                                                   int reserve )
 {
   m_RefCnt    = 1;
   m_Len       = src . m_Len;
//    m_Len2       = src . m_Len2;
//     m_Len3       = src . m_Len3;
   m_Max       = reserve;
   m_name     = new char[m_Max];
   m_surname     = new char[m_Max];
   m_RZ     = new char[11];
   memcpy ( m_name, src . m_name, m_Len + 1 );
   memcpy ( m_RZ, src . m_RZ, m_Len + 1 );
   memcpy ( m_surname, src . m_surname, m_Len + 1 );
 }

    CRegister::TData::~TData       ( void )
 {
   delete [] m_name;
   delete [] m_surname;
   delete [] m_RZ;
 }

    void              CRegister::TData::Append        ( const char * src,
                                                   int srcLen )
 {
   if ( m_Len + srcLen + 1 > m_Max )
     {
       // increase the size. If m_Max is small, just increase by 10 chars
       // if m_Max is big enough, increase the size by a factor of 1.5
       while (  m_Len + srcLen + 1 > m_Max )
        m_Max += m_Max < 100 ? 10 : m_Max / 2;

       char * tmp1 = new char [m_Max];
       char * tmp2 = new char [m_Max];
       char * tmp3 = new char [m_Max];
       memcpy ( tmp1, m_name, m_Len );
       memcpy ( tmp2, m_surname, m_Len );
       memcpy ( tmp3, m_RZ, m_Len );
       memcpy ( tmp1 + m_Len, src, srcLen );
       memcpy ( tmp2 + m_Len, src, srcLen );
       memcpy ( tmp3 + m_Len, src, srcLen );
       delete [] m_name;
       delete [] m_surname;
       delete [] m_RZ;// safe even if m_Str == src (can be the case of a += a)
       m_name = tmp1;
       m_surname = tmp2;
       m_RZ = tmp3;
     }
    else
     memcpy ( m_name + m_Len, src, srcLen );
     memcpy ( m_surname + m_Len, src, srcLen );
     memcpy ( m_RZ + m_Len, src, srcLen );
   //m_Len += srcLen;
   m_name[m_Len] = 0;
   m_surname[m_Len] = 0;
   m_RZ[m_Len] = 0;
 }


    CRegister::CRegister            ( void )
 {
   m_Cars           = new TData ( 1000 );
 }
     CRegister::CRegister             ( const CRegister & x )
 {
   m_Cars = x . m_Cars;
   m_Cars -> m_RefCnt ++;
 }
           CRegister::~CRegister           ( void )
 {
   if ( -- m_Cars -> m_RefCnt == 0 ) delete m_Cars;
 }

           CRegister         & CRegister::operator =          ( CRegister x )
 {
   swap ( m_Cars, x . m_Cars );
   return *this;
 }


           //-------------------------------------------------------------------------------------------------
void               CRegister::SetCharAt           ( int idx, char X )
 {
   if ( idx < 0 || idx >= m_Cars -> m_Len )
    throw "index out of range";

   detach ( m_Cars -> m_Max );
   m_Cars -> m_name[idx] = X;
   m_Cars -> m_surname[idx] = X;
   m_Cars -> m_RZ[idx] = X;
 }
//-------------------------------------------------------------------------------------------------
void               CRegister::append              ( const char * src,
                                                   int srcLen )
 {
   detach ( m_Cars -> m_Len + srcLen + 1 );
   m_Cars -> Append ( src, srcLen );
 }
//-------------------------------------------------------------------------------------------------
void               CRegister::detach              ( int newMaxSize )
 {
   if ( m_Cars -> m_RefCnt > 1 )
    {
      TData * tmp = new TData ( *m_Cars, newMaxSize );
      m_Cars -> m_RefCnt --;
      m_Cars = tmp;
    }
 }

 //-----------------------------------------------------------------------------
    bool           CRegister::AddCar       ( const char      * rz,
                                  const char      * name,
                                  const char      * surname )
    {
        for ( int i=0; i<m_CarsNr; i++ )
            if ( m_Cars[i] . m_RZ == rz )
                return ( false );



        memcpy ( m_Cars [m_CarsNr] . m_RZ, rz, strlen(rz)+1 );
        memcpy ( m_Cars [m_CarsNr] . m_name, name, strlen(name)+1 );
        memcpy ( m_Cars [m_CarsNr] . m_surname, surname, strlen(surname)+1 );

//              m_Cars [m_CarsNr] . m_RZ     = rz;
//              m_Cars [m_CarsNr] . m_name   = name;
//              m_Cars [m_CarsNr] . m_surname   = surname;
              m_Cars[m_CarsNr].majitel = 1;
              m_CarsNr++;

              return true;


    }