#ifndef SIMANN_H

 #ifndef LEMON_SIMANN_H

 #define SIMANN_H

 #define LEMON_SIMANN_H

 #ifndef INFTY

 namespace lemon {

 #define INFTY 1e24

 #endif

 #include <iostream>

   const double INFTY = 1e24;

 class SimAnnBase {

   class SimAnnBase {

 public:

   friend class Controller;

   class Controller {

     SimAnnBase *sab;

     class Controller;

     double T;

   private:

     void init(SimAnnBase *_sab) { sab = _sab; }

     Controller *controller;

     bool next() {}

   protected:

     bool accept(double cost) {}

     double curr_cost;

   };

     double prev_cost;

 protected:

     double best_cost;

   double CurrCost;

   double PrevCost;

   double BestCost;

   long Iter;

     virtual void mutate() = 0;

   long LastImpr;

     virtual void revert() = 0;

     virtual void saveAsBest() = 0;

   //friend class Controller;

   public:

   Controller *Ctrl;

     SimAnnBase() {

 public:

       curr_cost = prev_cost = best_cost = INFTY;

   long getIter() { return Iter; }

     }

   long getLastImpr() { return LastImpr; }

     void setController(Controller &_controller) { controller = &_controller; }

   double getBestCost() { return BestCost; }

     double getBestCost() { return best_cost; }

   virtual void mutate() = 0;

     void run() {

   virtual void revert() = 0;

       while (controller->next()) {

   virtual void saveAsBest() = 0;

         mutate();

   virtual void init() = 0;

         if (controller->accept(prev_cost - curr_cost)) {

           controller->acceptEvent();

   void run() {

           if (curr_cost < best_cost) {

     init();

             saveAsBest();

     while (Ctrl->next()) {

             controller->improveEvent();

       Iter++;

           }

       std::cout << Iter << std::endl;

         }

       mutate();

         else {

       if (Ctrl->accept(PrevCost - CurrCost) && (CurrCost < BestCost)) {

           revert();

 	LastImpr = Iter;

           controller->rejectEvent();

         saveAsBest();

         }

       }

       else {

         revert();

 template <typename E>

     class Controller {

 class SimAnn : public SimAnnBase {

     public:

 private:

       virtual void acceptEvent() {}

   E *CurrEnt;

       virtual void improveEvent() {}

   E *PrevEnt;

       virtual void rejectEvent() {}

   E *BestEnt;

       virtual bool next() = 0;

 public:

       virtual bool accept(double cost_diff) = 0;

   SimAnn() {

     };

     CurrCost = PrevCost = BestCost = INFTY;

   };

     Iter = LastImpr = 0;

   }

   void setController(Controller &_Ctrl) { Ctrl = &_Ctrl; }

   void setEnt(E &Ent) {

     CurrEnt = new E(Ent);

     PrevEnt = new E(Ent);

     BestEnt = new E(Ent);

   }

   E getBestEnt() { return *BestEnt; }

   void mutate() {

     *PrevEnt = *CurrEnt;

     PrevCost = CurrCost;

     CurrCost = CurrEnt->mutate();

   }

   void revert() {

     E *tmp = CurrEnt;

     CurrEnt = PrevEnt;

     PrevEnt = tmp;

     CurrCost = PrevCost;

   }

   void saveAsBest() {

     *BestEnt = *CurrEnt;

     BestCost = CurrCost;

   }

   void init() {

     Ctrl->init(this);

     CurrEnt->init();

   }

 };

 class EntitySkeleton {

   template <typename E>

 public:

   class SimAnn : public SimAnnBase {

   void init() {}

   private:

   // returns the new cost

     E *curr_ent;

   double mutate() { return 0.0; }

     E *prev_ent;

 };

     E *best_ent;

   public:

     SimAnn() : SimAnnBase() {}

     void setEntity(E &Ent) {

       curr_ent = new E(Ent);

       prev_ent = new E(Ent);

       best_ent = new E(Ent);

     }

     E getBestEntity() { return *best_ent; }

     void mutate() {

       *prev_ent = *curr_ent;

       prev_cost = curr_cost;

       curr_cost = curr_ent->mutate();

     }

     void revert() {

       E *tmp = curr_ent;

       curr_ent = prev_ent;

       prev_ent = tmp;

       curr_cost = prev_cost;

     }

     void saveAsBest() {

       *best_ent = *curr_ent;

       best_cost = curr_cost;

     }

   };

   class EntitySkeleton {

   public:

     // returns the new cost

     double mutate() { return 0.0; }

   };

   template <typename E>

   class SimAnn2 : public SimAnnBase {

   private:

     E *curr_ent;

     E *best_ent;

   public:

     SimAnn2() : SimAnnBase() {}

     void setEntity(E &Ent) {

       curr_ent = new E(Ent);

       best_ent = new E(Ent);

     }

     E getBestEntity() { return *best_ent; }

     void mutate() {

       curr_ent->mutate();

     }

     void revert() {

       curr_ent->revert();

     }

     void saveAsBest() {

       *best_ent = *curr_ent;

       best_cost = curr_cost;

     }

   };

   class EntitySkeleton2 {

   public:

     // returns the new cost

     double mutate() { return 0.0; }

     // restores the entity to its previous state i.e. reverts the effects of

     // the last mutate()

     void revert() {}

   };

 }