EV=0

For each outcome, J {

  // Make a temp copy of Stack[] and AmountStaked[] arrays to use below.

  // Assign each player their "finishing rank" for this outcome.

  // Share out side pot.
  Loop {

    // Find he smallest amount staked.
    MinAmountStaked=INF
    For each player with AmountStaked[I]>0, I
      MinAmountStaked=Min(MinAmountStaked,AmountStaked[I])

    // Create the side-pot.
    CurrentPot=0
    For each player with AmountStaked[I]>0, I {
      AmountStaked[I]-=MinAmountStaked
      CurrentPot+=MinAmountStaked
    }

    // Test if we are done.
    // NOTE: The last side-pot will just be the biggest stack geting his excess chips returned.
    If CurrentPot==0, we are done so break from the loop.

    // Share out the pot based on the hand rank of each player.
    NumHandWinners=0
    BestHand=INF
    For each player with money in CurrentPot, I {
      if (FinishingRank[I]<BestHand) {
        NumHandWinners=1;
        BestHand=FinishingRank[I];
      }
      else if (HandValue[I]==BestHand) 
        NumHandWinners++;
    }

    // Now lets give the player the share of the pot they need.
    For each player with money in CurrentPot, I {
      if (FinishingRank[I]==BestHand)
        Stack[I]+=CurrentPot/NumHandWinners;
    }

  }

  // Calculate ICM for this stack and weight by the chance of the outcome.
  EV+=ICM(Stack,PlayerIndex)*ChanceOfOutcome[J][Hand1][Hand2][Hand3]

}

// ***************************************************************************
// *                                  INCLUDES                               *
// ***************************************************************************

#include "../core/misc.h"
#include "../core/random_number_generator.h"

#include "../holdem_game_state.h"
#include "../holdem_game_state_with_history.h"
#include "../holdem_hole_card_ranking.h"
#include "../sng_icm_calculator.h"
#include "../holdem_parser.h"

#include "../party_nl_holdem_sng_parser.h"

// ***************************************************************************
// *                                  CONSTANTS                              *
// ***************************************************************************

// Define this to just examine our all-in hands from our perspective.
#define HERO_HANDS_ONLY

// Define this to only look at the 2/3-way all-in from a single randomly chose player's perspective.
// NOTE: Can't use this with HERO_HANDS_ONLY.
//#define RANDOM_PLAYER_PERPECTIVE

// Define this to read all folders again and again in a loop. Thius is usedful for use with
// RANDOM_PLAYER_PERPECTIVE to get an idea of the level of sample variance to expect from
// just doing a single pass (useful for plots, but no good for results...).
//#define REPEAT_LOOP_ALL_FOLDERS

// Set this to >1 to print less data (for plotting, etc).
#define FILE_OUTPUT_INTERVAL 1

// ===========================================================================

