*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
package spew
import (
"fmt"
"io"
)
// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
// passed with a default Formatter interface returned by NewFormatter. It
// returns the formatted string as a value that satisfies error. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Errorf(format, spew.NewFormatter(a), spew.NewFormatter(b))
func Errorf(format string, a ...interface{}) (err error) {
return fmt.Errorf(format, convertArgs(a)...)
}
// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
// passed with a default Formatter interface returned by NewFormatter. It
// returns the number of bytes written and any write error encountered. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Fprint(w, spew.NewFormatter(a), spew.NewFormatter(b))
func Fprint(w io.Writer, a ...interface{}) (n int, err error) {
return fmt.Fprint(w, convertArgs(a)...)
}
// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
// passed with a default Formatter interface returned by NewFormatter. It
// returns the number of bytes written and any write error encountered. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Fprintf(w, format, spew.NewFormatter(a), spew.NewFormatter(b))
func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
return fmt.Fprintf(w, format, convertArgs(a)...)
}
// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
// passed with a default Formatter interface returned by NewFormatter. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Fprintln(w, spew.NewFormatter(a), spew.NewFormatter(b))
func Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
return fmt.Fprintln(w, convertArgs(a)...)
}
// Print is a wrapper for fmt.Print that treats each argument as if it were
// passed with a default Formatter interface returned by NewFormatter. It
// returns the number of bytes written and any write error encountered. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Print(spew.NewFormatter(a), spew.NewFormatter(b))
func Print(a ...interface{}) (n int, err error) {
return fmt.Print(convertArgs(a)...)
}
// Printf is a wrapper for fmt.Printf that treats each argument as if it were
// passed with a default Formatter interface returned by NewFormatter. It
// returns the number of bytes written and any write error encountered. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Printf(format, spew.NewFormatter(a), spew.NewFormatter(b))
func Printf(format string, a ...interface{}) (n int, err error) {
return fmt.Printf(format, convertArgs(a)...)
}
// Println is a wrapper for fmt.Println that treats each argument as if it were
// passed with a default Formatter interface returned by NewFormatter. It
// returns the number of bytes written and any write error encountered. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Println(spew.NewFormatter(a), spew.NewFormatter(b))
func Println(a ...interface{}) (n int, err error) {
return fmt.Println(convertArgs(a)...)
}
// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
// passed with a default Formatter interface returned by NewFormatter. It
// returns the resulting string. See NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Sprint(spew.NewFormatter(a), spew.NewFormatter(b))
func Sprint(a ...interface{}) string {
return fmt.Sprint(convertArgs(a)...)
}
// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
// passed with a default Formatter interface returned by NewFormatter. It
// returns the resulting string. See NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Sprintf(format, spew.NewFormatter(a), spew.NewFormatter(b))
func Sprintf(format string, a ...interface{}) string {
return fmt.Sprintf(format, convertArgs(a)...)
}
// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
// were passed with a default Formatter interface returned by NewFormatter. It
// returns the resulting string. See NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Sprintln(spew.NewFormatter(a), spew.NewFormatter(b))
func Sprintln(a ...interface{}) string {
return fmt.Sprintln(convertArgs(a)...)
}
// convertArgs accepts a slice of arguments and returns a slice of the same
// length with each argument converted to a default spew Formatter interface.
func convertArgs(args []interface{}) (formatters []interface{}) {
formatters = make([]interface{}, len(args))
for index, arg := range args {
formatters[index] = NewFormatter(arg)
}
return formatters
}
================================================
FILE: src/github.com/stretchr/testify/vendor/github.com/pmezard/go-difflib/LICENSE
================================================
Copyright (c) 2013, Patrick Mezard
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
The names of its contributors may not be used to endorse or promote
products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: src/github.com/stretchr/testify/vendor/github.com/pmezard/go-difflib/difflib/difflib.go
================================================
// Package difflib is a partial port of Python difflib module.
//
// It provides tools to compare sequences of strings and generate textual diffs.
//
// The following class and functions have been ported:
//
// - SequenceMatcher
//
// - unified_diff
//
// - context_diff
//
// Getting unified diffs was the main goal of the port. Keep in mind this code
// is mostly suitable to output text differences in a human friendly way, there
// are no guarantees generated diffs are consumable by patch(1).
package difflib
import (
"bufio"
"bytes"
"fmt"
"io"
"strings"
)
func min(a, b int) int {
if a < b {
return a
}
return b
}
func max(a, b int) int {
if a > b {
return a
}
return b
}
func calculateRatio(matches, length int) float64 {
if length > 0 {
return 2.0 * float64(matches) / float64(length)
}
return 1.0
}
type Match struct {
A int
B int
Size int
}
type OpCode struct {
Tag byte
I1 int
I2 int
J1 int
J2 int
}
// SequenceMatcher compares sequence of strings. The basic
// algorithm predates, and is a little fancier than, an algorithm
// published in the late 1980's by Ratcliff and Obershelp under the
// hyperbolic name "gestalt pattern matching". The basic idea is to find
// the longest contiguous matching subsequence that contains no "junk"
// elements (R-O doesn't address junk). The same idea is then applied
// recursively to the pieces of the sequences to the left and to the right
// of the matching subsequence. This does not yield minimal edit
// sequences, but does tend to yield matches that "look right" to people.
//
// SequenceMatcher tries to compute a "human-friendly diff" between two
// sequences. Unlike e.g. UNIX(tm) diff, the fundamental notion is the
// longest *contiguous* & junk-free matching subsequence. That's what
// catches peoples' eyes. The Windows(tm) windiff has another interesting
// notion, pairing up elements that appear uniquely in each sequence.
// That, and the method here, appear to yield more intuitive difference
// reports than does diff. This method appears to be the least vulnerable
// to synching up on blocks of "junk lines", though (like blank lines in
// ordinary text files, or maybe "" lines in HTML files). That may be
// because this is the only method of the 3 that has a *concept* of
// "junk" .
//
// Timing: Basic R-O is cubic time worst case and quadratic time expected
// case. SequenceMatcher is quadratic time for the worst case and has
// expected-case behavior dependent in a complicated way on how many
// elements the sequences have in common; best case time is linear.
type SequenceMatcher struct {
a []string
b []string
b2j map[string][]int
IsJunk func(string) bool
autoJunk bool
bJunk map[string]struct{}
matchingBlocks []Match
fullBCount map[string]int
bPopular map[string]struct{}
opCodes []OpCode
}
func NewMatcher(a, b []string) *SequenceMatcher {
m := SequenceMatcher{autoJunk: true}
m.SetSeqs(a, b)
return &m
}
func NewMatcherWithJunk(a, b []string, autoJunk bool,
isJunk func(string) bool) *SequenceMatcher {
m := SequenceMatcher{IsJunk: isJunk, autoJunk: autoJunk}
m.SetSeqs(a, b)
return &m
}
// Set two sequences to be compared.
func (m *SequenceMatcher) SetSeqs(a, b []string) {
m.SetSeq1(a)
m.SetSeq2(b)
}
// Set the first sequence to be compared. The second sequence to be compared is
// not changed.
//
// SequenceMatcher computes and caches detailed information about the second
// sequence, so if you want to compare one sequence S against many sequences,
// use .SetSeq2(s) once and call .SetSeq1(x) repeatedly for each of the other
// sequences.
//
// See also SetSeqs() and SetSeq2().
func (m *SequenceMatcher) SetSeq1(a []string) {
if &a == &m.a {
return
}
m.a = a
m.matchingBlocks = nil
m.opCodes = nil
}
// Set the second sequence to be compared. The first sequence to be compared is
// not changed.
func (m *SequenceMatcher) SetSeq2(b []string) {
if &b == &m.b {
return
}
m.b = b
m.matchingBlocks = nil
m.opCodes = nil
m.fullBCount = nil
m.chainB()
}
func (m *SequenceMatcher) chainB() {
// Populate line -> index mapping
b2j := map[string][]int{}
for i, s := range m.b {
indices := b2j[s]
indices = append(indices, i)
b2j[s] = indices
}
// Purge junk elements
m.bJunk = map[string]struct{}{}
if m.IsJunk != nil {
junk := m.bJunk
for s, _ := range b2j {
if m.IsJunk(s) {
junk[s] = struct{}{}
}
}
for s, _ := range junk {
delete(b2j, s)
}
}
// Purge remaining popular elements
popular := map[string]struct{}{}
n := len(m.b)
if m.autoJunk && n >= 200 {
ntest := n/100 + 1
for s, indices := range b2j {
if len(indices) > ntest {
popular[s] = struct{}{}
}
}
for s, _ := range popular {
delete(b2j, s)
}
}
m.bPopular = popular
m.b2j = b2j
}
func (m *SequenceMatcher) isBJunk(s string) bool {
_, ok := m.bJunk[s]
return ok
}
// Find longest matching block in a[alo:ahi] and b[blo:bhi].
//
// If IsJunk is not defined:
//
// Return (i,j,k) such that a[i:i+k] is equal to b[j:j+k], where
// alo <= i <= i+k <= ahi
// blo <= j <= j+k <= bhi
// and for all (i',j',k') meeting those conditions,
// k >= k'
// i <= i'
// and if i == i', j <= j'
//
// In other words, of all maximal matching blocks, return one that
// starts earliest in a, and of all those maximal matching blocks that
// start earliest in a, return the one that starts earliest in b.
//
// If IsJunk is defined, first the longest matching block is
// determined as above, but with the additional restriction that no
// junk element appears in the block. Then that block is extended as
// far as possible by matching (only) junk elements on both sides. So
// the resulting block never matches on junk except as identical junk
// happens to be adjacent to an "interesting" match.
//
// If no blocks match, return (alo, blo, 0).
func (m *SequenceMatcher) findLongestMatch(alo, ahi, blo, bhi int) Match {
// CAUTION: stripping common prefix or suffix would be incorrect.
// E.g.,
// ab
// acab
// Longest matching block is "ab", but if common prefix is
// stripped, it's "a" (tied with "b"). UNIX(tm) diff does so
// strip, so ends up claiming that ab is changed to acab by
// inserting "ca" in the middle. That's minimal but unintuitive:
// "it's obvious" that someone inserted "ac" at the front.
// Windiff ends up at the same place as diff, but by pairing up
// the unique 'b's and then matching the first two 'a's.
besti, bestj, bestsize := alo, blo, 0
// find longest junk-free match
// during an iteration of the loop, j2len[j] = length of longest
// junk-free match ending with a[i-1] and b[j]
j2len := map[int]int{}
for i := alo; i != ahi; i++ {
// look at all instances of a[i] in b; note that because
// b2j has no junk keys, the loop is skipped if a[i] is junk
newj2len := map[int]int{}
for _, j := range m.b2j[m.a[i]] {
// a[i] matches b[j]
if j < blo {
continue
}
if j >= bhi {
break
}
k := j2len[j-1] + 1
newj2len[j] = k
if k > bestsize {
besti, bestj, bestsize = i-k+1, j-k+1, k
}
}
j2len = newj2len
}
// Extend the best by non-junk elements on each end. In particular,
// "popular" non-junk elements aren't in b2j, which greatly speeds
// the inner loop above, but also means "the best" match so far
// doesn't contain any junk *or* popular non-junk elements.
for besti > alo && bestj > blo && !m.isBJunk(m.b[bestj-1]) &&
m.a[besti-1] == m.b[bestj-1] {
besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
}
for besti+bestsize < ahi && bestj+bestsize < bhi &&
!m.isBJunk(m.b[bestj+bestsize]) &&
m.a[besti+bestsize] == m.b[bestj+bestsize] {
bestsize += 1
}
// Now that we have a wholly interesting match (albeit possibly
// empty!), we may as well suck up the matching junk on each
// side of it too. Can't think of a good reason not to, and it
// saves post-processing the (possibly considerable) expense of
// figuring out what to do with it. In the case of an empty
// interesting match, this is clearly the right thing to do,
// because no other kind of match is possible in the regions.
for besti > alo && bestj > blo && m.isBJunk(m.b[bestj-1]) &&
m.a[besti-1] == m.b[bestj-1] {
besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
}
for besti+bestsize < ahi && bestj+bestsize < bhi &&
m.isBJunk(m.b[bestj+bestsize]) &&
m.a[besti+bestsize] == m.b[bestj+bestsize] {
bestsize += 1
}
return Match{A: besti, B: bestj, Size: bestsize}
}
// Return list of triples describing matching subsequences.
//
// Each triple is of the form (i, j, n), and means that
// a[i:i+n] == b[j:j+n]. The triples are monotonically increasing in
// i and in j. It's also guaranteed that if (i, j, n) and (i', j', n') are
// adjacent triples in the list, and the second is not the last triple in the
// list, then i+n != i' or j+n != j'. IOW, adjacent triples never describe
// adjacent equal blocks.
//
// The last triple is a dummy, (len(a), len(b), 0), and is the only
// triple with n==0.
func (m *SequenceMatcher) GetMatchingBlocks() []Match {
if m.matchingBlocks != nil {
return m.matchingBlocks
}
var matchBlocks func(alo, ahi, blo, bhi int, matched []Match) []Match
matchBlocks = func(alo, ahi, blo, bhi int, matched []Match) []Match {
match := m.findLongestMatch(alo, ahi, blo, bhi)
i, j, k := match.A, match.B, match.Size
if match.Size > 0 {
if alo < i && blo < j {
matched = matchBlocks(alo, i, blo, j, matched)
}
matched = append(matched, match)
if i+k < ahi && j+k < bhi {
matched = matchBlocks(i+k, ahi, j+k, bhi, matched)
}
}
return matched
}
matched := matchBlocks(0, len(m.a), 0, len(m.b), nil)
// It's possible that we have adjacent equal blocks in the
// matching_blocks list now.
nonAdjacent := []Match{}
i1, j1, k1 := 0, 0, 0
for _, b := range matched {
// Is this block adjacent to i1, j1, k1?
i2, j2, k2 := b.A, b.B, b.Size
if i1+k1 == i2 && j1+k1 == j2 {
// Yes, so collapse them -- this just increases the length of
// the first block by the length of the second, and the first
// block so lengthened remains the block to compare against.
k1 += k2
} else {
// Not adjacent. Remember the first block (k1==0 means it's
// the dummy we started with), and make the second block the
// new block to compare against.
if k1 > 0 {
nonAdjacent = append(nonAdjacent, Match{i1, j1, k1})
}
i1, j1, k1 = i2, j2, k2
}
}
if k1 > 0 {
nonAdjacent = append(nonAdjacent, Match{i1, j1, k1})
}
nonAdjacent = append(nonAdjacent, Match{len(m.a), len(m.b), 0})
m.matchingBlocks = nonAdjacent
return m.matchingBlocks
}
// Return list of 5-tuples describing how to turn a into b.
//
// Each tuple is of the form (tag, i1, i2, j1, j2). The first tuple
// has i1 == j1 == 0, and remaining tuples have i1 == the i2 from the
// tuple preceding it, and likewise for j1 == the previous j2.
//
// The tags are characters, with these meanings:
//
// 'r' (replace): a[i1:i2] should be replaced by b[j1:j2]
//
// 'd' (delete): a[i1:i2] should be deleted, j1==j2 in this case.
//
// 'i' (insert): b[j1:j2] should be inserted at a[i1:i1], i1==i2 in this case.
//
// 'e' (equal): a[i1:i2] == b[j1:j2]
func (m *SequenceMatcher) GetOpCodes() []OpCode {
if m.opCodes != nil {
return m.opCodes
}
i, j := 0, 0
matching := m.GetMatchingBlocks()
opCodes := make([]OpCode, 0, len(matching))
for _, m := range matching {
// invariant: we've pumped out correct diffs to change
// a[:i] into b[:j], and the next matching block is
// a[ai:ai+size] == b[bj:bj+size]. So we need to pump
// out a diff to change a[i:ai] into b[j:bj], pump out
// the matching block, and move (i,j) beyond the match
ai, bj, size := m.A, m.B, m.Size
tag := byte(0)
if i < ai && j < bj {
tag = 'r'
} else if i < ai {
tag = 'd'
} else if j < bj {
tag = 'i'
}
if tag > 0 {
opCodes = append(opCodes, OpCode{tag, i, ai, j, bj})
}
i, j = ai+size, bj+size
// the list of matching blocks is terminated by a
// sentinel with size 0
if size > 0 {
opCodes = append(opCodes, OpCode{'e', ai, i, bj, j})
}
}
m.opCodes = opCodes
return m.opCodes
}
// Isolate change clusters by eliminating ranges with no changes.
//
// Return a generator of groups with up to n lines of context.
// Each group is in the same format as returned by GetOpCodes().
func (m *SequenceMatcher) GetGroupedOpCodes(n int) [][]OpCode {
if n < 0 {
n = 3
}
codes := m.GetOpCodes()
if len(codes) == 0 {
codes = []OpCode{OpCode{'e', 0, 1, 0, 1}}
}
// Fixup leading and trailing groups if they show no changes.
if codes[0].Tag == 'e' {
c := codes[0]
i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
codes[0] = OpCode{c.Tag, max(i1, i2-n), i2, max(j1, j2-n), j2}
}
if codes[len(codes)-1].Tag == 'e' {
c := codes[len(codes)-1]
i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
codes[len(codes)-1] = OpCode{c.Tag, i1, min(i2, i1+n), j1, min(j2, j1+n)}
}
nn := n + n
groups := [][]OpCode{}
group := []OpCode{}
for _, c := range codes {
i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
// End the current group and start a new one whenever
// there is a large range with no changes.
if c.Tag == 'e' && i2-i1 > nn {
group = append(group, OpCode{c.Tag, i1, min(i2, i1+n),
j1, min(j2, j1+n)})
groups = append(groups, group)
group = []OpCode{}
i1, j1 = max(i1, i2-n), max(j1, j2-n)
}
group = append(group, OpCode{c.Tag, i1, i2, j1, j2})
}
if len(group) > 0 && !(len(group) == 1 && group[0].Tag == 'e') {
groups = append(groups, group)
}
return groups
}
// Return a measure of the sequences' similarity (float in [0,1]).
//
// Where T is the total number of elements in both sequences, and
// M is the number of matches, this is 2.0*M / T.
// Note that this is 1 if the sequences are identical, and 0 if
// they have nothing in common.
//
// .Ratio() is expensive to compute if you haven't already computed
// .GetMatchingBlocks() or .GetOpCodes(), in which case you may
// want to try .QuickRatio() or .RealQuickRation() first to get an
// upper bound.
func (m *SequenceMatcher) Ratio() float64 {
matches := 0
for _, m := range m.GetMatchingBlocks() {
matches += m.Size
}
return calculateRatio(matches, len(m.a)+len(m.b))
}
// Return an upper bound on ratio() relatively quickly.
//
// This isn't defined beyond that it is an upper bound on .Ratio(), and
// is faster to compute.
func (m *SequenceMatcher) QuickRatio() float64 {
// viewing a and b as multisets, set matches to the cardinality
// of their intersection; this counts the number of matches
// without regard to order, so is clearly an upper bound
if m.fullBCount == nil {
m.fullBCount = map[string]int{}
for _, s := range m.b {
m.fullBCount[s] = m.fullBCount[s] + 1
}
}
// avail[x] is the number of times x appears in 'b' less the
// number of times we've seen it in 'a' so far ... kinda
avail := map[string]int{}
matches := 0
for _, s := range m.a {
n, ok := avail[s]
if !ok {
n = m.fullBCount[s]
}
avail[s] = n - 1
if n > 0 {
matches += 1
}
}
return calculateRatio(matches, len(m.a)+len(m.b))
}
// Return an upper bound on ratio() very quickly.
//
// This isn't defined beyond that it is an upper bound on .Ratio(), and
// is faster to compute than either .Ratio() or .QuickRatio().
func (m *SequenceMatcher) RealQuickRatio() float64 {
la, lb := len(m.a), len(m.b)
return calculateRatio(min(la, lb), la+lb)
}
// Convert range to the "ed" format
func formatRangeUnified(start, stop int) string {
// Per the diff spec at http://www.unix.org/single_unix_specification/
beginning := start + 1 // lines start numbering with one
length := stop - start
if length == 1 {
return fmt.Sprintf("%d", beginning)
}
if length == 0 {
beginning -= 1 // empty ranges begin at line just before the range
}
return fmt.Sprintf("%d,%d", beginning, length)
}
// Unified diff parameters
type UnifiedDiff struct {
A []string // First sequence lines
FromFile string // First file name
FromDate string // First file time
B []string // Second sequence lines
ToFile string // Second file name
ToDate string // Second file time
Eol string // Headers end of line, defaults to LF
Context int // Number of context lines
}
// Compare two sequences of lines; generate the delta as a unified diff.
//
// Unified diffs are a compact way of showing line changes and a few
// lines of context. The number of context lines is set by 'n' which
// defaults to three.
//
// By default, the diff control lines (those with ---, +++, or @@) are
// created with a trailing newline. This is helpful so that inputs
// created from file.readlines() result in diffs that are suitable for
// file.writelines() since both the inputs and outputs have trailing
// newlines.
//
// For inputs that do not have trailing newlines, set the lineterm
// argument to "" so that the output will be uniformly newline free.
//
// The unidiff format normally has a header for filenames and modification
// times. Any or all of these may be specified using strings for
// 'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.
// The modification times are normally expressed in the ISO 8601 format.
func WriteUnifiedDiff(writer io.Writer, diff UnifiedDiff) error {
buf := bufio.NewWriter(writer)
defer buf.Flush()
wf := func(format string, args ...interface{}) error {
_, err := buf.WriteString(fmt.Sprintf(format, args...))
return err
}
ws := func(s string) error {
_, err := buf.WriteString(s)
return err
}
if len(diff.Eol) == 0 {
diff.Eol = "\n"
}
started := false
m := NewMatcher(diff.A, diff.B)
for _, g := range m.GetGroupedOpCodes(diff.Context) {
if !started {
started = true
fromDate := ""
if len(diff.FromDate) > 0 {
fromDate = "\t" + diff.FromDate
}
toDate := ""
if len(diff.ToDate) > 0 {
toDate = "\t" + diff.ToDate
}
if diff.FromFile != "" || diff.ToFile != "" {
err := wf("--- %s%s%s", diff.FromFile, fromDate, diff.Eol)
if err != nil {
return err
}
err = wf("+++ %s%s%s", diff.ToFile, toDate, diff.Eol)
if err != nil {
return err
}
}
}
first, last := g[0], g[len(g)-1]
range1 := formatRangeUnified(first.I1, last.I2)
range2 := formatRangeUnified(first.J1, last.J2)
if err := wf("@@ -%s +%s @@%s", range1, range2, diff.Eol); err != nil {
return err
}
for _, c := range g {
i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
if c.Tag == 'e' {
for _, line := range diff.A[i1:i2] {
if err := ws(" " + line); err != nil {
return err
}
}
continue
}
if c.Tag == 'r' || c.Tag == 'd' {
for _, line := range diff.A[i1:i2] {
if err := ws("-" + line); err != nil {
return err
}
}
}
if c.Tag == 'r' || c.Tag == 'i' {
for _, line := range diff.B[j1:j2] {
if err := ws("+" + line); err != nil {
return err
}
}
}
}
}
return nil
}
// Like WriteUnifiedDiff but returns the diff a string.
func GetUnifiedDiffString(diff UnifiedDiff) (string, error) {
w := &bytes.Buffer{}
err := WriteUnifiedDiff(w, diff)
return string(w.Bytes()), err
}
// Convert range to the "ed" format.
func formatRangeContext(start, stop int) string {
// Per the diff spec at http://www.unix.org/single_unix_specification/
beginning := start + 1 // lines start numbering with one
length := stop - start
if length == 0 {
beginning -= 1 // empty ranges begin at line just before the range
}
if length <= 1 {
return fmt.Sprintf("%d", beginning)
}
return fmt.Sprintf("%d,%d", beginning, beginning+length-1)
}
type ContextDiff UnifiedDiff
// Compare two sequences of lines; generate the delta as a context diff.
//
// Context diffs are a compact way of showing line changes and a few
// lines of context. The number of context lines is set by diff.Context
// which defaults to three.
//
// By default, the diff control lines (those with *** or ---) are
// created with a trailing newline.
//
// For inputs that do not have trailing newlines, set the diff.Eol
// argument to "" so that the output will be uniformly newline free.
//
// The context diff format normally has a header for filenames and
// modification times. Any or all of these may be specified using
// strings for diff.FromFile, diff.ToFile, diff.FromDate, diff.ToDate.
// The modification times are normally expressed in the ISO 8601 format.
// If not specified, the strings default to blanks.
func WriteContextDiff(writer io.Writer, diff ContextDiff) error {
buf := bufio.NewWriter(writer)
defer buf.Flush()
var diffErr error
wf := func(format string, args ...interface{}) {
_, err := buf.WriteString(fmt.Sprintf(format, args...))
if diffErr == nil && err != nil {
diffErr = err
}
}
ws := func(s string) {
_, err := buf.WriteString(s)
if diffErr == nil && err != nil {
diffErr = err
}
}
if len(diff.Eol) == 0 {
diff.Eol = "\n"
}
prefix := map[byte]string{
'i': "+ ",
'd': "- ",
'r': "! ",
'e': " ",
}
started := false
m := NewMatcher(diff.A, diff.B)
for _, g := range m.GetGroupedOpCodes(diff.Context) {
if !started {
started = true
fromDate := ""
if len(diff.FromDate) > 0 {
fromDate = "\t" + diff.FromDate
}
toDate := ""
if len(diff.ToDate) > 0 {
toDate = "\t" + diff.ToDate
}
if diff.FromFile != "" || diff.ToFile != "" {
wf("*** %s%s%s", diff.FromFile, fromDate, diff.Eol)
wf("--- %s%s%s", diff.ToFile, toDate, diff.Eol)
}
}
first, last := g[0], g[len(g)-1]
ws("***************" + diff.Eol)
range1 := formatRangeContext(first.I1, last.I2)
wf("*** %s ****%s", range1, diff.Eol)
for _, c := range g {
if c.Tag == 'r' || c.Tag == 'd' {
for _, cc := range g {
if cc.Tag == 'i' {
continue
}
for _, line := range diff.A[cc.I1:cc.I2] {
ws(prefix[cc.Tag] + line)
}
}
break
}
}
range2 := formatRangeContext(first.J1, last.J2)
wf("--- %s ----%s", range2, diff.Eol)
for _, c := range g {
if c.Tag == 'r' || c.Tag == 'i' {
for _, cc := range g {
if cc.Tag == 'd' {
continue
}
for _, line := range diff.B[cc.J1:cc.J2] {
ws(prefix[cc.Tag] + line)
}
}
break
}
}
}
return diffErr
}
// Like WriteContextDiff but returns the diff a string.
func GetContextDiffString(diff ContextDiff) (string, error) {
w := &bytes.Buffer{}
err := WriteContextDiff(w, diff)
return string(w.Bytes()), err
}
// Split a string on "\n" while preserving them. The output can be used
// as input for UnifiedDiff and ContextDiff structures.
func SplitLines(s string) []string {
lines := strings.SplitAfter(s, "\n")
lines[len(lines)-1] += "\n"
return lines
}
================================================
FILE: src/github.com/stretchr/testify/vendor/github.com/stretchr/objx/LICENSE
================================================
The MIT License
Copyright (c) 2014 Stretchr, Inc.
Copyright (c) 2017-2018 objx contributors
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: src/github.com/stretchr/testify/vendor/github.com/stretchr/objx/accessors.go
================================================
package objx
import (
"fmt"
"regexp"
"strconv"
"strings"
)
// arrayAccesRegexString is the regex used to extract the array number
// from the access path
const arrayAccesRegexString = `^(.+)\[([0-9]+)\]$`
// arrayAccesRegex is the compiled arrayAccesRegexString
var arrayAccesRegex = regexp.MustCompile(arrayAccesRegexString)
// Get gets the value using the specified selector and
// returns it inside a new Obj object.
//
// If it cannot find the value, Get will return a nil
// value inside an instance of Obj.
//
// Get can only operate directly on map[string]interface{} and []interface.
//
// Example
//
// To access the title of the third chapter of the second book, do:
//
// o.Get("books[1].chapters[2].title")
func (m Map) Get(selector string) *Value {
rawObj := access(m, selector, nil, false, false)
return &Value{data: rawObj}
}
// Set sets the value using the specified selector and
// returns the object on which Set was called.
//
// Set can only operate directly on map[string]interface{} and []interface
//
// Example
//
// To set the title of the third chapter of the second book, do:
//
// o.Set("books[1].chapters[2].title","Time to Go")
func (m Map) Set(selector string, value interface{}) Map {
access(m, selector, value, true, false)
return m
}
// access accesses the object using the selector and performs the
// appropriate action.
func access(current, selector, value interface{}, isSet, panics bool) interface{} {
switch selector.(type) {
case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
if array, ok := current.([]interface{}); ok {
index := intFromInterface(selector)
if index >= len(array) {
if panics {
panic(fmt.Sprintf("objx: Index %d is out of range. Slice only contains %d items.", index, len(array)))
}
return nil
}
return array[index]
}
return nil
case string:
selStr := selector.(string)
selSegs := strings.SplitN(selStr, PathSeparator, 2)
thisSel := selSegs[0]
index := -1
var err error
if strings.Contains(thisSel, "[") {
arrayMatches := arrayAccesRegex.FindStringSubmatch(thisSel)
if len(arrayMatches) > 0 {
// Get the key into the map
thisSel = arrayMatches[1]
// Get the index into the array at the key
index, err = strconv.Atoi(arrayMatches[2])
if err != nil {
// This should never happen. If it does, something has gone
// seriously wrong. Panic.
panic("objx: Array index is not an integer. Must use array[int].")
}
}
}
if curMap, ok := current.(Map); ok {
current = map[string]interface{}(curMap)
}
// get the object in question
switch current.(type) {
case map[string]interface{}:
curMSI := current.(map[string]interface{})
if len(selSegs) <= 1 && isSet {
curMSI[thisSel] = value
return nil
}
current = curMSI[thisSel]
default:
current = nil
}
if current == nil && panics {
panic(fmt.Sprintf("objx: '%v' invalid on object.", selector))
}
// do we need to access the item of an array?
if index > -1 {
if array, ok := current.([]interface{}); ok {
if index < len(array) {
current = array[index]
} else {
if panics {
panic(fmt.Sprintf("objx: Index %d is out of range. Slice only contains %d items.", index, len(array)))
}
current = nil
}
}
}
if len(selSegs) > 1 {
current = access(current, selSegs[1], value, isSet, panics)
}
}
return current
}
// intFromInterface converts an interface object to the largest
// representation of an unsigned integer using a type switch and
// assertions
func intFromInterface(selector interface{}) int {
var value int
switch selector.(type) {
case int:
value = selector.(int)
case int8:
value = int(selector.(int8))
case int16:
value = int(selector.(int16))
case int32:
value = int(selector.(int32))
case int64:
value = int(selector.(int64))
case uint:
value = int(selector.(uint))
case uint8:
value = int(selector.(uint8))
case uint16:
value = int(selector.(uint16))
case uint32:
value = int(selector.(uint32))
case uint64:
value = int(selector.(uint64))
default:
panic("objx: array access argument is not an integer type (this should never happen)")
}
return value
}
================================================
FILE: src/github.com/stretchr/testify/vendor/github.com/stretchr/objx/constants.go
================================================
package objx
const (
// PathSeparator is the character used to separate the elements
// of the keypath.
//
// For example, `location.address.city`
PathSeparator string = "."
// SignatureSeparator is the character that is used to
// separate the Base64 string from the security signature.
SignatureSeparator = "_"
)
================================================
FILE: src/github.com/stretchr/testify/vendor/github.com/stretchr/objx/conversions.go
================================================
package objx
import (
"bytes"
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"net/url"
)
// JSON converts the contained object to a JSON string
// representation
func (m Map) JSON() (string, error) {
result, err := json.Marshal(m)
if err != nil {
err = errors.New("objx: JSON encode failed with: " + err.Error())
}
return string(result), err
}
// MustJSON converts the contained object to a JSON string
// representation and panics if there is an error
func (m Map) MustJSON() string {
result, err := m.JSON()
if err != nil {
panic(err.Error())
}
return result
}
// Base64 converts the contained object to a Base64 string
// representation of the JSON string representation
func (m Map) Base64() (string, error) {
var buf bytes.Buffer
jsonData, err := m.JSON()
if err != nil {
return "", err
}
encoder := base64.NewEncoder(base64.StdEncoding, &buf)
_, err = encoder.Write([]byte(jsonData))
if err != nil {
return "", err
}
_ = encoder.Close()
return buf.String(), nil
}
// MustBase64 converts the contained object to a Base64 string
// representation of the JSON string representation and panics
// if there is an error
func (m Map) MustBase64() string {
result, err := m.Base64()
if err != nil {
panic(err.Error())
}
return result
}
// SignedBase64 converts the contained object to a Base64 string
// representation of the JSON string representation and signs it
// using the provided key.
func (m Map) SignedBase64(key string) (string, error) {
base64, err := m.Base64()
if err != nil {
return "", err
}
sig := HashWithKey(base64, key)
return base64 + SignatureSeparator + sig, nil
}
// MustSignedBase64 converts the contained object to a Base64 string
// representation of the JSON string representation and signs it
// using the provided key and panics if there is an error
func (m Map) MustSignedBase64(key string) string {
result, err := m.SignedBase64(key)
if err != nil {
panic(err.Error())
}
return result
}
/*
URL Query
------------------------------------------------
*/
// URLValues creates a url.Values object from an Obj. This
// function requires that the wrapped object be a map[string]interface{}
func (m Map) URLValues() url.Values {
vals := make(url.Values)
for k, v := range m {
//TODO: can this be done without sprintf?
vals.Set(k, fmt.Sprintf("%v", v))
}
return vals
}
// URLQuery gets an encoded URL query representing the given
// Obj. This function requires that the wrapped object be a
// map[string]interface{}
func (m Map) URLQuery() (string, error) {
return m.URLValues().Encode(), nil
}
================================================
FILE: src/github.com/stretchr/testify/vendor/github.com/stretchr/objx/doc.go
================================================
/*
Objx - Go package for dealing with maps, slices, JSON and other data.
Overview
Objx provides the `objx.Map` type, which is a `map[string]interface{}` that exposes
a powerful `Get` method (among others) that allows you to easily and quickly get
access to data within the map, without having to worry too much about type assertions,
missing data, default values etc.
Pattern
Objx uses a preditable pattern to make access data from within `map[string]interface{}` easy.
Call one of the `objx.` functions to create your `objx.Map` to get going:
m, err := objx.FromJSON(json)
NOTE: Any methods or functions with the `Must` prefix will panic if something goes wrong,
the rest will be optimistic and try to figure things out without panicking.
Use `Get` to access the value you're interested in. You can use dot and array
notation too:
m.Get("places[0].latlng")
Once you have sought the `Value` you're interested in, you can use the `Is*` methods to determine its type.
if m.Get("code").IsStr() { // Your code... }
Or you can just assume the type, and use one of the strong type methods to extract the real value:
m.Get("code").Int()
If there's no value there (or if it's the wrong type) then a default value will be returned,
or you can be explicit about the default value.
Get("code").Int(-1)
If you're dealing with a slice of data as a value, Objx provides many useful methods for iterating,
manipulating and selecting that data. You can find out more by exploring the index below.
Reading data
A simple example of how to use Objx:
// Use MustFromJSON to make an objx.Map from some JSON
m := objx.MustFromJSON(`{"name": "Mat", "age": 30}`)
// Get the details
name := m.Get("name").Str()
age := m.Get("age").Int()
// Get their nickname (or use their name if they don't have one)
nickname := m.Get("nickname").Str(name)
Ranging
Since `objx.Map` is a `map[string]interface{}` you can treat it as such.
For example, to `range` the data, do what you would expect:
m := objx.MustFromJSON(json)
for key, value := range m {
// Your code...
}
*/
package objx
================================================
FILE: src/github.com/stretchr/testify/vendor/github.com/stretchr/objx/map.go
================================================
package objx
import (
"encoding/base64"
"encoding/json"
"errors"
"io/ioutil"
"net/url"
"strings"
)
// MSIConvertable is an interface that defines methods for converting your
// custom types to a map[string]interface{} representation.
type MSIConvertable interface {
// MSI gets a map[string]interface{} (msi) representing the
// object.
MSI() map[string]interface{}
}
// Map provides extended functionality for working with
// untyped data, in particular map[string]interface (msi).
type Map map[string]interface{}
// Value returns the internal value instance
func (m Map) Value() *Value {
return &Value{data: m}
}
// Nil represents a nil Map.
var Nil = New(nil)
// New creates a new Map containing the map[string]interface{} in the data argument.
// If the data argument is not a map[string]interface, New attempts to call the
// MSI() method on the MSIConvertable interface to create one.
func New(data interface{}) Map {
if _, ok := data.(map[string]interface{}); !ok {
if converter, ok := data.(MSIConvertable); ok {
data = converter.MSI()
} else {
return nil
}
}
return Map(data.(map[string]interface{}))
}
// MSI creates a map[string]interface{} and puts it inside a new Map.
//
// The arguments follow a key, value pattern.
//
// Panics
//
// Panics if any key argument is non-string or if there are an odd number of arguments.
//
// Example
//
// To easily create Maps:
//
// m := objx.MSI("name", "Mat", "age", 29, "subobj", objx.MSI("active", true))
//
// // creates an Map equivalent to
// m := objx.New(map[string]interface{}{"name": "Mat", "age": 29, "subobj": map[string]interface{}{"active": true}})
func MSI(keyAndValuePairs ...interface{}) Map {
newMap := make(map[string]interface{})
keyAndValuePairsLen := len(keyAndValuePairs)
if keyAndValuePairsLen%2 != 0 {
panic("objx: MSI must have an even number of arguments following the 'key, value' pattern.")
}
for i := 0; i < keyAndValuePairsLen; i = i + 2 {
key := keyAndValuePairs[i]
value := keyAndValuePairs[i+1]
// make sure the key is a string
keyString, keyStringOK := key.(string)
if !keyStringOK {
panic("objx: MSI must follow 'string, interface{}' pattern. " + keyString + " is not a valid key.")
}
newMap[keyString] = value
}
return New(newMap)
}
// ****** Conversion Constructors
// MustFromJSON creates a new Map containing the data specified in the
// jsonString.
//
// Panics if the JSON is invalid.
func MustFromJSON(jsonString string) Map {
o, err := FromJSON(jsonString)
if err != nil {
panic("objx: MustFromJSON failed with error: " + err.Error())
}
return o
}
// FromJSON creates a new Map containing the data specified in the
// jsonString.
//
// Returns an error if the JSON is invalid.
func FromJSON(jsonString string) (Map, error) {
var data interface{}
err := json.Unmarshal([]byte(jsonString), &data)
if err != nil {
return Nil, err
}
return New(data), nil
}
// FromBase64 creates a new Obj containing the data specified
// in the Base64 string.
//
// The string is an encoded JSON string returned by Base64
func FromBase64(base64String string) (Map, error) {
decoder := base64.NewDecoder(base64.StdEncoding, strings.NewReader(base64String))
decoded, err := ioutil.ReadAll(decoder)
if err != nil {
return nil, err
}
return FromJSON(string(decoded))
}
// MustFromBase64 creates a new Obj containing the data specified
// in the Base64 string and panics if there is an error.
//
// The string is an encoded JSON string returned by Base64
func MustFromBase64(base64String string) Map {
result, err := FromBase64(base64String)
if err != nil {
panic("objx: MustFromBase64 failed with error: " + err.Error())
}
return result
}
// FromSignedBase64 creates a new Obj containing the data specified
// in the Base64 string.
//
// The string is an encoded JSON string returned by SignedBase64
func FromSignedBase64(base64String, key string) (Map, error) {
parts := strings.Split(base64String, SignatureSeparator)
if len(parts) != 2 {
return nil, errors.New("objx: Signed base64 string is malformed")
}
sig := HashWithKey(parts[0], key)
if parts[1] != sig {
return nil, errors.New("objx: Signature for base64 data does not match")
}
return FromBase64(parts[0])
}
// MustFromSignedBase64 creates a new Obj containing the data specified
// in the Base64 string and panics if there is an error.
//
// The string is an encoded JSON string returned by Base64
func MustFromSignedBase64(base64String, key string) Map {
result, err := FromSignedBase64(base64String, key)
if err != nil {
panic("objx: MustFromSignedBase64 failed with error: " + err.Error())
}
return result
}
// FromURLQuery generates a new Obj by parsing the specified
// query.
//
// For queries with multiple values, the first value is selected.
func FromURLQuery(query string) (Map, error) {
vals, err := url.ParseQuery(query)
if err != nil {
return nil, err
}
m := make(map[string]interface{})
for k, vals := range vals {
m[k] = vals[0]
}
return New(m), nil
}
// MustFromURLQuery generates a new Obj by parsing the specified
// query.
//
// For queries with multiple values, the first value is selected.
//
// Panics if it encounters an error
func MustFromURLQuery(query string) Map {
o, err := FromURLQuery(query)
if err != nil {
panic("objx: MustFromURLQuery failed with error: " + err.Error())
}
return o
}
================================================
FILE: src/github.com/stretchr/testify/vendor/github.com/stretchr/objx/mutations.go
================================================
package objx
// Exclude returns a new Map with the keys in the specified []string
// excluded.
func (m Map) Exclude(exclude []string) Map {
excluded := make(Map)
for k, v := range m {
var shouldInclude = true
for _, toExclude := range exclude {
if k == toExclude {
shouldInclude = false
break
}
}
if shouldInclude {
excluded[k] = v
}
}
return excluded
}
// Copy creates a shallow copy of the Obj.
func (m Map) Copy() Map {
copied := make(map[string]interface{})
for k, v := range m {
copied[k] = v
}
return New(copied)
}
// Merge blends the specified map with a copy of this map and returns the result.
//
// Keys that appear in both will be selected from the specified map.
// This method requires that the wrapped object be a map[string]interface{}
func (m Map) Merge(merge Map) Map {
return m.Copy().MergeHere(merge)
}
// MergeHere blends the specified map with this map and returns the current map.
//
// Keys that appear in both will be selected from the specified map. The original map
// will be modified. This method requires that
// the wrapped object be a map[string]interface{}
func (m Map) MergeHere(merge Map) Map {
for k, v := range merge {
m[k] = v
}
return m
}
// Transform builds a new Obj giving the transformer a chance
// to change the keys and values as it goes. This method requires that
// the wrapped object be a map[string]interface{}
func (m Map) Transform(transformer func(key string, value interface{}) (string, interface{})) Map {
newMap := make(map[string]interface{})
for k, v := range m {
modifiedKey, modifiedVal := transformer(k, v)
newMap[modifiedKey] = modifiedVal
}
return New(newMap)
}
// TransformKeys builds a new map using the specified key mapping.
//
// Unspecified keys will be unaltered.
// This method requires that the wrapped object be a map[string]interface{}
func (m Map) TransformKeys(mapping map[string]string) Map {
return m.Transform(func(key string, value interface{}) (string, interface{}) {
if newKey, ok := mapping[key]; ok {
return newKey, value
}
return key, value
})
}
================================================
FILE: src/github.com/stretchr/testify/vendor/github.com/stretchr/objx/security.go
================================================
package objx
import (
"crypto/sha1"
"encoding/hex"
)
// HashWithKey hashes the specified string using the security
// key.
func HashWithKey(data, key string) string {
hash := sha1.New()
_, err := hash.Write([]byte(data + ":" + key))
if err != nil {
return ""
}
return hex.EncodeToString(hash.Sum(nil))
}
================================================
FILE: src/github.com/stretchr/testify/vendor/github.com/stretchr/objx/tests.go
================================================
package objx
// Has gets whether there is something at the specified selector
// or not.
//
// If m is nil, Has will always return false.
func (m Map) Has(selector string) bool {
if m == nil {
return false
}
return !m.Get(selector).IsNil()
}
// IsNil gets whether the data is nil or not.
func (v *Value) IsNil() bool {
return v == nil || v.data == nil
}
================================================
FILE: src/github.com/stretchr/testify/vendor/github.com/stretchr/objx/type_specific_codegen.go
================================================
package objx
/*
Inter (interface{} and []interface{})
*/
// Inter gets the value as a interface{}, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Inter(optionalDefault ...interface{}) interface{} {
if s, ok := v.data.(interface{}); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustInter gets the value as a interface{}.
//
// Panics if the object is not a interface{}.
func (v *Value) MustInter() interface{} {
return v.data.(interface{})
}
// InterSlice gets the value as a []interface{}, returns the optionalDefault
// value or nil if the value is not a []interface{}.
func (v *Value) InterSlice(optionalDefault ...[]interface{}) []interface{} {
if s, ok := v.data.([]interface{}); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustInterSlice gets the value as a []interface{}.
//
// Panics if the object is not a []interface{}.
func (v *Value) MustInterSlice() []interface{} {
return v.data.([]interface{})
}
// IsInter gets whether the object contained is a interface{} or not.
func (v *Value) IsInter() bool {
_, ok := v.data.(interface{})
return ok
}
// IsInterSlice gets whether the object contained is a []interface{} or not.
func (v *Value) IsInterSlice() bool {
_, ok := v.data.([]interface{})
return ok
}
// EachInter calls the specified callback for each object
// in the []interface{}.
//
// Panics if the object is the wrong type.
func (v *Value) EachInter(callback func(int, interface{}) bool) *Value {
for index, val := range v.MustInterSlice() {
carryon := callback(index, val)
if !carryon {
break
}
}
return v
}
// WhereInter uses the specified decider function to select items
// from the []interface{}. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereInter(decider func(int, interface{}) bool) *Value {
var selected []interface{}
v.EachInter(func(index int, val interface{}) bool {
shouldSelect := decider(index, val)
if !shouldSelect {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupInter uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]interface{}.
func (v *Value) GroupInter(grouper func(int, interface{}) string) *Value {
groups := make(map[string][]interface{})
v.EachInter(func(index int, val interface{}) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]interface{}, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceInter uses the specified function to replace each interface{}s
// by iterating each item. The data in the returned result will be a
// []interface{} containing the replaced items.
func (v *Value) ReplaceInter(replacer func(int, interface{}) interface{}) *Value {
arr := v.MustInterSlice()
replaced := make([]interface{}, len(arr))
v.EachInter(func(index int, val interface{}) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectInter uses the specified collector function to collect a value
// for each of the interface{}s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectInter(collector func(int, interface{}) interface{}) *Value {
arr := v.MustInterSlice()
collected := make([]interface{}, len(arr))
v.EachInter(func(index int, val interface{}) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
MSI (map[string]interface{} and []map[string]interface{})
*/
// MSI gets the value as a map[string]interface{}, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) MSI(optionalDefault ...map[string]interface{}) map[string]interface{} {
if s, ok := v.data.(map[string]interface{}); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustMSI gets the value as a map[string]interface{}.
//
// Panics if the object is not a map[string]interface{}.
func (v *Value) MustMSI() map[string]interface{} {
return v.data.(map[string]interface{})
}
// MSISlice gets the value as a []map[string]interface{}, returns the optionalDefault
// value or nil if the value is not a []map[string]interface{}.
func (v *Value) MSISlice(optionalDefault ...[]map[string]interface{}) []map[string]interface{} {
if s, ok := v.data.([]map[string]interface{}); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustMSISlice gets the value as a []map[string]interface{}.
//
// Panics if the object is not a []map[string]interface{}.
func (v *Value) MustMSISlice() []map[string]interface{} {
return v.data.([]map[string]interface{})
}
// IsMSI gets whether the object contained is a map[string]interface{} or not.
func (v *Value) IsMSI() bool {
_, ok := v.data.(map[string]interface{})
return ok
}
// IsMSISlice gets whether the object contained is a []map[string]interface{} or not.
func (v *Value) IsMSISlice() bool {
_, ok := v.data.([]map[string]interface{})
return ok
}
// EachMSI calls the specified callback for each object
// in the []map[string]interface{}.
//
// Panics if the object is the wrong type.
func (v *Value) EachMSI(callback func(int, map[string]interface{}) bool) *Value {
for index, val := range v.MustMSISlice() {
carryon := callback(index, val)
if !carryon {
break
}
}
return v
}
// WhereMSI uses the specified decider function to select items
// from the []map[string]interface{}. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereMSI(decider func(int, map[string]interface{}) bool) *Value {
var selected []map[string]interface{}
v.EachMSI(func(index int, val map[string]interface{}) bool {
shouldSelect := decider(index, val)
if !shouldSelect {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupMSI uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]map[string]interface{}.
func (v *Value) GroupMSI(grouper func(int, map[string]interface{}) string) *Value {
groups := make(map[string][]map[string]interface{})
v.EachMSI(func(index int, val map[string]interface{}) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]map[string]interface{}, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceMSI uses the specified function to replace each map[string]interface{}s
// by iterating each item. The data in the returned result will be a
// []map[string]interface{} containing the replaced items.
func (v *Value) ReplaceMSI(replacer func(int, map[string]interface{}) map[string]interface{}) *Value {
arr := v.MustMSISlice()
replaced := make([]map[string]interface{}, len(arr))
v.EachMSI(func(index int, val map[string]interface{}) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectMSI uses the specified collector function to collect a value
// for each of the map[string]interface{}s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectMSI(collector func(int, map[string]interface{}) interface{}) *Value {
arr := v.MustMSISlice()
collected := make([]interface{}, len(arr))
v.EachMSI(func(index int, val map[string]interface{}) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
ObjxMap ((Map) and [](Map))
*/
// ObjxMap gets the value as a (Map), returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) ObjxMap(optionalDefault ...(Map)) Map {
if s, ok := v.data.((Map)); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return New(nil)
}
// MustObjxMap gets the value as a (Map).
//
// Panics if the object is not a (Map).
func (v *Value) MustObjxMap() Map {
return v.data.((Map))
}
// ObjxMapSlice gets the value as a [](Map), returns the optionalDefault
// value or nil if the value is not a [](Map).
func (v *Value) ObjxMapSlice(optionalDefault ...[](Map)) [](Map) {
if s, ok := v.data.([](Map)); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustObjxMapSlice gets the value as a [](Map).
//
// Panics if the object is not a [](Map).
func (v *Value) MustObjxMapSlice() [](Map) {
return v.data.([](Map))
}
// IsObjxMap gets whether the object contained is a (Map) or not.
func (v *Value) IsObjxMap() bool {
_, ok := v.data.((Map))
return ok
}
// IsObjxMapSlice gets whether the object contained is a [](Map) or not.
func (v *Value) IsObjxMapSlice() bool {
_, ok := v.data.([](Map))
return ok
}
// EachObjxMap calls the specified callback for each object
// in the [](Map).
//
// Panics if the object is the wrong type.
func (v *Value) EachObjxMap(callback func(int, Map) bool) *Value {
for index, val := range v.MustObjxMapSlice() {
carryon := callback(index, val)
if !carryon {
break
}
}
return v
}
// WhereObjxMap uses the specified decider function to select items
// from the [](Map). The object contained in the result will contain
// only the selected items.
func (v *Value) WhereObjxMap(decider func(int, Map) bool) *Value {
var selected [](Map)
v.EachObjxMap(func(index int, val Map) bool {
shouldSelect := decider(index, val)
if !shouldSelect {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupObjxMap uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][](Map).
func (v *Value) GroupObjxMap(grouper func(int, Map) string) *Value {
groups := make(map[string][](Map))
v.EachObjxMap(func(index int, val Map) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([](Map), 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceObjxMap uses the specified function to replace each (Map)s
// by iterating each item. The data in the returned result will be a
// [](Map) containing the replaced items.
func (v *Value) ReplaceObjxMap(replacer func(int, Map) Map) *Value {
arr := v.MustObjxMapSlice()
replaced := make([](Map), len(arr))
v.EachObjxMap(func(index int, val Map) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectObjxMap uses the specified collector function to collect a value
// for each of the (Map)s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectObjxMap(collector func(int, Map) interface{}) *Value {
arr := v.MustObjxMapSlice()
collected := make([]interface{}, len(arr))
v.EachObjxMap(func(index int, val Map) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Bool (bool and []bool)
*/
// Bool gets the value as a bool, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Bool(optionalDefault ...bool) bool {
if s, ok := v.data.(bool); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return false
}
// MustBool gets the value as a bool.
//
// Panics if the object is not a bool.
func (v *Value) MustBool() bool {
return v.data.(bool)
}
// BoolSlice gets the value as a []bool, returns the optionalDefault
// value or nil if the value is not a []bool.
func (v *Value) BoolSlice(optionalDefault ...[]bool) []bool {
if s, ok := v.data.([]bool); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustBoolSlice gets the value as a []bool.
//
// Panics if the object is not a []bool.
func (v *Value) MustBoolSlice() []bool {
return v.data.([]bool)
}
// IsBool gets whether the object contained is a bool or not.
func (v *Value) IsBool() bool {
_, ok := v.data.(bool)
return ok
}
// IsBoolSlice gets whether the object contained is a []bool or not.
func (v *Value) IsBoolSlice() bool {
_, ok := v.data.([]bool)
return ok
}
// EachBool calls the specified callback for each object
// in the []bool.
//
// Panics if the object is the wrong type.
func (v *Value) EachBool(callback func(int, bool) bool) *Value {
for index, val := range v.MustBoolSlice() {
carryon := callback(index, val)
if !carryon {
break
}
}
return v
}
// WhereBool uses the specified decider function to select items
// from the []bool. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereBool(decider func(int, bool) bool) *Value {
var selected []bool
v.EachBool(func(index int, val bool) bool {
shouldSelect := decider(index, val)
if !shouldSelect {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupBool uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]bool.
func (v *Value) GroupBool(grouper func(int, bool) string) *Value {
groups := make(map[string][]bool)
v.EachBool(func(index int, val bool) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]bool, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceBool uses the specified function to replace each bools
// by iterating each item. The data in the returned result will be a
// []bool containing the replaced items.
func (v *Value) ReplaceBool(replacer func(int, bool) bool) *Value {
arr := v.MustBoolSlice()
replaced := make([]bool, len(arr))
v.EachBool(func(index int, val bool) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectBool uses the specified collector function to collect a value
// for each of the bools in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectBool(collector func(int, bool) interface{}) *Value {
arr := v.MustBoolSlice()
collected := make([]interface{}, len(arr))
v.EachBool(func(index int, val bool) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Str (string and []string)
*/
// Str gets the value as a string, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Str(optionalDefault ...string) string {
if s, ok := v.data.(string); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return ""
}
// MustStr gets the value as a string.
//
// Panics if the object is not a string.
func (v *Value) MustStr() string {
return v.data.(string)
}
// StrSlice gets the value as a []string, returns the optionalDefault
// value or nil if the value is not a []string.
func (v *Value) StrSlice(optionalDefault ...[]string) []string {
if s, ok := v.data.([]string); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustStrSlice gets the value as a []string.
//
// Panics if the object is not a []string.
func (v *Value) MustStrSlice() []string {
return v.data.([]string)
}
// IsStr gets whether the object contained is a string or not.
func (v *Value) IsStr() bool {
_, ok := v.data.(string)
return ok
}
// IsStrSlice gets whether the object contained is a []string or not.
func (v *Value) IsStrSlice() bool {
_, ok := v.data.([]string)
return ok
}
// EachStr calls the specified callback for each object
// in the []string.
//
// Panics if the object is the wrong type.
func (v *Value) EachStr(callback func(int, string) bool) *Value {
for index, val := range v.MustStrSlice() {
carryon := callback(index, val)
if !carryon {
break
}
}
return v
}
// WhereStr uses the specified decider function to select items
// from the []string. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereStr(decider func(int, string) bool) *Value {
var selected []string
v.EachStr(func(index int, val string) bool {
shouldSelect := decider(index, val)
if !shouldSelect {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupStr uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]string.
func (v *Value) GroupStr(grouper func(int, string) string) *Value {
groups := make(map[string][]string)
v.EachStr(func(index int, val string) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]string, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceStr uses the specified function to replace each strings
// by iterating each item. The data in the returned result will be a
// []string containing the replaced items.
func (v *Value) ReplaceStr(replacer func(int, string) string) *Value {
arr := v.MustStrSlice()
replaced := make([]string, len(arr))
v.EachStr(func(index int, val string) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectStr uses the specified collector function to collect a value
// for each of the strings in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectStr(collector func(int, string) interface{}) *Value {
arr := v.MustStrSlice()
collected := make([]interface{}, len(arr))
v.EachStr(func(index int, val string) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Int (int and []int)
*/
// Int gets the value as a int, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Int(optionalDefault ...int) int {
if s, ok := v.data.(int); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustInt gets the value as a int.
//
// Panics if the object is not a int.
func (v *Value) MustInt() int {
return v.data.(int)
}
// IntSlice gets the value as a []int, returns the optionalDefault
// value or nil if the value is not a []int.
func (v *Value) IntSlice(optionalDefault ...[]int) []int {
if s, ok := v.data.([]int); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustIntSlice gets the value as a []int.
//
// Panics if the object is not a []int.
func (v *Value) MustIntSlice() []int {
return v.data.([]int)
}
// IsInt gets whether the object contained is a int or not.
func (v *Value) IsInt() bool {
_, ok := v.data.(int)
return ok
}
// IsIntSlice gets whether the object contained is a []int or not.
func (v *Value) IsIntSlice() bool {
_, ok := v.data.([]int)
return ok
}
// EachInt calls the specified callback for each object
// in the []int.
//
// Panics if the object is the wrong type.
func (v *Value) EachInt(callback func(int, int) bool) *Value {
for index, val := range v.MustIntSlice() {
carryon := callback(index, val)
if !carryon {
break
}
}
return v
}
// WhereInt uses the specified decider function to select items
// from the []int. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereInt(decider func(int, int) bool) *Value {
var selected []int
v.EachInt(func(index int, val int) bool {
shouldSelect := decider(index, val)
if !shouldSelect {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupInt uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]int.
func (v *Value) GroupInt(grouper func(int, int) string) *Value {
groups := make(map[string][]int)
v.EachInt(func(index int, val int) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]int, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceInt uses the specified function to replace each ints
// by iterating each item. The data in the returned result will be a
// []int containing the replaced items.
func (v *Value) ReplaceInt(replacer func(int, int) int) *Value {
arr := v.MustIntSlice()
replaced := make([]int, len(arr))
v.EachInt(func(index int, val int) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectInt uses the specified collector function to collect a value
// for each of the ints in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectInt(collector func(int, int) interface{}) *Value {
arr := v.MustIntSlice()
collected := make([]interface{}, len(arr))
v.EachInt(func(index int, val int) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Int8 (int8 and []int8)
*/
// Int8 gets the value as a int8, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Int8(optionalDefault ...int8) int8 {
if s, ok := v.data.(int8); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustInt8 gets the value as a int8.
//
// Panics if the object is not a int8.
func (v *Value) MustInt8() int8 {
return v.data.(int8)
}
// Int8Slice gets the value as a []int8, returns the optionalDefault
// value or nil if the value is not a []int8.
func (v *Value) Int8Slice(optionalDefault ...[]int8) []int8 {
if s, ok := v.data.([]int8); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustInt8Slice gets the value as a []int8.
//
// Panics if the object is not a []int8.
func (v *Value) MustInt8Slice() []int8 {
return v.data.([]int8)
}
// IsInt8 gets whether the object contained is a int8 or not.
func (v *Value) IsInt8() bool {
_, ok := v.data.(int8)
return ok
}
// IsInt8Slice gets whether the object contained is a []int8 or not.
func (v *Value) IsInt8Slice() bool {
_, ok := v.data.([]int8)
return ok
}
// EachInt8 calls the specified callback for each object
// in the []int8.
//
// Panics if the object is the wrong type.
func (v *Value) EachInt8(callback func(int, int8) bool) *Value {
for index, val := range v.MustInt8Slice() {
carryon := callback(index, val)
if !carryon {
break
}
}
return v
}
// WhereInt8 uses the specified decider function to select items
// from the []int8. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereInt8(decider func(int, int8) bool) *Value {
var selected []int8
v.EachInt8(func(index int, val int8) bool {
shouldSelect := decider(index, val)
if !shouldSelect {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupInt8 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]int8.
func (v *Value) GroupInt8(grouper func(int, int8) string) *Value {
groups := make(map[string][]int8)
v.EachInt8(func(index int, val int8) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]int8, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceInt8 uses the specified function to replace each int8s
// by iterating each item. The data in the returned result will be a
// []int8 containing the replaced items.
func (v *Value) ReplaceInt8(replacer func(int, int8) int8) *Value {
arr := v.MustInt8Slice()
replaced := make([]int8, len(arr))
v.EachInt8(func(index int, val int8) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectInt8 uses the specified collector function to collect a value
// for each of the int8s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectInt8(collector func(int, int8) interface{}) *Value {
arr := v.MustInt8Slice()
collected := make([]interface{}, len(arr))
v.EachInt8(func(index int, val int8) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Int16 (int16 and []int16)
*/
// Int16 gets the value as a int16, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Int16(optionalDefault ...int16) int16 {
if s, ok := v.data.(int16); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustInt16 gets the value as a int16.
//
// Panics if the object is not a int16.
func (v *Value) MustInt16() int16 {
return v.data.(int16)
}
// Int16Slice gets the value as a []int16, returns the optionalDefault
// value or nil if the value is not a []int16.
func (v *Value) Int16Slice(optionalDefault ...[]int16) []int16 {
if s, ok := v.data.([]int16); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustInt16Slice gets the value as a []int16.
//
// Panics if the object is not a []int16.
func (v *Value) MustInt16Slice() []int16 {
return v.data.([]int16)
}
// IsInt16 gets whether the object contained is a int16 or not.
func (v *Value) IsInt16() bool {
_, ok := v.data.(int16)
return ok
}
// IsInt16Slice gets whether the object contained is a []int16 or not.
func (v *Value) IsInt16Slice() bool {
_, ok := v.data.([]int16)
return ok
}
// EachInt16 calls the specified callback for each object
// in the []int16.
//
// Panics if the object is the wrong type.
func (v *Value) EachInt16(callback func(int, int16) bool) *Value {
for index, val := range v.MustInt16Slice() {
carryon := callback(index, val)
if !carryon {
break
}
}
return v
}
// WhereInt16 uses the specified decider function to select items
// from the []int16. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereInt16(decider func(int, int16) bool) *Value {
var selected []int16
v.EachInt16(func(index int, val int16) bool {
shouldSelect := decider(index, val)
if !shouldSelect {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupInt16 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]int16.
func (v *Value) GroupInt16(grouper func(int, int16) string) *Value {
groups := make(map[string][]int16)
v.EachInt16(func(index int, val int16) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]int16, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceInt16 uses the specified function to replace each int16s
// by iterating each item. The data in the returned result will be a
// []int16 containing the replaced items.
func (v *Value) ReplaceInt16(replacer func(int, int16) int16) *Value {
arr := v.MustInt16Slice()
replaced := make([]int16, len(arr))
v.EachInt16(func(index int, val int16) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectInt16 uses the specified collector function to collect a value
// for each of the int16s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectInt16(collector func(int, int16) interface{}) *Value {
arr := v.MustInt16Slice()
collected := make([]interface{}, len(arr))
v.EachInt16(func(index int, val int16) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Int32 (int32 and []int32)
*/
// Int32 gets the value as a int32, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Int32(optionalDefault ...int32) int32 {
if s, ok := v.data.(int32); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustInt32 gets the value as a int32.
//
// Panics if the object is not a int32.
func (v *Value) MustInt32() int32 {
return v.data.(int32)
}
// Int32Slice gets the value as a []int32, returns the optionalDefault
// value or nil if the value is not a []int32.
func (v *Value) Int32Slice(optionalDefault ...[]int32) []int32 {
if s, ok := v.data.([]int32); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustInt32Slice gets the value as a []int32.
//
// Panics if the object is not a []int32.
func (v *Value) MustInt32Slice() []int32 {
return v.data.([]int32)
}
// IsInt32 gets whether the object contained is a int32 or not.
func (v *Value) IsInt32() bool {
_, ok := v.data.(int32)
return ok
}
// IsInt32Slice gets whether the object contained is a []int32 or not.
func (v *Value) IsInt32Slice() bool {
_, ok := v.data.([]int32)
return ok
}
// EachInt32 calls the specified callback for each object
// in the []int32.
//
// Panics if the object is the wrong type.
func (v *Value) EachInt32(callback func(int, int32) bool) *Value {
for index, val := range v.MustInt32Slice() {
carryon := callback(index, val)
if !carryon {
break
}
}
return v
}
// WhereInt32 uses the specified decider function to select items
// from the []int32. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereInt32(decider func(int, int32) bool) *Value {
var selected []int32
v.EachInt32(func(index int, val int32) bool {
shouldSelect := decider(index, val)
if !shouldSelect {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupInt32 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]int32.
func (v *Value) GroupInt32(grouper func(int, int32) string) *Value {
groups := make(map[string][]int32)
v.EachInt32(func(index int, val int32) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]int32, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceInt32 uses the specified function to replace each int32s
// by iterating each item. The data in the returned result will be a
// []int32 containing the replaced items.
func (v *Value) ReplaceInt32(replacer func(int, int32) int32) *Value {
arr := v.MustInt32Slice()
replaced := make([]int32, len(arr))
v.EachInt32(func(index int, val int32) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectInt32 uses the specified collector function to collect a value
// for each of the int32s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectInt32(collector func(int, int32) interface{}) *Value {
arr := v.MustInt32Slice()
collected := make([]interface{}, len(arr))
v.EachInt32(func(index int, val int32) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Int64 (int64 and []int64)
*/
// Int64 gets the value as a int64, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Int64(optionalDefault ...int64) int64 {
if s, ok := v.data.(int64); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustInt64 gets the value as a int64.
//
// Panics if the object is not a int64.
func (v *Value) MustInt64() int64 {
return v.data.(int64)
}
// Int64Slice gets the value as a []int64, returns the optionalDefault
// value or nil if the value is not a []int64.
func (v *Value) Int64Slice(optionalDefault ...[]int64) []int64 {
if s, ok := v.data.([]int64); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustInt64Slice gets the value as a []int64.
//
// Panics if the object is not a []int64.
func (v *Value) MustInt64Slice() []int64 {
return v.data.([]int64)
}
// IsInt64 gets whether the object contained is a int64 or not.
func (v *Value) IsInt64() bool {
_, ok := v.data.(int64)
return ok
}
// IsInt64Slice gets whether the object contained is a []int64 or not.
func (v *Value) IsInt64Slice() bool {
_, ok := v.data.([]int64)
return ok
}
// EachInt64 calls the specified callback for each object
// in the []int64.
//
// Panics if the object is the wrong type.
func (v *Value) EachInt64(callback func(int, int64) bool) *Value {
for index, val := range v.MustInt64Slice() {
carryon := callback(index, val)
if !carryon {
break
}
}
return v
}
// WhereInt64 uses the specified decider function to select items
// from the []int64. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereInt64(decider func(int, int64) bool) *Value {
var selected []int64
v.EachInt64(func(index int, val int64) bool {
shouldSelect := decider(index, val)
if !shouldSelect {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupInt64 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]int64.
func (v *Value) GroupInt64(grouper func(int, int64) string) *Value {
groups := make(map[string][]int64)
v.EachInt64(func(index int, val int64) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]int64, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceInt64 uses the specified function to replace each int64s
// by iterating each item. The data in the returned result will be a
// []int64 containing the replaced items.
func (v *Value) ReplaceInt64(replacer func(int, int64) int64) *Value {
arr := v.MustInt64Slice()
replaced := make([]int64, len(arr))
v.EachInt64(func(index int, val int64) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectInt64 uses the specified collector function to collect a value
// for each of the int64s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectInt64(collector func(int, int64) interface{}) *Value {
arr := v.MustInt64Slice()
collected := make([]interface{}, len(arr))
v.EachInt64(func(index int, val int64) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Uint (uint and []uint)
*/
// Uint gets the value as a uint, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Uint(optionalDefault ...uint) uint {
if s, ok := v.data.(uint); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustUint gets the value as a uint.
//
// Panics if the object is not a uint.
func (v *Value) MustUint() uint {
return v.data.(uint)
}
// UintSlice gets the value as a []uint, returns the optionalDefault
// value or nil if the value is not a []uint.
func (v *Value) UintSlice(optionalDefault ...[]uint) []uint {
if s, ok := v.data.([]uint); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustUintSlice gets the value as a []uint.
//
// Panics if the object is not a []uint.
func (v *Value) MustUintSlice() []uint {
return v.data.([]uint)
}
// IsUint gets whether the object contained is a uint or not.
func (v *Value) IsUint() bool {
_, ok := v.data.(uint)
return ok
}
// IsUintSlice gets whether the object contained is a []uint or not.
func (v *Value) IsUintSlice() bool {
_, ok := v.data.([]uint)
return ok
}
// EachUint calls the specified callback for each object
// in the []uint.
//
// Panics if the object is the wrong type.
func (v *Value) EachUint(callback func(int, uint) bool) *Value {
for index, val := range v.MustUintSlice() {
carryon := callback(index, val)
if !carryon {
break
}
}
return v
}
// WhereUint uses the specified decider function to select items
// from the []uint. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereUint(decider func(int, uint) bool) *Value {
var selected []uint
v.EachUint(func(index int, val uint) bool {
shouldSelect := decider(index, val)
if !shouldSelect {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupUint uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]uint.
func (v *Value) GroupUint(grouper func(int, uint) string) *Value {
groups := make(map[string][]uint)
v.EachUint(func(index int, val uint) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]uint, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceUint uses the specified function to replace each uints
// by iterating each item. The data in the returned result will be a
// []uint containing the replaced items.
func (v *Value) ReplaceUint(replacer func(int, uint) uint) *Value {
arr := v.MustUintSlice()
replaced := make([]uint, len(arr))
v.EachUint(func(index int, val uint) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectUint uses the specified collector function to collect a value
// for each of the uints in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectUint(collector func(int, uint) interface{}) *Value {
arr := v.MustUintSlice()
collected := make([]interface{}, len(arr))
v.EachUint(func(index int, val uint) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Uint8 (uint8 and []uint8)
*/
// Uint8 gets the value as a uint8, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Uint8(optionalDefault ...uint8) uint8 {
if s, ok := v.data.(uint8); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustUint8 gets the value as a uint8.
//
// Panics if the object is not a uint8.
func (v *Value) MustUint8() uint8 {
return v.data.(uint8)
}
// Uint8Slice gets the value as a []uint8, returns the optionalDefault
// value or nil if the value is not a []uint8.
func (v *Value) Uint8Slice(optionalDefault ...[]uint8) []uint8 {
if s, ok := v.data.([]uint8); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustUint8Slice gets the value as a []uint8.
//
// Panics if the object is not a []uint8.
func (v *Value) MustUint8Slice() []uint8 {
return v.data.([]uint8)
}
// IsUint8 gets whether the object contained is a uint8 or not.
func (v *Value) IsUint8() bool {
_, ok := v.data.(uint8)
return ok
}
// IsUint8Slice gets whether the object contained is a []uint8 or not.
func (v *Value) IsUint8Slice() bool {
_, ok := v.data.([]uint8)
return ok
}
// EachUint8 calls the specified callback for each object
// in the []uint8.
//
// Panics if the object is the wrong type.
func (v *Value) EachUint8(callback func(int, uint8) bool) *Value {
for index, val := range v.MustUint8Slice() {
carryon := callback(index, val)
if !carryon {
break
}
}
return v
}
// WhereUint8 uses the specified decider function to select items
// from the []uint8. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereUint8(decider func(int, uint8) bool) *Value {
var selected []uint8
v.EachUint8(func(index int, val uint8) bool {
shouldSelect := decider(index, val)
if !shouldSelect {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupUint8 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]uint8.
func (v *Value) GroupUint8(grouper func(int, uint8) string) *Value {
groups := make(map[string][]uint8)
v.EachUint8(func(index int, val uint8) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]uint8, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceUint8 uses the specified function to replace each uint8s
// by iterating each item. The data in the returned result will be a
// []uint8 containing the replaced items.
func (v *Value) ReplaceUint8(replacer func(int, uint8) uint8) *Value {
arr := v.MustUint8Slice()
replaced := make([]uint8, len(arr))
v.EachUint8(func(index int, val uint8) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectUint8 uses the specified collector function to collect a value
// for each of the uint8s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectUint8(collector func(int, uint8) interface{}) *Value {
arr := v.MustUint8Slice()
collected := make([]interface{}, len(arr))
v.EachUint8(func(index int, val uint8) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Uint16 (uint16 and []uint16)
*/
// Uint16 gets the value as a uint16, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Uint16(optionalDefault ...uint16) uint16 {
if s, ok := v.data.(uint16); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustUint16 gets the value as a uint16.
//
// Panics if the object is not a uint16.
func (v *Value) MustUint16() uint16 {
return v.data.(uint16)
}
// Uint16Slice gets the value as a []uint16, returns the optionalDefault
// value or nil if the value is not a []uint16.
func (v *Value) Uint16Slice(optionalDefault ...[]uint16) []uint16 {
if s, ok := v.data.([]uint16); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustUint16Slice gets the value as a []uint16.
//
// Panics if the object is not a []uint16.
func (v *Value) MustUint16Slice() []uint16 {
return v.data.([]uint16)
}
// IsUint16 gets whether the object contained is a uint16 or not.
func (v *Value) IsUint16() bool {
_, ok := v.data.(uint16)
return ok
}
// IsUint16Slice gets whether the object contained is a []uint16 or not.
func (v *Value) IsUint16Slice() bool {
_, ok := v.data.([]uint16)
return ok
}
// EachUint16 calls the specified callback for each object
// in the []uint16.
//
// Panics if the object is the wrong type.
func (v *Value) EachUint16(callback func(int, uint16) bool) *Value {
for index, val := range v.MustUint16Slice() {
carryon := callback(index, val)
if !carryon {
break
}
}
return v
}
// WhereUint16 uses the specified decider function to select items
// from the []uint16. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereUint16(decider func(int, uint16) bool) *Value {
var selected []uint16
v.EachUint16(func(index int, val uint16) bool {
shouldSelect := decider(index, val)
if !shouldSelect {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupUint16 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]uint16.
func (v *Value) GroupUint16(grouper func(int, uint16) string) *Value {
groups := make(map[string][]uint16)
v.EachUint16(func(index int, val uint16) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]uint16, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceUint16 uses the specified function to replace each uint16s
// by iterating each item. The data in the returned result will be a
// []uint16 containing the replaced items.
func (v *Value) ReplaceUint16(replacer func(int, uint16) uint16) *Value {
arr := v.MustUint16Slice()
replaced := make([]uint16, len(arr))
v.EachUint16(func(index int, val uint16) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectUint16 uses the specified collector function to collect a value
// for each of the uint16s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectUint16(collector func(int, uint16) interface{}) *Value {
arr := v.MustUint16Slice()
collected := make([]interface{}, len(arr))
v.EachUint16(func(index int, val uint16) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Uint32 (uint32 and []uint32)
*/
// Uint32 gets the value as a uint32, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Uint32(optionalDefault ...uint32) uint32 {
if s, ok := v.data.(uint32); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustUint32 gets the value as a uint32.
//
// Panics if the object is not a uint32.
func (v *Value) MustUint32() uint32 {
return v.data.(uint32)
}
// Uint32Slice gets the value as a []uint32, returns the optionalDefault
// value or nil if the value is not a []uint32.
func (v *Value) Uint32Slice(optionalDefault ...[]uint32) []uint32 {
if s, ok := v.data.([]uint32); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustUint32Slice gets the value as a []uint32.
//
// Panics if the object is not a []uint32.
func (v *Value) MustUint32Slice() []uint32 {
return v.data.([]uint32)
}
// IsUint32 gets whether the object contained is a uint32 or not.
func (v *Value) IsUint32() bool {
_, ok := v.data.(uint32)
return ok
}
// IsUint32Slice gets whether the object contained is a []uint32 or not.
func (v *Value) IsUint32Slice() bool {
_, ok := v.data.([]uint32)
return ok
}
// EachUint32 calls the specified callback for each object
// in the []uint32.
//
// Panics if the object is the wrong type.
func (v *Value) EachUint32(callback func(int, uint32) bool) *Value {
for index, val := range v.MustUint32Slice() {
carryon := callback(index, val)
if !carryon {
break
}
}
return v
}
// WhereUint32 uses the specified decider function to select items
// from the []uint32. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereUint32(decider func(int, uint32) bool) *Value {
var selected []uint32
v.EachUint32(func(index int, val uint32) bool {
shouldSelect := decider(index, val)
if !shouldSelect {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupUint32 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]uint32.
func (v *Value) GroupUint32(grouper func(int, uint32) string) *Value {
groups := make(map[string][]uint32)
v.EachUint32(func(index int, val uint32) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]uint32, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceUint32 uses the specified function to replace each uint32s
// by iterating each item. The data in the returned result will be a
// []uint32 containing the replaced items.
func (v *Value) ReplaceUint32(replacer func(int, uint32) uint32) *Value {
arr := v.MustUint32Slice()
replaced := make([]uint32, len(arr))
v.EachUint32(func(index int, val uint32) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectUint32 uses the specified collector function to collect a value
// for each of the uint32s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectUint32(collector func(int, uint32) interface{}) *Value {
arr := v.MustUint32Slice()
collected := make([]interface{}, len(arr))
v.EachUint32(func(index int, val uint32) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Uint64 (uint64 and []uint64)
*/
// Uint64 gets the value as a uint64, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Uint64(optionalDefault ...uint64) uint64 {
if s, ok := v.data.(uint64); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustUint64 gets the value as a uint64.
//
// Panics if the object is not a uint64.
func (v *Value) MustUint64() uint64 {
return v.data.(uint64)
}
// Uint64Slice gets the value as a []uint64, returns the optionalDefault
// value or nil if the value is not a []uint64.
func (v *Value) Uint64Slice(optionalDefault ...[]uint64) []uint64 {
if s, ok := v.data.([]uint64); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustUint64Slice gets the value as a []uint64.
//
// Panics if the object is not a []uint64.
func (v *Value) MustUint64Slice() []uint64 {
return v.data.([]uint64)
}
// IsUint64 gets whether the object contained is a uint64 or not.
func (v *Value) IsUint64() bool {
_, ok := v.data.(uint64)
return ok
}
// IsUint64Slice gets whether the object contained is a []uint64 or not.
func (v *Value) IsUint64Slice() bool {
_, ok := v.data.([]uint64)
return ok
}
// EachUint64 calls the specified callback for each object
// in the []uint64.
//
// Panics if the object is the wrong type.
func (v *Value) EachUint64(callback func(int, uint64) bool) *Value {
for index, val := range v.MustUint64Slice() {
carryon := callback(index, val)
if !carryon {
break
}
}
return v
}
// WhereUint64 uses the specified decider function to select items
// from the []uint64. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereUint64(decider func(int, uint64) bool) *Value {
var selected []uint64
v.EachUint64(func(index int, val uint64) bool {
shouldSelect := decider(index, val)
if !shouldSelect {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupUint64 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]uint64.
func (v *Value) GroupUint64(grouper func(int, uint64) string) *Value {
groups := make(map[string][]uint64)
v.EachUint64(func(index int, val uint64) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]uint64, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceUint64 uses the specified function to replace each uint64s
// by iterating each item. The data in the returned result will be a
// []uint64 containing the replaced items.
func (v *Value) ReplaceUint64(replacer func(int, uint64) uint64) *Value {
arr := v.MustUint64Slice()
replaced := make([]uint64, len(arr))
v.EachUint64(func(index int, val uint64) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectUint64 uses the specified collector function to collect a value
// for each of the uint64s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectUint64(collector func(int, uint64) interface{}) *Value {
arr := v.MustUint64Slice()
collected := make([]interface{}, len(arr))
v.EachUint64(func(index int, val uint64) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Uintptr (uintptr and []uintptr)
*/
// Uintptr gets the value as a uintptr, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Uintptr(optionalDefault ...uintptr) uintptr {
if s, ok := v.data.(uintptr); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustUintptr gets the value as a uintptr.
//
// Panics if the object is not a uintptr.
func (v *Value) MustUintptr() uintptr {
return v.data.(uintptr)
}
// UintptrSlice gets the value as a []uintptr, returns the optionalDefault
// value or nil if the value is not a []uintptr.
func (v *Value) UintptrSlice(optionalDefault ...[]uintptr) []uintptr {
if s, ok := v.data.([]uintptr); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustUintptrSlice gets the value as a []uintptr.
//
// Panics if the object is not a []uintptr.
func (v *Value) MustUintptrSlice() []uintptr {
return v.data.([]uintptr)
}
// IsUintptr gets whether the object contained is a uintptr or not.
func (v *Value) IsUintptr() bool {
_, ok := v.data.(uintptr)
return ok
}
// IsUintptrSlice gets whether the object contained is a []uintptr or not.
func (v *Value) IsUintptrSlice() bool {
_, ok := v.data.([]uintptr)
return ok
}
// EachUintptr calls the specified callback for each object
// in the []uintptr.
//
// Panics if the object is the wrong type.
func (v *Value) EachUintptr(callback func(int, uintptr) bool) *Value {
for index, val := range v.MustUintptrSlice() {
carryon := callback(index, val)
if !carryon {
break
}
}
return v
}
// WhereUintptr uses the specified decider function to select items
// from the []uintptr. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereUintptr(decider func(int, uintptr) bool) *Value {
var selected []uintptr
v.EachUintptr(func(index int, val uintptr) bool {
shouldSelect := decider(index, val)
if !shouldSelect {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupUintptr uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]uintptr.
func (v *Value) GroupUintptr(grouper func(int, uintptr) string) *Value {
groups := make(map[string][]uintptr)
v.EachUintptr(func(index int, val uintptr) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]uintptr, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceUintptr uses the specified function to replace each uintptrs
// by iterating each item. The data in the returned result will be a
// []uintptr containing the replaced items.
func (v *Value) ReplaceUintptr(replacer func(int, uintptr) uintptr) *Value {
arr := v.MustUintptrSlice()
replaced := make([]uintptr, len(arr))
v.EachUintptr(func(index int, val uintptr) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectUintptr uses the specified collector function to collect a value
// for each of the uintptrs in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectUintptr(collector func(int, uintptr) interface{}) *Value {
arr := v.MustUintptrSlice()
collected := make([]interface{}, len(arr))
v.EachUintptr(func(index int, val uintptr) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Float32 (float32 and []float32)
*/
// Float32 gets the value as a float32, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Float32(optionalDefault ...float32) float32 {
if s, ok := v.data.(float32); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustFloat32 gets the value as a float32.
//
// Panics if the object is not a float32.
func (v *Value) MustFloat32() float32 {
return v.data.(float32)
}
// Float32Slice gets the value as a []float32, returns the optionalDefault
// value or nil if the value is not a []float32.
func (v *Value) Float32Slice(optionalDefault ...[]float32) []float32 {
if s, ok := v.data.([]float32); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustFloat32Slice gets the value as a []float32.
//
// Panics if the object is not a []float32.
func (v *Value) MustFloat32Slice() []float32 {
return v.data.([]float32)
}
// IsFloat32 gets whether the object contained is a float32 or not.
func (v *Value) IsFloat32() bool {
_, ok := v.data.(float32)
return ok
}
// IsFloat32Slice gets whether the object contained is a []float32 or not.
func (v *Value) IsFloat32Slice() bool {
_, ok := v.data.([]float32)
return ok
}
// EachFloat32 calls the specified callback for each object
// in the []float32.
//
// Panics if the object is the wrong type.
func (v *Value) EachFloat32(callback func(int, float32) bool) *Value {
for index, val := range v.MustFloat32Slice() {
carryon := callback(index, val)
if !carryon {
break
}
}
return v
}
// WhereFloat32 uses the specified decider function to select items
// from the []float32. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereFloat32(decider func(int, float32) bool) *Value {
var selected []float32
v.EachFloat32(func(index int, val float32) bool {
shouldSelect := decider(index, val)
if !shouldSelect {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupFloat32 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]float32.
func (v *Value) GroupFloat32(grouper func(int, float32) string) *Value {
groups := make(map[string][]float32)
v.EachFloat32(func(index int, val float32) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]float32, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceFloat32 uses the specified function to replace each float32s
// by iterating each item. The data in the returned result will be a
// []float32 containing the replaced items.
func (v *Value) ReplaceFloat32(replacer func(int, float32) float32) *Value {
arr := v.MustFloat32Slice()
replaced := make([]float32, len(arr))
v.EachFloat32(func(index int, val float32) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectFloat32 uses the specified collector function to collect a value
// for each of the float32s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectFloat32(collector func(int, float32) interface{}) *Value {
arr := v.MustFloat32Slice()
collected := make([]interface{}, len(arr))
v.EachFloat32(func(index int, val float32) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Float64 (float64 and []float64)
*/
// Float64 gets the value as a float64, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Float64(optionalDefault ...float64) float64 {
if s, ok := v.data.(float64); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustFloat64 gets the value as a float64.
//
// Panics if the object is not a float64.
func (v *Value) MustFloat64() float64 {
return v.data.(float64)
}
// Float64Slice gets the value as a []float64, returns the optionalDefault
// value or nil if the value is not a []float64.
func (v *Value) Float64Slice(optionalDefault ...[]float64) []float64 {
if s, ok := v.data.([]float64); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustFloat64Slice gets the value as a []float64.
//
// Panics if the object is not a []float64.
func (v *Value) MustFloat64Slice() []float64 {
return v.data.([]float64)
}
// IsFloat64 gets whether the object contained is a float64 or not.
func (v *Value) IsFloat64() bool {
_, ok := v.data.(float64)
return ok
}
// IsFloat64Slice gets whether the object contained is a []float64 or not.
func (v *Value) IsFloat64Slice() bool {
_, ok := v.data.([]float64)
return ok
}
// EachFloat64 calls the specified callback for each object
// in the []float64.
//
// Panics if the object is the wrong type.
func (v *Value) EachFloat64(callback func(int, float64) bool) *Value {
for index, val := range v.MustFloat64Slice() {
carryon := callback(index, val)
if !carryon {
break
}
}
return v
}
// WhereFloat64 uses the specified decider function to select items
// from the []float64. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereFloat64(decider func(int, float64) bool) *Value {
var selected []float64
v.EachFloat64(func(index int, val float64) bool {
shouldSelect := decider(index, val)
if !shouldSelect {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupFloat64 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]float64.
func (v *Value) GroupFloat64(grouper func(int, float64) string) *Value {
groups := make(map[string][]float64)
v.EachFloat64(func(index int, val float64) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]float64, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceFloat64 uses the specified function to replace each float64s
// by iterating each item. The data in the returned result will be a
// []float64 containing the replaced items.
func (v *Value) ReplaceFloat64(replacer func(int, float64) float64) *Value {
arr := v.MustFloat64Slice()
replaced := make([]float64, len(arr))
v.EachFloat64(func(index int, val float64) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectFloat64 uses the specified collector function to collect a value
// for each of the float64s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectFloat64(collector func(int, float64) interface{}) *Value {
arr := v.MustFloat64Slice()
collected := make([]interface{}, len(arr))
v.EachFloat64(func(index int, val float64) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Complex64 (complex64 and []complex64)
*/
// Complex64 gets the value as a complex64, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Complex64(optionalDefault ...complex64) complex64 {
if s, ok := v.data.(complex64); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustComplex64 gets the value as a complex64.
//
// Panics if the object is not a complex64.
func (v *Value) MustComplex64() complex64 {
return v.data.(complex64)
}
// Complex64Slice gets the value as a []complex64, returns the optionalDefault
// value or nil if the value is not a []complex64.
func (v *Value) Complex64Slice(optionalDefault ...[]complex64) []complex64 {
if s, ok := v.data.([]complex64); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustComplex64Slice gets the value as a []complex64.
//
// Panics if the object is not a []complex64.
func (v *Value) MustComplex64Slice() []complex64 {
return v.data.([]complex64)
}
// IsComplex64 gets whether the object contained is a complex64 or not.
func (v *Value) IsComplex64() bool {
_, ok := v.data.(complex64)
return ok
}
// IsComplex64Slice gets whether the object contained is a []complex64 or not.
func (v *Value) IsComplex64Slice() bool {
_, ok := v.data.([]complex64)
return ok
}
// EachComplex64 calls the specified callback for each object
// in the []complex64.
//
// Panics if the object is the wrong type.
func (v *Value) EachComplex64(callback func(int, complex64) bool) *Value {
for index, val := range v.MustComplex64Slice() {
carryon := callback(index, val)
if !carryon {
break
}
}
return v
}
// WhereComplex64 uses the specified decider function to select items
// from the []complex64. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereComplex64(decider func(int, complex64) bool) *Value {
var selected []complex64
v.EachComplex64(func(index int, val complex64) bool {
shouldSelect := decider(index, val)
if !shouldSelect {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupComplex64 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]complex64.
func (v *Value) GroupComplex64(grouper func(int, complex64) string) *Value {
groups := make(map[string][]complex64)
v.EachComplex64(func(index int, val complex64) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]complex64, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceComplex64 uses the specified function to replace each complex64s
// by iterating each item. The data in the returned result will be a
// []complex64 containing the replaced items.
func (v *Value) ReplaceComplex64(replacer func(int, complex64) complex64) *Value {
arr := v.MustComplex64Slice()
replaced := make([]complex64, len(arr))
v.EachComplex64(func(index int, val complex64) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectComplex64 uses the specified collector function to collect a value
// for each of the complex64s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectComplex64(collector func(int, complex64) interface{}) *Value {
arr := v.MustComplex64Slice()
collected := make([]interface{}, len(arr))
v.EachComplex64(func(index int, val complex64) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Complex128 (complex128 and []complex128)
*/
// Complex128 gets the value as a complex128, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Complex128(optionalDefault ...complex128) complex128 {
if s, ok := v.data.(complex128); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustComplex128 gets the value as a complex128.
//
// Panics if the object is not a complex128.
func (v *Value) MustComplex128() complex128 {
return v.data.(complex128)
}
// Complex128Slice gets the value as a []complex128, returns the optionalDefault
// value or nil if the value is not a []complex128.
func (v *Value) Complex128Slice(optionalDefault ...[]complex128) []complex128 {
if s, ok := v.data.([]complex128); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustComplex128Slice gets the value as a []complex128.
//
// Panics if the object is not a []complex128.
func (v *Value) MustComplex128Slice() []complex128 {
return v.data.([]complex128)
}
// IsComplex128 gets whether the object contained is a complex128 or not.
func (v *Value) IsComplex128() bool {
_, ok := v.data.(complex128)
return ok
}
// IsComplex128Slice gets whether the object contained is a []complex128 or not.
func (v *Value) IsComplex128Slice() bool {
_, ok := v.data.([]complex128)
return ok
}
// EachComplex128 calls the specified callback for each object
// in the []complex128.
//
// Panics if the object is the wrong type.
func (v *Value) EachComplex128(callback func(int, complex128) bool) *Value {
for index, val := range v.MustComplex128Slice() {
carryon := callback(index, val)
if !carryon {
break
}
}
return v
}
// WhereComplex128 uses the specified decider function to select items
// from the []complex128. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereComplex128(decider func(int, complex128) bool) *Value {
var selected []complex128
v.EachComplex128(func(index int, val complex128) bool {
shouldSelect := decider(index, val)
if !shouldSelect {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupComplex128 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]complex128.
func (v *Value) GroupComplex128(grouper func(int, complex128) string) *Value {
groups := make(map[string][]complex128)
v.EachComplex128(func(index int, val complex128) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]complex128, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceComplex128 uses the specified function to replace each complex128s
// by iterating each item. The data in the returned result will be a
// []complex128 containing the replaced items.
func (v *Value) ReplaceComplex128(replacer func(int, complex128) complex128) *Value {
arr := v.MustComplex128Slice()
replaced := make([]complex128, len(arr))
v.EachComplex128(func(index int, val complex128) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectComplex128 uses the specified collector function to collect a value
// for each of the complex128s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectComplex128(collector func(int, complex128) interface{}) *Value {
arr := v.MustComplex128Slice()
collected := make([]interface{}, len(arr))
v.EachComplex128(func(index int, val complex128) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
================================================
FILE: src/github.com/stretchr/testify/vendor/github.com/stretchr/objx/value.go
================================================
package objx
import (
"fmt"
"strconv"
)
// Value provides methods for extracting interface{} data in various
// types.
type Value struct {
// data contains the raw data being managed by this Value
data interface{}
}
// Data returns the raw data contained by this Value
func (v *Value) Data() interface{} {
return v.data
}
// String returns the value always as a string
func (v *Value) String() string {
switch {
case v.IsStr():
return v.Str()
case v.IsBool():
return strconv.FormatBool(v.Bool())
case v.IsFloat32():
return strconv.FormatFloat(float64(v.Float32()), 'f', -1, 32)
case v.IsFloat64():
return strconv.FormatFloat(v.Float64(), 'f', -1, 64)
case v.IsInt():
return strconv.FormatInt(int64(v.Int()), 10)
case v.IsInt():
return strconv.FormatInt(int64(v.Int()), 10)
case v.IsInt8():
return strconv.FormatInt(int64(v.Int8()), 10)
case v.IsInt16():
return strconv.FormatInt(int64(v.Int16()), 10)
case v.IsInt32():
return strconv.FormatInt(int64(v.Int32()), 10)
case v.IsInt64():
return strconv.FormatInt(v.Int64(), 10)
case v.IsUint():
return strconv.FormatUint(uint64(v.Uint()), 10)
case v.IsUint8():
return strconv.FormatUint(uint64(v.Uint8()), 10)
case v.IsUint16():
return strconv.FormatUint(uint64(v.Uint16()), 10)
case v.IsUint32():
return strconv.FormatUint(uint64(v.Uint32()), 10)
case v.IsUint64():
return strconv.FormatUint(v.Uint64(), 10)
}
return fmt.Sprintf("%#v", v.Data())
}
================================================
FILE: src/main.go
================================================
package main
import (
"github.com/dolotech/leaf"
"server/conf"
"server/gate"
"server/login"
"net/http"
"flag"
"github.com/golang/glog"
"github.com/dolotech/lib/db"
"server/model"
"server/game"
)
var Commit = ""
var BUILD_TIME = ""
var VERSION = ""
var createdb bool
func init() {
flag.StringVar(&conf.Server.WSAddr, "addr", ":8989", "websocket port")
flag.IntVar(&conf.Server.MaxConnNum, "maxconn", 20000, "Max Conn Num")
flag.StringVar(&conf.Server.DBUrl, "pg", "postgres://postgres:haosql@127.0.0.1:5432/postgres?sslmode=disable", "pg addr")
flag.BoolVar(&createdb, "createdb", false, "initial database")
flag.Parse()
db.Init(conf.Server.DBUrl)
if createdb {
createDb()
}
}
func main() {
go leaf.Run(
game.Module,
gate.Module,
login.Module,
)
// for test client
http.Handle("/", http.StripPrefix("/", http.FileServer(http.Dir("./"))))
err := http.ListenAndServe(":12345", nil)
if err != nil {
glog.Fatalf("ListenAndServe: %v ", err)
}
}
func createDb() {
// 建表,只维护和服务器game里面有关的表
err := db.C().Sync(model.User{}, model.Room{})
if err != nil {
glog.Errorln(err)
}
}
================================================
FILE: src/server/algorithm/7462.txt
================================================
TOTAL FIVE CARDS HAND VALUE POKER HAND
=====================================================================
4 T J Q K A Royal Flush ROYAL FLUSH
4 9 T J Q K King High Straight Flush STRAIGHT FLUSH
4 8 9 T J Q Queen High Straight Flush
4 7 8 9 T J Jack High Straight Flush
4 6 7 8 9 T Ten High Straight Flush
4 5 6 7 8 9 Nine High Straight Flush
4 4 5 6 7 8 Eight High Straight Flush
4 3 4 5 6 7 Seven High Straight Flush
4 2 3 4 5 6 Six High Straight Flush
4 A 2 3 4 5 Five High Straight Flush
4 A A A A K Four Aces FOUR OF A KIND
4 A A A A Q
4 A A A A J
4 A A A A T
4 A A A A 9
4 A A A A 8
4 A A A A 7
4 A A A A 6
4 A A A A 5
4 A A A A 4
4 A A A A 3
4 A A A A 2
4 K K K K A Four Kings
4 K K K K Q
4 K K K K J
4 K K K K T
4 K K K K 9
4 K K K K 8
4 K K K K 7
4 K K K K 6
4 K K K K 5
4 K K K K 4
4 K K K K 3
4 K K K K 2
4 Q Q Q Q A Four Queens
4 Q Q Q Q K
4 Q Q Q Q J
4 Q Q Q Q T
4 Q Q Q Q 9
4 Q Q Q Q 8
4 Q Q Q Q 7
4 Q Q Q Q 6
4 Q Q Q Q 5
4 Q Q Q Q 4
4 Q Q Q Q 3
4 Q Q Q Q 2
4 J J J J A Four Jacks
4 J J J J K
4 J J J J Q
4 J J J J T
4 J J J J 9
4 J J J J 8
4 J J J J 7
4 J J J J 6
4 J J J J 5
4 J J J J 4
4 J J J J 3
4 J J J J 2
4 T T T T A Four Tens
4 T T T T K
4 T T T T Q
4 T T T T J
4 T T T T 9
4 T T T T 8
4 T T T T 7
4 T T T T 6
4 T T T T 5
4 T T T T 4
4 T T T T 3
4 T T T T 2
4 9 9 9 9 A Four Nines
4 9 9 9 9 K
4 9 9 9 9 Q
4 9 9 9 9 J
4 9 9 9 9 T
4 9 9 9 9 8
4 9 9 9 9 7
4 9 9 9 9 6
4 9 9 9 9 5
4 9 9 9 9 4
4 9 9 9 9 3
4 9 9 9 9 2
4 8 8 8 8 A Four Eights
4 8 8 8 8 K
4 8 8 8 8 Q
4 8 8 8 8 J
4 8 8 8 8 T
4 8 8 8 8 9
4 8 8 8 8 7
4 8 8 8 8 6
4 8 8 8 8 5
4 8 8 8 8 4
4 8 8 8 8 3
4 8 8 8 8 2
4 7 7 7 7 A Four Sevens
4 7 7 7 7 K
4 7 7 7 7 Q
4 7 7 7 7 J
4 7 7 7 7 T
4 7 7 7 7 9
4 7 7 7 7 8
4 7 7 7 7 6
4 7 7 7 7 5
4 7 7 7 7 4
4 7 7 7 7 3
4 7 7 7 7 2
4 6 6 6 6 A Four Sixes
4 6 6 6 6 K
4 6 6 6 6 Q
4 6 6 6 6 J
4 6 6 6 6 T
4 6 6 6 6 9
4 6 6 6 6 8
4 6 6 6 6 7
4 6 6 6 6 5
4 6 6 6 6 4
4 6 6 6 6 3
4 6 6 6 6 2
4 5 5 5 5 A Four Fives
4 5 5 5 5 K
4 5 5 5 5 Q
4 5 5 5 5 J
4 5 5 5 5 T
4 5 5 5 5 9
4 5 5 5 5 8
4 5 5 5 5 7
4 5 5 5 5 6
4 5 5 5 5 4
4 5 5 5 5 3
4 5 5 5 5 2
4 4 4 4 4 A Four Fours
4 4 4 4 4 K
4 4 4 4 4 Q
4 4 4 4 4 J
4 4 4 4 4 T
4 4 4 4 4 9
4 4 4 4 4 8
4 4 4 4 4 7
4 4 4 4 4 6
4 4 4 4 4 5
4 4 4 4 4 3
4 4 4 4 4 2
4 3 3 3 3 A Four Treys
4 3 3 3 3 K
4 3 3 3 3 Q
4 3 3 3 3 J
4 3 3 3 3 T
4 3 3 3 3 9
4 3 3 3 3 8
4 3 3 3 3 7
4 3 3 3 3 6
4 3 3 3 3 5
4 3 3 3 3 4
4 3 3 3 3 2
4 2 2 2 2 A Four Deuces
4 2 2 2 2 K
4 2 2 2 2 Q
4 2 2 2 2 J
4 2 2 2 2 T
4 2 2 2 2 9
4 2 2 2 2 8
4 2 2 2 2 7
4 2 2 2 2 6
4 2 2 2 2 5
4 2 2 2 2 4
4 2 2 2 2 3
24 A A A K K Aces Full FULL HOUSE
24 A A A Q Q
24 A A A J J
24 A A A T T
24 A A A 9 9
24 A A A 8 8
24 A A A 7 7
24 A A A 6 6
24 A A A 5 5
24 A A A 4 4
24 A A A 3 3
24 A A A 2 2
24 K K K A A Kings Full
24 K K K Q Q
24 K K K J J
24 K K K T T
24 K K K 9 9
24 K K K 8 8
24 K K K 7 7
24 K K K 6 6
24 K K K 5 5
24 K K K 4 4
24 K K K 3 3
24 K K K 2 2
24 Q Q Q A A Queens Full
24 Q Q Q K K
24 Q Q Q J J
24 Q Q Q T T
24 Q Q Q 9 9
24 Q Q Q 8 8
24 Q Q Q 7 7
24 Q Q Q 6 6
24 Q Q Q 5 5
24 Q Q Q 4 4
24 Q Q Q 3 3
24 Q Q Q 2 2
24 J J J A A Jacks Full
24 J J J K K
24 J J J Q Q
24 J J J T T
24 J J J 9 9
24 J J J 8 8
24 J J J 7 7
24 J J J 6 6
24 J J J 5 5
24 J J J 4 4
24 J J J 3 3
24 J J J 2 2
24 T T T A A Tens Full
24 T T T K K
24 T T T Q Q
24 T T T J J
24 T T T 9 9
24 T T T 8 8
24 T T T 7 7
24 T T T 6 6
24 T T T 5 5
24 T T T 4 4
24 T T T 3 3
24 T T T 2 2
24 9 9 9 A A Nines Full
24 9 9 9 K K
24 9 9 9 Q Q
24 9 9 9 J J
24 9 9 9 T T
24 9 9 9 8 8
24 9 9 9 7 7
24 9 9 9 6 6
24 9 9 9 5 5
24 9 9 9 4 4
24 9 9 9 3 3
24 9 9 9 2 2
24 8 8 8 A A Eights Full
24 8 8 8 K K
24 8 8 8 Q Q
24 8 8 8 J J
24 8 8 8 T T
24 8 8 8 9 9
24 8 8 8 7 7
24 8 8 8 6 6
24 8 8 8 5 5
24 8 8 8 4 4
24 8 8 8 3 3
24 8 8 8 2 2
24 7 7 7 A A Sevens Full
24 7 7 7 K K
24 7 7 7 Q Q
24 7 7 7 J J
24 7 7 7 T T
24 7 7 7 9 9
24 7 7 7 8 8
24 7 7 7 6 6
24 7 7 7 5 5
24 7 7 7 4 4
24 7 7 7 3 3
24 7 7 7 2 2
24 6 6 6 A A Sixes Full
24 6 6 6 K K
24 6 6 6 Q Q
24 6 6 6 J J
24 6 6 6 T T
24 6 6 6 9 9
24 6 6 6 8 8
24 6 6 6 7 7
24 6 6 6 5 5
24 6 6 6 4 4
24 6 6 6 3 3
24 6 6 6 2 2
24 5 5 5 A A Fives Full
24 5 5 5 K K
24 5 5 5 Q Q
24 5 5 5 J J
24 5 5 5 T T
24 5 5 5 9 9
24 5 5 5 8 8
24 5 5 5 7 7
24 5 5 5 6 6
24 5 5 5 4 4
24 5 5 5 3 3
24 5 5 5 2 2
24 4 4 4 A A Fours Full
24 4 4 4 K K
24 4 4 4 Q Q
24 4 4 4 J J
24 4 4 4 T T
24 4 4 4 9 9
24 4 4 4 8 8
24 4 4 4 7 7
24 4 4 4 6 6
24 4 4 4 5 5
24 4 4 4 3 3
24 4 4 4 2 2
24 3 3 3 A A Threes Full
24 3 3 3 K K
24 3 3 3 Q Q
24 3 3 3 J J
24 3 3 3 T T
24 3 3 3 9 9
24 3 3 3 8 8
24 3 3 3 7 7
24 3 3 3 6 6
24 3 3 3 5 5
24 3 3 3 4 4
24 3 3 3 2 2
24 2 2 2 A A Deuces Full
24 2 2 2 K K
24 2 2 2 Q Q
24 2 2 2 J J
24 2 2 2 T T
24 2 2 2 9 9
24 2 2 2 8 8
24 2 2 2 7 7
24 2 2 2 6 6
24 2 2 2 5 5
24 2 2 2 4 4
24 2 2 2 3 3
4 9 J Q K A Ace High Flush FLUSH
4 8 J Q K A
4 7 J Q K A
4 6 J Q K A
4 5 J Q K A
4 4 J Q K A
4 3 J Q K A
4 2 J Q K A
4 9 T Q K A
4 8 T Q K A
4 7 T Q K A
4 6 T Q K A
4 5 T Q K A
4 4 T Q K A
4 3 T Q K A
4 2 T Q K A
4 8 9 Q K A
4 7 9 Q K A
4 6 9 Q K A
4 5 9 Q K A
4 4 9 Q K A
4 3 9 Q K A
4 2 9 Q K A
4 7 8 Q K A
4 6 8 Q K A
4 5 8 Q K A
4 4 8 Q K A
4 3 8 Q K A
4 2 8 Q K A
4 6 7 Q K A
4 5 7 Q K A
4 4 7 Q K A
4 3 7 Q K A
4 2 7 Q K A
4 5 6 Q K A
4 4 6 Q K A
4 3 6 Q K A
4 2 6 Q K A
4 4 5 Q K A
4 3 5 Q K A
4 2 5 Q K A
4 3 4 Q K A
4 2 4 Q K A
4 2 3 Q K A
4 9 T J K A
4 8 T J K A
4 7 T J K A
4 6 T J K A
4 5 T J K A
4 4 T J K A
4 3 T J K A
4 2 T J K A
4 8 9 J K A
4 7 9 J K A
4 6 9 J K A
4 5 9 J K A
4 4 9 J K A
4 3 9 J K A
4 2 9 J K A
4 7 8 J K A
4 6 8 J K A
4 5 8 J K A
4 4 8 J K A
4 3 8 J K A
4 2 8 J K A
4 6 7 J K A
4 5 7 J K A
4 4 7 J K A
4 3 7 J K A
4 2 7 J K A
4 5 6 J K A
4 4 6 J K A
4 3 6 J K A
4 2 6 J K A
4 4 5 J K A
4 3 5 J K A
4 2 5 J K A
4 3 4 J K A
4 2 4 J K A
4 2 3 J K A
4 8 9 T K A
4 7 9 T K A
4 6 9 T K A
4 5 9 T K A
4 4 9 T K A
4 3 9 T K A
4 2 9 T K A
4 7 8 T K A
4 6 8 T K A
4 5 8 T K A
4 4 8 T K A
4 3 8 T K A
4 2 8 T K A
4 6 7 T K A
4 5 7 T K A
4 4 7 T K A
4 3 7 T K A
4 2 7 T K A
4 5 6 T K A
4 4 6 T K A
4 3 6 T K A
4 2 6 T K A
4 4 5 T K A
4 3 5 T K A
4 2 5 T K A
4 3 4 T K A
4 2 4 T K A
4 2 3 T K A
4 7 8 9 K A
4 6 8 9 K A
4 5 8 9 K A
4 4 8 9 K A
4 3 8 9 K A
4 2 8 9 K A
4 6 7 9 K A
4 5 7 9 K A
4 4 7 9 K A
4 3 7 9 K A
4 2 7 9 K A
4 5 6 9 K A
4 4 6 9 K A
4 3 6 9 K A
4 2 6 9 K A
4 4 5 9 K A
4 3 5 9 K A
4 2 5 9 K A
4 3 4 9 K A
4 2 4 9 K A
4 2 3 9 K A
4 6 7 8 K A
4 5 7 8 K A
4 4 7 8 K A
4 3 7 8 K A
4 2 7 8 K A
4 5 6 8 K A
4 4 6 8 K A
4 3 6 8 K A
4 2 6 8 K A
4 4 5 8 K A
4 3 5 8 K A
4 2 5 8 K A
4 3 4 8 K A
4 2 4 8 K A
4 2 3 8 K A
4 5 6 7 K A
4 4 6 7 K A
4 3 6 7 K A
4 2 6 7 K A
4 4 5 7 K A
4 3 5 7 K A
4 2 5 7 K A
4 3 4 7 K A
4 2 4 7 K A
4 2 3 7 K A
4 4 5 6 K A
4 3 5 6 K A
4 2 5 6 K A
4 3 4 6 K A
4 2 4 6 K A
4 2 3 6 K A
4 3 4 5 K A
4 2 4 5 K A
4 2 3 5 K A
4 2 3 4 K A
4 9 T J Q A
4 8 T J Q A
4 7 T J Q A
4 6 T J Q A
4 5 T J Q A
4 4 T J Q A
4 3 T J Q A
4 2 T J Q A
4 8 9 J Q A
4 7 9 J Q A
4 6 9 J Q A
4 5 9 J Q A
4 4 9 J Q A
4 3 9 J Q A
4 2 9 J Q A
4 7 8 J Q A
4 6 8 J Q A
4 5 8 J Q A
4 4 8 J Q A
4 3 8 J Q A
4 2 8 J Q A
4 6 7 J Q A
4 5 7 J Q A
4 4 7 J Q A
4 3 7 J Q A
4 2 7 J Q A
4 5 6 J Q A
4 4 6 J Q A
4 3 6 J Q A
4 2 6 J Q A
4 4 5 J Q A
4 3 5 J Q A
4 2 5 J Q A
4 3 4 J Q A
4 2 4 J Q A
4 2 3 J Q A
4 8 9 T Q A
4 7 9 T Q A
4 6 9 T Q A
4 5 9 T Q A
4 4 9 T Q A
4 3 9 T Q A
4 2 9 T Q A
4 7 8 T Q A
4 6 8 T Q A
4 5 8 T Q A
4 4 8 T Q A
4 3 8 T Q A
4 2 8 T Q A
4 6 7 T Q A
4 5 7 T Q A
4 4 7 T Q A
4 3 7 T Q A
4 2 7 T Q A
4 5 6 T Q A
4 4 6 T Q A
4 3 6 T Q A
4 2 6 T Q A
4 4 5 T Q A
4 3 5 T Q A
4 2 5 T Q A
4 3 4 T Q A
4 2 4 T Q A
4 2 3 T Q A
4 7 8 9 Q A
4 6 8 9 Q A
4 5 8 9 Q A
4 4 8 9 Q A
4 3 8 9 Q A
4 2 8 9 Q A
4 6 7 9 Q A
4 5 7 9 Q A
4 4 7 9 Q A
4 3 7 9 Q A
4 2 7 9 Q A
4 5 6 9 Q A
4 4 6 9 Q A
4 3 6 9 Q A
4 2 6 9 Q A
4 4 5 9 Q A
4 3 5 9 Q A
4 2 5 9 Q A
4 3 4 9 Q A
4 2 4 9 Q A
4 2 3 9 Q A
4 6 7 8 Q A
4 5 7 8 Q A
4 4 7 8 Q A
4 3 7 8 Q A
4 2 7 8 Q A
4 5 6 8 Q A
4 4 6 8 Q A
4 3 6 8 Q A
4 2 6 8 Q A
4 4 5 8 Q A
4 3 5 8 Q A
4 2 5 8 Q A
4 3 4 8 Q A
4 2 4 8 Q A
4 2 3 8 Q A
4 5 6 7 Q A
4 4 6 7 Q A
4 3 6 7 Q A
4 2 6 7 Q A
4 4 5 7 Q A
4 3 5 7 Q A
4 2 5 7 Q A
4 3 4 7 Q A
4 2 4 7 Q A
4 2 3 7 Q A
4 4 5 6 Q A
4 3 5 6 Q A
4 2 5 6 Q A
4 3 4 6 Q A
4 2 4 6 Q A
4 2 3 6 Q A
4 3 4 5 Q A
4 2 4 5 Q A
4 2 3 5 Q A
4 2 3 4 Q A
4 8 9 T J A
4 7 9 T J A
4 6 9 T J A
4 5 9 T J A
4 4 9 T J A
4 3 9 T J A
4 2 9 T J A
4 7 8 T J A
4 6 8 T J A
4 5 8 T J A
4 4 8 T J A
4 3 8 T J A
4 2 8 T J A
4 6 7 T J A
4 5 7 T J A
4 4 7 T J A
4 3 7 T J A
4 2 7 T J A
4 5 6 T J A
4 4 6 T J A
4 3 6 T J A
4 2 6 T J A
4 4 5 T J A
4 3 5 T J A
4 2 5 T J A
4 3 4 T J A
4 2 4 T J A
4 2 3 T J A
4 7 8 9 J A
4 6 8 9 J A
4 5 8 9 J A
4 4 8 9 J A
4 3 8 9 J A
4 2 8 9 J A
4 6 7 9 J A
4 5 7 9 J A
4 4 7 9 J A
4 3 7 9 J A
4 2 7 9 J A
4 5 6 9 J A
4 4 6 9 J A
4 3 6 9 J A
4 2 6 9 J A
4 4 5 9 J A
4 3 5 9 J A
4 2 5 9 J A
4 3 4 9 J A
4 2 4 9 J A
4 2 3 9 J A
4 6 7 8 J A
4 5 7 8 J A
4 4 7 8 J A
4 3 7 8 J A
4 2 7 8 J A
4 5 6 8 J A
4 4 6 8 J A
4 3 6 8 J A
4 2 6 8 J A
4 4 5 8 J A
4 3 5 8 J A
4 2 5 8 J A
4 3 4 8 J A
4 2 4 8 J A
4 2 3 8 J A
4 5 6 7 J A
4 4 6 7 J A
4 3 6 7 J A
4 2 6 7 J A
4 4 5 7 J A
4 3 5 7 J A
4 2 5 7 J A
4 3 4 7 J A
4 2 4 7 J A
4 2 3 7 J A
4 4 5 6 J A
4 3 5 6 J A
4 2 5 6 J A
4 3 4 6 J A
4 2 4 6 J A
4 2 3 6 J A
4 3 4 5 J A
4 2 4 5 J A
4 2 3 5 J A
4 2 3 4 J A
4 7 8 9 T A
4 6 8 9 T A
4 5 8 9 T A
4 4 8 9 T A
4 3 8 9 T A
4 2 8 9 T A
4 6 7 9 T A
4 5 7 9 T A
4 4 7 9 T A
4 3 7 9 T A
4 2 7 9 T A
4 5 6 9 T A
4 4 6 9 T A
4 3 6 9 T A
4 2 6 9 T A
4 4 5 9 T A
4 3 5 9 T A
4 2 5 9 T A
4 3 4 9 T A
4 2 4 9 T A
4 2 3 9 T A
4 6 7 8 T A
4 5 7 8 T A
4 4 7 8 T A
4 3 7 8 T A
4 2 7 8 T A
4 5 6 8 T A
4 4 6 8 T A
4 3 6 8 T A
4 2 6 8 T A
4 4 5 8 T A
4 3 5 8 T A
4 2 5 8 T A
4 3 4 8 T A
4 2 4 8 T A
4 2 3 8 T A
4 5 6 7 T A
4 4 6 7 T A
4 3 6 7 T A
4 2 6 7 T A
4 4 5 7 T A
4 3 5 7 T A
4 2 5 7 T A
4 3 4 7 T A
4 2 4 7 T A
4 2 3 7 T A
4 4 5 6 T A
4 3 5 6 T A
4 2 5 6 T A
4 3 4 6 T A
4 2 4 6 T A
4 2 3 6 T A
4 3 4 5 T A
4 2 4 5 T A
4 2 3 5 T A
4 2 3 4 T A
4 6 7 8 9 A
4 5 7 8 9 A
4 4 7 8 9 A
4 3 7 8 9 A
4 2 7 8 9 A
4 5 6 8 9 A
4 4 6 8 9 A
4 3 6 8 9 A
4 2 6 8 9 A
4 4 5 8 9 A
4 3 5 8 9 A
4 2 5 8 9 A
4 3 4 8 9 A
4 2 4 8 9 A
4 2 3 8 9 A
4 5 6 7 9 A
4 4 6 7 9 A
4 3 6 7 9 A
4 2 6 7 9 A
4 4 5 7 9 A
4 3 5 7 9 A
4 2 5 7 9 A
4 3 4 7 9 A
4 2 4 7 9 A
4 2 3 7 9 A
4 4 5 6 9 A
4 3 5 6 9 A
4 2 5 6 9 A
4 3 4 6 9 A
4 2 4 6 9 A
4 2 3 6 9 A
4 3 4 5 9 A
4 2 4 5 9 A
4 2 3 5 9 A
4 2 3 4 9 A
4 5 6 7 8 A
4 4 6 7 8 A
4 3 6 7 8 A
4 2 6 7 8 A
4 4 5 7 8 A
4 3 5 7 8 A
4 2 5 7 8 A
4 3 4 7 8 A
4 2 4 7 8 A
4 2 3 7 8 A
4 4 5 6 8 A
4 3 5 6 8 A
4 2 5 6 8 A
4 3 4 6 8 A
4 2 4 6 8 A
4 2 3 6 8 A
4 3 4 5 8 A
4 2 4 5 8 A
4 2 3 5 8 A
4 2 3 4 8 A
4 4 5 6 7 A
4 3 5 6 7 A
4 2 5 6 7 A
4 3 4 6 7 A
4 2 4 6 7 A
4 2 3 6 7 A
4 3 4 5 7 A
4 2 4 5 7 A
4 2 3 5 7 A
4 2 3 4 7 A
4 3 4 5 6 A
4 2 4 5 6 A
4 2 3 5 6 A
4 2 3 4 6 A
4 8 T J Q K King High Flush
4 7 T J Q K
4 6 T J Q K
4 5 T J Q K
4 4 T J Q K
4 3 T J Q K
4 2 T J Q K
4 8 9 J Q K
4 7 9 J Q K
4 6 9 J Q K
4 5 9 J Q K
4 4 9 J Q K
4 3 9 J Q K
4 2 9 J Q K
4 7 8 J Q K
4 6 8 J Q K
4 5 8 J Q K
4 4 8 J Q K
4 3 8 J Q K
4 2 8 J Q K
4 6 7 J Q K
4 5 7 J Q K
4 4 7 J Q K
4 3 7 J Q K
4 2 7 J Q K
4 5 6 J Q K
4 4 6 J Q K
4 3 6 J Q K
4 2 6 J Q K
4 4 5 J Q K
4 3 5 J Q K
4 2 5 J Q K
4 3 4 J Q K
4 2 4 J Q K
4 2 3 J Q K
4 8 9 T Q K
4 7 9 T Q K
4 6 9 T Q K
4 5 9 T Q K
4 4 9 T Q K
4 3 9 T Q K
4 2 9 T Q K
4 7 8 T Q K
4 6 8 T Q K
4 5 8 T Q K
4 4 8 T Q K
4 3 8 T Q K
4 2 8 T Q K
4 6 7 T Q K
4 5 7 T Q K
4 4 7 T Q K
4 3 7 T Q K
4 2 7 T Q K
4 5 6 T Q K
4 4 6 T Q K
4 3 6 T Q K
4 2 6 T Q K
4 4 5 T Q K
4 3 5 T Q K
4 2 5 T Q K
4 3 4 T Q K
4 2 4 T Q K
4 2 3 T Q K
4 7 8 9 Q K
4 6 8 9 Q K
4 5 8 9 Q K
4 4 8 9 Q K
4 3 8 9 Q K
4 2 8 9 Q K
4 6 7 9 Q K
4 5 7 9 Q K
4 4 7 9 Q K
4 3 7 9 Q K
4 2 7 9 Q K
4 5 6 9 Q K
4 4 6 9 Q K
4 3 6 9 Q K
4 2 6 9 Q K
4 4 5 9 Q K
4 3 5 9 Q K
4 2 5 9 Q K
4 3 4 9 Q K
4 2 4 9 Q K
4 2 3 9 Q K
4 6 7 8 Q K
4 5 7 8 Q K
4 4 7 8 Q K
4 3 7 8 Q K
4 2 7 8 Q K
4 5 6 8 Q K
4 4 6 8 Q K
4 3 6 8 Q K
4 2 6 8 Q K
4 4 5 8 Q K
4 3 5 8 Q K
4 2 5 8 Q K
4 3 4 8 Q K
4 2 4 8 Q K
4 2 3 8 Q K
4 5 6 7 Q K
4 4 6 7 Q K
4 3 6 7 Q K
4 2 6 7 Q K
4 4 5 7 Q K
4 3 5 7 Q K
4 2 5 7 Q K
4 3 4 7 Q K
4 2 4 7 Q K
4 2 3 7 Q K
4 4 5 6 Q K
4 3 5 6 Q K
4 2 5 6 Q K
4 3 4 6 Q K
4 2 4 6 Q K
4 2 3 6 Q K
4 3 4 5 Q K
4 2 4 5 Q K
4 2 3 5 Q K
4 2 3 4 Q K
4 8 9 T J K
4 7 9 T J K
4 6 9 T J K
4 5 9 T J K
4 4 9 T J K
4 3 9 T J K
4 2 9 T J K
4 7 8 T J K
4 6 8 T J K
4 5 8 T J K
4 4 8 T J K
4 3 8 T J K
4 2 8 T J K
4 6 7 T J K
4 5 7 T J K
4 4 7 T J K
4 3 7 T J K
4 2 7 T J K
4 5 6 T J K
4 4 6 T J K
4 3 6 T J K
4 2 6 T J K
4 4 5 T J K
4 3 5 T J K
4 2 5 T J K
4 3 4 T J K
4 2 4 T J K
4 2 3 T J K
4 7 8 9 J K
4 6 8 9 J K
4 5 8 9 J K
4 4 8 9 J K
4 3 8 9 J K
4 2 8 9 J K
4 6 7 9 J K
4 5 7 9 J K
4 4 7 9 J K
4 3 7 9 J K
4 2 7 9 J K
4 5 6 9 J K
4 4 6 9 J K
4 3 6 9 J K
4 2 6 9 J K
4 4 5 9 J K
4 3 5 9 J K
4 2 5 9 J K
4 3 4 9 J K
4 2 4 9 J K
4 2 3 9 J K
4 6 7 8 J K
4 5 7 8 J K
4 4 7 8 J K
4 3 7 8 J K
4 2 7 8 J K
4 5 6 8 J K
4 4 6 8 J K
4 3 6 8 J K
4 2 6 8 J K
4 4 5 8 J K
4 3 5 8 J K
4 2 5 8 J K
4 3 4 8 J K
4 2 4 8 J K
4 2 3 8 J K
4 5 6 7 J K
4 4 6 7 J K
4 3 6 7 J K
4 2 6 7 J K
4 4 5 7 J K
4 3 5 7 J K
4 2 5 7 J K
4 3 4 7 J K
4 2 4 7 J K
4 2 3 7 J K
4 4 5 6 J K
4 3 5 6 J K
4 2 5 6 J K
4 3 4 6 J K
4 2 4 6 J K
4 2 3 6 J K
4 3 4 5 J K
4 2 4 5 J K
4 2 3 5 J K
4 2 3 4 J K
4 7 8 9 T K
4 6 8 9 T K
4 5 8 9 T K
4 4 8 9 T K
4 3 8 9 T K
4 2 8 9 T K
4 6 7 9 T K
4 5 7 9 T K
4 4 7 9 T K
4 3 7 9 T K
4 2 7 9 T K
4 5 6 9 T K
4 4 6 9 T K
4 3 6 9 T K
4 2 6 9 T K
4 4 5 9 T K
4 3 5 9 T K
4 2 5 9 T K
4 3 4 9 T K
4 2 4 9 T K
4 2 3 9 T K
4 6 7 8 T K
4 5 7 8 T K
4 4 7 8 T K
4 3 7 8 T K
4 2 7 8 T K
4 5 6 8 T K
4 4 6 8 T K
4 3 6 8 T K
4 2 6 8 T K
4 4 5 8 T K
4 3 5 8 T K
4 2 5 8 T K
4 3 4 8 T K
4 2 4 8 T K
4 2 3 8 T K
4 5 6 7 T K
4 4 6 7 T K
4 3 6 7 T K
4 2 6 7 T K
4 4 5 7 T K
4 3 5 7 T K
4 2 5 7 T K
4 3 4 7 T K
4 2 4 7 T K
4 2 3 7 T K
4 4 5 6 T K
4 3 5 6 T K
4 2 5 6 T K
4 3 4 6 T K
4 2 4 6 T K
4 2 3 6 T K
4 3 4 5 T K
4 2 4 5 T K
4 2 3 5 T K
4 2 3 4 T K
4 6 7 8 9 K
4 5 7 8 9 K
4 4 7 8 9 K
4 3 7 8 9 K
4 2 7 8 9 K
4 5 6 8 9 K
4 4 6 8 9 K
4 3 6 8 9 K
4 2 6 8 9 K
4 4 5 8 9 K
4 3 5 8 9 K
4 2 5 8 9 K
4 3 4 8 9 K
4 2 4 8 9 K
4 2 3 8 9 K
4 5 6 7 9 K
4 4 6 7 9 K
4 3 6 7 9 K
4 2 6 7 9 K
4 4 5 7 9 K
4 3 5 7 9 K
4 2 5 7 9 K
4 3 4 7 9 K
4 2 4 7 9 K
4 2 3 7 9 K
4 4 5 6 9 K
4 3 5 6 9 K
4 2 5 6 9 K
4 3 4 6 9 K
4 2 4 6 9 K
4 2 3 6 9 K
4 3 4 5 9 K
4 2 4 5 9 K
4 2 3 5 9 K
4 2 3 4 9 K
4 5 6 7 8 K
4 4 6 7 8 K
4 3 6 7 8 K
4 2 6 7 8 K
4 4 5 7 8 K
4 3 5 7 8 K
4 2 5 7 8 K
4 3 4 7 8 K
4 2 4 7 8 K
4 2 3 7 8 K
4 4 5 6 8 K
4 3 5 6 8 K
4 2 5 6 8 K
4 3 4 6 8 K
4 2 4 6 8 K
4 2 3 6 8 K
4 3 4 5 8 K
4 2 4 5 8 K
4 2 3 5 8 K
4 2 3 4 8 K
4 4 5 6 7 K
4 3 5 6 7 K
4 2 5 6 7 K
4 3 4 6 7 K
4 2 4 6 7 K
4 2 3 6 7 K
4 3 4 5 7 K
4 2 4 5 7 K
4 2 3 5 7 K
4 2 3 4 7 K
4 3 4 5 6 K
4 2 4 5 6 K
4 2 3 5 6 K
4 2 3 4 6 K
4 2 3 4 5 K
4 7 9 T J Q Queen High Flush
4 6 9 T J Q
4 5 9 T J Q
4 4 9 T J Q
4 3 9 T J Q
4 2 9 T J Q
4 7 8 T J Q
4 6 8 T J Q
4 5 8 T J Q
4 4 8 T J Q
4 3 8 T J Q
4 2 8 T J Q
4 6 7 T J Q
4 5 7 T J Q
4 4 7 T J Q
4 3 7 T J Q
4 2 7 T J Q
4 5 6 T J Q
4 4 6 T J Q
4 3 6 T J Q
4 2 6 T J Q
4 4 5 T J Q
4 3 5 T J Q
4 2 5 T J Q
4 3 4 T J Q
4 2 4 T J Q
4 2 3 T J Q
4 7 8 9 J Q
4 6 8 9 J Q
4 5 8 9 J Q
4 4 8 9 J Q
4 3 8 9 J Q
4 2 8 9 J Q
4 6 7 9 J Q
4 5 7 9 J Q
4 4 7 9 J Q
4 3 7 9 J Q
4 2 7 9 J Q
4 5 6 9 J Q
4 4 6 9 J Q
4 3 6 9 J Q
4 2 6 9 J Q
4 4 5 9 J Q
4 3 5 9 J Q
4 2 5 9 J Q
4 3 4 9 J Q
4 2 4 9 J Q
4 2 3 9 J Q
4 6 7 8 J Q
4 5 7 8 J Q
4 4 7 8 J Q
4 3 7 8 J Q
4 2 7 8 J Q
4 5 6 8 J Q
4 4 6 8 J Q
4 3 6 8 J Q
4 2 6 8 J Q
4 4 5 8 J Q
4 3 5 8 J Q
4 2 5 8 J Q
4 3 4 8 J Q
4 2 4 8 J Q
4 2 3 8 J Q
4 5 6 7 J Q
4 4 6 7 J Q
4 3 6 7 J Q
4 2 6 7 J Q
4 4 5 7 J Q
4 3 5 7 J Q
4 2 5 7 J Q
4 3 4 7 J Q
4 2 4 7 J Q
4 2 3 7 J Q
4 4 5 6 J Q
4 3 5 6 J Q
4 2 5 6 J Q
4 3 4 6 J Q
4 2 4 6 J Q
4 2 3 6 J Q
4 3 4 5 J Q
4 2 4 5 J Q
4 2 3 5 J Q
4 2 3 4 J Q
4 7 8 9 T Q
4 6 8 9 T Q
4 5 8 9 T Q
4 4 8 9 T Q
4 3 8 9 T Q
4 2 8 9 T Q
4 6 7 9 T Q
4 5 7 9 T Q
4 4 7 9 T Q
4 3 7 9 T Q
4 2 7 9 T Q
4 5 6 9 T Q
4 4 6 9 T Q
4 3 6 9 T Q
4 2 6 9 T Q
4 4 5 9 T Q
4 3 5 9 T Q
4 2 5 9 T Q
4 3 4 9 T Q
4 2 4 9 T Q
4 2 3 9 T Q
4 6 7 8 T Q
4 5 7 8 T Q
4 4 7 8 T Q
4 3 7 8 T Q
4 2 7 8 T Q
4 5 6 8 T Q
4 4 6 8 T Q
4 3 6 8 T Q
4 2 6 8 T Q
4 4 5 8 T Q
4 3 5 8 T Q
4 2 5 8 T Q
4 3 4 8 T Q
4 2 4 8 T Q
4 2 3 8 T Q
4 5 6 7 T Q
4 4 6 7 T Q
4 3 6 7 T Q
4 2 6 7 T Q
4 4 5 7 T Q
4 3 5 7 T Q
4 2 5 7 T Q
4 3 4 7 T Q
4 2 4 7 T Q
4 2 3 7 T Q
4 4 5 6 T Q
4 3 5 6 T Q
4 2 5 6 T Q
4 3 4 6 T Q
4 2 4 6 T Q
4 2 3 6 T Q
4 3 4 5 T Q
4 2 4 5 T Q
4 2 3 5 T Q
4 2 3 4 T Q
4 6 7 8 9 Q
4 5 7 8 9 Q
4 4 7 8 9 Q
4 3 7 8 9 Q
4 2 7 8 9 Q
4 5 6 8 9 Q
4 4 6 8 9 Q
4 3 6 8 9 Q
4 2 6 8 9 Q
4 4 5 8 9 Q
4 3 5 8 9 Q
4 2 5 8 9 Q
4 3 4 8 9 Q
4 2 4 8 9 Q
4 2 3 8 9 Q
4 5 6 7 9 Q
4 4 6 7 9 Q
4 3 6 7 9 Q
4 2 6 7 9 Q
4 4 5 7 9 Q
4 3 5 7 9 Q
4 2 5 7 9 Q
4 3 4 7 9 Q
4 2 4 7 9 Q
4 2 3 7 9 Q
4 4 5 6 9 Q
4 3 5 6 9 Q
4 2 5 6 9 Q
4 3 4 6 9 Q
4 2 4 6 9 Q
4 2 3 6 9 Q
4 3 4 5 9 Q
4 2 4 5 9 Q
4 2 3 5 9 Q
4 2 3 4 9 Q
4 5 6 7 8 Q
4 4 6 7 8 Q
4 3 6 7 8 Q
4 2 6 7 8 Q
4 4 5 7 8 Q
4 3 5 7 8 Q
4 2 5 7 8 Q
4 3 4 7 8 Q
4 2 4 7 8 Q
4 2 3 7 8 Q
4 4 5 6 8 Q
4 3 5 6 8 Q
4 2 5 6 8 Q
4 3 4 6 8 Q
4 2 4 6 8 Q
4 2 3 6 8 Q
4 3 4 5 8 Q
4 2 4 5 8 Q
4 2 3 5 8 Q
4 2 3 4 8 Q
4 4 5 6 7 Q
4 3 5 6 7 Q
4 2 5 6 7 Q
4 3 4 6 7 Q
4 2 4 6 7 Q
4 2 3 6 7 Q
4 3 4 5 7 Q
4 2 4 5 7 Q
4 2 3 5 7 Q
4 2 3 4 7 Q
4 3 4 5 6 Q
4 2 4 5 6 Q
4 2 3 5 6 Q
4 2 3 4 6 Q
4 2 3 4 5 Q
4 6 8 9 T J Jack High Flush
4 5 8 9 T J
4 4 8 9 T J
4 3 8 9 T J
4 2 8 9 T J
4 6 7 9 T J
4 5 7 9 T J
4 4 7 9 T J
4 3 7 9 T J
4 2 7 9 T J
4 5 6 9 T J
4 4 6 9 T J
4 3 6 9 T J
4 2 6 9 T J
4 4 5 9 T J
4 3 5 9 T J
4 2 5 9 T J
4 3 4 9 T J
4 2 4 9 T J
4 2 3 9 T J
4 6 7 8 T J
4 5 7 8 T J
4 4 7 8 T J
4 3 7 8 T J
4 2 7 8 T J
4 5 6 8 T J
4 4 6 8 T J
4 3 6 8 T J
4 2 6 8 T J
4 4 5 8 T J
4 3 5 8 T J
4 2 5 8 T J
4 3 4 8 T J
4 2 4 8 T J
4 2 3 8 T J
4 5 6 7 T J
4 4 6 7 T J
4 3 6 7 T J
4 2 6 7 T J
4 4 5 7 T J
4 3 5 7 T J
4 2 5 7 T J
4 3 4 7 T J
4 2 4 7 T J
4 2 3 7 T J
4 4 5 6 T J
4 3 5 6 T J
4 2 5 6 T J
4 3 4 6 T J
4 2 4 6 T J
4 2 3 6 T J
4 3 4 5 T J
4 2 4 5 T J
4 2 3 5 T J
4 2 3 4 T J
4 6 7 8 9 J
4 5 7 8 9 J
4 4 7 8 9 J
4 3 7 8 9 J
4 2 7 8 9 J
4 5 6 8 9 J
4 4 6 8 9 J
4 3 6 8 9 J
4 2 6 8 9 J
4 4 5 8 9 J
4 3 5 8 9 J
4 2 5 8 9 J
4 3 4 8 9 J
4 2 4 8 9 J
4 2 3 8 9 J
4 5 6 7 9 J
4 4 6 7 9 J
4 3 6 7 9 J
4 2 6 7 9 J
4 4 5 7 9 J
4 3 5 7 9 J
4 2 5 7 9 J
4 3 4 7 9 J
4 2 4 7 9 J
4 2 3 7 9 J
4 4 5 6 9 J
4 3 5 6 9 J
4 2 5 6 9 J
4 3 4 6 9 J
4 2 4 6 9 J
4 2 3 6 9 J
4 3 4 5 9 J
4 2 4 5 9 J
4 2 3 5 9 J
4 2 3 4 9 J
4 5 6 7 8 J
4 4 6 7 8 J
4 3 6 7 8 J
4 2 6 7 8 J
4 4 5 7 8 J
4 3 5 7 8 J
4 2 5 7 8 J
4 3 4 7 8 J
4 2 4 7 8 J
4 2 3 7 8 J
4 4 5 6 8 J
4 3 5 6 8 J
4 2 5 6 8 J
4 3 4 6 8 J
4 2 4 6 8 J
4 2 3 6 8 J
4 3 4 5 8 J
4 2 4 5 8 J
4 2 3 5 8 J
4 2 3 4 8 J
4 4 5 6 7 J
4 3 5 6 7 J
4 2 5 6 7 J
4 3 4 6 7 J
4 2 4 6 7 J
4 2 3 6 7 J
4 3 4 5 7 J
4 2 4 5 7 J
4 2 3 5 7 J
4 2 3 4 7 J
4 3 4 5 6 J
4 2 4 5 6 J
4 2 3 5 6 J
4 2 3 4 6 J
4 2 3 4 5 J
4 5 7 8 9 T Ten High Flush
4 4 7 8 9 T
4 3 7 8 9 T
4 2 7 8 9 T
4 5 6 8 9 T
4 4 6 8 9 T
4 3 6 8 9 T
4 2 6 8 9 T
4 4 5 8 9 T
4 3 5 8 9 T
4 2 5 8 9 T
4 3 4 8 9 T
4 2 4 8 9 T
4 2 3 8 9 T
4 5 6 7 9 T
4 4 6 7 9 T
4 3 6 7 9 T
4 2 6 7 9 T
4 4 5 7 9 T
4 3 5 7 9 T
4 2 5 7 9 T
4 3 4 7 9 T
4 2 4 7 9 T
4 2 3 7 9 T
4 4 5 6 9 T
4 3 5 6 9 T
4 2 5 6 9 T
4 3 4 6 9 T
4 2 4 6 9 T
4 2 3 6 9 T
4 3 4 5 9 T
4 2 4 5 9 T
4 2 3 5 9 T
4 2 3 4 9 T
4 5 6 7 8 T
4 4 6 7 8 T
4 3 6 7 8 T
4 2 6 7 8 T
4 4 5 7 8 T
4 3 5 7 8 T
4 2 5 7 8 T
4 3 4 7 8 T
4 2 4 7 8 T
4 2 3 7 8 T
4 4 5 6 8 T
4 3 5 6 8 T
4 2 5 6 8 T
4 3 4 6 8 T
4 2 4 6 8 T
4 2 3 6 8 T
4 3 4 5 8 T
4 2 4 5 8 T
4 2 3 5 8 T
4 2 3 4 8 T
4 4 5 6 7 T
4 3 5 6 7 T
4 2 5 6 7 T
4 3 4 6 7 T
4 2 4 6 7 T
4 2 3 6 7 T
4 3 4 5 7 T
4 2 4 5 7 T
4 2 3 5 7 T
4 2 3 4 7 T
4 3 4 5 6 T
4 2 4 5 6 T
4 2 3 5 6 T
4 2 3 4 6 T
4 2 3 4 5 T
4 4 6 7 8 9 Nine High Flush
4 3 6 7 8 9
4 2 6 7 8 9
4 4 5 7 8 9
4 3 5 7 8 9
4 2 5 7 8 9
4 3 4 7 8 9
4 2 4 7 8 9
4 2 3 7 8 9
4 4 5 6 8 9
4 3 5 6 8 9
4 2 5 6 8 9
4 3 4 6 8 9
4 2 4 6 8 9
4 2 3 6 8 9
4 3 4 5 8 9
4 2 4 5 8 9
4 2 3 5 8 9
4 2 3 4 8 9
4 4 5 6 7 9
4 3 5 6 7 9
4 2 5 6 7 9
4 3 4 6 7 9
4 2 4 6 7 9
4 2 3 6 7 9
4 3 4 5 7 9
4 2 4 5 7 9
4 2 3 5 7 9
4 2 3 4 7 9
4 3 4 5 6 9
4 2 4 5 6 9
4 2 3 5 6 9
4 2 3 4 6 9
4 2 3 4 5 9
4 3 5 6 7 8 Eight High Flush
4 2 5 6 7 8
4 3 4 6 7 8
4 2 4 6 7 8
4 2 3 6 7 8
4 3 4 5 7 8
4 2 4 5 7 8
4 2 3 5 7 8
4 2 3 4 7 8
4 3 4 5 6 8
4 2 4 5 6 8
4 2 3 5 6 8
4 2 3 4 6 8
4 2 3 4 5 8
4 2 4 5 6 7 Seven High Flush
4 2 3 5 6 7
4 2 3 4 6 7
4 2 3 4 5 7
1024 T J Q K A Ace High Straight STRAIGHT
1024 9 T J Q K King High Straight
1024 8 9 T J Q Queen High Straight
1024 7 8 9 T J Jack High Straight
1024 6 7 8 9 T Ten High Straight
1024 5 6 7 8 9 Nine High Straight
1024 4 5 6 7 8 Eight High Straight
1024 3 4 5 6 7 Seven High Straight
1024 2 3 4 5 6 Six High Straight
1024 A 2 3 4 5 Five High Straight
64 Q K A A A Three Aces THREE OF A KIND
64 J K A A A
64 T K A A A
64 9 K A A A
64 8 K A A A
64 7 K A A A
64 6 K A A A
64 5 K A A A
64 4 K A A A
64 3 K A A A
64 2 K A A A
64 J Q A A A
64 T Q A A A
64 9 Q A A A
64 8 Q A A A
64 7 Q A A A
64 6 Q A A A
64 5 Q A A A
64 4 Q A A A
64 3 Q A A A
64 2 Q A A A
64 T J A A A
64 9 J A A A
64 8 J A A A
64 7 J A A A
64 6 J A A A
64 5 J A A A
64 4 J A A A
64 3 J A A A
64 2 J A A A
64 9 T A A A
64 8 T A A A
64 7 T A A A
64 6 T A A A
64 5 T A A A
64 4 T A A A
64 3 T A A A
64 2 T A A A
64 8 9 A A A
64 7 9 A A A
64 6 9 A A A
64 5 9 A A A
64 4 9 A A A
64 3 9 A A A
64 2 9 A A A
64 7 8 A A A
64 6 8 A A A
64 5 8 A A A
64 4 8 A A A
64 3 8 A A A
64 2 8 A A A
64 6 7 A A A
64 5 7 A A A
64 4 7 A A A
64 3 7 A A A
64 2 7 A A A
64 5 6 A A A
64 4 6 A A A
64 3 6 A A A
64 2 6 A A A
64 4 5 A A A
64 3 5 A A A
64 2 5 A A A
64 3 4 A A A
64 2 4 A A A
64 2 3 A A A
64 Q K K K A Three Kings
64 J K K K A
64 T K K K A
64 9 K K K A
64 8 K K K A
64 7 K K K A
64 6 K K K A
64 5 K K K A
64 4 K K K A
64 3 K K K A
64 2 K K K A
64 J Q K K K
64 T Q K K K
64 9 Q K K K
64 8 Q K K K
64 7 Q K K K
64 6 Q K K K
64 5 Q K K K
64 4 Q K K K
64 3 Q K K K
64 2 Q K K K
64 T J K K K
64 9 J K K K
64 8 J K K K
64 7 J K K K
64 6 J K K K
64 5 J K K K
64 4 J K K K
64 3 J K K K
64 2 J K K K
64 9 T K K K
64 8 T K K K
64 7 T K K K
64 6 T K K K
64 5 T K K K
64 4 T K K K
64 3 T K K K
64 2 T K K K
64 8 9 K K K
64 7 9 K K K
64 6 9 K K K
64 5 9 K K K
64 4 9 K K K
64 3 9 K K K
64 2 9 K K K
64 7 8 K K K
64 6 8 K K K
64 5 8 K K K
64 4 8 K K K
64 3 8 K K K
64 2 8 K K K
64 6 7 K K K
64 5 7 K K K
64 4 7 K K K
64 3 7 K K K
64 2 7 K K K
64 5 6 K K K
64 4 6 K K K
64 3 6 K K K
64 2 6 K K K
64 4 5 K K K
64 3 5 K K K
64 2 5 K K K
64 3 4 K K K
64 2 4 K K K
64 2 3 K K K
64 Q Q Q K A Three Queens
64 J Q Q Q A
64 T Q Q Q A
64 9 Q Q Q A
64 8 Q Q Q A
64 7 Q Q Q A
64 6 Q Q Q A
64 5 Q Q Q A
64 4 Q Q Q A
64 3 Q Q Q A
64 2 Q Q Q A
64 J Q Q Q K
64 T Q Q Q K
64 9 Q Q Q K
64 8 Q Q Q K
64 7 Q Q Q K
64 6 Q Q Q K
64 5 Q Q Q K
64 4 Q Q Q K
64 3 Q Q Q K
64 2 Q Q Q K
64 T J Q Q Q
64 9 J Q Q Q
64 8 J Q Q Q
64 7 J Q Q Q
64 6 J Q Q Q
64 5 J Q Q Q
64 4 J Q Q Q
64 3 J Q Q Q
64 2 J Q Q Q
64 9 T Q Q Q
64 8 T Q Q Q
64 7 T Q Q Q
64 6 T Q Q Q
64 5 T Q Q Q
64 4 T Q Q Q
64 3 T Q Q Q
64 2 T Q Q Q
64 8 9 Q Q Q
64 7 9 Q Q Q
64 6 9 Q Q Q
64 5 9 Q Q Q
64 4 9 Q Q Q
64 3 9 Q Q Q
64 2 9 Q Q Q
64 7 8 Q Q Q
64 6 8 Q Q Q
64 5 8 Q Q Q
64 4 8 Q Q Q
64 3 8 Q Q Q
64 2 8 Q Q Q
64 6 7 Q Q Q
64 5 7 Q Q Q
64 4 7 Q Q Q
64 3 7 Q Q Q
64 2 7 Q Q Q
64 5 6 Q Q Q
64 4 6 Q Q Q
64 3 6 Q Q Q
64 2 6 Q Q Q
64 4 5 Q Q Q
64 3 5 Q Q Q
64 2 5 Q Q Q
64 3 4 Q Q Q
64 2 4 Q Q Q
64 2 3 Q Q Q
64 J J J K A Three Jacks
64 J J J Q A
64 T J J J A
64 9 J J J A
64 8 J J J A
64 7 J J J A
64 6 J J J A
64 5 J J J A
64 4 J J J A
64 3 J J J A
64 2 J J J A
64 J J J Q K
64 T J J J K
64 9 J J J K
64 8 J J J K
64 7 J J J K
64 6 J J J K
64 5 J J J K
64 4 J J J K
64 3 J J J K
64 2 J J J K
64 T J J J Q
64 9 J J J Q
64 8 J J J Q
64 7 J J J Q
64 6 J J J Q
64 5 J J J Q
64 4 J J J Q
64 3 J J J Q
64 2 J J J Q
64 9 T J J J
64 8 T J J J
64 7 T J J J
64 6 T J J J
64 5 T J J J
64 4 T J J J
64 3 T J J J
64 2 T J J J
64 8 9 J J J
64 7 9 J J J
64 6 9 J J J
64 5 9 J J J
64 4 9 J J J
64 3 9 J J J
64 2 9 J J J
64 7 8 J J J
64 6 8 J J J
64 5 8 J J J
64 4 8 J J J
64 3 8 J J J
64 2 8 J J J
64 6 7 J J J
64 5 7 J J J
64 4 7 J J J
64 3 7 J J J
64 2 7 J J J
64 5 6 J J J
64 4 6 J J J
64 3 6 J J J
64 2 6 J J J
64 4 5 J J J
64 3 5 J J J
64 2 5 J J J
64 3 4 J J J
64 2 4 J J J
64 2 3 J J J
64 T T T K A Three Tens
64 T T T Q A
64 T T T J A
64 9 T T T A
64 8 T T T A
64 7 T T T A
64 6 T T T A
64 5 T T T A
64 4 T T T A
64 3 T T T A
64 2 T T T A
64 T T T Q K
64 T T T J K
64 9 T T T K
64 8 T T T K
64 7 T T T K
64 6 T T T K
64 5 T T T K
64 4 T T T K
64 3 T T T K
64 2 T T T K
64 T T T J Q
64 9 T T T Q
64 8 T T T Q
64 7 T T T Q
64 6 T T T Q
64 5 T T T Q
64 4 T T T Q
64 3 T T T Q
64 2 T T T Q
64 9 T T T J
64 8 T T T J
64 7 T T T J
64 6 T T T J
64 5 T T T J
64 4 T T T J
64 3 T T T J
64 2 T T T J
64 8 9 T T T
64 7 9 T T T
64 6 9 T T T
64 5 9 T T T
64 4 9 T T T
64 3 9 T T T
64 2 9 T T T
64 7 8 T T T
64 6 8 T T T
64 5 8 T T T
64 4 8 T T T
64 3 8 T T T
64 2 8 T T T
64 6 7 T T T
64 5 7 T T T
64 4 7 T T T
64 3 7 T T T
64 2 7 T T T
64 5 6 T T T
64 4 6 T T T
64 3 6 T T T
64 2 6 T T T
64 4 5 T T T
64 3 5 T T T
64 2 5 T T T
64 3 4 T T T
64 2 4 T T T
64 2 3 T T T
64 9 9 9 K A Three Nines
64 9 9 9 Q A
64 9 9 9 J A
64 9 9 9 T A
64 8 9 9 9 A
64 7 9 9 9 A
64 6 9 9 9 A
64 5 9 9 9 A
64 4 9 9 9 A
64 3 9 9 9 A
64 2 9 9 9 A
64 9 9 9 Q K
64 9 9 9 J K
64 9 9 9 T K
64 8 9 9 9 K
64 7 9 9 9 K
64 6 9 9 9 K
64 5 9 9 9 K
64 4 9 9 9 K
64 3 9 9 9 K
64 2 9 9 9 K
64 9 9 9 J Q
64 9 9 9 T Q
64 8 9 9 9 Q
64 7 9 9 9 Q
64 6 9 9 9 Q
64 5 9 9 9 Q
64 4 9 9 9 Q
64 3 9 9 9 Q
64 2 9 9 9 Q
64 9 9 9 T J
64 8 9 9 9 J
64 7 9 9 9 J
64 6 9 9 9 J
64 5 9 9 9 J
64 4 9 9 9 J
64 3 9 9 9 J
64 2 9 9 9 J
64 8 9 9 9 T
64 7 9 9 9 T
64 6 9 9 9 T
64 5 9 9 9 T
64 4 9 9 9 T
64 3 9 9 9 T
64 2 9 9 9 T
64 7 8 9 9 9
64 6 8 9 9 9
64 5 8 9 9 9
64 4 8 9 9 9
64 3 8 9 9 9
64 2 8 9 9 9
64 6 7 9 9 9
64 5 7 9 9 9
64 4 7 9 9 9
64 3 7 9 9 9
64 2 7 9 9 9
64 5 6 9 9 9
64 4 6 9 9 9
64 3 6 9 9 9
64 2 6 9 9 9
64 4 5 9 9 9
64 3 5 9 9 9
64 2 5 9 9 9
64 3 4 9 9 9
64 2 4 9 9 9
64 2 3 9 9 9
64 8 8 8 K A Three Eights
64 8 8 8 Q A
64 8 8 8 J A
64 8 8 8 T A
64 8 8 8 9 A
64 7 8 8 8 A
64 6 8 8 8 A
64 5 8 8 8 A
64 4 8 8 8 A
64 3 8 8 8 A
64 2 8 8 8 A
64 8 8 8 Q K
64 8 8 8 J K
64 8 8 8 T K
64 8 8 8 9 K
64 7 8 8 8 K
64 6 8 8 8 K
64 5 8 8 8 K
64 4 8 8 8 K
64 3 8 8 8 K
64 2 8 8 8 K
64 8 8 8 J Q
64 8 8 8 T Q
64 8 8 8 9 Q
64 7 8 8 8 Q
64 6 8 8 8 Q
64 5 8 8 8 Q
64 4 8 8 8 Q
64 3 8 8 8 Q
64 2 8 8 8 Q
64 8 8 8 T J
64 8 8 8 9 J
64 7 8 8 8 J
64 6 8 8 8 J
64 5 8 8 8 J
64 4 8 8 8 J
64 3 8 8 8 J
64 2 8 8 8 J
64 8 8 8 9 T
64 7 8 8 8 T
64 6 8 8 8 T
64 5 8 8 8 T
64 4 8 8 8 T
64 3 8 8 8 T
64 2 8 8 8 T
64 7 8 8 8 9
64 6 8 8 8 9
64 5 8 8 8 9
64 4 8 8 8 9
64 3 8 8 8 9
64 2 8 8 8 9
64 6 7 8 8 8
64 5 7 8 8 8
64 4 7 8 8 8
64 3 7 8 8 8
64 2 7 8 8 8
64 5 6 8 8 8
64 4 6 8 8 8
64 3 6 8 8 8
64 2 6 8 8 8
64 4 5 8 8 8
64 3 5 8 8 8
64 2 5 8 8 8
64 3 4 8 8 8
64 2 4 8 8 8
64 2 3 8 8 8
64 7 7 7 K A Three Sevens
64 7 7 7 Q A
64 7 7 7 J A
64 7 7 7 T A
64 7 7 7 9 A
64 7 7 7 8 A
64 6 7 7 7 A
64 5 7 7 7 A
64 4 7 7 7 A
64 3 7 7 7 A
64 2 7 7 7 A
64 7 7 7 Q K
64 7 7 7 J K
64 7 7 7 T K
64 7 7 7 9 K
64 7 7 7 8 K
64 6 7 7 7 K
64 5 7 7 7 K
64 4 7 7 7 K
64 3 7 7 7 K
64 2 7 7 7 K
64 7 7 7 J Q
64 7 7 7 T Q
64 7 7 7 9 Q
64 7 7 7 8 Q
64 6 7 7 7 Q
64 5 7 7 7 Q
64 4 7 7 7 Q
64 3 7 7 7 Q
64 2 7 7 7 Q
64 7 7 7 T J
64 7 7 7 9 J
64 7 7 7 8 J
64 6 7 7 7 J
64 5 7 7 7 J
64 4 7 7 7 J
64 3 7 7 7 J
64 2 7 7 7 J
64 7 7 7 9 T
64 7 7 7 8 T
64 6 7 7 7 T
64 5 7 7 7 T
64 4 7 7 7 T
64 3 7 7 7 T
64 2 7 7 7 T
64 7 7 7 8 9
64 6 7 7 7 9
64 5 7 7 7 9
64 4 7 7 7 9
64 3 7 7 7 9
64 2 7 7 7 9
64 6 7 7 7 8
64 5 7 7 7 8
64 4 7 7 7 8
64 3 7 7 7 8
64 2 7 7 7 8
64 5 6 7 7 7
64 4 6 7 7 7
64 3 6 7 7 7
64 2 6 7 7 7
64 4 5 7 7 7
64 3 5 7 7 7
64 2 5 7 7 7
64 3 4 7 7 7
64 2 4 7 7 7
64 2 3 7 7 7
64 6 6 6 K A Three Sixes
64 6 6 6 Q A
64 6 6 6 J A
64 6 6 6 T A
64 6 6 6 9 A
64 6 6 6 8 A
64 6 6 6 7 A
64 5 6 6 6 A
64 4 6 6 6 A
64 3 6 6 6 A
64 2 6 6 6 A
64 6 6 6 Q K
64 6 6 6 J K
64 6 6 6 T K
64 6 6 6 9 K
64 6 6 6 8 K
64 6 6 6 7 K
64 5 6 6 6 K
64 4 6 6 6 K
64 3 6 6 6 K
64 2 6 6 6 K
64 6 6 6 J Q
64 6 6 6 T Q
64 6 6 6 9 Q
64 6 6 6 8 Q
64 6 6 6 7 Q
64 5 6 6 6 Q
64 4 6 6 6 Q
64 3 6 6 6 Q
64 2 6 6 6 Q
64 6 6 6 T J
64 6 6 6 9 J
64 6 6 6 8 J
64 6 6 6 7 J
64 5 6 6 6 J
64 4 6 6 6 J
64 3 6 6 6 J
64 2 6 6 6 J
64 6 6 6 9 T
64 6 6 6 8 T
64 6 6 6 7 T
64 5 6 6 6 T
64 4 6 6 6 T
64 3 6 6 6 T
64 2 6 6 6 T
64 6 6 6 8 9
64 6 6 6 7 9
64 5 6 6 6 9
64 4 6 6 6 9
64 3 6 6 6 9
64 2 6 6 6 9
64 6 6 6 7 8
64 5 6 6 6 8
64 4 6 6 6 8
64 3 6 6 6 8
64 2 6 6 6 8
64 5 6 6 6 7
64 4 6 6 6 7
64 3 6 6 6 7
64 2 6 6 6 7
64 4 5 6 6 6
64 3 5 6 6 6
64 2 5 6 6 6
64 3 4 6 6 6
64 2 4 6 6 6
64 2 3 6 6 6
64 5 5 5 K A Three Fives
64 5 5 5 Q A
64 5 5 5 J A
64 5 5 5 T A
64 5 5 5 9 A
64 5 5 5 8 A
64 5 5 5 7 A
64 5 5 5 6 A
64 4 5 5 5 A
64 3 5 5 5 A
64 2 5 5 5 A
64 5 5 5 Q K
64 5 5 5 J K
64 5 5 5 T K
64 5 5 5 9 K
64 5 5 5 8 K
64 5 5 5 7 K
64 5 5 5 6 K
64 4 5 5 5 K
64 3 5 5 5 K
64 2 5 5 5 K
64 5 5 5 J Q
64 5 5 5 T Q
64 5 5 5 9 Q
64 5 5 5 8 Q
64 5 5 5 7 Q
64 5 5 5 6 Q
64 4 5 5 5 Q
64 3 5 5 5 Q
64 2 5 5 5 Q
64 5 5 5 T J
64 5 5 5 9 J
64 5 5 5 8 J
64 5 5 5 7 J
64 5 5 5 6 J
64 4 5 5 5 J
64 3 5 5 5 J
64 2 5 5 5 J
64 5 5 5 9 T
64 5 5 5 8 T
64 5 5 5 7 T
64 5 5 5 6 T
64 4 5 5 5 T
64 3 5 5 5 T
64 2 5 5 5 T
64 5 5 5 8 9
64 5 5 5 7 9
64 5 5 5 6 9
64 4 5 5 5 9
64 3 5 5 5 9
64 2 5 5 5 9
64 5 5 5 7 8
64 5 5 5 6 8
64 4 5 5 5 8
64 3 5 5 5 8
64 2 5 5 5 8
64 5 5 5 6 7
64 4 5 5 5 7
64 3 5 5 5 7
64 2 5 5 5 7
64 4 5 5 5 6
64 3 5 5 5 6
64 2 5 5 5 6
64 3 4 5 5 5
64 2 4 5 5 5
64 2 3 5 5 5
64 4 4 4 K A Three Fours
64 4 4 4 Q A
64 4 4 4 J A
64 4 4 4 T A
64 4 4 4 9 A
64 4 4 4 8 A
64 4 4 4 7 A
64 4 4 4 6 A
64 4 4 4 5 A
64 3 4 4 4 A
64 2 4 4 4 A
64 4 4 4 Q K
64 4 4 4 J K
64 4 4 4 T K
64 4 4 4 9 K
64 4 4 4 8 K
64 4 4 4 7 K
64 4 4 4 6 K
64 4 4 4 5 K
64 3 4 4 4 K
64 2 4 4 4 K
64 4 4 4 J Q
64 4 4 4 T Q
64 4 4 4 9 Q
64 4 4 4 8 Q
64 4 4 4 7 Q
64 4 4 4 6 Q
64 4 4 4 5 Q
64 3 4 4 4 Q
64 2 4 4 4 Q
64 4 4 4 T J
64 4 4 4 9 J
64 4 4 4 8 J
64 4 4 4 7 J
64 4 4 4 6 J
64 4 4 4 5 J
64 3 4 4 4 J
64 2 4 4 4 J
64 4 4 4 9 T
64 4 4 4 8 T
64 4 4 4 7 T
64 4 4 4 6 T
64 4 4 4 5 T
64 3 4 4 4 T
64 2 4 4 4 T
64 4 4 4 8 9
64 4 4 4 7 9
64 4 4 4 6 9
64 4 4 4 5 9
64 3 4 4 4 9
64 2 4 4 4 9
64 4 4 4 7 8
64 4 4 4 6 8
64 4 4 4 5 8
64 3 4 4 4 8
64 2 4 4 4 8
64 4 4 4 6 7
64 4 4 4 5 7
64 3 4 4 4 7
64 2 4 4 4 7
64 4 4 4 5 6
64 3 4 4 4 6
64 2 4 4 4 6
64 3 4 4 4 5
64 2 4 4 4 5
64 2 3 4 4 4
64 3 3 3 K A Three Treys
64 3 3 3 Q A
64 3 3 3 J A
64 3 3 3 T A
64 3 3 3 9 A
64 3 3 3 8 A
64 3 3 3 7 A
64 3 3 3 6 A
64 3 3 3 5 A
64 3 3 3 4 A
64 2 3 3 3 A
64 3 3 3 Q K
64 3 3 3 J K
64 3 3 3 T K
64 3 3 3 9 K
64 3 3 3 8 K
64 3 3 3 7 K
64 3 3 3 6 K
64 3 3 3 5 K
64 3 3 3 4 K
64 2 3 3 3 K
64 3 3 3 J Q
64 3 3 3 T Q
64 3 3 3 9 Q
64 3 3 3 8 Q
64 3 3 3 7 Q
64 3 3 3 6 Q
64 3 3 3 5 Q
64 3 3 3 4 Q
64 2 3 3 3 Q
64 3 3 3 T J
64 3 3 3 9 J
64 3 3 3 8 J
64 3 3 3 7 J
64 3 3 3 6 J
64 3 3 3 5 J
64 3 3 3 4 J
64 2 3 3 3 J
64 3 3 3 9 T
64 3 3 3 8 T
64 3 3 3 7 T
64 3 3 3 6 T
64 3 3 3 5 T
64 3 3 3 4 T
64 2 3 3 3 T
64 3 3 3 8 9
64 3 3 3 7 9
64 3 3 3 6 9
64 3 3 3 5 9
64 3 3 3 4 9
64 2 3 3 3 9
64 3 3 3 7 8
64 3 3 3 6 8
64 3 3 3 5 8
64 3 3 3 4 8
64 2 3 3 3 8
64 3 3 3 6 7
64 3 3 3 5 7
64 3 3 3 4 7
64 2 3 3 3 7
64 3 3 3 5 6
64 3 3 3 4 6
64 2 3 3 3 6
64 3 3 3 4 5
64 2 3 3 3 5
64 2 3 3 3 4
64 2 2 2 K A Three Deuces
64 2 2 2 Q A
64 2 2 2 J A
64 2 2 2 T A
64 2 2 2 9 A
64 2 2 2 8 A
64 2 2 2 7 A
64 2 2 2 6 A
64 2 2 2 5 A
64 2 2 2 4 A
64 2 2 2 3 A
64 2 2 2 Q K
64 2 2 2 J K
64 2 2 2 T K
64 2 2 2 9 K
64 2 2 2 8 K
64 2 2 2 7 K
64 2 2 2 6 K
64 2 2 2 5 K
64 2 2 2 4 K
64 2 2 2 3 K
64 2 2 2 J Q
64 2 2 2 T Q
64 2 2 2 9 Q
64 2 2 2 8 Q
64 2 2 2 7 Q
64 2 2 2 6 Q
64 2 2 2 5 Q
64 2 2 2 4 Q
64 2 2 2 3 Q
64 2 2 2 T J
64 2 2 2 9 J
64 2 2 2 8 J
64 2 2 2 7 J
64 2 2 2 6 J
64 2 2 2 5 J
64 2 2 2 4 J
64 2 2 2 3 J
64 2 2 2 9 T
64 2 2 2 8 T
64 2 2 2 7 T
64 2 2 2 6 T
64 2 2 2 5 T
64 2 2 2 4 T
64 2 2 2 3 T
64 2 2 2 8 9
64 2 2 2 7 9
64 2 2 2 6 9
64 2 2 2 5 9
64 2 2 2 4 9
64 2 2 2 3 9
64 2 2 2 7 8
64 2 2 2 6 8
64 2 2 2 5 8
64 2 2 2 4 8
64 2 2 2 3 8
64 2 2 2 6 7
64 2 2 2 5 7
64 2 2 2 4 7
64 2 2 2 3 7
64 2 2 2 5 6
64 2 2 2 4 6
64 2 2 2 3 6
64 2 2 2 4 5
64 2 2 2 3 5
64 2 2 2 3 4
144 Q K K A A Aces over Kings TWO PAIR
144 J K K A A
144 T K K A A
144 9 K K A A
144 8 K K A A
144 7 K K A A
144 6 K K A A
144 5 K K A A
144 4 K K A A
144 3 K K A A
144 2 K K A A
144 Q Q K A A Aces over Queens
144 J Q Q A A
144 T Q Q A A
144 9 Q Q A A
144 8 Q Q A A
144 7 Q Q A A
144 6 Q Q A A
144 5 Q Q A A
144 4 Q Q A A
144 3 Q Q A A
144 2 Q Q A A
144 J J K A A Aces over Jacks
144 J J Q A A
144 T J J A A
144 9 J J A A
144 8 J J A A
144 7 J J A A
144 6 J J A A
144 5 J J A A
144 4 J J A A
144 3 J J A A
144 2 J J A A
144 T T K A A Aces over Tens
144 T T Q A A
144 T T J A A
144 9 T T A A
144 8 T T A A
144 7 T T A A
144 6 T T A A
144 5 T T A A
144 4 T T A A
144 3 T T A A
144 2 T T A A
144 9 9 K A A Aces over Nines
144 9 9 Q A A
144 9 9 J A A
144 9 9 T A A
144 8 9 9 A A
144 7 9 9 A A
144 6 9 9 A A
144 5 9 9 A A
144 4 9 9 A A
144 3 9 9 A A
144 2 9 9 A A
144 8 8 K A A Aces over Eights
144 8 8 Q A A
144 8 8 J A A
144 8 8 T A A
144 8 8 9 A A
144 7 8 8 A A
144 6 8 8 A A
144 5 8 8 A A
144 4 8 8 A A
144 3 8 8 A A
144 2 8 8 A A
144 7 7 K A A Aces over Sevens
144 7 7 Q A A
144 7 7 J A A
144 7 7 T A A
144 7 7 9 A A
144 7 7 8 A A
144 6 7 7 A A
144 5 7 7 A A
144 4 7 7 A A
144 3 7 7 A A
144 2 7 7 A A
144 6 6 K A A Aces over Sixes
144 6 6 Q A A
144 6 6 J A A
144 6 6 T A A
144 6 6 9 A A
144 6 6 8 A A
144 6 6 7 A A
144 5 6 6 A A
144 4 6 6 A A
144 3 6 6 A A
144 2 6 6 A A
144 5 5 K A A Aces over Fives
144 5 5 Q A A
144 5 5 J A A
144 5 5 T A A
144 5 5 9 A A
144 5 5 8 A A
144 5 5 7 A A
144 5 5 6 A A
144 4 5 5 A A
144 3 5 5 A A
144 2 5 5 A A
144 4 4 K A A Aces over Fours
144 4 4 Q A A
144 4 4 J A A
144 4 4 T A A
144 4 4 9 A A
144 4 4 8 A A
144 4 4 7 A A
144 4 4 6 A A
144 4 4 5 A A
144 3 4 4 A A
144 2 4 4 A A
144 3 3 K A A Aces over Treys
144 3 3 Q A A
144 3 3 J A A
144 3 3 T A A
144 3 3 9 A A
144 3 3 8 A A
144 3 3 7 A A
144 3 3 6 A A
144 3 3 5 A A
144 3 3 4 A A
144 2 3 3 A A
144 2 2 K A A Aces over Deuces
144 2 2 Q A A
144 2 2 J A A
144 2 2 T A A
144 2 2 9 A A
144 2 2 8 A A
144 2 2 7 A A
144 2 2 6 A A
144 2 2 5 A A
144 2 2 4 A A
144 2 2 3 A A
144 Q Q K K A Kings over Queens
144 J Q Q K K
144 T Q Q K K
144 9 Q Q K K
144 8 Q Q K K
144 7 Q Q K K
144 6 Q Q K K
144 5 Q Q K K
144 4 Q Q K K
144 3 Q Q K K
144 2 Q Q K K
144 J J K K A Kings over Jacks
144 J J Q K K
144 T J J K K
144 9 J J K K
144 8 J J K K
144 7 J J K K
144 6 J J K K
144 5 J J K K
144 4 J J K K
144 3 J J K K
144 2 J J K K
144 T T K K A Kings over Tens
144 T T Q K K
144 T T J K K
144 9 T T K K
144 8 T T K K
144 7 T T K K
144 6 T T K K
144 5 T T K K
144 4 T T K K
144 3 T T K K
144 2 T T K K
144 9 9 K K A Kings over Nines
144 9 9 Q K K
144 9 9 J K K
144 9 9 T K K
144 8 9 9 K K
144 7 9 9 K K
144 6 9 9 K K
144 5 9 9 K K
144 4 9 9 K K
144 3 9 9 K K
144 2 9 9 K K
144 8 8 K K A Kings over Eights
144 8 8 Q K K
144 8 8 J K K
144 8 8 T K K
144 8 8 9 K K
144 7 8 8 K K
144 6 8 8 K K
144 5 8 8 K K
144 4 8 8 K K
144 3 8 8 K K
144 2 8 8 K K
144 7 7 K K A Kings over Sevens
144 7 7 Q K K
144 7 7 J K K
144 7 7 T K K
144 7 7 9 K K
144 7 7 8 K K
144 6 7 7 K K
144 5 7 7 K K
144 4 7 7 K K
144 3 7 7 K K
144 2 7 7 K K
144 6 6 K K A Kings over Sixes
144 6 6 Q K K
144 6 6 J K K
144 6 6 T K K
144 6 6 9 K K
144 6 6 8 K K
144 6 6 7 K K
144 5 6 6 K K
144 4 6 6 K K
144 3 6 6 K K
144 2 6 6 K K
144 5 5 K K A Kings over Fives
144 5 5 Q K K
144 5 5 J K K
144 5 5 T K K
144 5 5 9 K K
144 5 5 8 K K
144 5 5 7 K K
144 5 5 6 K K
144 4 5 5 K K
144 3 5 5 K K
144 2 5 5 K K
144 4 4 K K A Kings over Fours
144 4 4 Q K K
144 4 4 J K K
144 4 4 T K K
144 4 4 9 K K
144 4 4 8 K K
144 4 4 7 K K
144 4 4 6 K K
144 4 4 5 K K
144 3 4 4 K K
144 2 4 4 K K
144 3 3 K K A Kings over Treys
144 3 3 Q K K
144 3 3 J K K
144 3 3 T K K
144 3 3 9 K K
144 3 3 8 K K
144 3 3 7 K K
144 3 3 6 K K
144 3 3 5 K K
144 3 3 4 K K
144 2 3 3 K K
144 2 2 K K A Kings over Deuces
144 2 2 Q K K
144 2 2 J K K
144 2 2 T K K
144 2 2 9 K K
144 2 2 8 K K
144 2 2 7 K K
144 2 2 6 K K
144 2 2 5 K K
144 2 2 4 K K
144 2 2 3 K K
144 J J Q Q A Queens over Jacks
144 J J Q Q K
144 T J J Q Q
144 9 J J Q Q
144 8 J J Q Q
144 7 J J Q Q
144 6 J J Q Q
144 5 J J Q Q
144 4 J J Q Q
144 3 J J Q Q
144 2 J J Q Q
144 T T Q Q A Queens over Tens
144 T T Q Q K
144 T T J Q Q
144 9 T T Q Q
144 8 T T Q Q
144 7 T T Q Q
144 6 T T Q Q
144 5 T T Q Q
144 4 T T Q Q
144 3 T T Q Q
144 2 T T Q Q
144 9 9 Q Q A Queens over Nines
144 9 9 Q Q K
144 9 9 J Q Q
144 9 9 T Q Q
144 8 9 9 Q Q
144 7 9 9 Q Q
144 6 9 9 Q Q
144 5 9 9 Q Q
144 4 9 9 Q Q
144 3 9 9 Q Q
144 2 9 9 Q Q
144 8 8 Q Q A Queens over Eights
144 8 8 Q Q K
144 8 8 J Q Q
144 8 8 T Q Q
144 8 8 9 Q Q
144 7 8 8 Q Q
144 6 8 8 Q Q
144 5 8 8 Q Q
144 4 8 8 Q Q
144 3 8 8 Q Q
144 2 8 8 Q Q
144 7 7 Q Q A Queens over Sevens
144 7 7 Q Q K
144 7 7 J Q Q
144 7 7 T Q Q
144 7 7 9 Q Q
144 7 7 8 Q Q
144 6 7 7 Q Q
144 5 7 7 Q Q
144 4 7 7 Q Q
144 3 7 7 Q Q
144 2 7 7 Q Q
144 6 6 Q Q A Queens over Sixes
144 6 6 Q Q K
144 6 6 J Q Q
144 6 6 T Q Q
144 6 6 9 Q Q
144 6 6 8 Q Q
144 6 6 7 Q Q
144 5 6 6 Q Q
144 4 6 6 Q Q
144 3 6 6 Q Q
144 2 6 6 Q Q
144 5 5 Q Q A Queens over Fives
144 5 5 Q Q K
144 5 5 J Q Q
144 5 5 T Q Q
144 5 5 9 Q Q
144 5 5 8 Q Q
144 5 5 7 Q Q
144 5 5 6 Q Q
144 4 5 5 Q Q
144 3 5 5 Q Q
144 2 5 5 Q Q
144 4 4 Q Q A Queens over Fours
144 4 4 Q Q K
144 4 4 J Q Q
144 4 4 T Q Q
144 4 4 9 Q Q
144 4 4 8 Q Q
144 4 4 7 Q Q
144 4 4 6 Q Q
144 4 4 5 Q Q
144 3 4 4 Q Q
144 2 4 4 Q Q
144 3 3 Q Q A Queens over Treys
144 3 3 Q Q K
144 3 3 J Q Q
144 3 3 T Q Q
144 3 3 9 Q Q
144 3 3 8 Q Q
144 3 3 7 Q Q
144 3 3 6 Q Q
144 3 3 5 Q Q
144 3 3 4 Q Q
144 2 3 3 Q Q
144 2 2 Q Q A Queens over Deuces
144 2 2 Q Q K
144 2 2 J Q Q
144 2 2 T Q Q
144 2 2 9 Q Q
144 2 2 8 Q Q
144 2 2 7 Q Q
144 2 2 6 Q Q
144 2 2 5 Q Q
144 2 2 4 Q Q
144 2 2 3 Q Q
144 T T J J A Jacks over Tens
144 T T J J K
144 T T J J Q
144 9 T T J J
144 8 T T J J
144 7 T T J J
144 6 T T J J
144 5 T T J J
144 4 T T J J
144 3 T T J J
144 2 T T J J
144 9 9 J J A Jacks over Nines
144 9 9 J J K
144 9 9 J J Q
144 9 9 T J J
144 8 9 9 J J
144 7 9 9 J J
144 6 9 9 J J
144 5 9 9 J J
144 4 9 9 J J
144 3 9 9 J J
144 2 9 9 J J
144 8 8 J J A Jacks over Eights
144 8 8 J J K
144 8 8 J J Q
144 8 8 T J J
144 8 8 9 J J
144 7 8 8 J J
144 6 8 8 J J
144 5 8 8 J J
144 4 8 8 J J
144 3 8 8 J J
144 2 8 8 J J
144 7 7 J J A Jacks over Sevens
144 7 7 J J K
144 7 7 J J Q
144 7 7 T J J
144 7 7 9 J J
144 7 7 8 J J
144 6 7 7 J J
144 5 7 7 J J
144 4 7 7 J J
144 3 7 7 J J
144 2 7 7 J J
144 6 6 J J A Jacks over Sixes
144 6 6 J J K
144 6 6 J J Q
144 6 6 T J J
144 6 6 9 J J
144 6 6 8 J J
144 6 6 7 J J
144 5 6 6 J J
144 4 6 6 J J
144 3 6 6 J J
144 2 6 6 J J
144 5 5 J J A Jacks over Fives
144 5 5 J J K
144 5 5 J J Q
144 5 5 T J J
144 5 5 9 J J
144 5 5 8 J J
144 5 5 7 J J
144 5 5 6 J J
144 4 5 5 J J
144 3 5 5 J J
144 2 5 5 J J
144 4 4 J J A Jacks over Fours
144 4 4 J J K
144 4 4 J J Q
144 4 4 T J J
144 4 4 9 J J
144 4 4 8 J J
144 4 4 7 J J
144 4 4 6 J J
144 4 4 5 J J
144 3 4 4 J J
144 2 4 4 J J
144 3 3 J J A Jacks over Treys
144 3 3 J J K
144 3 3 J J Q
144 3 3 T J J
144 3 3 9 J J
144 3 3 8 J J
144 3 3 7 J J
144 3 3 6 J J
144 3 3 5 J J
144 3 3 4 J J
144 2 3 3 J J
144 2 2 J J A Jacks over Deuces
144 2 2 J J K
144 2 2 J J Q
144 2 2 T J J
144 2 2 9 J J
144 2 2 8 J J
144 2 2 7 J J
144 2 2 6 J J
144 2 2 5 J J
144 2 2 4 J J
144 2 2 3 J J
144 9 9 T T A Tens over Nines
144 9 9 T T K
144 9 9 T T Q
144 9 9 T T J
144 8 9 9 T T
144 7 9 9 T T
144 6 9 9 T T
144 5 9 9 T T
144 4 9 9 T T
144 3 9 9 T T
144 2 9 9 T T
144 8 8 T T A Tens over Eights
144 8 8 T T K
144 8 8 T T Q
144 8 8 T T J
144 8 8 9 T T
144 7 8 8 T T
144 6 8 8 T T
144 5 8 8 T T
144 4 8 8 T T
144 3 8 8 T T
144 2 8 8 T T
144 7 7 T T A Tens over Sevens
144 7 7 T T K
144 7 7 T T Q
144 7 7 T T J
144 7 7 9 T T
144 7 7 8 T T
144 6 7 7 T T
144 5 7 7 T T
144 4 7 7 T T
144 3 7 7 T T
144 2 7 7 T T
144 6 6 T T A Tens over Sixes
144 6 6 T T K
144 6 6 T T Q
144 6 6 T T J
144 6 6 9 T T
144 6 6 8 T T
144 6 6 7 T T
144 5 6 6 T T
144 4 6 6 T T
144 3 6 6 T T
144 2 6 6 T T
144 5 5 T T A Tens over Fives
144 5 5 T T K
144 5 5 T T Q
144 5 5 T T J
144 5 5 9 T T
144 5 5 8 T T
144 5 5 7 T T
144 5 5 6 T T
144 4 5 5 T T
144 3 5 5 T T
144 2 5 5 T T
144 4 4 T T A Tens over Fours
144 4 4 T T K
144 4 4 T T Q
144 4 4 T T J
144 4 4 9 T T
144 4 4 8 T T
144 4 4 7 T T
144 4 4 6 T T
144 4 4 5 T T
144 3 4 4 T T
144 2 4 4 T T
144 3 3 T T A Tens over Treys
144 3 3 T T K
144 3 3 T T Q
144 3 3 T T J
144 3 3 9 T T
144 3 3 8 T T
144 3 3 7 T T
144 3 3 6 T T
144 3 3 5 T T
144 3 3 4 T T
144 2 3 3 T T
144 2 2 T T A Tens over Deuces
144 2 2 T T K
144 2 2 T T Q
144 2 2 T T J
144 2 2 9 T T
144 2 2 8 T T
144 2 2 7 T T
144 2 2 6 T T
144 2 2 5 T T
144 2 2 4 T T
144 2 2 3 T T
144 8 8 9 9 A Nines over Eights
144 8 8 9 9 K
144 8 8 9 9 Q
144 8 8 9 9 J
144 8 8 9 9 T
144 7 8 8 9 9
144 6 8 8 9 9
144 5 8 8 9 9
144 4 8 8 9 9
144 3 8 8 9 9
144 2 8 8 9 9
144 7 7 9 9 A Nines over Sevens
144 7 7 9 9 K
144 7 7 9 9 Q
144 7 7 9 9 J
144 7 7 9 9 T
144 7 7 8 9 9
144 6 7 7 9 9
144 5 7 7 9 9
144 4 7 7 9 9
144 3 7 7 9 9
144 2 7 7 9 9
144 6 6 9 9 A Nines over Sixes
144 6 6 9 9 K
144 6 6 9 9 Q
144 6 6 9 9 J
144 6 6 9 9 T
144 6 6 8 9 9
144 6 6 7 9 9
144 5 6 6 9 9
144 4 6 6 9 9
144 3 6 6 9 9
144 2 6 6 9 9
144 5 5 9 9 A Nines over Fives
144 5 5 9 9 K
144 5 5 9 9 Q
144 5 5 9 9 J
144 5 5 9 9 T
144 5 5 8 9 9
144 5 5 7 9 9
144 5 5 6 9 9
144 4 5 5 9 9
144 3 5 5 9 9
144 2 5 5 9 9
144 4 4 9 9 A Nines over Fours
144 4 4 9 9 K
144 4 4 9 9 Q
144 4 4 9 9 J
144 4 4 9 9 T
144 4 4 8 9 9
144 4 4 7 9 9
144 4 4 6 9 9
144 4 4 5 9 9
144 3 4 4 9 9
144 2 4 4 9 9
144 3 3 9 9 A Nines over Treys
144 3 3 9 9 K
144 3 3 9 9 Q
144 3 3 9 9 J
144 3 3 9 9 T
144 3 3 8 9 9
144 3 3 7 9 9
144 3 3 6 9 9
144 3 3 5 9 9
144 3 3 4 9 9
144 2 3 3 9 9
144 2 2 9 9 A Nines over Deuces
144 2 2 9 9 K
144 2 2 9 9 Q
144 2 2 9 9 J
144 2 2 9 9 T
144 2 2 8 9 9
144 2 2 7 9 9
144 2 2 6 9 9
144 2 2 5 9 9
144 2 2 4 9 9
144 2 2 3 9 9
144 7 7 8 8 A Eights over Sevens
144 7 7 8 8 K
144 7 7 8 8 Q
144 7 7 8 8 J
144 7 7 8 8 T
144 7 7 8 8 9
144 6 7 7 8 8
144 5 7 7 8 8
144 4 7 7 8 8
144 3 7 7 8 8
144 2 7 7 8 8
144 6 6 8 8 A Eights over Sixes
144 6 6 8 8 K
144 6 6 8 8 Q
144 6 6 8 8 J
144 6 6 8 8 T
144 6 6 8 8 9
144 6 6 7 8 8
144 5 6 6 8 8
144 4 6 6 8 8
144 3 6 6 8 8
144 2 6 6 8 8
144 5 5 8 8 A Eights over Fives
144 5 5 8 8 K
144 5 5 8 8 Q
144 5 5 8 8 J
144 5 5 8 8 T
144 5 5 8 8 9
144 5 5 7 8 8
144 5 5 6 8 8
144 4 5 5 8 8
144 3 5 5 8 8
144 2 5 5 8 8
144 4 4 8 8 A Eights over Fours
144 4 4 8 8 K
144 4 4 8 8 Q
144 4 4 8 8 J
144 4 4 8 8 T
144 4 4 8 8 9
144 4 4 7 8 8
144 4 4 6 8 8
144 4 4 5 8 8
144 3 4 4 8 8
144 2 4 4 8 8
144 3 3 8 8 A Eights over Treys
144 3 3 8 8 K
144 3 3 8 8 Q
144 3 3 8 8 J
144 3 3 8 8 T
144 3 3 8 8 9
144 3 3 7 8 8
144 3 3 6 8 8
144 3 3 5 8 8
144 3 3 4 8 8
144 2 3 3 8 8
144 2 2 8 8 A Eights over Deuces
144 2 2 8 8 K
144 2 2 8 8 Q
144 2 2 8 8 J
144 2 2 8 8 T
144 2 2 8 8 9
144 2 2 7 8 8
144 2 2 6 8 8
144 2 2 5 8 8
144 2 2 4 8 8
144 2 2 3 8 8
144 6 6 7 7 A Sevens over Sixes
144 6 6 7 7 K
144 6 6 7 7 Q
144 6 6 7 7 J
144 6 6 7 7 T
144 6 6 7 7 9
144 6 6 7 7 8
144 5 6 6 7 7
144 4 6 6 7 7
144 3 6 6 7 7
144 2 6 6 7 7
144 5 5 7 7 A Sevens over Fives
144 5 5 7 7 K
144 5 5 7 7 Q
144 5 5 7 7 J
144 5 5 7 7 T
144 5 5 7 7 9
144 5 5 7 7 8
144 5 5 6 7 7
144 4 5 5 7 7
144 3 5 5 7 7
144 2 5 5 7 7
144 4 4 7 7 A Sevens over Fours
144 4 4 7 7 K
144 4 4 7 7 Q
144 4 4 7 7 J
144 4 4 7 7 T
144 4 4 7 7 9
144 4 4 7 7 8
144 4 4 6 7 7
144 4 4 5 7 7
144 3 4 4 7 7
144 2 4 4 7 7
144 3 3 7 7 A Sevens over Treys
144 3 3 7 7 K
144 3 3 7 7 Q
144 3 3 7 7 J
144 3 3 7 7 T
144 3 3 7 7 9
144 3 3 7 7 8
144 3 3 6 7 7
144 3 3 5 7 7
144 3 3 4 7 7
144 2 3 3 7 7
144 2 2 7 7 A Sevens over Deuces
144 2 2 7 7 K
144 2 2 7 7 Q
144 2 2 7 7 J
144 2 2 7 7 T
144 2 2 7 7 9
144 2 2 7 7 8
144 2 2 6 7 7
144 2 2 5 7 7
144 2 2 4 7 7
144 2 2 3 7 7
144 5 5 6 6 A Sixes over Fives
144 5 5 6 6 K
144 5 5 6 6 Q
144 5 5 6 6 J
144 5 5 6 6 T
144 5 5 6 6 9
144 5 5 6 6 8
144 5 5 6 6 7
144 4 5 5 6 6
144 3 5 5 6 6
144 2 5 5 6 6
144 4 4 6 6 A Sixes over Fours
144 4 4 6 6 K
144 4 4 6 6 Q
144 4 4 6 6 J
144 4 4 6 6 T
144 4 4 6 6 9
144 4 4 6 6 8
144 4 4 6 6 7
144 4 4 5 6 6
144 3 4 4 6 6
144 2 4 4 6 6
144 3 3 6 6 A Sixes over Treys
144 3 3 6 6 K
144 3 3 6 6 Q
144 3 3 6 6 J
144 3 3 6 6 T
144 3 3 6 6 9
144 3 3 6 6 8
144 3 3 6 6 7
144 3 3 5 6 6
144 3 3 4 6 6
144 2 3 3 6 6
144 2 2 6 6 A Sixes over Deuces
144 2 2 6 6 K
144 2 2 6 6 Q
144 2 2 6 6 J
144 2 2 6 6 T
144 2 2 6 6 9
144 2 2 6 6 8
144 2 2 6 6 7
144 2 2 5 6 6
144 2 2 4 6 6
144 2 2 3 6 6
144 4 4 5 5 A Fives over Fours
144 4 4 5 5 K
144 4 4 5 5 Q
144 4 4 5 5 J
144 4 4 5 5 T
144 4 4 5 5 9
144 4 4 5 5 8
144 4 4 5 5 7
144 4 4 5 5 6
144 3 4 4 5 5
144 2 4 4 5 5
144 3 3 5 5 A Fives over Treys
144 3 3 5 5 K
144 3 3 5 5 Q
144 3 3 5 5 J
144 3 3 5 5 T
144 3 3 5 5 9
144 3 3 5 5 8
144 3 3 5 5 7
144 3 3 5 5 6
144 3 3 4 5 5
144 2 3 3 5 5
144 2 2 5 5 A Fives over Deuces
144 2 2 5 5 K
144 2 2 5 5 Q
144 2 2 5 5 J
144 2 2 5 5 T
144 2 2 5 5 9
144 2 2 5 5 8
144 2 2 5 5 7
144 2 2 5 5 6
144 2 2 4 5 5
144 2 2 3 5 5
144 3 3 4 4 A Fours over Treys
144 3 3 4 4 K
144 3 3 4 4 Q
144 3 3 4 4 J
144 3 3 4 4 T
144 3 3 4 4 9
144 3 3 4 4 8
144 3 3 4 4 7
144 3 3 4 4 6
144 3 3 4 4 5
144 3 3 4 4 2
144 2 2 4 4 A Fours over Deuces
144 2 2 4 4 K
144 2 2 4 4 Q
144 2 2 4 4 J
144 2 2 4 4 T
144 2 2 4 4 9
144 2 2 4 4 8
144 2 2 4 4 7
144 2 2 4 4 6
144 2 2 4 4 5
144 2 2 4 4 3
144 2 2 3 3 A Treys over Deuces
144 2 2 3 3 K
144 2 2 3 3 Q
144 2 2 3 3 J
144 2 2 3 3 T
144 2 2 3 3 9
144 2 2 3 3 8
144 2 2 3 3 7
144 2 2 3 3 6
144 2 2 3 3 5
144 2 2 3 3 4
384 J Q K A A Pair of Aces ONE PAIR
384 T Q K A A
384 9 Q K A A
384 8 Q K A A
384 7 Q K A A
384 6 Q K A A
384 5 Q K A A
384 4 Q K A A
384 3 Q K A A
384 2 Q K A A
384 T J K A A
384 9 J K A A
384 8 J K A A
384 7 J K A A
384 6 J K A A
384 5 J K A A
384 4 J K A A
384 3 J K A A
384 2 J K A A
384 9 T K A A
384 8 T K A A
384 7 T K A A
384 6 T K A A
384 5 T K A A
384 4 T K A A
384 3 T K A A
384 2 T K A A
384 8 9 K A A
384 7 9 K A A
384 6 9 K A A
384 5 9 K A A
384 4 9 K A A
384 3 9 K A A
384 2 9 K A A
384 7 8 K A A
384 6 8 K A A
384 5 8 K A A
384 4 8 K A A
384 3 8 K A A
384 2 8 K A A
384 6 7 K A A
384 5 7 K A A
384 4 7 K A A
384 3 7 K A A
384 2 7 K A A
384 5 6 K A A
384 4 6 K A A
384 3 6 K A A
384 2 6 K A A
384 4 5 K A A
384 3 5 K A A
384 2 5 K A A
384 3 4 K A A
384 2 4 K A A
384 2 3 K A A
384 T J Q A A
384 9 J Q A A
384 8 J Q A A
384 7 J Q A A
384 6 J Q A A
384 5 J Q A A
384 4 J Q A A
384 3 J Q A A
384 2 J Q A A
384 9 T Q A A
384 8 T Q A A
384 7 T Q A A
384 6 T Q A A
384 5 T Q A A
384 4 T Q A A
384 3 T Q A A
384 2 T Q A A
384 8 9 Q A A
384 7 9 Q A A
384 6 9 Q A A
384 5 9 Q A A
384 4 9 Q A A
384 3 9 Q A A
384 2 9 Q A A
384 7 8 Q A A
384 6 8 Q A A
384 5 8 Q A A
384 4 8 Q A A
384 3 8 Q A A
384 2 8 Q A A
384 6 7 Q A A
384 5 7 Q A A
384 4 7 Q A A
384 3 7 Q A A
384 2 7 Q A A
384 5 6 Q A A
384 4 6 Q A A
384 3 6 Q A A
384 2 6 Q A A
384 4 5 Q A A
384 3 5 Q A A
384 2 5 Q A A
384 3 4 Q A A
384 2 4 Q A A
384 2 3 Q A A
384 9 T J A A
384 8 T J A A
384 7 T J A A
384 6 T J A A
384 5 T J A A
384 4 T J A A
384 3 T J A A
384 2 T J A A
384 8 9 J A A
384 7 9 J A A
384 6 9 J A A
384 5 9 J A A
384 4 9 J A A
384 3 9 J A A
384 2 9 J A A
384 7 8 J A A
384 6 8 J A A
384 5 8 J A A
384 4 8 J A A
384 3 8 J A A
384 2 8 J A A
384 6 7 J A A
384 5 7 J A A
384 4 7 J A A
384 3 7 J A A
384 2 7 J A A
384 5 6 J A A
384 4 6 J A A
384 3 6 J A A
384 2 6 J A A
384 4 5 J A A
384 3 5 J A A
384 2 5 J A A
384 3 4 J A A
384 2 4 J A A
384 2 3 J A A
384 8 9 T A A
384 7 9 T A A
384 6 9 T A A
384 5 9 T A A
384 4 9 T A A
384 3 9 T A A
384 2 9 T A A
384 7 8 T A A
384 6 8 T A A
384 5 8 T A A
384 4 8 T A A
384 3 8 T A A
384 2 8 T A A
384 6 7 T A A
384 5 7 T A A
384 4 7 T A A
384 3 7 T A A
384 2 7 T A A
384 5 6 T A A
384 4 6 T A A
384 3 6 T A A
384 2 6 T A A
384 4 5 T A A
384 3 5 T A A
384 2 5 T A A
384 3 4 T A A
384 2 4 T A A
384 2 3 T A A
384 7 8 9 A A
384 6 8 9 A A
384 5 8 9 A A
384 4 8 9 A A
384 3 8 9 A A
384 2 8 9 A A
384 6 7 9 A A
384 5 7 9 A A
384 4 7 9 A A
384 3 7 9 A A
384 2 7 9 A A
384 5 6 9 A A
384 4 6 9 A A
384 3 6 9 A A
384 2 6 9 A A
384 4 5 9 A A
384 3 5 9 A A
384 2 5 9 A A
384 3 4 9 A A
384 2 4 9 A A
384 2 3 9 A A
384 6 7 8 A A
384 5 7 8 A A
384 4 7 8 A A
384 3 7 8 A A
384 2 7 8 A A
384 5 6 8 A A
384 4 6 8 A A
384 3 6 8 A A
384 2 6 8 A A
384 4 5 8 A A
384 3 5 8 A A
384 2 5 8 A A
384 3 4 8 A A
384 2 4 8 A A
384 2 3 8 A A
384 5 6 7 A A
384 4 6 7 A A
384 3 6 7 A A
384 2 6 7 A A
384 4 5 7 A A
384 3 5 7 A A
384 2 5 7 A A
384 3 4 7 A A
384 2 4 7 A A
384 2 3 7 A A
384 4 5 6 A A
384 3 5 6 A A
384 2 5 6 A A
384 3 4 6 A A
384 2 4 6 A A
384 2 3 6 A A
384 3 4 5 A A
384 2 4 5 A A
384 2 3 5 A A
384 2 3 4 A A
384 J Q K K A Pair of Kings
384 T Q K K A
384 9 Q K K A
384 8 Q K K A
384 7 Q K K A
384 6 Q K K A
384 5 Q K K A
384 4 Q K K A
384 3 Q K K A
384 2 Q K K A
384 T J K K A
384 9 J K K A
384 8 J K K A
384 7 J K K A
384 6 J K K A
384 5 J K K A
384 4 J K K A
384 3 J K K A
384 2 J K K A
384 9 T K K A
384 8 T K K A
384 7 T K K A
384 6 T K K A
384 5 T K K A
384 4 T K K A
384 3 T K K A
384 2 T K K A
384 8 9 K K A
384 7 9 K K A
384 6 9 K K A
384 5 9 K K A
384 4 9 K K A
384 3 9 K K A
384 2 9 K K A
384 7 8 K K A
384 6 8 K K A
384 5 8 K K A
384 4 8 K K A
384 3 8 K K A
384 2 8 K K A
384 6 7 K K A
384 5 7 K K A
384 4 7 K K A
384 3 7 K K A
384 2 7 K K A
384 5 6 K K A
384 4 6 K K A
384 3 6 K K A
384 2 6 K K A
384 4 5 K K A
384 3 5 K K A
384 2 5 K K A
384 3 4 K K A
384 2 4 K K A
384 2 3 K K A
384 T J Q K K
384 9 J Q K K
384 8 J Q K K
384 7 J Q K K
384 6 J Q K K
384 5 J Q K K
384 4 J Q K K
384 3 J Q K K
384 2 J Q K K
384 9 T Q K K
384 8 T Q K K
384 7 T Q K K
384 6 T Q K K
384 5 T Q K K
384 4 T Q K K
384 3 T Q K K
384 2 T Q K K
384 8 9 Q K K
384 7 9 Q K K
384 6 9 Q K K
384 5 9 Q K K
384 4 9 Q K K
384 3 9 Q K K
384 2 9 Q K K
384 7 8 Q K K
384 6 8 Q K K
384 5 8 Q K K
384 4 8 Q K K
384 3 8 Q K K
384 2 8 Q K K
384 6 7 Q K K
384 5 7 Q K K
384 4 7 Q K K
384 3 7 Q K K
384 2 7 Q K K
384 5 6 Q K K
384 4 6 Q K K
384 3 6 Q K K
384 2 6 Q K K
384 4 5 Q K K
384 3 5 Q K K
384 2 5 Q K K
384 3 4 Q K K
384 2 4 Q K K
384 2 3 Q K K
384 9 T J K K
384 8 T J K K
384 7 T J K K
384 6 T J K K
384 5 T J K K
384 4 T J K K
384 3 T J K K
384 2 T J K K
384 8 9 J K K
384 7 9 J K K
384 6 9 J K K
384 5 9 J K K
384 4 9 J K K
384 3 9 J K K
384 2 9 J K K
384 7 8 J K K
384 6 8 J K K
384 5 8 J K K
384 4 8 J K K
384 3 8 J K K
384 2 8 J K K
384 6 7 J K K
384 5 7 J K K
384 4 7 J K K
384 3 7 J K K
384 2 7 J K K
384 5 6 J K K
384 4 6 J K K
384 3 6 J K K
384 2 6 J K K
384 4 5 J K K
384 3 5 J K K
384 2 5 J K K
384 3 4 J K K
384 2 4 J K K
384 2 3 J K K
384 8 9 T K K
384 7 9 T K K
384 6 9 T K K
384 5 9 T K K
384 4 9 T K K
384 3 9 T K K
384 2 9 T K K
384 7 8 T K K
384 6 8 T K K
384 5 8 T K K
384 4 8 T K K
384 3 8 T K K
384 2 8 T K K
384 6 7 T K K
384 5 7 T K K
384 4 7 T K K
384 3 7 T K K
384 2 7 T K K
384 5 6 T K K
384 4 6 T K K
384 3 6 T K K
384 2 6 T K K
384 4 5 T K K
384 3 5 T K K
384 2 5 T K K
384 3 4 T K K
384 2 4 T K K
384 2 3 T K K
384 7 8 9 K K
384 6 8 9 K K
384 5 8 9 K K
384 4 8 9 K K
384 3 8 9 K K
384 2 8 9 K K
384 6 7 9 K K
384 5 7 9 K K
384 4 7 9 K K
384 3 7 9 K K
384 2 7 9 K K
384 5 6 9 K K
384 4 6 9 K K
384 3 6 9 K K
384 2 6 9 K K
384 4 5 9 K K
384 3 5 9 K K
384 2 5 9 K K
384 3 4 9 K K
384 2 4 9 K K
384 2 3 9 K K
384 6 7 8 K K
384 5 7 8 K K
384 4 7 8 K K
384 3 7 8 K K
384 2 7 8 K K
384 5 6 8 K K
384 4 6 8 K K
384 3 6 8 K K
384 2 6 8 K K
384 4 5 8 K K
384 3 5 8 K K
384 2 5 8 K K
384 3 4 8 K K
384 2 4 8 K K
384 2 3 8 K K
384 5 6 7 K K
384 4 6 7 K K
384 3 6 7 K K
384 2 6 7 K K
384 4 5 7 K K
384 3 5 7 K K
384 2 5 7 K K
384 3 4 7 K K
384 2 4 7 K K
384 2 3 7 K K
384 4 5 6 K K
384 3 5 6 K K
384 2 5 6 K K
384 3 4 6 K K
384 2 4 6 K K
384 2 3 6 K K
384 3 4 5 K K
384 2 4 5 K K
384 2 3 5 K K
384 2 3 4 K K
384 J Q Q K A Pair of Queens
384 T Q Q K A
384 9 Q Q K A
384 8 Q Q K A
384 7 Q Q K A
384 6 Q Q K A
384 5 Q Q K A
384 4 Q Q K A
384 3 Q Q K A
384 2 Q Q K A
384 T J Q Q A
384 9 J Q Q A
384 8 J Q Q A
384 7 J Q Q A
384 6 J Q Q A
384 5 J Q Q A
384 4 J Q Q A
384 3 J Q Q A
384 2 J Q Q A
384 9 T Q Q A
384 8 T Q Q A
384 7 T Q Q A
384 6 T Q Q A
384 5 T Q Q A
384 4 T Q Q A
384 3 T Q Q A
384 2 T Q Q A
384 8 9 Q Q A
384 7 9 Q Q A
384 6 9 Q Q A
384 5 9 Q Q A
384 4 9 Q Q A
384 3 9 Q Q A
384 2 9 Q Q A
384 7 8 Q Q A
384 6 8 Q Q A
384 5 8 Q Q A
384 4 8 Q Q A
384 3 8 Q Q A
384 2 8 Q Q A
384 6 7 Q Q A
384 5 7 Q Q A
384 4 7 Q Q A
384 3 7 Q Q A
384 2 7 Q Q A
384 5 6 Q Q A
384 4 6 Q Q A
384 3 6 Q Q A
384 2 6 Q Q A
384 4 5 Q Q A
384 3 5 Q Q A
384 2 5 Q Q A
384 3 4 Q Q A
384 2 4 Q Q A
384 2 3 Q Q A
384 T J Q Q K
384 9 J Q Q K
384 8 J Q Q K
384 7 J Q Q K
384 6 J Q Q K
384 5 J Q Q K
384 4 J Q Q K
384 3 J Q Q K
384 2 J Q Q K
384 9 T Q Q K
384 8 T Q Q K
384 7 T Q Q K
384 6 T Q Q K
384 5 T Q Q K
384 4 T Q Q K
384 3 T Q Q K
384 2 T Q Q K
384 8 9 Q Q K
384 7 9 Q Q K
384 6 9 Q Q K
384 5 9 Q Q K
384 4 9 Q Q K
384 3 9 Q Q K
384 2 9 Q Q K
384 7 8 Q Q K
384 6 8 Q Q K
384 5 8 Q Q K
384 4 8 Q Q K
384 3 8 Q Q K
384 2 8 Q Q K
384 6 7 Q Q K
384 5 7 Q Q K
384 4 7 Q Q K
384 3 7 Q Q K
384 2 7 Q Q K
384 5 6 Q Q K
384 4 6 Q Q K
384 3 6 Q Q K
384 2 6 Q Q K
384 4 5 Q Q K
384 3 5 Q Q K
384 2 5 Q Q K
384 3 4 Q Q K
384 2 4 Q Q K
384 2 3 Q Q K
384 9 T J Q Q
384 8 T J Q Q
384 7 T J Q Q
384 6 T J Q Q
384 5 T J Q Q
384 4 T J Q Q
384 3 T J Q Q
384 2 T J Q Q
384 8 9 J Q Q
384 7 9 J Q Q
384 6 9 J Q Q
384 5 9 J Q Q
384 4 9 J Q Q
384 3 9 J Q Q
384 2 9 J Q Q
384 7 8 J Q Q
384 6 8 J Q Q
384 5 8 J Q Q
384 4 8 J Q Q
384 3 8 J Q Q
384 2 8 J Q Q
384 6 7 J Q Q
384 5 7 J Q Q
384 4 7 J Q Q
384 3 7 J Q Q
384 2 7 J Q Q
384 5 6 J Q Q
384 4 6 J Q Q
384 3 6 J Q Q
384 2 6 J Q Q
384 4 5 J Q Q
384 3 5 J Q Q
384 2 5 J Q Q
384 3 4 J Q Q
384 2 4 J Q Q
384 2 3 J Q Q
384 8 9 T Q Q
384 7 9 T Q Q
384 6 9 T Q Q
384 5 9 T Q Q
384 4 9 T Q Q
384 3 9 T Q Q
384 2 9 T Q Q
384 7 8 T Q Q
384 6 8 T Q Q
384 5 8 T Q Q
384 4 8 T Q Q
384 3 8 T Q Q
384 2 8 T Q Q
384 6 7 T Q Q
384 5 7 T Q Q
384 4 7 T Q Q
384 3 7 T Q Q
384 2 7 T Q Q
384 5 6 T Q Q
384 4 6 T Q Q
384 3 6 T Q Q
384 2 6 T Q Q
384 4 5 T Q Q
384 3 5 T Q Q
384 2 5 T Q Q
384 3 4 T Q Q
384 2 4 T Q Q
384 2 3 T Q Q
384 7 8 9 Q Q
384 6 8 9 Q Q
384 5 8 9 Q Q
384 4 8 9 Q Q
384 3 8 9 Q Q
384 2 8 9 Q Q
384 6 7 9 Q Q
384 5 7 9 Q Q
384 4 7 9 Q Q
384 3 7 9 Q Q
384 2 7 9 Q Q
384 5 6 9 Q Q
384 4 6 9 Q Q
384 3 6 9 Q Q
384 2 6 9 Q Q
384 4 5 9 Q Q
384 3 5 9 Q Q
384 2 5 9 Q Q
384 3 4 9 Q Q
384 2 4 9 Q Q
384 2 3 9 Q Q
384 6 7 8 Q Q
384 5 7 8 Q Q
384 4 7 8 Q Q
384 3 7 8 Q Q
384 2 7 8 Q Q
384 5 6 8 Q Q
384 4 6 8 Q Q
384 3 6 8 Q Q
384 2 6 8 Q Q
384 4 5 8 Q Q
384 3 5 8 Q Q
384 2 5 8 Q Q
384 3 4 8 Q Q
384 2 4 8 Q Q
384 2 3 8 Q Q
384 5 6 7 Q Q
384 4 6 7 Q Q
384 3 6 7 Q Q
384 2 6 7 Q Q
384 4 5 7 Q Q
384 3 5 7 Q Q
384 2 5 7 Q Q
384 3 4 7 Q Q
384 2 4 7 Q Q
384 2 3 7 Q Q
384 4 5 6 Q Q
384 3 5 6 Q Q
384 2 5 6 Q Q
384 3 4 6 Q Q
384 2 4 6 Q Q
384 2 3 6 Q Q
384 3 4 5 Q Q
384 2 4 5 Q Q
384 2 3 5 Q Q
384 2 3 4 Q Q
384 J J Q K A Pair of Jacks
384 T J J K A
384 9 J J K A
384 8 J J K A
384 7 J J K A
384 6 J J K A
384 5 J J K A
384 4 J J K A
384 3 J J K A
384 2 J J K A
384 T J J Q A
384 9 J J Q A
384 8 J J Q A
384 7 J J Q A
384 6 J J Q A
384 5 J J Q A
384 4 J J Q A
384 3 J J Q A
384 2 J J Q A
384 9 T J J A
384 8 T J J A
384 7 T J J A
384 6 T J J A
384 5 T J J A
384 4 T J J A
384 3 T J J A
384 2 T J J A
384 8 9 J J A
384 7 9 J J A
384 6 9 J J A
384 5 9 J J A
384 4 9 J J A
384 3 9 J J A
384 2 9 J J A
384 7 8 J J A
384 6 8 J J A
384 5 8 J J A
384 4 8 J J A
384 3 8 J J A
384 2 8 J J A
384 6 7 J J A
384 5 7 J J A
384 4 7 J J A
384 3 7 J J A
384 2 7 J J A
384 5 6 J J A
384 4 6 J J A
384 3 6 J J A
384 2 6 J J A
384 4 5 J J A
384 3 5 J J A
384 2 5 J J A
384 3 4 J J A
384 2 4 J J A
384 2 3 J J A
384 T J J Q K
384 9 J J Q K
384 8 J J Q K
384 7 J J Q K
384 6 J J Q K
384 5 J J Q K
384 4 J J Q K
384 3 J J Q K
384 2 J J Q K
384 9 T J J K
384 8 T J J K
384 7 T J J K
384 6 T J J K
384 5 T J J K
384 4 T J J K
384 3 T J J K
384 2 T J J K
384 8 9 J J K
384 7 9 J J K
384 6 9 J J K
384 5 9 J J K
384 4 9 J J K
384 3 9 J J K
384 2 9 J J K
384 7 8 J J K
384 6 8 J J K
384 5 8 J J K
384 4 8 J J K
384 3 8 J J K
384 2 8 J J K
384 6 7 J J K
384 5 7 J J K
384 4 7 J J K
384 3 7 J J K
384 2 7 J J K
384 5 6 J J K
384 4 6 J J K
384 3 6 J J K
384 2 6 J J K
384 4 5 J J K
384 3 5 J J K
384 2 5 J J K
384 3 4 J J K
384 2 4 J J K
384 2 3 J J K
384 9 T J J Q
384 8 T J J Q
384 7 T J J Q
384 6 T J J Q
384 5 T J J Q
384 4 T J J Q
384 3 T J J Q
384 2 T J J Q
384 8 9 J J Q
384 7 9 J J Q
384 6 9 J J Q
384 5 9 J J Q
384 4 9 J J Q
384 3 9 J J Q
384 2 9 J J Q
384 7 8 J J Q
384 6 8 J J Q
384 5 8 J J Q
384 4 8 J J Q
384 3 8 J J Q
384 2 8 J J Q
384 6 7 J J Q
384 5 7 J J Q
384 4 7 J J Q
384 3 7 J J Q
384 2 7 J J Q
384 5 6 J J Q
384 4 6 J J Q
384 3 6 J J Q
384 2 6 J J Q
384 4 5 J J Q
384 3 5 J J Q
384 2 5 J J Q
384 3 4 J J Q
384 2 4 J J Q
384 2 3 J J Q
384 8 9 T J J
384 7 9 T J J
384 6 9 T J J
384 5 9 T J J
384 4 9 T J J
384 3 9 T J J
384 2 9 T J J
384 7 8 T J J
384 6 8 T J J
384 5 8 T J J
384 4 8 T J J
384 3 8 T J J
384 2 8 T J J
384 6 7 T J J
384 5 7 T J J
384 4 7 T J J
384 3 7 T J J
384 2 7 T J J
384 5 6 T J J
384 4 6 T J J
384 3 6 T J J
384 2 6 T J J
384 4 5 T J J
384 3 5 T J J
384 2 5 T J J
384 3 4 T J J
384 2 4 T J J
384 2 3 T J J
384 7 8 9 J J
384 6 8 9 J J
384 5 8 9 J J
384 4 8 9 J J
384 3 8 9 J J
384 2 8 9 J J
384 6 7 9 J J
384 5 7 9 J J
384 4 7 9 J J
384 3 7 9 J J
384 2 7 9 J J
384 5 6 9 J J
384 4 6 9 J J
384 3 6 9 J J
384 2 6 9 J J
384 4 5 9 J J
384 3 5 9 J J
384 2 5 9 J J
384 3 4 9 J J
384 2 4 9 J J
384 2 3 9 J J
384 6 7 8 J J
384 5 7 8 J J
384 4 7 8 J J
384 3 7 8 J J
384 2 7 8 J J
384 5 6 8 J J
384 4 6 8 J J
384 3 6 8 J J
384 2 6 8 J J
384 4 5 8 J J
384 3 5 8 J J
384 2 5 8 J J
384 3 4 8 J J
384 2 4 8 J J
384 2 3 8 J J
384 5 6 7 J J
384 4 6 7 J J
384 3 6 7 J J
384 2 6 7 J J
384 4 5 7 J J
384 3 5 7 J J
384 2 5 7 J J
384 3 4 7 J J
384 2 4 7 J J
384 2 3 7 J J
384 4 5 6 J J
384 3 5 6 J J
384 2 5 6 J J
384 3 4 6 J J
384 2 4 6 J J
384 2 3 6 J J
384 3 4 5 J J
384 2 4 5 J J
384 2 3 5 J J
384 2 3 4 J J
384 T T Q K A Pair of Tens
384 T T J K A
384 9 T T K A
384 8 T T K A
384 7 T T K A
384 6 T T K A
384 5 T T K A
384 4 T T K A
384 3 T T K A
384 2 T T K A
384 T T J Q A
384 9 T T Q A
384 8 T T Q A
384 7 T T Q A
384 6 T T Q A
384 5 T T Q A
384 4 T T Q A
384 3 T T Q A
384 2 T T Q A
384 9 T T J A
384 8 T T J A
384 7 T T J A
384 6 T T J A
384 5 T T J A
384 4 T T J A
384 3 T T J A
384 2 T T J A
384 8 9 T T A
384 7 9 T T A
384 6 9 T T A
384 5 9 T T A
384 4 9 T T A
384 3 9 T T A
384 2 9 T T A
384 7 8 T T A
384 6 8 T T A
384 5 8 T T A
384 4 8 T T A
384 3 8 T T A
384 2 8 T T A
384 6 7 T T A
384 5 7 T T A
384 4 7 T T A
384 3 7 T T A
384 2 7 T T A
384 5 6 T T A
384 4 6 T T A
384 3 6 T T A
384 2 6 T T A
384 4 5 T T A
384 3 5 T T A
384 2 5 T T A
384 3 4 T T A
384 2 4 T T A
384 2 3 T T A
384 T T J Q K
384 9 T T Q K
384 8 T T Q K
384 7 T T Q K
384 6 T T Q K
384 5 T T Q K
384 4 T T Q K
384 3 T T Q K
384 2 T T Q K
384 9 T T J K
384 8 T T J K
384 7 T T J K
384 6 T T J K
384 5 T T J K
384 4 T T J K
384 3 T T J K
384 2 T T J K
384 8 9 T T K
384 7 9 T T K
384 6 9 T T K
384 5 9 T T K
384 4 9 T T K
384 3 9 T T K
384 2 9 T T K
384 7 8 T T K
384 6 8 T T K
384 5 8 T T K
384 4 8 T T K
384 3 8 T T K
384 2 8 T T K
384 6 7 T T K
384 5 7 T T K
384 4 7 T T K
384 3 7 T T K
384 2 7 T T K
384 5 6 T T K
384 4 6 T T K
384 3 6 T T K
384 2 6 T T K
384 4 5 T T K
384 3 5 T T K
384 2 5 T T K
384 3 4 T T K
384 2 4 T T K
384 2 3 T T K
384 9 T T J Q
384 8 T T J Q
384 7 T T J Q
384 6 T T J Q
384 5 T T J Q
384 4 T T J Q
384 3 T T J Q
384 2 T T J Q
384 8 9 T T Q
384 7 9 T T Q
384 6 9 T T Q
384 5 9 T T Q
384 4 9 T T Q
384 3 9 T T Q
384 2 9 T T Q
384 7 8 T T Q
384 6 8 T T Q
384 5 8 T T Q
384 4 8 T T Q
384 3 8 T T Q
384 2 8 T T Q
384 6 7 T T Q
384 5 7 T T Q
384 4 7 T T Q
384 3 7 T T Q
384 2 7 T T Q
384 5 6 T T Q
384 4 6 T T Q
384 3 6 T T Q
384 2 6 T T Q
384 4 5 T T Q
384 3 5 T T Q
384 2 5 T T Q
384 3 4 T T Q
384 2 4 T T Q
384 2 3 T T Q
384 8 9 T T J
384 7 9 T T J
384 6 9 T T J
384 5 9 T T J
384 4 9 T T J
384 3 9 T T J
384 2 9 T T J
384 7 8 T T J
384 6 8 T T J
384 5 8 T T J
384 4 8 T T J
384 3 8 T T J
384 2 8 T T J
384 6 7 T T J
384 5 7 T T J
384 4 7 T T J
384 3 7 T T J
384 2 7 T T J
384 5 6 T T J
384 4 6 T T J
384 3 6 T T J
384 2 6 T T J
384 4 5 T T J
384 3 5 T T J
384 2 5 T T J
384 3 4 T T J
384 2 4 T T J
384 2 3 T T J
384 7 8 9 T T
384 6 8 9 T T
384 5 8 9 T T
384 4 8 9 T T
384 3 8 9 T T
384 2 8 9 T T
384 6 7 9 T T
384 5 7 9 T T
384 4 7 9 T T
384 3 7 9 T T
384 2 7 9 T T
384 5 6 9 T T
384 4 6 9 T T
384 3 6 9 T T
384 2 6 9 T T
384 4 5 9 T T
384 3 5 9 T T
384 2 5 9 T T
384 3 4 9 T T
384 2 4 9 T T
384 2 3 9 T T
384 6 7 8 T T
384 5 7 8 T T
384 4 7 8 T T
384 3 7 8 T T
384 2 7 8 T T
384 5 6 8 T T
384 4 6 8 T T
384 3 6 8 T T
384 2 6 8 T T
384 4 5 8 T T
384 3 5 8 T T
384 2 5 8 T T
384 3 4 8 T T
384 2 4 8 T T
384 2 3 8 T T
384 5 6 7 T T
384 4 6 7 T T
384 3 6 7 T T
384 2 6 7 T T
384 4 5 7 T T
384 3 5 7 T T
384 2 5 7 T T
384 3 4 7 T T
384 2 4 7 T T
384 2 3 7 T T
384 4 5 6 T T
384 3 5 6 T T
384 2 5 6 T T
384 3 4 6 T T
384 2 4 6 T T
384 2 3 6 T T
384 3 4 5 T T
384 2 4 5 T T
384 2 3 5 T T
384 2 3 4 T T
384 9 9 Q K A Pair of Nines
384 9 9 J K A
384 9 9 T K A
384 8 9 9 K A
384 7 9 9 K A
384 6 9 9 K A
384 5 9 9 K A
384 4 9 9 K A
384 3 9 9 K A
384 2 9 9 K A
384 9 9 J Q A
384 9 9 T Q A
384 8 9 9 Q A
384 7 9 9 Q A
384 6 9 9 Q A
384 5 9 9 Q A
384 4 9 9 Q A
384 3 9 9 Q A
384 2 9 9 Q A
384 9 9 T J A
384 8 9 9 J A
384 7 9 9 J A
384 6 9 9 J A
384 5 9 9 J A
384 4 9 9 J A
384 3 9 9 J A
384 2 9 9 J A
384 8 9 9 T A
384 7 9 9 T A
384 6 9 9 T A
384 5 9 9 T A
384 4 9 9 T A
384 3 9 9 T A
384 2 9 9 T A
384 7 8 9 9 A
384 6 8 9 9 A
384 5 8 9 9 A
384 4 8 9 9 A
384 3 8 9 9 A
384 2 8 9 9 A
384 6 7 9 9 A
384 5 7 9 9 A
384 4 7 9 9 A
384 3 7 9 9 A
384 2 7 9 9 A
384 5 6 9 9 A
384 4 6 9 9 A
384 3 6 9 9 A
384 2 6 9 9 A
384 4 5 9 9 A
384 3 5 9 9 A
384 2 5 9 9 A
384 3 4 9 9 A
384 2 4 9 9 A
384 2 3 9 9 A
384 9 9 J Q K
384 9 9 T Q K
384 8 9 9 Q K
384 7 9 9 Q K
384 6 9 9 Q K
384 5 9 9 Q K
384 4 9 9 Q K
384 3 9 9 Q K
384 2 9 9 Q K
384 9 9 T J K
384 8 9 9 J K
384 7 9 9 J K
384 6 9 9 J K
384 5 9 9 J K
384 4 9 9 J K
384 3 9 9 J K
384 2 9 9 J K
384 8 9 9 T K
384 7 9 9 T K
384 6 9 9 T K
384 5 9 9 T K
384 4 9 9 T K
384 3 9 9 T K
384 2 9 9 T K
384 7 8 9 9 K
384 6 8 9 9 K
384 5 8 9 9 K
384 4 8 9 9 K
384 3 8 9 9 K
384 2 8 9 9 K
384 6 7 9 9 K
384 5 7 9 9 K
384 4 7 9 9 K
384 3 7 9 9 K
384 2 7 9 9 K
384 5 6 9 9 K
384 4 6 9 9 K
384 3 6 9 9 K
384 2 6 9 9 K
384 4 5 9 9 K
384 3 5 9 9 K
384 2 5 9 9 K
384 3 4 9 9 K
384 2 4 9 9 K
384 2 3 9 9 K
384 9 9 T J Q
384 8 9 9 J Q
384 7 9 9 J Q
384 6 9 9 J Q
384 5 9 9 J Q
384 4 9 9 J Q
384 3 9 9 J Q
384 2 9 9 J Q
384 8 9 9 T Q
384 7 9 9 T Q
384 6 9 9 T Q
384 5 9 9 T Q
384 4 9 9 T Q
384 3 9 9 T Q
384 2 9 9 T Q
384 7 8 9 9 Q
384 6 8 9 9 Q
384 5 8 9 9 Q
384 4 8 9 9 Q
384 3 8 9 9 Q
384 2 8 9 9 Q
384 6 7 9 9 Q
384 5 7 9 9 Q
384 4 7 9 9 Q
384 3 7 9 9 Q
384 2 7 9 9 Q
384 5 6 9 9 Q
384 4 6 9 9 Q
384 3 6 9 9 Q
384 2 6 9 9 Q
384 4 5 9 9 Q
384 3 5 9 9 Q
384 2 5 9 9 Q
384 3 4 9 9 Q
384 2 4 9 9 Q
384 2 3 9 9 Q
384 8 9 9 T J
384 7 9 9 T J
384 6 9 9 T J
384 5 9 9 T J
384 4 9 9 T J
384 3 9 9 T J
384 2 9 9 T J
384 7 8 9 9 J
384 6 8 9 9 J
384 5 8 9 9 J
384 4 8 9 9 J
384 3 8 9 9 J
384 2 8 9 9 J
384 6 7 9 9 J
384 5 7 9 9 J
384 4 7 9 9 J
384 3 7 9 9 J
384 2 7 9 9 J
384 5 6 9 9 J
384 4 6 9 9 J
384 3 6 9 9 J
384 2 6 9 9 J
384 4 5 9 9 J
384 3 5 9 9 J
384 2 5 9 9 J
384 3 4 9 9 J
384 2 4 9 9 J
384 2 3 9 9 J
384 7 8 9 9 T
384 6 8 9 9 T
384 5 8 9 9 T
384 4 8 9 9 T
384 3 8 9 9 T
384 2 8 9 9 T
384 6 7 9 9 T
384 5 7 9 9 T
384 4 7 9 9 T
384 3 7 9 9 T
384 2 7 9 9 T
384 5 6 9 9 T
384 4 6 9 9 T
384 3 6 9 9 T
384 2 6 9 9 T
384 4 5 9 9 T
384 3 5 9 9 T
384 2 5 9 9 T
384 3 4 9 9 T
384 2 4 9 9 T
384 2 3 9 9 T
384 6 7 8 9 9
384 5 7 8 9 9
384 4 7 8 9 9
384 3 7 8 9 9
384 2 7 8 9 9
384 5 6 8 9 9
384 4 6 8 9 9
384 3 6 8 9 9
384 2 6 8 9 9
384 4 5 8 9 9
384 3 5 8 9 9
384 2 5 8 9 9
384 3 4 8 9 9
384 2 4 8 9 9
384 2 3 8 9 9
384 5 6 7 9 9
384 4 6 7 9 9
384 3 6 7 9 9
384 2 6 7 9 9
384 4 5 7 9 9
384 3 5 7 9 9
384 2 5 7 9 9
384 3 4 7 9 9
384 2 4 7 9 9
384 2 3 7 9 9
384 4 5 6 9 9
384 3 5 6 9 9
384 2 5 6 9 9
384 3 4 6 9 9
384 2 4 6 9 9
384 2 3 6 9 9
384 3 4 5 9 9
384 2 4 5 9 9
384 2 3 5 9 9
384 2 3 4 9 9
384 8 8 Q K A Pair of Eights
384 8 8 J K A
384 8 8 T K A
384 8 8 9 K A
384 7 8 8 K A
384 6 8 8 K A
384 5 8 8 K A
384 4 8 8 K A
384 3 8 8 K A
384 2 8 8 K A
384 8 8 J Q A
384 8 8 T Q A
384 8 8 9 Q A
384 7 8 8 Q A
384 6 8 8 Q A
384 5 8 8 Q A
384 4 8 8 Q A
384 3 8 8 Q A
384 2 8 8 Q A
384 8 8 T J A
384 8 8 9 J A
384 7 8 8 J A
384 6 8 8 J A
384 5 8 8 J A
384 4 8 8 J A
384 3 8 8 J A
384 2 8 8 J A
384 8 8 9 T A
384 7 8 8 T A
384 6 8 8 T A
384 5 8 8 T A
384 4 8 8 T A
384 3 8 8 T A
384 2 8 8 T A
384 7 8 8 9 A
384 6 8 8 9 A
384 5 8 8 9 A
384 4 8 8 9 A
384 3 8 8 9 A
384 2 8 8 9 A
384 6 7 8 8 A
384 5 7 8 8 A
384 4 7 8 8 A
384 3 7 8 8 A
384 2 7 8 8 A
384 5 6 8 8 A
384 4 6 8 8 A
384 3 6 8 8 A
384 2 6 8 8 A
384 4 5 8 8 A
384 3 5 8 8 A
384 2 5 8 8 A
384 3 4 8 8 A
384 2 4 8 8 A
384 2 3 8 8 A
384 8 8 J Q K
384 8 8 T Q K
384 8 8 9 Q K
384 7 8 8 Q K
384 6 8 8 Q K
384 5 8 8 Q K
384 4 8 8 Q K
384 3 8 8 Q K
384 2 8 8 Q K
384 8 8 T J K
384 8 8 9 J K
384 7 8 8 J K
384 6 8 8 J K
384 5 8 8 J K
384 4 8 8 J K
384 3 8 8 J K
384 2 8 8 J K
384 8 8 9 T K
384 7 8 8 T K
384 6 8 8 T K
384 5 8 8 T K
384 4 8 8 T K
384 3 8 8 T K
384 2 8 8 T K
384 7 8 8 9 K
384 6 8 8 9 K
384 5 8 8 9 K
384 4 8 8 9 K
384 3 8 8 9 K
384 2 8 8 9 K
384 6 7 8 8 K
384 5 7 8 8 K
384 4 7 8 8 K
384 3 7 8 8 K
384 2 7 8 8 K
384 5 6 8 8 K
384 4 6 8 8 K
384 3 6 8 8 K
384 2 6 8 8 K
384 4 5 8 8 K
384 3 5 8 8 K
384 2 5 8 8 K
384 3 4 8 8 K
384 2 4 8 8 K
384 2 3 8 8 K
384 8 8 T J Q
384 8 8 9 J Q
384 7 8 8 J Q
384 6 8 8 J Q
384 5 8 8 J Q
384 4 8 8 J Q
384 3 8 8 J Q
384 2 8 8 J Q
384 8 8 9 T Q
384 7 8 8 T Q
384 6 8 8 T Q
384 5 8 8 T Q
384 4 8 8 T Q
384 3 8 8 T Q
384 2 8 8 T Q
384 7 8 8 9 Q
384 6 8 8 9 Q
384 5 8 8 9 Q
384 4 8 8 9 Q
384 3 8 8 9 Q
384 2 8 8 9 Q
384 6 7 8 8 Q
384 5 7 8 8 Q
384 4 7 8 8 Q
384 3 7 8 8 Q
384 2 7 8 8 Q
384 5 6 8 8 Q
384 4 6 8 8 Q
384 3 6 8 8 Q
384 2 6 8 8 Q
384 4 5 8 8 Q
384 3 5 8 8 Q
384 2 5 8 8 Q
384 3 4 8 8 Q
384 2 4 8 8 Q
384 2 3 8 8 Q
384 8 8 9 T J
384 7 8 8 T J
384 6 8 8 T J
384 5 8 8 T J
384 4 8 8 T J
384 3 8 8 T J
384 2 8 8 T J
384 7 8 8 9 J
384 6 8 8 9 J
384 5 8 8 9 J
384 4 8 8 9 J
384 3 8 8 9 J
384 2 8 8 9 J
384 6 7 8 8 J
384 5 7 8 8 J
384 4 7 8 8 J
384 3 7 8 8 J
384 2 7 8 8 J
384 5 6 8 8 J
384 4 6 8 8 J
384 3 6 8 8 J
384 2 6 8 8 J
384 4 5 8 8 J
384 3 5 8 8 J
384 2 5 8 8 J
384 3 4 8 8 J
384 2 4 8 8 J
384 2 3 8 8 J
384 7 8 8 9 T
384 6 8 8 9 T
384 5 8 8 9 T
384 4 8 8 9 T
384 3 8 8 9 T
384 2 8 8 9 T
384 6 7 8 8 T
384 5 7 8 8 T
384 4 7 8 8 T
384 3 7 8 8 T
384 2 7 8 8 T
384 5 6 8 8 T
384 4 6 8 8 T
384 3 6 8 8 T
384 2 6 8 8 T
384 4 5 8 8 T
384 3 5 8 8 T
384 2 5 8 8 T
384 3 4 8 8 T
384 2 4 8 8 T
384 2 3 8 8 T
384 6 7 8 8 9
384 5 7 8 8 9
384 4 7 8 8 9
384 3 7 8 8 9
384 2 7 8 8 9
384 5 6 8 8 9
384 4 6 8 8 9
384 3 6 8 8 9
384 2 6 8 8 9
384 4 5 8 8 9
384 3 5 8 8 9
384 2 5 8 8 9
384 3 4 8 8 9
384 2 4 8 8 9
384 2 3 8 8 9
384 5 6 7 8 8
384 4 6 7 8 8
384 3 6 7 8 8
384 2 6 7 8 8
384 4 5 7 8 8
384 3 5 7 8 8
384 2 5 7 8 8
384 3 4 7 8 8
384 2 4 7 8 8
384 2 3 7 8 8
384 4 5 6 8 8
384 3 5 6 8 8
384 2 5 6 8 8
384 3 4 6 8 8
384 2 4 6 8 8
384 2 3 6 8 8
384 3 4 5 8 8
384 2 4 5 8 8
384 2 3 5 8 8
384 2 3 4 8 8
384 7 7 Q K A Pair of Sevens
384 7 7 J K A
384 7 7 T K A
384 7 7 9 K A
384 7 7 8 K A
384 6 7 7 K A
384 5 7 7 K A
384 4 7 7 K A
384 3 7 7 K A
384 2 7 7 K A
384 7 7 J Q A
384 7 7 T Q A
384 7 7 9 Q A
384 7 7 8 Q A
384 6 7 7 Q A
384 5 7 7 Q A
384 4 7 7 Q A
384 3 7 7 Q A
384 2 7 7 Q A
384 7 7 T J A
384 7 7 9 J A
384 7 7 8 J A
384 6 7 7 J A
384 5 7 7 J A
384 4 7 7 J A
384 3 7 7 J A
384 2 7 7 J A
384 7 7 9 T A
384 7 7 8 T A
384 6 7 7 T A
384 5 7 7 T A
384 4 7 7 T A
384 3 7 7 T A
384 2 7 7 T A
384 7 7 8 9 A
384 6 7 7 9 A
384 5 7 7 9 A
384 4 7 7 9 A
384 3 7 7 9 A
384 2 7 7 9 A
384 6 7 7 8 A
384 5 7 7 8 A
384 4 7 7 8 A
384 3 7 7 8 A
384 2 7 7 8 A
384 5 6 7 7 A
384 4 6 7 7 A
384 3 6 7 7 A
384 2 6 7 7 A
384 4 5 7 7 A
384 3 5 7 7 A
384 2 5 7 7 A
384 3 4 7 7 A
384 2 4 7 7 A
384 2 3 7 7 A
384 7 7 J Q K
384 7 7 T Q K
384 7 7 9 Q K
384 7 7 8 Q K
384 6 7 7 Q K
384 5 7 7 Q K
384 4 7 7 Q K
384 3 7 7 Q K
384 2 7 7 Q K
384 7 7 T J K
384 7 7 9 J K
384 7 7 8 J K
384 6 7 7 J K
384 5 7 7 J K
384 4 7 7 J K
384 3 7 7 J K
384 2 7 7 J K
384 7 7 9 T K
384 7 7 8 T K
384 6 7 7 T K
384 5 7 7 T K
384 4 7 7 T K
384 3 7 7 T K
384 2 7 7 T K
384 7 7 8 9 K
384 6 7 7 9 K
384 5 7 7 9 K
384 4 7 7 9 K
384 3 7 7 9 K
384 2 7 7 9 K
384 6 7 7 8 K
384 5 7 7 8 K
384 4 7 7 8 K
384 3 7 7 8 K
384 2 7 7 8 K
384 5 6 7 7 K
384 4 6 7 7 K
384 3 6 7 7 K
384 2 6 7 7 K
384 4 5 7 7 K
384 3 5 7 7 K
384 2 5 7 7 K
384 3 4 7 7 K
384 2 4 7 7 K
384 2 3 7 7 K
384 7 7 T J Q
384 7 7 9 J Q
384 7 7 8 J Q
384 6 7 7 J Q
384 5 7 7 J Q
384 4 7 7 J Q
384 3 7 7 J Q
384 2 7 7 J Q
384 7 7 9 T Q
384 7 7 8 T Q
384 6 7 7 T Q
384 5 7 7 T Q
384 4 7 7 T Q
384 3 7 7 T Q
384 2 7 7 T Q
384 7 7 8 9 Q
384 6 7 7 9 Q
384 5 7 7 9 Q
384 4 7 7 9 Q
384 3 7 7 9 Q
384 2 7 7 9 Q
384 6 7 7 8 Q
384 5 7 7 8 Q
384 4 7 7 8 Q
384 3 7 7 8 Q
384 2 7 7 8 Q
384 5 6 7 7 Q
384 4 6 7 7 Q
384 3 6 7 7 Q
384 2 6 7 7 Q
384 4 5 7 7 Q
384 3 5 7 7 Q
384 2 5 7 7 Q
384 3 4 7 7 Q
384 2 4 7 7 Q
384 2 3 7 7 Q
384 7 7 9 T J
384 7 7 8 T J
384 6 7 7 T J
384 5 7 7 T J
384 4 7 7 T J
384 3 7 7 T J
384 2 7 7 T J
384 7 7 8 9 J
384 6 7 7 9 J
384 5 7 7 9 J
384 4 7 7 9 J
384 3 7 7 9 J
384 2 7 7 9 J
384 6 7 7 8 J
384 5 7 7 8 J
384 4 7 7 8 J
384 3 7 7 8 J
384 2 7 7 8 J
384 5 6 7 7 J
384 4 6 7 7 J
384 3 6 7 7 J
384 2 6 7 7 J
384 4 5 7 7 J
384 3 5 7 7 J
384 2 5 7 7 J
384 3 4 7 7 J
384 2 4 7 7 J
384 2 3 7 7 J
384 7 7 8 9 T
384 6 7 7 9 T
384 5 7 7 9 T
384 4 7 7 9 T
384 3 7 7 9 T
384 2 7 7 9 T
384 6 7 7 8 T
384 5 7 7 8 T
384 4 7 7 8 T
384 3 7 7 8 T
384 2 7 7 8 T
384 5 6 7 7 T
384 4 6 7 7 T
384 3 6 7 7 T
384 2 6 7 7 T
384 4 5 7 7 T
384 3 5 7 7 T
384 2 5 7 7 T
384 3 4 7 7 T
384 2 4 7 7 T
384 2 3 7 7 T
384 6 7 7 8 9
384 5 7 7 8 9
384 4 7 7 8 9
384 3 7 7 8 9
384 2 7 7 8 9
384 5 6 7 7 9
384 4 6 7 7 9
384 3 6 7 7 9
384 2 6 7 7 9
384 4 5 7 7 9
384 3 5 7 7 9
384 2 5 7 7 9
384 3 4 7 7 9
384 2 4 7 7 9
384 2 3 7 7 9
384 5 6 7 7 8
384 4 6 7 7 8
384 3 6 7 7 8
384 2 6 7 7 8
384 4 5 7 7 8
384 3 5 7 7 8
384 2 5 7 7 8
384 3 4 7 7 8
384 2 4 7 7 8
384 2 3 7 7 8
384 4 5 6 7 7
384 3 5 6 7 7
384 2 5 6 7 7
384 3 4 6 7 7
384 2 4 6 7 7
384 2 3 6 7 7
384 3 4 5 7 7
384 2 4 5 7 7
384 2 3 5 7 7
384 2 3 4 7 7
384 6 6 Q K A Pair of Sixes
384 6 6 J K A
384 6 6 T K A
384 6 6 9 K A
384 6 6 8 K A
384 6 6 7 K A
384 5 6 6 K A
384 4 6 6 K A
384 3 6 6 K A
384 2 6 6 K A
384 6 6 J Q A
384 6 6 T Q A
384 6 6 9 Q A
384 6 6 8 Q A
384 6 6 7 Q A
384 5 6 6 Q A
384 4 6 6 Q A
384 3 6 6 Q A
384 2 6 6 Q A
384 6 6 T J A
384 6 6 9 J A
384 6 6 8 J A
384 6 6 7 J A
384 5 6 6 J A
384 4 6 6 J A
384 3 6 6 J A
384 2 6 6 J A
384 6 6 9 T A
384 6 6 8 T A
384 6 6 7 T A
384 5 6 6 T A
384 4 6 6 T A
384 3 6 6 T A
384 2 6 6 T A
384 6 6 8 9 A
384 6 6 7 9 A
384 5 6 6 9 A
384 4 6 6 9 A
384 3 6 6 9 A
384 2 6 6 9 A
384 6 6 7 8 A
384 5 6 6 8 A
384 4 6 6 8 A
384 3 6 6 8 A
384 2 6 6 8 A
384 5 6 6 7 A
384 4 6 6 7 A
384 3 6 6 7 A
384 2 6 6 7 A
384 4 5 6 6 A
384 3 5 6 6 A
384 2 5 6 6 A
384 3 4 6 6 A
384 2 4 6 6 A
384 2 3 6 6 A
384 6 6 J Q K
384 6 6 T Q K
384 6 6 9 Q K
384 6 6 8 Q K
384 6 6 7 Q K
384 5 6 6 Q K
384 4 6 6 Q K
384 3 6 6 Q K
384 2 6 6 Q K
384 6 6 T J K
384 6 6 9 J K
384 6 6 8 J K
384 6 6 7 J K
384 5 6 6 J K
384 4 6 6 J K
384 3 6 6 J K
384 2 6 6 J K
384 6 6 9 T K
384 6 6 8 T K
384 6 6 7 T K
384 5 6 6 T K
384 4 6 6 T K
384 3 6 6 T K
384 2 6 6 T K
384 6 6 8 9 K
384 6 6 7 9 K
384 5 6 6 9 K
384 4 6 6 9 K
384 3 6 6 9 K
384 2 6 6 9 K
384 6 6 7 8 K
384 5 6 6 8 K
384 4 6 6 8 K
384 3 6 6 8 K
384 2 6 6 8 K
384 5 6 6 7 K
384 4 6 6 7 K
384 3 6 6 7 K
384 2 6 6 7 K
384 4 5 6 6 K
384 3 5 6 6 K
384 2 5 6 6 K
384 3 4 6 6 K
384 2 4 6 6 K
384 2 3 6 6 K
384 6 6 T J Q
384 6 6 9 J Q
384 6 6 8 J Q
384 6 6 7 J Q
384 5 6 6 J Q
384 4 6 6 J Q
384 3 6 6 J Q
384 2 6 6 J Q
384 6 6 9 T Q
384 6 6 8 T Q
384 6 6 7 T Q
384 5 6 6 T Q
384 4 6 6 T Q
384 3 6 6 T Q
384 2 6 6 T Q
384 6 6 8 9 Q
384 6 6 7 9 Q
384 5 6 6 9 Q
384 4 6 6 9 Q
384 3 6 6 9 Q
384 2 6 6 9 Q
384 6 6 7 8 Q
384 5 6 6 8 Q
384 4 6 6 8 Q
384 3 6 6 8 Q
384 2 6 6 8 Q
384 5 6 6 7 Q
384 4 6 6 7 Q
384 3 6 6 7 Q
384 2 6 6 7 Q
384 4 5 6 6 Q
384 3 5 6 6 Q
384 2 5 6 6 Q
384 3 4 6 6 Q
384 2 4 6 6 Q
384 2 3 6 6 Q
384 6 6 9 T J
384 6 6 8 T J
384 6 6 7 T J
384 5 6 6 T J
384 4 6 6 T J
384 3 6 6 T J
384 2 6 6 T J
384 6 6 8 9 J
384 6 6 7 9 J
384 5 6 6 9 J
384 4 6 6 9 J
384 3 6 6 9 J
384 2 6 6 9 J
384 6 6 7 8 J
384 5 6 6 8 J
384 4 6 6 8 J
384 3 6 6 8 J
384 2 6 6 8 J
384 5 6 6 7 J
384 4 6 6 7 J
384 3 6 6 7 J
384 2 6 6 7 J
384 4 5 6 6 J
384 3 5 6 6 J
384 2 5 6 6 J
384 3 4 6 6 J
384 2 4 6 6 J
384 2 3 6 6 J
384 6 6 8 9 T
384 6 6 7 9 T
384 5 6 6 9 T
384 4 6 6 9 T
384 3 6 6 9 T
384 2 6 6 9 T
384 6 6 7 8 T
384 5 6 6 8 T
384 4 6 6 8 T
384 3 6 6 8 T
384 2 6 6 8 T
384 5 6 6 7 T
384 4 6 6 7 T
384 3 6 6 7 T
384 2 6 6 7 T
384 4 5 6 6 T
384 3 5 6 6 T
384 2 5 6 6 T
384 3 4 6 6 T
384 2 4 6 6 T
384 2 3 6 6 T
384 6 6 7 8 9
384 5 6 6 8 9
384 4 6 6 8 9
384 3 6 6 8 9
384 2 6 6 8 9
384 5 6 6 7 9
384 4 6 6 7 9
384 3 6 6 7 9
384 2 6 6 7 9
384 4 5 6 6 9
384 3 5 6 6 9
384 2 5 6 6 9
384 3 4 6 6 9
384 2 4 6 6 9
384 2 3 6 6 9
384 5 6 6 7 8
384 4 6 6 7 8
384 3 6 6 7 8
384 2 6 6 7 8
384 4 5 6 6 8
384 3 5 6 6 8
384 2 5 6 6 8
384 3 4 6 6 8
384 2 4 6 6 8
384 2 3 6 6 8
384 4 5 6 6 7
384 3 5 6 6 7
384 2 5 6 6 7
384 3 4 6 6 7
384 2 4 6 6 7
384 2 3 6 6 7
384 3 4 5 6 6
384 2 4 5 6 6
384 2 3 5 6 6
384 2 3 4 6 6
384 5 5 Q K A Pair of Fives
384 5 5 J K A
384 5 5 T K A
384 5 5 9 K A
384 5 5 8 K A
384 5 5 7 K A
384 5 5 6 K A
384 4 5 5 K A
384 3 5 5 K A
384 2 5 5 K A
384 5 5 J Q A
384 5 5 T Q A
384 5 5 9 Q A
384 5 5 8 Q A
384 5 5 7 Q A
384 5 5 6 Q A
384 4 5 5 Q A
384 3 5 5 Q A
384 2 5 5 Q A
384 5 5 T J A
384 5 5 9 J A
384 5 5 8 J A
384 5 5 7 J A
384 5 5 6 J A
384 4 5 5 J A
384 3 5 5 J A
384 2 5 5 J A
384 5 5 9 T A
384 5 5 8 T A
384 5 5 7 T A
384 5 5 6 T A
384 4 5 5 T A
384 3 5 5 T A
384 2 5 5 T A
384 5 5 8 9 A
384 5 5 7 9 A
384 5 5 6 9 A
384 4 5 5 9 A
384 3 5 5 9 A
384 2 5 5 9 A
384 5 5 7 8 A
384 5 5 6 8 A
384 4 5 5 8 A
384 3 5 5 8 A
384 2 5 5 8 A
384 5 5 6 7 A
384 4 5 5 7 A
384 3 5 5 7 A
384 2 5 5 7 A
384 4 5 5 6 A
384 3 5 5 6 A
384 2 5 5 6 A
384 3 4 5 5 A
384 2 4 5 5 A
384 2 3 5 5 A
384 5 5 J Q K
384 5 5 T Q K
384 5 5 9 Q K
384 5 5 8 Q K
384 5 5 7 Q K
384 5 5 6 Q K
384 4 5 5 Q K
384 3 5 5 Q K
384 2 5 5 Q K
384 5 5 T J K
384 5 5 9 J K
384 5 5 8 J K
384 5 5 7 J K
384 5 5 6 J K
384 4 5 5 J K
384 3 5 5 J K
384 2 5 5 J K
384 5 5 9 T K
384 5 5 8 T K
384 5 5 7 T K
384 5 5 6 T K
384 4 5 5 T K
384 3 5 5 T K
384 2 5 5 T K
384 5 5 8 9 K
384 5 5 7 9 K
384 5 5 6 9 K
384 4 5 5 9 K
384 3 5 5 9 K
384 2 5 5 9 K
384 5 5 7 8 K
384 5 5 6 8 K
384 4 5 5 8 K
384 3 5 5 8 K
384 2 5 5 8 K
384 5 5 6 7 K
384 4 5 5 7 K
384 3 5 5 7 K
384 2 5 5 7 K
384 4 5 5 6 K
384 3 5 5 6 K
384 2 5 5 6 K
384 3 4 5 5 K
384 2 4 5 5 K
384 2 3 5 5 K
384 5 5 T J Q
384 5 5 9 J Q
384 5 5 8 J Q
384 5 5 7 J Q
384 5 5 6 J Q
384 4 5 5 J Q
384 3 5 5 J Q
384 2 5 5 J Q
384 5 5 9 T Q
384 5 5 8 T Q
384 5 5 7 T Q
384 5 5 6 T Q
384 4 5 5 T Q
384 3 5 5 T Q
384 2 5 5 T Q
384 5 5 8 9 Q
384 5 5 7 9 Q
384 5 5 6 9 Q
384 4 5 5 9 Q
384 3 5 5 9 Q
384 2 5 5 9 Q
384 5 5 7 8 Q
384 5 5 6 8 Q
384 4 5 5 8 Q
384 3 5 5 8 Q
384 2 5 5 8 Q
384 5 5 6 7 Q
384 4 5 5 7 Q
384 3 5 5 7 Q
384 2 5 5 7 Q
384 4 5 5 6 Q
384 3 5 5 6 Q
384 2 5 5 6 Q
384 3 4 5 5 Q
384 2 4 5 5 Q
384 2 3 5 5 Q
384 5 5 9 T J
384 5 5 8 T J
384 5 5 7 T J
384 5 5 6 T J
384 4 5 5 T J
384 3 5 5 T J
384 2 5 5 T J
384 5 5 8 9 J
384 5 5 7 9 J
384 5 5 6 9 J
384 4 5 5 9 J
384 3 5 5 9 J
384 2 5 5 9 J
384 5 5 7 8 J
384 5 5 6 8 J
384 4 5 5 8 J
384 3 5 5 8 J
384 2 5 5 8 J
384 5 5 6 7 J
384 4 5 5 7 J
384 3 5 5 7 J
384 2 5 5 7 J
384 4 5 5 6 J
384 3 5 5 6 J
384 2 5 5 6 J
384 3 4 5 5 J
384 2 4 5 5 J
384 2 3 5 5 J
384 5 5 8 9 T
384 5 5 7 9 T
384 5 5 6 9 T
384 4 5 5 9 T
384 3 5 5 9 T
384 2 5 5 9 T
384 5 5 7 8 T
384 5 5 6 8 T
384 4 5 5 8 T
384 3 5 5 8 T
384 2 5 5 8 T
384 5 5 6 7 T
384 4 5 5 7 T
384 3 5 5 7 T
384 2 5 5 7 T
384 4 5 5 6 T
384 3 5 5 6 T
384 2 5 5 6 T
384 3 4 5 5 T
384 2 4 5 5 T
384 2 3 5 5 T
384 5 5 7 8 9
384 5 5 6 8 9
384 4 5 5 8 9
384 3 5 5 8 9
384 2 5 5 8 9
384 5 5 6 7 9
384 4 5 5 7 9
384 3 5 5 7 9
384 2 5 5 7 9
384 4 5 5 6 9
384 3 5 5 6 9
384 2 5 5 6 9
384 3 4 5 5 9
384 2 4 5 5 9
384 2 3 5 5 9
384 5 5 6 7 8
384 4 5 5 7 8
384 3 5 5 7 8
384 2 5 5 7 8
384 4 5 5 6 8
384 3 5 5 6 8
384 2 5 5 6 8
384 3 4 5 5 8
384 2 4 5 5 8
384 2 3 5 5 8
384 4 5 5 6 7
384 3 5 5 6 7
384 2 5 5 6 7
384 3 4 5 5 7
384 2 4 5 5 7
384 2 3 5 5 7
384 3 4 5 5 6
384 2 4 5 5 6
384 2 3 5 5 6
384 2 3 4 5 5
384 4 4 Q K A Pair of Fours
384 4 4 J K A
384 4 4 T K A
384 4 4 9 K A
384 4 4 8 K A
384 4 4 7 K A
384 4 4 6 K A
384 4 4 5 K A
384 3 4 4 K A
384 2 4 4 K A
384 4 4 J Q A
384 4 4 T Q A
384 4 4 9 Q A
384 4 4 8 Q A
384 4 4 7 Q A
384 4 4 6 Q A
384 4 4 5 Q A
384 3 4 4 Q A
384 2 4 4 Q A
384 4 4 T J A
384 4 4 9 J A
384 4 4 8 J A
384 4 4 7 J A
384 4 4 6 J A
384 4 4 5 J A
384 3 4 4 J A
384 2 4 4 J A
384 4 4 9 T A
384 4 4 8 T A
384 4 4 7 T A
384 4 4 6 T A
384 4 4 5 T A
384 3 4 4 T A
384 2 4 4 T A
384 4 4 8 9 A
384 4 4 7 9 A
384 4 4 6 9 A
384 4 4 5 9 A
384 3 4 4 9 A
384 2 4 4 9 A
384 4 4 7 8 A
384 4 4 6 8 A
384 4 4 5 8 A
384 3 4 4 8 A
384 2 4 4 8 A
384 4 4 6 7 A
384 4 4 5 7 A
384 3 4 4 7 A
384 2 4 4 7 A
384 4 4 5 6 A
384 3 4 4 6 A
384 2 4 4 6 A
384 3 4 4 5 A
384 2 4 4 5 A
384 2 3 4 4 A
384 4 4 J Q K
384 4 4 T Q K
384 4 4 9 Q K
384 4 4 8 Q K
384 4 4 7 Q K
384 4 4 6 Q K
384 4 4 5 Q K
384 3 4 4 Q K
384 2 4 4 Q K
384 4 4 T J K
384 4 4 9 J K
384 4 4 8 J K
384 4 4 7 J K
384 4 4 6 J K
384 4 4 5 J K
384 3 4 4 J K
384 2 4 4 J K
384 4 4 9 T K
384 4 4 8 T K
384 4 4 7 T K
384 4 4 6 T K
384 4 4 5 T K
384 3 4 4 T K
384 2 4 4 T K
384 4 4 8 9 K
384 4 4 7 9 K
384 4 4 6 9 K
384 4 4 5 9 K
384 3 4 4 9 K
384 2 4 4 9 K
384 4 4 7 8 K
384 4 4 6 8 K
384 4 4 5 8 K
384 3 4 4 8 K
384 2 4 4 8 K
384 4 4 6 7 K
384 4 4 5 7 K
384 3 4 4 7 K
384 2 4 4 7 K
384 4 4 5 6 K
384 3 4 4 6 K
384 2 4 4 6 K
384 3 4 4 5 K
384 2 4 4 5 K
384 2 3 4 4 K
384 4 4 T J Q
384 4 4 9 J Q
384 4 4 8 J Q
384 4 4 7 J Q
384 4 4 6 J Q
384 4 4 5 J Q
384 3 4 4 J Q
384 2 4 4 J Q
384 4 4 9 T Q
384 4 4 8 T Q
384 4 4 7 T Q
384 4 4 6 T Q
384 4 4 5 T Q
384 3 4 4 T Q
384 2 4 4 T Q
384 4 4 8 9 Q
384 4 4 7 9 Q
384 4 4 6 9 Q
384 4 4 5 9 Q
384 3 4 4 9 Q
384 2 4 4 9 Q
384 4 4 7 8 Q
384 4 4 6 8 Q
384 4 4 5 8 Q
384 3 4 4 8 Q
384 2 4 4 8 Q
384 4 4 6 7 Q
384 4 4 5 7 Q
384 3 4 4 7 Q
384 2 4 4 7 Q
384 4 4 5 6 Q
384 3 4 4 6 Q
384 2 4 4 6 Q
384 3 4 4 5 Q
384 2 4 4 5 Q
384 2 3 4 4 Q
384 4 4 9 T J
384 4 4 8 T J
384 4 4 7 T J
384 4 4 6 T J
384 4 4 5 T J
384 3 4 4 T J
384 2 4 4 T J
384 4 4 8 9 J
384 4 4 7 9 J
384 4 4 6 9 J
384 4 4 5 9 J
384 3 4 4 9 J
384 2 4 4 9 J
384 4 4 7 8 J
384 4 4 6 8 J
384 4 4 5 8 J
384 3 4 4 8 J
384 2 4 4 8 J
384 4 4 6 7 J
384 4 4 5 7 J
384 3 4 4 7 J
384 2 4 4 7 J
384 4 4 5 6 J
384 3 4 4 6 J
384 2 4 4 6 J
384 3 4 4 5 J
384 2 4 4 5 J
384 2 3 4 4 J
384 4 4 8 9 T
384 4 4 7 9 T
384 4 4 6 9 T
384 4 4 5 9 T
384 3 4 4 9 T
384 2 4 4 9 T
384 4 4 7 8 T
384 4 4 6 8 T
384 4 4 5 8 T
384 3 4 4 8 T
384 2 4 4 8 T
384 4 4 6 7 T
384 4 4 5 7 T
384 3 4 4 7 T
384 2 4 4 7 T
384 4 4 5 6 T
384 3 4 4 6 T
384 2 4 4 6 T
384 3 4 4 5 T
384 2 4 4 5 T
384 2 3 4 4 T
384 4 4 7 8 9
384 4 4 6 8 9
384 4 4 5 8 9
384 3 4 4 8 9
384 2 4 4 8 9
384 4 4 6 7 9
384 4 4 5 7 9
384 3 4 4 7 9
384 2 4 4 7 9
384 4 4 5 6 9
384 3 4 4 6 9
384 2 4 4 6 9
384 3 4 4 5 9
384 2 4 4 5 9
384 2 3 4 4 9
384 4 4 6 7 8
384 4 4 5 7 8
384 3 4 4 7 8
384 2 4 4 7 8
384 4 4 5 6 8
384 3 4 4 6 8
384 2 4 4 6 8
384 3 4 4 5 8
384 2 4 4 5 8
384 2 3 4 4 8
384 4 4 5 6 7
384 3 4 4 6 7
384 2 4 4 6 7
384 3 4 4 5 7
384 2 4 4 5 7
384 2 3 4 4 7
384 3 4 4 5 6
384 2 4 4 5 6
384 2 3 4 4 6
384 2 3 4 4 5
384 3 3 Q K A Pair of Treys
384 3 3 J K A
384 3 3 T K A
384 3 3 9 K A
384 3 3 8 K A
384 3 3 7 K A
384 3 3 6 K A
384 3 3 5 K A
384 3 3 4 K A
384 2 3 3 K A
384 3 3 J Q A
384 3 3 T Q A
384 3 3 9 Q A
384 3 3 8 Q A
384 3 3 7 Q A
384 3 3 6 Q A
384 3 3 5 Q A
384 3 3 4 Q A
384 2 3 3 Q A
384 3 3 T J A
384 3 3 9 J A
384 3 3 8 J A
384 3 3 7 J A
384 3 3 6 J A
384 3 3 5 J A
384 3 3 4 J A
384 2 3 3 J A
384 3 3 9 T A
384 3 3 8 T A
384 3 3 7 T A
384 3 3 6 T A
384 3 3 5 T A
384 3 3 4 T A
384 2 3 3 T A
384 3 3 8 9 A
384 3 3 7 9 A
384 3 3 6 9 A
384 3 3 5 9 A
384 3 3 4 9 A
384 2 3 3 9 A
384 3 3 7 8 A
384 3 3 6 8 A
384 3 3 5 8 A
384 3 3 4 8 A
384 2 3 3 8 A
384 3 3 6 7 A
384 3 3 5 7 A
384 3 3 4 7 A
384 2 3 3 7 A
384 3 3 5 6 A
384 3 3 4 6 A
384 2 3 3 6 A
384 3 3 4 5 A
384 2 3 3 5 A
384 2 3 3 4 A
384 3 3 J Q K
384 3 3 T Q K
384 3 3 9 Q K
384 3 3 8 Q K
384 3 3 7 Q K
384 3 3 6 Q K
384 3 3 5 Q K
384 3 3 4 Q K
384 2 3 3 Q K
384 3 3 T J K
384 3 3 9 J K
384 3 3 8 J K
384 3 3 7 J K
384 3 3 6 J K
384 3 3 5 J K
384 3 3 4 J K
384 2 3 3 J K
384 3 3 9 T K
384 3 3 8 T K
384 3 3 7 T K
384 3 3 6 T K
384 3 3 5 T K
384 3 3 4 T K
384 2 3 3 T K
384 3 3 8 9 K
384 3 3 7 9 K
384 3 3 6 9 K
384 3 3 5 9 K
384 3 3 4 9 K
384 2 3 3 9 K
384 3 3 7 8 K
384 3 3 6 8 K
384 3 3 5 8 K
384 3 3 4 8 K
384 2 3 3 8 K
384 3 3 6 7 K
384 3 3 5 7 K
384 3 3 4 7 K
384 2 3 3 7 K
384 3 3 5 6 K
384 3 3 4 6 K
384 2 3 3 6 K
384 3 3 4 5 K
384 2 3 3 5 K
384 2 3 3 4 K
384 3 3 T J Q
384 3 3 9 J Q
384 3 3 8 J Q
384 3 3 7 J Q
384 3 3 6 J Q
384 3 3 5 J Q
384 3 3 4 J Q
384 2 3 3 J Q
384 3 3 9 T Q
384 3 3 8 T Q
384 3 3 7 T Q
384 3 3 6 T Q
384 3 3 5 T Q
384 3 3 4 T Q
384 2 3 3 T Q
384 3 3 8 9 Q
384 3 3 7 9 Q
384 3 3 6 9 Q
384 3 3 5 9 Q
384 3 3 4 9 Q
384 2 3 3 9 Q
384 3 3 7 8 Q
384 3 3 6 8 Q
384 3 3 5 8 Q
384 3 3 4 8 Q
384 2 3 3 8 Q
384 3 3 6 7 Q
384 3 3 5 7 Q
384 3 3 4 7 Q
384 2 3 3 7 Q
384 3 3 5 6 Q
384 3 3 4 6 Q
384 2 3 3 6 Q
384 3 3 4 5 Q
384 2 3 3 5 Q
384 2 3 3 4 Q
384 3 3 9 T J
384 3 3 8 T J
384 3 3 7 T J
384 3 3 6 T J
384 3 3 5 T J
384 3 3 4 T J
384 2 3 3 T J
384 3 3 8 9 J
384 3 3 7 9 J
384 3 3 6 9 J
384 3 3 5 9 J
384 3 3 4 9 J
384 2 3 3 9 J
384 3 3 7 8 J
384 3 3 6 8 J
384 3 3 5 8 J
384 3 3 4 8 J
384 2 3 3 8 J
384 3 3 6 7 J
384 3 3 5 7 J
384 3 3 4 7 J
384 2 3 3 7 J
384 3 3 5 6 J
384 3 3 4 6 J
384 2 3 3 6 J
384 3 3 4 5 J
384 2 3 3 5 J
384 2 3 3 4 J
384 3 3 8 9 T
384 3 3 7 9 T
384 3 3 6 9 T
384 3 3 5 9 T
384 3 3 4 9 T
384 2 3 3 9 T
384 3 3 7 8 T
384 3 3 6 8 T
384 3 3 5 8 T
384 3 3 4 8 T
384 2 3 3 8 T
384 3 3 6 7 T
384 3 3 5 7 T
384 3 3 4 7 T
384 2 3 3 7 T
384 3 3 5 6 T
384 3 3 4 6 T
384 2 3 3 6 T
384 3 3 4 5 T
384 2 3 3 5 T
384 2 3 3 4 T
384 3 3 7 8 9
384 3 3 6 8 9
384 3 3 5 8 9
384 3 3 4 8 9
384 2 3 3 8 9
384 3 3 6 7 9
384 3 3 5 7 9
384 3 3 4 7 9
384 2 3 3 7 9
384 3 3 5 6 9
384 3 3 4 6 9
384 2 3 3 6 9
384 3 3 4 5 9
384 2 3 3 5 9
384 2 3 3 4 9
384 3 3 6 7 8
384 3 3 5 7 8
384 3 3 4 7 8
384 2 3 3 7 8
384 3 3 5 6 8
384 3 3 4 6 8
384 2 3 3 6 8
384 3 3 4 5 8
384 2 3 3 5 8
384 2 3 3 4 8
384 3 3 5 6 7
384 3 3 4 6 7
384 2 3 3 6 7
384 3 3 4 5 7
384 2 3 3 5 7
384 2 3 3 4 7
384 3 3 4 5 6
384 2 3 3 5 6
384 2 3 3 4 6
384 2 3 3 4 5
384 2 2 Q K A Pair of Deuces
384 2 2 J K A
384 2 2 T K A
384 2 2 9 K A
384 2 2 8 K A
384 2 2 7 K A
384 2 2 6 K A
384 2 2 5 K A
384 2 2 4 K A
384 2 2 3 K A
384 2 2 J Q A
384 2 2 T Q A
384 2 2 9 Q A
384 2 2 8 Q A
384 2 2 7 Q A
384 2 2 6 Q A
384 2 2 5 Q A
384 2 2 4 Q A
384 2 2 3 Q A
384 2 2 T J A
384 2 2 9 J A
384 2 2 8 J A
384 2 2 7 J A
384 2 2 6 J A
384 2 2 5 J A
384 2 2 4 J A
384 2 2 3 J A
384 2 2 9 T A
384 2 2 8 T A
384 2 2 7 T A
384 2 2 6 T A
384 2 2 5 T A
384 2 2 4 T A
384 2 2 3 T A
384 2 2 8 9 A
384 2 2 7 9 A
384 2 2 6 9 A
384 2 2 5 9 A
384 2 2 4 9 A
384 2 2 3 9 A
384 2 2 7 8 A
384 2 2 6 8 A
384 2 2 5 8 A
384 2 2 4 8 A
384 2 2 3 8 A
384 2 2 6 7 A
384 2 2 5 7 A
384 2 2 4 7 A
384 2 2 3 7 A
384 2 2 5 6 A
384 2 2 4 6 A
384 2 2 3 6 A
384 2 2 4 5 A
384 2 2 3 5 A
384 2 2 3 4 A
384 2 2 J Q K
384 2 2 T Q K
384 2 2 9 Q K
384 2 2 8 Q K
384 2 2 7 Q K
384 2 2 6 Q K
384 2 2 5 Q K
384 2 2 4 Q K
384 2 2 3 Q K
384 2 2 T J K
384 2 2 9 J K
384 2 2 8 J K
384 2 2 7 J K
384 2 2 6 J K
384 2 2 5 J K
384 2 2 4 J K
384 2 2 3 J K
384 2 2 9 T K
384 2 2 8 T K
384 2 2 7 T K
384 2 2 6 T K
384 2 2 5 T K
384 2 2 4 T K
384 2 2 3 T K
384 2 2 8 9 K
384 2 2 7 9 K
384 2 2 6 9 K
384 2 2 5 9 K
384 2 2 4 9 K
384 2 2 3 9 K
384 2 2 7 8 K
384 2 2 6 8 K
384 2 2 5 8 K
384 2 2 4 8 K
384 2 2 3 8 K
384 2 2 6 7 K
384 2 2 5 7 K
384 2 2 4 7 K
384 2 2 3 7 K
384 2 2 5 6 K
384 2 2 4 6 K
384 2 2 3 6 K
384 2 2 4 5 K
384 2 2 3 5 K
384 2 2 3 4 K
384 2 2 T J Q
384 2 2 9 J Q
384 2 2 8 J Q
384 2 2 7 J Q
384 2 2 6 J Q
384 2 2 5 J Q
384 2 2 4 J Q
384 2 2 3 J Q
384 2 2 9 T Q
384 2 2 8 T Q
384 2 2 7 T Q
384 2 2 6 T Q
384 2 2 5 T Q
384 2 2 4 T Q
384 2 2 3 T Q
384 2 2 8 9 Q
384 2 2 7 9 Q
384 2 2 6 9 Q
384 2 2 5 9 Q
384 2 2 4 9 Q
384 2 2 3 9 Q
384 2 2 7 8 Q
384 2 2 6 8 Q
384 2 2 5 8 Q
384 2 2 4 8 Q
384 2 2 3 8 Q
384 2 2 6 7 Q
384 2 2 5 7 Q
384 2 2 4 7 Q
384 2 2 3 7 Q
384 2 2 5 6 Q
384 2 2 4 6 Q
384 2 2 3 6 Q
384 2 2 4 5 Q
384 2 2 3 5 Q
384 2 2 3 4 Q
384 2 2 9 T J
384 2 2 8 T J
384 2 2 7 T J
384 2 2 6 T J
384 2 2 5 T J
384 2 2 4 T J
384 2 2 3 T J
384 2 2 8 9 J
384 2 2 7 9 J
384 2 2 6 9 J
384 2 2 5 9 J
384 2 2 4 9 J
384 2 2 3 9 J
384 2 2 7 8 J
384 2 2 6 8 J
384 2 2 5 8 J
384 2 2 4 8 J
384 2 2 3 8 J
384 2 2 6 7 J
384 2 2 5 7 J
384 2 2 4 7 J
384 2 2 3 7 J
384 2 2 5 6 J
384 2 2 4 6 J
384 2 2 3 6 J
384 2 2 4 5 J
384 2 2 3 5 J
384 2 2 3 4 J
384 2 2 8 9 T
384 2 2 7 9 T
384 2 2 6 9 T
384 2 2 5 9 T
384 2 2 4 9 T
384 2 2 3 9 T
384 2 2 7 8 T
384 2 2 6 8 T
384 2 2 5 8 T
384 2 2 4 8 T
384 2 2 3 8 T
384 2 2 6 7 T
384 2 2 5 7 T
384 2 2 4 7 T
384 2 2 3 7 T
384 2 2 5 6 T
384 2 2 4 6 T
384 2 2 3 6 T
384 2 2 4 5 T
384 2 2 3 5 T
384 2 2 3 4 T
384 2 2 7 8 9
384 2 2 6 8 9
384 2 2 5 8 9
384 2 2 4 8 9
384 2 2 3 8 9
384 2 2 6 7 9
384 2 2 5 7 9
384 2 2 4 7 9
384 2 2 3 7 9
384 2 2 5 6 9
384 2 2 4 6 9
384 2 2 3 6 9
384 2 2 4 5 9
384 2 2 3 5 9
384 2 2 3 4 9
384 2 2 6 7 8
384 2 2 5 7 8
384 2 2 4 7 8
384 2 2 3 7 8
384 2 2 5 6 8
384 2 2 4 6 8
384 2 2 3 6 8
384 2 2 4 5 8
384 2 2 3 5 8
384 2 2 3 4 8
384 2 2 5 6 7
384 2 2 4 6 7
384 2 2 3 6 7
384 2 2 4 5 7
384 2 2 3 5 7
384 2 2 3 4 7
384 2 2 4 5 6
384 2 2 3 5 6
384 2 2 3 4 6
384 2 2 3 4 5
1024 9 J Q K A Ace High HIGH CARD
1024 8 J Q K A
1024 7 J Q K A
1024 6 J Q K A
1024 5 J Q K A
1024 4 J Q K A
1024 3 J Q K A
1024 2 J Q K A
1024 9 T Q K A
1024 8 T Q K A
1024 7 T Q K A
1024 6 T Q K A
1024 5 T Q K A
1024 4 T Q K A
1024 3 T Q K A
1024 2 T Q K A
1024 8 9 Q K A
1024 7 9 Q K A
1024 6 9 Q K A
1024 5 9 Q K A
1024 4 9 Q K A
1024 3 9 Q K A
1024 2 9 Q K A
1024 7 8 Q K A
1024 6 8 Q K A
1024 5 8 Q K A
1024 4 8 Q K A
1024 3 8 Q K A
1024 2 8 Q K A
1024 6 7 Q K A
1024 5 7 Q K A
1024 4 7 Q K A
1024 3 7 Q K A
1024 2 7 Q K A
1024 5 6 Q K A
1024 4 6 Q K A
1024 3 6 Q K A
1024 2 6 Q K A
1024 4 5 Q K A
1024 3 5 Q K A
1024 2 5 Q K A
1024 3 4 Q K A
1024 2 4 Q K A
1024 2 3 Q K A
1024 9 T J K A
1024 8 T J K A
1024 7 T J K A
1024 6 T J K A
1024 5 T J K A
1024 4 T J K A
1024 3 T J K A
1024 2 T J K A
1024 8 9 J K A
1024 7 9 J K A
1024 6 9 J K A
1024 5 9 J K A
1024 4 9 J K A
1024 3 9 J K A
1024 2 9 J K A
1024 7 8 J K A
1024 6 8 J K A
1024 5 8 J K A
1024 4 8 J K A
1024 3 8 J K A
1024 2 8 J K A
1024 6 7 J K A
1024 5 7 J K A
1024 4 7 J K A
1024 3 7 J K A
1024 2 7 J K A
1024 5 6 J K A
1024 4 6 J K A
1024 3 6 J K A
1024 2 6 J K A
1024 4 5 J K A
1024 3 5 J K A
1024 2 5 J K A
1024 3 4 J K A
1024 2 4 J K A
1024 2 3 J K A
1024 8 9 T K A
1024 7 9 T K A
1024 6 9 T K A
1024 5 9 T K A
1024 4 9 T K A
1024 3 9 T K A
1024 2 9 T K A
1024 7 8 T K A
1024 6 8 T K A
1024 5 8 T K A
1024 4 8 T K A
1024 3 8 T K A
1024 2 8 T K A
1024 6 7 T K A
1024 5 7 T K A
1024 4 7 T K A
1024 3 7 T K A
1024 2 7 T K A
1024 5 6 T K A
1024 4 6 T K A
1024 3 6 T K A
1024 2 6 T K A
1024 4 5 T K A
1024 3 5 T K A
1024 2 5 T K A
1024 3 4 T K A
1024 2 4 T K A
1024 2 3 T K A
1024 7 8 9 K A
1024 6 8 9 K A
1024 5 8 9 K A
1024 4 8 9 K A
1024 3 8 9 K A
1024 2 8 9 K A
1024 6 7 9 K A
1024 5 7 9 K A
1024 4 7 9 K A
1024 3 7 9 K A
1024 2 7 9 K A
1024 5 6 9 K A
1024 4 6 9 K A
1024 3 6 9 K A
1024 2 6 9 K A
1024 4 5 9 K A
1024 3 5 9 K A
1024 2 5 9 K A
1024 3 4 9 K A
1024 2 4 9 K A
1024 2 3 9 K A
1024 6 7 8 K A
1024 5 7 8 K A
1024 4 7 8 K A
1024 3 7 8 K A
1024 2 7 8 K A
1024 5 6 8 K A
1024 4 6 8 K A
1024 3 6 8 K A
1024 2 6 8 K A
1024 4 5 8 K A
1024 3 5 8 K A
1024 2 5 8 K A
1024 3 4 8 K A
1024 2 4 8 K A
1024 2 3 8 K A
1024 5 6 7 K A
1024 4 6 7 K A
1024 3 6 7 K A
1024 2 6 7 K A
1024 4 5 7 K A
1024 3 5 7 K A
1024 2 5 7 K A
1024 3 4 7 K A
1024 2 4 7 K A
1024 2 3 7 K A
1024 4 5 6 K A
1024 3 5 6 K A
1024 2 5 6 K A
1024 3 4 6 K A
1024 2 4 6 K A
1024 2 3 6 K A
1024 3 4 5 K A
1024 2 4 5 K A
1024 2 3 5 K A
1024 2 3 4 K A
1024 9 T J Q A
1024 8 T J Q A
1024 7 T J Q A
1024 6 T J Q A
1024 5 T J Q A
1024 4 T J Q A
1024 3 T J Q A
1024 2 T J Q A
1024 8 9 J Q A
1024 7 9 J Q A
1024 6 9 J Q A
1024 5 9 J Q A
1024 4 9 J Q A
1024 3 9 J Q A
1024 2 9 J Q A
1024 7 8 J Q A
1024 6 8 J Q A
1024 5 8 J Q A
1024 4 8 J Q A
1024 3 8 J Q A
1024 2 8 J Q A
1024 6 7 J Q A
1024 5 7 J Q A
1024 4 7 J Q A
1024 3 7 J Q A
1024 2 7 J Q A
1024 5 6 J Q A
1024 4 6 J Q A
1024 3 6 J Q A
1024 2 6 J Q A
1024 4 5 J Q A
1024 3 5 J Q A
1024 2 5 J Q A
1024 3 4 J Q A
1024 2 4 J Q A
1024 2 3 J Q A
1024 8 9 T Q A
1024 7 9 T Q A
1024 6 9 T Q A
1024 5 9 T Q A
1024 4 9 T Q A
1024 3 9 T Q A
1024 2 9 T Q A
1024 7 8 T Q A
1024 6 8 T Q A
1024 5 8 T Q A
1024 4 8 T Q A
1024 3 8 T Q A
1024 2 8 T Q A
1024 6 7 T Q A
1024 5 7 T Q A
1024 4 7 T Q A
1024 3 7 T Q A
1024 2 7 T Q A
1024 5 6 T Q A
1024 4 6 T Q A
1024 3 6 T Q A
1024 2 6 T Q A
1024 4 5 T Q A
1024 3 5 T Q A
1024 2 5 T Q A
1024 3 4 T Q A
1024 2 4 T Q A
1024 2 3 T Q A
1024 7 8 9 Q A
1024 6 8 9 Q A
1024 5 8 9 Q A
1024 4 8 9 Q A
1024 3 8 9 Q A
1024 2 8 9 Q A
1024 6 7 9 Q A
1024 5 7 9 Q A
1024 4 7 9 Q A
1024 3 7 9 Q A
1024 2 7 9 Q A
1024 5 6 9 Q A
1024 4 6 9 Q A
1024 3 6 9 Q A
1024 2 6 9 Q A
1024 4 5 9 Q A
1024 3 5 9 Q A
1024 2 5 9 Q A
1024 3 4 9 Q A
1024 2 4 9 Q A
1024 2 3 9 Q A
1024 6 7 8 Q A
1024 5 7 8 Q A
1024 4 7 8 Q A
1024 3 7 8 Q A
1024 2 7 8 Q A
1024 5 6 8 Q A
1024 4 6 8 Q A
1024 3 6 8 Q A
1024 2 6 8 Q A
1024 4 5 8 Q A
1024 3 5 8 Q A
1024 2 5 8 Q A
1024 3 4 8 Q A
1024 2 4 8 Q A
1024 2 3 8 Q A
1024 5 6 7 Q A
1024 4 6 7 Q A
1024 3 6 7 Q A
1024 2 6 7 Q A
1024 4 5 7 Q A
1024 3 5 7 Q A
1024 2 5 7 Q A
1024 3 4 7 Q A
1024 2 4 7 Q A
1024 2 3 7 Q A
1024 4 5 6 Q A
1024 3 5 6 Q A
1024 2 5 6 Q A
1024 3 4 6 Q A
1024 2 4 6 Q A
1024 2 3 6 Q A
1024 3 4 5 Q A
1024 2 4 5 Q A
1024 2 3 5 Q A
1024 2 3 4 Q A
1024 8 9 T J A
1024 7 9 T J A
1024 6 9 T J A
1024 5 9 T J A
1024 4 9 T J A
1024 3 9 T J A
1024 2 9 T J A
1024 7 8 T J A
1024 6 8 T J A
1024 5 8 T J A
1024 4 8 T J A
1024 3 8 T J A
1024 2 8 T J A
1024 6 7 T J A
1024 5 7 T J A
1024 4 7 T J A
1024 3 7 T J A
1024 2 7 T J A
1024 5 6 T J A
1024 4 6 T J A
1024 3 6 T J A
1024 2 6 T J A
1024 4 5 T J A
1024 3 5 T J A
1024 2 5 T J A
1024 3 4 T J A
1024 2 4 T J A
1024 2 3 T J A
1024 7 8 9 J A
1024 6 8 9 J A
1024 5 8 9 J A
1024 4 8 9 J A
1024 3 8 9 J A
1024 2 8 9 J A
1024 6 7 9 J A
1024 5 7 9 J A
1024 4 7 9 J A
1024 3 7 9 J A
1024 2 7 9 J A
1024 5 6 9 J A
1024 4 6 9 J A
1024 3 6 9 J A
1024 2 6 9 J A
1024 4 5 9 J A
1024 3 5 9 J A
1024 2 5 9 J A
1024 3 4 9 J A
1024 2 4 9 J A
1024 2 3 9 J A
1024 6 7 8 J A
1024 5 7 8 J A
1024 4 7 8 J A
1024 3 7 8 J A
1024 2 7 8 J A
1024 5 6 8 J A
1024 4 6 8 J A
1024 3 6 8 J A
1024 2 6 8 J A
1024 4 5 8 J A
1024 3 5 8 J A
1024 2 5 8 J A
1024 3 4 8 J A
1024 2 4 8 J A
1024 2 3 8 J A
1024 5 6 7 J A
1024 4 6 7 J A
1024 3 6 7 J A
1024 2 6 7 J A
1024 4 5 7 J A
1024 3 5 7 J A
1024 2 5 7 J A
1024 3 4 7 J A
1024 2 4 7 J A
1024 2 3 7 J A
1024 4 5 6 J A
1024 3 5 6 J A
1024 2 5 6 J A
1024 3 4 6 J A
1024 2 4 6 J A
1024 2 3 6 J A
1024 3 4 5 J A
1024 2 4 5 J A
1024 2 3 5 J A
1024 2 3 4 J A
1024 7 8 9 T A
1024 6 8 9 T A
1024 5 8 9 T A
1024 4 8 9 T A
1024 3 8 9 T A
1024 2 8 9 T A
1024 6 7 9 T A
1024 5 7 9 T A
1024 4 7 9 T A
1024 3 7 9 T A
1024 2 7 9 T A
1024 5 6 9 T A
1024 4 6 9 T A
1024 3 6 9 T A
1024 2 6 9 T A
1024 4 5 9 T A
1024 3 5 9 T A
1024 2 5 9 T A
1024 3 4 9 T A
1024 2 4 9 T A
1024 2 3 9 T A
1024 6 7 8 T A
1024 5 7 8 T A
1024 4 7 8 T A
1024 3 7 8 T A
1024 2 7 8 T A
1024 5 6 8 T A
1024 4 6 8 T A
1024 3 6 8 T A
1024 2 6 8 T A
1024 4 5 8 T A
1024 3 5 8 T A
1024 2 5 8 T A
1024 3 4 8 T A
1024 2 4 8 T A
1024 2 3 8 T A
1024 5 6 7 T A
1024 4 6 7 T A
1024 3 6 7 T A
1024 2 6 7 T A
1024 4 5 7 T A
1024 3 5 7 T A
1024 2 5 7 T A
1024 3 4 7 T A
1024 2 4 7 T A
1024 2 3 7 T A
1024 4 5 6 T A
1024 3 5 6 T A
1024 2 5 6 T A
1024 3 4 6 T A
1024 2 4 6 T A
1024 2 3 6 T A
1024 3 4 5 T A
1024 2 4 5 T A
1024 2 3 5 T A
1024 2 3 4 T A
1024 6 7 8 9 A
1024 5 7 8 9 A
1024 4 7 8 9 A
1024 3 7 8 9 A
1024 2 7 8 9 A
1024 5 6 8 9 A
1024 4 6 8 9 A
1024 3 6 8 9 A
1024 2 6 8 9 A
1024 4 5 8 9 A
1024 3 5 8 9 A
1024 2 5 8 9 A
1024 3 4 8 9 A
1024 2 4 8 9 A
1024 2 3 8 9 A
1024 5 6 7 9 A
1024 4 6 7 9 A
1024 3 6 7 9 A
1024 2 6 7 9 A
1024 4 5 7 9 A
1024 3 5 7 9 A
1024 2 5 7 9 A
1024 3 4 7 9 A
1024 2 4 7 9 A
1024 2 3 7 9 A
1024 4 5 6 9 A
1024 3 5 6 9 A
1024 2 5 6 9 A
1024 3 4 6 9 A
1024 2 4 6 9 A
1024 2 3 6 9 A
1024 3 4 5 9 A
1024 2 4 5 9 A
1024 2 3 5 9 A
1024 2 3 4 9 A
1024 5 6 7 8 A
1024 4 6 7 8 A
1024 3 6 7 8 A
1024 2 6 7 8 A
1024 4 5 7 8 A
1024 3 5 7 8 A
1024 2 5 7 8 A
1024 3 4 7 8 A
1024 2 4 7 8 A
1024 2 3 7 8 A
1024 4 5 6 8 A
1024 3 5 6 8 A
1024 2 5 6 8 A
1024 3 4 6 8 A
1024 2 4 6 8 A
1024 2 3 6 8 A
1024 3 4 5 8 A
1024 2 4 5 8 A
1024 2 3 5 8 A
1024 2 3 4 8 A
1024 4 5 6 7 A
1024 3 5 6 7 A
1024 2 5 6 7 A
1024 3 4 6 7 A
1024 2 4 6 7 A
1024 2 3 6 7 A
1024 3 4 5 7 A
1024 2 4 5 7 A
1024 2 3 5 7 A
1024 2 3 4 7 A
1024 3 4 5 6 A
1024 2 4 5 6 A
1024 2 3 5 6 A
1024 2 3 4 6 A
1024 8 T J Q K King High
1024 7 T J Q K
1024 6 T J Q K
1024 5 T J Q K
1024 4 T J Q K
1024 3 T J Q K
1024 2 T J Q K
1024 8 9 J Q K
1024 7 9 J Q K
1024 6 9 J Q K
1024 5 9 J Q K
1024 4 9 J Q K
1024 3 9 J Q K
1024 2 9 J Q K
1024 7 8 J Q K
1024 6 8 J Q K
1024 5 8 J Q K
1024 4 8 J Q K
1024 3 8 J Q K
1024 2 8 J Q K
1024 6 7 J Q K
1024 5 7 J Q K
1024 4 7 J Q K
1024 3 7 J Q K
1024 2 7 J Q K
1024 5 6 J Q K
1024 4 6 J Q K
1024 3 6 J Q K
1024 2 6 J Q K
1024 4 5 J Q K
1024 3 5 J Q K
1024 2 5 J Q K
1024 3 4 J Q K
1024 2 4 J Q K
1024 2 3 J Q K
1024 8 9 T Q K
1024 7 9 T Q K
1024 6 9 T Q K
1024 5 9 T Q K
1024 4 9 T Q K
1024 3 9 T Q K
1024 2 9 T Q K
1024 7 8 T Q K
1024 6 8 T Q K
1024 5 8 T Q K
1024 4 8 T Q K
1024 3 8 T Q K
1024 2 8 T Q K
1024 6 7 T Q K
1024 5 7 T Q K
1024 4 7 T Q K
1024 3 7 T Q K
1024 2 7 T Q K
1024 5 6 T Q K
1024 4 6 T Q K
1024 3 6 T Q K
1024 2 6 T Q K
1024 4 5 T Q K
1024 3 5 T Q K
1024 2 5 T Q K
1024 3 4 T Q K
1024 2 4 T Q K
1024 2 3 T Q K
1024 7 8 9 Q K
1024 6 8 9 Q K
1024 5 8 9 Q K
1024 4 8 9 Q K
1024 3 8 9 Q K
1024 2 8 9 Q K
1024 6 7 9 Q K
1024 5 7 9 Q K
1024 4 7 9 Q K
1024 3 7 9 Q K
1024 2 7 9 Q K
1024 5 6 9 Q K
1024 4 6 9 Q K
1024 3 6 9 Q K
1024 2 6 9 Q K
1024 4 5 9 Q K
1024 3 5 9 Q K
1024 2 5 9 Q K
1024 3 4 9 Q K
1024 2 4 9 Q K
1024 2 3 9 Q K
1024 6 7 8 Q K
1024 5 7 8 Q K
1024 4 7 8 Q K
1024 3 7 8 Q K
1024 2 7 8 Q K
1024 5 6 8 Q K
1024 4 6 8 Q K
1024 3 6 8 Q K
1024 2 6 8 Q K
1024 4 5 8 Q K
1024 3 5 8 Q K
1024 2 5 8 Q K
1024 3 4 8 Q K
1024 2 4 8 Q K
1024 2 3 8 Q K
1024 5 6 7 Q K
1024 4 6 7 Q K
1024 3 6 7 Q K
1024 2 6 7 Q K
1024 4 5 7 Q K
1024 3 5 7 Q K
1024 2 5 7 Q K
1024 3 4 7 Q K
1024 2 4 7 Q K
1024 2 3 7 Q K
1024 4 5 6 Q K
1024 3 5 6 Q K
1024 2 5 6 Q K
1024 3 4 6 Q K
1024 2 4 6 Q K
1024 2 3 6 Q K
1024 3 4 5 Q K
1024 2 4 5 Q K
1024 2 3 5 Q K
1024 2 3 4 Q K
1024 8 9 T J K
1024 7 9 T J K
1024 6 9 T J K
1024 5 9 T J K
1024 4 9 T J K
1024 3 9 T J K
1024 2 9 T J K
1024 7 8 T J K
1024 6 8 T J K
1024 5 8 T J K
1024 4 8 T J K
1024 3 8 T J K
1024 2 8 T J K
1024 6 7 T J K
1024 5 7 T J K
1024 4 7 T J K
1024 3 7 T J K
1024 2 7 T J K
1024 5 6 T J K
1024 4 6 T J K
1024 3 6 T J K
1024 2 6 T J K
1024 4 5 T J K
1024 3 5 T J K
1024 2 5 T J K
1024 3 4 T J K
1024 2 4 T J K
1024 2 3 T J K
1024 7 8 9 J K
1024 6 8 9 J K
1024 5 8 9 J K
1024 4 8 9 J K
1024 3 8 9 J K
1024 2 8 9 J K
1024 6 7 9 J K
1024 5 7 9 J K
1024 4 7 9 J K
1024 3 7 9 J K
1024 2 7 9 J K
1024 5 6 9 J K
1024 4 6 9 J K
1024 3 6 9 J K
1024 2 6 9 J K
1024 4 5 9 J K
1024 3 5 9 J K
1024 2 5 9 J K
1024 3 4 9 J K
1024 2 4 9 J K
1024 2 3 9 J K
1024 6 7 8 J K
1024 5 7 8 J K
1024 4 7 8 J K
1024 3 7 8 J K
1024 2 7 8 J K
1024 5 6 8 J K
1024 4 6 8 J K
1024 3 6 8 J K
1024 2 6 8 J K
1024 4 5 8 J K
1024 3 5 8 J K
1024 2 5 8 J K
1024 3 4 8 J K
1024 2 4 8 J K
1024 2 3 8 J K
1024 5 6 7 J K
1024 4 6 7 J K
1024 3 6 7 J K
1024 2 6 7 J K
1024 4 5 7 J K
1024 3 5 7 J K
1024 2 5 7 J K
1024 3 4 7 J K
1024 2 4 7 J K
1024 2 3 7 J K
1024 4 5 6 J K
1024 3 5 6 J K
1024 2 5 6 J K
1024 3 4 6 J K
1024 2 4 6 J K
1024 2 3 6 J K
1024 3 4 5 J K
1024 2 4 5 J K
1024 2 3 5 J K
1024 2 3 4 J K
1024 7 8 9 T K
1024 6 8 9 T K
1024 5 8 9 T K
1024 4 8 9 T K
1024 3 8 9 T K
1024 2 8 9 T K
1024 6 7 9 T K
1024 5 7 9 T K
1024 4 7 9 T K
1024 3 7 9 T K
1024 2 7 9 T K
1024 5 6 9 T K
1024 4 6 9 T K
1024 3 6 9 T K
1024 2 6 9 T K
1024 4 5 9 T K
1024 3 5 9 T K
1024 2 5 9 T K
1024 3 4 9 T K
1024 2 4 9 T K
1024 2 3 9 T K
1024 6 7 8 T K
1024 5 7 8 T K
1024 4 7 8 T K
1024 3 7 8 T K
1024 2 7 8 T K
1024 5 6 8 T K
1024 4 6 8 T K
1024 3 6 8 T K
1024 2 6 8 T K
1024 4 5 8 T K
1024 3 5 8 T K
1024 2 5 8 T K
1024 3 4 8 T K
1024 2 4 8 T K
1024 2 3 8 T K
1024 5 6 7 T K
1024 4 6 7 T K
1024 3 6 7 T K
1024 2 6 7 T K
1024 4 5 7 T K
1024 3 5 7 T K
1024 2 5 7 T K
1024 3 4 7 T K
1024 2 4 7 T K
1024 2 3 7 T K
1024 4 5 6 T K
1024 3 5 6 T K
1024 2 5 6 T K
1024 3 4 6 T K
1024 2 4 6 T K
1024 2 3 6 T K
1024 3 4 5 T K
1024 2 4 5 T K
1024 2 3 5 T K
1024 2 3 4 T K
1024 6 7 8 9 K
1024 5 7 8 9 K
1024 4 7 8 9 K
1024 3 7 8 9 K
1024 2 7 8 9 K
1024 5 6 8 9 K
1024 4 6 8 9 K
1024 3 6 8 9 K
1024 2 6 8 9 K
1024 4 5 8 9 K
1024 3 5 8 9 K
1024 2 5 8 9 K
1024 3 4 8 9 K
1024 2 4 8 9 K
1024 2 3 8 9 K
1024 5 6 7 9 K
1024 4 6 7 9 K
1024 3 6 7 9 K
1024 2 6 7 9 K
1024 4 5 7 9 K
1024 3 5 7 9 K
1024 2 5 7 9 K
1024 3 4 7 9 K
1024 2 4 7 9 K
1024 2 3 7 9 K
1024 4 5 6 9 K
1024 3 5 6 9 K
1024 2 5 6 9 K
1024 3 4 6 9 K
1024 2 4 6 9 K
1024 2 3 6 9 K
1024 3 4 5 9 K
1024 2 4 5 9 K
1024 2 3 5 9 K
1024 2 3 4 9 K
1024 5 6 7 8 K
1024 4 6 7 8 K
1024 3 6 7 8 K
1024 2 6 7 8 K
1024 4 5 7 8 K
1024 3 5 7 8 K
1024 2 5 7 8 K
1024 3 4 7 8 K
1024 2 4 7 8 K
1024 2 3 7 8 K
1024 4 5 6 8 K
1024 3 5 6 8 K
1024 2 5 6 8 K
1024 3 4 6 8 K
1024 2 4 6 8 K
1024 2 3 6 8 K
1024 3 4 5 8 K
1024 2 4 5 8 K
1024 2 3 5 8 K
1024 2 3 4 8 K
1024 4 5 6 7 K
1024 3 5 6 7 K
1024 2 5 6 7 K
1024 3 4 6 7 K
1024 2 4 6 7 K
1024 2 3 6 7 K
1024 3 4 5 7 K
1024 2 4 5 7 K
1024 2 3 5 7 K
1024 2 3 4 7 K
1024 3 4 5 6 K
1024 2 4 5 6 K
1024 2 3 5 6 K
1024 2 3 4 6 K
1024 2 3 4 5 K
1024 7 9 T J Q Queen High
1024 6 9 T J Q
1024 5 9 T J Q
1024 4 9 T J Q
1024 3 9 T J Q
1024 2 9 T J Q
1024 7 8 T J Q
1024 6 8 T J Q
1024 5 8 T J Q
1024 4 8 T J Q
1024 3 8 T J Q
1024 2 8 T J Q
1024 6 7 T J Q
1024 5 7 T J Q
1024 4 7 T J Q
1024 3 7 T J Q
1024 2 7 T J Q
1024 5 6 T J Q
1024 4 6 T J Q
1024 3 6 T J Q
1024 2 6 T J Q
1024 4 5 T J Q
1024 3 5 T J Q
1024 2 5 T J Q
1024 3 4 T J Q
1024 2 4 T J Q
1024 2 3 T J Q
1024 7 8 9 J Q
1024 6 8 9 J Q
1024 5 8 9 J Q
1024 4 8 9 J Q
1024 3 8 9 J Q
1024 2 8 9 J Q
1024 6 7 9 J Q
1024 5 7 9 J Q
1024 4 7 9 J Q
1024 3 7 9 J Q
1024 2 7 9 J Q
1024 5 6 9 J Q
1024 4 6 9 J Q
1024 3 6 9 J Q
1024 2 6 9 J Q
1024 4 5 9 J Q
1024 3 5 9 J Q
1024 2 5 9 J Q
1024 3 4 9 J Q
1024 2 4 9 J Q
1024 2 3 9 J Q
1024 6 7 8 J Q
1024 5 7 8 J Q
1024 4 7 8 J Q
1024 3 7 8 J Q
1024 2 7 8 J Q
1024 5 6 8 J Q
1024 4 6 8 J Q
1024 3 6 8 J Q
1024 2 6 8 J Q
1024 4 5 8 J Q
1024 3 5 8 J Q
1024 2 5 8 J Q
1024 3 4 8 J Q
1024 2 4 8 J Q
1024 2 3 8 J Q
1024 5 6 7 J Q
1024 4 6 7 J Q
1024 3 6 7 J Q
1024 2 6 7 J Q
1024 4 5 7 J Q
1024 3 5 7 J Q
1024 2 5 7 J Q
1024 3 4 7 J Q
1024 2 4 7 J Q
1024 2 3 7 J Q
1024 4 5 6 J Q
1024 3 5 6 J Q
1024 2 5 6 J Q
1024 3 4 6 J Q
1024 2 4 6 J Q
1024 2 3 6 J Q
1024 3 4 5 J Q
1024 2 4 5 J Q
1024 2 3 5 J Q
1024 2 3 4 J Q
1024 7 8 9 T Q
1024 6 8 9 T Q
1024 5 8 9 T Q
1024 4 8 9 T Q
1024 3 8 9 T Q
1024 2 8 9 T Q
1024 6 7 9 T Q
1024 5 7 9 T Q
1024 4 7 9 T Q
1024 3 7 9 T Q
1024 2 7 9 T Q
1024 5 6 9 T Q
1024 4 6 9 T Q
1024 3 6 9 T Q
1024 2 6 9 T Q
1024 4 5 9 T Q
1024 3 5 9 T Q
1024 2 5 9 T Q
1024 3 4 9 T Q
1024 2 4 9 T Q
1024 2 3 9 T Q
1024 6 7 8 T Q
1024 5 7 8 T Q
1024 4 7 8 T Q
1024 3 7 8 T Q
1024 2 7 8 T Q
1024 5 6 8 T Q
1024 4 6 8 T Q
1024 3 6 8 T Q
1024 2 6 8 T Q
1024 4 5 8 T Q
1024 3 5 8 T Q
1024 2 5 8 T Q
1024 3 4 8 T Q
1024 2 4 8 T Q
1024 2 3 8 T Q
1024 5 6 7 T Q
1024 4 6 7 T Q
1024 3 6 7 T Q
1024 2 6 7 T Q
1024 4 5 7 T Q
1024 3 5 7 T Q
1024 2 5 7 T Q
1024 3 4 7 T Q
1024 2 4 7 T Q
1024 2 3 7 T Q
1024 4 5 6 T Q
1024 3 5 6 T Q
1024 2 5 6 T Q
1024 3 4 6 T Q
1024 2 4 6 T Q
1024 2 3 6 T Q
1024 3 4 5 T Q
1024 2 4 5 T Q
1024 2 3 5 T Q
1024 2 3 4 T Q
1024 6 7 8 9 Q
1024 5 7 8 9 Q
1024 4 7 8 9 Q
1024 3 7 8 9 Q
1024 2 7 8 9 Q
1024 5 6 8 9 Q
1024 4 6 8 9 Q
1024 3 6 8 9 Q
1024 2 6 8 9 Q
1024 4 5 8 9 Q
1024 3 5 8 9 Q
1024 2 5 8 9 Q
1024 3 4 8 9 Q
1024 2 4 8 9 Q
1024 2 3 8 9 Q
1024 5 6 7 9 Q
1024 4 6 7 9 Q
1024 3 6 7 9 Q
1024 2 6 7 9 Q
1024 4 5 7 9 Q
1024 3 5 7 9 Q
1024 2 5 7 9 Q
1024 3 4 7 9 Q
1024 2 4 7 9 Q
1024 2 3 7 9 Q
1024 4 5 6 9 Q
1024 3 5 6 9 Q
1024 2 5 6 9 Q
1024 3 4 6 9 Q
1024 2 4 6 9 Q
1024 2 3 6 9 Q
1024 3 4 5 9 Q
1024 2 4 5 9 Q
1024 2 3 5 9 Q
1024 2 3 4 9 Q
1024 5 6 7 8 Q
1024 4 6 7 8 Q
1024 3 6 7 8 Q
1024 2 6 7 8 Q
1024 4 5 7 8 Q
1024 3 5 7 8 Q
1024 2 5 7 8 Q
1024 3 4 7 8 Q
1024 2 4 7 8 Q
1024 2 3 7 8 Q
1024 4 5 6 8 Q
1024 3 5 6 8 Q
1024 2 5 6 8 Q
1024 3 4 6 8 Q
1024 2 4 6 8 Q
1024 2 3 6 8 Q
1024 3 4 5 8 Q
1024 2 4 5 8 Q
1024 2 3 5 8 Q
1024 2 3 4 8 Q
1024 4 5 6 7 Q
1024 3 5 6 7 Q
1024 2 5 6 7 Q
1024 3 4 6 7 Q
1024 2 4 6 7 Q
1024 2 3 6 7 Q
1024 3 4 5 7 Q
1024 2 4 5 7 Q
1024 2 3 5 7 Q
1024 2 3 4 7 Q
1024 3 4 5 6 Q
1024 2 4 5 6 Q
1024 2 3 5 6 Q
1024 2 3 4 6 Q
1024 2 3 4 5 Q
1024 6 8 9 T J Jack High
1024 5 8 9 T J
1024 4 8 9 T J
1024 3 8 9 T J
1024 2 8 9 T J
1024 6 7 9 T J
1024 5 7 9 T J
1024 4 7 9 T J
1024 3 7 9 T J
1024 2 7 9 T J
1024 5 6 9 T J
1024 4 6 9 T J
1024 3 6 9 T J
1024 2 6 9 T J
1024 4 5 9 T J
1024 3 5 9 T J
1024 2 5 9 T J
1024 3 4 9 T J
1024 2 4 9 T J
1024 2 3 9 T J
1024 6 7 8 T J
1024 5 7 8 T J
1024 4 7 8 T J
1024 3 7 8 T J
1024 2 7 8 T J
1024 5 6 8 T J
1024 4 6 8 T J
1024 3 6 8 T J
1024 2 6 8 T J
1024 4 5 8 T J
1024 3 5 8 T J
1024 2 5 8 T J
1024 3 4 8 T J
1024 2 4 8 T J
1024 2 3 8 T J
1024 5 6 7 T J
1024 4 6 7 T J
1024 3 6 7 T J
1024 2 6 7 T J
1024 4 5 7 T J
1024 3 5 7 T J
1024 2 5 7 T J
1024 3 4 7 T J
1024 2 4 7 T J
1024 2 3 7 T J
1024 4 5 6 T J
1024 3 5 6 T J
1024 2 5 6 T J
1024 3 4 6 T J
1024 2 4 6 T J
1024 2 3 6 T J
1024 3 4 5 T J
1024 2 4 5 T J
1024 2 3 5 T J
1024 2 3 4 T J
1024 6 7 8 9 J
1024 5 7 8 9 J
1024 4 7 8 9 J
1024 3 7 8 9 J
1024 2 7 8 9 J
1024 5 6 8 9 J
1024 4 6 8 9 J
1024 3 6 8 9 J
1024 2 6 8 9 J
1024 4 5 8 9 J
1024 3 5 8 9 J
1024 2 5 8 9 J
1024 3 4 8 9 J
1024 2 4 8 9 J
1024 2 3 8 9 J
1024 5 6 7 9 J
1024 4 6 7 9 J
1024 3 6 7 9 J
1024 2 6 7 9 J
1024 4 5 7 9 J
1024 3 5 7 9 J
1024 2 5 7 9 J
1024 3 4 7 9 J
1024 2 4 7 9 J
1024 2 3 7 9 J
1024 4 5 6 9 J
1024 3 5 6 9 J
1024 2 5 6 9 J
1024 3 4 6 9 J
1024 2 4 6 9 J
1024 2 3 6 9 J
1024 3 4 5 9 J
1024 2 4 5 9 J
1024 2 3 5 9 J
1024 2 3 4 9 J
1024 5 6 7 8 J
1024 4 6 7 8 J
1024 3 6 7 8 J
1024 2 6 7 8 J
1024 4 5 7 8 J
1024 3 5 7 8 J
1024 2 5 7 8 J
1024 3 4 7 8 J
1024 2 4 7 8 J
1024 2 3 7 8 J
1024 4 5 6 8 J
1024 3 5 6 8 J
1024 2 5 6 8 J
1024 3 4 6 8 J
1024 2 4 6 8 J
1024 2 3 6 8 J
1024 3 4 5 8 J
1024 2 4 5 8 J
1024 2 3 5 8 J
1024 2 3 4 8 J
1024 4 5 6 7 J
1024 3 5 6 7 J
1024 2 5 6 7 J
1024 3 4 6 7 J
1024 2 4 6 7 J
1024 2 3 6 7 J
1024 3 4 5 7 J
1024 2 4 5 7 J
1024 2 3 5 7 J
1024 2 3 4 7 J
1024 3 4 5 6 J
1024 2 4 5 6 J
1024 2 3 5 6 J
1024 2 3 4 6 J
1024 2 3 4 5 J
1024 5 7 8 9 T Ten High
1024 4 7 8 9 T
1024 3 7 8 9 T
1024 2 7 8 9 T
1024 5 6 8 9 T
1024 4 6 8 9 T
1024 3 6 8 9 T
1024 2 6 8 9 T
1024 4 5 8 9 T
1024 3 5 8 9 T
1024 2 5 8 9 T
1024 3 4 8 9 T
1024 2 4 8 9 T
1024 2 3 8 9 T
1024 5 6 7 9 T
1024 4 6 7 9 T
1024 3 6 7 9 T
1024 2 6 7 9 T
1024 4 5 7 9 T
1024 3 5 7 9 T
1024 2 5 7 9 T
1024 3 4 7 9 T
1024 2 4 7 9 T
1024 2 3 7 9 T
1024 4 5 6 9 T
1024 3 5 6 9 T
1024 2 5 6 9 T
1024 3 4 6 9 T
1024 2 4 6 9 T
1024 2 3 6 9 T
1024 3 4 5 9 T
1024 2 4 5 9 T
1024 2 3 5 9 T
1024 2 3 4 9 T
1024 5 6 7 8 T
1024 4 6 7 8 T
1024 3 6 7 8 T
1024 2 6 7 8 T
1024 4 5 7 8 T
1024 3 5 7 8 T
1024 2 5 7 8 T
1024 3 4 7 8 T
1024 2 4 7 8 T
1024 2 3 7 8 T
1024 4 5 6 8 T
1024 3 5 6 8 T
1024 2 5 6 8 T
1024 3 4 6 8 T
1024 2 4 6 8 T
1024 2 3 6 8 T
1024 3 4 5 8 T
1024 2 4 5 8 T
1024 2 3 5 8 T
1024 2 3 4 8 T
1024 4 5 6 7 T
1024 3 5 6 7 T
1024 2 5 6 7 T
1024 3 4 6 7 T
1024 2 4 6 7 T
1024 2 3 6 7 T
1024 3 4 5 7 T
1024 2 4 5 7 T
1024 2 3 5 7 T
1024 2 3 4 7 T
1024 3 4 5 6 T
1024 2 4 5 6 T
1024 2 3 5 6 T
1024 2 3 4 6 T
1024 2 3 4 5 T
1024 4 6 7 8 9 Nine High
1024 3 6 7 8 9
1024 2 6 7 8 9
1024 4 5 7 8 9
1024 3 5 7 8 9
1024 2 5 7 8 9
1024 3 4 7 8 9
1024 2 4 7 8 9
1024 2 3 7 8 9
1024 4 5 6 8 9
1024 3 5 6 8 9
1024 2 5 6 8 9
1024 3 4 6 8 9
1024 2 4 6 8 9
1024 2 3 6 8 9
1024 3 4 5 8 9
1024 2 4 5 8 9
1024 2 3 5 8 9
1024 2 3 4 8 9
1024 4 5 6 7 9
1024 3 5 6 7 9
1024 2 5 6 7 9
1024 3 4 6 7 9
1024 2 4 6 7 9
1024 2 3 6 7 9
1024 3 4 5 7 9
1024 2 4 5 7 9
1024 2 3 5 7 9
1024 2 3 4 7 9
1024 3 4 5 6 9
1024 2 4 5 6 9
1024 2 3 5 6 9
1024 2 3 4 6 9
1024 2 3 4 5 9
1024 3 5 6 7 8 Eight High
1024 2 5 6 7 8
1024 3 4 6 7 8
1024 2 4 6 7 8
1024 2 3 6 7 8
1024 3 4 5 7 8
1024 2 4 5 7 8
1024 2 3 5 7 8
1024 2 3 4 7 8
1024 3 4 5 6 8
1024 2 4 5 6 8
1024 2 3 5 6 8
1024 2 3 4 6 8
1024 2 3 4 5 8
1024 2 4 5 6 7 Seven High
1024 2 3 5 6 7
1024 2 3 4 6 7
1024 2 3 4 5 7
================================================
FILE: src/server/algorithm/Pocker Rule.html
================================================
德州扑克流程与规则德州扑克玩法与规则
游戏规则
使用道具
游戏人数
发牌下注
Pre-flop
Flop
Turn
River
比牌
比牌方法
玩法介绍
庄家(Dealer)
盲注(Blinds)
底牌(Hole cards)
第一轮下注(Pre-flop)
翻牌及第二轮下注(Flop)
转牌及第三轮下注(Turn)
河牌及第四轮下注(River)
摊牌和比牌(Showdown)
新手盲注
全押(All-in)
底池(Pot)
主池(Main pot)与边池(Side pot)
参考文档
游戏规则
使用道具
一副标准扑克牌去掉大小王后的52张牌进行游戏
游戏人数
理论上一桌同时最多可容纳22位玩家，一般2-10个玩家
发牌下注
发牌一般分为5个步骤，分别为：
Pre-flop
先下大小盲注，然后给每个玩家发2张底牌，大盲注后面第一个玩家选择跟注、加注或者盖牌放弃，按照顺时针方向，其他玩家依次表态，大盲注玩家最后表态，如果玩家有加注情况，前面已经跟注的玩家需要再次表态甚至多次表态。
Flop
同时发三张公牌，由小盲注开始（如果小盲注已盖牌，由后面最近的玩家开始，以此类推），按照顺时针方向依次表态，玩家可以选择下注、加注、或者盖牌放弃。
Turn
发第4张牌，由小盲注开始，按照顺时针方向依次表态。
River
发第五张牌，由小盲注开始，按照顺时针方向依次表态，玩家可以选择下注、加注、或者盖牌放弃。
比牌
经过前面4轮发牌和下注，剩余的玩家开始亮牌比大小，成牌最大的玩家赢取池底。
比牌方法
用自己的2张底牌和5张公共牌结合在一起，选出5张牌，不论手中的牌使用几张（甚至可以不用手中的底牌），凑成最大的成牌，跟其他玩家比大小。
比牌先比牌型，大的牌型大于小的牌型，牌型一般分为10种，从大到小为：
皇家同花顺（Royal Flush）
同花色的A, K, Q, J和10。
平手牌：在摊牌的时候有两副多副皇家同花顺时，平分筹码。
同花顺（Straight Flush）
五张同花色的连续牌。
平手牌：如果摊牌时有两副或多副同花顺，连续牌的头张牌大的获得筹码。如果是两副或多副相同的连续牌，平分筹码。
四条（Four of a Kind，亦称“铁支”、“四张”或“炸弹”）
其中四张是相同点数但不同花的扑克牌，第五张是随意的一张牌。
平手牌：如果两组或者更多组摊牌，则四张牌中的最大者赢局，如果一组人持有的四张牌是一样的，那么第五张牌最大者赢局（起脚牌）。如果起脚牌也一样，平分彩池。
满堂彩（Fullhouse，葫芦，三带二）
由三张相同点数及任何两张其他相同点数的扑克牌组成。
平手牌：如果两组或者更多组摊牌，那么三张相同点数中较大者赢局。如果三张牌都一样，则两张牌中点数较大者赢局，如果所有的牌都一样，则平分彩池。
同花（Flush，简称“花”）
此牌由五张不按顺序但相同花的扑克牌组成。
平手牌：如果不止一人抓到此牌相，则牌点最高的人赢得该局，如果最大点相同，则由第二、第三、第四或者第五张牌来决定胜负，如果所有的牌都相同，平分彩池。
顺子（Straight，亦称“蛇”）
此牌由五张顺序扑克牌组成。
平手牌：如果不止一人抓到此牌，则五张牌中点数最大的赢得此局，如果所有牌点数都相同，平分彩池。
三条（Three of a kind，亦称“三张”）
由三张相同点数和两张不同点数的扑克组成。
平手牌：如果不止一人抓到此牌，则三张牌中最大点数者赢局，如果三张牌都相同，比较第四张牌，必要时比较第五张，点数大的人赢局。如果所有牌都相同，则平分彩池。
两对（Two Pairs）
两对点数相同但两两不同的扑克和随意的一张牌组成。
平手牌：如果不止一人抓大此牌相，牌点比较大的人赢，如果比较大的牌点相同，那么较小牌点中的较大者赢，如果两对牌点相同，那么第五张牌点较大者赢（起脚牌）。如果起脚牌也相同，则平分彩池。
一对（One Pair）
由两张相同点数的扑克牌和另三张随意的牌组成。
平手牌：如果不止一人抓到此牌，则两张牌中点数大的赢，如果对牌都一样，则比较另外三张牌中大的赢，如果另外三张牌中较大的也一样则比较第二大的和第三大的，如果所有的牌都一样，则平分彩池。
高牌（high card）
既不是同一花色也不是同一点数的五张牌组成。
平手牌：如果不止一人抓到此牌，则比较点数最大者，如果点数最大的相同，则比较第二、第三、第四和第五大的，如果所有牌都相同，则平分彩池。
玩法介绍
庄家(Dealer)
首先确定庄家（英文为Button，固也称按钮）位置。第一局庄家位置系统随机指定，以后每局庄家位置按照顺时针方向下移一位。
盲注(Blinds)
为了使得游戏能够进行，强制庄家左边第一个人下一注（称小盲注 Small Blind），按钮左边第二个人下两注（称大盲注 Big Blind）。
底牌(Hole cards)
下盲注后从下大盲注玩家开始按顺时针方向每人发两张牌，皆为暗牌，称底牌或起手牌。
第一轮下注(Pre-flop)
发底牌后，从大盲注左边的玩家开始行动/叫注/说话(Action)，行动指从以下几项选择其一：
- 弃牌(Fold)：放弃本副牌，不参与竞争。
- 让牌(Check)：观望态度，或者是挖陷阱。
- 跟注(Call)：跟到和上家相同的注额。
- 加注(Raise)：增加下注额，直到全部筹码即全押(All-in)。
一人结束行动后按顺时针方向下一玩家获得行动权，直到不再有人弃牌，且每人已向奖池投入相同注额。已弃牌玩家不再有行动权。
如无盲注，则为发牌人左方的玩家，如为一对一时，则由大盲注先行叫注。
翻牌及第二轮下注(Flop)
发三张牌到牌桌中央，称为“翻牌”，为公共牌，所有人可见。
从小盲注玩家按顺时针方向做同于第一轮的行动，直到不再有人弃牌，且每人已向奖池投入相同注额。已弃牌玩家不再参与游戏。
转牌及第三轮下注(Turn)
发第四张牌，称为“转牌”，为公共牌，所有人可见。
从小盲注玩家按顺时针方向做同于第一轮的行动，直到不再有人弃牌，且每人已向奖池投入相同注额。已弃牌玩家不再参与游戏。
河牌及第四轮下注(River)
发第五张牌，称为“河牌”，为公共牌，所有人可见。
从小盲注玩家按顺时针方向做同于第一轮的行动，直到不再有人弃牌，且每人已向奖池投入相同注额。已弃牌玩家不再参与游戏。
摊牌和比牌(Showdown)
四轮下注都完成后，若仍剩余两名或两名以上玩家，则进行比牌。
比牌时，每位玩家用手中2张底牌与5张公共牌中任选5张组成最大牌者进行比较大小。胜者赢得底池所有注码。若有多人获胜，则平分底池注码。
當彩池由兩個以上玩家平分時，若有無法平分之小額籌碼，由順時鐘方向算過去，最靠近發牌者的贏家取得，舉例來說有ABCDE依順時鐘方向入座，A為本局發牌者，最小面額籌碼為$10，所有玩家皆未蓋牌至攤牌，最終由CDE勝出平分本局彩池$1000時，則DE各分到$330，而多出的$10將分配給最靠近A的贏家C，C於本局可分到$340。
新手盲注
在牌局已经形成的情况下，新加入牌局的人，需要下新手盲注，新手盲注等于大盲注。
全押(All-in)
当一个玩家加注或企图跟注却筹码不足时，他可以选择全押。当有玩家全押时，他会跟进他所有的筹码，底池被分为主池和边池。其他玩家多出全押玩家筹码的注额将都会被加入边池，此全押玩家将不可能获得边池而只可能赢得主池。同理，当多个玩家全押时可能出现多个边池。
底池(Pot)
每一个牌局里众人已押上的筹码总额，也即该局的奖金数目。
主池(Main pot)与边池(Side pot)
当没有玩家全押(All-in)时，底池由未弃牌的玩家中牌型最大者独得。
当有一个或多个玩家全押时，超过玩家压注金额的部分将会形成一个或多个边池。玩家参与投注该边池才有机会赢取改边池。
当一局结束而且所有已全押的玩家未持有最大牌型时，边池和主池都由牌面最佳获胜者赢取。
当一局结束而且有全押的玩家赢牌时，该玩家有参与投注的主池和边池均归该玩家，而其他边池由参与改池投注里，持有最大牌面的玩家赢得。
在几个玩家全押形成多个边池时，依全押的顺序分配给各边池中最佳牌面的玩家，有最大牌面的玩家赢得该玩家全押前所累积的边池。已全押的玩家无法赢取全押后产生的边池，即最多只能从其他每个跟牌玩家处取得相当于本身全押的总筹码数。全押后的下注可视为只在之后参与的玩家之间的独立输赢分配。
无人跟注的边池(仅有一位玩家下注，剩下其他玩家都弃牌)将会直接赢得该边池，相当于退换下注于该边池的筹码。
底池分配范例
例如ABCDEF六名玩家參與牌局，F於中途蓋牌退出，最終A全押投入$50，B全押投入$250，C全押投入$350，DE各投入$800，F投入$500，此時總彩池大小為$2750，形成了一個主池為50*6=$300，邊池各為（250-50）*5=$1000，（350-250）*4=$400，（500-350）*3=$450，（800-500）*2=$600，若最終組成牌面大小為F>A>B>D>E>C，但F已蓋牌不能分配任何彩池，則此局主池即為A於此局贏得的籌碼（$300），B可贏得第一個邊池（$1000），D參與至最後一個邊池，且牌面勝過參與第二、第三及第四邊池的所有玩家，因此可贏得剩下所有的邊池（400+450+600=$1450）
因为每个人手中的筹码量会不时的产生变化，当出现多个筹码量不等的玩家“全下(ALL-IN)”争夺底池的时候就会出现多个奖池，这时候底池将分出主池和边池，主池里的筹码可由任何一位争夺者胜利后将其拿走，其后每个边池将分别由参与者按牌型大小分别拿走。
举个例子，假如发到河牌后共有三个人争夺底池，三人分别用ABC代替，假设A玩家手中有60，B手中有80，C手中有100。三人ALL-IN后则先把每人的筹码划分成：
A玩家60；B玩家60+20；C玩家60+20+20，然后分出底池：
主池 由60乘以三个人(A+B+C)形成一个堆，总额为180；
边池一 由20乘以剩下的两个人(B+C)多出的部分为一个堆，总额为40；
边池二 由筹码最多者C的多出的部分20单独组成一个堆，总额为20。
现在三个底池形成了，然后分别按照牌型的大小来决定谁拿走哪个底池……
首先，主池可以由三人中的任何一人得到胜利都可以拿走；但是边池一的争夺就只能在B与C之间产生，两人谁赢谁拿走，与A无关(就算A玩家的牌最大也只能拿走他参与的主池)。而最后剩下的边池二不论三人谁输谁赢都只能由C拿走，因为边池二里的筹码只有C自己参与了，与其他人无关。
参考文档
http://jingyan.baidu.com/article/0aa223758306b688cd0d6462.html
http://zhidao.baidu.com/question/1446347228032870540.html
================================================
FILE: src/server/algorithm/cards.go
================================================
package algorithm
type Cards []byte
// todo 两对和四张起脚牌的判定
var StraightMask = []uint16{15872, 7936, 3968, 1984, 992, 496, 248, 124, 62, 31}
//顺子（Straight，亦称“蛇”）
//此牌由五张顺序扑克牌组成。
//平手牌：如果不止一人抓到此牌，则五张牌中点数最大的赢得此局，
// 如果所有牌点数都相同，平分彩池。
func (this *Cards) straight() uint32 {
var handvalue uint16
for _, v := range (*this) {
value := v & 0xF
if value == 0xE {
handvalue |= 1
}
handvalue |= (1 << (value - 1 ) )
}
for i := uint8(0); i < 10; i++ {
if handvalue&StraightMask[i] == StraightMask[i] {
return En(STRAIGHT, uint32(10-i+4))
}
}
return 0
}
//同花顺（Straight Flush）
//五张同花色的连续牌。
//平手牌：如果摊牌时有两副或多副同花顺，连续牌的头张牌大的获得筹码。
//如果是两副或多副相同的连续牌，平分筹码。
func (this *Cards) straightFlush() uint32 {
cards := *this
for i := byte(0); i < SUITSIZE; i++ {
var handvalue uint16
for _, v := range cards {
if (v >> 4) == i {
value := v & 0xF
if value == 0xE {
handvalue |= 1
}
handvalue |= (1 << (value - 1 ) )
}
}
for i := uint8(0); i < 10; i++ {
if handvalue&StraightMask[i] == StraightMask[i] {
return En(STRAIGHT_FLUSH, uint32(10-i+4))
}
}
}
return 0
}
//皇家同花顺（Royal Flush）
//同花色的A, K, Q, J和10。
//平手牌：在摊牌的时候有两副多副皇家同花顺时，平分筹码。
func (this *Cards) royalFlush() uint32 {
cards := *this
for i := byte(0); i < SUITSIZE; i++ {
var handvalue uint16
for _, v := range cards {
if (v >> 4) == i {
value := v & 0xF
if value == 0xE {
handvalue |= 1
}
handvalue |= (1 << (value - 1 ) )
}
}
if handvalue&StraightMask[0] == StraightMask[0] {
return En(ROYAL_FLUSH, 0)
}
}
return 0
}
//四条（Four of a Kind，亦称“铁支”、“四张”或“炸弹”）
//其中四张是相同点数但不同花的扑克牌，第五张是随意的一张牌。
//平手牌：如果两组或者更多组摊牌，则四张牌中的最大者赢局，如果一组人持有的四张牌是一样的，
//那么第五张牌最大者赢局（起脚牌,2张起手牌中小的那张就叫做起脚牌）。如果起脚牌也一样，平分彩池。
func (this *Cards) four(counter *ValueCounter) uint32 {
cards := *this
if counter.Get(cards[len(cards)-1]) == 4 {
return En(FOUR, ToValue(cards))
}
return 0
}
//满堂彩（Fullhouse，葫芦，三带二）
//由三张相同点数及任何两张其他相同点数的扑克牌组成。
//平手牌：如果两组或者更多组摊牌，那么三张相同点数中较大者赢局。
//如果三张牌都一样，则两张牌中点数较大者赢局，如果所有的牌都一样，则平分彩池。
func (this *Cards) fullFouse(counter *ValueCounter) uint32 {
cards := *this
length := len(cards)
if length >= 5 {
if cards[length-1]&0xF == cards[length-2]&0xF &&
cards[length-3]&0xF == cards[length-1]&0xF &&
cards[length-4]&0xF == cards[length-5]&0xF {
return En(FULL_HOUSE, ToValue(cards))
}
}
return 0
}
//同花（Flush，简称“花”）
//此牌由五张不按顺序但相同花的扑克牌组成。
//平手牌：如果不止一人抓到此牌相，则牌点最高的人赢得该局，
//如果最大点相同，则由第二、第三、第四或者第五张牌来决定胜负，如果所有的牌都相同，平分彩池。
func (this *Cards) flush() uint32 {
cards := *this
for i := byte(0); i < SUITSIZE; i++ {
var count uint8
for _, v := range cards {
if (v >> 4) == i {
count ++
if count == 5 {
var handvalue uint16
for _, v1 := range cards {
if (v1 >> 4) == i {
value := v1 & 0xF
if value == 0xE {
handvalue |= 1
}
handvalue |= (1 << (value - 1 ) )
}
}
return En(FLUSH, uint32(handvalue))
}
}
}
}
return 0
}
//三条（Three of a kind，亦称“三张”）
//由三张相同点数和两张不同点数的扑克组成。
//平手牌：如果不止一人抓到此牌，则三张牌中最大点数者赢局，
//如果三张牌都相同，比较第四张牌，必要时比较第五张，点数大的人赢局。如果所有牌都相同，则平分彩池。
func (this *Cards) three(counter *ValueCounter) uint32 {
cards := *this
if counter.Get(cards[len(cards)-1]) == 3 {
return En(THREE, ToValue(cards))
}
return 0
}
//两对（Two Pairs）
//两对点数相同但两两不同的扑克和随意的一张牌组成。
//平手牌：如果不止一人抓大此牌相，牌点比较大的人赢，如果比较大的牌点相同，那么较小牌点中的较大者赢，
//如果两对牌点相同，那么第五张牌点较大者赢（起脚牌,2张起手牌中小的那张就叫做起脚牌）。如果起脚牌也相同，则平分彩池。
func (this *Cards) twoPair() uint32 {
cards := *this
length := len(cards)
if length >= 4 {
if cards[length-1]&0xF == cards[length-2]&0xF &&
cards[length-3]&0xF == cards[length-4]&0xF {
return En(TWO_PAIR, ToValue(cards))
}
}
return 0
}
//一对（One Pair）
//由两张相同点数的扑克牌和另三张随意的牌组成。
//平手牌：如果不止一人抓到此牌，则两张牌中点数大的赢，如果对牌都一样，则比较另外三张牌中大的赢，
//如果另外三张牌中较大的也一样则比较第二大的和第三大的，如果所有的牌都一样，则平分彩池。
func (this *Cards) onePair() uint32 {
cards := *this
length := len(cards)
if length >= 2 {
if cards[length-1]&0xF == cards[length-2]&0xF {
return En(ONE_PAIR, ToValue(cards))
}
}
return 0
}
func ToValue(cards []byte) uint32 {
var res uint32
for i := len(cards) - 1; i >= 0; i-- {
res *= 10
res += uint32(cards[i] & 0xF)
}
return res
}
func De(v uint32) (uint8, uint32) {
return uint8(v >> 24), v & 0xFFFFFF
}
func En(t uint8, v uint32) uint32 {
v1 := v | ( uint32(t) << 24)
return v1
}
================================================
FILE: src/server/algorithm/cards_test.go
================================================
package algorithm
import (
"testing"
"strings"
"github.com/stretchr/testify/assert"
)
func TestFour(t *testing.T) {
cards := Cards{0x12, 0x02, 0x22, 0xb, 0x1b, 0x7, 0x32}
k,_:=De(cards.GetType())
assert.Equal(t, k, FOUR)
cards = Cards{0x12, 0x02, 0x22, 0x32}
k,_=De(cards.GetType())
assert.Equal(t, k, FOUR)
}
func TestThree(t *testing.T) {
cards := Cards{0x12, 0x02, 0x22, 0x3a, 0x2a, 0x1a, 0x33}
k,_:=De(cards.GetType())
assert.Equal(t, k, FULL_HOUSE)
}
func TestHighCard(t *testing.T) {
//var cs Cards
cards := Cards{0x1E, 0x02, 0x22, 0x3a, 0x2a, 0x1a, 0x33}
k, _ := De(cards.GetType())
assert.Equal(t, k, FULL_HOUSE)
//assert.Equal(t, v, uint32(0xE))
}
func TestCards_OnePair(t *testing.T) {
cards := Cards{0x12, 0x0e, 0x2e, 0x3a, 0x2a, 0x1a, 0x32}
k, _ := De(cards.GetType())
assert.Equal(t, k, FULL_HOUSE)
}
func TestCards_Straight(t *testing.T) {
cards := Cards{0x12, 0x03, 0x24, 0x35, 0x26, 0x17, 0x33}
k, v := De(cards.GetType())
assert.Equal(t, k, STRAIGHT)
assert.Equal(t, v, uint32(7))
cards = Cards{0x12, 0x03, 0x24, 0x34, 0x26, 0x17, 0x37}
assert.Equal(t, k, STRAIGHT)
assert.Equal(t, v, uint32(7))
cards = Cards{0x12, 0x03, 0x24, 0x34, 0x25, 0x17, 0x3E}
k, v = De(cards.GetType())
assert.Equal(t, k, STRAIGHT)
assert.Equal(t, v, uint32(0x5))
cards = Cards{0x12, 0x03, 0x2a, 0x3c, 0x2b, 0x1d, 0x3E}
k, v = De(cards.GetType())
assert.Equal(t, k, STRAIGHT)
assert.Equal(t, v, uint32(0xe))
}
func TestCards_Flush(t *testing.T) {
cards := Cards{0x32, 0x33, 0x34, 0x35, 0x26, 0x37, 0x28}
k, _ := De(cards.GetType())
assert.Equal(t, k,FLUSH)
//assert.Equal(t, v, uint32(6))
}
func TestCards_TwoPair(t *testing.T) {
cards := Cards{0x12, 0x22, 0x34, 0x35, 0x25, 0x38, 0x28}
k, _ := De(cards.GetType())
assert.Equal(t, k, TWO_PAIR)
}
func TestCards_RoyalFlush(t *testing.T) {
cards := Cards{0x3A, 0x3B, 0x3C, 0x3E, 0x3D, 0x38, 0x28}
k, _ := De(cards.GetType())
assert.Equal(t, k, ROYAL_FLUSH)
cards = Cards{0x3A, 0x3B, 0x3C, 0x3E, 0x2D, 0x38, 0x28}
k, _ = De(cards.GetType())
assert.Equal(t, k, FLUSH)
}
func TestCards_FLUSH1(t *testing.T) {
cards1 := Cards{0x22, 0x22, 0x22, 0x25, 0x38, 0x28}
cards2 := Cards{0x32, 0x32, 0x33, 0x34, 0x25, 0x36}
v1:=cards1.GetType()
v2:=cards2.GetType()
assert.Equal(t,v1 > v2 ,true)
cards1 = Cards{0x22, 0x22, 0x2E, 0x25, 0x38, 0x28}
cards2 = Cards{0x32, 0x32, 0x33, 0x3a, 0x2a, 0x3E}
assert.Equal(t,cards1.GetType() > cards2.GetType() ,false)
}
func TestCards_FLUSH(t *testing.T) {
cards1 := Cards{0x22, 0x22, 0x24, 0x25, 0x38, 0x28}
cards2 := Cards{0x32, 0x32, 0x33, 0x34, 0x25, 0x36}
v1:=cards1.GetType()
v2:=cards2.GetType()
assert.Equal(t,v1 > v2 ,true)
}
func TestCards_PK(t *testing.T) {
cards1 := Cards{0x32, 0x32, 0x34, 0x35, 0x25, 0x38, 0x28}
cards2 := Cards{0x32, 0x32, 0x33, 0x34, 0x25, 0x36}
v1:=cards1.GetType()
v2:=cards2.GetType()
assert.Equal(t,v1 > v2 ,true)
}
func TestCards_StraightFlush(t *testing.T) {
cards := Cards{0x32, 0x33, 0x34, 0x35, 0x36, 0x27, 0x28}
k, v := De(cards.GetType())
assert.Equal(t, k, uint8(9))
assert.Equal(t, v, uint32(6))
cards = Cards{0x32, 0x33, 0x34, 0x35, 0x3E, 0x37, 0x28}
k, v = De(cards.GetType())
assert.Equal(t, k, uint8(9))
assert.Equal(t, v, uint32(5))
cards = Cards{0x32, 0x33, 0x34, 0x35, 0x3E, 0x36, 0x28}
k, v = De(cards.GetType())
assert.Equal(t, k, uint8(9))
assert.Equal(t, v, uint32(6))
}
func TestCards_FullFouse(t *testing.T) {
cards := Cards{0x33, 0x33, 0x33, 0x35, 0x25, 0x35, 0x28}
k, _ := De(cards.GetType())
//t.Logf("%v %v %#v ",k,v,cards)
assert.Equal(t, k, FULL_HOUSE)
//assert.Equal(t, v, FULL_HOUSE)
//t.Log(cards.String())
//t.Log(cards.Hex())
}
func TestString2Num(t *testing.T) {
array := Cards{0x33, 0x33, 0x33, 0x35, 0x25, 0x35, 0x3E, 0x1A}
//for i := 0; i < N; i++ {
go array.Shuffle()
t.Log(array.String())
//}
}
func TestFullFouse(t *testing.T) {
var s = "A A A K K|" +
"A A A Q Q|" +
"A A A J J|" +
"A A A T T|" +
"A A A 9 9|" +
"A A A 8 8|" +
"A A A 7 7|" +
"A A A 6 6|" +
"A A A 5 5|" +
"A A A 4 4|" +
"A A A 3 3|" +
"A A A 2 2|" +
"K K K A A|" +
"K K K Q Q|" +
"K K K J J|" +
"K K K T T|" +
"K K K 9 9|" +
"K K K 8 8|" +
"K K K 7 7|" +
"K K K 6 6|" +
"K K K 5 5|" +
"K K K 4 4|" +
"K K K 3 3|" +
"K K K 2 2|" +
"Q Q Q A A|" +
"Q Q Q K K|" +
"Q Q Q J J|" +
"Q Q Q T T|" +
"Q Q Q 9 9"
array := strings.Split(s, "|")
var oldValue uint32
for _, v := range array {
cards := &Cards{}
cards.SetByString(v)
//t.Log(cards.String())
k, value := De(cards.GetType())
if oldValue == 0{
oldValue = value
continue
}
assert.Equal(t, oldValue> value, true)
assert.Equal(t, k, FULL_HOUSE)
//assert.Equal(t,v,uint32(6))
//t.Log(De(cards.FullFouse(cards.Counter())))
}
}
func Test_Straight1(t *testing.T) {
/* testCards := "T J Q K A|" +
"9 T J Q K|" +
"8 9 T J Q|" +
"7 8 9 T J|" +
"6 7 8 9 T|" +
"5 6 7 8 9|" +
"4 5 6 7 8|" +
"3 4 5 6 7|" +
"2 3 4 5 6|" +
"A 2 3 4 5"
//array := strings.Split(testCards, "|")
for _, v := range array {
cards := &Cards{}
cards.SetByString(v)
cards.Sort()
t.Log(cards.String(), cards.Straight() > 0)
}
t.Log("--------------------------------------")
for _, v := range array {
cards := &Cards{}
cards.SetByString(v)
cards.Sort()
t.Log(cards.String(), cards.StraightFlush() > 0)
}*/
/* t.Log("--------------------------------------")
for _, v := range array {
cards := &Cards{}
cards.SetByString(v)
cards.Sort()
t.Log(cards.String(), cards.RoyalFlush())
}*/
}
func Test_AnalyseCards(t *testing.T) {
var a ColorCounter
cards := []byte{0x33, 0x35, 0x25, 0x35, 0x28}
a.Set(cards)
t.Log(a.Get(0x33), a.Get(0x35), a.Get(0x28))
}
func Test_Append(t *testing.T) {
cards := Cards{0x33, 0x35, 0x25, 0x35, 0x28}
cards = cards.Append(Cards{0x33, 0x33}...)
t.Logf("%#v ", cards.GetType())
}
func Test_turnToValue1(t *testing.T) {
v1 := []byte{0x33, 0x35, 0x25, 0x35, 0x28}
v2 := []byte{0x35, 0x35, 0x25, 0x35, 0x27}
t.Logf("%#v %#v ", v1, v2)
b1 := ToValue(v1)
b2 := ToValue(v2)
t.Log(b1, b2)
}
func Test_ColorCounter(t *testing.T) {
v2 := []byte{0x35, 0x35, 0x25, 0x35, 0x27}
var colorCounter ColorCounter
colorCounter.Set(v2)
t.Log(v2)
}
func Test_turnToValue(t *testing.T) {
v := ToValue([]byte{0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E})
//var v3 uint16 = v
v1 := v | ( 10 << 24)
//t.Log(v3)
t.Logf("%v %v %v", v, v1>>24, v1&0xFFFFFF)
t.Logf("%v ", ToValue([]byte{0x33, 0x35, 0x25, 0x35, 0x28}))
}
================================================
FILE: src/server/algorithm/constan.go
================================================
package algorithm
// 扑克牌52张，分别包含普通牌52张 2-10、J、Q、K、A （以上每种牌4个花色 黑桃、梅花、红心、方块）
var CARDS = []byte{
//方块
0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
//梅花
0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E,
//红桃
0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E,
//黑桃
0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E,
}
const (
CARDRANK = 13
SUITSIZE = 4
TOTAL = 13 * 4
TYPE_LEN = 5 // 牌型长度
CARDS_LEN = 7 // 河牌+底牌长度
)
//牌型大小：
//1、皇家同花顺＞同花顺＞四条＞葫芦＞同花＞顺子＞三条＞两队＞一对＞单牌
//2、牌点从大到小为：A、K、Q、J、10、9、8、7、6、5、4、3、2，各花色不分大小。
//3、同种牌型，对子时比对子的大小，其它牌型比最大的牌张，如最大牌张相同则比第二大的牌张，以此类推，都相同时为相同。
//4、A 可以组顺子 A、1、2、3、4、5 也可以组顺子 10、J、Q、K、A 同花顺同理
//所有牌型如下：
const (
ROYAL_FLUSH uint8= 10 // 皇家同花顺：同一花色的最大顺子。（最大牌：A-K-Q-J-10）
STRAIGHT_FLUSH uint8= 9 // 同花顺：同一花色的顺子。（最大牌：K-Q-J-10-9 最小牌：A-2-3-4-5）
FOUR uint8= 8 // 四条：四同张加单张。（最大牌：A-A-A-A-K 最小牌：2-2-2-2-3）
FULL_HOUSE uint8= 7 // 葫芦（豪斯）：三同张加对子。（最大牌：A-A-A-K-K 最小牌：2-2-2-3-3）
FLUSH uint8= 6 // 同花：同一花色。（最大牌：A-K-Q-J-9 最小牌：2-3-4-5-7）
STRAIGHT uint8= 5 // 顺子：花色不一样的顺子。（最大牌：A-K-Q-J-10 最小牌：A-2-3-4-5）
THREE uint8= 4 // 三条：三同张加两单张。（最大牌：A-A-A-K-Q 最小牌：2-2-2-3-4）
TWO_PAIR uint8= 3 // 两对：（最大牌：A-A-K-K-Q 最小牌：2-2-3-3-4）
ONE_PAIR uint8= 2 // 一对：（最大牌：A-A-K-Q-J 最小牌：2-2-3-4-5）
HIGH_CARD uint8= 1 // 高牌：（最大牌：A-K-Q-J-9 最小牌：2-3-4-5-7）
)
================================================
FILE: src/server/algorithm/dealer.go
================================================
package algorithm
import (
"time"
"math/rand"
)
//var n int64
//var a int64= 1<<62
// 洗牌
func (this *Cards) Shuffle() {
*this = make([]byte, TOTAL)
copy(*this, CARDS)
source := rand.NewSource(time.Now().UnixNano() )
//n ++
//n %=a
r := rand.New(source)
for i := TOTAL - 1; i > 0; i-- {
index := r.Int() % i
(*this)[i], (*this)[index] = (*this)[index], (*this)[i]
}
}
================================================
FILE: src/server/algorithm/dealer_test.go
================================================
package algorithm
import "testing"
func Test_Dealer(t *testing.T) {
d:= &Cards{}
d.Shuffle()
d.Shuffle()
t.Logf("%#v ",d)
}
================================================
FILE: src/server/algorithm/flush_test.go
================================================
package algorithm
import (
"testing"
"strings"
"github.com/stretchr/testify/assert"
)
func TestFlush1(t *testing.T) {
var s = "9 J Q K A |" +
"8 J Q K A |" +
"7 J Q K A |" +
"6 J Q K A |" +
"5 J Q K A |" +
"4 J Q K A |" +
"3 J Q K A |" +
"2 J Q K A |" +
"9 T Q K A |" +
"8 T Q K A |" +
"7 T Q K A |" +
"6 T Q K A |" +
"5 T Q K A |" +
"4 T Q K A |" +
"3 T Q K A |" +
"2 T Q K A |" +
"8 9 Q K A |" +
"7 9 Q K A |" +
"6 9 Q K A |" +
"5 9 Q K A |" +
"4 9 Q K A |" +
"3 9 Q K A |" +
"2 9 Q K A |" +
"7 8 Q K A |" +
"6 8 Q K A |" +
"5 8 Q K A |" +
"4 8 Q K A |" +
"3 8 Q K A |" +
"2 8 Q K A |" +
"6 7 Q K A |" +
"5 7 Q K A |" +
"4 7 Q K A |" +
"3 7 Q K A |" +
"2 7 Q K A |" +
"5 6 Q K A |" +
"4 6 Q K A |" +
"3 6 Q K A |" +
"2 6 Q K A |" +
"4 5 Q K A |" +
"3 5 Q K A |" +
"2 5 Q K A |" +
"3 4 Q K A |" +
"2 4 Q K A |" +
"2 3 Q K A |" +
"9 T J K A |" +
"8 T J K A |" +
"7 T J K A |" +
"6 T J K A |" +
"5 T J K A |" +
"4 T J K A |" +
"3 T J K A |" +
"2 T J K A |" +
"8 9 J K A |" +
"7 9 J K A |" +
"6 9 J K A |" +
"5 9 J K A |" +
"4 9 J K A |" +
"3 9 J K A |" +
"2 9 J K A |" +
"7 8 J K A |" +
"6 8 J K A |" +
"5 8 J K A |" +
"4 8 J K A |" +
"3 8 J K A |" +
"2 8 J K A |" +
"6 7 J K A |" +
"5 7 J K A |" +
"4 7 J K A |" +
"3 7 J K A |" +
"2 7 J K A |" +
"5 6 J K A |" +
"4 6 J K A |" +
"3 6 J K A |" +
"2 6 J K A |" +
"4 5 J K A |" +
"3 5 J K A |" +
"2 5 J K A |" +
"3 4 J K A |" +
"2 4 J K A |" +
"2 3 J K A |" +
"8 9 T K A |" +
"7 9 T K A |" +
"6 9 T K A |" +
"5 9 T K A |" +
"4 9 T K A |" +
"3 9 T K A |" +
"2 9 T K A |" +
"7 8 T K A |" +
"6 8 T K A |" +
"5 8 T K A |" +
"4 8 T K A |" +
"3 8 T K A |" +
"2 8 T K A |" +
"6 7 T K A |" +
"5 7 T K A |" +
"4 7 T K A |" +
"3 7 T K A |" +
"2 7 T K A |" +
"5 6 T K A |" +
"4 6 T K A |" +
"3 6 T K A |" +
"2 6 T K A |" +
"4 5 T K A |" +
"3 5 T K A |" +
"2 5 T K A |" +
"3 4 T K A |" +
"2 4 T K A |" +
"2 3 T K A |" +
"7 8 9 K A |" +
"6 8 9 K A |" +
"5 8 9 K A |" +
"4 8 9 K A |" +
"3 8 9 K A |" +
"2 8 9 K A |" +
"6 7 9 K A |" +
"5 7 9 K A |" +
"4 7 9 K A |" +
"3 7 9 K A |" +
"2 7 9 K A |" +
"5 6 9 K A |" +
"4 6 9 K A |" +
"3 6 9 K A |" +
"2 6 9 K A |" +
"4 5 9 K A |" +
"3 5 9 K A |" +
"2 5 9 K A |" +
"3 4 9 K A |" +
"2 4 9 K A |" +
"2 3 9 K A |" +
"6 7 8 K A |" +
"5 7 8 K A |" +
"4 7 8 K A |" +
"3 7 8 K A |" +
"2 7 8 K A |" +
"5 6 8 K A |" +
"4 6 8 K A |" +
"3 6 8 K A |" +
"2 6 8 K A |" +
"4 5 8 K A |" +
"3 5 8 K A |" +
"2 5 8 K A |" +
"3 4 8 K A |" +
"2 4 8 K A |" +
"2 3 8 K A |" +
"5 6 7 K A |" +
"4 6 7 K A |" +
"3 6 7 K A |" +
"2 6 7 K A |" +
"4 5 7 K A |" +
"3 5 7 K A |" +
"2 5 7 K A |" +
"3 4 7 K A |" +
"2 4 7 K A |" +
"2 3 7 K A |" +
"4 5 6 K A |" +
"3 5 6 K A |" +
"2 5 6 K A |" +
"3 4 6 K A |" +
"2 4 6 K A |" +
"2 3 6 K A |" +
"3 4 5 K A |" +
"2 4 5 K A |" +
"2 3 5 K A |" +
"2 3 4 K A |" +
"9 T J Q A |" +
"8 T J Q A |" +
"7 T J Q A |" +
"6 T J Q A |" +
"5 T J Q A |" +
"4 T J Q A |" +
"3 T J Q A |" +
"2 T J Q A |" +
"8 9 J Q A |" +
"7 9 J Q A |" +
"6 9 J Q A |" +
"5 9 J Q A |" +
"4 9 J Q A |" +
"3 9 J Q A |" +
"2 9 J Q A |" +
"7 8 J Q A |" +
"6 8 J Q A |" +
"5 8 J Q A |" +
"4 8 J Q A |" +
"3 8 J Q A |" +
"2 8 J Q A |" +
"6 7 J Q A |" +
"5 7 J Q A |" +
"4 7 J Q A |" +
"3 7 J Q A |" +
"2 7 J Q A |" +
"5 6 J Q A |" +
"4 6 J Q A |" +
"3 6 J Q A |" +
"2 6 J Q A |" +
"4 5 J Q A |" +
"3 5 J Q A |" +
"2 5 J Q A |" +
"3 4 J Q A |" +
"2 4 J Q A |" +
"2 3 J Q A |" +
"8 9 T Q A |" +
"7 9 T Q A |" +
"6 9 T Q A |" +
"5 9 T Q A |" +
"4 9 T Q A |" +
"3 9 T Q A |" +
"2 9 T Q A |" +
"7 8 T Q A |" +
"6 8 T Q A |" +
"5 8 T Q A |" +
"4 8 T Q A |" +
"3 8 T Q A |" +
"2 8 T Q A |" +
"6 7 T Q A |" +
"5 7 T Q A |" +
"4 7 T Q A |" +
"3 7 T Q A |" +
"2 7 T Q A |" +
"5 6 T Q A |" +
"4 6 T Q A |" +
"3 6 T Q A |" +
"2 6 T Q A |" +
"4 5 T Q A |" +
"3 5 T Q A |" +
"2 5 T Q A |" +
"3 4 T Q A |" +
"2 4 T Q A |" +
"2 3 T Q A |" +
"7 8 9 Q A |" +
"6 8 9 Q A |" +
"5 8 9 Q A |" +
"4 8 9 Q A |" +
"3 8 9 Q A |" +
"2 8 9 Q A |" +
"6 7 9 Q A |" +
"5 7 9 Q A |" +
"4 7 9 Q A |" +
"3 7 9 Q A |" +
"2 7 9 Q A |" +
"5 6 9 Q A |" +
"4 6 9 Q A |" +
"3 6 9 Q A |" +
"2 6 9 Q A |" +
"4 5 9 Q A |" +
"3 5 9 Q A |" +
"2 5 9 Q A |" +
"3 4 9 Q A |" +
"2 4 9 Q A |" +
"2 3 9 Q A |" +
"6 7 8 Q A |" +
"5 7 8 Q A |" +
"4 7 8 Q A |" +
"3 7 8 Q A |" +
"2 7 8 Q A |" +
"5 6 8 Q A |" +
"4 6 8 Q A |" +
"3 6 8 Q A |" +
"2 6 8 Q A |" +
"4 5 8 Q A |" +
"3 5 8 Q A |" +
"2 5 8 Q A |" +
"3 4 8 Q A |" +
"2 4 8 Q A |" +
"2 3 8 Q A |" +
"5 6 7 Q A |" +
"4 6 7 Q A |" +
"3 6 7 Q A |" +
"2 6 7 Q A |" +
"4 5 7 Q A |" +
"3 5 7 Q A |" +
"2 5 7 Q A |" +
"3 4 7 Q A |" +
"2 4 7 Q A |" +
"2 3 7 Q A |" +
"4 5 6 Q A |" +
"3 5 6 Q A |" +
"2 5 6 Q A |" +
"3 4 6 Q A |" +
"2 4 6 Q A |" +
"2 3 6 Q A |" +
"3 4 5 Q A |" +
"2 4 5 Q A |" +
"2 3 5 Q A |" +
"2 3 4 Q A |" +
"8 9 T J A |" +
"7 9 T J A |" +
"6 9 T J A |" +
"5 9 T J A |" +
"4 9 T J A |" +
"3 9 T J A |" +
"2 9 T J A |" +
"7 8 T J A |" +
"6 8 T J A |" +
"5 8 T J A |" +
"4 8 T J A |" +
"3 8 T J A |" +
"2 8 T J A |" +
"6 7 T J A |" +
"5 7 T J A |" +
"4 7 T J A |" +
"3 7 T J A |" +
"2 7 T J A |" +
"5 6 T J A |" +
"4 6 T J A |" +
"3 6 T J A |" +
"2 6 T J A |" +
"4 5 T J A |" +
"3 5 T J A |" +
"2 5 T J A |" +
"3 4 T J A |" +
"2 4 T J A |" +
"2 3 T J A |" +
"7 8 9 J A |" +
"6 8 9 J A |" +
"5 8 9 J A |" +
"4 8 9 J A |" +
"3 8 9 J A |" +
"2 8 9 J A |" +
"6 7 9 J A |" +
"5 7 9 J A |" +
"4 7 9 J A |" +
"3 7 9 J A |" +
"2 7 9 J A |" +
"5 6 9 J A |" +
"4 6 9 J A |" +
"3 6 9 J A |" +
"2 6 9 J A |" +
"4 5 9 J A |" +
"3 5 9 J A |" +
"2 5 9 J A |" +
"3 4 9 J A |" +
"2 4 9 J A |" +
"2 3 9 J A |" +
"6 7 8 J A |" +
"5 7 8 J A |" +
"4 7 8 J A |" +
"3 7 8 J A |" +
"2 7 8 J A |" +
"5 6 8 J A |" +
"4 6 8 J A |" +
"3 6 8 J A |" +
"2 6 8 J A |" +
"4 5 8 J A |" +
"3 5 8 J A |" +
"2 5 8 J A |" +
"3 4 8 J A |" +
"2 4 8 J A |" +
"2 3 8 J A |" +
"5 6 7 J A |" +
"4 6 7 J A |" +
"3 6 7 J A |" +
"2 6 7 J A |" +
"4 5 7 J A |" +
"3 5 7 J A |" +
"2 5 7 J A |" +
"3 4 7 J A |" +
"2 4 7 J A |" +
"2 3 7 J A |" +
"4 5 6 J A |" +
"3 5 6 J A |" +
"2 5 6 J A |" +
"3 4 6 J A |" +
"2 4 6 J A |" +
"2 3 6 J A |" +
"3 4 5 J A |" +
"2 4 5 J A |" +
"2 3 5 J A |" +
"2 3 4 J A |" +
"7 8 9 T A |" +
"6 8 9 T A |" +
"5 8 9 T A |" +
"4 8 9 T A |" +
"3 8 9 T A |" +
"2 8 9 T A |" +
"6 7 9 T A |" +
"5 7 9 T A |" +
"4 7 9 T A |" +
"3 7 9 T A |" +
"2 7 9 T A |" +
"5 6 9 T A |" +
"4 6 9 T A |" +
"3 6 9 T A |" +
"2 6 9 T A |" +
"4 5 9 T A |" +
"3 5 9 T A |" +
"2 5 9 T A |" +
"3 4 9 T A |" +
"2 4 9 T A |" +
"2 3 9 T A |" +
"6 7 8 T A |" +
"5 7 8 T A |" +
"4 7 8 T A |" +
"3 7 8 T A |" +
"2 7 8 T A |" +
"5 6 8 T A |" +
"4 6 8 T A |" +
"3 6 8 T A |" +
"2 6 8 T A |" +
"4 5 8 T A |" +
"3 5 8 T A |" +
"2 5 8 T A |" +
"3 4 8 T A |" +
"2 4 8 T A |" +
"2 3 8 T A |" +
"5 6 7 T A |" +
"4 6 7 T A |" +
"3 6 7 T A |" +
"2 6 7 T A |" +
"4 5 7 T A |" +
"3 5 7 T A |" +
"2 5 7 T A |" +
"3 4 7 T A |" +
"2 4 7 T A |" +
"2 3 7 T A |" +
"4 5 6 T A |" +
"3 5 6 T A |" +
"2 5 6 T A |" +
"3 4 6 T A |" +
"2 4 6 T A |" +
"2 3 6 T A |" +
"3 4 5 T A |" +
"2 4 5 T A |" +
"2 3 5 T A |" +
"2 3 4 T A |" +
"6 7 8 9 A |" +
"5 7 8 9 A |" +
"4 7 8 9 A |" +
"3 7 8 9 A |" +
"2 7 8 9 A |" +
"5 6 8 9 A |" +
"4 6 8 9 A |" +
"3 6 8 9 A |" +
"2 6 8 9 A |" +
"4 5 8 9 A |" +
"3 5 8 9 A |" +
"2 5 8 9 A |" +
"3 4 8 9 A |" +
"2 4 8 9 A |" +
"2 3 8 9 A |" +
"5 6 7 9 A |" +
"4 6 7 9 A |" +
"3 6 7 9 A |" +
"2 6 7 9 A |" +
"4 5 7 9 A |" +
"3 5 7 9 A |" +
"2 5 7 9 A |" +
"3 4 7 9 A |" +
"2 4 7 9 A |" +
"2 3 7 9 A |" +
"4 5 6 9 A |" +
"3 5 6 9 A |" +
"2 5 6 9 A |" +
"3 4 6 9 A |" +
"2 4 6 9 A |" +
"2 3 6 9 A |" +
"3 4 5 9 A |" +
"2 4 5 9 A |" +
"2 3 5 9 A |" +
"2 3 4 9 A |" +
"5 6 7 8 A |" +
"4 6 7 8 A |" +
"3 6 7 8 A |" +
"2 6 7 8 A |" +
"4 5 7 8 A |" +
"3 5 7 8 A |" +
"2 5 7 8 A |" +
"3 4 7 8 A |" +
"2 4 7 8 A |" +
"2 3 7 8 A |" +
"4 5 6 8 A |" +
"3 5 6 8 A |" +
"2 5 6 8 A |" +
"3 4 6 8 A |" +
"2 4 6 8 A |" +
"2 3 6 8 A |" +
"3 4 5 8 A |" +
"2 4 5 8 A |" +
"2 3 5 8 A |" +
"2 3 4 8 A |" +
"4 5 6 7 A |" +
"3 5 6 7 A |" +
"2 5 6 7 A |" +
"3 4 6 7 A |" +
"2 4 6 7 A |" +
"2 3 6 7 A |" +
"3 4 5 7 A |" +
"2 4 5 7 A |" +
"2 3 5 7 A |" +
"2 3 4 7 A |" +
"3 4 5 6 A |" +
"2 4 5 6 A |" +
"2 3 5 6 A |" +
"2 3 4 6 A |" +
"8 T J Q K |" +
"7 T J Q K |" +
"6 T J Q K |" +
"5 T J Q K |" +
"4 T J Q K |" +
"3 T J Q K |" +
"2 T J Q K |" +
"8 9 J Q K |" +
"7 9 J Q K |" +
"6 9 J Q K |" +
"5 9 J Q K |" +
"4 9 J Q K |" +
"3 9 J Q K |" +
"2 9 J Q K |" +
"7 8 J Q K |" +
"6 8 J Q K |" +
"5 8 J Q K |" +
"4 8 J Q K |" +
"3 8 J Q K |" +
"2 8 J Q K |" +
"6 7 J Q K |" +
"5 7 J Q K |" +
"4 7 J Q K |" +
"3 7 J Q K |" +
"2 7 J Q K |" +
"5 6 J Q K |" +
"4 6 J Q K |" +
"3 6 J Q K |" +
"2 6 J Q K |" +
"4 5 J Q K |" +
"3 5 J Q K |" +
"2 5 J Q K |" +
"3 4 J Q K |" +
"2 4 J Q K |" +
"2 3 J Q K |" +
"8 9 T Q K |" +
"7 9 T Q K |" +
"6 9 T Q K |" +
"5 9 T Q K |" +
"4 9 T Q K |" +
"3 9 T Q K |" +
"2 9 T Q K |" +
"7 8 T Q K |" +
"6 8 T Q K |" +
"5 8 T Q K |" +
"4 8 T Q K |" +
"3 8 T Q K |" +
"2 8 T Q K |" +
"6 7 T Q K |" +
"5 7 T Q K |" +
"4 7 T Q K |" +
"3 7 T Q K |" +
"2 7 T Q K |" +
"5 6 T Q K |" +
"4 6 T Q K |" +
"3 6 T Q K |" +
"2 6 T Q K |" +
"4 5 T Q K |" +
"3 5 T Q K |" +
"2 5 T Q K |" +
"3 4 T Q K |" +
"2 4 T Q K |" +
"2 3 T Q K |" +
"7 8 9 Q K |" +
"6 8 9 Q K |" +
"5 8 9 Q K |" +
"4 8 9 Q K |" +
"3 8 9 Q K |" +
"2 8 9 Q K |" +
"6 7 9 Q K |" +
"5 7 9 Q K |" +
"4 7 9 Q K |" +
"3 7 9 Q K |" +
"2 7 9 Q K |" +
"5 6 9 Q K |" +
"4 6 9 Q K |" +
"3 6 9 Q K |" +
"2 6 9 Q K |" +
"4 5 9 Q K |" +
"3 5 9 Q K |" +
"2 5 9 Q K |" +
"3 4 9 Q K |" +
"2 4 9 Q K |" +
"2 3 9 Q K |" +
"6 7 8 Q K |" +
"5 7 8 Q K |" +
"4 7 8 Q K |" +
"3 7 8 Q K |" +
"2 7 8 Q K |" +
"5 6 8 Q K |" +
"4 6 8 Q K |" +
"3 6 8 Q K |" +
"2 6 8 Q K |" +
"4 5 8 Q K |" +
"3 5 8 Q K |" +
"2 5 8 Q K |" +
"3 4 8 Q K |" +
"2 4 8 Q K |" +
"2 3 8 Q K |" +
"5 6 7 Q K |" +
"4 6 7 Q K |" +
"3 6 7 Q K |" +
"2 6 7 Q K |" +
"4 5 7 Q K |" +
"3 5 7 Q K |" +
"2 5 7 Q K |" +
"3 4 7 Q K |" +
"2 4 7 Q K |" +
"2 3 7 Q K |" +
"4 5 6 Q K |" +
"3 5 6 Q K |" +
"2 5 6 Q K |" +
"3 4 6 Q K |" +
"2 4 6 Q K |" +
"2 3 6 Q K |" +
"3 4 5 Q K |" +
"2 4 5 Q K |" +
"2 3 5 Q K |" +
"2 3 4 Q K |" +
"8 9 T J K |" +
"7 9 T J K |" +
"6 9 T J K |" +
"5 9 T J K |" +
"4 9 T J K |" +
"3 9 T J K |" +
"2 9 T J K |" +
"7 8 T J K |" +
"6 8 T J K |" +
"5 8 T J K |" +
"4 8 T J K |" +
"3 8 T J K |" +
"2 8 T J K |" +
"6 7 T J K |" +
"5 7 T J K |" +
"4 7 T J K |" +
"3 7 T J K |" +
"2 7 T J K |" +
"5 6 T J K |" +
"4 6 T J K |" +
"3 6 T J K |" +
"2 6 T J K |" +
"4 5 T J K |" +
"3 5 T J K |" +
"2 5 T J K |" +
"3 4 T J K |" +
"2 4 T J K |" +
"2 3 T J K |" +
"7 8 9 J K |" +
"6 8 9 J K |" +
"5 8 9 J K |" +
"4 8 9 J K |" +
"3 8 9 J K |" +
"2 8 9 J K |" +
"6 7 9 J K |" +
"5 7 9 J K |" +
"4 7 9 J K |" +
"3 7 9 J K |" +
"2 7 9 J K |" +
"5 6 9 J K |" +
"4 6 9 J K |" +
"3 6 9 J K |" +
"2 6 9 J K |" +
"4 5 9 J K |" +
"3 5 9 J K |" +
"2 5 9 J K |" +
"3 4 9 J K |" +
"2 4 9 J K |" +
"2 3 9 J K |" +
"6 7 8 J K |" +
"5 7 8 J K |" +
"4 7 8 J K |" +
"3 7 8 J K |" +
"2 7 8 J K |" +
"5 6 8 J K |" +
"4 6 8 J K |" +
"3 6 8 J K |" +
"2 6 8 J K |" +
"4 5 8 J K |" +
"3 5 8 J K |" +
"2 5 8 J K |" +
"3 4 8 J K |" +
"2 4 8 J K |" +
"2 3 8 J K |" +
"5 6 7 J K |" +
"4 6 7 J K |" +
"3 6 7 J K |" +
"2 6 7 J K |" +
"4 5 7 J K |" +
"3 5 7 J K |" +
"2 5 7 J K |" +
"3 4 7 J K |" +
"2 4 7 J K |" +
"2 3 7 J K |" +
"4 5 6 J K |" +
"3 5 6 J K |" +
"2 5 6 J K |" +
"3 4 6 J K |" +
"2 4 6 J K |" +
"2 3 6 J K |" +
"3 4 5 J K |" +
"2 4 5 J K |" +
"2 3 5 J K |" +
"2 3 4 J K |" +
"7 8 9 T K |" +
"6 8 9 T K |" +
"5 8 9 T K |" +
"4 8 9 T K |" +
"3 8 9 T K |" +
"2 8 9 T K |" +
"6 7 9 T K |" +
"5 7 9 T K |" +
"4 7 9 T K |" +
"3 7 9 T K |" +
"2 7 9 T K |" +
"5 6 9 T K |" +
"4 6 9 T K |" +
"3 6 9 T K |" +
"2 6 9 T K |" +
"4 5 9 T K |" +
"3 5 9 T K |" +
"2 5 9 T K |" +
"3 4 9 T K |" +
"2 4 9 T K |" +
"2 3 9 T K |" +
"6 7 8 T K |" +
"5 7 8 T K |" +
"4 7 8 T K |" +
"3 7 8 T K |" +
"2 7 8 T K |" +
"5 6 8 T K |" +
"4 6 8 T K |" +
"3 6 8 T K |" +
"2 6 8 T K |" +
"4 5 8 T K |" +
"3 5 8 T K |" +
"2 5 8 T K |" +
"3 4 8 T K |" +
"2 4 8 T K |" +
"2 3 8 T K |" +
"5 6 7 T K |" +
"4 6 7 T K |" +
"3 6 7 T K |" +
"2 6 7 T K |" +
"4 5 7 T K |" +
"3 5 7 T K |" +
"2 5 7 T K |" +
"3 4 7 T K |" +
"2 4 7 T K |" +
"2 3 7 T K |" +
"4 5 6 T K |" +
"3 5 6 T K |" +
"2 5 6 T K |" +
"3 4 6 T K |" +
"2 4 6 T K |" +
"2 3 6 T K |" +
"3 4 5 T K |" +
"2 4 5 T K |" +
"2 3 5 T K |" +
"2 3 4 T K |" +
"6 7 8 9 K |" +
"5 7 8 9 K |" +
"4 7 8 9 K |" +
"3 7 8 9 K |" +
"2 7 8 9 K |" +
"5 6 8 9 K |" +
"4 6 8 9 K |" +
"3 6 8 9 K |" +
"2 6 8 9 K |" +
"4 5 8 9 K |" +
"3 5 8 9 K |" +
"2 5 8 9 K |" +
"3 4 8 9 K |" +
"2 4 8 9 K |" +
"2 3 8 9 K |" +
"5 6 7 9 K |" +
"4 6 7 9 K |" +
"3 6 7 9 K |" +
"2 6 7 9 K |" +
"4 5 7 9 K |" +
"3 5 7 9 K |" +
"2 5 7 9 K |" +
"3 4 7 9 K |" +
"2 4 7 9 K |" +
"2 3 7 9 K |" +
"4 5 6 9 K |" +
"3 5 6 9 K |" +
"2 5 6 9 K |" +
"3 4 6 9 K |" +
"2 4 6 9 K |" +
"2 3 6 9 K |" +
"3 4 5 9 K |" +
"2 4 5 9 K |" +
"2 3 5 9 K |" +
"2 3 4 9 K |" +
"5 6 7 8 K |" +
"4 6 7 8 K |" +
"3 6 7 8 K |" +
"2 6 7 8 K |" +
"4 5 7 8 K |" +
"3 5 7 8 K |" +
"2 5 7 8 K |" +
"3 4 7 8 K |" +
"2 4 7 8 K |" +
"2 3 7 8 K |" +
"4 5 6 8 K |" +
"3 5 6 8 K |" +
"2 5 6 8 K |" +
"3 4 6 8 K |" +
"2 4 6 8 K |" +
"2 3 6 8 K |" +
"3 4 5 8 K |" +
"2 4 5 8 K |" +
"2 3 5 8 K |" +
"2 3 4 8 K |" +
"4 5 6 7 K |" +
"3 5 6 7 K |" +
"2 5 6 7 K |" +
"3 4 6 7 K |" +
"2 4 6 7 K |" +
"2 3 6 7 K |" +
"3 4 5 7 K |" +
"2 4 5 7 K |" +
"2 3 5 7 K |" +
"2 3 4 7 K |" +
"3 4 5 6 K |" +
"2 4 5 6 K |" +
"2 3 5 6 K |" +
"2 3 4 6 K |" +
"2 3 4 5 K |" +
"7 9 T J Q |" +
"6 9 T J Q |" +
"5 9 T J Q |" +
"4 9 T J Q |" +
"3 9 T J Q |" +
"2 9 T J Q |" +
"7 8 T J Q |" +
"6 8 T J Q |" +
"5 8 T J Q |" +
"4 8 T J Q |" +
"3 8 T J Q |" +
"2 8 T J Q |" +
"6 7 T J Q |" +
"5 7 T J Q |" +
"4 7 T J Q |" +
"3 7 T J Q |" +
"2 7 T J Q |" +
"5 6 T J Q |" +
"4 6 T J Q |" +
"3 6 T J Q |" +
"2 6 T J Q |" +
"4 5 T J Q |" +
"3 5 T J Q |" +
"2 5 T J Q |" +
"3 4 T J Q |" +
"2 4 T J Q |" +
"2 3 T J Q |" +
"7 8 9 J Q |" +
"6 8 9 J Q |" +
"5 8 9 J Q |" +
"4 8 9 J Q |" +
"3 8 9 J Q |" +
"2 8 9 J Q |" +
"6 7 9 J Q |" +
"5 7 9 J Q |" +
"4 7 9 J Q |" +
"3 7 9 J Q |" +
"2 7 9 J Q |" +
"5 6 9 J Q |" +
"4 6 9 J Q |" +
"3 6 9 J Q |" +
"2 6 9 J Q |" +
"4 5 9 J Q |" +
"3 5 9 J Q |" +
"2 5 9 J Q |" +
"3 4 9 J Q |" +
"2 4 9 J Q |" +
"2 3 9 J Q |" +
"6 7 8 J Q |" +
"5 7 8 J Q |" +
"4 7 8 J Q |" +
"3 7 8 J Q |" +
"2 7 8 J Q |" +
"5 6 8 J Q |" +
"4 6 8 J Q |" +
"3 6 8 J Q |" +
"2 6 8 J Q |" +
"4 5 8 J Q |" +
"3 5 8 J Q |" +
"2 5 8 J Q |" +
"3 4 8 J Q |" +
"2 4 8 J Q |" +
"2 3 8 J Q |" +
"5 6 7 J Q |" +
"4 6 7 J Q |" +
"3 6 7 J Q |" +
"2 6 7 J Q |" +
"4 5 7 J Q |" +
"3 5 7 J Q |" +
"2 5 7 J Q |" +
"3 4 7 J Q |" +
"2 4 7 J Q |" +
"2 3 7 J Q |" +
"4 5 6 J Q |" +
"3 5 6 J Q |" +
"2 5 6 J Q |" +
"3 4 6 J Q |" +
"2 4 6 J Q |" +
"2 3 6 J Q |" +
"3 4 5 J Q |" +
"2 4 5 J Q |" +
"2 3 5 J Q |" +
"2 3 4 J Q |" +
"7 8 9 T Q |" +
"6 8 9 T Q |" +
"5 8 9 T Q |" +
"4 8 9 T Q |" +
"3 8 9 T Q |" +
"2 8 9 T Q |" +
"6 7 9 T Q |" +
"5 7 9 T Q"
array := strings.Split(s, " |")
var oldValue uint32
for _, v := range array {
cards := &Cards{}
cards.SetByString(v)
//t.Log(cards.String())
k, value := De(cards.GetType())
if oldValue == 0 {
oldValue = value
continue
}
assert.Equal(t, oldValue > value, true)
assert.Equal(t, k, FLUSH)
//assert.Equal(t,v,uint32(6))
//t.Log(De(cards.FullFouse(cards.Counter())))
}
}
================================================
FILE: src/server/algorithm/pk.go
================================================
package algorithm
func (this *Cards) Counter() *ValueCounter {
var counter ValueCounter
counter.Set(*this)
return &counter
}
func (this *Cards) GetType() uint32 {
if len(*this) == 0 {
return 0
}
counter := this.Counter()
ASort(*this, 0, int8(len(*this))-1, counter)
if res := this.royalFlush(); res > 0 {
return res
}
if res := this.straightFlush(); res > 0 {
return res
}
if res := this.four(counter); res > 0 {
return res
}
if res := this.fullFouse(counter); res > 0 {
return res
}
if res := this.flush(); res > 0 {
return res
}
if res := this.straight(); res > 0 {
return res
}
if res := this.three(counter); res > 0 {
return res
}
if res := this.twoPair(); res > 0 {
return res
}
if res := this.onePair(); res > 0 {
return res
}
//高牌（high card）
//既不是同一花色也不是同一点数的五张牌组成。
//平手牌：如果不止一人抓到此牌，则比较点数最大者，
//如果点数最大的相同，则比较第二、第三、第四和第五大的，如果所有牌都相同，则平分彩池。
return En(HIGH_CARD, ToValue(*this))
}
================================================
FILE: src/server/algorithm/sort.go
================================================
package algorithm
// 对牌值从小到大排序，采用快速排序算法
func SortCards(arr []byte, start, end int8) {
if start < end {
i, j := start, end
card := arr[(start+end)/2]
key := card & 0xF
suit := card >> 4
for i <= j {
for (arr[i])&0xF < key || ((arr[i])&0xF == key && arr[i]>>4 < suit) {
i++
}
for (arr[j])&0xF > key || ((arr[j])&0xF == key && arr[j]>>4 > suit) {
j--
}
if i <= j {
arr[i], arr[j] = arr[j], arr[i]
i++
j--
}
}
if start < j {
SortCards(arr, start, j)
}
if end > i {
SortCards(arr, i, end)
}
}
}
func Sort(cards []byte, start, end int8) {
if start < end {
i, j := start, end
card := cards[(start+end)/2]
for i <= j {
for cards[i] < card {
i++
}
for cards[j] > card {
j--
}
if i <= j {
cards[i], cards[j] = cards[j], cards[i]
i++
j--
}
}
if start < j {
Sort(cards, start, j)
}
if end > i {
Sort(cards, i, end)
}
}
}
type ColorCounter uint16
func (this *ColorCounter) Set(cards []byte) {
//*this = 0
l := uint8(len(cards))
for i := uint8(0); i < l; i++ {
card := (cards[i] >> 4) * 3
count := ((*this >> card) & 0x07) + 1
*this &= (^(0x07 << card))
*this |= (count << card)
}
}
func (this *ColorCounter) Get(card byte) uint8 {
return uint8((*this >> (card >> 4) * 3 ) & 0x07)
}
type ValueCounter uint64
func (this *ValueCounter) Set(cards []byte) {
//*this = 0
l := uint8(len(cards))
for i := uint8(0); i < l; i++ {
card := (cards[i] & 0xF) * 3
count := ((*this >> card) & 0x07) + 1
*this &= (^(0x07 << card))
*this |= (count << card)
}
}
func (this *ValueCounter) Get(card byte) uint8 {
return uint8((*this >> (card & 0xF * 3 )) & 0x07)
}
func ASort(arr []byte, start, end int8, counter *ValueCounter) {
if start < end {
i, j := start, end
card := arr[(start+end)/2]
key := card & 0xF
count := counter.Get(key)
for i <= j {
for (counter.Get(arr[i]&0xF) < count) || ((counter.Get(arr[i]&0xF) == count) && (arr[i])&0xF < key ) {
i++
}
for (counter.Get(arr[j]&0xF) > count) || ((counter.Get(arr[j]&0xF) == count) && (arr[j])&0xF > key ) {
j--
}
if i <= j {
arr[i], arr[j] = arr[j], arr[i]
i++
j--
}
}
if start < j {
ASort(arr, start, j, counter)
}
if end > i {
ASort(arr, i, end, counter)
}
}
}
================================================
FILE: src/server/algorithm/sort_test.go
================================================
package algorithm
import "testing"
func Test11Base(t *testing.T) {
cards := Cards{0x12, 0x03, 0x24, 0x35, 0x26, 0x17, 0x33}
var a ValueCounter
a.Set(cards)
ASort(cards, 0, int8(len(cards) -1), &a)
t.Logf("%#v ",cards)
}
func Test10Base(t *testing.T) {
arr := Cards([]byte{1, 2, 3, 4, 4, 5, 6})
arr.Shuffle()
t.Logf("%#v ", arr)
t.Logf("%#v ", arr)
}
================================================
FILE: src/server/algorithm/tostring.go
================================================
package algorithm
import (
"strings"
"fmt"
)
func (this *Cards) Bytes() []byte {
b := make([]byte, len(*this))
for k, v := range *this {
b[k] = byte(v)
}
return b
}
func (this *Cards) Len() int {
return len(*this)
}
func (this *Cards) Take() byte {
card := (*this)[0]
(*this) = (*this)[1:]
return card
}
func (this *Cards) Append(cards ...byte) Cards {
cs := make([]byte, 0, len(cards)+len(*this))
cs = append(cs, (*this)...)
cs = append(cs, cards...)
return cs
}
func (this *Cards) Equal(cards []byte) bool {
if len(*this) != len(cards) {
return false
}
for k, v := range *this {
if cards[k] != v {
return false
}
}
return true
}
func Color(color byte) (char string) {
switch color {
case 0:
char = "♦"
case 1:
char = "♣"
case 2:
char = "♥"
case 3:
char = "♠"
}
return
}
func String2Num(c byte) (n byte) {
switch c {
case '2':
n = 2
case '3':
n = 3
case '4':
n = 4
case '5':
n = 5
case '6':
n = 6
case '7':
n = 7
case '8':
n = 8
case '9':
n = 9
case 'T':
n = 0xA
case 'J':
n = 0xB
case 'Q':
n = 0xC
case 'K':
n = 0xD
case 'A':
n = 0xE
}
return
}
func Num2String(n byte) (c byte) {
switch n {
case 2:
c = '2'
case 3:
c = '3'
case 4:
c = '4'
case 5:
c = '5'
case 6:
c = '6'
case 7:
c = '7'
case 8:
c = '8'
case 9:
c = '9'
case 0xA:
c = 'T'
case 0xB:
c = 'J'
case 0xC:
c = 'Q'
case 0xD:
c = 'K'
case 0xE:
c = 'A'
}
return
}
func (this *Cards) SetByString(str string) {
array := strings.Split(str, " ")
*this = make([]byte, len(array))
for k, v := range array {
(*this)[k] = String2Num(byte(v[0]))
}
}
func (this *Cards) String() (str string) {
for k, v := range *this {
color := Color(v)
value := Num2String(v)
str += string(color) + string(value)
if k < len(*this)-1 {
str += " "
}
}
return
}
func (this *Cards) Hex() string {
return fmt.Sprintf("%#v", *this)
}
================================================
FILE: src/server/base/skeleton.go
================================================
package base
import (
"github.com/dolotech/leaf/chanrpc"
"github.com/dolotech/leaf/module"
"server/conf"
)
func NewSkeleton() *module.Skeleton {
skeleton := &module.Skeleton{
GoLen: conf.GoLen,
TimerDispatcherLen: conf.TimerDispatcherLen,
AsynCallLen: conf.AsynCallLen,
ChanRPCServer: chanrpc.NewServer(conf.ChanRPCLen),
}
skeleton.Init()
return skeleton
}
================================================
FILE: src/server/conf/conf.go
================================================
package conf
import (
"log"
"time"
)
var (
// glog conf
LogFlag = log.LstdFlags
// gate conf
PendingWriteNum = 2000
MaxMsgLen uint32 = 4096
HTTPTimeout = 10 * time.Second
LenMsgLen = 2
LittleEndian = false
// skeleton conf
GoLen = 10000
TimerDispatcherLen = 10000
AsynCallLen = 10000
ChanRPCLen = 10000
)
var Server struct {
WSAddr string
CertFile string
KeyFile string
TCPAddr string
MaxConnNum int
DBMaxConnNum int
DBUrl string
}
================================================
FILE: src/server/game/external.go
================================================
package game
import (
"server/game/internal"
)
var (
Module = new(internal.Module)//建立模块新的
ChanRPC = internal.ChanRPC
)
================================================
FILE: src/server/game/internal/chanrpc.go
================================================
package internal
import (
"github.com/dolotech/leaf/gate"
"github.com/golang/glog"
"server/model"
"github.com/dolotech/leaf/room"
)
func init() {
skeleton.RegisterChanRPC(model.Agent_New, rpcNewAgent)
skeleton.RegisterChanRPC(model.Agent_Close, rpcCloseAgent)
skeleton.RegisterChanRPC(model.Agent_Login, rpcLoginAgent)
}
func rpcNewAgent(a gate.Agent) {
glog.Errorln("新建链接 ", a)
}
func rpcCloseAgent(a gate.Agent) {
glog.Errorln("链接关闭 ", a)
}
func rpcLoginAgent(u *model.User, a gate.Agent) {
o := NewOccupant(u, a)
a.SetUserData(o)
if len(u.RoomID) > 0 {
o.room = room.GetRoom(u.RoomID)
}
glog.Errorln("rpcLoginAgent", u)
}
================================================
FILE: src/server/game/internal/game_rule.go
================================================
package internal
import (
"github.com/golang/glog"
"server/protocol"
"server/model"
"server/algorithm"
"time"
"github.com/dolotech/lib/utils"
)
func (r *Room) startDelay(startDelay *startDelay, o *Occupant) {
if startDelay.kind == 0 {
r.Info()
r.start()
}
}
func (r *Room) start() {
if r.status == RUNNING {
return
}
// 产生庄
var dealer *Occupant
button := r.Button - 1
r.Each((button+1)%r.Cap(), func(o *Occupant) bool {
r.Button = o.Pos
dealer = o
return false
})
if dealer == nil {
return
}
r.remain = 0
r.allin = 0
// 剔除筹码小于大盲和离线的玩家
n := 0
r.Each(0, func(o *Occupant) bool {
if o.chips < r.BB || o.IsOffline() {
o.SetSitdown()
return true
}
o.SetGameing()
n ++
return true
})
// 2人及以上才开始游戏
if n < 2 {
return
}
r.status = RUNNING
// 洗牌
r.Cards.Shuffle()
// 产生小盲
sb := r.next(dealer.Pos)
if n == 2 { // one-to-one
sb = dealer
}
// 产生大盲
bb := r.next(sb.Pos)
bbPos := bb.Pos
// 通报本局庄家
r.WriteMsg(&protocol.Button{Uid: dealer.Uid})
// 小大盲下注
r.betting(sb, int32(r.SB))
r.betting(bb, int32(r.BB))
// Round 1 : preflop
r.ready()
r.Each(0, func(o *Occupant) bool {
o.cards = algorithm.Cards{r.Cards.Take(), r.Cards.Take()}
kind, _ := algorithm.De(o.cards.GetType())
m := &protocol.PreFlop{
Cards: o.cards.Bytes(),
Kind: kind,
}
o.WriteMsg(m)
return true
})
r.Broadcast(&protocol.PreFlop{}, false)
r.action(0)
if r.remain <= 1 {
goto showdown
}
r.calc()
// Round 2 : Flop
r.ready()
r.Cards = algorithm.Cards{r.Cards.Take(), r.Cards.Take(), r.Cards.Take()}
r.Each(0, func(o *Occupant) bool {
cs := r.Cards.Append(o.cards...)
kind, _ := algorithm.De(cs.GetType())
m := &protocol.Flop{
Cards: cs.Bytes(),
Kind: kind,
}
o.WriteMsg(m)
return true
})
r.Broadcast(&protocol.Flop{Cards: r.Cards.Bytes()}, false)
r.action(0)
if r.remain <= 1 {
goto showdown
}
r.calc()
// Round 3 : Turn
r.ready()
r.Cards = r.Cards.Append(r.Cards.Take())
r.Each(0, func(o *Occupant) bool {
cs := r.Cards.Append(o.cards...)
kind, _ := algorithm.De(cs.GetType())
m := &protocol.Turn{
Card: r.Cards[3],
Kind: kind,
}
o.WriteMsg(m)
return true
})
r.Broadcast(&protocol.Turn{Card: r.Cards[3]}, false)
r.action(0)
if r.remain <= 1 {
goto showdown
}
r.calc()
// Round 4 : River
r.ready()
r.Cards = r.Cards.Append(r.Cards.Take())
r.Each(0, func(o *Occupant) bool {
cs := r.Cards.Append(o.cards...)
value := cs.GetType()
kind, _ := algorithm.De(value)
m := &protocol.River{
Card: r.Cards[4],
Kind: kind,
}
o.WriteMsg(m)
o.HandValue = value
return true
})
r.Broadcast(&protocol.River{Card: r.Cards[4]}, false)
r.action(0)
showdown:
r.showdown()
showdown := &protocol.Showdown{}
for _, o := range r.Occupants {
if o != nil && o.IsGameing() {
o.SetSitdown()
item := &protocol.ShowdownItem{
Uid: o.Uid,
ChipsWin: r.Chips[o.Pos-1],
Chips: o.chips,
}
showdown.Showdown = append(showdown.Showdown, item)
}
}
r.Broadcast(showdown, true)
r.Info(sb.Pos, bbPos)
r.status = GAMEOVER
time.AfterFunc(time.Second*2, func() {
defer utils.PrintPanicStack()
r.Send(nil, &startDelay{})
})
}
func (r *Room) calc() (pots []handPot) {
pots = calcPot(r.Chips)
r.Pot = r.Pot[:]
var ps []uint32
for _, pot := range pots {
r.Pot = append(r.Pot, pot.Pot)
ps = append(ps, pot.Pot)
}
r.Broadcast(&protocol.Pot{Pot: ps}, true)
return
}
func (r *Room) action(pos uint8) {
if r.allin+1 >= r.remain {
return
}
var skip uint8
if pos == 0 { // start from left hand of button
pos = (r.Button)%r.Cap() + 1
}
for {
var raised uint8
r.Each(pos-1, func(o *Occupant) bool {
if r.remain <= 1 {
return false
}
if o.Pos == skip || o.chips == 0 {
return true
}
r.WriteMsg(&protocol.BetPrompt{})
n := o.GetAction(r.Timeout)
if r.remain <= 1 {
return false
}
if r.betting(o, n) {
raised = o.Pos
return false
}
return true
})
if raised == 0 {
break
}
pos = raised
skip = pos
}
}
func (r *Room) ready() {
r.Bet = 0
r.Each(0, func(o *Occupant) bool {
o.Bet = 0
o.waitAction = false
r.remain++
o.HandValue = 0
return true
})
}
// 比牌
func (r *Room) showdown() {
pots := r.calc()
for i, _ := range r.Chips {
r.Chips[i] = 0
}
for _, pot := range pots {
var maxO *Occupant
for _, pos := range pot.OPos {
o := r.Occupants[pos-1]
if o != nil && len(o.cards) > 0 {
if maxO == nil {
maxO = o
continue
}
if o.HandValue > maxO.HandValue {
maxO = o
}
}
}
var winners []uint8
for _, pos := range pot.OPos {
o := r.Occupants[pos-1]
if o != nil && o.HandValue == maxO.HandValue && o.IsGameing() {
winners = append(winners, o.Pos)
}
}
if len(winners) == 0 {
glog.Errorln("!!!no winners!!!")
return
}
for _, winner := range winners {
r.Chips[winner-1] += pot.Pot / uint32(len(winners))
}
r.Chips[winners[0]-1] += pot.Pot % uint32(len(winners)) // odd chips
}
for i, _ := range r.Chips {
if r.Occupants[i] != nil {
r.Occupants[i].chips += r.Chips[i]
}
}
}
func (r *Room) betting(o *Occupant, n int32) (raised bool) {
if n > int32(o.chips) || // 手上筹码不足
(n == 0 && o.Bet != r.Bet) || // 让牌
(n > 0 && n != int32(o.chips) && ((n + int32(o.Bet)) < int32(r.Bet))) {
glog.Errorf("下注筹码不合法!!！ n:%d p.Bet:%d p.Chips:%d t.Bet:%d", n, o.Bet, o.chips, r.Bet)
return
}
value := n
actionName := ""
if n < 0 {
actionName = model.BET_FOLD
n = 0
r.remain--
o.SetSitdown()
} else if n == 0 {
actionName = model.BET_CHECK
} else if uint32(n)+o.Bet <= r.Bet {
actionName = model.BET_CALL
o.chips -= uint32(n)
o.Bet += uint32(n)
} else {
actionName = model.BET_RAISE
o.chips -= uint32(n)
o.Bet += uint32(n)
r.Bet = o.Bet
raised = true
}
if o.chips == 0 {
r.allin++
actionName = model.BET_ALLIN
}
r.Chips[o.Pos-1] += uint32(n)
r.Broadcast(&protocol.BetBroadcast{
Uid: o.Uid,
Kind: actionName,
Value: value,
}, true)
return
}
func (r *Room) next(pos uint8) *Occupant {
volume := r.Cap()
for i := (pos) % volume; i != pos-1; i = (i + 1) % volume {
if r.Occupants[i] != nil && r.Occupants[i].IsGameing() {
return r.Occupants[i]
}
}
return nil
}
================================================
FILE: src/server/game/internal/module.go
================================================
package internal
import (
"github.com/dolotech/leaf/module"
"server/base"
"github.com/golang/glog"
"server/protocol"
"github.com/dolotech/leaf/room"
"reflect"
"server/model"
)
var (
skeleton = base.NewSkeleton()
ChanRPC = skeleton.ChanRPCServer
)
func handler(m interface{}, h interface{}) {
skeleton.RegisterChanRPC(reflect.TypeOf(m), h)
}
func init() {
handler(&protocol.JoinRoom{}, room.OnMessage)
handler(&protocol.LeaveRoom{}, room.OnMessage)
handler(&protocol.Bet{}, room.OnMessage)
handler(&protocol.SitDown{}, room.OnMessage) //
handler(&protocol.StandUp{}, room.OnMessage) //
handler(&protocol.Chat{}, room.OnMessage) //
}
type Module struct {
*module.Skeleton
}
func (m *Module) OnInit() {
m.Skeleton = skeleton
room.Init(&Creator{})
}
func (m *Module) OnDestroy() {
glog.Errorln("OnDestroy")
}
type Creator struct{}
// 对玩家未进入房间，或者没房间数据的处理
func (this *Creator) Create(m interface{}) room.IRoom {
if msg, ok := m.(*protocol.JoinRoom); ok {
if len(msg.RoomNumber) == 0 {
r := room.FindRoom()
return r
}
r := room.GetRoom(msg.RoomNumber)
if r != nil {
return r
}
room := NewRoom(9, 5, 10, 1000, model.Timeout)
room.Insert()
return room
}
return nil
}
================================================
FILE: src/server/game/internal/occupant.go
================================================
package internal
import (
"server/model"
"github.com/dolotech/leaf/gate"
"server/algorithm"
"time"
"errors"
"github.com/dolotech/leaf/room"
)
type Occupant struct {
*model.User
gate.Agent
room room.IRoom
cards algorithm.Cards
Pos uint8 // 玩家座位号，从1开始
status int32 // 1为离线状态
Bet uint32 // 当前下注
actions chan int32
waitAction bool
chips uint32 // 带入的筹码
HandValue uint32
}
const (
Occupant_status_InGame int32 = 3
Occupant_status_Offline int32 = 1
Occupant_status_Observe int32 = 2
Occupant_status_Sitdown int32 = 0
)
func (o *Occupant) GetRoom() room.IRoom {
return o.room
}
func (o *Occupant) SetRoom(m room.IRoom) {
o.room = m
}
func (o *Occupant) SetAction(n int32)error {
if o.waitAction {
o.actions <- n
return nil
}
return errors.New("not your action")
}
func (o *Occupant) GetAction(timeout time.Duration) int32 {
timer := time.NewTimer(timeout)
o.waitAction = true
select {
case n := <-o.actions:
timer.Stop()
o.waitAction = false
return n
case <-o.room.Closed():
timer.Stop()
o.waitAction = false
return -1
case <-timer.C:
o.waitAction = false
timer.Stop()
return -1 // 超时弃牌
}
}
func (o *Occupant)SetPos(pos uint8) {
o.Pos = pos
}
func (o *Occupant) GetPos() uint8 {
return o.Pos
}
func (o *Occupant) GetUid() uint32 {
return o.Uid
}
func (o *Occupant) WriteMsg(msg interface{}) {
if o.status != Occupant_status_Offline {
o.Agent.WriteMsg(msg)
}
}
func (o *Occupant) SetData(d interface{}) {
o.User = d.(*model.User)
}
func (o *Occupant) GetId() uint32 {
return o.Uid
}
func (o *Occupant) SetObserve() {
o.status = Occupant_status_Observe
}
func (o *Occupant) IsObserve() bool {
return o.status == Occupant_status_Observe
}
func (o *Occupant) SetOffline() {
o.status = Occupant_status_Offline
}
func (o *Occupant) IsOffline() bool {
return o.status == Occupant_status_Offline
}
func (o *Occupant) SetSitdown() {
o.status = Occupant_status_Sitdown
}
func (o *Occupant) IsSitdown() bool {
return o.status == Occupant_status_Sitdown
}
func (o *Occupant) SetGameing() {
o.status = Occupant_status_InGame
}
func (o *Occupant) IsGameing() bool {
return o.status == Occupant_status_InGame
}
func (o *Occupant) Replace(value *Occupant) {
o.Pos = value.Pos
o.cards = value.cards
o.room = value.room
}
func NewOccupant(data *model.User, conn gate.Agent) *Occupant {
o := &Occupant{
User: data,
Agent: conn,
actions: make(chan int32),
}
return o
}
================================================
FILE: src/server/game/internal/pot.go
================================================
package internal
import (
"sort"
)
type handBet struct {
Pos uint8
Bet uint32
}
type handBets []handBet
func (p handBets) Len() int {
return len(p)
}
func (p handBets) Less(i, j int) bool {
return p[i].Bet < p[j].Bet
}
func (p handBets) Swap(i, j int) {
p[i], p[j] = p[j], p[i]
}
type handPot struct {
Pot uint32
OPos []uint32
}
//因为每个人手中的筹码量会不时的产生变化，当出现多个筹码量不等的玩家“全下(ALL-IN)”争夺底池的时候就会出现多个奖池，
//这时候底池将分出主池和边池，主池里的筹码可 由任何一位争夺者胜利后将其拿走，其后每个边池将分别由参与者按牌型大小分别拿走。
//举个例子，假如发到河牌后共有三个人争夺底池，三人分别用ABC代替，
//假设A玩家手中有60，B手中有80，C手中有100。三人ALL-IN后则先把每人的筹码划分成：
//A玩家60；B玩家60+20；C玩家60+20+20，然后分出底池：
//主池 由60乘以三个人(A+B+C)形成一个堆，总额为180；
//边池一 由20乘以剩下的两个人(B+C)多出的部分为一个堆，总额为40；
//边池二 由筹码最多者C的多出的部分20单独组成一个堆，总额为20。
//现在三个底池形成了，然后分别按照牌型的大小来决定谁拿走哪个底池……
//首先，主池可以由三人中的任何一人得到胜利都可以拿走；
// 但是边池一的争夺就只能在B与C之间产生，两人谁赢谁拿走，与A无关(就算A玩家的牌最大也只能拿走他参与的主池)。
//而最后剩下的边池二不论三人谁输谁赢都只能由C拿走，因为边池二里的筹码只有C自己参与了，与其他人无关。
func calcPot(bets []uint32) (pots []handPot) {
var obs handBets
for i, bet := range bets {
if bet > 0 {
obs = append(obs, handBet{Pos: uint8(i) + 1, Bet: bet})
}
}
sort.Sort(obs)
for i, ob := range obs {
if ob.Bet > 0 {
s := obs[i:]
hpot := handPot{Pot: ob.Bet * uint32(len(s))}
for j, _ := range s {
s[j].Bet -= ob.Bet
hpot.OPos = append(hpot.OPos, uint32(s[j].Pos))
}
pots = append(pots, hpot)
}
}
return
}
================================================
FILE: src/server/game/internal/pot_test.go
================================================
package internal
import "testing"
func Test_Pot(t *testing.T) {
bets := []uint32{60,80,90,0,0,0,0,0,0}
res:=calcPot(bets)
//[{180 [1 2 3]} {40 [2 3]} {10 [3]}]
t.Log(res)
bets = []uint32{60,60,60,0,0,0,0,0,0}
res=calcPot(bets)
//[{180 [1 2 3]}]
t.Log(res)
a:= []byte{}
a = nil
t.Log(len(a))
}
================================================
FILE: src/server/game/internal/room.go
================================================
package internal
import (
"server/model"
"server/protocol"
"server/algorithm"
"time"
"github.com/dolotech/leaf/room"
"github.com/golang/glog"
)
const (
RUNNING uint8= 1
GAMEOVER uint8= 0
)
type Room struct {
*model.Room
*room.MsgLoop
*room.Log
Occupants []*Occupant
observes []*Occupant // 站起的玩家
AutoSitdown []*Occupant // 自动坐下队列
remain int
allin int
n uint8
status uint8
SB uint32 // 小盲注
BB uint32 // 大盲注
Cards algorithm.Cards // 公共牌
Pot []uint32 // 奖池筹码数, 第一项为主池，其他项(若存在)为边池
Timeout time.Duration // 倒计时超时时间(秒)
Button uint8 // 当前庄家座位号，从1开始
Chips []uint32 // 玩家本局下注的总筹码数，与occupants一一对应
Bet uint32 // 当前回合 上一玩家下注额
Max uint8 // 房间最大玩家人数
MaxChips uint32
MinChips uint32
}
func NewRoom(max uint8, sb, bb uint32, chips uint32, timeout uint8) *Room {
if max <= 0 || max > 9 {
max = 9 // default 9 Occupants
}
r := &Room{
Room: &model.Room{DraginChips: chips,},
MsgLoop: room.NewMsgLoop(),
Chips: make([]uint32, max),
Occupants: make([]*Occupant, max),
Pot: make([]uint32, 0, max),
Timeout: time.Second * time.Duration(timeout),
SB: sb,
BB: bb,
Max: max,
}
r.Log = room.NewLog(r)
r.Regist(&protocol.JoinRoom{}, r.joinRoom)
r.Regist(&protocol.LeaveRoom{}, r.leaveRoom)
r.Regist(&protocol.Bet{}, r.bet)
r.Regist(&protocol.SitDown{}, r.sitDown) //
r.Regist(&protocol.StandUp{}, r.standUp) //
r.Regist(&protocol.Chat{}, r.chat) //
r.Regist(&protocol.Chat{}, r.chat) //
r.Regist(&startDelay{}, r.startDelay) //
return r
}
type startDelay struct {
kind uint8
}
func (r *Room) New(m interface{}) room.IRoom {
glog.Errorln(r, m)
if msg, ok := m.(*protocol.JoinRoom); ok {
if len(msg.RoomNumber) == 0 {
r := room.FindRoom()
return r
}
r := room.GetRoom(msg.RoomNumber)
if r != nil {
return r
}
room := NewRoom(9, 5, 10, 1000, model.Timeout)
room.Insert()
return room
}
return nil
}
func (r *Room) WriteMsg(msg interface{}, exc ...uint32) {
for _, v := range r.Occupants {
if v != nil {
for _, uid := range exc {
if uid == v.GetUid() {
goto End
}
}
v.WriteMsg(msg)
}
End:
}
}
func (r *Room) Broadcast(msg interface{}, all bool, exc ...uint32) {
for _, v := range r.Occupants {
if v != nil && (all || !v.IsGameing()) {
for _, uid := range exc {
if uid == v.GetUid() {
goto End1
}
}
v.WriteMsg(msg)
}
End1:
}
for _, v := range r.observes {
if v != nil {
for _, uid := range exc {
if uid == v.Uid {
goto End
}
}
v.WriteMsg(msg)
}
End:
}
}
func (r *Room) addOccupant(o *Occupant) uint8 {
for _, v := range r.Occupants {
if v != nil && v.GetUid() == o.Uid {
return 0
}
}
for k, v := range r.Occupants {
if v == nil {
r.Occupants[k] = o
o.SetRoom(r)
o.Pos = uint8(k + 1)
o.SetSitdown()
return o.Pos
}
}
return 0
}
func (r *Room) removeOccupant(o *Occupant) uint8 {
for k, v := range r.Occupants {
if v != nil && v.GetUid() == o.Uid {
v.SetPos(0)
r.Occupants[k] = nil
return uint8(k + 1)
}
}
return 0
}
func (r *Room) addObserve(o *Occupant) uint8 {
for _, v := range r.observes {
if v != nil && v.Uid == o.Uid {
return 0
}
}
o.SetObserve()
r.observes = append(r.observes, o)
return 0
}
func (r *Room) removeObserve(o *Occupant) {
for k, v := range r.observes {
if v != nil && v.Uid == o.Uid {
r.observes = append(r.observes[:k], r.observes[k+1:]...)
return
}
}
}
// start starts from 0
func (r *Room) Each(start uint8, f func(o *Occupant) bool) {
volume := r.Cap()
end := (volume + start - 1) % volume
i := start
for ; i != end; i = (i + 1) % volume {
if r.Occupants[i] != nil && r.Occupants[i].IsGameing() && !f(r.Occupants[i]) {
return
}
}
// end
if r.Occupants[i] != nil && r.Occupants[i].IsGameing() {
f(r.Occupants[i])
}
}
func (r *Room) Cap() uint8 {
return r.Max
}
func (r *Room) Len() uint8 {
var num uint8
for _, v := range r.Occupants {
if v != nil {
num ++
}
}
return num
}
func (r *Room) GetNumber() string {
return r.Number
}
func (r *Room) SetNumber(value string) {
r.Number = value
}
func (r *Room) Data() interface{} { return r.Room }
func (r *Room) SetData(d interface{}) {
r.Room = d.(*model.Room)
}
================================================
FILE: src/server/game/internal/room_internal_handler.go
================================================
package internal
import (
"server/protocol"
"github.com/golang/glog"
"github.com/davecgh/go-spew/spew"
"time"
"github.com/dolotech/lib/utils"
)
func (r *Room) joinRoom(m *protocol.JoinRoom, o *Occupant) {
if o.room != nil {
for k, v := range r.Occupants {
glog.Infoln(v, o)
if v.Uid == o.Uid {
// todo 掉线重连现场数据替换处理
o.Replace(r.Occupants[k])
r.Occupants[k] = o
if o != v {
v.Close()
glog.Infoln("掉线重连处理")
} else {
glog.Infoln("同一个链接重复请求加入房间")
}
r.WriteMsg(&protocol.UserInfo{Uid: o.Uid}, o.Uid)
return
}
}
}
rinfo := &protocol.RoomInfo{
Number: r.Number,
}
userinfos := make([]*protocol.UserInfo, 0, r.Cap())
r.Each(0, func(o *Occupant) bool {
userinfo := &protocol.UserInfo{
Nickname: o.Nickname,
Uid: o.Uid,
Account: o.Account,
Sex: o.Sex,
Profile: o.Profile,
Chips: o.chips,
}
userinfos = append(userinfos, userinfo)
return true
})
pos := r.addOccupant(o)
// 坐下失败转为旁观
if pos == 0 {
r.addObserve(o)
} else {
userInfo := &protocol.UserInfo{
Nickname: o.Nickname,
Uid: o.Uid,
Account: o.Account,
Sex: o.Sex,
Profile: o.Profile,
Chips: o.chips,
}
r.Broadcast(&protocol.JoinRoomBroadcast{UserInfo: userInfo}, true, o.Uid)
}
o.RoomID = r.Number
o.UpdateRoomId()
o.WriteMsg(&protocol.JoinRoomResp{UserInfos: userinfos, RoomInfo: rinfo})
time.AfterFunc(time.Second*2, func() {
defer utils.PrintPanicStack()
r.Send(o,&startDelay{})
})
r.Debug("joinRoom", spew.Sdump(m))
}
func (r *Room) leaveAndRecycleChips(o *Occupant) {
if r.removeOccupant(o) > 0 {
// 玩家站起回收带入筹码
gap := int32(o.chips) - int32(r.DraginChips)
if gap == 0 {
o.UpdateChips(gap)
}
}
}
func (r *Room) leaveRoom(m *protocol.LeaveRoom, o *Occupant) {
r.removeObserve(o)
r.removeOccupant(o)
r.leaveAndRecycleChips(o)
o.RoomID = ""
o.room = nil
o.UpdateRoomId()
leave := &protocol.LeaveRoom{
RoomNumber: r.Number,
Uid: o.Uid,
}
r.Broadcast(leave, true)
r.Debug()
// 房间里没有玩家时关闭并从列表中删除
if r.Len() == 0 {
r.Close(r)
}
glog.Errorln("leaveRoom", m)
}
func (r *Room) bet(m *protocol.Bet, o *Occupant) {
if !o.IsGameing() {
o.WriteMsg(protocol.MSG_NOT_NOT_START)
return
}
if m.Value < 0 {
err := o.SetAction(-1)
if err != nil {
o.WriteMsg(protocol.MSG_NOT_TURN)
}
} else {
err := o.SetAction(m.Value)
if err != nil {
o.WriteMsg(protocol.MSG_NOT_TURN)
}
}
glog.Errorln("bet", m)
}
func (r *Room) sitDown(m *protocol.SitDown, o *Occupant) {
pos := r.addOccupant(o)
if pos == 0 {
// 给进入房间的玩家带入筹码
o.chips = r.DraginChips
r.addObserve(o)
} else {
}
r.Broadcast(&protocol.SitDown{Uid: o.Uid, Pos: o.Pos}, true)
glog.Errorln("sitDown", m)
}
func (r *Room) standUp(m *protocol.StandUp, o *Occupant) {
o.SetAction(-1)
r.leaveAndRecycleChips(o)
r.addObserve(o)
r.Broadcast(&protocol.StandUp{Uid: o.Uid}, true)
glog.Errorln("standUp", m)
}
func (r *Room) chat(m *protocol.Chat, o *Occupant) {
r.Broadcast(m, true)
}
================================================
FILE: src/server/game/internal/room_test.go
================================================
package internal
import (
"testing"
"time"
"reflect"
)
func TestRoom_Value(t *testing.T) {
t.Log(reflect.ValueOf(12))
}
func TestRoom_RecvMsg(t *testing.T) {
/*room:= NewRoom(&model.Room{})
protocol:= &msg2.JoinRoom{RoomNumber:"9999"}
room.Send(12,protocol)
*/
//msg1:= &msg2.LeaveRoom{RoomNumber:"9999"}
//room.RecvMsg(12,msg1)
time.Sleep(time.Second * 2)
}
func TestClose(t *testing.T) {
c:= make(chan struct{},1)
go func() {
select {
case <-c:
default:
t.Log("default")
}
}()
<- time.After(time.Second)
close(c)
select {
case c<- struct{}{}:
default:
t.Log("default")
}
<- time.After(time.Second)
}
func BenchmarkCloseRoom(t *testing.B) {
/*
for i:=0;i