acpc_dealer 2.4.1 → 3.0.0

data/vendor/project_acpc_server/net.c

@@ -1,218 +0,0 @@
-/*
-Copyright (C) 2011 by the Computer Poker Research Group, University of Alberta
-*/
-
-#include <unistd.h>
-#include <netdb.h>
-#include <string.h>
-#include <sys/socket.h>
-#include <sys/time.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include "net.h"
-
-
-ReadBuf *createReadBuf( int fd )
-{
-  ReadBuf *readBuf = (ReadBuf*)malloc( sizeof( ReadBuf ) );
-  if( readBuf == 0 ) {
-
-    return readBuf;
-  }
-
-  readBuf->fd = fd;
-  readBuf->bufStart = 0;
-  readBuf->bufEnd = 0;
-
-  return readBuf;
-}
-
-void destroyReadBuf( ReadBuf *readBuf )
-{
-  close( readBuf->fd );
-  free( readBuf );
-}
-
-/* get a newline terminated line and place it as a string in 'line'
-   terminates the string with a 0 character
-   if timeoutMicros is non-negative, do not spend more than
-   that number of microseconds waiting to read data
-   return number of characters read (including newline, excluding 0)
-   0 on end of file, or -1 on error or timeout */
-ssize_t getLine( ReadBuf *readBuf,
-		 size_t maxLen,
-		 char *line,
-		 int64_t timeoutMicros )
-{
-  int haveStartTime, c;
-  ssize_t len;
-  fd_set fds;
-  struct timeval start, tv;
-
-  /* reserve space for string terminator */
-  --maxLen;
-  if( maxLen < 0 ) {
-    return -1;
-  }
-
-  /* read the line */
-  haveStartTime = 0;
-  len = 0;
-  while( len < maxLen ) {
-
-    if( readBuf->bufStart >= readBuf->bufEnd ) {
-      /* buffer is empty */
-
-      if( timeoutMicros >= 0 ) {
-	/* figure out how much time is left for reading */
-	uint64_t timeLeft;
-
-	timeLeft = timeoutMicros;
-	if( haveStartTime ) {
-
-	  gettimeofday( &tv, NULL );
-	  timeLeft -= (uint64_t)( tv.tv_sec - start.tv_sec ) * 1000000
-	    + ( tv.tv_usec - start.tv_usec );
-	  if( timeLeft < 0 ) {
-
-	    timeLeft = 0;
-	  }
-	} else {
-
-	  haveStartTime = 1;
-	  gettimeofday( &start, NULL );
-	}
-	tv.tv_sec = timeLeft / 1000000;
-	tv.tv_usec = timeLeft % 1000000;
-
-	/* wait for file descriptor to be ready */
-	FD_ZERO( &fds );
-	FD_SET( readBuf->fd, &fds );
-	if( select( readBuf->fd + 1, &fds, NULL, NULL, &tv ) < 1 ) {
-	  /* no input ready within time, or an actual error */
-	
-	  return -1;
-	}
-      }
-
-      /* try reading a buffer full of data */
-      readBuf->bufStart = 0;
-      readBuf->bufEnd = read( readBuf->fd, readBuf->buf, READBUF_LEN );
-      if( readBuf->bufEnd == 0 ) {
-	/* end of input */
-
-	break;
-      } else if( readBuf->bufEnd < 0 ) {
-	/* error condition */
-
-	readBuf->bufEnd = 0;
-	return -1;
-      }
-    }
-
-    /* keep adding to the string until we see a newline */
-    c = readBuf->buf[ readBuf->bufStart ];
-    ++readBuf->bufStart;
-    line[ len ] = c;
-    ++len;
-    if( c == '\n' ) {
-
-      break;
-    }
-  }
-
-  /* terminate the string */
-  line[ len ] = 0;
-  return len;
-}
-
-
-int connectTo( char *hostname, uint16_t port )
-{
-  int sock;
-  struct hostent *hostent;
-  struct sockaddr_in addr;
-
-  hostent = gethostbyname( hostname );
-  if( hostent == NULL ) {
-
-    fprintf( stderr, "ERROR: could not look up address for %s\n", hostname );
-    return -1;
-  }
-
-  if( ( sock = socket( AF_INET, SOCK_STREAM, 0 ) ) < 0 ) {
-
-    fprintf( stderr, "ERROR: could not open socket\n" );
-    return -1;
-  }
-
-  addr.sin_family = AF_INET;
-  addr.sin_port = htons( port );
-  memcpy( &addr.sin_addr, hostent->h_addr_list[ 0 ], hostent->h_length );
-
-  if( connect( sock, (struct sockaddr *)&addr, sizeof( addr ) ) < 0 ) {
-
-    fprintf( stderr, "ERROR: could not connect to %s:%"PRIu16"\n",
-	     hostname, port );
-    return -1;
-  }
-
-  return sock;
-}
-
-int getListenSocket( uint16_t *desiredPort )
-{
-  int sock, t;
-  struct sockaddr_in addr;
-
-  if( ( sock = socket( AF_INET, SOCK_STREAM, 0 ) ) < 0 ) {
-
-    return -1;
-  }
-
-  /* allow fast socket reuse - ignore failure */
-  t = 1;
-  setsockopt( sock, SOL_SOCKET, SO_REUSEADDR, &t, sizeof( int ) );
-
-  /* bind the socket to the port */
-  if( *desiredPort != 0 ) {
-
-    addr.sin_family = AF_INET;
-    addr.sin_port = htons( *desiredPort );
-    addr.sin_addr.s_addr = htonl( INADDR_ANY );
-    if( bind( sock, (struct sockaddr *)&addr, sizeof( addr ) ) < 0 ) {
-
-      return -1;
-    }
-  } else {
-
-    t = 0;
-    while( 1 ) {
-      addr.sin_family = AF_INET;
-      *desiredPort = ( random() % 64512 ) + 1024;
-      addr.sin_port = htons( *desiredPort );
-      addr.sin_addr.s_addr = htonl( INADDR_ANY );
-      if( bind( sock, (struct sockaddr *)&addr, sizeof( addr ) ) < 0 ) {
-
-	if( t < NUM_PORT_CREATION_ATTEMPTS ) {
-
-	  ++t;
-	  continue;
-	} else {
-
-	  return -1;
-	}
-      }
-
-      break;
-    }
-  }
-
-  /* listen on the socket */
-  if( listen( sock, 8 ) < 0 ) {
-
-    return -1;
-  }
-
-  return sock;
-}

