// CHECK for STRAIGHT
            // if its not a flush, check for straight
            if (retval == 0 && nBitsTable[allRanks] >= 5)
            {
                uint allRanks2;
                if ((allRanks2 = (allRanks & (allRanks << 1))) != 0 &&
                    (allRanks2 &= (allRanks << 2)) != 0 &&
                    (allRanks2 &= (allRanks << 3)) != 0 &&
                    (allRanks2 &= (allRanks << 4)) != 0)
                {
                    do
                    {
                        // 31U = 11111 in binary, mask for the 65432 straight; left shifting the mask gives all other straights
                        uint straightMask = 31U << (topCardTable[allRanks2] - 4);
                        if ((nBitsTable[straightMask & holeRanks] >= 2) && (nBitsTable[straightMask & boardRanks] >= 3))
                        {
                            retval = HANDTYPE_VALUE_STRAIGHT + (uint)(topCardTable[allRanks2] << TOP_CARD_SHIFT);
                            break;
                        }
                        allRanks2 ^= (1U << topCardTable[allRanks2]);
                    } while (allRanks2 != 0);
                }
                if (retval == 0)
                {
                    // 4111U = 1000000001111 in binary, mask for the wheel (A5432) straight
                    if (((4111U & allRanks) == 4111U) && (nBitsTable[4111U & holeRanks] >= 2) && (nBitsTable[4111U & boardRanks] >= 3))
                    {
                        retval = HANDTYPE_VALUE_STRAIGHT + (3U << TOP_CARD_SHIFT);
                    }
                }
            } // end of CHECK for STRAIGHT

//check if straight
//NB: straights can be computed using a lookup-table for further performance increases. 715*1200ish bits..? alternatively 40bits per hand and table
for (int i=8;i>=0;i--) {
   short mask=0x1F<<i;
   if ((mask&totRanks)==mask && AtLeast2bit(holeRanks&mask) && countBits(tableRanks&mask) >2)
      return STRAIGHT_OFFSET+i+1;
}
short mask=0x100F;
if ((mask&totRanks) == mask && AtLeast2bit(holeRanks&mask) && countBits(tableRanks&mask) >2)   //A-5 straight
   return STRAIGHT_OFFSET;

// if current best hand beats current 7 card hand (hole + whole board), we dont need to test it
                        if (bestpocket > Evaluate(p | boardhand))
                            continue;