void BackTestAllInLuck(const char** Folders,const int NumFolders)
{	

	// The parser we are going to use.
	PartyNLHoldemSNGParser Parser;

	// The vector of hands we get from the parser.
	vector<HoldemGameStateWithHistory> Hands;

	// This is what we use to get the EV at the end of the hand.
	SNG_ICM_Calculator ICM;

	// These are the possible finish rankings for each outcome.
	const int TwoWayFinishRanking[3][2]={{1,1},{1,2},{2,1}};
	const int ThreeWayFinishRanking[13][3]={{1,1,1},{1,1,2},{1,2,1},{1,2,2},{1,2,3},{1,3,2},{2,1,2},
	                                        {2,2,1},{2,1,3},{2,3,1},{2,1,1},{3,1,2},{3,2,1}};

	// These hold the outcomes for each 2-way and 3-way hand matchup.
	static double TwoWayOutcomeChances[3][169][169];
	static double ThreeWayOutcomeChances[13][169][169][169];

	// The sum of differences from our predicted EV.
	double SumPrizeEquityDifferences=0.0;
	double SumChipEquityDifferences=0.0;

	// The number of SNGs we have played.
	int NumSNGs=0;

	// The number of 2-way, 3-way and multi-way data-points seperately.
	int Num2WayAllIns=0;
	int Num3WayAllIns=0;
	int NumMultiWayAllIns=0;										// We don't deal with these atm.

	// The number fo data-points we have used.
	// NOTE: This can be 2x or 3x the number of all-ins, as we can (if asked) take a data-point from
	//       multiple player's perspectives.
	int NumDataPoints=0;

	// The last tourney number.
	char LastTournamentNumber[BUFFER_SIZE+1];
	LastTournamentNumber[0]=0;

	// Use for reading in the outcome look files.
	int H1,H2,H3;
	double Outcome;

	// Open and read each line of the HU data file.
	// NOTE: Inversed as HoldemHoleCardRanking::GetIndex() uses AA in top left, A2s top right, etc.
	ifstream InFile1;
	InFile1.open("HU_HandEval.dat");
	if (InFile1.fail())
		Error(FATAL,"Could not load the 'HU_HandEval.dat'");
	while (InFile1 >> H1 >> H2) {
		for (int I=0;I<3;I++)
			InFile1 >> TwoWayOutcomeChances[I][168-H1][168-H2];
	}
	InFile1.close();

	// Open and read each line of the HU data file.
	// NOTE: Inversed as HoldemHoleCardRanking::GetIndex() uses AA in top left, A2s top right, etc.
	ifstream InFile2;
	InFile2.open("3WAY_HandEval.dat");
	if (InFile2.fail())
		Error(FATAL,"Could not load '3WAY_HandEval.dat'.");
	while (InFile2 >> H1 >> H2 >> H3) {
		for (int I=0;I<13;I++)
			InFile2 >> ThreeWayOutcomeChances[I][168-H1][168-H2][168-H3];
	}
	InFile2.close();

	// Open the output file.
	ofstream Outfile;
	Outfile.open("luck_results.csv");
	if (Outfile.fail())
		Error(FATAL,"Could not open 'luck_restults.csv'");

	// Lets do it on each folder.
	for (int Folder=0;Folder<NumFolders;Folder++) {

		// Lets try and get the first vector of hands.
		Parser.InitHandHistorySearcher(Folders[Folder]);
		while (Parser.SearchForAndParseNextHandHistoryFile(Hands,true)==true) {

			// Lets keep going until we get no more.
			for (int I=0;I<Hands.size();I++) {

				// Is this a new tournament number?
				if (strcmp(LastTournamentNumber,Hands[I].GetTournamentNumber())!=0) {
					NumSNGs++;
					strcpy_s(LastTournamentNumber,BUFFER_SIZE,Hands[I].GetTournamentNumber());
				}

				// If we have gone from pre-flop to river, then this is an all-in hand.
				if (Hands[I].GetNumStates()>=2
					&& Hands[I].GetCurrentGameStage()==RIVER
					&& Hands[I][Hands[I].GetNumStates()-2].GetCurrentGameStage()==PRE_FLOP
					&& Hands[I].GetTotalInHandCurrently()>=2) {

					// This is the number of all-in players we are dealing with here.
					int NumAllInPlayers=Hands[I].GetTotalInHandCurrently();

					// This is the index of each of the players who are left.
					int PlayerIndex[10];	// ### Only use the first 3, but need 10 incase we start to sim for 4+ players...
					int NumValidShowdownHands=0;

					// The (temp) "finishing rank" assigned depending on outcome.
					int PlayersFinishingRank[10];

					// This holds the rank indexes (0..168) for the player's hand.
					int PlayerHandType[10];

					// The stacks for each player at the start and end of hand.
					int StackAtStartOfHand[10];
					int StackAtEndOfHand[10];

					// These are used to temporailty sim the outcomes.
					int CurrentStacks[10];
					int CurrentStakes[10];
					bool InHandCurrently[10];

					// The actaul EV from the start to end of hand.
					double ActualPrizeEquity,ActualChipEquity;

					// Expected average EV based on the hand matchup.
					double ExpectedPrizeEquity;
					double ExpectedChipEquity;

					// If asked to look at the hands from our perspective only. and we're not here, then skip.
					#ifdef HERO_HANDS_ONLY
					if (Hands[I].GetOurSeatIndex()==NO_SEAT)
						continue;
					#endif

					// @@@@@@@@@@@@@@ Don't really need this @@@@@@@@@@@@@@@@@@@@@
					// Lets make sure that 1 or both players are all-in.
					int NumNonAllInPlayers=0;
					for (int J=0;J<10;J++) {
						if (Hands[I].IsInHandCurrently(J)==true && Hands[I].GetCurrentStack(J)!=0)
							NumNonAllInPlayers++;
					}
					if (NumNonAllInPlayers>1) {
						Error(WARNING,"Non all-in hand (should not get here...).");
						continue;
					}
					// @@@@@@@@@@@@@@ Don't really need this @@@@@@@@@@@@@@@@@@@@@

					// If the player is in the hand currently and his cards are known, then lets count him and get his seat index.
					for (int J=0;J<10;J++) {
						if (Hands[I].IsInHandCurrently(J)==true && Hands[I].GetShowdownHoleCard(J,0).Rank!=RANK_NONE) {
							PlayerIndex[NumValidShowdownHands]=J;
							PlayerHandType[J]=HoldemHoleCardRanking::GetIndex((Hands[I].GetShowdownHoleCard(J,0).Suit*13)+Hands[I].GetShowdownHoleCard(J,0).Rank,
																			  (Hands[I].GetShowdownHoleCard(J,1).Suit*13)+Hands[I].GetShowdownHoleCard(J,1).Rank);
							NumValidShowdownHands++;	// One more.
						}
					}

					// If we don't have cards for all the players at the end then skip this hand.
					if (NumValidShowdownHands!=NumAllInPlayers)
						continue;

					// Lets work out the stacks at the start/end of the hand.
					for (int K=0;K<10;K++) {
						StackAtStartOfHand[K]=0;
						StackAtEndOfHand[K]=0;
					}
					for (int K=0;K<10;K++) {
						if (Hands[I].WasInHandAtStartOfHand(K)==true) {
							StackAtStartOfHand[K]=Hands[I].GetStackAtStartOFHand(K);
							StackAtEndOfHand[K]=Hands[I].GetCurrentStack(K)+Hands[I].GetUnCalledBets(K)+Hands[I].GetAmountWon(K);
						}
					}

					// Check we have not lost any chips.
					// #### NOTE: This happens for truncated HH files where their is no "wins" line...
					int TotalChipsStart=0;
					int TotalChipsEnd=0;
					for (int K=0;K<10;K++) {
						TotalChipsStart+=StackAtStartOfHand[K];
						TotalChipsEnd+=StackAtEndOfHand[K];
					}
					if (TotalChipsStart!=TotalChipsEnd) {
						Error(WARNING,Hands[I].GetHandNumber(),"Chips at end of hand != start of hand. Ignoreing hand...");
						continue;
					}

					// At the moment we can only deal with 2-way and 3-way all-in, but we will count the rest.
					if (NumAllInPlayers>3) {
						NumMultiWayAllIns++;
						continue;
					}
					else if (NumAllInPlayers==3) {
						Num3WayAllIns++;						
					}
					else {
						Num2WayAllIns++;						
					}

					// We must make sure that player's indexes are ordered based on their cards (for lookup into the outcome tables).
					// NOTE: Bubble-sort is fine for this...
					for (int J=0;J<(NumAllInPlayers-1);J++) {
						for (int K=J+1;K<NumAllInPlayers;K++) {
							if (PlayerHandType[PlayerIndex[J]]>PlayerHandType[PlayerIndex[K]]) {
								int Temp=PlayerIndex[J];
								PlayerIndex[J]=PlayerIndex[K];
								PlayerIndex[K]=Temp;
							}	
						}
					}

					// Chose one player randomly.
					#ifdef RANDOM_PLAYER_PERPECTIVE
					int ChosenPlayer=RandInt(NumAllInPlayers-1);
					#endif

					// Now lets do the calculation for each of the players.
					for (int Player=0;Player<NumAllInPlayers;Player++) {


						// If asked to, then lets looks at the hands from our perspective only.
						#ifdef HERO_HANDS_ONLY
						if (Hands[I].GetOurSeatIndex()!=PlayerIndex[Player])
							continue;
						#else

						// We can also look the luck from just one of the players involved in the all-in.
						#ifdef RANDOM_PLAYER_PERPECTIVE
						if (Player!=ChosenPlayer)
							continue;
						#endif
						#endif

						// Lets print the hand number first.
						Outfile << Hands[I].GetHandNumber() << ", ";

						// If we didn't just bust out we need to calculate the real EV using ICM.
						if (ICM.TestBustout(StackAtStartOfHand,StackAtEndOfHand,PlayerIndex[Player])==true)
							ActualPrizeEquity=ICM.CalculateBustoutPrizeEV(StackAtStartOfHand,StackAtEndOfHand,PlayerIndex[Player]);
						else
							ActualPrizeEquity=ICM.CalculatePrizeEV(StackAtEndOfHand,PlayerIndex[Player]);

						// Get the cEV too.
						ActualChipEquity=StackAtEndOfHand[PlayerIndex[Player]];

						// Init ready to sum for each outcome.
						ExpectedPrizeEquity=0.0;
						ExpectedChipEquity=0.0;

						// Lets go through the three possible outcomes.
						for (int OutCome=0;OutCome<(NumAllInPlayers==2?3:13);OutCome++) {

							// Lets make a copy of the current stacks, amounts staked and Inhand flags.
							for (int J=0;J<10;J++) {
								CurrentStacks[J]=Hands[I].GetCurrentStack(J);
								CurrentStakes[J]=Hands[I].GetStackAtStartOFHand(J)-Hands[I].GetCurrentStack(J);
								InHandCurrently[J]=Hands[I].IsInHandCurrently(J);
							}

							// Lets assign a finishing rank to each player based on the current outcome index.
							for (int J=0;J<NumAllInPlayers;J++)
								PlayersFinishingRank[PlayerIndex[J]]=TwoWayFinishRanking[OutCome][J];

							// Lets share out all the side-pots.
							for (;;) {

								// Lets set any player who has nothing staked anymore to not be in the hand.
								for (int J=0;J<10;J++)
									if (CurrentStakes[J]==0)
										InHandCurrently[J]=false;					// Not in hand now.

								// Find he smallest amount staked.
								int MinAmountStaked=0x7fffffff;
								for (int J=0;J<10;J++)
									if (InHandCurrently[J]==true)
										MinAmountStaked=Min(MinAmountStaked,CurrentStakes[J]);

								// Create the side-pot and subtract from the staked amounts.
								int CurrentPot=0;
								for (int J=0;J<10;J++) {
									CurrentPot+=Min(CurrentStakes[J],MinAmountStaked);
									CurrentStakes[J]-=Min(CurrentStakes[J],MinAmountStaked);
								}

								// Test if we are done.
								// NOTE: The last side-pot will just be the biggest stack geting his excess chips returned.
								if (CurrentPot==0)
									break;

								// Share out the pot based on the hand rank of each player.
								int NumHandWinners=0;
								int BestHand=0x7fffffff;
								for (int J=0;J<10;J++) {
									if (InHandCurrently[J]==true) {
										if (PlayersFinishingRank[J]<BestHand) {
											NumHandWinners=1;
											BestHand=PlayersFinishingRank[J];
										}
										else if (PlayersFinishingRank[J]==BestHand) {
											NumHandWinners++;
										}
									}
								}

								// Now lets take off the smount they put into the vurrent pot and give them any pot they might need.
								int OddChips=(CurrentPot%NumHandWinners);
								for (int J=0;J<10;J++) {
									if (InHandCurrently[J]==true && PlayersFinishingRank[J]==BestHand) {
										CurrentStacks[J]+=(CurrentPot/NumHandWinners)+OddChips;
										OddChips=0;			// If there were any, they have been assigned now.
									}
								}

							}

							// Get the chance of outcome from the lookup table.
							double ChanceOfOutcome;
							if (NumAllInPlayers==2)
								ChanceOfOutcome=TwoWayOutcomeChances[OutCome][PlayerHandType[PlayerIndex[0]]][PlayerHandType[PlayerIndex[1]]];
							else
								ChanceOfOutcome=ThreeWayOutcomeChances[OutCome][PlayerHandType[PlayerIndex[0]]][PlayerHandType[PlayerIndex[1]]][PlayerHandType[PlayerIndex[2]]];

							double TempExpectedPrizeEquity,TempExpectedChipEquity,TempPLoseDiff;

							// Work out our $EV for this outcome.
							if (ICM.TestBustout(StackAtStartOfHand,CurrentStacks,PlayerIndex[Player])==true)
								TempExpectedPrizeEquity=ICM.CalculateBustoutPrizeEV(StackAtStartOfHand,CurrentStacks,PlayerIndex[Player]);
							else
								TempExpectedPrizeEquity=ICM.CalculatePrizeEV(CurrentStacks,PlayerIndex[Player]);

							// Work out the cEV for this outcome.
							TempExpectedChipEquity=CurrentStacks[PlayerIndex[Player]];

							// Lets add to the sums.
							ExpectedPrizeEquity+=TempExpectedPrizeEquity*ChanceOfOutcome;
							ExpectedChipEquity+=TempExpectedChipEquity*ChanceOfOutcome;

							// Lets print the EVs and the outcomes.
							// @@@ This file is gonna be a nightmare to read, as it will have different numbers of feilds for 2-way and 3-way lines...
							Outfile << ChanceOfOutcome << ',' << TempExpectedPrizeEquity << ',' << TempExpectedChipEquity << ", ";

						} // End for each outcome.

						SumPrizeEquityDifferences+=ActualPrizeEquity-ExpectedPrizeEquity;
						SumChipEquityDifferences+=ActualChipEquity-ExpectedChipEquity;

						// Lets print the EV for this hand.
						Outfile << ExpectedPrizeEquity << ',' << ActualPrizeEquity << ',' << ActualPrizeEquity-ExpectedPrizeEquity << ", "
								<< ExpectedChipEquity << ',' << ActualChipEquity << ',' << ActualChipEquity-ExpectedChipEquity << ", ";

						// Lets print the cumulative versions.
						if (NumDataPoints%FILE_OUTPUT_INTERVAL==0)
							Outfile << SumPrizeEquityDifferences*100.0 << ','<< SumChipEquityDifferences*100.0 << endl;

						NumDataPoints++;

					} // End for each player.

				} // End if valid all-in hand.

			} // End for each hand in hand history.

			// Print the difference between expected and real.
			cout << "NumSNGs: " << NumSNGs
				 << " / NumAllIns[2,3,4+]: " << Num2WayAllIns << ',' << Num3WayAllIns << ',' << NumMultiWayAllIns
				 << " / NumDataPoints: " << NumDataPoints << endl
				 << "$EV Luck: " << (int)(SumPrizeEquityDifferences*100.0)
				 << "% (" << (SumPrizeEquityDifferences*100.0)/(double)(NumDataPoints>0?NumDataPoints:1)
				 << "% per all-in)" << endl
				 << "cEV Luck: " << (int)SumChipEquityDifferences
				 << "t (" << SumChipEquityDifferences/(double)(NumDataPoints>0?NumDataPoints:1)
				 << "t per all-in)" << endl;

		} // End for each hand history in folder.

		// If asked to, then reset to use again.
		#ifdef REPEAT_LOOP_ALL_FOLDERS
		if (Folder==NumFolders-1)
			Folder=-1;
		#endif

	} // For each folder.

	// Close the output file.
	Outfile.close();

} // End BackTestAllInLuck.