data/vendor/project_acpc_server/net.h

@@ -1,62 +0,0 @@
-/*
-Copyright (C) 2011 by the Computer Poker Research Group, University of Alberta
-*/
-
-#ifndef _NET_H
-#define _NET_H
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <sys/types.h>
-#define __STDC_FORMAT_MACROS
-#include <inttypes.h>
-
-
-#define READBUF_LEN 4096
-#define NUM_PORT_CREATION_ATTEMPTS 10
-
-
-/* buffered I/O on file descriptors
-
-   Yes... this is basically re-implementing bits of a standard FILE.
-   Unfortunately, trying to mix timeouts and FILE streams either
-   a) doesn't work, or b) is fairly system specific */
-typedef struct {
-  int fd;
-  int bufStart;
-  int bufEnd;
-  char buf[ READBUF_LEN ];
-} ReadBuf;
-
-
-/* open a socket to hostname/port
-   returns file descriptor on success, <0 on failure */
-int connectTo( char *hostname, uint16_t port );
-
-/* try opening a socket suitable for connecting to
-   if *desiredPort>0, uses specified port, otherwise use a random port
-   returns actual port in *desiredPort
-   returns file descriptor for socket, or -1 on failure */
-int getListenSocket( uint16_t *desiredPort );
-
-
-/* create a read buffer structure
-   returns 0 on failure */
-ReadBuf *createReadBuf( int fd );
-
-/* destroy a read buffer - like fdopen, it will close the file descriptor */
-void destroyReadBuf( ReadBuf *readBuf );
-
-/* get a newline terminated line and place it as a string in 'line'
-   terminates the string with a 0 character
-   if timeoutMicros is non-negative, do not spend more than
-   that number of microseconds waiting to read data
-   return number of characters read (including newline, excluding 0)
-   0 on end of file, or -1 on error or timeout */
-ssize_t getLine( ReadBuf *readBuf,
-		 size_t maxLen,
-		 char *line,
-		 int64_t timeoutMicros );
-
-
-#endif