// if the very last tested player has the best hand already, there is no need to test the rest
                                if (actualBestPlayer == pockets.Length - 1)
                                {
                                    bestHandFound = true;
                                    break;
                                }

                for (int i = 0; i < pockets.Length; i++)
                {
                    result[i] = 0;

                    foreach (ulong p in pocketmasks[i])
                    {
                        // if current best hand beats current 7 card hand (hole + whole board), we dont need to test it
                        if (bestpocket > Evaluate(p | boardhand))
                            continue;

                        foreach (ulong b in boards)
                        {
                            if (result[i] < Evaluate(p | b))
                                result[i] = Evaluate(p | b);
                           
                            if (bestpocket < result[i])
                            {
                                bestpocket = result[i];
                                bestcount = 1;
                                actualBestPlayer = i;
                               
                               // if the very last tested player has the best hand already, there is no need to test the rest
                                if (actualBestPlayer == pockets.Length - 1)
                                {
                                    bestHandFound = true;
                                    break;
                                }
                            }
                            else if (bestpocket == result[i] && i != actualBestPlayer)
                            {
                                bestcount++;
                            }
                        }
                        if (bestHandFound) break;
                    }
                }

        public static void HandOddsOmaha(string[] pockets, string board, string dead, long[] wins, long[] ties, long[] losses, ref long totalHands)
        {
            ulong[][] pocketmasks = new ulong[pockets.Length][];
            ulong[][] pockethands = new ulong[pockets.Length][];
            int count = 0, bestcount = 0;
            ulong boardmask = 0UL;
            ulong deadcards_mask = 0UL, deadcards = Hand.ParseHand(dead, ref count);

            totalHands = 0;
            deadcards_mask |= deadcards;

            // Split 4 Omaha holecards into 6 combinations of Holdem 2 cards
            string[][] splitPockets = new string[pockets.Length][];
            for (int k = 0; k < splitPockets.Length; k++)
            {
                int index = 0;
                splitPockets[k] = new string[6];
                for (int i = 0; i < 4; i++)
                {
                    for (int j = i + 1; j < 4; j++)
                    {
                        splitPockets[k][index++] = pockets[k].Substring(i * 2, 2) + pockets[k].Substring(j * 2, 2);
                    }
                }
            }

            // Read pocket cards
            for (int i = 0; i < pockets.Length; i++)
            {
                count = 0;
                Hand.ParseHand(pockets[i], "", ref count);
                if (count != 4)
                    throw new ArgumentException("There must be four pocket cards."); // Must have 4 cards in each pocket card set.
               
                pocketmasks[i] = new ulong[6];
                pockethands[i] = new ulong[6];
                for (int j = 0; j < 6; j++)
                {
                    pocketmasks[i][j] = Hand.ParseHand(splitPockets[i][j], "", ref count);
                    deadcards_mask |= pocketmasks[i][j];
                }

                wins[i] = ties[i] = losses[i] = 0;
            }

            // Read board cards
            count = 0;
            boardmask = Hand.ParseHand("", board, ref count);
/*
#if DEBUG
            Debug.Assert(count >= 0 && count <= 5); // The board must have zero or more cards but no more than a total of 5

            // Check pocket cards, board, and dead cards for duplicates
            if ((boardmask & deadcards) != 0)
                throw new ArgumentException("Duplicate between cards dead cards and board");

            // Validate the input
            for (int i = 0; i < pockets.Length; i++)
            {
                for (int j = i + 1; j < pockets.Length; j++)
                {
                    if ((pocketmasks[i] & pocketmasks[j]) != 0)
                        throw new ArgumentException("Duplicate pocket cards");
                }

                if ((pocketmasks[i] & boardmask) != 0)
                    throw new ArgumentException("Duplicate between cards pocket and board");

                if ((pocketmasks[i] & deadcards) != 0)
                    throw new ArgumentException("Duplicate between cards pocket and dead cards");
            }
#endif
*/

            // Iterate through all board possibilities that don't include any pocket cards.
            foreach (ulong boardhand in Hands(boardmask, deadcards_mask, 5))
            {
                ulong bestpocket = 0;
                int n = 0;
                ulong[] cards = new ulong[5];
                int index = 0;
                while (n < 64 && index < 5)
                {
                    if ((boardhand & 1UL << n) != 0) // if n-th bit is 1, then assign card
                        cards[index++] = 1UL << n;
                    n++;
                }
                ulong[] boards = null;
                boards = new ulong[] { cards[0] | cards[1] | cards[2], cards[0] | cards[1] | cards[3], cards[0] | cards[1] | cards[4],
                    cards[0] | cards[2] | cards[3], cards[0] | cards[2] | cards[4], cards[0] | cards[3] | cards[4], cards[1] | cards[2] | cards[3],
                    cards[1] | cards[2] | cards[4], cards[1] | cards[3] | cards[4], cards[2] | cards[3] | cards[4] };               

                ulong[] result = new ulong[pockets.Length];
                int actualBestPlayer = 0;
                for (int i = 0; i < pockets.Length; i++)
                {
                    result[i] = 0;
                    foreach (ulong p in pocketmasks[i])
                    {
                        foreach (ulong b in boards)
                        {
                            if (result[i] < Evaluate(p | b))
                                result[i] = Evaluate(p | b);
                           
                            if (bestpocket < result[i])
                            {
                                bestpocket = result[i];
                                bestcount = 1;
                                actualBestPlayer = i;
                            }
                            else if (bestpocket == result[i] && i != actualBestPlayer)
                            {
                                bestcount++;
                            }
                        }
                    }
                }

                // Calculate wins/ties/loses for each pocket + board combination.
                for (int i = 0; i < pockets.Length; i++)
                {
                    if (result[i] == bestpocket)
                    {
                        if (bestcount > 1)
                        {
                            ties[i]++;
                        }
                        else
                        {
                            wins[i]++;
                        }
                    }
                    else if (result[i] < bestpocket)
                    {
                        losses[i]++;
                    }
                }

                totalHands++;

            }
        }