#include <fstream.h>
#include <stdlib.h>
#include <iomanip.h>
#include <string.h>   // for strlen, strcpy
#include <math.h>   // for sqrt, pow, M_PI etc
#include "AdamsConst.h"
//#include <dos.h>     // for sleep
//#include <conio.h>  // for clrscr
//------------------------- constants ---------------------------

//const int zero=0;
//const int one=1;
//const int two=2;
//const int  buf=200;
//const char quit='¬' ;


template <class T> class item {  // template for members of a list
public:
        T *i;
        item<T> *prev;
        item<T> *next;
        item() {i=zero; prev=zero; next=zero;}
        ~item() {
                //if (prev) {prev->next = next;}
                //if (next) {next->prev = prev;}
                if (i) delete i;
                i=zero; prev=zero; next=zero;
                }
};

template <class T> class list{  // template for a list
public:
        item<T> *root;
        list() { root=zero; len=zero; }

        void grow(T *i) { //add element in item
		item<T> *temp=root; root= new item<T>;	root->next=temp;
                if(temp) temp->prev=root; root->i=i   ; len++;
	  }

      unsigned int len;
      item<T>* tail() {
		item<T>* p=root; if (!p) return zero; //empty list
		while (p->next) p=p->next;
		return p;
		}
      void clear() {  if (!root) return;
               len=zero;
        			item<T> *p=root;
               if (!p) return ; // nothing to del
		while (p!=root) {
      		item<T>* q=p;
                        p=p->prev;
                        delete q; q=0;}  // while (p!=root);
                len = 0;}
      ~list() {clear();}
        item<T>* get(int k) {
                item<T>* p=tail(); int c=zero;
                while (c++<k) { if (p->prev) p=p->prev; }
                return p;  }
        T& operator [] (int i) {return get(i)->i; }
        bool operator = (list* s) {return false; }
        bool operator < (T s) {return false; }
        list<T>& operator = (const char &c) { return *this;} // fix for clear in row
        void remove(int k) {
                item<T> *r = get(k);
                if (len == 0) {return;}
                if (len == 1) {
                        len = 0;
                        delete r; r=0;
                        root = 0;
                        //delete this;
                        //*this = new list<T>;
                        return;
                        }
                if (k != 0) { r->next->prev = r->prev;   // has a next
                }else{ r->prev->next = 0; }
                if (k+1 < len) { r->prev->next = r->next;  // has a previous
                }else{ r->next->prev = 0; root = r->next;}
                len--; delete r; r=0;
                }

        //virtual bool selectitem(unsigned int id);

};


template <class T> class row  {
   unsigned int n;
   T* p;
public: row(int x):n(x) { on=1; p=new T [n];  }
	bool on;
   void clear()  { for (unsigned int c=zero;c<n;c++) { p[c]=zero;}}

   int no() {return n;}
   ~row() { if (!on) delete [] p; }
   void del() { delete [] p; }
   T& operator [] (int i) {return p[i];}
   row<T> *xcopy(){
        row<T> *cpto = new row<T>(no());
        for (unsigned int c=zero;c<no();c++) { (*cpto)[c] = (*this)[c];}
        return cpto;
   }
};


template <class S> class arry  {
   int nrows,ncols;
   row <S> **p;
public:
      bool on;
		arry(int r,int c):nrows(r),ncols(c) {
		on=zero;
      p=new row<S> *[nrows];
		for (int i=zero;i<nrows;i++) {p[i]=new row<S>(ncols);}}
            int nr() {return nrows;}
	~arry() { if (!on) { delete [] p; }
   	 }
   del() { for (int i=zero;i<nrows;i++) delete [] p; }
	row<S> operator [] (int i) {return *p[i];}
   };

 /*  ostream& operator << (ostream& s,list<unsigned int> &n)  {
      for (int c=zero;c<n.len;c++) { s<<' '<<n[c];}

      s<<'\n';
      return s;
       }             */


// AnsiString remove spaces;