data/vendor/project_acpc_server/play_match.pl

@@ -1,99 +0,0 @@
-#!/usr/bin/perl
-
-# Copyright (C) 2011 by the Computer Poker Research Group, University of Alberta
-
-use Socket;
-
-$hostname = `hostname` or die "could not get hostname";
-chomp $hostname;
-@hostent = gethostbyname( $hostname );
-$#hostent >= 4 or die "could not look up $hostname";
-$hostip = inet_ntoa( $hostent[ 4 ] );
-
-$#ARGV >= 3 or die "usage: play_match.pl matchName gameDefFile #Hands rngSeed player1name player1exe player2name player2exe ... [options]";
-
-$numPlayers = -1;
-open FILE, '<', $ARGV[ 1 ] or die "couldn't open game definition $ARGV[ 1 ]";
-while( $_ = <FILE> ) {
-
-    @_ = split;
-
-    if( uc( $_[ 0 ] ) eq 'NUMPLAYERS' ) {
-	$numPlayers = $_[ $#_ ];
-    }
-}
-close FILE;
-
-$numPlayers > 1 or die "couldn't get number of players from $ARGV[ 1 ]";
-
-
-$#ARGV >= 3 + $numPlayers * 2 or die "too few players on command line";
-
-pipe STDINREADPIPE, STDINWRITEPIPE or die "couldn't create stdin pipe";
-pipe STDOUTREADPIPE, STDOUTWRITEPIPE or die "couldn't create stdout pipe";
-
-$dealerPID = fork();
-if( $dealerPID == 0 ) {
-    # we're the child
-
-    # replace standard in and standard out with pipe
-    close STDINWRITEPIPE;
-    close STDOUTREADPIPE;
-    open STDIN, '<&STDINREADPIPE' or die "can't dup STDIN";
-    open STDOUT, '>&STDOUTWRITEPIPE' or die "can't dup STDOUT";
-    open STDERR, ">>$ARGV[ 0 ].err" or die "can't open log file $ARGV[ 0 ].err";
-
-    @args = ( "dealer", $ARGV[ 0 ], $ARGV[ 1 ],
-	      $ARGV[ 2 ], $ARGV[ 3 ] );
-
-    # add names to the arguments
-    for( $p = 0; $p < $numPlayers; ++$p ) {
-	push @args, $ARGV[ 4 + $p * 2 ];
-    }
-
-    # add any extra arguments (options?) to the arguments
-    for( $i = 4 + $numPlayers * 2; $i <= $#ARGV; ++$i ) {
-	push @args, $ARGV[ $i ];
-    }
-    exec { "./dealer" } @args or die "Couldn't run dealer";
-}
-
-close STDINREADPIPE;
-close STDOUTWRITEPIPE;
-
-$_ = <STDOUTREADPIPE> or die "couldn't read port description from dealer";
-@_ = split;
-$#_ + 1 >= $numPlayers or die "couldn't get enough ports from $_";
-
-for( $p = 0; $p < $numPlayers; ++$p ) {
-
-    $playerPID[ $p ] = fork();
-
-    if( $playerPID[ $p ] == 0 ) {
-	# we're the child
-
-	# log standard out and standard error
-	open STDOUT, ">$ARGV[ 0 ].player$p.std"
-	    or die "can't dup player $p STDOUT";
-	open STDERR, ">$ARGV[ 0 ].player$p.err"
-	    or die "can't dup player $p STDERR";
-
-	exec { $ARGV[ 4 + $p * 2 + 1 ] } ( $ARGV[ 4 + $p * 2 + 1 ],
-					   $hostip, $_[ $p ] )
-	    or die "couldn't run $ARGV[ 4 + $p * 2 + 1 ] for player $p";
-    }
-}
-
-$_ = <STDOUTREADPIPE>;
-
-for( $p = 0; $p < $numPlayers; ++$p ) {
-    waitpid( $playerPID[ $p ], 0 );
-}
-
-waitpid( $dealerPID, 0 );
-
-$_ or die "couldn't get values from dealer";
-
-print $_;
-
-exit( 0 );

data/vendor/project_acpc_server/protocol.md

@@ -1,239 +0,0 @@
-ACPC Protocol Specification, version 2.0.0, October 2010
-=======================================
-
-This document describes the format of messages between the ACPC `dealer` program and a player. Communication is over *TCP*, where players connect to `dealer` with a port number that `dealer` will print to `STDOUT` upon starting. All messages are terminated by a 
-carriage return and a new line (`\r\n` or *ASCII* characters 13 and 10, respectively). 
-<!-- @todo Does the dealer still ever send comments or GUI commands?/do we still want users to be aware of this? Why would we waste the bandwidth to send players comments? -->
-Any message from the server which starts with '#' or ';' is a comment or GUI command, and may be safely ignored.
-The first message from a player must be a version string
-    
-    VERSION:2.0.0\r\n
-
-After this, the server will repeatedly send *match state* strings to players describing their view of the match after every event,including an initial state, states where the player is not acting, and the final state when the game is over.
-
-Match States
---------------
-<!-- @todo -->
-
-ACPC Representation of Actions
----------------------------------
-
-         Action                      ACPC Representation
-         ------                      -------------------
-      check or call                          `c`
-          fold                               `f`
-    bet or raise (limit)                     `r`
-bet or raise **to** 100 (no-limit)          `r100` 
-
-Sending Actions
------------------
-If the player is acting, it must respond by returning a message with the same state, with their action, in ACPC format, appended. For example, had the player received the match state <!-- @todo -->
-
-
-<serverMessage> := <matchState> '\r\n'
-<matchState> := 'MATCHSTATE:' <position> <handNumber> <betting> <cards>
-<position> := <unsigned integer> ':'
-<handNumber>:= <unsigned integer> ':'
-<betting> := { <limitBetting> } { <nolimitBetting> } ':'
-<limitBetting> := ( <round1LimitBetting>
-{ | <round1LimitBetting> '/' <round2LimitBetting> … } )
-<roundXLimitBetting> = <limitAction>*
-<limitAction> := <fold> | <call> | <limitRaise>
-<fold> := 'f'
-<call> := 'c'
-<limitRaise> := 'r'
-<nolimitBetting> := ( <round1NolimitBetting>
- { | <round1NolimitBetting> '/' <round2NolimitBetting> … } )
-<roundXNolimitBetting> := <noLimitAction>*
-<noLimitAction> := <fold> | <call> | <nolimitRaise>
-<nolmitRaise> := 'r' <nolimitRaiseSize>
-<nolimitRaiseSize> := <unsigned integer>
-<cards> := <holeCards> <boardCards>
-<holeCards> := <player1Cards> '|' <player2Cards> { '|' <player3Cards> … }
-<boardCards> := <round1BoardCards> { '/' <round2BoardCards> … }
-<playerXCards> := '' | <card> { <card> … }
-<roundXBoardCards> := { <card> … }
-<card> := <rank> <suit>
-<rank> := '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | 'T' | 'J' | 'Q' | 'K' | 'A'
-<suit> := 's' | 'h' | 'd' | 'c'
-<clientResponse> := <matchState> ':'  { <limitAction> } { <noLimitAction> } '\r\n'
-Parts of the specification in brackets indicate game specific definitions.  For example, in Texas 
-Hold'em, there are four rounds with zero, three, one, and one board cards on the rounds respectively, so 
-the actual definition would be
-<round1BoardCards> := ''
-<round2BoardCards> := <card> <card> <card>
-<round3BoardCards> := <card>
-<round4BoardCards> := <card>
-The <position> field tells the client their position relative to the dealer button.  A value of 0 indicates 
-that for the current hand, the client is the first player after the button (the small blind in ring games, or 
-the big blind in reverse-blind heads-up games.)
-The <handNumber> is simply an identifier for the current hand.  Clients should make no assumption 
-about these values, other than that it will be unique across hands within a match, and that it will not 
-change within a single hand.
-<betting> is a list of actions taken by all players.  There is no distinction made between calling and 
-checking, or betting and raising.  In no-limit betting strings, the raise action includes a size, which 
-indicates the total number of chips the player will have put into the pot after raising (ie the value they 
-are raising to, not the value they are raising by.)  Valid betting strings will be described in a later 
-section.
-<cards> is the complete set of cards visible to the player, given their <position>.  <holecards> 
-describes the view of the private cards, and the number of <playerCards> sections is determined by the 
-game being player.  For example, heads-up games will have two sections, 3 player ring games will have 
-3 sections, and so on.  Each <playerCard> section will either be an empty string, indicating that the 
-player does not know what those cards are, or a number of <card> strings determined by the game.  A 
-<card> is simply two characters, one for the rank and one for the suit.  The <boardCards> description 
-will also have a number of sections, one for each round, up to the current round as indicated by the 
-<betting>.  The number of <cards> in each section is fixed, and determined by the game.  Note that if it 
-ever becomes desirable to play a game with board cards in the first round, the protocol should probably 
-be changed again to add a separator between the hole cards and board cards.
-A valid <betting> string consists of a sequence of valid actions for successive acting players.  Calling is 
-always valid.  Folding is only valid if the acting player would need to add money to the pot to call.  To 
-describe raises, it is worth making a distinction between raising by and raising to.  Unless this 
-document specifically mention otherwise, when it speaks of a raise size, it is talking about a raise to a 
-value, using the term to mean the total number of chips the player will have put into the pot, including 
-chips added in previous rounds.  In contrast, raising by a value is adding that number of chips to the pot 
-after calling the current bet.
-A raise is valid if a) it raises by at least one chip, b) the player has sufficient money in their stack to 
-raise to the value, and c) the raise would put the player all-in (they have spent all their chips) or the 
-amount they are raising by is at least as large as the big blind and the raise-by amount for any other 
-raise in the round.  This description properly handles some odd cases where some players may be all-
-in.  Informally, at the beginning of a round a player may bet as low as the big blind, and each 
-subsequent raise must increase the bet by at least as much as the last raise.  In limit betting games, there 
-may also be a limit on the number of raises in a round, and any raise action over this limit is not valid.
-An active player is one that has not folded, and is not all-in.  Label the players from 0 to N-1, where N 
-is the number of players in the game.  After an action by player p, the next acting player is p' for the 
-minimum d>0 such that p' is active and p' =(p+d) modulo N.  That is, the next player around the table 
-who has at least two valid actions.  The first player in a round is specified by the game.
-A betting round ends when all active players remaining have either called, or were the player which 
-initiated the current bet.  The game is over if the all betting rounds have finished, or if there are not at 
-least two active players left in the game.  If all players but one have folded, the remaining player wins 
-the entire pot, and does not show other players their cards.  Otherwise, the game has ended in a 
-showdown and all non-folding players show everyone their cards.
-Values in a showdown are determined by the rank of a players best hand, constructed from their hole 
-cards and the public board cards.  Folding players have a lower rank than any non-folding player. 
-Every pot of money is split evenly between all participating players with the highest rank.  There is a 
-separate pot for every distinct amount j of money spent by a player (whether they fold or not), and a 
-player is participating in the pot if they spent at least that much money (again, whether they fold or 
-not.)  The size of the pot is equal to the number of participating players multiplied by (j - the size of the 
-next smallest amount spent by a player).
-Changes from Version 1
-There a number of changes from the first version of the protocol.  Ring games are now documented. 
-No-limit games no longer give a value for a call, and there are no blinds in the string.  The question of 
-whether all-in players got to act was previously left unspecified, and different implementations had 
-different behaviour.  Folding is no longer allowed if the player could have called for free.  Finally, this 
-updated description also covers the protocol for no-limit ring games, in the event that this game is 
-added to the competition.
-It is also strongly suggested to the chair that on a failed responses from a client, whether the message 
-was malformed, the action was invalid, or the player did not respond in time, the entire match should 
-be ended.  If the problem can not be fixed easily by a very short interaction with the team, the program 
-should be disqualified.  The previous choice of having the player call in some cases, or fold all 
-remaining hands led to some situations where the results of the competition depended on the chair's 
-decision on exactly how to handle incorrect behaviour.  Teams with buggy programs also took up large 
-amounts of the chair's time.  As long as players are given sufficient time for testing, using the exact 
-same code used for the competition, it is not unreasonable to expect players to be able to run without 
-producing error messages or warnings.
-Examples
-The rest of this document is examples of messages to and from a client in various games.  Messages 
-from the server are prefaced with S->.  Responses from the client are prefaced with <-C.
-Two player limit Texas Hold'em
-S-> MATCHSTATE:0:0::TdAs| 
-S-> MATCHSTATE:0:0:r:TdAs| 
-<-C MATCHSTATE:0:0:r:TdAs|:r 
-S-> MATCHSTATE:0:0:rr:TdAs| 
-S-> MATCHSTATE:0:0:rrc/:TdAs|/2c8c3h 
-<-C MATCHSTATE:0:0:rrc/:TdAs|/2c8c3h:r 
-S-> MATCHSTATE:0:0:rrc/r:TdAs|/2c8c3h 
-S-> MATCHSTATE:0:0:rrc/rc/:TdAs|/2c8c3h/9c 
-<-C MATCHSTATE:0:0:rrc/rc/:TdAs|/2c8c3h/9c:c 
-S-> MATCHSTATE:0:0:rrc/rc/c:TdAs|/2c8c3h/9c 
-S-> MATCHSTATE:0:0:rrc/rc/cr:TdAs|/2c8c3h/9c 
-<-C MATCHSTATE:0:0:rrc/rc/cr:TdAs|/2c8c3h/9c:c 
-S-> MATCHSTATE:0:0:rrc/rc/crc/:TdAs|/2c8c3h/9c/Kh 
-<-C MATCHSTATE:0:0:rrc/rc/crc/:TdAs|/2c8c3h/9c/Kh:c 
-S-> MATCHSTATE:0:0:rrc/rc/crc/c:TdAs|/2c8c3h/9c/Kh 
-S-> MATCHSTATE:0:0:rrc/rc/crc/cr:TdAs|/2c8c3h/9c/Kh 
-<-C MATCHSTATE:0:0:rrc/rc/crc/cr:TdAs|/2c8c3h/9c/Kh:c 
-S-> MATCHSTATE:0:0:rrc/rc/crc/crc:TdAs|8hTc/2c8c3h/9c/Kh 
-S-> MATCHSTATE:1:1::|Qd7c 
-<-C MATCHSTATE:1:1::|Qd7c:r 
-S-> MATCHSTATE:1:1:r:|Qd7c 
-S-> MATCHSTATE:1:1:rr:|Qd7c 
-<-C MATCHSTATE:1:1:rr:|Qd7c:c 
-S-> MATCHSTATE:1:1:rrc/:|Qd7c/2h8h5c 
-S-> MATCHSTATE:1:1:rrc/r:|Qd7c/2h8h5c 
-<-C MATCHSTATE:1:1:rrc/r:|Qd7c/2h8h5c:c 
-S-> MATCHSTATE:1:1:rrc/rc/:|Qd7c/2h8h5c/Th 
-S-> MATCHSTATE:1:1:rrc/rc/r:|Qd7c/2h8h5c/Th 
-<-C MATCHSTATE:1:1:rrc/rc/r:|Qd7c/2h8h5c/Th:f 
-S-> MATCHSTATE:1:1:rrc/rc/rf:|Qd7c/2h8h5c/Th 
-S-> MATCHSTATE:0:2::9d7s| 
-S-> MATCHSTATE:0:2:r:9d7s| 
-<-C MATCHSTATE:0:2:r:9d7s|:c 
-S-> MATCHSTATE:0:2:rc/:9d7s|/5d2cJc 
-<-C MATCHSTATE:0:2:rc/:9d7s|/5d2cJc:c 
-S-> MATCHSTATE:0:2:rc/c:9d7s|/5d2cJc 
-S-> MATCHSTATE:0:2:rc/cc/:9d7s|/5d2cJc/3d 
-<-C MATCHSTATE:0:2:rc/cc/:9d7s|/5d2cJc/3d:c 
-S-> MATCHSTATE:0:2:rc/cc/c:9d7s|/5d2cJc/3d 
-S-> MATCHSTATE:0:2:rc/cc/cr:9d7s|/5d2cJc/3d 
-<-C MATCHSTATE:0:2:rc/cc/cr:9d7s|/5d2cJc/3d:f 
-S-> MATCHSTATE:0:2:rc/cc/crf:9d7s|/5d2cJc/3d 
-Two player no-limit Texas Hold'em
-S-> MATCHSTATE:0:30::9s8h| 
-S-> MATCHSTATE:0:30:c:9s8h| 
-<-C MATCHSTATE:0:30:c:9s8h|:c 
-S-> MATCHSTATE:0:30:cc/:9s8h|/8c8d5c 
-<-C MATCHSTATE:0:30:cc/:9s8h|/8c8d5c:r250 
-S-> MATCHSTATE:0:30:cc/r250:9s8h|/8c8d5c 
-S-> MATCHSTATE:0:30:cc/r250c/:9s8h|/8c8d5c/6s 
-<-C MATCHSTATE:0:30:cc/r250c/:9s8h|/8c8d5c/6s:r500 
-S-> MATCHSTATE:0:30:cc/r250c/r500:9s8h|/8c8d5c/6s 
-S-> MATCHSTATE:0:30:cc/r250c/r500c/:9s8h|/8c8d5c/6s/2d 
-<-C MATCHSTATE:0:30:cc/r250c/r500c/:9s8h|/8c8d5c/6s/2d:r1250 
-S-> MATCHSTATE:0:30:cc/r250c/r500c/r1250:9s8h|/8c8d5c/6s/2d 
-S-> MATCHSTATE:0:30:cc/r250c/r500c/r1250c:9s8h|9c6h/8c8d5c/6s/2d 
-S-> MATCHSTATE:1:31::|JdTc 
-<-C MATCHSTATE:1:31::|JdTc:r300 
-S-> MATCHSTATE:1:31:r300:|JdTc 
-S-> MATCHSTATE:1:31:r300r900:|JdTc 
-<-C MATCHSTATE:1:31:r300r900:|JdTc:c 
-S-> MATCHSTATE:1:31:r300r900c/:|JdTc/6dJc9c 
-S-> MATCHSTATE:1:31:r300r900c/r1800:|JdTc/6dJc9c 
-<-C MATCHSTATE:1:31:r300r900c/r1800:|JdTc/6dJc9c:r3600 
-S-> MATCHSTATE:1:31:r300r900c/r1800r3600:|JdTc/6dJc9c 
-S-> MATCHSTATE:1:31:r300r900c/r1800r3600r9000:|JdTc/6dJc9c 
-<-C MATCHSTATE:1:31:r300r900c/r1800r3600r9000:|JdTc/6dJc9c:c 
-S-> MATCHSTATE:1:31:r300r900c/r1800r3600r9000c/:|JdTc/6dJc9c/Kh 
-S-> MATCHSTATE:1:31:r300r900c/r1800r3600r9000c/r20000:|JdTc/6dJc9c/Kh 
-<-C MATCHSTATE:1:31:r300r900c/r1800r3600r9000c/r20000:|JdTc/6dJc9c/Kh:c 
-S-> MATCHSTATE:1:31:r300r900c/r1800r3600r9000c/r20000c/:KsJs|JdTc/6dJc9c/Kh/Qc 
-Three player limit Texas Hold'em
-S-> MATCHSTATE:2:55::||AsTs 
-<-C MATCHSTATE:2:55::||AsTs:r 
-S-> MATCHSTATE:2:55:r:||AsTs 
-S-> MATCHSTATE:2:55:rc:||AsTs 
-S-> MATCHSTATE:2:55:rcc/:||AsTs/4cJh8h 
-S-> MATCHSTATE:2:55:rcc/r:||AsTs/4cJh8h 
-S-> MATCHSTATE:2:55:rcc/rf:||AsTs/4cJh8h 
-<-C MATCHSTATE:2:55:rcc/rf:||AsTs/4cJh8h:c 
-S-> MATCHSTATE:2:55:rcc/rfc/:||AsTs/4cJh8h/Kd 
-S-> MATCHSTATE:2:55:rcc/rfc/r:||AsTs/4cJh8h/Kd 
-<-C MATCHSTATE:2:55:rcc/rfc/r:||AsTs/4cJh8h/Kd:c 
-S-> MATCHSTATE:2:55:rcc/rfc/rc/:||AsTs/4cJh8h/Kd/8c 
-S-> MATCHSTATE:2:55:rcc/rfc/rc/r:||AsTs/4cJh8h/Kd/8c 
-<-C MATCHSTATE:2:55:rcc/rfc/rc/r:||AsTs/4cJh8h/Kd/8c:f 
-S-> MATCHSTATE:2:55:rcc/rfc/rc/rf:||AsTs/4cJh8h/Kd/8c 
-S-> MATCHSTATE:0:90::Ad6h|| 
-S-> MATCHSTATE:0:90:c:Ad6h|| 
-<-C MATCHSTATE:0:90:c:Ad6h||:r 
-S-> MATCHSTATE:0:90:cr:Ad6h|| 
-S-> MATCHSTATE:0:90:crf:Ad6h|| 
-S-> MATCHSTATE:0:90:crfc/:Ad6h||/TsKd7h 
-<-C MATCHSTATE:0:90:crfc/:Ad6h||/TsKd7h:r 
-S-> MATCHSTATE:0:90:crfc/r:Ad6h||/TsKd7h 
-S-> MATCHSTATE:0:90:crfc/rc/:Ad6h||/TsKd7h/Kh 
-<-C MATCHSTATE:0:90:crfc/rc/:Ad6h||/TsKd7h/Kh:r 
-S-> MATCHSTATE:0:90:crfc/rc/r:Ad6h||/TsKd7h/Kh 
-S-> MATCHSTATE:0:90:crfc/rc/rc/:Ad6h||/TsKd7h/Kh/6d 
-<-C MATCHSTATE:0:90:crfc/rc/rc/:Ad6h||/TsKd7h/Kh/6d:r 
-S-> MATCHSTATE:0:90:crfc/rc/rc/r:Ad6h||/TsKd7h/Kh/6d 
-S-> MATCHSTATE:0:90:crfc/rc/rc/rc:Ad6h||Td2h/TsKd7h/Kh/6d