int TerminalNodeIcm2p::evaluate(const hand_t& hand, const int position, Game* game) const {
   std::vector<double> oldStacks = stacks; // Stacks before the hand
   std::vector<double> newStacks = oldStacks; // Stacks after the hand ended with this terminal node

   for (int i = 0; i < game->numPlayers; i++) {
      // terminalNode2p is a class from the cashgame solver
      // it computes the change in chips, not icm equity
      int change = terminalNode2p.evaluate(hand, i, game);
      newStacks[i] += change;   // compute stacks after hand
   }

   std::vector<double> oldIcm = ICM::getEquities(oldStacks, payouts); // ICM equity before hand
   std::vector<double> newIcm = ICM::getEquities(newStacks, payouts); // ICM equity after hand

   double res = newIcm[position] - oldIcm[position]; // Return change in ICM equity as the value of this terminal node

   return res;
}

#include <iostream>
using namespace std;

double getEquity(int player, int depth, int payouts, int stacks, double total, double* p_payouts, double* p_stacks)
{
   /*
      func doing the recursive ICM calculation
   */
   double eq = p_stacks[player]/total*p_payouts[depth];

   if(payouts > depth+1)
   {
      for(int j=0;j < stacks; j++)
      {
         if(j != player && p_stacks[j] > 0)
         {
            double c = p_stacks[j];

            p_stacks[j] = 0;
            eq += getEquity(player, depth+1, payouts, stacks, total-c, p_payouts, p_stacks)*c/total;
            p_stacks[j] = c;
         }
      }
   }

   return eq;
}

double getEquity(int player, int payouts, int stacks, double* p_payouts, double* p_stacks)
{
   /*
      player - player index
      payouts - amount of
      stacks - amount of
      p_payouts - pointer containing adress of the payout structure
      p_stacks - pointer containing adress of the stack size structure
   */
   double total = 0;

   for(int j=0;j<stacks;j++) total += p_stacks[j];

   return getEquity(player, 0, payouts, stacks, total, p_payouts, p_stacks);
}

int main()
{
   //-----------------------------------------------------------------------------------------------------
   // Test Examples
   //-----------------------------------------------------------------------------------------------------
   int payouts = 3, stacks = 6;
   double p_stacks[6] = {5500, 3500, 3000, 1500, 1000, 500};
   double p_payoutsSNG[3] = {0.5,0.3,0.2};
   double p_payoutsDON[3] = {0.33,0.33,0.33};
   double p_payouts1st[3] = {1,0,0};

   //SNG structure
   cout << "SNG Equities" << endl;

   for(int j=0;j<stacks;j++)
   {
      cout << "Equity stack " << j << ": " << getEquity(j, payouts, stacks, p_payoutsSNG, p_stacks) << endl;
   }

   //DON structure
   cout << "DON Equities" << endl;

   for(int j=0;j<stacks;j++)
   {
      cout << "Equity stack " << j << ": " << getEquity(j, payouts, stacks, p_payoutsDON, p_stacks) << endl;
   }

   //Winner gets all structure
   cout << "Winner gets all Equities" << endl;

   for(int j=0;j<stacks;j++)
   {
      cout << "Equity stack " << j << ": " << getEquity(j, payouts, stacks, p_payouts1st, p_stacks) << endl;
   }

   system("PAUSE");

   return 0;
}