// ***************************************************************************
// *                                  INCLUDES                               *
// ***************************************************************************

#include "../core/misc.h"
#include "../core/random_number_generator.h"

#include "../holdem_game_state.h"
#include "../holdem_game_state_with_history.h"
#include "../holdem_hole_card_ranking.h"
#include "../sng_icm_calculator.h"
#include "../holdem_parser.h"

#include "../party_nl_holdem_sng_parser.h"

// ***************************************************************************
// *                                  CONSTANTS                              *
// ***************************************************************************

// Define this to just examine our all-in hands from our perspective.
#define HERO_HANDS_ONLY

// Define this to only look at the 2/3-way all-in from a single randomly chose player's perspective.
// NOTE: Can't use this with HERO_HANDS_ONLY.
//#define RANDOM_PLAYER_PERPECTIVE

// Define this to read all folders again and again in a loop. Thius is usedful for use with
// RANDOM_PLAYER_PERPECTIVE to get an idea of the level of sample variance to expect from
// just doing a single pass (useful for plots, but no good for results...).
//#define REPEAT_LOOP_ALL_FOLDERS

// Set this to >1 to print less data (for plotting, etc).
#define FILE_OUTPUT_INTERVAL 1

// ===========================================================================

void BackTestAllInLuck(const char** Folders,const int NumFolders)
{	

	// The parser we are going to use.
	PartyNLHoldemSNGParser Parser;

	// The vector of hands we get from the parser.
	vector<HoldemGameStateWithHistory> Hands;

	// This is what we use to get the EV at the end of the hand.
	SNG_ICM_Calculator ICM;

	// These are the possible finish rankings for each outcome.
	const int TwoWayFinishRanking[3][2]    = {{1,1},  {1,2},  {2,1}};
	const int ThreeWayFinishRanking[13][3] = {{1,1,1},{1,1,2},{1,2,1},
											  {1,2,2},{1,2,3},{1,3,2},
											  {2,1,2},{2,2,1},{2,1,3},
											  {2,3,1},{2,1,1},{3,1,2},
	                                          {3,2,1}};

	// These hold the outcomes for each 2-way and 3-way hand matchup.
	// NOTE: Use floats to reduce memory consumption.
	static float TwoWayOutcomeChances[3][169][169];
	static float ThreeWayOutcomeChances[13][169][169][169];

	// The sum of differences from our predicted EV.
	double SumPrizeEquityDifferences=0.0;
	double SumChipEquityDifferences=0.0;

	// The number of SNGs we have played.
	int NumSNGs=0;

	// The number of 2-way, 3-way and multi-way data-points seperately.
	int Num2WayAllIns=0;
	int Num3WayAllIns=0;
	int NumMultiWayAllIns=0;										// We don't deal with these atm.

	// The number fo data-points we have used.
	// NOTE: This can be 2x or 3x the number of all-ins, as we can (if asked) take a data-point from
	//       multiple player's perspectives.
	int NumDataPoints=0;

	// The last tourney number.
	char LastTournamentNumber[BUFFER_SIZE+1];
	LastTournamentNumber[0]=0;

	// *************************************************************************
	// ************** LOAD THE LOOKUP AND/OR CREATE BINARY VERSIONS ************
	// *************************************************************************

	// Have to use two different once because C++ messes up on 2nd use...
	ifstream InFile1,InFile2;

	// This flag gets unset if we failed to loaded either of the (fast) binary versions ok.
	bool LoadedBinary=true;

	// Lets first try and open the binary versions.
	InFile1.open("2WAY_HandEval_binary.dat",ios::binary);
	InFile2.open("3WAY_HandEval_binary.dat",ios::binary);

	// If all ok, then read these instead.
	if (!InFile1.fail() && !InFile2.fail()) {
		InFile1.read((char*)&TwoWayOutcomeChances,sizeof(TwoWayOutcomeChances));
		InFile2.read((char*)&ThreeWayOutcomeChances,sizeof(ThreeWayOutcomeChances));
	}		
	else {
		LoadedBinary=false;
	}

	// Close the input files.
	InFile1.close();
	InFile2.close();

	// if we couldn't open the binary versions, lets load from the test and then save the binary again.
	if (LoadedBinary==false) {

		// Have to use two different once because C++ messes up on 2nd use...
		ifstream InFileT1,InFileT2;

		// Have to use two different once because C++ messes up on 2nd use...
		ofstream OutFile1,OutFile2;

		// Use for reading in the outcome look files.
		int H1,H2,H3;
		double Outcome;

		// Tell the user what's going on.
		cout << "Failed to load binary equity lookup tables. Re-creating them now... "; cout.flush();

		// Open and read each line of the test data files.
		// NOTE: Inversed as HoldemHoleCardRanking::GetIndex() uses AA in top left, A2s top right, etc.
		InFileT1.open("2WAY_HandEval.dat");
		InFileT2.open("3WAY_HandEval.dat");

		// If all ok, then read these in.
		if (InFileT1.fail() || InFileT2.fail())
			Error(FATAL,"Could not load the (text) equity lookups.");
		while (InFileT1 >> H1 >> H2) {
			for (int I=0;I<3;I++)
				InFileT1 >> TwoWayOutcomeChances[I][168-H1][168-H2];
		}
		while (InFileT2 >> H1 >> H2 >> H3) {
			for (int I=0;I<13;I++)
				InFileT2 >> ThreeWayOutcomeChances[I][168-H1][168-H2][168-H3];
		}

		// Close the input files.
		InFileT1.close();
		InFileT2.close();

		// Lets save the binary versions for use next time.
		OutFile1.open("2WAY_HandEval_binary.dat",ios::binary);
		OutFile2.open("3WAY_HandEval_binary.dat",ios::binary);

		// If all OK, save them out.
		if (OutFile1.fail() || OutFile2.fail())
			Error(FATAL,"Could not save the (binary) equity lookups.");
		OutFile1.write((char*)&TwoWayOutcomeChances,sizeof(TwoWayOutcomeChances));
		OutFile2.write((char*)&ThreeWayOutcomeChances,sizeof(ThreeWayOutcomeChances));

		// Close the output files.
		OutFile1.close();
		OutFile2.close();

		// All done creating them now.
		cout << "Done." << endl;

	}

	// *************************************************************************
	// *************************************************************************

	// Open the output file.
	ofstream Outfile;
	Outfile.open("luck_results.csv");
	if (Outfile.fail())
		Error(FATAL,"Could not open 'luck_results.csv'");

	// Lets do it on each folder.
	for (int Folder=0;Folder<NumFolders;Folder++) {

		// Lets try and get the first vector of hands.
		Parser.InitHandHistorySearcher(Folders[Folder]);
		while (Parser.SearchForAndParseNextHandHistoryFile(Hands,true)==true) {

			// Lets keep going until we get no more.
			for (int I=0;I<Hands.size();I++) {

				// Is this a new tournament number?
				if (strcmp(LastTournamentNumber,Hands[I].GetTournamentNumber())!=0) {
					NumSNGs++;
					strcpy_s(LastTournamentNumber,BUFFER_SIZE,Hands[I].GetTournamentNumber());
				}

				// If we have gone from pre-flop to river, then this is an all-in hand.
				if (Hands[I].GetNumStates()>=2
					&& Hands[I].GetCurrentGameStage()==RIVER
					&& Hands[I][Hands[I].GetNumStates()-2].GetCurrentGameStage()==PRE_FLOP
					&& Hands[I].GetTotalInHandCurrently()>=2) {

					// This is the number of all-in players we are dealing with here.
					int NumAllInPlayers=Hands[I].GetTotalInHandCurrently();

					// This is the index of each of the players who are left.
					int PlayerIndex[10];	// ### Only use the first 3, but need 10 incase we start to sim for 4+ players...
					int NumValidShowdownHands=0;

					// The (temp) "finishing rank" assigned depending on outcome.
					int PlayersFinishingRank[10];

					// The chance of each outcome (retrived from the lookup table).
					double ChanceOfOutcome;

					// This holds the rank indexes (0..168) for the player's hand.
					int PlayerHandType[10];

					// The stacks for each player at the start and end of hand.
					int StackAtStartOfHand[10];
					int StackAtEndOfHand[10];

					// These are used to temporailty sim the outcomes.
					int CurrentStacks[10];
					int CurrentStakes[10];
					bool InHandCurrently[10];

					// The actaul EV from the start to end of hand.
					double ActualPrizeEquity,ActualChipEquity;

					// Expected average EV based on the hand matchup.
					double ExpectedPrizeEquity;
					double ExpectedChipEquity;

					// If asked to look at the hands from our perspective only. and we're not here, then skip.
					#ifdef HERO_HANDS_ONLY
					if (Hands[I].GetOurSeatIndex()==NO_SEAT)
						continue;
					#endif

					// @@@@@@@@@@@@@@ Don't really need this @@@@@@@@@@@@@@@@@@@@@
					// Lets make sure that 1 or both players are all-in.
					int NumNonAllInPlayers=0;
					for (int J=0;J<10;J++) {
						if (Hands[I].IsInHandCurrently(J)==true && Hands[I].GetCurrentStack(J)!=0)
							NumNonAllInPlayers++;
					}
					if (NumNonAllInPlayers>1) {
						Error(WARNING,"Non all-in hand (should not get here...).");
						continue;
					}
					// @@@@@@@@@@@@@@ Don't really need this @@@@@@@@@@@@@@@@@@@@@

					// If the player is in the hand currently and his cards are known, then lets count him and get his seat index.
					for (int J=0;J<10;J++) {
						if (Hands[I].IsInHandCurrently(J)==true && Hands[I].GetShowdownHoleCard(J,0).Rank!=RANK_NONE) {
							PlayerIndex[NumValidShowdownHands]=J;
							PlayerHandType[J]=HoldemHoleCardRanking::GetIndex((Hands[I].GetShowdownHoleCard(J,0).Suit*13)+Hands[I].GetShowdownHoleCard(J,0).Rank,
																			  (Hands[I].GetShowdownHoleCard(J,1).Suit*13)+Hands[I].GetShowdownHoleCard(J,1).Rank);
							NumValidShowdownHands++;	// One more.
						}
					}

					// If we don't have cards for all the players at the end then skip this hand.
					if (NumValidShowdownHands!=NumAllInPlayers)
						continue;

					// Lets work out the stacks at the start/end of the hand.
					for (int K=0;K<10;K++) {
						StackAtStartOfHand[K]=0;
						StackAtEndOfHand[K]=0;
					}
					for (int K=0;K<10;K++) {
						if (Hands[I].WasInHandAtStartOfHand(K)==true) {
							StackAtStartOfHand[K]=Hands[I].GetStackAtStartOFHand(K);
							StackAtEndOfHand[K]=Hands[I].GetCurrentStack(K)+Hands[I].GetUnCalledBets(K)+Hands[I].GetAmountWon(K);
						}
					}

					// Check we have not lost any chips.
					// #### NOTE: This happens for truncated HH files where their is no "wins" line...
					int TotalChipsStart=0;
					int TotalChipsEnd=0;
					for (int K=0;K<10;K++) {
						TotalChipsStart+=StackAtStartOfHand[K];
						TotalChipsEnd+=StackAtEndOfHand[K];
					}
					if (TotalChipsStart!=TotalChipsEnd) {
						Error(WARNING,Hands[I].GetHandNumber(),"Chips at end of hand != start of hand. Ignoreing hand...");
						continue;
					}

					// At the moment we can only deal with 2-way and 3-way all-in, but we will count the rest.
					if (NumAllInPlayers>3) {
						NumMultiWayAllIns++;
						continue;
					}
					else if (NumAllInPlayers==3) {
						Num3WayAllIns++;
					}
					else {
						Num2WayAllIns++;
					}

					// We must make sure that player's indexes are ordered based on their cards (for lookup into the outcome tables).
					// NOTE: Bubble-sort is fine for this...
					for (int J=0;J<(NumAllInPlayers-1);J++) {
						for (int K=J+1;K<NumAllInPlayers;K++) {
							if (PlayerHandType[PlayerIndex[J]]>PlayerHandType[PlayerIndex[K]]) {
								int Temp=PlayerIndex[J];
								PlayerIndex[J]=PlayerIndex[K];
								PlayerIndex[K]=Temp;
							}	
						}
					}

					// Chose one player randomly.
					#ifdef RANDOM_PLAYER_PERPECTIVE
					int ChosenPlayer=RandInt(NumAllInPlayers-1);
					#endif

					// Now lets do the calculation for each of the players.
					for (int Player=0;Player<NumAllInPlayers;Player++) {


						// If asked to, then lets looks at the hands from our perspective only.
						#ifdef HERO_HANDS_ONLY
						if (Hands[I].GetOurSeatIndex()!=PlayerIndex[Player])
							continue;
						#else

						// We can also look the luck from just one of the players involved in the all-in.
						#ifdef RANDOM_PLAYER_PERPECTIVE
						if (Player!=ChosenPlayer)
							continue;
						#endif
						#endif

						// Lets print the hand number first. @@@ DEBUG ONLY @@@
						//Outfile << Hands[I].GetHandNumber() << ", ";

						// If we didn't just bust out we need to calculate the real EV using ICM.
						if (ICM.TestBustout(StackAtStartOfHand,StackAtEndOfHand,PlayerIndex[Player])==true)
							ActualPrizeEquity=ICM.CalculateBustoutPrizeEV(StackAtStartOfHand,StackAtEndOfHand,PlayerIndex[Player]);
						else
							ActualPrizeEquity=ICM.CalculatePrizeEV(StackAtEndOfHand,PlayerIndex[Player]);

						// Get the cEV too.
						ActualChipEquity=StackAtEndOfHand[PlayerIndex[Player]];

						// Init ready to sum for each outcome.
						ExpectedPrizeEquity=0.0;
						ExpectedChipEquity=0.0;

						// Lets go through the three possible outcomes.
						for (int OutCome=0;OutCome<(NumAllInPlayers==2?3:13);OutCome++) {

							// We can share the pot much faster if only 2 players.
							if (NumAllInPlayers==2) {

								// Lets assign a finishing rank to each player based on the current outcome index.
								for (int J=0;J<2;J++)
									PlayersFinishingRank[PlayerIndex[J]]=TwoWayFinishRanking[OutCome][J];

								// Get the chance of outcome from the lookup table.
								ChanceOfOutcome=TwoWayOutcomeChances[OutCome][PlayerHandType[PlayerIndex[0]]][PlayerHandType[PlayerIndex[1]]];

								// Lets make a copy of the current stacks and amounts staked.
								// NOTE: For the 2-way code we need to take off the amount staked AFTER we have equalized the stakes below.
								for (int J=0;J<10;J++) {
									CurrentStacks[J]=Hands[I].GetStackAtStartOFHand(J);
									CurrentStakes[J]=Hands[I].GetStackAtStartOFHand(J)-Hands[I].GetCurrentStack(J);
								}

								// Get the chance of outcome from the lookup table.
								ChanceOfOutcome=TwoWayOutcomeChances[OutCome][PlayerHandType[PlayerIndex[0]]][PlayerHandType[PlayerIndex[1]]];

								// Lets return any uncalled bets so they have both staked the same.
								CurrentStakes[PlayerIndex[0]]=Min(CurrentStakes[PlayerIndex[0]],CurrentStakes[PlayerIndex[1]]);
								CurrentStakes[PlayerIndex[1]]=CurrentStakes[PlayerIndex[0]];

								// Now work out the size of the pot available to each left in the hand.
								int CurrentPot=0;
								for (int J=0;J<10;J++) {
									CurrentPot+=CurrentStakes[J];
									CurrentStacks[J]-=CurrentStakes[J]; // Take off now.
								}

								// Lets work out the chance dependig on the outcome type.
								// NOTE: We assign any odd chips to an aribtary player.
								if (PlayersFinishingRank[PlayerIndex[0]]<PlayersFinishingRank[PlayerIndex[1]]) {
									CurrentStacks[PlayerIndex[0]]+=CurrentPot;
								}
								else if (PlayersFinishingRank[PlayerIndex[1]]<PlayersFinishingRank[PlayerIndex[0]]) {
									CurrentStacks[PlayerIndex[1]]+=CurrentPot;
								}
								else {
									CurrentStacks[PlayerIndex[0]]+=(CurrentPot/2)+(CurrentPot%2);
									CurrentStacks[PlayerIndex[1]]+=(CurrentPot/2);
								}

							} // End 2-way pot shareout.

							// Will have to do the slower way for 3 players them.
							else {

								// Lets assign a finishing rank to each player based on the current outcome index.
								for (int J=0;J<3;J++)
									PlayersFinishingRank[PlayerIndex[J]]=ThreeWayFinishRanking[OutCome][J];

								// Get the chance of outcome from the lookup table.
								ChanceOfOutcome=ThreeWayOutcomeChances[OutCome][PlayerHandType[PlayerIndex[0]]][PlayerHandType[PlayerIndex[1]]][PlayerHandType[PlayerIndex[2]]];

								// Lets make a copy of the current stacks, amounts staked and Inhand flags.
								// NOTE: For the 3-way code we need to take off the amount staked BEFORE.
								for (int J=0;J<10;J++) {
									CurrentStacks[J]=Hands[I].GetCurrentStack(J);
									CurrentStakes[J]=Hands[I].GetStackAtStartOFHand(J)-Hands[I].GetCurrentStack(J);
									InHandCurrently[J]=Hands[I].IsInHandCurrently(J);
								}

								// Lets share out all the side-pots.
								for (;;) {

									// Lets set any player who has nothing staked anymore to not be in the hand.
									for (int J=0;J<10;J++)
										if (CurrentStakes[J]==0)
											InHandCurrently[J]=false;					// Not in hand now.

									// Find he smallest amount staked.
									int MinAmountStaked=0x7fffffff;
									for (int J=0;J<10;J++)
										if (InHandCurrently[J]==true)
											MinAmountStaked=Min(MinAmountStaked,CurrentStakes[J]);

									// Create the side-pot and subtract from the staked amounts.
									int CurrentPot=0;
									for (int J=0;J<10;J++) {
										CurrentPot+=Min(CurrentStakes[J],MinAmountStaked);
										CurrentStakes[J]-=Min(CurrentStakes[J],MinAmountStaked);
									}

									// Test if we are done.
									// NOTE: The last side-pot will just be the biggest stack geting his excess chips returned.
									if (CurrentPot==0)
										break;

									// Share out the pot based on the hand rank of each player.
									int NumHandWinners=0;
									int BestHand=0x7fffffff;
									for (int J=0;J<10;J++) {
										if (InHandCurrently[J]==true) {
											if (PlayersFinishingRank[J]<BestHand) {
												NumHandWinners=1;
												BestHand=PlayersFinishingRank[J];
											}
											else if (PlayersFinishingRank[J]==BestHand) {
												NumHandWinners++;
											}
										}
									}

									// Now lets take off the smount they put into the vurrent pot and give them any pot they might need.
									// NOTE: We assign any odd chips to an aribtary player.
									int OddChips=(CurrentPot%NumHandWinners);
									for (int J=0;J<10;J++) {
										if (InHandCurrently[J]==true && PlayersFinishingRank[J]==BestHand) {
											CurrentStacks[J]+=(CurrentPot/NumHandWinners)+OddChips;
											OddChips=0;			// If there were any, they have been assigned now.
										}
									}

								}

							} // End 3-way pot shareout.

							double TempExpectedPrizeEquity,TempExpectedChipEquity,TempPLoseDiff;

							// Work out our $EV for this outcome.
							if (ICM.TestBustout(StackAtStartOfHand,CurrentStacks,PlayerIndex[Player])==true)
								TempExpectedPrizeEquity=ICM.CalculateBustoutPrizeEV(StackAtStartOfHand,CurrentStacks,PlayerIndex[Player]);
							else
								TempExpectedPrizeEquity=ICM.CalculatePrizeEV(CurrentStacks,PlayerIndex[Player]);

							// Work out the cEV for this outcome.
							TempExpectedChipEquity=CurrentStacks[PlayerIndex[Player]];

							// Lets add to the sums.
							ExpectedPrizeEquity+=TempExpectedPrizeEquity*ChanceOfOutcome;
							ExpectedChipEquity+=TempExpectedChipEquity*ChanceOfOutcome;

							// Lets print the EVs and the outcomes. @@@ DEBUG ONLY @@@
							// @@@ This file is gonna be a nightmare to read, as it will have different numbers of feilds for 2-way and 3-way lines...
							//Outfile << ChanceOfOutcome << ',' << TempExpectedPrizeEquity << ',' << TempExpectedChipEquity << ", ";

						} // End for each outcome.

						SumPrizeEquityDifferences+=ActualPrizeEquity-ExpectedPrizeEquity;
						SumChipEquityDifferences+=ActualChipEquity-ExpectedChipEquity;

						// Lets print the EV for this hand. @@@ DEBUG ONLY @@@
						//Outfile << ExpectedPrizeEquity << ',' << ActualPrizeEquity << ',' << ActualPrizeEquity-ExpectedPrizeEquity << ", "
						//		<< ExpectedChipEquity << ',' << ActualChipEquity << ',' << ActualChipEquity-ExpectedChipEquity << ", ";

						// Lets print the cumulative versions for plotting, etc.
						if (NumDataPoints%FILE_OUTPUT_INTERVAL==0)
							Outfile << SumPrizeEquityDifferences*100.0 << ','<< SumChipEquityDifferences*100.0 << endl;

						NumDataPoints++;

					} // End for each player.

				} // End if valid all-in hand.

			} // End for each hand in hand history.

			// Print the difference between expected and real.
			cout << "NumSNGs: " << NumSNGs
				 << " / NumAllIns[2,3,4+]: " << Num2WayAllIns << ',' << Num3WayAllIns << ',' << NumMultiWayAllIns
				 << " / NumDataPoints: " << NumDataPoints << endl
				 << "$EV Luck: " << (int)(SumPrizeEquityDifferences*100.0)
				 << "% (" << (SumPrizeEquityDifferences*100.0)/(double)(NumDataPoints>0?NumDataPoints:1)
				 << "% per all-in)" << endl
				 << "cEV Luck: " << (int)SumChipEquityDifferences
				 << "t (" << SumChipEquityDifferences/(double)(NumDataPoints>0?NumDataPoints:1)
				 << "t per all-in)" << endl;

		} // End for each hand history in folder.

		// If asked to, then reset to use again.
		#ifdef REPEAT_LOOP_ALL_FOLDERS
		if (Folder==NumFolders-1)
			Folder=-1;
		#endif

	} // For each folder.

	// Close the output file.
	Outfile.close();

} // End BackTestAllInLuck.