My Deuces Wild odd calcuations seem very weird

import java.security.SecureRandom;
import java.util.ArrayList;


public class DeucesWild {
	private static Chance [] chances =
		new Chance [] { new Chance("Natural royal flush ",800 ,440202756l),
		new Chance("Four deuces ",200 ,4060462824l),
		new Chance("Wild royal flush ",25 ,35796957696l),
		new Chance("Five of a kind ",15 ,63818309856l),
		new Chance("Straight flush ",9 ,83087969280l),
		new Chance("Four of a kind ",5 ,1294427430576l),
		new Chance("Full house ",3 ,423165297240l),
		new Chance("Flush ",2 ,334561280724l),
		new Chance("Straight ",2 ,1117664265756l),
		new Chance("Three of a kind ",1 ,5674784779512l),
		new Chance("Nothing ",0 ,10901423560980l),
	};
	
	public static class Chance
	{
		String name;
		int payoff;
		long odds; //get it? :/
		
		public Chance(String name, int payoff, long odds) {
			super();
			this.name = name;
			this.payoff = payoff;
			this.odds = odds;
		}
		
		
	}
	
	private static final long TOTAL = 19933230517200l;
	
	public static final int INITIAL_PLAYS = 0;
	
	public static final int [] RECORDED_PROFITS = { 800, 8000 };

	public static final int NUM_PLAYERS = 1000;
	
	public ArrayList<Results> results = new ArrayList<Results>();
	
	
	public static class Results
	{
		ArrayList<PlayStats> playStatsList = new ArrayList<PlayStats>(RECORDED_PROFITS.length);

		public static void printCsvHeader() {
			for(int i = 0; i < RECORDED_PROFITS.length; i++)
			{
				System.out.print(RECORDED_PROFITS+",");
				PlayStats.printHeader();
				if(i == RECORDED_PROFITS.length-1)
					System.out.println();
				else
					System.out.print(",");
			}
		}

		public void printCsv() {
			for(int i = 0; i < RECORDED_PROFITS.length; i++)
			{
				System.out.print(RECORDED_PROFITS+",");
				playStatsList.get(i).printCsv();
				if(i == RECORDED_PROFITS.length-1)
					System.out.println();
				else
					System.out.print(",");
			}
		}

		public void add(PlayStats ps) {
			playStatsList.add(ps);
			
		}
	}
	
	public static class PlayStats
	{
		int numPlays;
		int minBalance, maxBalance, endingBalance;
		private int recordedProfitIndex;
		
		
		public PlayStats(int recordedProfitIndex) {
			this.recordedProfitIndex = recordedProfitIndex;
		}

		public static void printHeader() {
			System.out.print("numPlays,minBalance, maxBalance, endingBalance");
			
		}

		public void printCsv() {
			System.out.print(numPlays+","+minBalance+","+maxBalance+","+endingBalance);
		}

		public void update(int payoff) {
			numPlays ++;
			endingBalance += -1 + payoff;
			minBalance = Math.min(minBalance,endingBalance);
			maxBalance = Math.max(maxBalance,endingBalance);
		}

		public boolean isWinner() {
			return endingBalance >= RECORDED_PROFITS[recordedProfitIndex];
		}

		public static PlayStats createNextPlayStats(PlayStats ps) {
			if(ps.recordedProfitIndex == RECORDED_PROFITS.length -1)
				return null; //end of the test
			
			PlayStats newPs = new PlayStats(ps.recordedProfitIndex+1);
			
			newPs.numPlays = ps.numPlays;
			newPs.minBalance = ps.minBalance;
			newPs.maxBalance = ps.maxBalance;
			newPs.endingBalance = ps.endingBalance;
			
			return newPs;
		}
	}
	
	public static void main(String [] argv)
	{
		new DeucesWild().start();
	}
	
	public void start()
	{
		long calcTotal = 0;
		for(Chance c: chances)
		{
			calcTotal += c.odds;
		}
		
		if(calcTotal != TOTAL) 
		{
			throw new IllegalStateException("bad calcTotal, got "+calcTotal+", expected "+TOTAL);
		}
		
		Results.printCsvHeader();
		for(int i = 0; i < NUM_PLAYERS; i++)
		{
			runUntilProfits().printCsv();
		}
		
	}

	private Results runUntilProfits() {
		Results r = new Results();
		
		PlayStats ps = new PlayStats(0);
		
		//first do the initial plays
		for(int i = 0; i < INITIAL_PLAYS; i++)
		{
			ps.update(runPlay());
		}
		
		//now we start to save stats
		for(;;)
		{
			if(ps.isWinner())
			{
				r.add(ps);
				ps = PlayStats.createNextPlayStats(ps);
				
				if(ps == null) // if we're at the end of recorded stats, then exit, we're done
					break;
				
				//continue to check if that one is also a winner
				continue;
			}
			ps.update(runPlay());
		}
		
		return r;
	}
	
	private SecureRandom sr = new SecureRandom();

	private int runPlay() {
		long val = Math.abs(sr.nextLong()) % TOTAL;
		
		for(Chance c : chances)
		{
			val -= c.odds;
			if(val < 0)
				return c.payoff;
		}

		throw new IllegalStateException("why did val run off the end? "+val);
	}
}