From a1c619f528d30292b3d33acf13e08f9f52ac0cbf Mon Sep 17 00:00:00 2001 From: Bo Haglund Date: Wed, 15 Oct 2014 12:25:54 -0400 Subject: [PATCH] historical commit dds 2.7.0 --- ABsearch.cpp | 1671 ++++++++++++ ABsearch.h | 67 + ABstats.cpp | 643 +++++ ABstats.h | 173 ++ CalcTables.cpp | 198 ++ DLL-dds_260_u.rtf | 2665 ------------------- DLL-dds_270_v.rtf | Bin 0 -> 58941 bytes DealerPar.cpp | 187 +- Exports.def | 54 + Init.cpp | 737 ++++++ Init.h | 21 + LaterTricks.cpp | 314 +++ LaterTricks.h | 15 + Moves.cpp | 1383 ++++++++++ Moves.h | 14 + PBN.cpp | 193 ++ PBN.h | 11 + Par.cpp | 569 ++++- PlayAnalyser.cpp | 167 +- QuickTricks.cpp | 1235 +++++++++ QuickTricks.h | 17 + SolveBoard.cpp | 326 +++ SolveBoard.h | 6 + SolverIF.cpp | 1122 ++++++++ Stats.cpp | 248 ++ Stats.h | 23 + Timer.cpp | 720 ++++++ Timer.h | 282 +++ TransTable.cpp | 1862 ++++++++++++++ TransTable.h | 757 ++++++ dds.cpp | 6173 +-------------------------------------------- dds.h | 312 ++- debug.h | 116 + dll.h | 626 ++--- portab.h | 60 + readme.txt | 16 +- release_notes.txt | 9 +- 37 files changed, 13438 insertions(+), 9554 deletions(-) create mode 100644 ABsearch.cpp create mode 100644 ABsearch.h create mode 100644 ABstats.cpp create mode 100644 ABstats.h create mode 100644 CalcTables.cpp delete mode 100644 DLL-dds_260_u.rtf create mode 100644 DLL-dds_270_v.rtf create mode 100644 Exports.def create mode 100644 Init.cpp create mode 100644 Init.h create mode 100644 LaterTricks.cpp create mode 100644 LaterTricks.h create mode 100644 Moves.cpp create mode 100644 Moves.h create mode 100644 PBN.cpp create mode 100644 PBN.h create mode 100644 QuickTricks.cpp create mode 100644 QuickTricks.h create mode 100644 SolveBoard.cpp create mode 100644 SolveBoard.h create mode 100644 SolverIF.cpp create mode 100644 Stats.cpp create mode 100644 Stats.h create mode 100644 Timer.cpp create mode 100644 Timer.h create mode 100644 TransTable.cpp create mode 100644 TransTable.h create mode 100644 debug.h create mode 100644 portab.h diff --git a/ABsearch.cpp b/ABsearch.cpp new file mode 100644 index 00000000..37030b8c --- /dev/null +++ b/ABsearch.cpp @@ -0,0 +1,1671 @@ +/* + DDS 2.7.0 A bridge double dummy solver. + Copyright (C) 2006-2014 by Bo Haglund + Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. + The code for calculation of par score / contracts is based upon the + perl code written by Matthew Kidd for ACBLmerge. He has kindly given + permission to include a C++ adaptation in DDS. + + The PlayAnalyser analyses the played cards of the deal and presents + their double dummy values. The par calculation function DealerPar + provides an alternative way of calculating and presenting par + results. Both these functions have been written by Soren Hein. + He has also made numerous contributions to the code, especially in + the initialization part. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + + +#include "dds.h" +#include "TransTable.h" +#include "Moves.h" +#include "QuickTricks.h" +#include "LaterTricks.h" +#include "ABsearch.h" + + +#define DDS_POS_LINES 5 +#define DDS_HAND_LINES 12 +#define DDS_NODE_LINES 4 +#define DDS_FULL_LINE 80 +#define DDS_HAND_OFFSET 16 +#define DDS_HAND_OFFSET2 12 +#define DDS_DIAG_WIDTH 34 + + +bool ABsearch0( + struct pos * posPoint, + int target, + int depth, + struct localVarType * thrp); + +bool ABsearch1( + struct pos * posPoint, + int target, + int depth, + struct localVarType * thrp); + +bool ABsearch2( + struct pos * posPoint, + int target, + int depth, + struct localVarType * thrp); + +bool ABsearch3( + struct pos * posPoint, + int target, + int depth, + struct localVarType * thrp); + +struct evalType Evaluate( + struct pos * posPoint, + int trump, + localVarType * thrp); + +void Make( + struct pos * posPoint, + unsigned short int trickCards[DDS_SUITS], + int depth, + int trump, + struct movePlyType * mply, + struct localVarType * thrp); + +void Undo( + struct pos * posPoint, + int depth, + struct movePlyType * mply, + struct localVarType * thrp); + +bool NextMove( + struct pos * posPoint, + int depth, + struct movePlyType * mply, + struct localVarType * thrp); + +bool NextMoveNew( + unsigned short int winRanks[DDS_SUITS], + unsigned short int lowestWin[DDS_SUITS], + struct movePlyType * mply); + +void RankToText( + unsigned short int rankInSuit[DDS_HANDS][DDS_SUITS], + char text[DDS_HAND_LINES][DDS_FULL_LINE]); + +void RankToDiagrams( + unsigned short int rankInSuit[DDS_HANDS][DDS_SUITS], + struct nodeCardsTYpe * np, + char text[DDS_HAND_LINES][DDS_FULL_LINE]); + +void WinnersToText( + unsigned short int winRanks[DDS_SUITS], + char text[DDS_SUITS][DDS_FULL_LINE]); + +void PlyToText( + struct movePlyType * mply, + int depth, + int firstHand, + char text[DDS_FULL_LINE]); + +void NodeToText( + struct nodeCardsType * np, + char text[DDS_NODE_LINES][DDS_FULL_LINE]); + +void FullNodeToText( + struct nodeCardsType * np, + char text[DDS_NODE_LINES][DDS_FULL_LINE]); + +void PosToText( + struct pos * posPoint, + int target, + int depth, + char text[DDS_POS_LINES][DDS_FULL_LINE]); + +void DumpRetrieved( + FILE * fp, + struct pos * posPoint, + struct nodeCardsType * np, + int target, + int depth); + +void DumpStored( + FILE * fp, + struct pos * posPoint, + struct movePlyType mply[], + struct nodeCardsType * np, + int target, + int depth); + + +const int handDelta[DDS_SUITS] = { 256, 16, 1, 0 }; + + +// The top-level debugging should possibly go in SolveBoard.cpp +// at some point, but it's so similar to the code here that I +// leave it in this file for now. + +void InitFileTopLevel(int thrId) +{ +#ifdef DDS_TOP_LEVEL + struct localVarType * thrp = &localVar[thrId]; + + char fname[DDS_FNAME_LEN]; + sprintf(fname, "%s%d%s", + DDS_TOP_LEVEL_PREFIX, + thrId, + DDS_DEBUG_SUFFIX); + + thrp->fpTopLevel = fopen(fname, "w"); + if (! thrp->fpTopLevel) + thrp->fpTopLevel = stdout; +#endif +} + + +void InitFileABstats(int thrId) +{ +#ifdef DDS_AB_STATS + struct localVarType * thrp = &localVar[thrId]; + + char fname[DDS_FNAME_LEN]; + sprintf(fname, "%s%d%s", + DDS_AB_STATS_PREFIX, + thrId, + DDS_DEBUG_SUFFIX); + + thrp->ABstats.SetFile(fname); + + thrp->ABstats.SetName(AB_TARGET_REACHED, "Target decided"); + thrp->ABstats.SetName(AB_DEPTH_ZERO , "depth == 0"); + thrp->ABstats.SetName(AB_QUICKTRICKS , "QuickTricks"); + thrp->ABstats.SetName(AB_LATERTRICKS , "LaterTricks"); + thrp->ABstats.SetName(AB_MAIN_LOOKUP , "Main lookup"); + thrp->ABstats.SetName(AB_SIDE_LOOKUP , "Other lookup"); + thrp->ABstats.SetName(AB_MOVE_LOOP , "Move trial"); +#endif +} + + +void InitFilesABhits(int thrId) +{ +#ifdef DDS_AB_HITS + struct localVarType * thrp = &localVar[thrId]; + + char fname[DDS_FNAME_LEN]; + sprintf(fname, "%s%d%s", + DDS_AB_HITS_RETRIEVED_PREFIX, + thrId, + DDS_DEBUG_SUFFIX); + + thrp->fpRetrieved = fopen(fname, "w"); + if (! thrp->fpRetrieved) + thrp->fpRetrieved = stdout; + + sprintf(fname, "%s%d%s", + DDS_AB_HITS_STORED_PREFIX, + thrId, + DDS_DEBUG_SUFFIX); + + thrp->fpStored = fopen(fname, "w"); + if (! thrp->fpStored) + thrp->fpStored = stdout; +#endif +} + + +void InitFileTTstats(int thrId) +{ +#ifdef DDS_TT_STATS + struct localVarType * thrp = &localVar[thrId]; + + char fname[DDS_FNAME_LEN]; + sprintf(fname, "%s%d%s", + DDS_TT_STATS_PREFIX, + thrId, + DDS_DEBUG_SUFFIX); + + thrp->transTable.SetFile(fname); +#endif +} + + +void InitFileTimer(int thrId) +{ +#ifdef DDS_TIMING + Timer * timerp = &localVar[thrId].timer; + + char fname[DDS_FNAME_LEN]; + sprintf(fname, "%s%d%s\0", + DDS_TIMING_PREFIX, + thrId, + DDS_DEBUG_SUFFIX); + + timerp->SetFile(fname); + + timerp->SetNames(); +#endif +} + + +void CloseFileTopLevel(localVarType * thrp) +{ +#ifdef DDS_TOP_LEVEL + if (thrp->fpTopLevel != stdout) + fclose(thrp->fpTopLevel); +#endif +} + + +void CloseFilesABhits(localVarType * thrp) +{ +#ifdef DDS_AB_HITS + if (thrp->fpStored != stdout) + fclose(thrp->fpStored); +#endif +} + + +bool ABsearch( + struct pos * posPoint, + int target, + int depth, + struct localVarType * thrp) +{ + /* posPoint points to the current look-ahead position, + target is number of tricks to take for the player, + depth is the remaining search length, must be positive, + the value of the subtree is returned. + This is a specialized AB function for handRelFirst == 0. */ + + struct movePlyType * mply = &thrp->movePly[depth]; + unsigned short int makeWinRank[DDS_SUITS]; + + int trump = thrp->trump; + int hand = posPoint->first[depth]; + int tricks = depth >> 2; + bool success = (thrp->nodeTypeStore[hand] == MAXNODE ? true : false); + bool value = ! success; + + assert(posPoint->handRelFirst == 0); + +#ifdef DDS_TOP_LEVEL + thrp->nodes++; +#endif + + TIMER_START(TIMER_MOVEGEN + depth); + int moveExists = MoveGen(posPoint, depth, trump, mply, thrp); + TIMER_END(TIMER_MOVEGEN + depth); + + mply->current = 0; + + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = 0; + + while (moveExists) + { + TIMER_START(TIMER_MAKE + depth); + Make(posPoint, makeWinRank, depth, trump, mply, thrp); + TIMER_END(TIMER_MAKE + depth); + + TIMER_START(TIMER_AB + depth - 1); + value = ABsearch1(posPoint, target, depth - 1, thrp); + TIMER_END(TIMER_AB + depth - 1); + + TIMER_START(TIMER_UNDO + depth); + Undo(posPoint, depth, mply, thrp); + TIMER_END(TIMER_UNDO + depth); + + if (value == success) /* A cut-off? */ + { + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = + posPoint->winRanks[depth - 1][ss] | makeWinRank[ss]; + + thrp->bestMove[depth] = mply->move[mply->current]; + goto ABexit; + } + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] |= + posPoint->winRanks[depth - 1][ss] | makeWinRank[ss]; + + TIMER_START(TIMER_NEXTMOVE + depth); + moveExists = NextMove(posPoint, depth, mply, thrp); + TIMER_END(TIMER_NEXTMOVE + depth); + } + +ABexit: + + AB_COUNT(AB_MOVE_LOOP, value, depth); +#ifdef DDS_AB_STATS + thrp->ABstats.PrintStats(); +#endif + + return value; +} + + +bool ABsearch0( + struct pos * posPoint, + int target, + int depth, + struct localVarType * thrp) +{ + /* posPoint points to the current look-ahead position, + target is number of tricks to take for the player, + depth is the remaining search length, must be positive, + the value of the subtree is returned. + This is a specialized AB function for handRelFirst == 0. */ + + struct movePlyType * mply = &thrp->movePly[depth]; + unsigned short int makeWinRank[DDS_SUITS]; + + int trump = thrp->trump; + int hand = posPoint->first[depth]; + int tricks = depth >> 2; + + assert(posPoint->handRelFirst == 0); + +#ifdef DDS_TOP_LEVEL + thrp->nodes++; +#endif + + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = 0; + + if (posPoint->tricksMAX >= target) + { + AB_COUNT(AB_TARGET_REACHED, true, depth); + return true; + } + else if (posPoint->tricksMAX + tricks + 1 < target) + { + AB_COUNT(AB_TARGET_REACHED, false, depth); + return false; + } + else if (depth == 0) /* Maximum depth? */ + { + TIMER_START(TIMER_EVALUATE + depth); + struct evalType evalData = Evaluate(posPoint, trump, thrp); + TIMER_END(TIMER_EVALUATE + depth); + + bool value = (evalData.tricks >= target ? true : false); + + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = evalData.winRanks[ss]; + + AB_COUNT(AB_DEPTH_ZERO, value, depth); + return value; + } + + bool res; + TIMER_START(TIMER_QT + depth); + int qtricks = QuickTricks(posPoint, hand, depth, target, + trump, &res, thrp); + TIMER_END(TIMER_QT + depth); + + if (thrp->nodeTypeStore[hand] == MAXNODE) + { + if (res) + { + AB_COUNT(AB_QUICKTRICKS, 1, depth); + return (qtricks == 0 ? false : true); + } + + TIMER_START(TIMER_LT + depth); + res = LaterTricksMIN(posPoint, hand, depth, target, trump, thrp); + TIMER_END(TIMER_LT + depth); + + if (! res) + { + // Is 1 right here?! + AB_COUNT(AB_LATERTRICKS, true, depth); + return false; + } + } + else + { + if (res) + { + AB_COUNT(AB_QUICKTRICKS, false, depth); + return (qtricks == 0 ? true : false); + } + + TIMER_START(TIMER_LT + depth); + res = LaterTricksMAX(posPoint, hand, depth, target, trump, thrp); + TIMER_END(TIMER_LT + depth); + + if (res) + { + AB_COUNT(AB_LATERTRICKS, false, depth); + return true; + } + } + + /* Find node that fits the suit lengths */ + int limit; + if (thrp->nodeTypeStore[0] == MAXNODE) + limit = target - posPoint->tricksMAX - 1; + else + limit = tricks - (target - posPoint->tricksMAX - 1); + + bool lowerFlag; + TIMER_START(TIMER_LOOKUP + depth); + struct nodeCardsType * cardsP = + thrp->transTable.Lookup( + tricks, hand, posPoint->aggr, posPoint->handDist, + limit, &lowerFlag); + TIMER_END(TIMER_LOOKUP + depth); + + if (cardsP) + { +AB_LOOKUP_MATCH: + +#ifdef DDS_AB_HITS + DumpRetrieved(thrp->fpRetrieved, posPoint, cardsP, target, depth); +#endif + + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = + winRanks[ posPoint->aggr[ss] ][ (int)cardsP->leastWin[ss] ]; + + if (cardsP->bestMoveRank != 0) + { + thrp->bestMoveTT[depth].suit = cardsP->bestMoveSuit; + thrp->bestMoveTT[depth].rank = cardsP->bestMoveRank; + } + + bool scoreFlag = + (thrp->nodeTypeStore[0] == MAXNODE ? lowerFlag : ! lowerFlag); + + AB_COUNT(AB_MAIN_LOOKUP, scoreFlag, depth); + return scoreFlag; + } + + bool success = (thrp->nodeTypeStore[hand] == MAXNODE ? true : false); + bool value = ! success; + + TIMER_START(TIMER_MOVEGEN + depth); + int moveExists = MoveGen(posPoint, depth, trump, mply, thrp); + TIMER_END(TIMER_MOVEGEN + depth); + + mply->current = 0; + + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = 0; + + while (moveExists) + { + TIMER_START(TIMER_MAKE + depth); + Make(posPoint, makeWinRank, depth, trump, mply, thrp); + TIMER_END(TIMER_MAKE + depth); + + TIMER_START(TIMER_AB + depth - 1); + value = ABsearch1(posPoint, target, depth - 1, thrp); + TIMER_END(TIMER_AB + depth - 1); + + TIMER_START(TIMER_UNDO + depth); + Undo(posPoint, depth, mply, thrp); + TIMER_END(TIMER_UNDO + depth); + + if (value == success) /* A cut-off? */ + { + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = + posPoint->winRanks[depth - 1][ss] | makeWinRank[ss]; + + thrp->bestMove[depth] = mply->move[mply->current]; + goto ABexit; + } + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] |= + posPoint->winRanks[depth - 1][ss] | makeWinRank[ss]; + + TIMER_START(TIMER_NEXTMOVE + depth); + moveExists = NextMove(posPoint, depth, mply, thrp); + TIMER_END(TIMER_NEXTMOVE + depth); + } + +ABexit: + struct nodeCardsType first; + if (value) + { + if (thrp->nodeTypeStore[0] == MAXNODE) + { + first.ubound = tricks + 1; + first.lbound = target - posPoint->tricksMAX; + } + else + { + first.ubound = tricks + 1 - target + posPoint->tricksMAX; + first.lbound = 0; + } + } + else + { + if (thrp->nodeTypeStore[0] == MAXNODE) + { + first.ubound = target - posPoint->tricksMAX - 1; + first.lbound = 0; + } + else + { + first.ubound = tricks + 1; + first.lbound = tricks + 1 - target + posPoint->tricksMAX + 1; + } + } + + first.bestMoveSuit = thrp->bestMove[depth].suit; + first.bestMoveRank = thrp->bestMove[depth].rank; + + bool flag = + ((thrp->nodeTypeStore[hand] == MAXNODE && value) || + (thrp->nodeTypeStore[hand] == MINNODE && !value)) + ? true : false; + + TIMER_START(TIMER_BUILD + depth); + thrp->transTable.Add( + tricks, + hand, + posPoint->aggr, + posPoint->winRanks[depth], + &first, + flag); + TIMER_END(TIMER_BUILD + depth); + +#ifdef DDS_AB_HITS + DumpStored(thrp->fpStored, posPoint, thrp->movePly, + &first, target, depth); +#endif + + AB_COUNT(AB_MOVE_LOOP, value, depth); + return value; +} + + +bool ABsearch1( + struct pos * posPoint, + int target, + int depth, + struct localVarType * thrp) +{ + /* This is a specialized AB function for handRelFirst == 1. */ + + struct movePlyType * mply = &thrp->movePly[depth]; + unsigned short int makeWinRank[DDS_SUITS]; + + int trump = thrp->trump; + int hand = handId(posPoint->first[depth], 1); + bool success = (thrp->nodeTypeStore[hand] == MAXNODE ? true : false); + bool value = ! success; + + assert(posPoint->handRelFirst == 1); + +#ifdef DDS_TOP_LEVEL + thrp->nodes++; +#endif + + TIMER_START(TIMER_QT + depth); + int res = QuickTricksSecondHand(posPoint, hand, depth, target, + trump, thrp); + TIMER_END(TIMER_QT + depth); + + if (res) + { + return success; + } + + TIMER_START(TIMER_MOVEGEN + depth); + bool moveExists = + (MoveGen(posPoint, depth, trump, mply, thrp) ? true : false); + TIMER_END(TIMER_MOVEGEN + depth); + + mply->current = 0; + + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = 0; + + while (moveExists) + { + TIMER_START(TIMER_MAKE + depth); + Make(posPoint, makeWinRank, depth, trump, mply, thrp); + TIMER_END(TIMER_MAKE + depth); + + TIMER_START(TIMER_AB + depth - 1); + value = ABsearch2(posPoint, target, depth - 1, thrp); + TIMER_END(TIMER_AB + depth - 1); + + TIMER_START(TIMER_UNDO + depth); + Undo(posPoint, depth, mply, thrp); + TIMER_END(TIMER_UNDO + depth); + + if (value == success) /* A cut-off? */ + { + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = + posPoint->winRanks[depth - 1][ss] | makeWinRank[ss]; + + thrp->bestMove[depth] = mply->move[mply->current]; + goto ABexit; + } + + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] |= + posPoint->winRanks[depth - 1][ss] | makeWinRank[ss]; + + TIMER_START(TIMER_NEXTMOVE + depth); + moveExists = NextMove(posPoint, depth, mply, thrp); + TIMER_END(TIMER_NEXTMOVE + depth); + } + +ABexit: + AB_COUNT(AB_MOVE_LOOP, value, depth); + return value; +} + + +bool ABsearch2( + struct pos * posPoint, + int target, + int depth, + struct localVarType * thrp) +{ + /* This is a specialized AB function for handRelFirst == 2. */ + + struct movePlyType * mply = &thrp->movePly[depth]; + unsigned short int makeWinRank[DDS_SUITS]; + + int trump = thrp->trump; + int hand = handId(posPoint->first[depth], 2); + bool success = (thrp->nodeTypeStore[hand] == MAXNODE ? true : false); + bool value = ! success; + + assert(posPoint->handRelFirst == 2); + +#ifdef DDS_TOP_LEVEL + thrp->nodes++; +#endif + + TIMER_START(TIMER_MOVEGEN + depth); + bool moveExists = + (MoveGen(posPoint, depth, trump, mply, thrp) ? true : false); + TIMER_END(TIMER_MOVEGEN + depth); + + mply->current = 0; + + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = 0; + + while (moveExists) + { + TIMER_START(TIMER_MAKE + depth); + Make(posPoint, makeWinRank, depth, trump, mply, thrp); + TIMER_END(TIMER_MAKE + depth); + + TIMER_START(TIMER_AB + depth - 1); + value = ABsearch3(posPoint, target, depth - 1, thrp); + TIMER_END(TIMER_AB + depth - 1); + + TIMER_START(TIMER_UNDO + depth); + Undo(posPoint, depth, mply, thrp); + TIMER_END(TIMER_UNDO + depth); + + if (value == success) /* A cut-off? */ + { + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = + posPoint->winRanks[depth - 1][ss] | makeWinRank[ss]; + + thrp->bestMove[depth] = mply->move[mply->current]; + goto ABexit; + } + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] |= + posPoint->winRanks[depth - 1][ss] | makeWinRank[ss]; + + TIMER_START(TIMER_NEXTMOVE + depth); + moveExists = NextMove(posPoint, depth, mply, thrp); + TIMER_END(TIMER_NEXTMOVE + depth); + } + +ABexit: + AB_COUNT(AB_MOVE_LOOP, value, depth); + return value; +} + + +bool ABsearch3( + struct pos * posPoint, + int target, + int depth, + struct localVarType * thrp) +{ + /* This is a specialized AB function for handRelFirst == 3. */ + + struct movePlyType * mply = &thrp->movePly[depth]; + unsigned short int makeWinRank[DDS_SUITS]; + + int trump = thrp->trump; + int hand = handId(posPoint->first[depth], 3); + bool success = (thrp->nodeTypeStore[hand] == MAXNODE ? true : false); + bool value = ! success; + + assert(posPoint->handRelFirst == 3); + +#ifdef DDS_TOP_LEVEL + thrp->nodes++; +#endif + + TIMER_START(TIMER_MOVEGEN + depth); + bool moveExists = + (MoveGen(posPoint, depth, trump, mply, thrp) ? 1 : 0); + TIMER_END(TIMER_MOVEGEN + depth); + + if ((depth >= 37) && (thrp->iniDepth != depth)) + { + struct nodeCardsType * cardsP; + int tricks = depth >> 2; + bool mexists = true; + bool ready = false; + bool scoreFlag, lowerFlag; + + mply->current = 0; + while (mexists) + { + TIMER_START(TIMER_MAKE + depth); + Make(posPoint, makeWinRank, depth, trump, mply, thrp); + TIMER_END(TIMER_MAKE + depth); + + int hfirst = posPoint->first[depth - 1]; + + int limit; + if (thrp->nodeTypeStore[0] == MAXNODE) + limit = target - posPoint->tricksMAX - 1; + else + limit = tricks - (target - posPoint->tricksMAX - 1); + + TIMER_START(TIMER_LOOKUP + depth); + cardsP = thrp->transTable.Lookup( + tricks, hfirst, posPoint->aggr, posPoint->handDist, + limit, &lowerFlag); + TIMER_END(TIMER_LOOKUP + depth); + + if (cardsP) + { + scoreFlag = + (thrp->nodeTypeStore[0] == MAXNODE ? lowerFlag : ! lowerFlag); + + if (((thrp->nodeTypeStore[hand] == MAXNODE) && scoreFlag) || + ((thrp->nodeTypeStore[hand] == MINNODE) && ! scoreFlag)) + { + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = + winRanks[ posPoint->aggr[ss] ][ (int)cardsP->leastWin[ss] ]; + + if (cardsP->bestMoveRank != 0) + { + thrp->bestMoveTT[depth].suit = cardsP->bestMoveSuit; + thrp->bestMoveTT[depth].rank = cardsP->bestMoveRank; + } + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] |= makeWinRank[ss]; + + TIMER_START(TIMER_UNDO + depth); + Undo(posPoint, depth, mply, thrp); + TIMER_END(TIMER_UNDO + depth); + + AB_COUNT(AB_SIDE_LOOKUP, value, depth); + return scoreFlag; + } + else + { + mply->move[mply->current].weight += 100; + ready = true; + } + } + + TIMER_START(TIMER_UNDO + depth); + Undo(posPoint, depth, mply, thrp); + TIMER_END(TIMER_UNDO + depth); + + if (ready) + break; + + if (mply->current <= (mply->last - 1)) + { + mply->current++; + mexists = true; + } + else + mexists = false; + } + if (ready) + MergeSort(mply->last + 1, mply->move); + } + + mply->current = 0; + + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = 0; + +if (moveExists) + + while (moveExists) + { + TIMER_START(TIMER_MAKE + depth); + Make(posPoint, makeWinRank, depth, trump, mply, thrp); + TIMER_END(TIMER_MAKE + depth); + + thrp->trickNodes++; // As handRelFirst == 0 + + TIMER_START(TIMER_AB + depth - 1); + value = ABsearch0(posPoint, target, depth - 1, thrp); + TIMER_END(TIMER_AB + depth - 1); + + TIMER_START(TIMER_UNDO + depth); + Undo(posPoint, depth, mply, thrp); + TIMER_END(TIMER_UNDO + depth); + + if (value == success) /* A cut-off? */ + { + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = + posPoint->winRanks[depth - 1][ss] | makeWinRank[ss]; + + thrp->bestMove[depth] = mply->move[mply->current]; + goto ABexit; + } + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] |= + posPoint->winRanks[depth - 1][ss] | makeWinRank[ss]; + + TIMER_START(TIMER_NEXTMOVE + depth); + moveExists = NextMove(posPoint, depth, mply, thrp); + TIMER_END(TIMER_NEXTMOVE + depth); + } + +ABexit: + AB_COUNT(AB_MOVE_LOOP, value, depth); + return value; +} + + +void Make( + struct pos * posPoint, + unsigned short int trickCards[DDS_SUITS], + int depth, + int trump, + struct movePlyType * mply, + struct localVarType * thrp) +{ + int t, u, w; + int mcurr, q; + + assert((posPoint->handRelFirst >= 0) && + (posPoint->handRelFirst <= 3)); + + for (int suit = 0; suit < DDS_SUITS; suit++) + trickCards[suit] = 0; + + int firstHand = posPoint->first[depth]; + int r = mply->current; + + if (posPoint->handRelFirst == 3) /* This hand is last hand */ + { + if (mply->move[r].suit == posPoint->move[depth + 1].suit) + { + if (mply->move[r].rank > posPoint->move[depth + 1].rank) + { + posPoint->move[depth] = mply->move[r]; + posPoint->high[depth] = handId(firstHand, 3); + } + else + { + posPoint->move[depth] = posPoint->move[depth + 1]; + posPoint->high[depth] = posPoint->high[depth + 1]; + } + } + else if (mply->move[r].suit == trump) + { + posPoint->move[depth] = mply->move[r]; + posPoint->high[depth] = handId(firstHand, 3); + } + else + { + posPoint->move[depth] = posPoint->move[depth + 1]; + posPoint->high[depth] = posPoint->high[depth + 1]; + } + + /* Is the trick won by rank? */ + int s = posPoint->move[depth].suit; + int count = 0; + if (mply->move[r].suit == s) + count++; + + for (int e = 1; e <= 3; e++) + { + mcurr = thrp->movePly[depth + e].current; + if (thrp->movePly[depth + e].move[mcurr].suit == s) + { + count++; + } + } + + if (thrp->nodeTypeStore[posPoint->high[depth]] == MAXNODE) + posPoint->tricksMAX++; + posPoint->first[depth - 1] = posPoint->high[depth]; + /* Defines who is first in the next move */ + + t = handId(firstHand, 3); + posPoint->handRelFirst = 0; + /* Hand pointed to by posPoint->first + will lead the next trick */ + + + bool done = false; + for (int d = 3; d >= 0; d--) + { + q = handId(firstHand, 3 - d); + /* Add the moves to removed ranks */ + r = thrp->movePly[depth + d].current; + w = thrp->movePly[depth + d].move[r].rank; + u = thrp->movePly[depth + d].move[r].suit; + posPoint->removedRanks[u] |= bitMapRank[w]; + + if (d == 0) + { + posPoint->rankInSuit[t][u] &= (~bitMapRank[w]); + posPoint->aggr[u] ^= bitMapRank[w]; + } + + if ((w == posPoint->winner[u].rank) || + (w == posPoint->secondBest[u].rank)) + { + int aggr = posPoint->aggr[u]; + + posPoint->winner[u].rank = thrp->rel[aggr].absRank[1][u].rank; + posPoint->winner[u].hand = thrp->rel[aggr].absRank[1][u].hand; + posPoint->secondBest[u].rank = thrp->rel[aggr].absRank[2][u].rank; + posPoint->secondBest[u].hand = thrp->rel[aggr].absRank[2][u].hand; + } + + /* Determine win-ranked cards */ + if ((q == posPoint->high[depth]) && (!done)) + { + done = true; + if (count >= 2) + { + trickCards[u] = bitMapRank[w]; + /* Mark ranks as winning if they are part of a sequence */ + trickCards[u] |= thrp->movePly[depth + d].move[r].sequence; + } + } + } + } + else if (posPoint->handRelFirst == 0) /* Is it the 1st hand? */ + { + posPoint->first[depth - 1] = firstHand; + /* First hand is not changed in next move */ + + posPoint->high[depth] = firstHand; + posPoint->move[depth] = mply->move[r]; + t = firstHand; + posPoint->handRelFirst = 1; + r = mply->current; + u = mply->move[r].suit; + w = mply->move[r].rank; + posPoint->rankInSuit[t][u] &= (~bitMapRank[w]); + + posPoint->aggr[u] ^= bitMapRank[w]; + } + else + { + r = mply->current; + u = mply->move[r].suit; + w = mply->move[r].rank; + if (u == posPoint->move[depth + 1].suit) + { + if (w > posPoint->move[depth + 1].rank) + { + posPoint->move[depth] = mply->move[r]; + posPoint->high[depth] = handId(firstHand, posPoint->handRelFirst); + } + else + { + posPoint->move[depth] = posPoint->move[depth + 1]; + posPoint->high[depth] = posPoint->high[depth + 1]; + } + } + else if (u == trump) + { + posPoint->move[depth] = mply->move[r]; + posPoint->high[depth] = handId(firstHand, posPoint->handRelFirst); + } + else + { + posPoint->move[depth] = posPoint->move[depth + 1]; + posPoint->high[depth] = posPoint->high[depth + 1]; + } + + t = handId(firstHand, posPoint->handRelFirst); + posPoint->handRelFirst++; /* Current hand is stepped */ + // assert((posPoint->handRelFirst >= 0) && + // (posPoint->handRelFirst <= 3)); + + posPoint->first[depth - 1] = firstHand; + /* First hand is not changed in next move */ + + posPoint->rankInSuit[t][u] &= (~bitMapRank[w]); + + posPoint->aggr[u] ^= bitMapRank[w]; + + } + + posPoint->length[t][u]--; + + posPoint->handDist[t] -= handDelta[u]; + +#ifdef DDS_AB_STATS + thrp->ABstats.IncrNode(depth); +#endif + + return; +} + + +void Undo( + struct pos * posPoint, + int depth, + struct movePlyType * mply, + struct localVarType * thrp) +{ + int c, h, s, r; + + // One hand backwards. + posPoint->handRelFirst = (posPoint->handRelFirst + 3) & 0x3; + + int firstHand = posPoint->first[depth]; + + if (posPoint->handRelFirst == 0) + { + /* 1st hand which won the previous trick */ + h = firstHand; + c = mply->current; + s = mply->move[c].suit; + r = mply->move[c].rank; + } + else if (posPoint->handRelFirst == 3) /* Last hand */ + { + for (int d = 3; d >= 0; d--) + { + /* Delete the moves from removed ranks */ + c = thrp->movePly[depth + d].current; + r = thrp->movePly[depth + d].move[c].rank; + s = thrp->movePly[depth + d].move[c].suit; + + posPoint->removedRanks[s] &= (~bitMapRank[r]); + + if (r > posPoint->winner[s].rank) + { + posPoint->secondBest[s] = posPoint->winner[s]; + posPoint->winner[s].rank = r; + posPoint->winner[s].hand = handId(firstHand, 3 - d); + } + else if (r > posPoint->secondBest[s].rank) + { + posPoint->secondBest[s].rank = r; + posPoint->secondBest[s].hand = handId(firstHand, 3 - d); + } + } + h = handId(firstHand, 3); + + + if (thrp->nodeTypeStore[posPoint->first[depth - 1]] == MAXNODE) + /* First hand of next trick is winner of the current trick */ + posPoint->tricksMAX--; + } + else + { + h = handId(firstHand, posPoint->handRelFirst); + c = mply->current; + s = mply->move[c].suit; + r = mply->move[c].rank; + } + + posPoint->length[h][s]++; + posPoint->rankInSuit[h][s] |= bitMapRank[r]; + posPoint->aggr[s] |= bitMapRank[r]; + posPoint->handDist[h] += handDelta[s]; + + return; +} + + +struct evalType Evaluate( + struct pos * posPoint, + int trump, + struct localVarType * thrp) +{ + int s, h, hmax = 0, count = 0, k = 0; + unsigned short rmax = 0; + struct evalType eval; + + int firstHand = posPoint->first[0]; + assert((firstHand >= 0) && (firstHand <= 3)); + + for (s = 0; s < DDS_SUITS; s++) + eval.winRanks[s] = 0; + + /* Who wins the last trick? */ + if (trump != DDS_NOTRUMP) /* Highest trump card wins */ + { + for (h = 0; h < DDS_HANDS; h++) + { + if (posPoint->rankInSuit[h][trump] != 0) + count++; + if (posPoint->rankInSuit[h][trump] > rmax) + { + hmax = h; + rmax = posPoint->rankInSuit[h][trump]; + } + } + + if (rmax > 0) /* Trumpcard wins */ + { + if (count >= 2) + eval.winRanks[trump] = rmax; + + if (thrp->nodeTypeStore[hmax] == MAXNODE) + goto maxexit; + else + goto minexit; + } + } + + /* Who has the highest card in the suit played by 1st hand? */ + + k = 0; + while (k <= 3) /* Find the card the 1st hand played */ + { + if (posPoint->rankInSuit[firstHand][k] != 0) /* Is this the card? */ + break; + k++; + } + + assert(k < 4); + + for (h = 0; h < DDS_HANDS; h++) + { + if (posPoint->rankInSuit[h][k] != 0) + count++; + if (posPoint->rankInSuit[h][k] > rmax) + { + hmax = h; + rmax = posPoint->rankInSuit[h][k]; + } + } + + if (count >= 2) + eval.winRanks[k] = rmax; + + if (thrp->nodeTypeStore[hmax] == MAXNODE) + goto maxexit; + else + goto minexit; + +maxexit: + eval.tricks = posPoint->tricksMAX + 1; + return eval; + +minexit: + eval.tricks = posPoint->tricksMAX; + return eval; +} + + +bool NextMove( + struct pos * posPoint, + int depth, + struct movePlyType * mply, + struct localVarType * thrp) +{ + /* Returns true if at least one move remains to be + searched, otherwise FALSE is returned. */ + + unsigned short int * lw_list = thrp->lowestWin[depth]; + unsigned short int lw; + int suit; + struct moveType currMove = mply->move[mply->current]; + + if (lw_list[currMove.suit] == 0) + { + /* A small card has not yet been identified for this suit. */ + lw = posPoint->winRanks[depth][currMove.suit]; + if (lw != 0) + lw = lw & (-lw); /* LSB */ + else + lw = bitMapRank[15]; + + if (bitMapRank[currMove.rank] < lw) + { + /* The current move has a small card. */ + lw_list[currMove.suit] = lw; + while (mply->current <= (mply->last - 1)) + { + mply->current++; + if (bitMapRank[mply->move[mply->current].rank] >= + lw_list[mply->move[mply->current].suit]) + return true; + } + return false; + } + else + { + while (mply->current <= (mply->last - 1)) + { + mply->current++; + suit = mply->move[mply->current].suit; + if ((currMove.suit == suit) || + (bitMapRank[mply->move[mply->current].rank] >= + lw_list[suit])) + return true; + } + return false; + } + } + else + { + while (mply->current <= (mply->last - 1)) + { + mply->current++; + if (bitMapRank[mply->move[mply->current].rank] >= + lw_list[mply->move[mply->current].suit]) + return true; + } + return false; + } +} + + +void RankToText( + unsigned short int rankInSuit[DDS_HANDS][DDS_SUITS], + char text[DDS_HAND_LINES][DDS_FULL_LINE]) +{ + int c, h, s, r; + + for (int l = 0; l < DDS_HAND_LINES; l++) + { + memset(text[l], ' ', DDS_FULL_LINE); + text[l][DDS_FULL_LINE-1] = '\0'; + } + + for (h = 0; h < DDS_HANDS; h++) + { + int offset, line; + if (h == 0) + { + offset = DDS_HAND_OFFSET; + line = 0; + } + else if (h == 1) + { + offset = 2 * DDS_HAND_OFFSET; + line = 4; + } + else if (h == 2) + { + offset = DDS_HAND_OFFSET; + line = 8; + } + else + { + offset = 0; + line = 4; + } + + for (s = 0; s < DDS_SUITS; s++) + { + c = offset; + for (r = 14; r >= 2; r--) + { + if (rankInSuit[h][s] & bitMapRank[r]) + text[line + s][c++] = cardRank[r]; + } + + if (c == offset) + text[line + s][c++] = '-'; + + if (h != 3) + text[line + s][c] = '\0'; + } + } +} + + +void RankToDiagrams( + unsigned short int rankInSuit[DDS_HANDS][DDS_SUITS], + struct nodeCardsType * np, + char text[DDS_HAND_LINES][DDS_FULL_LINE]) +{ + int c, h, s, r; + + for (int l = 0; l < DDS_HAND_LINES; l++) + { + memset(text[l], ' ', DDS_FULL_LINE); + text[l][DDS_FULL_LINE-1] = '\0'; + text[l][DDS_DIAG_WIDTH ] = '|'; + } + + strncpy(text[0], "Sought", 6); + strncpy(&text[0][DDS_DIAG_WIDTH + 5], "Found", 5); + + for (h = 0; h < DDS_HANDS; h++) + { + int offset, line; + if (h == 0) + { + offset = DDS_HAND_OFFSET2; + line = 0; + } + else if (h == 1) + { + offset = 2 * DDS_HAND_OFFSET2; + line = 4; + } + else if (h == 2) + { + offset = DDS_HAND_OFFSET2; + line = 8; + } + else + { + offset = 0; + line = 4; + } + + for (s = 0; s < DDS_SUITS; s++) + { + c = offset; + for (r = 14; r >= 2; r--) + { + if (rankInSuit[h][s] & bitMapRank[r]) + { + text[line + s][c] = cardRank[r]; + text[line + s][c + DDS_DIAG_WIDTH + 5] = + (r >= 15 - np->leastWin[s] ? cardRank[r] : 'x'); + c++; + } + } + + if (c == offset) + { + text[line + s][c] = '-'; + text[line + s][c + DDS_DIAG_WIDTH + 5] = '-'; + c++; + } + + if (h != 3) + text[line + s][c + DDS_DIAG_WIDTH + 5] = '\0'; + } + } +} + + +void WinnersToText( + unsigned short int winRanks[DDS_SUITS], + char text[DDS_SUITS][DDS_FULL_LINE]) +{ + int c, s, r; + + for (int l = 0; l < DDS_SUITS; l++) + memset(text[l], ' ', DDS_FULL_LINE); + + for (s = 0; s < DDS_SUITS; s++) + { + text[s][0] = cardSuit[s]; + + c = 2; + for (r = 14; r >= 2; r--) + { + if (winRanks[s] & bitMapRank[r]) + text[s][c++] = cardRank[r]; + } + text[s][c] = '\0'; + } +} + + +void PlyToText( + struct movePlyType mply[], + int depth, + int firstHand, + char text[DDS_FULL_LINE]) +{ + sprintf(text, "Last trick\t%c: %c%c - %c%c - %c%c - %c%c\n", + cardHand[firstHand], + cardSuit[ mply[depth+4].move[ mply[depth+4].current ].suit ], + cardRank[ mply[depth+4].move[ mply[depth+4].current ].rank ], + + cardSuit[ mply[depth+3].move[ mply[depth+3].current ].suit ], + cardRank[ mply[depth+3].move[ mply[depth+3].current ].rank ], + + cardSuit[ mply[depth+2].move[ mply[depth+2].current ].suit ], + cardRank[ mply[depth+2].move[ mply[depth+2].current ].rank ], + + cardSuit[ mply[depth+1].move[ mply[depth+1].current ].suit ], + cardRank[ mply[depth+1].move[ mply[depth+1].current ].rank ]); +} + + +void NodeToText( + struct nodeCardsType * np, + char text[DDS_NODE_LINES-1][DDS_FULL_LINE]) + +{ + sprintf(text[0], "Address\t\t0x%08x\n", np); + + sprintf(text[1], "Bounds\t\t%d to %d tricks\n", + (int) np->lbound, (int) np->ubound); + + sprintf(text[2], "Best move\t%c%c\n", + cardSuit[ (int) np->bestMoveSuit ], + cardRank[ (int) np->bestMoveRank ]); + +} + + +void FullNodeToText( + struct nodeCardsType * np, + char text[DDS_NODE_LINES][DDS_FULL_LINE]) + +{ + sprintf(text[0], "Address\t\t0x%08x\n", np); + + sprintf(text[1], "Lowest used\t%c%c, %c%c, %c%c, %c%c\n", + cardSuit[0], cardRank[ 15 - (int) np->leastWin[0] ], + cardSuit[1], cardRank[ 15 - (int) np->leastWin[1] ], + cardSuit[2], cardRank[ 15 - (int) np->leastWin[2] ], + cardSuit[3], cardRank[ 15 - (int) np->leastWin[3] ]); + + sprintf(text[2], "Bounds\t\t%d to %d tricks\n", + (int) np->lbound, (int) np->ubound); + + sprintf(text[3], "Best move\t%c%c\n", + cardSuit[ (int) np->bestMoveSuit ], + cardRank[ (int) np->bestMoveRank ]); + +} + + +void PosToText( + struct pos * posPoint, + int target, + int depth, + char text[DDS_POS_LINES][DDS_FULL_LINE]) +{ + sprintf(text[0], "Target\t\t%d\n" , target); + sprintf(text[1], "Depth\t\t%d\n" , depth); + sprintf(text[2], "tricksMAX\t%d\n" , posPoint->tricksMAX); + sprintf(text[3], "First hand\t%c\n", + cardHand[ posPoint->first[depth] ]); + sprintf(text[4], "Next first\t%c\n", + cardHand[ posPoint->first[depth-1] ]); +} + + +void DumpRetrieved( + FILE * fp, + struct pos * posPoint, + struct nodeCardsType * np, + int target, + int depth) +{ + // Big enough for all uses. + char text[DDS_HAND_LINES][DDS_FULL_LINE]; + + fprintf(fp, "Retrieved entry\n"); + fprintf(fp, "---------------\n"); + + PosToText(posPoint, target, depth, text); + for (int i = 0; i < DDS_POS_LINES; i++) + fprintf(fp, "%s", text[i]); + fprintf(fp, "\n"); + + FullNodeToText(np, text); + for (int i = 0; i < DDS_NODE_LINES; i++) + fprintf(fp, "%s", text[i]); + fprintf(fp, "\n"); + + RankToDiagrams(posPoint->rankInSuit, np, text); + for (int i = 0; i < DDS_HAND_LINES; i++) + fprintf(fp, "%s\n", text[i]); + fprintf(fp, "\n"); +} + + +void DumpStored( + FILE * fp, + struct pos * posPoint, + struct movePlyType mply[], + struct nodeCardsType * np, + int target, + int depth) +{ + // Big enough for all uses. + char text[DDS_HAND_LINES][DDS_FULL_LINE]; + + fprintf(fp, "Stored entry\n"); + fprintf(fp, "------------\n"); + + PosToText(posPoint, target, depth, text); + for (int i = 0; i < DDS_POS_LINES; i++) + fprintf(fp, "%s", text[i]); + fprintf(fp, "\n"); + + NodeToText(np, text); + for (int i = 0; i < DDS_NODE_LINES-1; i++) + fprintf(fp, "%s", text[i]); + fprintf(fp, "\n"); + + PlyToText(mply, depth, posPoint->first[depth+3], text[0]); + fprintf(fp, "%s", text[0]); + fprintf(fp, "\n"); + + RankToText(posPoint->rankInSuit, text); + for (int i = 0; i < DDS_HAND_LINES; i++) + fprintf(fp, "%s\n", text[i]); + fprintf(fp, "\n"); +} + + +void DumpTopLevel( + struct localVarType * thrp, + int tricks, + int lower, + int upper, + int printMode) +{ +#ifdef DDS_TOP_LEVEL + char text[DDS_HAND_LINES][DDS_FULL_LINE]; + struct pos * posPoint = &thrp->lookAheadPos; + FILE * fp = thrp->fpTopLevel; + + if (printMode == 0) + { + // Trying just one target. + sprintf(text[0], "Single target %d, %s\n", + tricks, + "achieved"); + } + else if (printMode == 1) + { + // Looking for best score. + if (thrp->val) + { + sprintf(text[0], + "Loop target %d, bounds %d .. %d, achieved with move %c%c\n", + tricks, + lower, + upper, + cardSuit[ thrp->bestMove[thrp->game.noOfCards-4].suit ], + cardRank[ thrp->bestMove[thrp->game.noOfCards-4].rank ]); + } + else + { + sprintf(text[0], + "Loop target %d, bounds %d .. %d, failed\n", + tricks, + lower, + upper); + } + } + else if (printMode == 2) + { + // Looking for other moves with best score. + if (thrp->val) + { + sprintf(text[0], + "Loop for cards with score %d, achieved with move %c%c\n", + tricks, + cardSuit[ thrp->bestMove[thrp->game.noOfCards-4].suit ], + cardRank[ thrp->bestMove[thrp->game.noOfCards-4].rank ]); + } + else + { + sprintf(text[0], + "Loop for cards with score %d, failed\n", + tricks); + } + } + + int l = strlen(text[0]) - 1; + + memset(text[1], '-', l); + text[1][l] = '\0'; + fprintf(fp, "%s%s\n\n", text[0], text[1]); + + RankToText(posPoint->rankInSuit, text); + for (int i = 0; i < DDS_HAND_LINES; i++) + fprintf(fp, "%s\n", text[i]); + fprintf(fp, "\n"); + + WinnersToText(posPoint->winRanks[ thrp->iniDepth ], text); + for (int i = 0; i < DDS_SUITS; i++) + fprintf(fp, "%s\n", text[i]); + fprintf(fp, "\n"); + + fprintf(fp, "%d AB nodes, %d trick nodes\n\n", + thrp->nodes, + thrp->trickNodes); +#endif +} + + diff --git a/ABsearch.h b/ABsearch.h new file mode 100644 index 00000000..04ae38d1 --- /dev/null +++ b/ABsearch.h @@ -0,0 +1,67 @@ +#define DDS_POS_LINES 5 +#define DDS_HAND_LINES 12 +#define DDS_NODE_LINES 4 +#define DDS_FULL_LINE 80 +#define DDS_HAND_OFFSET 16 +#define DDS_HAND_OFFSET2 12 +#define DDS_DIAG_WIDTH 34 + + +bool ABsearch( + struct pos * posPoint, + int target, + int depth, + struct localVarType * thrp); + +bool ABsearch0( + struct pos * posPoint, + int target, + int depth, + struct localVarType * thrp); + +bool ABsearch1( + struct pos * posPoint, + int target, + int depth, + struct localVarType * thrp); + +bool ABsearch2( + struct pos * posPoint, + int target, + int depth, + struct localVarType * thrp); + +bool ABsearch3( + struct pos * posPoint, + int target, + int depth, + struct localVarType * thrp); + +void InitFileTopLevel( + int thrId); + +void InitFileABstats( + int thrId); + +void InitFileABhits( + int thrId); + +void InitFileTTstats( + int thrId); + +void InitFileTimer( + int thrId); + +void CloseFileTopLevel( + localVarType * thrp); + +void CloseFileABhits( + localVarType * thrp); + +void DumpTopLevel( + struct localVarType * thrp, + int tricks, + int lower, + int upper, + int printMode); + diff --git a/ABstats.cpp b/ABstats.cpp new file mode 100644 index 00000000..f9c91e8f --- /dev/null +++ b/ABstats.cpp @@ -0,0 +1,643 @@ +/* + DDS 2.7.0 A bridge double dummy solver. + + Copyright (C) 2006-2014 by Bo Haglund + + Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. + + The code for calculation of par score / contracts is based upon the + + perl code written by Matthew Kidd for ACBLmerge. + He has kindly given + me permission to include a C++ adaptation in DDS. +*/ + + + +/* + Licensed under the Apache License, Version 2.0 (the "License"); + + you may not use this file except in compliance with the License. + + You may obtain a copy of the License at + + + http://www.apache.org/licenses/LICENSE-2.0 + + + Unless required by applicable law or agreed to in writing, software + + distributed under the License is distributed on an "AS IS" BASIS, + + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + + implied. See the License for the specific language governing + + permissions and limitations under the License. +*/ + + + +/* + This object, ABstats, was was written by Søren Hein. + + Many thanks for allowing me to include it in DDS. + + + It is a simple object for AB statistics and return values. +*/ + + + + +#include "dds.h" + +#include "ABstats.h" + + + + +ABstats::ABstats() + +{ + sprintf(fname, ""); + + fp = stdout; + ABstats::Reset(); + + ABstats::ResetCum(); + +} + + + + +ABstats::~ABstats() + +{ + +// Nothing to do + + if (fp != stdout) + + fclose(fp); + +} + + + + +void ABstats::Reset() + +{ + + for (int p = 0; p < DDS_AB_POS; p++) + + { + + sprintf(name[p], "Position %4d", p); + + + for (int depth = 0; depth < DDS_MAXDEPTH; depth++) + + counter[p][depth] = 0; + + } + + + + for (int side = 0; side < 2; side++) + + { + + for (int depth = 0; depth < DDS_MAXDEPTH; depth++) + + score[side][depth] = 0; + + } + + + + for (int depth = 0; depth < DDS_MAXDEPTH; depth++) + + nodes[depth] = 0; + + + allnodes = 0; + +} + + + + +void ABstats::ResetCum() + +{ + + for (int depth = 0; depth < DDS_MAXDEPTH; depth++) + + nodesCum[depth] = 0; + + +allnodesCum = 0; + + + scoreCum[1] = 0; + + scoreCum[0] = 0; + + + pscoreCum[1] = 0; + + pscoreCum[0] = 0; + + + for (int p = 0; p < DDS_AB_POS; p++) + + { + + counterCum[p] = 0; + + pcounterCum[p] = 0; + + } + +} + + + + +void ABstats::SetFile(char * fname) + +{ + + if (strlen(fname) > DDS_LINE_LEN) + + return; + + + +if (fp != stdout) + // Already set + + return; + + + + strncpy(this->fname, fname, strlen(fname)); + + + fp = fopen(fname, "w"); + + if (! fp) + + fp = stdout; + +} + + + + +void ABstats::SetName(int no, char * name) + +{ + + if (no < 0 || no >= DDS_AB_POS) + + return; + + + sprintf(this->name[no], "%s\0", name); + +} + + + + +void ABstats::IncrPos(int no, bool side, int depth) + +{ + + if (no < 0 || no >= DDS_AB_POS) + + return; + + + counter[no][depth]++; + + if (side) + + score[1][depth]++; + + else + + score[0][depth]++; + +} + + + + +void ABstats::IncrNode(int depth) + +{ + + nodes[depth]++; + + allnodes++; + +} + + + + +int ABstats::GetNodes() + +{ + + return allnodes; + +} + + + + +void ABstats::PrintStats() + +{ + + int sumScore1 = 0 , sumScore0 = 0; + int psumScore1 = 0 , psumScore0 = 0; + + int sum[DDS_AB_POS], psum[DDS_AB_POS]; + + + + for (int p = 0; p < DDS_AB_POS; p++) + + { + + sum[p] = 0; + + psum[p] = 0; + + } + + + for (int d = 0; d < DDS_MAXDEPTH; d++) + + { + + sumScore1 += score[1][d]; + + sumScore0 += score[0][d]; + + + psumScore1 += d * score[1][d]; + + psumScore0 += d * score[0][d]; + + + for (int p = 0; p < DDS_AB_POS; p++) + + { + + sum[p] += counter[p][d]; + + psum[p] += d * counter[p][d]; + + } + + + nodesCum[d] += nodes[d]; + + } + + + allnodesCum += allnodes; + + + scoreCum[1] += sumScore1; + + scoreCum[0] += sumScore0; + + + pscoreCum[1] += psumScore1; + + pscoreCum[0] += psumScore0; + + + + for (int p = 0; p < DDS_AB_POS; p++) + + { + + counterCum[p] += sum[p]; + + pcounterCum[p] += psum[p]; + + } + + + + int s = sumScore1 + sumScore0; + + int cs = scoreCum[1] + scoreCum[0]; + + if (s) + + { + + fprintf(fp, "%2s %-20s %8s %5s %5s %8s %5s %5s\n", + + "No", + "Return", + "Count", + "%", + "d_avg", + + "Cumul", + "%", + "d_avg"); + + + + fprintf(fp, "-----------------------------------"); + + + fprintf(fp, "------------------------------\n"); + + + + fprintf(fp, "%2s %-20s %8d %5.1f %5.1f %8d %5.1f %5.1f\n", + + + "", + + "Side1", + +sumScore1, + + 100. * sumScore1 / (double) s, + + psumScore1 / (double) s, + + scoreCum[1], + + 100. * scoreCum[1] / (double) cs, + + pscoreCum[1] / (double) cs); + + + + fprintf(fp, "%2s %-20s %8d %5.1f %5.1f %8d %5.1f %5.1f\n\n", + + "", + + "Side0", + + sumScore0, + + 100. * sumScore0 / (double) s, + + psumScore0 / (double) s, + + scoreCum[0], + + 100. * scoreCum[0] / (double) cs, + + pscoreCum[0] / (double) cs); + + + + for (int p = 0; p < DDS_AB_POS; p++) + + { + + if (sum[p]) + + { + + fprintf(fp, "%2d %-20s %8d %5.1f %5.1f %8d %5.1f %5.1f\n", + + p, + + name[p], + + sum[p], + + 100. * sum[p] / (double) s, + + psum[p] / (double) sum[p], + + counterCum[p], + + 100. * counterCum[p] / (double) cs, + + pcounterCum[p] / (double) counterCum[p]); + + } + + else if (counterCum[p]) + + { + + fprintf(fp, "%2d %-20s %8d %5.1f %5s %8d %5.1f %5.1f\n", + + p, + + name[p], + + sum[p], + + 100. * sum[p] / (double) s, + + "", + + counterCum[p], + + 100. * counterCum[p] / (double) cs, + + pcounterCum[p] / (double) counterCum[p]); + + } + + } + + } + + + + fprintf(fp, "\n%5s %6s %6s %5s %5s %6s\n", + + "Depth", + "Nodes", + "Cumul", + "Cum%", + "Cumc%", + "Branch"); + + + + fprintf(fp, "------------------------------------------\n"); + + + + int c = 0; + + double np = 0., ncp = 0.; + + + for (int d = DDS_MAXDEPTH-1; d >= 0; d--) + + { + + if (nodesCum[d] == 0) + + continue; + + + c += nodesCum[d]; + + np += d * nodes[d]; + + ncp += d * nodesCum[d]; + + + + fprintf(fp, "%5d %6d %6d %5.1f %5.1f", + + d, + + nodes[d], + + nodesCum[d], + + 100. * nodesCum[d] / (double) allnodesCum, + + 100. * c / (double) allnodesCum); + + + + // "Branching factor" from end of one trick to end of + + // the previous trick. + + if ((d % 4 == 1) && + + (d + 4 < DDS_MAXDEPTH) && + + (nodesCum[d+4] > 0)) + + fprintf(fp, " %5.2f", + + nodesCum[d] / (double) nodesCum[d+4]); + + + fprintf(fp, "\n"); + + } + + + fprintf(fp, "\n%-5s %6d %6d\n", + + "Total", allnodes, allnodesCum); + + + + if (allnodes) + + { + + fprintf(fp, "%-5s %6.1f %6.1f\n", + + "d_avg", + + np / (double) allnodes, + + ncp / (double) allnodesCum); + + } + + else if (allnodesCum) + + { + + fprintf(fp, "\n%-5s %6s %6.1f\n", + + "Avg", + + "-", + + ncp / (double) allnodesCum); + + } + + + + fprintf(fp, "%-5s %6d\n\n\n", "Diff", allnodes - sumScore1 - sumScore0); + + + +#ifdef DDS_AB_DETAILS + + fprintf(fp, "%2s %6s %6s", + "d", + "Side1", + "Side0"); + + + + for (int p = 0; p < DDS_AB_POS; p++) + + fprintf(fp, " %5d", p); + + fprintf(fp, "\n------------------------------"); + + fprintf(fp, "-----------------------------\n"); + + + + + for (int d = DDS_MAXDEPTH-1; d >= 0; d--) + + { + + if (score[1][d] == 0 && score[0][d] == 0) + + continue; + + + fprintf(fp, "%2d %6d %6d", + d, score[1][d], score[0][d]); + + + for (int p = 0; p < DDS_AB_POS; p++) + + fprintf(fp, " %5d", counter[p][d]); + + fprintf(fp, "\n"); + + } + + + fprintf(fp, "--------------------------------"); + + fprintf(fp, "---------------------------\n"); + + + fprintf(fp, "%2s %6d %6d", + "S", sumScore1, sumScore0); + + + + for (int p = 0; p < DDS_AB_POS; p++) + + fprintf(fp, " %5d", sum[p]); + + fprintf(fp, "\n\n"); + +#endif + + +} diff --git a/ABstats.h b/ABstats.h new file mode 100644 index 00000000..96cde9e2 --- /dev/null +++ b/ABstats.h @@ -0,0 +1,173 @@ +/* + DDS 2.7.0 A bridge double dummy solver. + + Copyright (C) 2006-2014 by Bo Haglund + + Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. + + The code for calculation of par score / contracts is based upon the + + perl code written by Matthew Kidd for ACBLmerge. He has kindly given + + me permission to include a C++ adaptation in DDS. +*/ + + + +/* + Licensed under the Apache License, Version 2.0 (the "License"); + + you may not use this file except in compliance with the License. + + You may obtain a copy of the License at + + + http://www.apache.org/licenses/LICENSE-2.0 + + + Unless required by applicable law or agreed to in writing, software + + distributed under the License is distributed on an "AS IS" BASIS, + + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + + implied. See the License for the specific language governing + + permissions and limitations under the License. +*/ + + + +/* + This object, ABstats, was was written by Søren Hein. + + Many thanks for allowing me to include it in DDS. + + + It is a simple object for AB statistics and return values. + + As it stands, it is quite specific to AB counts. +*/ + + + + +#ifndef _DDS_AB_STATS + +#define _DDS_AB_STATS + + +#include + +#include + +#include + + + +/* + AB_COUNT is a macro that avoids the tedious #ifdef's at + + the code places to be counted. +*/ + + + +#ifdef DDS_AB_STATS + +#define AB_COUNT(a, b, c) + thrp->ABstats.IncrPos(a, b, c) + +#else + +#define AB_COUNT(a, b, c) 1 + +#endif + + + +#define AB_TARGET_REACHED 0 + +#define AB_DEPTH_ZERO 1 + +#define AB_QUICKTRICKS 2 + +#define AB_LATERTRICKS 3 + +#define AB_MAIN_LOOKUP 4 + +#define AB_SIDE_LOOKUP 5 + +#define AB_MOVE_LOOP 6 + + + + +#define DDS_MAXDEPTH 49 + +#define DDS_LINE_LEN 20 + +#define DDS_AB_POS 7 + + + + + +class ABstats + +{ + + private: + + FILE * fp; + + char fname[DDS_LINE_LEN]; + + char name[DDS_AB_POS][40]; + + int counter[DDS_AB_POS][DDS_MAXDEPTH]; + + int counterCum[DDS_AB_POS], + pcounterCum[DDS_AB_POS]; + + int score[2][DDS_MAXDEPTH]; + + int scoreCum[2], + pscoreCum[2]; + + int nodes[DDS_MAXDEPTH], + nodesCum[DDS_MAXDEPTH]; + + int allnodes, + allnodesCum; + + int iniDepth; + + + + public: + + ABstats(); + + ~ABstats(); + + void Reset(); + + void ResetCum(); + + void SetFile(char * fname); + + void SetName(int no, char * name); + + void IncrPos(int no, bool side, int depth); + + void IncrNode(int depth); + + int GetNodes(); + + void PrintStats(); + +}; + + +#endif diff --git a/CalcTables.cpp b/CalcTables.cpp new file mode 100644 index 00000000..b3eee0fe --- /dev/null +++ b/CalcTables.cpp @@ -0,0 +1,198 @@ +/* + DDS 2.7.0 A bridge double dummy solver. + Copyright (C) 2006-2014 by Bo Haglund + Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. + The code for calculation of par score / contracts is based upon the + perl code written by Matthew Kidd for ACBLmerge. He has kindly given + permission to include a C++ adaptation in DDS. + + The PlayAnalyser analyses the played cards of the deal and presents + their double dummy values. The par calculation function DealerPar + provides an alternative way of calculating and presenting par + results. Both these functions have been written by Soren Hein. + He has also made numerous contributions to the code, especially in + the initialization part. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + + +#include "dds.h" +#include "SolveBoard.h" +#include "PBN.h" + + +int STDCALL CalcDDtable(struct ddTableDeal tableDeal, struct ddTableResults * tablep) { + + int h, s, k, ind, tr, first, res; + struct deal dl; + struct boards bo; + struct solvedBoards solved; + + for (h=0; h=0; tr--) + for (first=0; first<=3; first++) { + dl.first=first; + dl.trump=tr; + bo.deals[ind]=dl; + bo.target[ind]=-1; + bo.solutions[ind]=1; + bo.mode[ind]=1; + ind++; + } + + res=SolveAllBoardsN(&bo, &solved, 4); + if (res==1) { + for (ind=0; ind<20; ind++) { + tablep->resTable[bo.deals[ind].trump][rho[bo.deals[ind].first]]= + 13-solved.solvedBoard[ind].score[0]; + } + return RETURN_NO_FAULT; + } + + return res; +} + + +int STDCALL CalcAllTables(struct ddTableDeals *dealsp, int mode, int trumpFilter[5], + struct ddTablesRes *resp, struct allParResults *presp) { + + /* mode = 0: par calculation, vulnerability None + mode = 1: par calculation, vulnerability All + mode = 2: par calculation, vulnerability NS + mode = 3: par calculation, vulnerability EW + mode = -1: no par calculation */ + + int h, s, k, m, ind, tr, first, res, rs, lastIndex=0, + lastBoardIndex[MAXNOOFBOARDS>>2], count=0; + bool okey = false; + struct boards bo; + struct solvedBoards solved; + + /*int Par(struct ddTableResults * tablep, struct parResults *presp, int vulnerable);*/ + + for (k=0; k<5; k++) { + if (!trumpFilter[k]) { + okey=true; + count++; + } + } + + if (!okey) + return RETURN_NO_SUIT; + + switch (count) { + case 1: if (dealsp->noOfTables > 50) return RETURN_TOO_MANY_TABLES;break; + case 2: if (dealsp->noOfTables > 25) return RETURN_TOO_MANY_TABLES;break; + case 3: if (dealsp->noOfTables > 16) return RETURN_TOO_MANY_TABLES;break; + case 4: if (dealsp->noOfTables > 12) return RETURN_TOO_MANY_TABLES;break; + case 5: if (dealsp->noOfTables > 10) return RETURN_TOO_MANY_TABLES;break; + } + + ind=0; + resp->noOfBoards=0; + + for (m=0; mnoOfTables; m++) { + for (tr=4; tr>=0; tr--) { + if (!trumpFilter[tr]) { + for (first=0; first<=3; first++) { + for (h=0; hdeals[m].cards[h][s]; + bo.deals[ind].first=first; + bo.deals[ind].trump=tr; + for (k=0; k<=2; k++) { + bo.deals[ind].currentTrickRank[k]=0; + bo.deals[ind].currentTrickSuit[k]=0; + } + + bo.target[ind]=-1; + bo.solutions[ind]=1; + bo.mode[ind]=1; + lastIndex=ind; + lastBoardIndex[m]=ind; + ind++; + } + } + } + } + + bo.noOfBoards=lastIndex+1; + + res=SolveAllBoardsN(&bo, &solved, 4); + if (res==1) { + resp->noOfBoards+=solved.noOfBoards; + for (ind=0; ind<=lastIndex; ind++) { + for (k=0; k<=lastIndex; k++) { + if (ind<=lastBoardIndex[k]) { + resp->results[k].resTable[bo.deals[ind].trump][rho[bo.deals[ind].first]]= + 13-solved.solvedBoard[ind].score[0]; + break; + } + } + } + + if ((mode > -1) && (mode < 4)) { + /* Calculate par */ + for (k=0; knoOfTables; k++) { + rs=Par(&(resp->results[k]), &(presp->presults[k]), mode); + /* vulnerable 0: None 1: Both 2: NS 3: EW */ + if (rs!=1) + return rs; + } + } + return RETURN_NO_FAULT; + } + return res; +} + + +int STDCALL CalcAllTablesPBN(struct ddTableDealsPBN *dealsp, int mode, int trumpFilter[5], + struct ddTablesRes *resp, struct allParResults *presp) { + int res, k; + struct ddTableDeals dls; + + for (k=0; knoOfTables; k++) + if (ConvertFromPBN(dealsp->deals[k].cards, dls.deals[k].cards)!=1) + return RETURN_PBN_FAULT; + + dls.noOfTables=dealsp->noOfTables; + + res=CalcAllTables(&dls, mode, trumpFilter, resp, presp); + + return res; +} + + +int STDCALL CalcDDtablePBN(struct ddTableDealPBN tableDealPBN, struct ddTableResults * tablep) { + struct ddTableDeal tableDeal; + int res; + + if (ConvertFromPBN(tableDealPBN.cards, tableDeal.cards)!=1) + return RETURN_PBN_FAULT; + + res=CalcDDtable(tableDeal, tablep); + + return res; +} + + diff --git a/DLL-dds_260_u.rtf b/DLL-dds_260_u.rtf deleted file mode 100644 index 55f1035f..00000000 --- a/DLL-dds_260_u.rtf +++ /dev/null @@ -1,2665 +0,0 @@ -{\rtf1\adeflang1025\ansi\ansicpg1252\uc1\adeff1\deff0\stshfdbch0\stshfloch37\stshfhich37\stshfbi37\deflang1053\deflangfe1053\themelang1053\themelangfe0\themelangcs0{\fonttbl{\f0\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f1\fbidi \fswiss\fcharset0\fprq2{\*\panose 020b0604020202020204}Arial;} -{\f2\fbidi \fmodern\fcharset0\fprq1{\*\panose 02070309020205020404}Courier New;}{\f3\fbidi \froman\fcharset2\fprq2{\*\panose 05050102010706020507}Symbol;}{\f10\fbidi \fnil\fcharset2\fprq2{\*\panose 05000000000000000000}Wingdings;} -{\f34\fbidi \froman\fcharset0\fprq2{\*\panose 02040503050406030204}Cambria Math;}{\f37\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;}{\f39\fbidi \froman\fcharset0\fprq2{\*\panose 00000000000000000000}Cambria;} -{\f40\fbidi \fswiss\fcharset0\fprq2{\*\panose 00000000000000000000}Tahoma;}{\flomajor\f31500\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;} -{\fdbmajor\f31501\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fhimajor\f31502\fbidi \froman\fcharset0\fprq2{\*\panose 00000000000000000000}Cambria;} -{\fbimajor\f31503\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\flominor\f31504\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;} -{\fdbminor\f31505\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fhiminor\f31506\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;} -{\fbiminor\f31507\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f41\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\f42\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;} -{\f44\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\f45\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\f46\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\f47\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);} -{\f48\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\f49\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\f51\fbidi \fswiss\fcharset238\fprq2 Arial CE;}{\f52\fbidi \fswiss\fcharset204\fprq2 Arial Cyr;} -{\f54\fbidi \fswiss\fcharset161\fprq2 Arial Greek;}{\f55\fbidi \fswiss\fcharset162\fprq2 Arial Tur;}{\f56\fbidi \fswiss\fcharset177\fprq2 Arial (Hebrew);}{\f57\fbidi \fswiss\fcharset178\fprq2 Arial (Arabic);} -{\f58\fbidi \fswiss\fcharset186\fprq2 Arial Baltic;}{\f59\fbidi \fswiss\fcharset163\fprq2 Arial (Vietnamese);}{\f61\fbidi \fmodern\fcharset238\fprq1 Courier New CE;}{\f62\fbidi \fmodern\fcharset204\fprq1 Courier New Cyr;} -{\f64\fbidi \fmodern\fcharset161\fprq1 Courier New Greek;}{\f65\fbidi \fmodern\fcharset162\fprq1 Courier New Tur;}{\f66\fbidi \fmodern\fcharset177\fprq1 Courier New (Hebrew);}{\f67\fbidi \fmodern\fcharset178\fprq1 Courier New (Arabic);} -{\f68\fbidi \fmodern\fcharset186\fprq1 Courier New Baltic;}{\f69\fbidi \fmodern\fcharset163\fprq1 Courier New (Vietnamese);}{\f381\fbidi \froman\fcharset238\fprq2 Cambria Math CE;}{\f382\fbidi \froman\fcharset204\fprq2 Cambria Math Cyr;} -{\f384\fbidi \froman\fcharset161\fprq2 Cambria Math Greek;}{\f385\fbidi \froman\fcharset162\fprq2 Cambria Math Tur;}{\f388\fbidi \froman\fcharset186\fprq2 Cambria Math Baltic;}{\f389\fbidi \froman\fcharset163\fprq2 Cambria Math (Vietnamese);} -{\f411\fbidi \fswiss\fcharset238\fprq2 Calibri CE;}{\f412\fbidi \fswiss\fcharset204\fprq2 Calibri Cyr;}{\f414\fbidi \fswiss\fcharset161\fprq2 Calibri Greek;}{\f415\fbidi \fswiss\fcharset162\fprq2 Calibri Tur;} -{\f418\fbidi \fswiss\fcharset186\fprq2 Calibri Baltic;}{\f419\fbidi \fswiss\fcharset163\fprq2 Calibri (Vietnamese);}{\f431\fbidi \froman\fcharset238\fprq2 Cambria CE;}{\f432\fbidi \froman\fcharset204\fprq2 Cambria Cyr;} -{\f434\fbidi \froman\fcharset161\fprq2 Cambria Greek;}{\f435\fbidi \froman\fcharset162\fprq2 Cambria Tur;}{\f438\fbidi \froman\fcharset186\fprq2 Cambria Baltic;}{\f439\fbidi \froman\fcharset163\fprq2 Cambria (Vietnamese);} -{\f441\fbidi \fswiss\fcharset238\fprq2 Tahoma CE;}{\f442\fbidi \fswiss\fcharset204\fprq2 Tahoma Cyr;}{\f444\fbidi \fswiss\fcharset161\fprq2 Tahoma Greek;}{\f445\fbidi \fswiss\fcharset162\fprq2 Tahoma Tur;} -{\f446\fbidi \fswiss\fcharset177\fprq2 Tahoma (Hebrew);}{\f447\fbidi \fswiss\fcharset178\fprq2 Tahoma (Arabic);}{\f448\fbidi \fswiss\fcharset186\fprq2 Tahoma Baltic;}{\f449\fbidi \fswiss\fcharset163\fprq2 Tahoma (Vietnamese);} -{\f450\fbidi \fswiss\fcharset222\fprq2 Tahoma (Thai);}{\flomajor\f31508\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\flomajor\f31509\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;} -{\flomajor\f31511\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\flomajor\f31512\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\flomajor\f31513\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);} -{\flomajor\f31514\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\flomajor\f31515\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\flomajor\f31516\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);} -{\fdbmajor\f31518\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fdbmajor\f31519\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fdbmajor\f31521\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;} -{\fdbmajor\f31522\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fdbmajor\f31523\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fdbmajor\f31524\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);} -{\fdbmajor\f31525\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fdbmajor\f31526\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fhimajor\f31528\fbidi \froman\fcharset238\fprq2 Cambria CE;} -{\fhimajor\f31529\fbidi \froman\fcharset204\fprq2 Cambria Cyr;}{\fhimajor\f31531\fbidi \froman\fcharset161\fprq2 Cambria Greek;}{\fhimajor\f31532\fbidi \froman\fcharset162\fprq2 Cambria Tur;} -{\fhimajor\f31535\fbidi \froman\fcharset186\fprq2 Cambria Baltic;}{\fhimajor\f31536\fbidi \froman\fcharset163\fprq2 Cambria (Vietnamese);}{\fbimajor\f31538\fbidi \froman\fcharset238\fprq2 Times New Roman CE;} -{\fbimajor\f31539\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fbimajor\f31541\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fbimajor\f31542\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;} -{\fbimajor\f31543\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fbimajor\f31544\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fbimajor\f31545\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;} -{\fbimajor\f31546\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\flominor\f31548\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\flominor\f31549\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;} -{\flominor\f31551\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\flominor\f31552\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\flominor\f31553\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);} -{\flominor\f31554\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\flominor\f31555\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\flominor\f31556\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);} -{\fdbminor\f31558\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fdbminor\f31559\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fdbminor\f31561\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;} -{\fdbminor\f31562\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fdbminor\f31563\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fdbminor\f31564\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);} -{\fdbminor\f31565\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fdbminor\f31566\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fhiminor\f31568\fbidi \fswiss\fcharset238\fprq2 Calibri CE;} -{\fhiminor\f31569\fbidi \fswiss\fcharset204\fprq2 Calibri Cyr;}{\fhiminor\f31571\fbidi \fswiss\fcharset161\fprq2 Calibri Greek;}{\fhiminor\f31572\fbidi \fswiss\fcharset162\fprq2 Calibri Tur;} -{\fhiminor\f31575\fbidi \fswiss\fcharset186\fprq2 Calibri Baltic;}{\fhiminor\f31576\fbidi \fswiss\fcharset163\fprq2 Calibri (Vietnamese);}{\fbiminor\f31578\fbidi \froman\fcharset238\fprq2 Times New Roman CE;} -{\fbiminor\f31579\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fbiminor\f31581\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fbiminor\f31582\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;} -{\fbiminor\f31583\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fbiminor\f31584\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fbiminor\f31585\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;} -{\fbiminor\f31586\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}}{\colortbl;\red0\green0\blue0;\red0\green0\blue255;\red0\green255\blue255;\red0\green255\blue0;\red255\green0\blue255;\red255\green0\blue0;\red255\green255\blue0; -\red255\green255\blue255;\red0\green0\blue128;\red0\green128\blue128;\red0\green128\blue0;\red128\green0\blue128;\red128\green0\blue0;\red128\green128\blue0;\red128\green128\blue128;\red192\green192\blue192; -\chyperlink\ctint255\cshade255\red0\green0\blue255;\cfollowedhyperlink\ctint255\cshade255\red128\green0\blue128;\red0\green112\blue192;}{\*\defchp \f37 }{\*\defpap \ql \li0\ri0\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 } -\noqfpromote {\stylesheet{\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 \snext0 \sqformat \spriority0 \styrsid2449260 Normal;}{ -\s1\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\outlinelevel0\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 \sbasedon0 \snext0 \slink15 \sqformat heading 1;}{ -\s2\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\outlinelevel1\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 \sbasedon0 \snext0 \slink16 \sqformat heading 2;}{ -\s3\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 \sbasedon0 \snext0 \slink17 \sqformat heading 3;}{\*\cs10 \additive -\sunhideused \spriority1 Default Paragraph Font;}{\*\ts11\tsrowd\trftsWidthB3\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblind0\tblindtype3\tsvertalt\tsbrdrt\tsbrdrl\tsbrdrb\tsbrdrr\tsbrdrdgl\tsbrdrdgr\tsbrdrh\tsbrdrv -\ql \li0\ri0\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af37\afs20\alang1025 \ltrch\fcs0 \f37\fs20\lang1053\langfe1053\cgrid\langnp1053\langfenp1053 \snext11 \ssemihidden \sunhideused Normal Table;}{\*\cs15 -\additive \rtlch\fcs1 \af0 \ltrch\fcs0 \b\f39\fs32\lang1033\langfe0\kerning32\langnp1033\langfenp0 \sbasedon10 \slink1 \slocked \spriority9 Rubrik 1 Char;}{\*\cs16 \additive \rtlch\fcs1 \af0 \ltrch\fcs0 \b\i\f39\fs28\lang1033\langfe0\langnp1033\langfenp0 -\sbasedon10 \slink2 \slocked \ssemihidden \spriority9 Rubrik 2 Char;}{\*\cs17 \additive \rtlch\fcs1 \af0 \ltrch\fcs0 \b\f39\fs26\lang1033\langfe0\langnp1033\langfenp0 \sbasedon10 \slink3 \slocked \ssemihidden \spriority9 Rubrik 3 Char;}{ -\s18\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af40\afs16\alang1025 \ltrch\fcs0 \f40\fs16\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 \sbasedon0 \snext18 \slink19 \ssemihidden \sunhideused \styrsid5376200 Balloon Text;} -{\*\cs19 \additive \rtlch\fcs1 \af0 \ltrch\fcs0 \f40\fs16\lang1033\langfe1053\langnp1033\langfenp1053 \sbasedon10 \slink18 \slocked \ssemihidden \styrsid5376200 Ballongtext Char;}{\*\ts20\tsrowd\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb -\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidthB3\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblind0\tblindtype3\tsvertalt\tsbrdrt\tsbrdrl\tsbrdrb\tsbrdrr\tsbrdrdgl\tsbrdrdgr\tsbrdrh\tsbrdrv -\ql \li0\ri0\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af0\afs20\alang1025 \ltrch\fcs0 \f37\fs20\lang1031\langfe1031\cgrid\langnp1031\langfenp1031 \sbasedon11 \snext20 \spriority59 \styrsid1789909 Table Grid;}{ -\s21\ql \li0\ri0\nowidctlpar\tqc\tx4536\tqr\tx9072\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 \sbasedon0 \snext21 \slink22 \sunhideused \styrsid14119459 -header;}{\*\cs22 \additive \rtlch\fcs1 \af0 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\langnp1033\langfenp1053 \sbasedon10 \slink21 \slocked \styrsid14119459 Sidhuvud Char;}{\s23\ql \li0\ri0\nowidctlpar -\tqc\tx4536\tqr\tx9072\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 \sbasedon0 \snext23 \slink24 \sunhideused \styrsid14119459 footer;}{\*\cs24 \additive -\rtlch\fcs1 \af0 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\langnp1033\langfenp1053 \sbasedon10 \slink23 \slocked \styrsid14119459 Sidfot Char;}{\s25\ql \li0\ri0\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 -\af0\afs22\alang1025 \ltrch\fcs0 \f37\fs22\lang1031\langfe1033\cgrid\langnp1031\langfenp1033 \snext25 \sqformat \spriority1 \styrsid2849436 No Spacing;}{\*\cs26 \additive \rtlch\fcs1 \af0 \ltrch\fcs0 \ul\cf17 \sbasedon10 \sunhideused \styrsid16189992 -Hyperlink;}{\*\cs27 \additive \rtlch\fcs1 \af0 \ltrch\fcs0 \ul\cf18 \sbasedon10 \ssemihidden \sunhideused \styrsid1385888 FollowedHyperlink;}}{\*\listtable{\list\listtemplateid1990129598\listhybrid{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0 -\levelfollow0\levelstartat3\levelspace0\levelindent0{\leveltext\leveltemplateid-561612730\'01-;}{\levelnumbers;}\loch\af37\hich\af37\dbch\af0\fbias0 \fi-360\li720\lin720 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1 -\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid67567619\'01o;}{\levelnumbers;}\f2\fbias0 \fi-360\li1440\lin1440 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0 -{\leveltext\leveltemplateid67567621\'01\u-3929 ?;}{\levelnumbers;}\f10\fbias0 \fi-360\li2160\lin2160 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid67567617 -\'01\u-3913 ?;}{\levelnumbers;}\f3\fbias0 \fi-360\li2880\lin2880 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid67567619\'01o;}{\levelnumbers;}\f2\fbias0 -\fi-360\li3600\lin3600 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid67567621\'01\u-3929 ?;}{\levelnumbers;}\f10\fbias0 \fi-360\li4320\lin4320 }{\listlevel -\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid67567617\'01\u-3913 ?;}{\levelnumbers;}\f3\fbias0 \fi-360\li5040\lin5040 }{\listlevel\levelnfc23\levelnfcn23\leveljc0 -\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid67567619\'01o;}{\levelnumbers;}\f2\fbias0 \fi-360\li5760\lin5760 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1 -\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid67567621\'01\u-3929 ?;}{\levelnumbers;}\f10\fbias0 \fi-360\li6480\lin6480 }{\listname ;}\listid111049838}{\list\listtemplateid1379147632\listhybrid{\listlevel\levelnfc23\levelnfcn23\leveljc0 -\leveljcn0\levelfollow0\levelstartat3\levelspace0\levelindent0{\leveltext\leveltemplateid-926013378\'01\u-3913 ?;}{\levelnumbers;}\loch\af3\hich\af3\dbch\af0\fbias0 \fi-360\li360\lin360 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0 -\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid67567619\'01o;}{\levelnumbers;}\f2\fbias0 \fi-360\li1080\lin1080 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0 -\levelindent0{\leveltext\leveltemplateid67567621\'01\u-3929 ?;}{\levelnumbers;}\f10\fbias0 \fi-360\li1800\lin1800 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext -\leveltemplateid67567617\'01\u-3913 ?;}{\levelnumbers;}\f3\fbias0 \fi-360\li2520\lin2520 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid67567619 -\'01o;}{\levelnumbers;}\f2\fbias0 \fi-360\li3240\lin3240 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid67567621\'01\u-3929 ?;}{\levelnumbers;}\f10\fbias0 -\fi-360\li3960\lin3960 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid67567617\'01\u-3913 ?;}{\levelnumbers;}\f3\fbias0 \fi-360\li4680\lin4680 }{\listlevel -\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid67567619\'01o;}{\levelnumbers;}\f2\fbias0 \fi-360\li5400\lin5400 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0 -\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid67567621\'01\u-3929 ?;}{\levelnumbers;}\f10\fbias0 \fi-360\li6120\lin6120 }{\listname ;}\listid356662528}{\list\listtemplateid59153134\listhybrid{\listlevel -\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat3\levelspace0\levelindent0{\leveltext\leveltemplateid-320719486\'01\u-3986 ?;}{\levelnumbers;}\loch\af10\hich\af10\dbch\af0\fbias0 \fi-360\li720\lin720 }{\listlevel\levelnfc23\levelnfcn23 -\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid67567619\'01o;}{\levelnumbers;}\f2\fbias0 \fi-360\li1440\lin1440 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0 -\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid67567621\'01\u-3929 ?;}{\levelnumbers;}\f10\fbias0 \fi-360\li2160\lin2160 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative -\levelspace0\levelindent0{\leveltext\leveltemplateid67567617\'01\u-3913 ?;}{\levelnumbers;}\f3\fbias0 \fi-360\li2880\lin2880 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext -\leveltemplateid67567619\'01o;}{\levelnumbers;}\f2\fbias0 \fi-360\li3600\lin3600 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid67567621 -\'01\u-3929 ?;}{\levelnumbers;}\f10\fbias0 \fi-360\li4320\lin4320 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid67567617\'01\u-3913 ?;}{\levelnumbers;} -\f3\fbias0 \fi-360\li5040\lin5040 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid67567619\'01o;}{\levelnumbers;}\f2\fbias0 \fi-360\li5760\lin5760 } -{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid67567621\'01\u-3929 ?;}{\levelnumbers;}\f10\fbias0 \fi-360\li6480\lin6480 }{\listname ;}\listid880896998} -{\list\listtemplateid1722038506\listhybrid{\listlevel\levelnfc0\levelnfcn0\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\leveltemplateid69009423\'02\'00.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 \fbias0 -\fi-360\li720\lin720 }{\listlevel\levelnfc4\levelnfcn4\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid69009433\'02\'01.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 -\fi-360\li1440\lin1440 }{\listlevel\levelnfc2\levelnfcn2\leveljc2\leveljcn2\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid69009435\'02\'02.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 -\fi-180\li2160\lin2160 }{\listlevel\levelnfc0\levelnfcn0\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid69009423\'02\'03.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 -\fi-360\li2880\lin2880 }{\listlevel\levelnfc4\levelnfcn4\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid69009433\'02\'04.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 -\fi-360\li3600\lin3600 }{\listlevel\levelnfc2\levelnfcn2\leveljc2\leveljcn2\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid69009435\'02\'05.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 -\fi-180\li4320\lin4320 }{\listlevel\levelnfc0\levelnfcn0\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid69009423\'02\'06.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 -\fi-360\li5040\lin5040 }{\listlevel\levelnfc4\levelnfcn4\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid69009433\'02\'07.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 -\fi-360\li5760\lin5760 }{\listlevel\levelnfc2\levelnfcn2\leveljc2\leveljcn2\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid69009435\'02\'08.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 -\fi-180\li6480\lin6480 }{\listname ;}\listid894395624}{\list\listtemplateid-681416416\listhybrid{\listlevel\levelnfc0\levelnfcn0\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\leveltemplateid69009423 -\'02\'00.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 \fbias0 \fi-360\li720\lin720 }{\listlevel\levelnfc4\levelnfcn4\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid69009433 -\'02\'01.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 \fi-360\li1440\lin1440 }{\listlevel\levelnfc2\levelnfcn2\leveljc2\leveljcn2\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid69009435 -\'02\'02.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 \fi-180\li2160\lin2160 }{\listlevel\levelnfc0\levelnfcn0\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid69009423 -\'02\'03.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 \fi-360\li2880\lin2880 }{\listlevel\levelnfc4\levelnfcn4\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid69009433 -\'02\'04.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 \fi-360\li3600\lin3600 }{\listlevel\levelnfc2\levelnfcn2\leveljc2\leveljcn2\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid69009435 -\'02\'05.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 \fi-180\li4320\lin4320 }{\listlevel\levelnfc0\levelnfcn0\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid69009423 -\'02\'06.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 \fi-360\li5040\lin5040 }{\listlevel\levelnfc4\levelnfcn4\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid69009433 -\'02\'07.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 \fi-360\li5760\lin5760 }{\listlevel\levelnfc2\levelnfcn2\leveljc2\leveljcn2\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\leveltemplateid69009435 -\'02\'08.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 \fi-180\li6480\lin6480 }{\listname ;}\listid1355108172}}{\*\listoverridetable{\listoverride\listid880896998\listoverridecount0\ls1}{\listoverride\listid111049838\listoverridecount0\ls2} -{\listoverride\listid356662528\listoverridecount0\ls3}{\listoverride\listid894395624\listoverridecount0\ls4}{\listoverride\listid1355108172\listoverridecount0\ls5}}{\*\revtbl {Unknown;}}{\*\pgptbl {\pgp\ipgp0\itap0\li0\ri0\sb0\sa0}}{\*\rsidtbl \rsid70445\rsid81923 -\rsid133834\rsid163452\rsid201282\rsid340960\rsid348894\rsid394021\rsid409864\rsid415956\rsid488565\rsid490522\rsid532764\rsid543320\rsid556337\rsid617158\rsid678750\rsid750270\rsid750573\rsid856123\rsid875686\rsid876335\rsid930020\rsid940090\rsid943124 -\rsid1187219\rsid1190356\rsid1191142\rsid1202844\rsid1212155\rsid1258951\rsid1261441\rsid1313463\rsid1385888\rsid1386919\rsid1445386\rsid1449865\rsid1469964\rsid1538933\rsid1579764\rsid1596512\rsid1706832\rsid1708722\rsid1716250\rsid1716707\rsid1770393 -\rsid1775603\rsid1783690\rsid1789909\rsid1800033\rsid1839042\rsid1846101\rsid1910210\rsid2057006\rsid2060511\rsid2112235\rsid2112392\rsid2181632\rsid2229366\rsid2244172\rsid2260548\rsid2365273\rsid2427760\rsid2443070\rsid2446079\rsid2447429\rsid2449260 -\rsid2493172\rsid2505631\rsid2635362\rsid2641133\rsid2647507\rsid2769001\rsid2833141\rsid2838088\rsid2849436\rsid2894529\rsid2952804\rsid3034397\rsid3034548\rsid3036029\rsid3095740\rsid3228943\rsid3231049\rsid3243212\rsid3303530\rsid3308555\rsid3342996 -\rsid3347855\rsid3352595\rsid3547548\rsid3552042\rsid3567911\rsid3752772\rsid3819803\rsid3893966\rsid3937665\rsid3954019\rsid4000336\rsid4002451\rsid4071901\rsid4155951\rsid4264099\rsid4288894\rsid4350787\rsid4405244\rsid4460640\rsid4533879\rsid4538894 -\rsid4542728\rsid4545218\rsid4602097\rsid4616356\rsid4675069\rsid4679726\rsid4683401\rsid4738929\rsid4981561\rsid5054625\rsid5113162\rsid5191231\rsid5320216\rsid5332441\rsid5376200\rsid5388872\rsid5462095\rsid5506187\rsid5525810\rsid5526679\rsid5594575 -\rsid5638529\rsid5650157\rsid5653460\rsid5712409\rsid5712463\rsid5767474\rsid5843075\rsid5862788\rsid5928646\rsid5974982\rsid5979431\rsid6047888\rsid6054214\rsid6058144\rsid6099241\rsid6170015\rsid6228168\rsid6246771\rsid6247188\rsid6302457\rsid6309374 -\rsid6309794\rsid6362316\rsid6384684\rsid6436444\rsid6499600\rsid6557897\rsid6569652\rsid6573516\rsid6578564\rsid6580905\rsid6629265\rsid6633554\rsid6641819\rsid6650094\rsid6701983\rsid6845226\rsid6895698\rsid6910245\rsid6950962\rsid6957422\rsid6968528 -\rsid7041439\rsid7089377\rsid7167315\rsid7277737\rsid7285964\rsid7302518\rsid7305895\rsid7421144\rsid7542885\rsid7545453\rsid7616262\rsid7678768\rsid7683346\rsid7763137\rsid7804526\rsid7807046\rsid7931676\rsid7949161\rsid7952569\rsid7959800\rsid8000484 -\rsid8001475\rsid8090374\rsid8137115\rsid8154048\rsid8281290\rsid8323199\rsid8395240\rsid8408337\rsid8527940\rsid8538722\rsid8541195\rsid8549130\rsid8588264\rsid8592696\rsid8593145\rsid8610523\rsid8616569\rsid8655475\rsid8799536\rsid8983788\rsid8999377 -\rsid9002512\rsid9047914\rsid9125746\rsid9175287\rsid9176944\rsid9249735\rsid9314635\rsid9315241\rsid9331762\rsid9389132\rsid9401184\rsid9515364\rsid9515749\rsid9530285\rsid9534906\rsid9572146\rsid9586997\rsid9588289\rsid9713208\rsid9716036\rsid9731125 -\rsid9834330\rsid9838060\rsid9845272\rsid9856546\rsid9898065\rsid9907738\rsid9974881\rsid10108539\rsid10122796\rsid10174318\rsid10176355\rsid10239463\rsid10245607\rsid10290420\rsid10308289\rsid10310988\rsid10313626\rsid10376323\rsid10383915\rsid10423813 -\rsid10426263\rsid10452726\rsid10486826\rsid10490777\rsid10496751\rsid10567623\rsid10576044\rsid10631094\rsid10698169\rsid10843677\rsid11078728\rsid11089766\rsid11107656\rsid11149793\rsid11173409\rsid11277669\rsid11279197\rsid11294126\rsid11297517 -\rsid11344057\rsid11351616\rsid11367514\rsid11540483\rsid11562205\rsid11762622\rsid11801900\rsid11805493\rsid11868543\rsid11882119\rsid11930665\rsid11952575\rsid11956256\rsid11958279\rsid12008966\rsid12065713\rsid12068517\rsid12071252\rsid12087407 -\rsid12128238\rsid12156867\rsid12408664\rsid12460046\rsid12530193\rsid12595610\rsid12595779\rsid12649012\rsid12657542\rsid12658900\rsid12659025\rsid12720965\rsid12732549\rsid12788235\rsid12854747\rsid12874235\rsid12914880\rsid12915233\rsid12941889 -\rsid12982360\rsid12986669\rsid12992185\rsid12998134\rsid13053124\rsid13174672\rsid13180120\rsid13244366\rsid13250408\rsid13267252\rsid13316938\rsid13319718\rsid13321745\rsid13331862\rsid13336457\rsid13444065\rsid13457490\rsid13593709\rsid13641876 -\rsid13697230\rsid13701456\rsid13714332\rsid13780248\rsid13857996\rsid13902528\rsid13915886\rsid14095979\rsid14102810\rsid14119459\rsid14169293\rsid14171083\rsid14292727\rsid14295269\rsid14307787\rsid14370947\rsid14429502\rsid14435334\rsid14436934 -\rsid14444034\rsid14498845\rsid14574742\rsid14636249\rsid14892228\rsid15031452\rsid15079468\rsid15150655\rsid15291332\rsid15490742\rsid15613967\rsid15620535\rsid15668792\rsid15747980\rsid15755105\rsid15757396\rsid15821976\rsid15932640\rsid15939092 -\rsid15999168\rsid16012515\rsid16021753\rsid16147558\rsid16151628\rsid16189992\rsid16206388\rsid16217378\rsid16276961\rsid16323149\rsid16348565\rsid16405367\rsid16467273\rsid16470149\rsid16530750\rsid16534708\rsid16585076\rsid16609230\rsid16610750 -\rsid16655487\rsid16676162\rsid16715055\rsid16724586\rsid16731528}{\mmathPr\mmathFont34\mbrkBin0\mbrkBinSub0\msmallFrac0\mdispDef1\mlMargin0\mrMargin0\mdefJc1\mwrapIndent1440\mintLim0\mnaryLim1}{\info{\author Soren Hein}{\operator Microsoft-konto} -{\creatim\yr2014\mo8\dy20\hr18\min30}{\revtim\yr2014\mo9\dy15\hr8\min35}{\printim\yr2014\mo7\dy8\hr18\min6}{\version113}{\edmins1122}{\nofpages20}{\nofwords5659}{\nofchars29997}{\*\company HP}{\nofcharsws35585}{\vern57437}}{\*\xmlnstbl {\xmlns1 http://sch -emas.microsoft.com/office/word/2003/wordml}}\paperw12240\paperh15840\margl1417\margr1417\margt1417\margb1417\gutter0\ltrsect -\widowctrl\ftnbj\aenddoc\hyphhotz425\trackmoves0\trackformatting1\donotembedsysfont0\relyonvml0\donotembedlingdata1\grfdocevents0\validatexml0\showplaceholdtext0\ignoremixedcontent0\saveinvalidxml0\showxmlerrors0\horzdoc\dghspace120\dgvspace120 -\dghorigin1701\dgvorigin1984\dghshow0\dgvshow3\jcompress\viewkind1\viewscale100\rsidroot4538894 \fet0{\*\wgrffmtfilter 2450}\ilfomacatclnup0{\*\ftnsep \ltrpar \pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid14119459 -\rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \insrsid10122796 \chftnsep -\par }}{\*\ftnsepc \ltrpar \pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\insrsid10122796 \chftnsepc -\par }}{\*\aftnsep \ltrpar \pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\insrsid10122796 \chftnsep -\par }}{\*\aftnsepc \ltrpar \pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\insrsid10122796 \chftnsepc -\par }}\ltrpar \sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\footerr \ltrpar \pard\plain \ltrpar\s23\qc \li0\ri0\nowidctlpar\tqc\tx4536\tqr\tx9072\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\field{\*\fldinst {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid10174318\charrsid14119459 PAGE \\* MERGEFORMAT}}{\fldrslt {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\lang1024\langfe1024\noproof\langnp1031\insrsid9572146\charrsid9572146 20}}}\sectd \ltrsect\linex0\endnhere\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid10174318\charrsid14119459 -\par }\pard \ltrpar\s23\ql \li0\ri0\nowidctlpar\tqc\tx4536\tqr\tx9072\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \insrsid10174318 -\par }}{\*\pnseclvl1\pnucrm\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl2\pnucltr\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl3\pndec\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl4\pnlcltr\pnstart1\pnindent720\pnhang {\pntxta )}} -{\*\pnseclvl5\pndec\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl6\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl7\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl8 -\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl9\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 -\ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid6650094\charrsid14119459 Bo Haglund, Bob Richardson -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid5712463 Rev U}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid15291332 , 2014-09}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid5712463 -}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid9572146 1}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\insrsid6170015 5}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid6650094\charrsid14119459 -\par Latest DLL issue with this description is available at }{\field\flddirty{\*\fldinst {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid6650094\charrsid14119459 HYPERLINK "http://www.bahnhof.se/wb758135/"}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\lang1053\langfe1053\langnp1053\insrsid4538894\charrsid14119459 {\*\datafield -00d0c9ea79f9bace118c8200aa004ba90b0200000003000000e0c9ea79f9bace118c8200aa004ba90b5800000068007400740070003a002f002f007700770077002e006200610068006e0068006f0066002e00730065002f00770062003700350038003100330035002f000000795881f43b1d7f48af2c825dc48527630000 -0000a5ab00000000004b00000079000000000075000b00006d000000000b0100000000000028f90000710000000b0000004b0000c200f90000003b000000001b00000f000000001b006c001b00000000008a00000000}}}{\fldrslt {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\ul\cf2\insrsid6650094\charrsid14119459 http://www.bahnhof.se/wb758135/}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid6650094\charrsid14119459 -\par -\par -\par }\pard\plain \ltrpar\s2\ql \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel1\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\ul\cf1\insrsid6650094\charrsid14119459 Short description of the DLL functions supported in D}{\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \b\f37\ul\cf1\insrsid5712463 ouble Dummy Problem Solver 2.6}{\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\ul\cf1\insrsid6650094\charrsid14119459 -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid10576044\charrsid14119459 -\par }\pard\plain \ltrpar\s3\ql \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid6650094\charrsid14119459 Callable functions -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1789909\charrsid14119459 -The callable functions are all preceded with }{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 \f2\fs22\cf1\insrsid1789909\charrsid1789909 extern "C" __declspec(dllimport) int __stdcall}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1789909 . }{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid10576044 The prototypes are available in dll.h.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14119459 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13331862 -\par -\par }{\field{\*\fldinst {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\ul\cf19\insrsid14119459\charrsid14119459 REF Return \\h }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\ul\cf19\insrsid14119459\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b020000000800000007000000520065007400750072006e0000000074006100610061000000000069000f00000065000000000064000800c67d0000420030000000000000002c00060000}}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\ul\cf19\insrsid14119459\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \f37\ul\cf19\insrsid16012515\charrsid16012515 Return codes}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid14119459 are given at the end.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10576044 -\par -\par }\pard \ltrpar\qj \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid13331862 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1789909 Not all functions are present in all versions of the DLL.}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid8154048 - For historical reasons, the function names are not entirely consistent with respect to the input format. Functions accepting binary deals will end on Bin, and those accepting PBN deals will end on PBN in the future. At some point existing function nam -es may be changed as well, so use the new names!}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6650094 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid8395240 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \i\f37\cf1\insrsid8395240\charrsid1800033 The Basic Functions -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid8395240 -\par The basic functions SolveBoard and SolveBoardPBN solve }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12941889 each }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid8395240 a single hand }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12941889 -and are thread-safe}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid8395240 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12941889 making it possible }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6641819 using them for solving}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12941889 several han -ds in parallel. The other callable functions use the SolveBoard functions either directly or indirectly. -\par -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \i\f37\cf1\insrsid7545453\charrsid1800033 The Multi-thread}{\rtlch\fcs1 \af1 \ltrch\fcs0 \i\f37\cf1\insrsid12941889\charrsid1800033 Double Dummy Solver Functions -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6054214 -\par The double dummy trick values for all 20 possible combinations of a hand\rquote s trump strain and declarer han}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid5506187 d alternatives are solved by a}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6054214 }{ -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid4738929 single }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6054214 call to }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid5506187 one of }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6054214 the function}{ -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid5506187 s CalcDDtable and CalcDDtablePBN.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid856123 Threads are allocated per strain.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6054214 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid856123 -\par To obtain better utilization of available threads, the double dummy}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid4155951 (DD)}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid856123 tables can be grouped using one of the func}{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid5388872 tions CalcAllTables and }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid856123 CalcAllTablesPBN. -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11277669 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid4155951 Solving hands can be done much quicker using one of the multi-thread alternatives }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6910245 for}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid4155951 }{ -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6910245 calling }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid4155951 SolveBoard. Then a number of hands are grouped for a sing}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12008966 -le call to one of the functions}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11277669 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid5388872 SolveAllChunksBin and }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid4155951 SolveAllChunksPBN. -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12008966 T}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1708722 he hands }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12008966 are then solved }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1708722 -in parallel}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12008966 using the available threads}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1708722 . -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1800033 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \i\f37\cf1\insrsid1800033\charrsid7959800 The PAR Calculation Functions -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1800033 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11958279 The PAR calculation functions }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6957422 find the optimal contract(s) assuming open cards and optimal bidding from both sides.}{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid5650157 In very rare cases it matters which side }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid4002451 or hand that starts the bidding, i.e. which side or hand that }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10423813 -is first to bid its optimal contract.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1800033 -\par }\pard \ltrpar\qj \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid10308289 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid5650157 Two }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2833141 alternatives are given}{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid10308289 : -\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af0 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langnp1033\insrsid10308289 \hich\af37\dbch\af0\loch\f37 1.\tab}}\pard \ltrpar\ql \fi-360\li720\ri0\nowidctlpar\wrapdefault\faauto\ls5\rin0\lin720\itap0\pararsid7305895 -{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10308289 The PAR scores / contracts are calculated separately for each side. In almost all cases the results w}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3752772 -ill be identical for both sides, but in rare cases}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9834330 the result is dependent on which side that \'93starts the bidding\'94, }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9834330\charrsid9834330 i.e. }{ -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9834330 that first finds the }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9834330\charrsid9834330 bid that is most b}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid7305895 eneficial for the }{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid9834330 own side. }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid409864\charrsid7305895 One example is when both sides can make 1 NT.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10308289\charrsid7305895 -\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af0 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langnp1033\insrsid10308289\charrsid9834330 \hich\af37\dbch\af0\loch\f37 2.\tab}}\pard \ltrpar -\qj \fi-360\li720\ri0\nowidctlpar\wrapdefault\faauto\ls5\rin0\lin720\itap0\pararsid2057006 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10308289\charrsid9834330 The dealer hand is}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10383915 assumed to \'93 -start the bidding\'94.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid15755105\charrsid9834330 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10308289\charrsid9834330 -\par }\pard \ltrpar\qj \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid13331862 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid7804526 The presentation of the par score and contracts are given in 2 alternative formats.}{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid4155951 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6054214 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6573516 The functions Par, }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3352595 SidesPar and DealerPar }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1386919 do the par calculation, their call}{\rtlch\fcs1 -\af1 \ltrch\fcs0 \f37\cf1\insrsid6573516 must be preceded by a function }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1386919 call }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6573516 calculating the double dummy table value}{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid11952575 s}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6573516 .}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12941889 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3352595 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3352595\charrsid3352595 It is also possible as an option to perform par calculation in CalcAllTables and CalcAllTablesPBN. }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3352595 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6573516 -\par The par calculation is }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1386919 executed}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6573516 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9974881 using}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid7305895 a single thread. But }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6573516 the calculation is very fast and }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid4533879 i}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid7305895 t}{ -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid4533879 s }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid7305895 duration is negligible}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6573516 compared to the }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid7763137 double}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6573516 dummy calculation}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid4533879 duration}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6573516 . -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid7959800 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \i\f37\cf1\insrsid13902528 Double Dummy Value}{\rtlch\fcs1 \af1 \ltrch\fcs0 \i\f37\cf1\insrsid7959800\charrsid7959800 Analyser Functions -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid7959800 -\par The functions AnalysePlayBin, AnalysePlayPBN, AnalyseAllPlaysBin and AnalyseAll}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13902528 PlaysPBN take}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid7959800 the played cards in a game }{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid10313626 or games }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid7959800 and calculate and present their double dummy values. -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12941889 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid8154048\charrsid14119459 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1789909\charrsid14119459 -\par \ltrrow}\trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11173409\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2161\clshdrawnil \cellx2053\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3514\clshdrawnil \cellx5567 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1545\clshdrawnil \cellx7112\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2402\clshdrawnil \cellx9514\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid8154048\charrsid14119459 Function\cell Arguments -\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid13267252 Format }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid8154048\charrsid14119459 \cell Comment\cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11173409\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2161\clshdrawnil \cellx2053\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3514\clshdrawnil \cellx5567 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1545\clshdrawnil \cellx7112\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2402\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid14119459\charrsid14119459 REF SolveBoard \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid14119459\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b00000053006f006c007600650042006f0061007200640000000020004912000065000000ff00537400c2009200007c0022000000180099120000000077002200000000007000000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid14119459\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \ab\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 SolveBoard}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\insrsid8154048\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid1789909 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 struct } -{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5767474\charrsid14119459 REF deal \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5767474\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b0200000008000000050000006400650061006c000000ff5700527507000000000000002000fdff1f0000000000000000002500483a000000006b005400000000006100650000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid5767474\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 deal}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\cf1\insrsid8154048\charrsid14119459 }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid16530750 dl,}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 -\par int target, -\par int solutions, -\par int mode, -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid12659025\charrsid14119459 REF futureTricks \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid12659025\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d00000066007500740075007200650054007200690063006b0073000000277d002e75ff0159000000000000000000030000000000000000004300c251000000007a007d00000000006cff6dea00}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid12659025\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 futureTricks}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 *futp, -\par int threadIndex\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid8154048 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid13267252 Binary }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid8154048\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid1789909 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid8154048\charrsid14119459 The mo -st basic function, solves a single hand from the beginning or from later play\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 -\trowd \irow1\irowband1\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11173409\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2161\clshdrawnil \cellx2053\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3514\clshdrawnil \cellx5567 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1545\clshdrawnil \cellx7112\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2402\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid13331862\charrsid13331862 REF SolveBoardPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid13331862\charrsid13331862 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000e00000053006f006c007600650042006f00610072006400500042004e0000000001226d001bc2640000000000610000000000000000000900000000006900003d000041004700001d00690083680000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid13331862\charrsid13331862 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \ab\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 SolveBoardPBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\insrsid8154048\charrsid13331862 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid1789909 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 struct } -{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6968528\charrsid14119459 REF dealPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6968528\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b0200000008000000080000006400650061006c00500042004e0000000061000000ff00400003000000002e02e400ff0000000000002009000000000038000000005c00060000000000000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid6968528\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 dealPBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\cf1\insrsid4616356 dlPBN}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid16530750 ,}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 -\par int target, -\par int solutions, -\par int mode, -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid12659025\charrsid14119459 REF futureTricks \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid12659025\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d00000066007500740075007200650054007200690063006b00730000000000001800b40000c20000000057080000730000000000ff007c0000000200ff00000000005300000000ff0000000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid12659025\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 futureTricks}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 *futp, -\par int threadIndex}{\rtlch\fcs1 \af1\afs18 \ltrch\fcs0 \f37\fs18\cf1\insrsid8154048\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid8154048 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid13267252 PBN}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid8154048\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid16609230 As SolveBoard, but with PBN deal format.}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid8154048\charrsid14119459 \cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow2\irowband2\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11173409\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2161\clshdrawnil \cellx2053\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3514\clshdrawnil \cellx5567 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1545\clshdrawnil \cellx7112\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2402\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid11107656\charrsid11107656 REF CalcDDtable \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid11107656\charrsid11107656 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000c000000430061006c006300440044007400610062006c0065000000007a002e0000006d00030000000000270000b10000000000008400000000000000000000000000000000000000000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid11107656\charrsid11107656 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \ab\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 CalcDDtable}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\insrsid8154048\charrsid11107656 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid5974982 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 struct } -{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid70445\charrsid14119459 REF ddTableDeal \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid70445\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000c000000640064005400610062006c0065004400650061006c0000000000c200001f2018000000400000e10000000000000000000000000000000000000000000000000000ff000000000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid70445\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 ddTableDeal}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 tableDeal, \line struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 REF ddTableResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f000000640064005400610062006c00650052006500730075006c0074007300000000000000002900002027006f006d00000017000000000000000000000000000000000000006f0000000000c700000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 ddTableResults}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 * tablep\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid13267252 Binary }{\rtlch\fcs1 \af1\afs22 -\ltrch\fcs0 \f37\fs22\cf1\insrsid8154048\charrsid14119459 \cell Solves an initial hand for all possible declarers and denominations (}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid16012515 up to }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid8154048\charrsid14119459 20 combinations)\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 -\trowd \irow3\irowband3\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11173409\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2161\clshdrawnil \cellx2053\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3514\clshdrawnil \cellx5567 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1545\clshdrawnil \cellx7112\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2402\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid11107656\charrsid11107656 REF CalcDDtablePBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid11107656\charrsid11107656 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f000000430061006c006300440044007400610062006c006500500042004e00000000700101001900000000000000000000005900000000000000690000000000000000000000000068001e000000000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid11107656\charrsid11107656 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \ab\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 CalcDDtablePBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\insrsid8154048\charrsid11107656 \cell }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid70445\charrsid14119459 REF ddTableDealPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid70445\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f000000640064005400610062006c0065004400650061006c00500042004e00000000680f2000c0c20000000065006300000088000000000000000000000000000000000000000000000000000000000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid70445\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 ddTableDealPBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 \line }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid6968528\charrsid14119459 }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 tableDealPBN, -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid5974982 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 REF ddTableResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f000000640064005400610062006c00650052006500730075006c00740073000000000b00000061006500484300000000007a07000000ff0000000000000000000000000000006900000000000000000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 ddTableResults}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 * tablep\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14307787 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid8154048\charrsid14119459 PBN }{ -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14307787\charrsid14119459 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid8154048 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid8154048\charrsid14119459 \cell }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid16609230 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid16609230\charrsid16609230 As }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid16609230 CalcDDtable}{\rtlch\fcs1 -\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid16609230\charrsid16609230 , but with PBN deal format.}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid8154048\charrsid14119459 \cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow4\irowband4\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11173409\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2161\clshdrawnil \cellx2053\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3514\clshdrawnil \cellx5567 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1545\clshdrawnil \cellx7112\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2402\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid11107656\charrsid11107656 REF CalcAllTables \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid11107656\charrsid11107656 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000e000000430061006c00630041006c006c005400610062006c00650073000000006c0020006b00000000080e005003c400000000000000000000000000ce070000000000000000000000000000000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid11107656\charrsid11107656 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 CalcAllTables}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\insrsid8154048\charrsid11107656 \cell }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 REF ddTableDeals \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d000000640064005400610062006c0065004400650061006c0073000000000000c0739001e5028e030000489300000042000c00006800ea0c000000000010000000000000000000000000110000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 ddTableDeals}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 *dealsp, -\par int mode, -\par int trumpFilter[5], -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 REF ddTablesRes \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000c000000640064005400610062006c00650073005200650073000000002f03b2db0000e09e610011007d00100000000000680000000000000000000000000000000000000000000000500000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 ddTablesRes}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 *resp, -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6701983 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid6701983\charrsid14119459 REF allParResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6701983\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000e00000061006c006c0050006100720052006500730075006c007400730000000873000000c0020000200000008900000000000000903500000000000000000000000000000000000000000008000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid6701983\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 allParResults}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 *presp\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14307787 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid8154048\charrsid14119459 Binary -\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid8154048\charrsid14119459 Solves a number of hands in parallel. Multi-threaded.\cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow5\irowband5\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11173409\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2161\clshdrawnil \cellx2053\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3514\clshdrawnil \cellx5567 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1545\clshdrawnil \cellx7112\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2402\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid11107656\charrsid11107656 REF CalcAllTablesPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid11107656\charrsid11107656 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b020000000800000011000000430061006c00630041006c006c005400610062006c0065007300500042004e000000030000200016fb0000000000000000000020000000000000000000000000000000002580000000000000000000000000}}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\insrsid11107656\charrsid11107656 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 CalcAllTablesPBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid8154048\charrsid11107656 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid8154048 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 -struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 REF ddTableDealsPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b020000000800000010000000640064005400610062006c0065004400650061006c007300500042004e0000000000000000000000006900260b0000000800006000ff0000000007b63c6c000000000000e70000000000000000000000}}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 ddTableDealsPBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 *dealsp, -\par int mode, -\par int trumpFilter[5], }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid70445\charrsid14119459 -\par }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 REF ddTablesRes \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000c000000640064005400610062006c00650073005200650073000000c96f000b00ffff007600001b0b0000680000000000000000000000000000006800000000000000000700006800000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 ddTablesRes}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 *resp, -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6701983 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid6701983\charrsid14119459 REF allParResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6701983\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000e00000061006c006c0050006100720052006500730075006c0074007300000000000080d800004d09000025406f004b020000610000000000002a000080000000000000000000009c00000008690000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid6701983\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 allParResults}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 *presp\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14307787 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid8154048\charrsid14119459 PBN }{ -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14307787\charrsid14119459 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid8154048 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid8154048\charrsid14119459 \cell }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid16609230 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid16609230\charrsid16609230 As }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid16609230 CalcAllTables}{ -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid16609230\charrsid16609230 , but with PBN deal format.}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid8154048\charrsid14119459 \cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow6\irowband6\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11173409\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2161\clshdrawnil \cellx2053\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3514\clshdrawnil \cellx5567 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1545\clshdrawnil \cellx7112\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2402\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid5320216\charrsid5320216 REF SolveAllBoards \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5320216\charrsid5320216 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f00000053006f006c007600650041006c006c0042006f006100720064007300000000000000000e0000000000000000006f0000ff390000008a000000000061000000000000000000002800000000000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid5320216\charrsid5320216 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \ab\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 SolveAllBoards}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\insrsid8154048\charrsid5320216 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid8154048 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 struct } -{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid70445\charrsid14119459 REF boardsPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid70445\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000a00000062006f006100720064007300500042004e00000000000003547800200000009c000000002e00c0e60000000000008f0000004c000000008100d60000a900000000b80000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid70445\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 boardsPBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\cf1\insrsid8154048\charrsid14119459 *bop, -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14429502 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid14429502\charrsid14119459 REF solvedBoards \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid14429502\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d00000073006f006c0076006500640042006f0061007200640073000000004e00610716fb000002000000489300004000e6000000b40000b200000000000000000000680000f000000037101000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid14429502\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 solvedBoards}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 *solvedp\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14307787 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid8154048\charrsid14119459 PBN }{ -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14307787\charrsid14119459 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid8154048 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid8154048\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 { -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid8154048\charrsid14119459 Use SolveAllChunks instead!\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow7\irowband7\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11173409\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2161\clshdrawnil \cellx2053\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3514\clshdrawnil \cellx5567 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1545\clshdrawnil \cellx7112\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2402\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid5320216\charrsid5320216 REF SolveAllChunksBin \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5320216\charrsid5320216 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000001200000053006f006c007600650041006c006c004300680075006e006b007300420069006e000000000000009000006d000000254089009001650000400000000000380000000000000000000000000090000000004000e0}}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5320216\charrsid5320216 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \ab\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 SolveAllChunksBin}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid8154048\charrsid5320216 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid8154048 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 struct -}{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid70445\charrsid14119459 REF boards \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid70445\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000700000062006f00610072006400730000005d0b0000006a0000000000000048096f00740000000000f200002d000000000000000000000000007d00000000000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid70445\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 boards}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\cf1\insrsid8154048\charrsid14119459 *bop, -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14429502 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid14429502\charrsid14119459 REF solvedBoards \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid14429502\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d00000073006f006c0076006500640042006f0061007200640073000000034a00000060000000900100fffb16455a4e00e60000000049003d0000000000009e44000069000000000000000000ba}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid14429502\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 solvedBoards}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 *solvedp, int chunkSize\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14307787 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid8154048\charrsid14119459 Binary }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14307787\charrsid14119459 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid8154048\charrsid14119459 \cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 -Solves a number of hands in parallel. Multi-threaded.}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid8154048\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 -\af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow8\irowband8\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11173409\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2161\clshdrawnil \cellx2053\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3514\clshdrawnil \cellx5567 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1545\clshdrawnil \cellx7112\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2402\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid5320216\charrsid5320216 REF SolveAllChunks \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5320216\charrsid5320216 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f00000053006f006c007600650041006c006c004300680075006e006b0073000000001eff00000000000002000500c40000000003e6006800000000b000000000c848000000000000000000000041000069}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid5320216\charrsid5320216 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \ab\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 SolveAllChunks}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\insrsid8154048\charrsid5320216 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid16151628 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid16151628\charrsid14119459 struct } -{\field\flddirty{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16151628\charrsid14119459 REF boardsPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16151628\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000a00000062006f006100720064007300500042004e000000006f005401c0026800000000020000e401010000006900000000be000000000000ff000000400000ff00000000ff4600}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid16151628\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16151628\charrsid16012515 boardsPBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid16151628\charrsid14119459 *bop, -\par struct }{\field\flddirty{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16151628\charrsid14119459 REF solvedBoards \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16151628\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d00000073006f006c0076006500640042006f006100720064007300000000770000620200650020002400dc00000074000000fe000000680dda6400000000bcff0000690000c900000000000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid16151628\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16151628\charrsid16012515 solvedBoards}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid16151628\charrsid14119459 *solvedp, int chunkSize}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 { -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid16151628 PBN}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid8154048\charrsid14119459 \cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid1716707\charrsid1716707 -Alias for SolveAllChunksPBN; don\rquote t use!}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid8154048\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow9\irowband9\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11173409\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2161\clshdrawnil \cellx2053\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3514\clshdrawnil \cellx5567 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1545\clshdrawnil \cellx7112\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2402\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid5320216\charrsid5320216 REF SolveAllChunksPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5320216\charrsid5320216 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000001200000053006f006c007600650041006c006c004300680075006e006b007300500042004e0000000000c0000000008e005b00cc0000000e000000000000000053008c0000000000000000000000000000a2360000000800}}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5320216\charrsid5320216 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \ab\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 SolveAllChunksPBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid8154048\charrsid5320216 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12657542 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 -struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid70445\charrsid14119459 REF boardsPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid70445\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000a00000062006f006100720064007300500042004e000000006f005401c0026800000000020000e401010000006900000000be000000000000ff001000d6000000c03700e6000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid70445\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 boardsPBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\cf1\insrsid12657542\charrsid14119459 *bop, -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14429502 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid14429502\charrsid14119459 REF solvedBoards \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid14429502\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d00000073006f006c0076006500640042006f006100720064007300000000770000620200650020002400dc00000074000000fe000000680dda6400000000bc0000006800000000000000000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid14429502\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 solvedBoards}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 *solvedp, int chunkSize}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8154048\charrsid14119459 \cell }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14307787 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 PBN }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14307787\charrsid14119459 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 \cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid16151628\charrsid16151628 -Solves a number of hands in parallel. Multi-threaded.}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid8154048\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 -\af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow10\irowband10\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11173409\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2161\clshdrawnil \cellx2053\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3514\clshdrawnil \cellx5567 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1545\clshdrawnil \cellx7112\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2402\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid12658900\charrsid12658900 REF Par \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid12658900\charrsid12658900 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b020000000800000004000000500061007200000000000000526b00b49d00000000000004010056000069001100200d000060000000240000000000000000000000000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid12658900\charrsid12658900 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 Par}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid12657542\charrsid12658900 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12657542 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 struct } -{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 REF ddTableResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f000000640064005400610062006c00650052006500730075006c0074007300000000680f00009001640000002000680020002e000000000000000021aa78000000006d0000009600000000000000000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 ddTableResults}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 *tablep, struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6701983\charrsid14119459 REF parResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid6701983\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b00000070006100720052006500730075006c0074007300000000680f4401e40100e600000000740000000200e600620000000000610000000000030000004e00000000000000ff0000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid6701983\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 parResults}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 *presp, -\par int vulnerable\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14307787 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 No format }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid14307787\charrsid14119459 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12657542 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 \cell }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid10452726 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 Solves for the par contracts given a DD result table. \cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow11\irowband11\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11173409\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2161\clshdrawnil \cellx2053\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3514\clshdrawnil \cellx5567 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1545\clshdrawnil \cellx7112\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2402\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3567911 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid3567911 DealerPar}{ -\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid3567911\charrsid12658900 \cell }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid3567911\charrsid14119459 struct }{\field\flddirty{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid3567911\charrsid14119459 REF ddTableResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid3567911\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f000000640064005400610062006c00650052006500730075006c007400730000000054006500595920003401282000000000840100ffdb2500ff000c00000000000050000000000000001e080000000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid3567911\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid3567911\charrsid16012515 ddTableResults}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid3567911\charrsid14119459 *tablep, -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid13701456 HYPERLINK \\l "parResultsDealer" }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid13701456 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000001100000070006100720052006500730075006c00740073004400650061006c00650072000000006801000069006800f0000000}}}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\cs26\f2\fs18\ul\cf17\insrsid13701456\charrsid13701456 parResultsDealer}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid13701456 }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\cf1\insrsid3567911\charrsid14119459 *presp, -\par int dealer, -\par int vulnerable\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3567911\charrsid14119459 No format -\par \cell Similar to Par(), but requires and use}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3567911 s dealer}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3567911\charrsid14119459 .\cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3567911\charrsid14119459 \trowd \irow12\irowband12\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11173409\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2161\clshdrawnil \cellx2053\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3514\clshdrawnil \cellx5567 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1545\clshdrawnil \cellx7112\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2402\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid348894 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid15939092 SidesPar}{ -\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid348894\charrsid8538722 \cell }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid348894\charrsid14119459 struct }{\field\flddirty{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid348894\charrsid14119459 REF ddTableResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid348894\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f000000640064005400610062006c00650052006500730075006c007400730000000072334400c4006400020000000000e400646c0066db110000380f00008f0f0000940000000000000000000061ff0000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid348894\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid348894\charrsid16012515 ddTableResults}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid348894 -\par *}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid348894\charrsid14119459 tablep, -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid3954019 HYPERLINK \\l "parResultsDealer" }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid3954019 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000001100000070006100720052006500730075006c00740073004400650061006c0065007200000000000000680000f7}}}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \cs26\f2\fs18\ul\cf17\insrsid3954019\charrsid3954019 par -ResultsDealer}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid348894 }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid348894\charrsid14119459 *presp}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\cf1\insrsid348894 , -\par int vulnerable}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid348894\charrsid12595610 }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid348894\charrsid14119459 \cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid13053124\charrsid13053124 No format}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid348894\charrsid14119459 \cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid2769001 -Par results are given for sides with the DealerPar output format.}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid348894\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 { -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid348894\charrsid14119459 \trowd \irow13\irowband13\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv -\brdrs\brdrw10 \trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11173409\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl -\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2161\clshdrawnil \cellx2053\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 -\cltxlrtb\clftsWidth3\clwWidth3514\clshdrawnil \cellx5567\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1545\clshdrawnil \cellx7112\clvertalt\clbrdrt\brdrs\brdrw10 -\clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2402\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\insrsid8538722\charrsid8538722 REF CalcPar \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid8538722\charrsid8538722 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b020000000800000008000000430061006c006300500061007200000000000004000000ba0059000203000000005200e60000000000000000000000006e000000000000000000000000000016}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid8538722\charrsid8538722 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 CalcPar}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid12657542\charrsid8538722 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12657542 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 struct }{\field{\*\fldinst -{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid70445\charrsid14119459 REF ddTableDeal \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid70445\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000c000000640064005400610062006c0065004400650061006c000000002820fa00056a900059006476690027000000e60d00000000000000000000690000000000000000000000690000002b}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid70445\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 ddTableDeal}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 tableDeal, -\par int vulnerable, -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 REF ddTableResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f000000640064005400610062006c00650052006500730075006c00740073000000000b00440061000000e83a00e10e00012054010000620e698600000000ff0000000000007400000000000069000000ec}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid5974982\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 ddTableResults}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid15757396 -\par * }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 tablep, -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6701983 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid6701983\charrsid14119459 REF parResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6701983\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b00000070006100720052006500730075006c007400730000000072000000650000000c016100e40100005c0100000000000000000000ff0000006800000000ff00000400690000005c}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid6701983\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 parResults}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 *presp\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12657542 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14307787 Binary}{\rtlch\fcs1 -\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 -Solves for both the DD result table and the par contracts}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid16609230 . Is deprecated}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3034548 , use a CalcDDtable function plus Par() instead!}{ -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow14\irowband14\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11173409\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2161\clshdrawnil \cellx2053\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3514\clshdrawnil \cellx5567 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1545\clshdrawnil \cellx7112\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2402\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid8538722\charrsid8538722 REF CalcParPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid8538722\charrsid8538722 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b000000430061006c006300500061007200500042004e000000000b000008440000004843650088000259025a0000e4000000000000ff00000000000000000057000000006900000088}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid8538722\charrsid8538722 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 CalcParPBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\insrsid12657542\charrsid8538722 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12657542 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 struct } -{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid70445\charrsid14119459 REF ddTableDealPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid70445\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f000000640064005400610062006c0065004400650061006c00500042004e000000000000000b700100004843630000000059a19200004c00cc000000000000000f00000000000000000035000082ffff53}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid70445\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 ddTableDealPBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid70445\charrsid14119459 -\par }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 tableDealPBN, -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6578564 HYPERLINK \\l "ddTableResults" }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6578564 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f000000640064005400610062006c00650052006500730075006c0074007300000000dc04b000d60e00b1860d00006d0d00}}}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \cs26\f2\fs18\ul\cf17\insrsid6578564\charrsid6578564 -ddTableResults}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid15757396 -\par }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 * tablep, -\par int vulnerable, -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6701983 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid6701983\charrsid14119459 REF parResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6701983\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b00000070006100720052006500730075006c0074007300000000a809b50000006f006c005900647600007c010000300000ff0000000000000000000f00006b1100a600110000691100}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid6701983\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 parResults}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 *presp\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14307787 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 PBN \cell -}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid2769001 As CalcPar, but with PBN input format.}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3034548 }{ -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3034548\charrsid3034548 Is deprecated, use a CalcDDtable function plus Par() instead!}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3034548 }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid12657542\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 -\trowd \irow15\irowband15\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11173409\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2161\clshdrawnil \cellx2053\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3514\clshdrawnil \cellx5567 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1545\clshdrawnil \cellx7112\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2402\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\field\fldedit{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid2849436\charrsid2849436 REF TracePlayBin \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid2849436\charrsid2849436 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d0000005400720061006300650050006c0061007900420069006e00000000000061000000ff590000000000a3720000006172ef0042060000d40000000000000000ad1800000400000000350100}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid2849436\charrsid2849436 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6246771 Analyse}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 PlayBin}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid12657542\charrsid2849436 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12657542 {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6968528\charrsid14119459 REF deal \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid6968528\charrsid14119459 {\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b0200000008000000050000006400650061006c0000000002003a0016fb000054000000fb1618001f00ff000201006c00000000ae190200000e00008200000b00000000b000ac}}{\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6968528\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 deal}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 dl, -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6580905\charrsid14119459 REF playTraceBin \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6580905\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d00000070006c006100790054007200610063006500420069006e0000000072323a206c01e5029a000000fb160000030000000000ff001eff02010000000000120000e700000200000000b10000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid6580905\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 playTraceBin}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid6580905\charrsid14119459 }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid14119459\charrsid14119459 play}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 ,}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid14119459\charrsid14119459 -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid14119459\charrsid14119459 REF solvedPlay \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid14119459\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b00000073006f006c0076006500640050006c006100790000000002f9440000000000e80820080000610000000000ffff0600000e000000000000a1150000883800ff000000004a0068}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid14119459\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 solvedPlay}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid14119459\charrsid14119459 *solvedp,}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 -\par int thrId\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14307787 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 Binary }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid14307787\charrsid14119459 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12657542 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 { -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 Returns the par result after each card in a particular play sequence\cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow16\irowband16\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11173409\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2161\clshdrawnil \cellx2053\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3514\clshdrawnil \cellx5567 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1545\clshdrawnil \cellx7112\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2402\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\field\fldedit{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid2849436\charrsid2849436 REF TracePlayPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid2849436\charrsid2849436 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d0000005400720061006300650050006c0061007900500042004e00000000000000007c01e502640075006ef9b60053447400160006000912d300000fff00cf180000000000ff00000000010000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid2849436\charrsid2849436 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6246771 Analyse}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 PlayPBN}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid12657542\charrsid2849436 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12657542 {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6968528\charrsid14119459 REF dealPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid6968528\charrsid14119459 {\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b0200000008000000080000006400650061006c00500042004e000000c91f20c4007200a800000072f90000ec0173ff00000000001b0000001400000015000000000000690000000000000000}}{ -\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6968528\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 dealPBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj { -\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 dlPBN, -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6580905\charrsid14119459 REF playTracePBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6580905\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d00000070006c006100790054007200610063006500500042004e000000008e033a6559006100030072006100e2031002000039090000d117000000150000bd1e00000000460000000000060000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid6580905\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 playTracePBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 playPBN, -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid14119459\charrsid14119459 REF solvedPlay \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid14119459\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b00000073006f006c0076006500640050006c00610079000000005400447400002000e8f900000700000070000000ed0e00004e19800000170000412100000000000000000000ad2500}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid14119459\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 solvedPlay}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 *solvedp, -\par int thrId\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14307787 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 PBN }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid14307787\charrsid14119459 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12657542 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 \cell }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3034548 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3034548\charrsid3034548 As }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3034548 AnalysePlayBin}{\rtlch\fcs1 -\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3034548\charrsid3034548 , but with PBN deal format.}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 \cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow17\irowband17\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11173409\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2161\clshdrawnil \cellx2053\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3514\clshdrawnil \cellx5567 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1545\clshdrawnil \cellx7112\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2402\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\field\fldedit{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid5979431\charrsid5979431 REF TraceAllPlaysBin \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5979431\charrsid5979431 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b0200000008000000110000005400720061006300650041006c006c0050006c00610079007300420069006e0000000077006de059000000000000ffe401e203542e00003c100000211cb800001a0000ed2500000000000000000000c40162}}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5979431\charrsid5979431 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6246771 Analyse}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 -AllPlaysBin}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid12657542\charrsid5979431 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12657542 {\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid70445\charrsid14119459 REF boards \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid70445\charrsid14119459 {\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000700000062006f0061007200640073000000215900000890013220e82e00000000720013000000a8110000721f0000001d00001b0a000000000000000b0000100000}}{ -\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid70445\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 boards}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj { -\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 *bop, -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6580905\charrsid14119459 REF playTracesBin \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6580905\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000e00000070006c0061007900540072006100630065007300420069006e0000000009002018000000004f000000000000000000b11600002100000004220000ab230000000000000000000000a50000b0}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid6580905\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 playTracesBin}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 *plp, -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6580905\charrsid14119459 REF solvedPlays \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6580905\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000c00000073006f006c0076006500640050006c006100790073000000b40000130000c28ef900007202000002001f005e170000847f0000ff000000380c00002c0000a200000000000000007c}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid6580905\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 solvedPlays}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 *solvedp, -\par int chunkSize\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14307787 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 Binary }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid14307787\charrsid14119459 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12657542 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 { -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 Solves a number of hands with play sequences in parallel. Multi-threaded.\cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow18\irowband18\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11173409\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2161\clshdrawnil \cellx2053\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3514\clshdrawnil \cellx5567 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1545\clshdrawnil \cellx7112\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2402\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\field\fldedit{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid5979431\charrsid5979431 REF TraceAllPlaysPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5979431\charrsid5979431 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b0200000008000000110000005400720061006300650041006c006c0050006c00610079007300500042004e0000000000003a4600000000f0f9005900000008000000009c150000710f8000940e0000001201002a0e0000001200007d0d00}}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5979431\charrsid5979431 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6246771 Analyse}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 -AllPlaysPBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid12657542\charrsid5979431 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12657542 {\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid70445\charrsid14119459 REF boardsPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid70445\charrsid14119459 {\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000a00000062006f006100720064007300500042004e0000000a00002000000002004f001f00000000000059761900009887000061000000fe1100000012000000000000000000007f -}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid70445\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 boardsPBN}}}\sectd \ltrsect -\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 *bopPBN, -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6580905\charrsid14119459 REF playTracesPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6580905\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000e00000070006c0061007900540072006100630065007300500042004e0000000000002000000002006500bc2e01223e0800004f1b0000a2000000000000003d12000000150000000000000000ae00be}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid6580905\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 playTracesPBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 *plpPBN, -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6580905\charrsid14119459 REF solvedPlays \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6580905\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000c00000073006f006c0076006500640050006c006100790073000000b42f0356ff0000730000006d007400b4410000b31c00000000000000000000691400000018000000000000000000001d}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\insrsid6580905\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid16012515\charrsid16012515 solvedPlays}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid12657542\charrsid14119459 *solvedp, -\par int chunkSize\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14307787 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 PBN }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid14307787\charrsid14119459 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12657542 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 \cell }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3034548 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3034548\charrsid3034548 As }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3034548 AnalyseAllPlaysBin}{ -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3034548\charrsid3034548 , but with PBN deal format.}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12657542\charrsid14119459 \cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow19\irowband19\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11173409\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2161\clshdrawnil \cellx2053\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3514\clshdrawnil \cellx5567 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1545\clshdrawnil \cellx7112\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2402\clshdrawnil \cellx9514\row }\pard\plain \ltrpar\s3\ql \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0\pararsid12657542 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11173409 \page }{\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \b\f37\cf1\insrsid12657542 Data structures}{\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid12657542\charrsid12657542 -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid5376200\charrsid14119459 - -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12720965\charrsid14119459 Common encodings are as follows. -\par -\par \ltrrow}\trowd \irow0\irowband0\ltrrow\ts11\trqc\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth3\trwWidth9700\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid9713208\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl -\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1281\clshdrawnil \cellx1173\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 -\cltxlrtb\clftsWidth3\clwWidth1134\clshdrawnil \cellx2307\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth7285\clshdrawnil \cellx9592\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid10239463\charrsid14119459 Encoding\cell Element\cell Value\cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10239463\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trqc\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth3\trwWidth9700\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid9713208\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl -\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1281\clshdrawnil \cellx1173\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 -\cltxlrtb\clftsWidth3\clwWidth1134\clshdrawnil \cellx2307\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth7285\clshdrawnil \cellx9592\row \ltrrow}\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid10239463\charrsid14119459 {\*\bkmkstart suit}Suit{\*\bkmkend suit}\cell }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12720965 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid10239463\charrsid14119459 Spades\tab -\par Hearts \tab -\par Diamonds -\par Clubs \tab -\par NT \tab \cell 0 -\par 1 -\par 2 -\par 3 -\par 4\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10239463\charrsid14119459 \trowd \irow1\irowband1\ltrrow\ts11\trqc\trgaph70\trleft-108\trbrdrt -\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth3\trwWidth9700\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid9713208\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl -\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1281\clshdrawnil \cellx1173\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 -\cltxlrtb\clftsWidth3\clwWidth1134\clshdrawnil \cellx2307\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth7285\clshdrawnil \cellx9592\row \ltrrow}\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid10239463\charrsid14119459 {\*\bkmkstart hand}Hand{\*\bkmkend hand}\cell }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12720965 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid10239463\charrsid14119459 North \tab -\par East \tab -\par South \tab -\par West \tab \cell 0 -\par 1 -\par 2 -\par 3\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10239463\charrsid14119459 \trowd \irow2\irowband2\ltrrow\ts11\trqc\trgaph70\trleft-108\trbrdrt -\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth3\trwWidth9700\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid9713208\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl -\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1281\clshdrawnil \cellx1173\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 -\cltxlrtb\clftsWidth3\clwWidth1134\clshdrawnil \cellx2307\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth7285\clshdrawnil \cellx9592\row \ltrrow}\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid10239463 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid9713208 {\*\bkmkstart vulnerable}Vulnerable}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid9713208\charrsid14119459 {\*\bkmkend vulnerable}\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12720965 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid9713208 None -\par Both -\par NS only -\par EW only}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid9713208\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid9713208 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid9713208\charrsid14119459 0 -\par 1 -\par 2 -\par 3\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9713208\charrsid14119459 \trowd \irow3\irowband3\ltrrow\ts11\trqc\trgaph70\trleft-108\trbrdrt -\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth3\trwWidth9700\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid9713208\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl -\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1281\clshdrawnil \cellx1173\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 -\cltxlrtb\clftsWidth3\clwWidth1134\clshdrawnil \cellx2307\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth7285\clshdrawnil \cellx9592\row \ltrrow}\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid10239463 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14429502\charrsid14119459 {\*\bkmkstart side}Side{\*\bkmkend side}\cell }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12720965 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14429502\charrsid14119459 N-S -\par E-W\cell 0 -\par 1\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow4\irowband4\ltrrow\ts11\trqc\trgaph70\trleft-108\trbrdrt -\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth3\trwWidth9700\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid9713208\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl -\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1281\clshdrawnil \cellx1173\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 -\cltxlrtb\clftsWidth3\clwWidth1134\clshdrawnil \cellx2307\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth7285\clshdrawnil \cellx9592\row \ltrrow}\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid10239463 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid10239463\charrsid14119459 {\*\bkmkstart card}Card{\*\bkmkend card} \cell }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12720965 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid10239463\charrsid14119459 Bit 2\tab -\par \'85 -\par Bit 13\tab -\par Bit 14\tab \cell Rank of deuce -\par -\par Rank of king -\par Rank of ace\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10239463\charrsid14119459 \trowd \irow5\irowband5\ltrrow\ts11\trqc\trgaph70\trleft-108 -\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth3\trwWidth9700\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid9713208\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl -\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1281\clshdrawnil \cellx1173\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 -\cltxlrtb\clftsWidth3\clwWidth1134\clshdrawnil \cellx2307\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth7285\clshdrawnil \cellx9592\row \ltrrow -}\trowd \irow6\irowband6\ltrrow\ts11\trqc\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth3\trwWidth9700\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid9713208\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl -\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1281\clshdrawnil \cellx1173\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 -\cltxlrtb\clftsWidth3\clwWidth8419\clshdrawnil \cellx9592\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid10239463 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid7285964\charrsid14119459 {\*\bkmkstart holding} -Holding\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12720965 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid7285964\charrsid14119459 A value of 16388 = 16384 + 4 is the encoding for the holding \'93A2 -\'94 (ace and deuce)}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid15757396 .}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid7285964 -\par }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid15757396 The two lowest bits are always zero.}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid15757396\charrsid14119459 \cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid7285964\charrsid14119459 \trowd \irow6\irowband6\ltrrow\ts11\trqc\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth3\trwWidth9700\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid9713208\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl -\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1281\clshdrawnil \cellx1173\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 -\cltxlrtb\clftsWidth3\clwWidth8419\clshdrawnil \cellx9592\row \ltrrow}\trowd \irow7\irowband7\lastrow \ltrrow\ts11\trqc\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 -\trbrdrv\brdrs\brdrw10 \trftsWidth3\trwWidth9700\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid9713208\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt -\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1281\clshdrawnil \cellx1173\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 -\cltxlrtb\clftsWidth3\clwWidth1134\clshdrawnil \cellx2307\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth7285\clshdrawnil \cellx9592\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid10239463 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid7285964\charrsid14119459 {\*\bkmkstart PBN}PBN{\*\bkmkend PBN}\cell }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12720965 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid7285964\charrsid14119459 Whole hand\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid6968528\charrsid14119459 Example:}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid7285964\charrsid14119459 -\par }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid6968528\charrsid14119459 W:T5.K4.652.A98542 K6.QJT976.QT7.Q6 432.A.AKJ93.JT73 AQJ987.8532.84.K\cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid7285964\charrsid14119459 \trowd \irow7\irowband7\lastrow \ltrrow\ts11\trqc\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 -\trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth3\trwWidth9700\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid9713208\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl -\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1281\clshdrawnil \cellx1173\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 -\cltxlrtb\clftsWidth3\clwWidth1134\clshdrawnil \cellx2307\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth7285\clshdrawnil \cellx9592\row }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12720965\charrsid14119459 {\*\bkmkend holding} -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12659025\charrsid14119459 -\par \ltrrow}\trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\rtlch\fcs1 \af1\afs22 -\ltrch\fcs0 \b\f37\fs22\cf1\insrsid10576044\charrsid14119459 struct\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid12659025\charrsid14119459 Field}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid10576044\charrsid14119459 -\cell Comment\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10576044\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt -\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\rtlch\fcs1 -\af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid10576044\charrsid14119459 {\*\bkmkstart deal}deal{\*\bkmkend deal}\cell int trump;\cell }{\field{\*\fldinst {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid10239463\charrsid14119459 REF suit \\h }{ -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid10239463\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b020000000800000005000000730075006900740000000046000000ff010000c40000005c005a000060ffff02010000a215000027ff028c00180000004e00002d000000000000}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid10239463\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 Suit}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid10239463\charrsid14119459 encoding}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid10576044\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 { -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10576044\charrsid14119459 \trowd \irow1\irowband1\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv -\brdrs\brdrw10 \trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid10576044\charrsid14119459 \cell int first;\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid10239463\charrsid14119459 The hand leading to the trick. }{\field{\*\fldinst {\rtlch\fcs1 -\af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 REF hand \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b020000000800000005000000680061006e006400000003560000850095000000008e00740000002000ffff02010000ef160000d400ff8cff00000100c8000035000000ff0000}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 Hand}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid10239463\charrsid14119459 encoding}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid10576044\charrsid14119459 -\par \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10576044\charrsid14119459 \trowd \irow2\irowband2\ltrrow\ts11\trgaph70\trleft-108\trbrdrt -\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\rtlch\fcs1 -\af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid10576044\charrsid14119459 \cell int currentTrickSuit[3];\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12659025 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid10576044\charrsid14119459 Up to 3 cards may already have been played to the trick. }{\field{\*\fldinst {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 REF suit \\h }{\rtlch\fcs1 \af1\afs22 -\ltrch\fcs0 \f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 {\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b020000000800000005000000730075006900740000000064760000e401000000004f00000000000108ffff0201000022170000640000cf00ff0000ff0000005f000000000000}}{ -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 Suit}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj { -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12659025\charrsid14119459 encoding.}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid163452 }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid163452\charrsid163452 -Set to 0 if no card has been played.}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid10576044\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid10576044\charrsid14119459 \trowd \irow3\irowband3\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\rtlch\fcs1 -\af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid10576044\charrsid14119459 \cell int currentTrickRank[3];\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12659025 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid12659025\charrsid14119459 Up to 3 cards may already have been played to the trick. }{\field{\*\fldinst {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 REF card \\h }{\rtlch\fcs1 \af1\afs22 -\ltrch\fcs0 \f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 {\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000500000063006100720064000000ff1f00ff55e0fd6f002033000048932400000000ff0601000040180201ff0000ba020000000011000054ffff00000000}}{ -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 Card}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj { -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12659025\charrsid14119459 encoding.}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid163452 }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid163452\charrsid163452 Set to -0 if no card has been played.}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid10576044\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid10576044\charrsid14119459 \trowd \irow4\irowband4\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0 {\rtlch\fcs1 -\af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid10576044\charrsid14119459 \cell unsigned int remainCards[4][4];\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12659025 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid10576044\charrsid14119459 First index is hand}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid15757396 . }{\field\flddirty{\*\fldinst {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid15757396\charrsid14119459 - REF hand \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid15757396\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b020000000800000005000000680061006e006400000000700100db1c00e5002e32280064020000000000ff020100003b00ffff000100a1000100006100ff0002010000000000}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid15757396\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid15757396\charrsid16012515 Hand}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid15757396\charrsid14119459 encoding}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid15757396 . -\par S}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid10576044\charrsid14119459 econd index is suit}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12659025\charrsid14119459 . }{\field\flddirty{\*\fldinst {\rtlch\fcs1 \af1\afs22 -\ltrch\fcs0 \f37\fs22\ul\cf19\insrsid15757396\charrsid14119459 REF suit \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid15757396\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000500000073007500690074000000009709000065002e00000000001000e20300ff00ff020100000000000000ff021bd9000000690000000000000000ff02}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid15757396\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid15757396\charrsid16012515 Suit}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid15757396\charrsid14119459 encoding. }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid10576044\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 { -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10576044\charrsid14119459 \trowd \irow5\irowband5\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 -\trbrdrv\brdrs\brdrw10 \trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 -\clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil -\cellx4820\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 { -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12657542\charrsid14119459 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9713208 \page }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6968528\charrsid14119459 -\par \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid12659025\charrsid14119459 struct\cell Field\cell Comment\cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12659025\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid12659025\charrsid14119459 {\*\bkmkstart dealPBN}dealPBN{\*\bkmkend dealPBN}\cell int trump;\cell }{\field{\*\fldinst {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 REF suit \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b020000000800000005000000730075006900740000000300003a7030fb5bc002002000a0000e00002effff02040000000100000000029f900000007f090200ffff0201000000}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 Suit}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid12659025\charrsid14119459 encoding\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12659025\charrsid14119459 -\trowd \irow1\irowband1\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid12659025\charrsid14119459 \cell int first;\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12659025\charrsid14119459 The hand leading to the trick. }{\field{\*\fldinst {\rtlch\fcs1 -\af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 REF hand \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b020000000800000005000000680061006e0064000000002e00000004020222bc00ff00e40061006000ff00020e00f002ff00000200ff01c308000d110f0000000000000000ff}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 Hand}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid9713208 encoding}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12659025\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid12659025\charrsid14119459 \trowd \irow2\irowband2\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid12659025\charrsid14119459 \cell int currentTrickSuit[3];\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12659025\charrsid14119459 -Up to 3 cards may already have been played to the trick. }{\field{\*\fldinst {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 REF suit \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 {\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000500000073007500690074000000c2000000dd27006f00eb080000020864002700ff00020f0000ff006001ff0000ff490f0000001000000000ffff000100}}{\rtlch\fcs1 -\af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 Suit}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 -\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12659025\charrsid14119459 encoding.\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid12659025\charrsid14119459 \trowd \irow3\irowband3\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid12659025\charrsid14119459 \cell int currentTrickRank[3];\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12659025\charrsid14119459 -Up to 3 cards may already have been played to the trick. }{\field{\*\fldinst {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 REF card \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 {\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000500000063006100720064000000007300007372000072000000c6fb160000bb08000006100000000001ffdafe00007c10000100110080d6000000c10b00}}{\rtlch\fcs1 -\af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 Card}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 -\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12659025\charrsid14119459 encoding.\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid12659025\charrsid14119459 \trowd \irow4\irowband4\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid12659025\charrsid14119459 \cell char remainCards[80];\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12659025\charrsid14119459 Remaining cards. }{\field{\*\fldinst {\rtlch\fcs1 -\af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid6968528\charrsid14119459 REF PBN \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid6968528\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b020000000800000004000000500042004e000000c970000064720003002e0020760027840200000000ff00027f000000000000020000003c000000b8080000000000005a}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid6968528\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 PBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid12659025\charrsid14119459 encoding.\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12659025\charrsid14119459 -\trowd \irow5\irowband5\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid12659025\charrsid14119459 -\par \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid70445\charrsid14119459 struct\cell Field\cell Comment\cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid70445\charrsid14119459 {\*\bkmkstart ddTableDeal}ddTableDeal{\*\bkmkend ddTableDeal}\cell unsigned int cards[4][4];\cell }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid15757396 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid70445\charrsid14119459 Encodes a deal. }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid15757396\charrsid14119459 First index is hand}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid15757396 . }{\field\flddirty{\*\fldinst {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid15757396\charrsid14119459 - REF hand \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid15757396\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b020000000800000005000000680061006e0064000000005c096a0000f900004400000000006f00727600000212000000ff00009c000200161302000d140000d1000000f20f00}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid15757396\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid15757396\charrsid16012515 Hand}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid15757396\charrsid14119459 encoding}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid15757396 . S}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid15757396\charrsid14119459 econd index is suit. } -{\field\flddirty{\*\fldinst {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid15757396\charrsid14119459 REF suit \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid15757396\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000500000073007500690074000000c27400000024026f00000000000b004600730800000214000000000000ea00ff01431900ff651500005b000000a61100}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid15757396\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid15757396\charrsid16012515 Suit}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid15757396\charrsid14119459 encoding. }{\field\fldedit{\*\fldinst {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid70445\charrsid14119459 REF holding \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid70445\charrsid14119459 {\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000800000068006f006c00640069006e0067000000002d0000ff0000b49d59002e0000000000000000140000ff1200010000000000000000ff0100009911000000000000c6}}{ -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid70445\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt }}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid70445\charrsid15757396 \cell -}\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow1\irowband1\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt -\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid70445\charrsid14119459 -\par \ltrrow}\trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1897\clshdrawnil \cellx1789\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3031\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4694\clshdrawnil \cellx9514\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 -\af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid70445\charrsid14119459 struct\cell Field\cell Comment\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1897\clshdrawnil \cellx1789\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3031\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4694\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid70445\charrsid14119459 {\*\bkmkstart ddTableDealPBN}ddTableDealPBN{\*\bkmkend ddTableDealPBN}\cell char cards[80];\cell }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid15757396 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid70445\charrsid14119459 Encodes a deal. }{\field{\*\fldinst {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid70445\charrsid14119459 REF PBN \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid70445\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b020000000800000004000000500042004e000000c96500410000006100d00246006100000000008a160000ff1400010000000002ff000000000000f1120000000100001a}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid70445\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 PBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid70445\charrsid14119459 encoding.\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 -\trowd \irow1\irowband1\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1897\clshdrawnil \cellx1789\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3031\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4694\clshdrawnil \cellx9514\row }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid70445\charrsid14119459 -\par \ltrrow}\trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 -\af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid70445\charrsid14119459 struct\cell Field\cell Comment\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid70445\charrsid14119459 {\*\bkmkstart ddTableDeals}ddTableDeals{\*\bkmkend ddTableDeals}\cell int noOfTables;\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid70445\charrsid14119459 -Number of DD table deals in structure\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow1\irowband1\ltrrow -\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid70445\charrsid14119459 \cell struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid70445\charrsid14119459 REF ddTableDeal \\h }{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\ul\cf19\insrsid70445\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000c000000640064005400610062006c0065004400650061006c000000c900002700000020cc00006500007200f9000061180000a7170000021200000000000000ff00001a1300000001000084}}{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\ul\cf19\insrsid70445\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid16012515\charrsid16012515 ddTableDeal}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs20 -\ltrch\fcs0 \f2\fs20\cf1\insrsid70445\charrsid14119459 -\par deals[MAXNOOFBOARDS/4];\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid70445\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow2\irowband2\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid70445\charrsid14119459 -\par \ltrrow}\trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2017\clshdrawnil \cellx1909\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2977\clshdrawnil \cellx4886\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4628\clshdrawnil \cellx9514\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 -\af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid70445\charrsid14119459 struct\cell Field\cell Comment\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2017\clshdrawnil \cellx1909\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2977\clshdrawnil \cellx4886\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4628\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid70445\charrsid14119459 {\*\bkmkstart ddTableDealsPBN}ddTableDealsPBN{\*\bkmkend ddTableDealsPBN}\cell int noOfTables;\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid70445\charrsid14119459 Number of DD table deals in structure\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow1\irowband1\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2017\clshdrawnil \cellx1909\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2977\clshdrawnil \cellx4886\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4628\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid70445\charrsid14119459 \cell }{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid2493172 s}{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid70445\charrsid14119459 truct } -{\field{\*\fldinst {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid70445\charrsid14119459 REF ddTableDealPBN \\h }{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid70445\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f000000640064005400610062006c0065004400650061006c00500042004e0000007c6100b5003c08003e000000001f00000000000000000000000000020000000000000000000000000087260000df1700}}{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\ul\cf19\insrsid70445\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid16012515\charrsid16012515 ddTableDealPBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs20 -\ltrch\fcs0 \f2\fs20\cf1\insrsid70445\charrsid14119459 -\par deals[MAXNOOFBOARDS/4];\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid70445\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow2\irowband2\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2017\clshdrawnil \cellx1909\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2977\clshdrawnil \cellx4886\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4628\clshdrawnil \cellx9514\row }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid70445\charrsid14119459 -\par \ltrrow}\trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 {\rtlch\fcs1 -\af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid6968528\charrsid14119459 struct\cell Field\cell Comment\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid6968528\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid6968528\charrsid14119459 {\*\bkmkstart boards}boards{\*\bkmkend boards}\cell int noOfBoards;\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid6968528\charrsid14119459 Number of boards -\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6968528\charrsid14119459 \trowd \irow1\irowband1\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 -\trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid6968528\charrsid14119459 \cell struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid6968528\charrsid14119459 REF deal \\h }{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\ul\cf19\insrsid6968528\charrsid14119459 {\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b0200000008000000050000006400650061006c000000006476000016fb0000000000ff1000610050ff0000000100000000000000000000ff0000ff0000680006ff0000000000}}{\rtlch\fcs1 -\af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid6968528\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid16012515\charrsid16012515 deal}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 -\af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid6968528\charrsid14119459 [MAXNOOFBOARDS];\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid6968528\charrsid14119459 \cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6968528\charrsid14119459 \trowd \irow2\irowband2\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid6968528\charrsid14119459 \cell int target[MAXNOOFBOARDS];\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid6968528\charrsid14119459 See }{\field{\*\fldinst {\rtlch\fcs1 \af1\afs22 -\ltrch\fcs0 \f37\fs22\ul\cf19\insrsid6968528\charrsid14119459 REF SolveBoard \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid6968528\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b00000053006f006c007600650042006f0061007200640000006c2000000000000000000001006d07000b00000000000000000000000000000000000f0000e600000000030000ff0000}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid6968528\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 SolveBoard}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 -\ltrch\fcs0 \f37\fs22\cf1\insrsid6968528\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6968528\charrsid14119459 -\trowd \irow3\irowband3\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid6968528\charrsid14119459 \cell int solutions[MAXNOOFBOARDS];\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid6968528\charrsid14119459 See }{\field{\*\fldinst {\rtlch\fcs1 \af1\afs22 -\ltrch\fcs0 \f37\fs22\ul\cf19\insrsid6968528\charrsid14119459 REF SolveBoard \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid6968528\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b00000053006f006c007600650042006f00610072006400000000000044006b0000000200bb020b0000fffc02000000ff000100000200ffff000106120201a6ff020000ff00000000ff}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid6968528\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 SolveBoard}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 -\ltrch\fcs0 \f37\fs22\cf1\insrsid6968528\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6968528\charrsid14119459 -\trowd \irow4\irowband4\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid6968528\charrsid14119459 \cell int mode[MAXNOOFBOARDS];\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid6968528\charrsid14119459 See }{\field{\*\fldinst {\rtlch\fcs1 \af1\afs22 -\ltrch\fcs0 \f37\fs22\ul\cf19\insrsid6968528\charrsid14119459 REF SolveBoard \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid6968528\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b00000053006f006c007600650042006f00610072006400000000000000000700ff08006c000000f96900a192000000000000aa0000000000000000150000f6010000008400000000ff}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid6968528\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 SolveBoard}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 -\ltrch\fcs0 \f37\fs22\cf1\insrsid6968528\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6968528\charrsid14119459 -\trowd \irow5\irowband5\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid6968528\charrsid14119459 -\par \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid6968528\charrsid14119459 struct\cell Field\cell Comment\cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6968528\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid6968528\charrsid14119459 {\*\bkmkstart boardsPBN}boardsPBN{\*\bkmkend boardsPBN}\cell int noOfBoards;\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid6968528\charrsid14119459 -Number of boards\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6968528\charrsid14119459 \trowd \irow1\irowband1\ltrrow\ts11\trgaph70\trleft-108 -\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid6968528\charrsid14119459 \cell struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid6968528\charrsid14119459 REF dealPBN \\h }{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\ul\cf19\insrsid6968528\charrsid14119459 {\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b0200000008000000080000006400650061006c00500042004e0000006c000047000000740200c0c40000ff070000007a1300009500000052110201b00000000b000000ff0000000600020000}}{ -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid6968528\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid16012515\charrsid16012515 dealPBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid6968528\charrsid14119459 [MAXNOOFBOARDS];\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid6968528\charrsid14119459 \cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6968528\charrsid14119459 \trowd \irow2\irowband2\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid6968528\charrsid14119459 \cell int target[MAXNOOFBOARDS];\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid6968528\charrsid14119459 See }{\field{\*\fldinst {\rtlch\fcs1 \af1\afs22 -\ltrch\fcs0 \f37\fs22\ul\cf19\insrsid6968528\charrsid14119459 REF SolveBoard \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid6968528\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b00000053006f006c007600650042006f0061007200640000004b7c020000c400640000000000a80901208845000000ff0001001600000000000000170000d001020000feff00ff0006}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid6968528\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 SolveBoard}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 -\ltrch\fcs0 \f37\fs22\cf1\insrsid6968528\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6968528\charrsid14119459 -\trowd \irow3\irowband3\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid6968528\charrsid14119459 \cell int solutions[MAXNOOFBOARDS];\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid6968528\charrsid14119459 See }{\field{\*\fldinst {\rtlch\fcs1 \af1\afs22 -\ltrch\fcs0 \f37\fs22\ul\cf19\insrsid6968528\charrsid14119459 REF SolveBoard \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid6968528\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b00000053006f006c007600650042006f00610072006400000000680f28004b000059600000ff370600ca56000000ff000000b2fe00ff000000ffff1c0100780000000c000200ff0802}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid6968528\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 SolveBoard}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 -\ltrch\fcs0 \f37\fs22\cf1\insrsid6968528\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6968528\charrsid14119459 -\trowd \irow4\irowband4\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid6968528\charrsid14119459 \cell int mode[MAXNOOFBOARDS];\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid6968528\charrsid14119459 See }{\field{\*\fldinst {\rtlch\fcs1 \af1\afs22 -\ltrch\fcs0 \f37\fs22\ul\cf19\insrsid6968528\charrsid14119459 REF SolveBoard \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid6968528\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b00000053006f006c007600650042006f00610072006400000000683968001a006100484300006900000007000000000100006800613f060100000022000154000000dc000000ff0002}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid6968528\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 SolveBoard}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 -\ltrch\fcs0 \f37\fs22\cf1\insrsid6968528\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6968528\charrsid14119459 -\trowd \irow5\irowband5\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid6968528\charrsid14119459 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid5974982\charrsid14119459 \page }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6968528\charrsid14119459 -\par \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid12720965\charrsid14119459 struct\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\b\f37\fs22\cf1\insrsid12659025\charrsid14119459 Field}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid12720965\charrsid14119459 \cell Comment\cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12720965\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid12720965\charrsid14119459 {\*\bkmkstart futureTricks}futureTricks{\*\bkmkend futureTricks}\cell int nodes;\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12720965\charrsid14119459 -Number of nodes searched by the DD solver\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12720965\charrsid14119459 \trowd \irow1\irowband1\ltrrow -\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid12720965\charrsid14119459 \cell int cards;\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12720965\charrsid14119459 Number of cards for which a result is returned}{\rtlch\fcs1 -\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12659025\charrsid14119459 . May be all the cards, but equivalent ranks are omitted, so for a holding of KQ76 only the cards K and 7 would be returned, and the \'93equals\'94 - field below would be 2048 (Q) for the king and 54 (6) for the 7.}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12720965\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 -{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12720965\charrsid14119459 \trowd \irow2\irowband2\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv -\brdrs\brdrw10 \trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid12720965\charrsid14119459 \cell int suit[13];\cell }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12659025 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12659025\charrsid14119459 Suit of the each returned card. }{\field{\*\fldinst {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 REF suit \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b020000000800000005000000730075006900740000005ac40074002d00ff204b0876000000000029ff0000ff00000068006100000000000000010000000080510000ff0000ff}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 Suit}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid12659025\charrsid14119459 encoding}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12720965\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 { -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12720965\charrsid14119459 \trowd \irow3\irowband3\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv -\brdrs\brdrw10 \trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid12659025\charrsid14119459 \cell int rank[13];\cell }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12659025 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12659025\charrsid14119459 Rank of the returned card. }{\field{\*\fldinst {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 REF card \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b0200000008000000050000006300610072006400000059100000005a080000420800004893b6004ef9610000000000000000000201000000fffc0002010200b5ff0000060000}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 Card}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid12659025\charrsid14119459 encoding\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12659025\charrsid14119459 -\trowd \irow4\irowband4\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid12659025\charrsid14119459 \cell int equals[13];\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12659025 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid12659025\charrsid14119459 Lower-ranked equals. }{\field\fldedit{\*\fldinst {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 REF holding \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 {\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000800000068006f006c00640069006e00670000000000ff00000000730000004300000807000000481a0001000069006100290aff6e000100000000000e00ff0000000000}}{ -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid12659025\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt }}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12659025\charrsid14119459 } -{\field\flddirty{\*\fldinst {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid15757396\charrsid14119459 REF PBN \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid15757396\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b020000000800000004000000500042004e000000087a006505000020000000000000a7b4410000001b00c000400000002e2900006e00ff010000ffff0f00000200000000}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid15757396\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid15757396\charrsid16012515 PBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid15757396\charrsid14119459 encoding.}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid12659025\charrsid15757396 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 { -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12659025\charrsid14119459 \trowd \irow5\irowband5\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv -\brdrs\brdrw10 \trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row \ltrrow}\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6968528 {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid12659025\charrsid14119459 \cell int score[13];\cell }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12659025 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid12659025\charrsid14119459 -1: target not reached. -\par Otherwise: Target of maximum number of tricks.\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12659025\charrsid14119459 -\trowd \irow6\irowband6\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4618\clshdrawnil \cellx9438\row }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid5767474\charrsid14119459 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14429502\charrsid14119459 -\par \ltrrow}\trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4694\clshdrawnil \cellx9514\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 -\af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid14429502\charrsid14119459 struct\cell Field\cell Comment\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4694\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid14429502\charrsid14119459 {\*\bkmkstart solvedBoards}solvedBoards{\*\bkmkend solvedBoards}\cell int noOfBoards;\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid14429502\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow1\irowband1\ltrrow -\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4694\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid14429502\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14429502 {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\cf1\insrsid14429502\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid14429502\charrsid14119459 REF futureTricks \\h }{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\ul\cf19\insrsid14429502\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d00000066007500740075007200650054007200690063006b00730000000300000000b40000c0c40000002c03e2036900000000ff000109010000400000090000000000000000a4110000061100}}{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\ul\cf19\insrsid14429502\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid16012515\charrsid16012515 futureTricks}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs20 -\ltrch\fcs0 \f2\fs20\cf1\insrsid14429502\charrsid14119459 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid12065713 solvedBoard}{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid12065713\charrsid14119459 }{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\cf1\insrsid14429502\charrsid14119459 [MAXNOOFBOARDS];\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14429502\charrsid14119459 \cell -}\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow2\irowband2\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt -\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4694\clshdrawnil \cellx9514\row }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid14429502\charrsid14119459 -\par -\par \ltrrow}\trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1897\clshdrawnil \cellx1789\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3031\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4694\clshdrawnil \cellx9514\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 -\af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid14429502\charrsid14119459 S}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid5974982\charrsid14119459 truct\cell Field\cell Comment\cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1897\clshdrawnil \cellx1789\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3031\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4694\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid5974982\charrsid14119459 {\*\bkmkstart ddTableResults}ddTableResults{\*\bkmkend ddTableResults}\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid5974982 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid5974982\charrsid14119459 int resTable[5][4];\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid5974982\charrsid14119459 -Encodes the solution of a deal for combinations of denomination and declarer. First index is denomination. }{\field{\*\fldinst {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid5974982\charrsid14119459 REF suit \\h }{\rtlch\fcs1 \af1\afs22 -\ltrch\fcs0 \f37\fs22\ul\cf19\insrsid5974982\charrsid14119459 {\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b0200000008000000050000007300750069007400000003000100000284610000006f203403e2030a00000000600000e7ffb244ae00ff0600010100ff00ff005a170000001700}}{ -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid5974982\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 Suit}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj { -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid5974982\charrsid14119459 encoding. Second index is declarer. }{\field{\*\fldinst {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid5974982\charrsid14119459 REF hand \\h }{\rtlch\fcs1 -\af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid5974982\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b020000000800000005000000680061006e006400000000005c6f000200610000004600000000000001000000ffff013e0000e900000000000000b50001000002000200ff0000}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid5974982\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 Hand}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid5974982\charrsid14119459 encoding. Each entry is a number of tricks.\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow1\irowband1\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1897\clshdrawnil \cellx1789\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3031\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4694\clshdrawnil \cellx9514\row }\pard\plain \ltrpar -\s3\ql \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0\pararsid6968528 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid5974982\charrsid14119459 -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid5974982 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\insrsid5974982\charrsid5974982 -\par \ltrrow}\trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4694\clshdrawnil \cellx9514\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 -\af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid5974982\charrsid14119459 struct\cell Field\cell Comment\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4694\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid5974982\charrsid14119459 {\*\bkmkstart ddTablesRes}ddTablesRes{\*\bkmkend ddTablesRes}\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid5974982 {\rtlch\fcs1 -\af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid5974982\charrsid14119459 int noOfBoards;\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid5974982\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow1\irowband1\ltrrow -\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4694\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid5974982\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid5974982 {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\cf1\insrsid5974982\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid5974982\charrsid14119459 REF ddTableResults \\h }{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\ul\cf19\insrsid5974982\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f000000640064005400610062006c00650052006500730075006c00740073000000000000c6000000ff00484300000500740002000000000000001800e43ab4000000000002000600020000013c00000000}}{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\ul\cf19\insrsid5974982\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid16012515\charrsid16012515 ddTableResults}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs20 -\ltrch\fcs0 \f2\fs20\cf1\insrsid5974982\charrsid14119459 results[MAXNOOFBOARDS/4];\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid5974982\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 -\trowd \irow2\irowband2\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1668\clshdrawnil \cellx1560\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4820\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4694\clshdrawnil \cellx9514\row }\pard\plain \ltrpar -\s3\ql \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0\pararsid6968528 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid14429502\charrsid14119459 -\par -\par -\par \page -\par \ltrrow}\trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1663\clshdrawnil \cellx1555\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4115\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 -\rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid14429502\charrsid14119459 struct\cell Field\cell Comment\cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1663\clshdrawnil \cellx1555\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4115\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid14429502\charrsid14119459 {\*\bkmkstart parResults}parResults{\*\bkmkend parResults}\cell char parScore[2][16];\cell }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14429502 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14429502\charrsid14119459 First index is NS/EW. }{\field{\*\fldinst {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid14429502\charrsid14119459 REF side \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid14429502\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b020000000800000005000000730069006400650000000000f900000c040000f500000000000000000000ff0000000013ff0400001100000000000006000200001d0100020000}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid14429502\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 Side}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid14429502\charrsid14119459 encoding.\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 -\trowd \irow1\irowband1\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1663\clshdrawnil \cellx1555\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4115\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid14429502\charrsid14119459 \cell char parContractsString[2][128];\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14429502\charrsid14119459 First index is NS/EW. }{\field{\*\fldinst { -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid14429502\charrsid14119459 REF side \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid14429502\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b0200000008000000050000007300690064006500000000002e0055bc020000ec004f001f000000740000ff000000009400000061160000ff01ff0000000000ff240000000000}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid14429502\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 Side}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid14429502\charrsid14119459 encoding.\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 -\trowd \irow2\irowband2\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1663\clshdrawnil \cellx1555\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4115\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row }\pard\plain \ltrpar -\s3\ql \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0\pararsid6968528 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid14429502\charrsid14119459 -\par -\par \ltrrow}\trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1777\clshdrawnil \cellx1669\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4001\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 -\rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid14429502\charrsid14119459 struct\cell Field\cell Comment\cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1777\clshdrawnil \cellx1669\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4001\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid14429502\charrsid14119459 {\*\bkmkstart allParResults}allParResults{\*\bkmkend allParResults}\cell struct parResults[MAXNOOFBOARDS/20];\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid14429502\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 -\trowd \irow1\irowband1\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1777\clshdrawnil \cellx1669\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4001\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row }\pard\plain \ltrpar -\s3\ql \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0\pararsid6968528 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid750270\charrsid14119459 -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid750270 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\insrsid750270\charrsid750270 -\par \ltrrow}\trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1663\clshdrawnil \cellx2029\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4115\clshdrawnil \cellx5960 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid750270\charrsid14119459 {\*\bkmkstart parResultsDealer}struct\cell Field\cell Comment\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 { -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv -\brdrs\brdrw10 \trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl -\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1663\clshdrawnil \cellx2029\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 -\cltxlrtb\clftsWidth3\clwWidth4115\clshdrawnil \cellx5960\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid5594575\charrsid9515364 {\*\bkmkend parResultsDealer}parResultsDealer}{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\cf1\insrsid750270\charrsid14119459 \cell int number;\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid750270\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 -{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow1\irowband1\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv -\brdrs\brdrw10 \trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl -\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1663\clshdrawnil \cellx2029\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 -\cltxlrtb\clftsWidth3\clwWidth4115\clshdrawnil \cellx5960\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid750270\charrsid14119459 \cell int score;\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid750270\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow2\irowband2\ltrrow -\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1663\clshdrawnil \cellx2029\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4115\clshdrawnil \cellx5960 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid750270\charrsid14119459 \cell }{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid15757396 c}{\rtlch\fcs1 \af2\afs20 -\ltrch\fcs0 \f2\fs20\cf1\insrsid750270\charrsid14119459 har contracts[10][10];\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid750270\charrsid14119459 \cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow3\irowband3\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1663\clshdrawnil \cellx2029\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4115\clshdrawnil \cellx5960 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row }\pard\plain \ltrpar -\s3\ql \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0\pararsid6968528 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \insrsid750270 -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid16323149 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\insrsid16323149\charrsid16323149 -\par \ltrrow}\trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1663\clshdrawnil \cellx1555\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4115\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 -\af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid750270\charrsid14119459 struct\cell Field\cell Comment\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1663\clshdrawnil \cellx1555\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4115\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid750270\charrsid14119459 {\*\bkmkstart playTraceBin}playTraceBin{\*\bkmkend playTraceBin}\cell int number;\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid750270\charrsid14119459 -Number of cards in the play trace, starting from the beginning of the hand\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 -\trowd \irow1\irowband1\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1663\clshdrawnil \cellx1555\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4115\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid750270\charrsid14119459 \cell int suit[52];\cell }{\field{\*\fldinst {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid750270\charrsid14119459 REF suit \\h }{\rtlch\fcs1 \af1\afs22 -\ltrch\fcs0 \f37\fs22\ul\cf19\insrsid750270\charrsid14119459 {\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b0200000008000000050000007300750069007400000020000300db00956f000000000048930000000000ffc718b50013006100e21d0000b8d200007a0300000025cc00d31000}}{ -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid750270\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 Suit}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj { -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid750270\charrsid14119459 encoding.\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow2\irowband2\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1663\clshdrawnil \cellx1555\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4115\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid750270\charrsid14119459 \cell int rank[52];\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid750270 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid750270\charrsid14119459 Encoding 2 .. 14 (}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \i\f37\fs22\cf1\insrsid750270\charrsid14119459 not}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid750270\charrsid14119459 }{\field{\*\fldinst { -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid750270\charrsid14119459 REF card \\h }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid750270\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b020000000800000005000000630061007200640000000000f90000f402e5026c0000ff6c030800000000ff2f1b00009501000000230000b8d20201c4000000001000002d1700}}{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\ul\cf19\insrsid750270\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\ul\cf19\insrsid16012515\charrsid16012515 Card}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid750270\charrsid14119459 encoding).\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 -\trowd \irow3\irowband3\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1663\clshdrawnil \cellx1555\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4115\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row }\pard\plain \ltrpar -\s3\ql \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0\pararsid6968528 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid750270\charrsid14119459 -\par -\par \ltrrow}\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\b\f37\fs22\cf1\insrsid750270\charrsid14119459 struct\cell Field\cell Comment\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 -\trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1663\clshdrawnil \cellx1555\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4115\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid750270\charrsid14119459 {\*\bkmkstart playTracePBN}playTracePBN{\*\bkmkend playTracePBN}\cell int number;\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid750270\charrsid14119459 -Number of cards in the play trace, starting from the beginning of the hand\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 -\trowd \irow1\irowband1\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1663\clshdrawnil \cellx1555\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4115\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid750270\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid750270 {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid750270\charrsid14119459 -int cards[106];\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid750270\charrsid14119459 -String of cards with no space in between, also not between tricks. Each card consists of a suit (C/D/H/S) and then a rank (2 .. A). }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid6580905\charrsid14119459 The string must be null-terminated.}{ -\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid750270\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow2\irowband2\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1663\clshdrawnil \cellx1555\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4115\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row }\pard\plain \ltrpar -\s3\ql \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0\pararsid6968528 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid6580905\charrsid14119459 -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid6580905 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \insrsid6580905 -\par \ltrrow}\trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1777\clshdrawnil \cellx1669\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4001\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 -\af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid6580905\charrsid14119459 struct\cell Field\cell Comment\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1777\clshdrawnil \cellx1669\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4001\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid6580905\charrsid14119459 {\*\bkmkstart playTracesBin}playTracesBin{\*\bkmkend playTracesBin}\cell int noOfBoards;\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid6580905\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow1\irowband1\ltrrow -\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1777\clshdrawnil \cellx1669\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4001\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid6580905\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6580905 {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\cf1\insrsid6580905\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid6580905\charrsid14119459 REF playTraceBin \\h }{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\ul\cf19\insrsid6580905\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d00000070006c006100790054007200610063006500420069006e0000000000036131fc02e502006c000048930000c4000000eb2000006800000000280000000100001800000000170000231e00}}{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\ul\cf19\insrsid6580905\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid16012515\charrsid16012515 playTraceBin}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs20 -\ltrch\fcs0 \f2\fs20\cf1\insrsid6580905\charrsid14119459 plays[MAXNOOFBOARDS / 10];\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid6580905\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 -\trowd \irow2\irowband2\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1777\clshdrawnil \cellx1669\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4001\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid6580905 { -\rtlch\fcs1 \af1 \ltrch\fcs0 \insrsid6580905 -\par -\par \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid6580905\charrsid14119459 struct\cell Field\cell Comment\cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1777\clshdrawnil \cellx1669\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4001\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid6580905\charrsid14119459 {\*\bkmkstart playTracesPBN}playTracesPBN{\*\bkmkend playTracesPBN}\cell int noOfBoards;\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid6580905\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow1\irowband1\ltrrow -\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1777\clshdrawnil \cellx1669\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4001\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid6580905\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6580905 {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\cf1\insrsid6580905\charrsid14119459 Struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid6580905\charrsid14119459 REF playTracePBN \\h }{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\ul\cf19\insrsid6580905\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d00000070006c006100790054007200610063006500500042004e000000c2200000580403e502c4004f00600000000000000095250100afff0000002b000038000000a9690000001e00ff542400}}{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\ul\cf19\insrsid6580905\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid16012515\charrsid16012515 playTracePBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs20 -\ltrch\fcs0 \f2\fs20\cf1\insrsid6580905\charrsid14119459 plays[MAXNOOFBOARDS / 10];\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid6580905\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 -\trowd \irow2\irowband2\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1777\clshdrawnil \cellx1669\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4001\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid6580905 { -\rtlch\fcs1 \af1 \ltrch\fcs0 \insrsid6580905\charrsid6580905 -\par }\pard\plain \ltrpar\s3\ql \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0\pararsid6968528 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid6580905 -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid16323149 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\insrsid16323149\charrsid16323149 -\par \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid6580905\charrsid14119459 struct\cell Field\cell Comment\cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1777\clshdrawnil \cellx1669\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4001\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid6580905\charrsid14119459 {\*\bkmkstart solvedPlay}solvedPlay{\*\bkmkend solvedPlay}\cell int number;\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid6580905\charrsid14119459 \cell -}\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow1\irowband1\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 -\trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1777\clshdrawnil \cellx1669\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4001\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid6580905\charrsid14119459 \cell int tricks[53];\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid6580905\charrsid14119459 \cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow2\irowband2\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1777\clshdrawnil \cellx1669\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4001\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid6580905 { -\rtlch\fcs1 \af1 \ltrch\fcs0 \insrsid6580905 -\par -\par \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid6580905\charrsid14119459 struct\cell Field\cell Comment\cell }\pard \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1777\clshdrawnil \cellx1669\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4001\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid6580905\charrsid14119459 {\*\bkmkstart solvedPlays}solvedPlays{\*\bkmkend solvedPlays}\cell int noOfBoards;\cell }{\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid6580905\charrsid14119459 -\cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow1\irowband1\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 -\trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1777\clshdrawnil \cellx1669\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4001\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row \ltrrow}\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 { -\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\cf1\insrsid6580905\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6580905 {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\cf1\insrsid6580905\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid6580905\charrsid14119459 REF solvedPlay \\h }{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\ul\cf19\insrsid6580905\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b00000073006f006c0076006500640050006c0061007900000000bc020073c4006400104300002400720000000000021000ffaeff0000021100000000000000000000ff000000001e00}}{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\ul\cf19\insrsid6580905\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid16012515\charrsid16012515 solvedPlay}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs20 -\ltrch\fcs0 \f2\fs20\cf1\insrsid6580905\charrsid14119459 solved[MAXNOOFBOARDS / 10];\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3342996 {\rtlch\fcs1 \af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid6580905\charrsid14119459 \cell }\pard \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid3937665\charrsid14119459 -\trowd \irow2\irowband2\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14119459\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 -\clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1777\clshdrawnil \cellx1669\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth4001\clshdrawnil \cellx5670\clvertalt -\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3844\clshdrawnil \cellx9514\row }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid6580905 { -\rtlch\fcs1 \af1 \ltrch\fcs0 \insrsid6580905\charrsid6580905 -\par }\pard\plain \ltrpar\s3\ql \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0\pararsid6968528 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid6968528\charrsid14119459 \page }{\rtlch\fcs1 \ab\af1\afs28 \ltrch\fcs0 \b\f37\fs28\cf1\insrsid6968528\charrsid14119459 Functions}{\rtlch\fcs1 \af1\afs28 \ltrch\fcs0 \f37\fs28\cf1\insrsid6968528\charrsid14119459 -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid5376200 -\par \ltrrow}\trowd \irow0\irowband0\lastrow \ltrrow\ts20\trgaph70\trleft-108\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid6099241\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 -\clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx4665\clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl -\cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx9438\pard\plain \ltrpar\s3\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel2\rin0\lin0\pararsid6099241\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \b\f37\cf1\insrsid6099241\charrsid14119459 {\*\bkmkstart SolveBoard}SolveBoard}{\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 {\*\bkmkend SolveBoard} -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6099241\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid8154048 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid5767474 REF deal \\h }{\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6099241\charrsid5767474 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b0200000008000000050000006400650061006c000000001500c60600956f0000074f00c0726500badc00ab001500002d0000ff00170000000000300003000000000000d02000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid5767474 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 deal}}}\sectd \ltrsect -\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid6099241\charrsid8154048 }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241 dl,}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid8154048 -\par int target, -\par int solutions, -\par int mode, -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid12659025 REF futureTricks \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6099241\charrsid12659025 -{\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d00000066007500740075007200650054007200690063006b0073000000004c0000004e022400000000000000000075ddc000021900ff9a000000001b000000ff003600d00000000000008d2100}}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid12659025 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 futureTricks} -}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid6099241\charrsid8154048 *futp, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid8154048 -\par int threadIndex}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241 \cell }\pard\plain \ltrpar -\s3\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel2\rin0\lin0\pararsid6099241\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid6099241\charrsid14119459 {\*\bkmkstart SolveBoardPBN}SolveBoardPBN}{\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 {\*\bkmkend SolveBoardPBN} -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6099241\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 REF dealPBN \\h }{\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6099241\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b0200000008000000080000006400650061006c00500042004e000000042f03707c200000000000000000004500653f00b600000000000061000200952bff00bc00ff00820000004900000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 dealPBN}}}\sectd \ltrsect -\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid16731528 d}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid15150655 l}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid16731528 ,}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\insrsid6099241\charrsid14119459 }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 -\par int target, -\par int solutions, -\par int mode, -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 REF futureTricks \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6099241\charrsid14119459 -{\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d00000066007500740075007200650054007200690063006b0073000000220000004003006100000000ff00000000530000bb002200001700000000250000000000005aff000000ff0000552600}}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 futureTricks} -}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid6099241\charrsid14119459 *futp, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 - -\par }\pard\plain \ltrpar\s3\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel2\rin0\lin0\pararsid6099241\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 int threadIndex}{\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241 \cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6099241 \trowd \irow0\irowband0\lastrow \ltrrow -\ts20\trgaph70\trleft-108\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid6099241\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb -\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx4665\clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx9438\row }\pard\plain \ltrpar -\s3\ql \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0\pararsid16467273 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid16467273 SolveBoardPBN}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11107656 is just like SolveBoard, }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid16467273 except for the input format.}{\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid16467273\charrsid14119459 -\par }\pard\plain \ltrpar\qj \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid13331862 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid16467273 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14119459\charrsid14119459 SolveBoard solves a single deal }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid16530750 \'93}{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 \b\f2\fs22\cf1\insrsid16530750\charrsid16530750 dl}{ -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid16530750 \'94 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14119459\charrsid14119459 and returns the result in }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid16530750 \'93}{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 -\b\f2\fs22\cf1\insrsid14119459\charrsid16530750 *futp}{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 \b\f2\fs22\cf1\insrsid16530750 \'94}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14119459\charrsid14119459 which must be declared before calling SolveBoard. -\par -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6650094\charrsid14119459 SolveBoard is threa}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid4542728\charrsid14119459 d-safe, so several threads }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid6650094\charrsid14119459 can call SolveBoard in parallel.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid4538894\charrsid14119459 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9716036 -Thus the user of DDS can create threads and call SolveBoard in parallel over them. }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid4538894\charrsid14119459 The }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14119459\charrsid14119459 -maximum number of threads is fixed in the DLL at co}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13331862 mpile time and is currently 16. So }{\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\cf1\insrsid16530750\charrsid16530750 \'93}{\rtlch\fcs1 \af2\afs22 -\ltrch\fcs0 \b\f2\fs22\cf1\insrsid13331862\charrsid16530750 threadIndex}{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 \b\f2\fs22\cf1\insrsid16530750\charrsid16530750 \'94}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13331862 must be between 0 and 15 inclusive. } -{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10108539 Together with the }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2849436 Play}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10108539 Analyse}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2849436 - functions, t}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13331862 his is the only function that exposes the thread number to the user.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9716036 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13331862 -\par There is a \'93transposition table\'94 - memory associated with each thread. Each node in the table is effectively a position after certain cards have been played and other certain cards remain. The table is not deleted automatically after each call to SolveBoar -d, so it can be reused from call to call. However, it only really makes sense to reuse the table when the hand is very similar in the two calls. The function will still run if this is not the case, but it won\rquote t be as efficient.}{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid13857996 The reu}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid16323149 se of the transposition table can be}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13857996 controlled by the \'93}{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 -\b\f2\fs22\cf1\insrsid13857996\charrsid13857996 mode}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13857996 \'94 parameter}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11540483 , but normally this is not needed and should not be done}{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid13857996 .}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid16530750 -\par -\par The three parameters \'93}{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 \b\f2\fs22\cf1\insrsid16530750\charrsid16530750 target}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid16530750 \'94, \'93}{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 -\b\f2\fs22\cf1\insrsid16530750\charrsid16530750 solutions}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid16530750 \'94 and \'93}{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 \b\f2\fs22\cf1\insrsid16530750\charrsid16530750 mode}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid16530750 \'94 together control the function. General}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13857996 ly speaking, the target is the number of tricks to -be won (at least) by the side to play; solutions controls how many solutions should be returned; and mode }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11294126 controls the search behavior.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid16467273 - See next page for definitions.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid16530750 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11294126 -\par For equivalent cards, only the highest is returned, and lower equivalent cards are encoded in the }{\field{\*\fldinst {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\ul\cf19\insrsid11294126\charrsid11294126 REF futureTricks \\h }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\ul\cf19\insrsid11294126\charrsid11294126 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d00000066007500740075007200650054007200690063006b007300000000c40000202800000020000000a20000006f00ff00062709ff0a080000022a0000000000007400000000000000a52800}}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\ul\cf19\insrsid11294126 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\ul\cf19\insrsid16012515\charrsid16012515 futureTricks}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid11294126 structure (see \'93equals\'94). -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid16530750 -\par -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11294126 \page }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid16530750 -\par \ltrrow}\trowd \irow0\irowband0\ltrrow\ts20\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11294126\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1242\clshdrawnil \cellx1134\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1701\clshdrawnil \cellx2835 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth6521\clshdrawnil \cellx9356\pard\plain \ltrpar -\qc \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid13857996\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 -\b\f2\fs22\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid16530750 target\cell }{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 \b\f2\fs22\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 s}{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 -\b\f2\fs22\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid16530750 olutions\cell }\pard \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid13331862\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid16530750 Comment\cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11294126 \trowd \irow0\irowband0\ltrrow\ts20\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr -\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 \trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11294126\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1242\clshdrawnil \cellx1134\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1701\clshdrawnil \cellx2835\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth6521\clshdrawnil \cellx9356\row \ltrrow -}\pard\plain \ltrpar\qc \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid13857996\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 -1\cell 1\cell }\pard \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid13331862\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 Find the maximum number of tricks for the side to play. -\par Return only one of the optimum cards and its score.\cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11294126 \trowd \irow1\irowband1\ltrrow\ts20\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr -\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 \trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11294126\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1242\clshdrawnil \cellx1134\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1701\clshdrawnil \cellx2835\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth6521\clshdrawnil \cellx9356\row \ltrrow -}\pard\plain \ltrpar\qc \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid13857996\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 -1\cell 2\cell }\pard \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid13857996\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 Find the maximum number of tricks for the side to play. -\par Return all optimum cards and their scores.\cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11294126 \trowd \irow2\irowband2\ltrrow\ts20\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr -\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 \trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11294126\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1242\clshdrawnil \cellx1134\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1701\clshdrawnil \cellx2835\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth6521\clshdrawnil \cellx9356\row \ltrrow -}\pard\plain \ltrpar\qc \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid13857996\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 0\cell 1\cell }\pard \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid13331862\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\lang1033\langfe1053\langfenp1053\insrsid11294126 -Return}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid14119459 only one of the cards legal to play}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\lang1033\langfe1053\langfenp1053\insrsid11294126 ,}{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid14119459 with score set to 0}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\lang1033\langfe1053\langfenp1053\insrsid11294126 .}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 \cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11294126 \trowd \irow3\irowband3\ltrrow\ts20\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr -\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 \trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11294126\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1242\clshdrawnil \cellx1134\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1701\clshdrawnil \cellx2835\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth6521\clshdrawnil \cellx9356\row \ltrrow -}\pard\plain \ltrpar\qc \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14574742\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 0\cell 2\cell }\pard \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid13857996\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\lang1033\langfe1053\langfenp1053\insrsid11294126 -Return}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid14119459 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\lang1033\langfe1053\langfenp1053\insrsid11294126 all}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid14119459 cards }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\lang1033\langfe1053\langfenp1053\insrsid11294126 that }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid14119459 legal to play}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\lang1033\langfe1053\langfenp1053\insrsid11294126 ,}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid14119459 with score set to 0}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\lang1033\langfe1053\langfenp1053\insrsid11294126 .}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 \cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11294126 \trowd \irow4\irowband4\ltrrow\ts20\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr -\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 \trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11294126\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1242\clshdrawnil \cellx1134\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1701\clshdrawnil \cellx2835\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth6521\clshdrawnil \cellx9356\row \ltrrow -}\pard\plain \ltrpar\qc \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid13857996\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 1 .. 13\cell 1\cell }\pard \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid13331862\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 If score is -1: Target cannot be reached. -\par If score is 0: In fact no tricks at all can be won. -\par If score is > 0: score will always equal target, even if more tricks can be won. -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid1313463 One }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 of the cards achieving the target is returned.\cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11294126 -\trowd \irow5\irowband5\ltrrow\ts20\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11294126\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1242\clshdrawnil \cellx1134\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1701\clshdrawnil \cellx2835 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth6521\clshdrawnil \cellx9356\row \ltrrow}\pard\plain \ltrpar -\qc \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14574742\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 1 .. 13\cell 2\cell }\pard \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid13331862\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 Return all cards meeting (at least) the target. -\par If the target cannot be achieved, only one card is returned with the score set as above.\cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11294126 \trowd \irow6\irowband6\ltrrow\ts20\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr -\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 \trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11294126\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1242\clshdrawnil \cellx1134\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1701\clshdrawnil \cellx2835\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth6521\clshdrawnil \cellx9356\row \ltrrow -}\pard\plain \ltrpar\qc \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid13857996\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 any\cell 3\cell }\pard \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid13331862\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 Return all cards that can be legally played, with their scores in descending order.\cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 -\rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11294126 \trowd \irow7\irowband7\lastrow \ltrrow\ts20\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl -\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid11294126\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1242\clshdrawnil \cellx1134\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1701\clshdrawnil \cellx2835 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth6521\clshdrawnil \cellx9356\row }\pard \ltrpar\qj \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid11294126 -{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6650094\charrsid14119459 \line }{\rtlch\fcs1 \af1\afs20 \ltrch\fcs0 \f37\fs20\cf1\insrsid11294126\charrsid1212155 -\par \ltrrow}\pard\plain \ltrpar\qc \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14574742\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 -\b\f2\fs22\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 mode}{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 \b\f2\fs22\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid16530750 \cell }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid11294126\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 Reuse TT?}{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 -\b\f2\fs22\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid16530750 \cell }\pard \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14574742\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid16530750 Comment\cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11294126 \trowd \irow0\irowband0\ltrrow\ts20\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr -\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 \trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14574742\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1242\clshdrawnil \cellx1134\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1701\clshdrawnil \cellx2835\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth6521\clshdrawnil \cellx9356\row \ltrrow -}\trowd \irow1\irowband1\ltrrow\ts20\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14574742\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1242\clshdrawnil \cellx1134\clvmgf\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1701\clshdrawnil -\cellx2835\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth6521\clshdrawnil \cellx9356\pard\plain \ltrpar -\qc \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14574742\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 0\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid1212155\yts20 {\rtlch\fcs1 \af2 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid1212155 Automatic if same trump suit and }{\rtlch\fcs1 \af2 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid1212155\charrsid1212155 the same or nearly the same card}{ -\rtlch\fcs1 \af2 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid7277737 s}{\rtlch\fcs1 \af2 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid1212155\charrsid1212155 distribution, }{\rtlch\fcs1 \af2 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid1212155 deal.first -\par }{\rtlch\fcs1 \af2 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid1212155\charrsid1212155 can be different.}{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 \f2\fs22\cf1\lang1033\langfe1053\langfenp1053\insrsid1212155 }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid1212155 \cell }\pard \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14574742\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid14119459 Do not search to find the score if the hand to play has only one card, }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid1212155 -including its equivalents, to play. Score is set to \endash 2 for this card, indicating that there are no alternative cards. If there are multiple choices for c}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid14119459 ards to play, search is done to find the score. This mode is very fast but you don\rquote t }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 a}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid8137115 lways search to find the score.}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 \cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11294126 \trowd \irow1\irowband1\ltrrow\ts20\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr -\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 \trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14574742\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1242\clshdrawnil \cellx1134\clvmgf\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1701\clshdrawnil \cellx2835\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth6521\clshdrawnil \cellx9356\row \ltrrow -}\trowd \irow2\irowband2\ltrrow\ts20\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14574742\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1242\clshdrawnil \cellx1134\clvmrg\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1701\clshdrawnil -\cellx2835\clvmgf\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth6521\clshdrawnil \cellx9356\pard\plain \ltrpar -\qc \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14574742\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 1\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid11294126\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 -\cell }\pard \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14574742\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid14119459 Always }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid14119459 search to find the score. Even when the h}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\lang1033\langfe1053\langfenp1053\insrsid15150655 and to play has only one card, }{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid14119459 with possible equivalents, to play. }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid14119459 \cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11294126 -\trowd \irow2\irowband2\ltrrow\ts20\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14574742\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1242\clshdrawnil \cellx1134\clvmrg\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1701\clshdrawnil -\cellx2835\clvmgf\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth6521\clshdrawnil \cellx9356\row \ltrrow}\trowd \irow3\irowband3\lastrow \ltrrow\ts20\trgaph70\trleft-108 -\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14574742\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1242\clshdrawnil \cellx1134\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1701\clshdrawnil \cellx2835 -\clvmrg\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth6521\clshdrawnil \cellx9356\pard\plain \ltrpar -\qc \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14574742\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 2\cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid11294126\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126 -Always\cell }\pard \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid14574742\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11294126\charrsid14119459 \cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11294126 -\trowd \irow3\irowband3\lastrow \ltrrow\ts20\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid14574742\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1242\clshdrawnil \cellx1134\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1701\clshdrawnil \cellx2835 -\clvmrg\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth6521\clshdrawnil \cellx9356\row }\pard \ltrpar -\qj \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid11294126 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6650094 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid11294126 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11294126 \'93Reuse\'94 means \'93reuse the transposition table from the previous run with the same thread number\'94 -. For mode = 2 it }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid11294126\charrsid14119459 is the responsibility of the programmer using the DLL to ensure that reusing the table is s -afe in the actual situation. Example: Deal is the same, except for deal.first. Trump suit is the same. }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid11294126 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid11294126\charrsid14119459 -\par }\pard \ltrpar\ql \fi720\li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid11294126 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid11294126\charrsid14119459 1}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\super\insrsid11294126\charrsid14119459 st}{ -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid11294126\charrsid14119459 call}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid11294126 , East leads}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid11294126\charrsid14119459 : }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\insrsid11294126 \tab }{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\insrsid11294126\charrsid11294126 SolveB}{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\insrsid11294126 oard(deal, -1, 1, 1, &fut, 0), }{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\insrsid11294126\charrsid11294126 deal.first=1}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid11294126\charrsid14119459 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid11294126 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid11294126\charrsid14119459 \tab 2}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\super\insrsid11294126\charrsid14119459 nd}{ -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid11294126\charrsid14119459 call}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid11294126 , South leads}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid11294126\charrsid14119459 : }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\insrsid11294126 \tab }{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\insrsid11294126\charrsid11294126 SolveBoard(deal, -1, 1, 2, &fut,}{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\insrsid11294126 0), }{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\insrsid11294126\charrsid11294126 deal.first=2}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid11294126\charrsid14119459 -\par \tab 3rd call}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid11294126 , West leads}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid11294126\charrsid14119459 : }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid11294126 \tab }{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\insrsid11294126\charrsid11294126 SolveB}{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\insrsid11294126 oard(deal, -1, 1, 2, &fut, 0), }{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\insrsid11294126\charrsid11294126 deal.first=3}{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\insrsid11294126\charrsid14119459 -\par }\pard \ltrpar\ql \fi720\li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid11294126 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid11294126\charrsid14119459 4th call}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid11294126 , North leads}{\rtlch\fcs1 -\af1 \ltrch\fcs0 \f37\insrsid11294126\charrsid14119459 : }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid11294126 \tab }{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\insrsid11294126\charrsid11294126 SolveB}{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 -\f2\fs20\insrsid11294126 oard(deal, -1, 1, 2, &fut, 0), }{\rtlch\fcs1 \af2\afs20 \ltrch\fcs0 \f2\fs20\insrsid11294126\charrsid11294126 deal.first=0}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11294126\charrsid14119459 -\par }\pard \ltrpar\qj \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid11294126 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11294126 -\par -\par \ltrrow}\trowd \irow0\irowband0\lastrow \ltrrow -\ts20\trgaph70\trleft-108\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid6099241\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrtbl \clbrdrl -\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx4665\clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx9438\pard\plain \ltrpar -\s3\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel2\rin0\lin0\pararsid6099241\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid16467273 \page }{\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \b\f37\cf1\insrsid6099241\charrsid16467273 {\*\bkmkstart CalcDDtable}CalcDDtable}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241 -{\*\bkmkend CalcDDtable} -\par }\pard\plain \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6099241\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 REF ddTableDeal \\h }{ -\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6099241\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000c000000640064005400610062006c0065004400650061006c000000030120007100005960000000000000b441000000000000000000000014000095180000df000000130000006100000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 ddTableDeal}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid6099241\charrsid14119459 tableDeal, \line }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 REF ddTableResults \\h }{ -\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6099241\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f000000640064005400610062006c00650052006500730075006c00740073000000c20d000000ff2e00007500bb0246000044a1920000002c0000e4009800000000003b0000008200000033180001000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 ddTableResults}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid6099241\charrsid14119459 * tablep}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241 \cell }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6099241\yts20 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \b\f37\cf1\insrsid6099241\charrsid14119459 {\*\bkmkstart CalcDDtablePBN}CalcDDtablePBN}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 {\*\bkmkend CalcDDtablePBN} -\par }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 REF ddTableDealPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6099241\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f000000640064005400610062006c0065004400650061006c00500042004e0000000030000080000000009c035900000000087200f001e82e00ff6d38000000ff0000e900000047000000931f00011a0000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 ddTableDealPBN}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid6099241 }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 tableDealPBN, -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 REF ddTableResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6099241\charrsid14119459 -{\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f000000640064005400610062006c00650052006500730075006c0074007300000000d000200b22006100e83aff006f00440800000000d4ff00000000000000000000dca50000e1ff00008e240001780000}}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 -ddTableResults}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid6099241\charrsid14119459 * tablep}{\rtlch\fcs1 \af0 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid6099241 -\cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid6099241 \trowd \irow0\irowband0\lastrow \ltrrow -\ts20\trgaph70\trleft-108\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid6099241\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrtbl \clbrdrl -\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx4665\clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx9438\row -}\pard\plain \ltrpar\s3\ql \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0\pararsid11107656 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid6099241 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11107656 CalcDDtablePBN is just like CalcDDtable, except for the input format. -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid11107656 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \insrsid11107656 -\par }\pard \ltrpar\qj \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid6099241 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11107656 CalcDDtable}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11107656\charrsid14119459 solves a single deal }{ -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11107656 \'93}{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 \b\f2\fs22\cf1\insrsid11107656 tableDeal}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11107656 \'94 }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid11107656\charrsid14119459 and returns the }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11107656 double-dummy values for the initial 52 cards for all the 20 combinations of denomination and declarer}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid11107656\charrsid14119459 in }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11107656 \'93}{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 \b\f2\fs22\cf1\insrsid11107656 *table}{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 -\b\f2\fs22\cf1\insrsid11107656\charrsid16530750 p}{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 \b\f2\fs22\cf1\insrsid11107656 \'94}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11107656 , }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11107656\charrsid14119459 -which must be declared before calling }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11107656 CalcDDtable}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11107656\charrsid14119459 .}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11107656 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6099241 -\par }\pard\plain \ltrpar\s3\ql \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0\pararsid11107656 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid6099241 -\par \ltrrow}\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6099241\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\b\f37\cf1\insrsid6099241\charrsid14119459 {\*\bkmkstart CalcAllTables}CalcAllTables}{\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 {\*\bkmkend CalcAllTables} -\par }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 REF ddTableDeals \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6099241\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d000000640064005400610062006c0065004400650061006c007300000000720000000000680000000000600000006c0000ff00000000ff0000000000ff006ba4000098000000a12600d1ff0000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 ddTableDeals}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid6099241\charrsid14119459 *dealsp,}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 - -\par int mode, -\par int trumpFilter[5], -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 REF ddTablesRes \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6099241\charrsid14119459 -{\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000c000000640064005400610062006c00650073005200650073000000032f030096e4000b0000004000000069000000ff00020002000000d2230000002c0000f01800006b1100007700000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 ddTablesRes}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid6099241\charrsid14119459 *resp, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 REF allParResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6099241\charrsid14119459 -{\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000e00000061006c006c0050006100720052006500730075006c00740073000000f900000b8c0000f0002000bc006f0000000000000002000273ff4c02250000002f0000b21c000016170000a5f60000dd}}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 allParResults -}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid6099241\charrsid14119459 *presp}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid6099241 -\par }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid1846101 -\par }\pard\plain \ltrpar\s3\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel2\rin0\lin0\pararsid5594575\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid1846101 \cell }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6099241\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\cf1\insrsid6099241\charrsid14119459 {\*\bkmkstart CalcAllTablesPBN}CalcAllTables}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241 PBN}{\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 {\*\bkmkend CalcAllTablesPBN} -\par }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 REF ddTableDealsPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6099241\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b020000000800000010000000640064005400610062006c0065004400650061006c007300500042004e000000002f03d091282020002e0024007d000002000000010000080000001200000000006900ec1f0000bd1e00008e0000ff6d}}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 -ddTableDealsPBN}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid6099241\charrsid14119459 *dealsp, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 -\par int mode, -\par int trumpFilter[5], -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 REF ddTablesRes \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6099241\charrsid14119459 -{\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000c000000640064005400610062006c00650073005200650073000000002f037b000000b49d2e2000007d000000ff00000e000000000000e5150000080000003922000058230000110000ff14}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 ddTablesRes}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid6099241\charrsid14119459 *resp, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid8323199\yts20 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 REF allParResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid6099241\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000e00000061006c006c0050006100720052006500730075006c007400730000000073000000c002c40000c0bc030000200000000004000002000000b117000000250000e2250000b7240001b4000000c1}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 allParResults}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid6099241\charrsid14119459 *presp}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid1846101\charrsid5594575 \cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6099241 -\trowd \irow0\irowband0\lastrow \ltrrow\ts20\trgaph70\trleft-108\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid6099241\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 -\clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx4665\clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl -\cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx9438\row }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid8323199 {\rtlch\fcs1 \af1 \ltrch\fcs0 \lang1033\langfe1031\langfenp1031\insrsid8323199\charrsid8323199 -\par }\pard\plain \ltrpar\s3\ql \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0\pararsid11107656 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid11107656 CalcAllTablesPBN is just like CalcAllTables, except for the input format. -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11107656 -\par }\pard \ltrpar\qj \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid11107656 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1770393 CallAllTables}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1770393\charrsid1770393 }{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid1770393 calculates }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1770393\charrsid1770393 the double dummy values }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1770393 of the }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid9713208 denomination}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1770393\charrsid1770393 /declarer hand combinations }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11762622 in }{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 -\b\f2\fs22\cf1\insrsid11762622\charrsid11762622 \'93*dealsp\'94}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11762622 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12068517 for }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1770393\charrsid1770393 -a number of }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13319718 DD table}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1770393\charrsid1770393 s in parallel}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12068517 . This increases}{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid1770393\charrsid1770393 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10631094 the speed}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1770393\charrsid1770393 compared to }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid4602097 calculating}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1770393\charrsid1770393 the}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12068517 se values}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1770393\charrsid1770393 using a -}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12068517 CalcDDtable call }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1770393\charrsid1770393 for each }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13319718 DD table}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid1770393\charrsid1770393 .}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11762622 The results are returned in }{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 \b\f2\fs22\cf1\insrsid11762622\charrsid11762622 \'93*resp\'94}{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid11762622 which must be defined before CalcAllTables is called.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1770393 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9175287 -\par }\pard \ltrpar\qj \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid6099241 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6099241 The }{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 \b\f2\fs22\cf1\insrsid6099241\charrsid6099241 \'93mode\'94}{ -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6099241 parameter contains the vulnerability (}{\field{\*\fldinst {\rtlch\fcs1 \af2 \ltrch\fcs0 \f37\ul\cf19\insrsid6099241\charrsid6099241 REF vulnerable \\h }{\rtlch\fcs1 \af2 \ltrch\fcs0 -\f37\ul\cf19\insrsid6099241\charrsid6099241 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b000000760075006c006e0065007200610062006c006500000000680f0000bf060000000000ff09000000ff0000006a00000002100000e217000000160000ec230000000000005a0000}}{\rtlch\fcs1 \af2 \ltrch\fcs0 -\f37\ul\cf19\insrsid6099241\charrsid6099241 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2 \ltrch\fcs0 \f37\ul\cf19\insrsid16012515\charrsid16012515 Vulnerable}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid6099241 encoding) for use in the par calculation. It is set to -1 if no par calculation is to be performed. -\par }\pard \ltrpar\qj \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid11762622 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6099241 -\par }\pard \ltrpar\qj \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid6099241 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9713208 There are 5 possible denominations or strains (the four trump suits and no trump). }{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid11762622 The parameter }{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 \b\f2\fs22\cf1\insrsid11762622\charrsid11762622 \'93trumpFilter\'94}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11762622 describes which, if any, of the }{ -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6099241 5 possibilities}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11762622 that will be }{\rtlch\fcs1 \af1 \ltrch\fcs0 \i\f37\cf1\insrsid11762622\charrsid6099241 excluded}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid11762622 from the calculations. They are defined}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6099241 in }{\field{\*\fldinst {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\ul\cf19\insrsid6099241\charrsid6099241 REF suit \\h }{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\ul\cf19\insrsid6099241\charrsid6099241 {\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b0200000008000000050000007300750069007400000022ce0700005600000009000000fb160000750000003b000000001200007c1a0000001800002225000000000000380000}}{ -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\ul\cf19\insrsid6099241\charrsid6099241 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\ul\cf19\insrsid16012515\charrsid16012515 Suit}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid6099241 encoding order, so}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11762622 setting trumpFilter to \{FALSE, FALSE, TRUE, TRUE, TRUE\} means that values will only be calculated for }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid6099241 the trump suits spades and h}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11762622 earts.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13244366 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid13244366\charrsid9401184 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9713208 -\par }\pard \ltrpar\qj \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid6099241 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9175287 The maximum number of DD tables in a CallAllTables call depends on the number of }{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid6099241 strains required}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9175287 . }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6099241 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9175287 If all 5 }{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid6099241 strains}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9175287 are included there are 20 declarer hand / strain combinations. The maximum number of boards that can be calculated in parallel is 200, so the maximum number -}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid1445386 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14102810 of DD tables that can be included in a CallAllTable call is 10.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9175287 }{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid6099241 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14892228 At fewer strains the maximum number o}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6099241 f DD tables in a call is higher.}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid9175287 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6629265 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6099241 -\par \ltrrow}\trowd \irow0\irowband0\ltrrow\ts20\trqc\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid6099241\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2235\clshdrawnil \cellx2127\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3543\clshdrawnil \cellx5670 -\pard\plain \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6099241\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid6099241 Number of strains\cell }\pard \ltrpar\qc \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6099241\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241\charrsid6099241 Maximum number of DD tables\cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 -\ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6099241 \trowd \irow0\irowband0\ltrrow\ts20\trqc\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 -\trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid6099241\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2235\clshdrawnil \cellx2127\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3543\clshdrawnil \cellx5670 -\row \ltrrow}\pard\plain \ltrpar\qc \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6099241\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241 5\cell 10\cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6099241 \trowd \irow1\irowband1\ltrrow\ts20\trqc\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr -\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 \trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid6099241\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2235\clshdrawnil \cellx2127\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3543\clshdrawnil \cellx5670\row \ltrrow}\pard\plain \ltrpar\qc \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6099241\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241 4\cell 12\cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6099241 -\trowd \irow2\irowband2\ltrrow\ts20\trqc\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid6099241\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2235\clshdrawnil \cellx2127\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3543\clshdrawnil \cellx5670 -\row \ltrrow}\pard\plain \ltrpar\qc \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6099241\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241 3\cell 16\cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6099241 \trowd \irow3\irowband3\ltrrow\ts20\trqc\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr -\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 \trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid6099241\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2235\clshdrawnil \cellx2127\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr -\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3543\clshdrawnil \cellx5670\row \ltrrow}\pard\plain \ltrpar\qc \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6099241\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241 2\cell 25\cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6099241 -\trowd \irow4\irowband4\ltrrow\ts20\trqc\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid6099241\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2235\clshdrawnil \cellx2127\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3543\clshdrawnil \cellx5670 -\row \ltrrow}\pard\plain \ltrpar\qc \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6099241\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid6099241 1\cell 50\cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6099241 \trowd \irow5\irowband5\lastrow \ltrrow\ts20\trqc\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 -\trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid6099241\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth2235\clshdrawnil \cellx2127\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3543\clshdrawnil \cellx5670 -\row }\pard \ltrpar\qj \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid6099241 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6099241 -\par \ltrrow}\trowd \irow0\irowband0\lastrow \ltrrow\ts20\trgaph70\trleft-108\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid15668792\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0 -\tblindtype3 \clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx4665\clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl -\cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx9438\pard\plain \ltrpar\s3\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel2\rin0\lin0\pararsid5320216\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \b\f37\cf1\insrsid5320216\charrsid5320216 {\*\bkmkstart SolveAllChunksBin}SolveAllChunksBin}{\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid5320216\charrsid5320216 {\*\bkmkend SolveAllChunksBin} -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid5320216\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid5320216\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid5320216\charrsid14119459 REF boards \\h }{\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5320216\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000700000062006f006100720064007300000000bc02618000000000e83a00360000611646000000790000000a150000d8220000021c00006d2800000000002a780000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid5320216\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 boards}}}\sectd \ltrsect -\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid5320216\charrsid14119459 *bop, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid5320216\charrsid14119459 -\par }\pard \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid5320216\yts20 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid5320216\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid5320216\charrsid14119459 REF solvedBoards \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5320216\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d00000073006f006c0076006500640042006f006100720064007300000000000074080c04e5020000000000000800002e00007e000000b817000069250000ff1d00000e2b000000ffff00380000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid5320216\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 solvedBoards}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid5320216\charrsid14119459 *solvedp, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid5320216 -\par }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid5320216\charrsid14119459 int chunkSize}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid1846101\charrsid1846101 \cell -}\pard\plain \ltrpar\s3\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel2\rin0\lin0\pararsid5320216\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \ab\af1 -\ltrch\fcs0 \b\f37\cf1\insrsid5320216\charrsid5320216 {\*\bkmkstart SolveAllChunksPBN}SolveAllChunksPBN}{\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid5320216\charrsid5320216 {\*\bkmkend SolveAllChunksPBN} -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid5320216\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid5320216\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid5320216\charrsid14119459 REF boardsPBN \\h }{ -\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5320216\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000a00000062006f006100720064007300500042004e0000000000003806013120c64f000000690000056b00942f0000121d0000b817000000120000bc000000000000000000000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid5320216\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 boardsPBN}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid5320216\charrsid14119459 *bop, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid5320216\charrsid14119459 -\par }\pard \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid5320216\yts20 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid5320216\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid5320216\charrsid14119459 REF solvedBoards \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5320216\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d00000073006f006c0076006500640042006f00610072006400730000000000003a7572000100c400000004000003bc020000020000006a190000302c00000021000fe40000000000ff00000100}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid5320216\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 solvedBoards}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid5320216\charrsid14119459 *solvedp, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid5320216 -\par }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid5320216\charrsid14119459 int chunkSize}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid5320216 -\par }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid1846101 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid1846101 \cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid5320216 \trowd \irow0\irowband0\lastrow \ltrrow -\ts20\trgaph70\trleft-108\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid15668792\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrtbl \clbrdrl -\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx4665\clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx9438\row }\pard \ltrpar -\qj \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid6099241 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \b\f37\cf1\insrsid5320216\charrsid5320216 {\*\bkmkstart SolveAllChunks}SolveAllChunks}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid5320216 -{\*\bkmkend SolveAllChunks} i}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11344057 s an alias for SolveAllChunksPBN}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid5320216 ; don\rquote t use it. -\par -\par }{\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \b\f37\cf1\insrsid5320216\charrsid5320216 {\*\bkmkstart SolveAllBoards}SolveAllBoards}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid5320216 {\*\bkmkend SolveAllBoards} - is an alias for SolveAllChunksPBN with a chunkSize of 1; don\rquote t use it. -\par -\par The SolveAll* functions invoke SolveBoard several times in parallel in multiple threads, rather than sequentially in a single thread. This increases execution speed. Up to 200 boards are permitted per call.}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid4545218 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid15668792 -\par It is important to understand the parallelism and the concept of a chunk. -\par -\par If the chunk size is 1, then each of the threads starts out with a single board. If there are four threads, then boards 0, -1, 2 and 3 are initially solved. If thread 2 is finished first, it gets the next available board, in this case board 4. Perhaps this is a particularly easy board, so thread 2 also finishes this board before any other thread completes. Thread 2 then als -o gets board 5, and so on. This continues until all boards have been solved. In the end, three of the threads will be waiting for the last thread to finish, which causes a bit of inefficiency. -\par -\par The transposition table in a given thread (see }{\field{\*\fldinst {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\ul\cf19\insrsid15668792\charrsid15668792 REF SolveBoard \\h }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\ul\cf19\insrsid15668792\charrsid15668792 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b00000053006f006c007600650042006f0061007200640000000056000000000065004843000000007240a1920000bdef0000003c0100204300002a110000e3ff020000000000000000}}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\ul\cf19\insrsid15668792\charrsid15668792 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \f37\ul\cf19\insrsid16012515\charrsid16012515 SolveBoard}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid15668792 ) is generally not reused between board 2, 4 and 5 in thread 2. This only happens if SolveBoard itself determines that the boards are suspiciously similar. -\par -\par If the chunk size is 2, then initially thread 0 gets boards 0 and 1, thread 1 gets boards 2 and 3, thread 2 gets boards 4 and 5, and thread 3 gets boards 6 and 7. When a thread is finished, it gets two new boards in one go, for instance boards 8 and 9.}{ -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13593709 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid15668792 The transposition table in a given thread is reused within a chunk. -\par -\par No matter what the chunk size is, the boards are solved in parallel. But if the user knows that boards are grouped in chunks of 2 or 10, it is possible to force the DD solver to use this knowledge. }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid13593709 Here are some examples: -\par -\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af1 \ltrch\fcs0 \f3\cf1\lang1033\langfe1053\langnp1033\insrsid13593709 \loch\af3\dbch\af0\hich\f3 \'b7\tab}}\pard \ltrpar\qj \fi-360\li360\ri0\nowidctlpar\wrapdefault\faauto\ls3\rin0\lin360\itap0\pararsid13593709 -{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13593709 T}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid15668792 he same board is played at two tables of a team match. }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13593709 -\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af1 \ltrch\fcs0 \f3\cf1\lang1033\langfe1053\langnp1033\insrsid13593709 \loch\af3\dbch\af0\hich\f3 \'b7\tab}A }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid15668792 -board is played at 10 tables in a pairs tournament. }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13593709 -\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af1 \ltrch\fcs0 \f3\cf1\lang1033\langfe1053\langnp1033\insrsid13593709 \loch\af3\dbch\af0\hich\f3 \'b7\tab}The trump suit is the same, and there are very minor differences in the rest. -\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af1 \ltrch\fcs0 \f3\cf1\lang1033\langfe1053\langnp1033\insrsid13593709 \loch\af3\dbch\af0\hich\f3 \'b7\tab} -The simulation aims to find out which hand is best as declarer. But CalcAllTables can be a more convenient alternative for this. -\par }\pard \ltrpar\qj \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid6099241 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13593709 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid15668792 Note that the alignment must remain perfect t -hroughout the whole function call: If the chunk size is 2, then a board with an even number and the following board must be very similar. This must be the case even if the board is passed out at one table, or played in the same contract.}{\rtlch\fcs1 -\af1 \ltrch\fcs0 \f37\cf1\insrsid12658900 -\par \page -\par \ltrrow}\pard\plain \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6099241\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\b\f37\cf1\insrsid12658900\charrsid12658900 {\*\bkmkstart Par}Par}{\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid12658900 {\*\bkmkend Par} -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12658900\yts20 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid12658900\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid12658900\charrsid14119459 REF ddTableResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid12658900\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f000000640064005400610062006c00650052006500730075006c0074007300000000260000aeaf0000006978000027040072889200000000000f081e0000b70000000000000083ff000000000000000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid12658900\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 ddTableResults}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12658900\charrsid14119459 *tablep, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid12658900 -\par }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid12658900\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid12658900\charrsid14119459 REF parResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid12658900\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b00000070006100720052006500730075006c00740073000000003500000064000000040024001c040002a192000900000000001f00007000000f0800000043ff00009400ff00000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid12658900\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 parResults}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12658900\charrsid14119459 *presp, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid12658900\charrsid14119459 - -\par }\pard \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12658900\yts20 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid12658900\charrsid14119459 int vulnerable}{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid12658900\charrsid12658900 \cell }\pard \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6099241\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\cf1\insrsid2838088 DealerPar} -{\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid12658900\charrsid12658900 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12658900\yts20 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid12658900\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid12658900\charrsid14119459 REF ddTableResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid12658900\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f000000640064005400610062006c00650052006500730075006c00740073000000004c000000cd00000061726f0000010000e400000008000000000400000000000f08000000a8ff00009400ff00000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid12658900\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 ddTableResults}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12658900\charrsid14119459 *tablep, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid12658900\charrsid14119459 - -\par }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid5843075 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid5843075 HYPERLINK \\ -l "parResultsDealer" }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid5843075 {\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000001100000070006100720052006500730075006c00740073004400650061006c0065007200000000022b}}}{\fldrslt { -\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \cs26\f2\fs18\ul\cf17\lang1033\langfe1053\langfenp1053\insrsid5843075\charrsid5843075 parResultsDealer}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid5843075 }{ -\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid12658900\charrsid14119459 *presp, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid12658900\charrsid14119459 -\par int dealer, -\par }\pard \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12658900\yts20 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid12658900\charrsid14119459 int vulnerable}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid11956256 -\par }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid11956256\charrsid11956256 \cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 -\af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12658900 \trowd \irow0\irowband0\ltrrow -\ts20\trgaph70\trleft-108\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid12658900\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrtbl \clbrdrl -\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx4665\clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx9438\row \ltrrow -}\pard\plain \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12128238\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\b\f37\cf1\insrsid11956256 Sides}{\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\cf1\insrsid11956256\charrsid12658900 Par}{\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11956256 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12128238\yts20 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid11956256\charrsid14119459 struct }{\field\flddirty{\*\fldinst { -\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid11956256\charrsid14119459 REF ddTableResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid11956256\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f000000640064005400610062006c00650052006500730075006c0074007300000000260000aeaf0000006978000027040072889200000000000f081e0000b70000000000000083ff00000000000000ff00}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid11956256\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid11956256\charrsid16012515 ddTableResults}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid11956256\charrsid14119459 *tablep, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid11956256 -\par }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid11956256\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5843075 HYPERLINK \\l "parResultsDealer" }{ -\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5843075 {\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000001100000070006100720052006500730075006c00740073004400650061006c00650072000000000003}}}{\fldrslt {\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \cs26\f2\fs18\ul\cf17\insrsid5843075\charrsid5843075 parResultsDealer}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid5843075 *sidesRes[2],}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\cf1\insrsid11956256\charrsid14119459 }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid11956256\charrsid14119459 -\par }\pard \ltrpar\qj \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid12128238\yts20 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid11956256\charrsid14119459 int vulnerable}{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\lang1033\langfe1053\langfenp1053\insrsid11956256\charrsid12658900 \cell }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid11956256\charrsid11956256 \cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11956256 -\trowd \irow1\irowband1\lastrow \ltrrow\ts20\trgaph70\trleft-108\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid12128238\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 -\clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx4665\clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl -\cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx9438\row }\pard \ltrpar\qj \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid6099241 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11956256 -\par }\pard \ltrpar\qj \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid12658900 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12658900 These functions calculate the par score and par contracts of a given double-dummy solution matrix }{ -\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 \b\f2\fs22\cf1\insrsid12658900\charrsid12658900 \'93*tablep\'94}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12658900 which would often be the solution of a call to }{\field{\*\fldinst {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\ul\cf19\insrsid12658900\charrsid12658900 REF CalcDDtable \\h }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\ul\cf19\insrsid12658900\charrsid12658900 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000c000000430061006c006300440044007400610062006c00650000000000002e06200069000000c4000000460409004d10000f3939000c00000000000000008c240000000000ffff1400ff94}}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\ul\cf19\insrsid12658900\charrsid12658900 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \f37\ul\cf19\insrsid16012515\charrsid16012515 CalcDDtable}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid12658900 .}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10290420 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid10290420 Since the input is a table, there is no PBN and non-PBN version of this function.}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid12854747 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12658900 -\par Before the functions can be called, a structure of the type }{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 \b\f2\fs22\cf1\insrsid12658900\charrsid12658900 \'93parResults\'94}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12658900 }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid2505631 or }{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 \b\f2\fs22\cf1\insrsid2505631\charrsid2505631 \'93parResultsDealer\'94}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2505631 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12658900 -must already }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9716036 have }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12658900 be}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9716036 en}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12658900 defined. - -\par -\par The }{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 \b\f2\fs22\cf1\insrsid12658900\charrsid12658900 \'93vulnerable\'94}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12658900 parameter is given using }{\field{\*\fldinst {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\ul\cf19\insrsid12658900\charrsid12658900 REF vulnerable \\h }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\ul\cf19\insrsid12658900\charrsid12658900 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b000000760075006c006e0065007200610062006c0065000000000000020000022000460000000000fc0000670000001000000025000000000000000000000000000011ff0000000000}}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\ul\cf19\insrsid12658900\charrsid12658900 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\ul\cf19\insrsid16012515\charrsid16012515 Vulnerable}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid12658900 encoding. -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14574742 -\par The Par() function uses knowledge of the vulnerability, but not of the dealer. It attempts to return results for both declaring s -ides. These results can be different in some rare cases, for instance when both sides can make 1NT due to the opening lead. -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2505631 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2838088 The DealerPar}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14574742 () function also uses knowledge of the }{\rtlch\fcs1 \af2\afs22 \ltrch\fcs0 \b\f2\fs22\cf1\insrsid14574742\charrsid14574742 \'93 -dealer\'94}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14574742 using }{\field{\*\fldinst {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\ul\cf19\insrsid14574742\charrsid14574742 REF hand \\h }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\ul\cf19\insrsid14574742\charrsid14574742 {\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b020000000800000005000000680061006e0064000000c2a000720002000000650400000008000000050000001500000000ff0013ff300000000000000000008effff00000000}}{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\ul\cf19\insrsid14574742\charrsid14574742 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\ul\cf19\insrsid16012515\charrsid16012515 Hand}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid14574742 encoding. The argument is that in all practical cases, the dealer is known when the vulnerability is known. Therefore all results returned will be for the same side. -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9716036 -\par The SidesPar() function is similar to the Par() function, the only difference is the par results are given in the same format as for DealerPar(). -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14574742 -\par In Par() }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2505631 and SidesPar() }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14574742 there may be more than one par score; in }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2505631 DealerPar}{\rtlch\fcs1 -\af1 \ltrch\fcs0 \f37\cf1\insrsid14574742 () that is not the case. Par()}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2505631 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14574742 returns the scores as a text string, for instance \'93NS -460\'94 -, while }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid11562205\charrsid11562205 DealerPar}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2244172 () and SidesPar()}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14574742 }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid2244172 use }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14574742 an integer, -460. -\par -\par There may be several par contracts, for instance 3NT just making and 5C just making. Each par contract is returned as a text string. The format are a bit diff}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10174318 -erent betweeen the two output format alternatives}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14574742 . -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid3547548 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12658900 -\par }\pard \ltrpar\qj \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid14574742 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14574742 Par() returns the par contracts separated by commas. }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\insrsid14574742\charrsid14119459 Possible different trick levels of par score contracts are enumerated in the contract description, e.g the possible trick levels 3, 4 and 5 in }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14574742 no trump}{\rtlch\fcs1 -\af1 \ltrch\fcs0 \f37\insrsid14574742\charrsid14119459 are given as 345N.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14574742 Examples: -\par -\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af1 \ltrch\fcs0 \f3\lang1033\langfe1053\langnp1033\insrsid14574742 \loch\af3\dbch\af0\hich\f3 \'b7\tab}}\pard \ltrpar\qj \fi-360\li360\ri0\nowidctlpar\wrapdefault\faauto\ls3\rin0\lin360\itap0\pararsid14574742 { -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14574742 \'93}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14574742\charrsid4679726 NS:NS 23S,NS 23H}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14574742 \'94. }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\insrsid14574742\charrsid14574742 North and South as declarer make 2 or 3 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14574742 s}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14574742\charrsid14574742 pades and }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\insrsid14574742 h}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14574742\charrsid14574742 earts contracts, 2 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14574742 spades and 2 h}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14574742\charrsid14574742 -earts with an overtrick.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14574742 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14574742\charrsid14574742 This is from the NS view}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14574742 , shown by \'93NS:\'94 - meaning that NS made the first bid}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14574742\charrsid14574742 . }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14574742 -Note that this information is actually not enough, as it may be that N and S can make a given contract and that either E or W can bid this same contract (for instance 1NT) before N but not before S. So in the rare case -s where the NS and EW sides are not the same, the results will take some manual inspection. -\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af1 \ltrch\fcs0 \f3\lang1033\langfe1053\langnp1033\insrsid14574742 \loch\af3\dbch\af0\hich\f3 \'b7\tab}}\pard \ltrpar\ql \fi-360\li360\ri0\nowidctlpar\wrapdefault\faauto\ls3\rin0\lin360\itap0\pararsid14574742 { -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14574742 \'93}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14574742\charrsid9515749 NS:NS 23S,N 23H}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14574742\charrsid14574742 \'94}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\insrsid14574742 : Only North makes 3 hearts. -\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af1 \ltrch\fcs0 \f3\lang1033\langfe1053\langnp1033\insrsid14574742 \loch\af3\dbch\af0\hich\f3 \'b7\tab}\'93}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14574742\charrsid14574742 EW:NS 23S,N 23H}{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\insrsid14574742 \'94: This time the result is the same when EW open the bidding.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14574742\charrsid14574742 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid3547548 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14574742 -\par }\pard \ltrpar\qj \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid10290420 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10290420 \page }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14498845 DealerPar}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid14574742 ()}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14498845 and SidesPar() give}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10290420 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid10290420 each p}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\insrsid10290420\charrsid14171083 ar }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14498845 contract}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid10290420\charrsid14171083 as a }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid10290420 separate text string: - -\par -\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af1 \ltrch\fcs0 \f3\lang1033\langfe1053\langnp1033\insrsid10290420 \loch\af3\dbch\af0\hich\f3 \'b7\tab}}\pard \ltrpar\qj \fi-360\li360\ri0\nowidctlpar\wrapdefault\faauto\ls3\rin0\lin360\itap0\pararsid10290420 { -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid10290420 \'934S*-EW-1\'94 means that E and W can both sacrifice in four spades doubled, going down one trick. -\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af1 \ltrch\fcs0 \f3\lang1033\langfe1053\langnp1033\insrsid10290420 \loch\af3\dbch\af0\hich\f3 \'b7\tab}\'933N-EW\'94 means that E and W can both make exactly 3NT. -\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af1 \ltrch\fcs0 \f3\lang1033\langfe1053\langnp1033\insrsid10290420 \loch\af3\dbch\af0\hich\f3 \'b7\tab}\'934N-W+1\'94 means that only West can make 4NT +1. I -n the last example, 5NT just making can also be considered a par contract, but North-South don\rquote t have a profitable sacrifice against 4NT, so the par contract is shown in this way. If North-South did indeed have a profitable sacrifi}{\rtlch\fcs1 -\af1 \ltrch\fcs0 \f37\insrsid14498845 ce, perhaps 5C*_NS-2, then }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid10290420 par contract would }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14498845 ha}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14435334 -ve been shown as \'935N-W\'94. }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14498845 Par}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid10290420 () would show \'934N-W+1\'94 as \'93W 45N\'94. -\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af1 \ltrch\fcs0 \f3\lang1033\langfe1053\langnp1033\insrsid14498845 \loch\af3\dbch\af0\hich\f3 \'b7\tab}}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14498845 SidesPar() }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\insrsid13697230 give the par contract text strings }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid3034397 as described above }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid13697230 for each side.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14498845 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13915886 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14574742 -\par \ltrrow}\trowd \irow0\irowband0\lastrow \ltrrow\ts20\trgaph70\trleft-108\trftsWidth3\trwWidth9889\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid8538722\tbllkhdrrows\tbllkhdrcols\tbllknocolband -\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth3182\clshdrawnil \cellx3074\clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl -\cltxlrtb\clftsWidth3\clwWidth3305\clshdrawnil \cellx6379\clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth3402\clshdrawnil \cellx9781\pard\plain \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\cf1\insrsid7931676\charrsid7931676 -{\*\bkmkstart CalcPar}CalcPar}{\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid7931676 {\*\bkmkend CalcPar} -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid8538722\yts20 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid8538722\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid8538722\charrsid14119459 REF ddTableDeal \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid8538722\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000c000000640064005400610062006c0065004400650061006c00000062ff001c0000ff90000000c4006f0000000000001d0000723e00001310000100ff0000e400000000000000001800ff00}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid8538722\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 ddTableDeal}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8538722\charrsid14119459 }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid8538722 dl}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid8538722\charrsid14119459 -\par int vulnerable, -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid8538722\charrsid14119459 REF ddTableResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid8538722\charrsid14119459 -{\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f000000640064005400610062006c00650052006500730075006c00740073000000007400000020000000000000004b000b0075450000001e000000100000000100ff00ff00000000000000000000080000}}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid8538722\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 -ddTableResults}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8538722 * t}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid8538722\charrsid14119459 p, -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid4071901\yts20 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid8538722\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid8538722\charrsid14119459 REF parResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid8538722\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b00000070006100720052006500730075006c00740073000000006b00007500f9240000000040000000007445000000230000007a0000000000000000000000bb000000280000000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid8538722\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 parResults}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid4071901 *presp}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid6058144\charrsid4071901 \cell }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\cf1\insrsid7931676\charrsid7931676 {\*\bkmkstart CalcParPBN}CalcParPBN}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid7931676 {\*\bkmkend CalcParPBN} -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid8538722\yts20 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid8538722\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid8538722\charrsid14119459 REF ddTableDealPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid8538722\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f000000640064005400610062006c0065004400650061006c00500042004e00000000040005034e006f0059000000c400610000000000002f0000007aff001300000000600000312df40024300000000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid8538722\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 ddTableDealPBN}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8538722\charrsid14119459 }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid8538722 dl}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid8538722\charrsid14119459 , -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid8538722\charrsid14119459 REF ddTableResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid8538722\charrsid14119459 -{\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000f000000640064005400610062006c00650052006500730075006c0074007300000000ff016500000000c272007200c40061004e0200000031b800ff110000940000008ff20000f42f0000cc320000000100}}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid8538722\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 -ddTableResults}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8538722 * t}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid8538722\charrsid14119459 p, -\par int vulnerable, -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid8538722\charrsid14119459 REF parResults \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid8538722\charrsid14119459 -{\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b00000070006100720052006500730075006c00740073000000594e0061720000000048430000c4006100000000009ba8b80000170000940000008f7c0000db320000d4350000000100}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid8538722\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 parResults}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8538722\charrsid14119459 *presp}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8538722 -\par }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid6058144 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid4071901\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid6058144\charrsid7931676 \cell }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid8538722\yts20 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid8655475 -\par -\par }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid6058144 -\par -\par }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid2449260 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid6058144\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid2449260\charrsid7931676 \cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid7931676 -\trowd \irow0\irowband0\lastrow \ltrrow\ts20\trgaph70\trleft-108\trftsWidth3\trwWidth9889\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid8538722\tbllkhdrrows\tbllkhdrcols\tbllknocolband -\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth3182\clshdrawnil \cellx3074\clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl -\cltxlrtb\clftsWidth3\clwWidth3305\clshdrawnil \cellx6379\clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth3402\clshdrawnil \cellx9781\row }\pard\plain \ltrpar -\s3\qj \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0\pararsid8538722 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid8538722 CalcParPBN is just like CalcPar, except for the input format. -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid8538722 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \insrsid8538722 -\par }\pard\plain \ltrpar\s3\qj \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0\pararsid8538722 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid8538722\charrsid8538722 Each of }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid8538722 these functions calculates both the double-dummy table solution and the par solution to a given deal. -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid13780248 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \insrsid13780248 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid13780248\charrsid13780248 Both}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14435334 functions are deprecated. I}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid13780248\charrsid13780248 nstead }{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\insrsid14435334 use }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid13780248\charrsid13780248 one of the CalcDDtable functions followed by Par(). -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid14574742\charrsid14119459 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid3347855 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2849436 \page -\par \ltrrow}\trowd \irow0\irowband0\lastrow \ltrrow\ts20\trgaph70\trleft-108\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid2849436\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 -\clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx4665\clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl -\cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx9438\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3347855\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\cf1\insrsid2449260 {\*\bkmkstart TracePlayBin}Analyse}{\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\cf1\insrsid2849436\charrsid2849436 PlayBin}{\rtlch\fcs1 \af1 -\ltrch\fcs0 \b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid2849436 {\*\bkmkend TracePlayBin} -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid2849436\yts20 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid14119459 REF deal \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid2849436\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b0200000008000000050000006400650061006c000000000000000016fb0000c40000004e0065000000000000120000b00000000036000000010000000000000000000000ff00}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 deal}}}\sectd \ltrsect -\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid2849436\charrsid14119459 dl, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid14119459 -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid14119459 REF playTraceBin \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid2849436\charrsid14119459 -{\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d00000070006c006100790054007200610063006500420069006e000000000000007016fb000013006500690002000000000000150008970000000000000000000000000000000000000000ff00}}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 playTraceBin} -}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid2849436\charrsid14119459 play,}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid14119459 -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid14119459 REF solvedPlay \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid2849436\charrsid14119459 -{\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b00000073006f006c0076006500640050006c00610079000000ff0000ff0000000000e83a0000c40061000000010000170023ed000000000000006c01000000b400fa00000000000000}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 solvedPlay}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid2849436\charrsid14119459 *solvedp, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid14119459 - -\par int thrId}{\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid2849436 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid3347855\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\b\f37\cf1\insrsid2449260 {\*\bkmkstart TracePlayPBN}Analyse}{\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\cf1\insrsid2849436\charrsid2849436 PlayPBN}{\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid2849436 -{\*\bkmkend TracePlayPBN} -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid2849436\yts20 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid14119459 REF dealPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid2849436\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b0200000008000000080000006400650061006c00500042004e000000b4ffff7810650075000000020100001405520027290000340500009400000013009e000000000162000400ea0000007f}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 dealPBN}}}\sectd \ltrsect -\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid2849436\charrsid14119459 dlPBN, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid14119459 -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid14119459 REF playTracePBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid2849436\charrsid14119459 -{\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000d00000070006c006100790054007200610063006500500042004e0000000023000052800220ff7b0500002405e203000000000000000f9b00000008000000000000000000000000000000000e00}}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 playTracePBN} -}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid2849436\charrsid14119459 playPBN, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid14119459 - -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid14119459 REF solvedPlay \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid2849436\charrsid14119459 -{\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b00000073006f006c0076006500640050006c00610079000000007400b500410000c2d40400ff00000000000000000000009c4a00000f00000000080000000000000000000000001100}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 solvedPlay}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid2849436\charrsid14119459 *solvedp, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid14119459 - -\par int thrId}{\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\cf1\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid2849436 \cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 -\af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2849436 \trowd \irow0\irowband0\lastrow \ltrrow -\ts20\trgaph70\trleft-108\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid2849436\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb -\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx4665\clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx9438\row }\pard\plain \ltrpar -\s3\ql \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0\pararsid2849436 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid8538722 \line }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2449260 Analyse}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2849436 PlayPBN is just like }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2449260 Analyse}{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid2849436 PlayBin, except for the input format. -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid2849436 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \insrsid2849436 -\par }\pard\plain \ltrpar\s3\qj \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0\pararsid2849436 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid2849436\charrsid2849436 The }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2849436 function returns a list of double-dummy values after each specific played card in a hand. Since the function uses }{\field{\*\fldinst {\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\ul\cf19\insrsid2849436\charrsid2849436 REF SolveBoard \\h }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\ul\cf19\insrsid2849436\charrsid2849436 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000b00000053006f006c007600650042006f006100720064000000006900c60064001800dc046f0018007600884802000000000063000000000000000000000000000000a2000000001500}}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\ul\cf19\insrsid2849436\charrsid2849436 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \f37\ul\cf19\insrsid16012515\charrsid16012515 SolveBoard}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid2849436 , the same comments apply concerning the thread number \'93thrId\'94 and the transposition tables.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2849436\charrsid2849436 -\par }\pard\plain \ltrpar\s25\ql \li0\ri0\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid2849436 \rtlch\fcs1 \af0\afs22\alang1025 \ltrch\fcs0 \f37\fs22\lang1031\langfe1033\cgrid\langnp1031\langfenp1033 {\rtlch\fcs1 \af0 -\ltrch\fcs0 \lang1033\langfe1033\langnp1033\insrsid2849436 -\par }\pard\plain \ltrpar\s3\qj \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0\pararsid2849436 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid2849436 As an example, let us}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2849436\charrsid2849436 say the DD result in a given contract is 9 tricks for declarer. The }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2849436 play }{ -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2849436\charrsid2849436 consists of t}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2849436 he first trick}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2849436\charrsid2849436 -, two cards from the second trick, and then declarer claims. The lead and declarer\rquote s play to the second trick (he wins the first trick) are sub-optimal. Then the trace would look like this, assuming each sub-optimal costs 1 trick: -\par -\par 9 10 10 10 10 9 9 -\par -\par The number of tricks are always seen from declarer\rquote s viewpoint (he is the one to the right of the opening leader). There is one more result in the trace than there are cards played, b -ecause there is a DD value before any card is played, and one DD value after each card played. -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid11279197 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid2849436 - -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid1190356 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14119459 -\par \ltrrow}\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid1190356\yts20 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1031\cgrid\langnp1033\langfenp1031 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\b\f37\insrsid2449260 {\*\bkmkstart TraceAllPlaysBin}Analyse}{\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\insrsid2849436\charrsid2849436 AllPlaysBin}{\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\lang1033\langfe1053\langfenp1053\insrsid2849436 {\*\bkmkend TraceAllPlaysBin} - -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid5979431\yts20 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid5979431\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid5979431\charrsid14119459 REF boards \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5979431\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000700000062006f0061007200640073000000001eff0000cc000200040056002d000000a192060000000000ac0000000000000000000000180000348c000000001800}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid5979431\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 boards}}}\sectd \ltrsect -\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid5979431\charrsid14119459 *bop, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid5979431\charrsid14119459 -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid5979431\charrsid14119459 REF playTracesBin \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5979431\charrsid14119459 -{\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000e00000070006c0061007900540072006100630065007300420069006e000000000000460000ff0000000030ef72002e0000f40000000000540000000060000000000000800006ad000000400000008f}}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid5979431\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 playTracesBin -}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid5979431\charrsid14119459 *plp, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid5979431\charrsid14119459 - -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid5979431\charrsid14119459 REF solvedPlays \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5979431\charrsid14119459 -{\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000c00000073006f006c0076006500640050006c006100790073000000b46f006d00720043000400c40000006000000000000000000e000000001a000000000000840000850000007400000015}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid5979431\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 solvedPlays}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid5979431\charrsid14119459 *solvedp, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid5979431\charrsid14119459 - -\par int chunkSize}{\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\lang1033\langfe1053\langfenp1053\insrsid5979431\charrsid2849436 \cell }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid1190356\yts20 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\b\f37\insrsid2449260 {\*\bkmkstart TraceAllPlaysPBN}Analyse}{\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\insrsid2849436\charrsid2849436 AllPlaysPBN}{\rtlch\fcs1 \af1 \ltrch\fcs0 \b\f37\lang1033\langfe1053\langfenp1053\insrsid2849436\charrsid2849436 -{\*\bkmkend TraceAllPlaysPBN} -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\intbl\wrapdefault\faauto\rin0\lin0\pararsid5979431\yts20 {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid5979431\charrsid14119459 struct }{\field{\*\fldinst {\rtlch\fcs1 -\af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid5979431\charrsid14119459 REF boardsPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5979431\charrsid14119459 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000000a00000062006f006100720064007300500042004e0000000672000a000800720000002540003624000000ff00000f00110001000000000839000000050000a900ff00250000001c}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid5979431\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 boardsPBN}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid5979431\charrsid14119459 *bopPBN, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid5979431\charrsid14119459 - -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid5979431\charrsid14119459 REF playTracesPBN \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5979431\charrsid14119459 -{\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000e00000070006c0061007900540072006100630065007300500042004e00000000ff00000000598b000000254000a375000000000000000014000008000000083b0000000500001d00ff009600000028}}{\rtlch\fcs1 \af2\afs18 -\ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid5979431\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 playTracesPBN -}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid5979431\charrsid14119459 *plpPBN, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid5979431\charrsid14119459 - -\par struct }{\field{\*\fldinst {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid5979431\charrsid14119459 REF solvedPlays \\h }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\insrsid5979431\charrsid14119459 -{\*\datafield 08d0c9ea79f9bace118c8200aa004ba90b02000000080000000c00000073006f006c0076006500640050006c006100790073000000c900004e006e00f00020006404200000000000000000000017830000000000003d0000000000007100ff00c6000000c6}}{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 -\f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid5979431\charrsid14119459 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\ul\cf19\lang1033\langfe1053\langfenp1053\insrsid16012515\charrsid16012515 solvedPlays}}} -\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\insrsid5979431\charrsid14119459 *solvedp, }{\rtlch\fcs1 \af2\afs18 \ltrch\fcs0 \f2\fs18\cf1\lang1033\langfe1053\langfenp1053\insrsid5979431\charrsid14119459 - -\par int chunkSize}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\lang1033\langfe1053\langfenp1053\insrsid2849436 \cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid2849436 \trowd \irow0\irowband0\lastrow \ltrrow -\ts20\trgaph70\trleft-108\trftsWidth1\trftsWidthB3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5979431\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb -\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx4665\clvertalt\clbrdrt\brdrtbl \clbrdrl\brdrtbl \clbrdrb\brdrtbl \clbrdrr\brdrtbl \cltxlrtb\clftsWidth3\clwWidth4773\clshdrawnil \cellx9438\row }\pard \ltrpar -\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid1190356 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid2849436 -\par }\pard\plain \ltrpar\s3\ql \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel2\rin0\lin0\itap0\pararsid5979431 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid5979431 \line }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2449260 Analyse}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid5979431 AllPlaysPBN is just like }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2449260 Analyse}{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid5979431 AllPlaysBin, except for the input format. -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid1190356 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid14119459 - -\par }\pard \ltrpar\qj \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid10376323 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10376323 The }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid2449260 Analyse}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid10376323 AllPlays* functions invoke SolveBoard several times in parallel in multiple threads, rather than sequentially in a single thread. This increases execution speed. Up to 20 boards are permitted per call. -\par -\par Concerning chunkSize, exactly the same remarks apply as with }{\field{\*\fldinst {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\ul\cf19\insrsid10376323\charrsid10376323 REF SolveAllChunksBin \\h }{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\ul\cf19\insrsid10376323\charrsid10376323 {\*\datafield -08d0c9ea79f9bace118c8200aa004ba90b02000000080000001200000053006f006c007600650041006c006c004300680075006e006b007300420069006e0000000000ff0000002e1a02000b00000000a204480000000000001a0f000033da00084000a9e40053001a000000010d0900de}}{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\ul\cf19\insrsid10376323\charrsid10376323 \\* MERGEFORMAT }}{\fldrslt {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \f37\ul\cf19\insrsid16012515\charrsid16012515 SolveAllChunksBin}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid10376323 .}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid10376323 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid1190356 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid490522\charrsid14119459 -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\insrsid6650094\charrsid14119459 -\par }\pard\plain \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel0\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid14119459\charrsid14119459 \page {\*\bkmkstart Return}Return codes{\*\bkmkend Return} -\par -\par \ltrrow}\trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\pard \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid14119459\charrsid14119459 Value\cell }\pard \ltrpar -\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \b\f37\fs22\cf1\insrsid14119459\charrsid14119459 Code\cell Comment\cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow0\irowband0\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid14119459\charrsid14119459 1\cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14119459\charrsid14119459 -RETURN_NO_FAULT\cell \cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 -\ab\af1 \ltrch\fcs0 \b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow1\irowband1\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv -\brdrs\brdrw10 \trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl -\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 -\cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid14119459\charrsid14119459 -1\cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14119459\charrsid14119459 -RETURN_UNKNOWN_FAULT\cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid2449260 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3342996 -Currently happens when fopen() returns an error or when }{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid2449260 Analyse}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3342996 -AllPlaysBin() gets a different number of boards in its first two arguments.}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14119459\charrsid14119459 \cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow2\irowband2\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid14119459\charrsid14119459 -2\cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14119459\charrsid14119459 -RETURN_ZERO_CARDS\cell }{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3342996 SolveBoard(), self-explanatory.}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14119459\charrsid14119459 \cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow3\irowband3\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid14119459\charrsid14119459 -3\cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14119459\charrsid14119459 -RETURN_TARGET_TOO_HIGH\cell }{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3342996 SolveBoard(), target is higher than the number of tricks remaining.}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14119459\charrsid14119459 -\cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow4\irowband4\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid14119459\charrsid14119459 -4\cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14119459\charrsid14119459 -RETURN_DUPLICATE_CARDS\cell }{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3342996 SolveBoard(), self-explanatory.}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14119459\charrsid14119459 \cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow5\irowband5\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid14119459\charrsid14119459 -5\cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14119459\charrsid14119459 -RETURN_TARGET_WRONG_LO\cell }{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3342996 SolveBoard(), target is less than -1.}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14119459\charrsid14119459 \cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow6\irowband6\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid3937665 -7}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14119459\charrsid14119459 \cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 -\ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14119459\charrsid14119459 RETURN_TARGET_WRONG_HI\cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid3342996 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid3342996 SolveBoard(), target is higher than 13.}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14119459\charrsid14119459 \cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow7\irowband7\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid3937665 -8}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14119459\charrsid14119459 \cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 -\ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665 RETURN_SOLNS_WRONG_LO}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid14119459\charrsid14119459 \cell }\pard \ltrpar -\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid3342996 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3342996 SolveBoard(), solutions is less than 1.}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid14119459\charrsid14119459 \cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow8\irowband8\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb -\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid3937665 -9\cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665 RETURN_SOLNS_WRONG_HI\cell -}\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid3342996 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3342996 SolveBoard(), solutions is higher than 3.}{\rtlch\fcs1 \ab\af1\afs22 -\ltrch\fcs0 \f37\fs22\cf1\insrsid3937665\charrsid14119459 \cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow9\irowband9\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb -\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid3937665 -10\cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665 RETURN_TOO_MANY_CARDS\cell }{ -\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3342996 SolveBoard(), self-explanatory.}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665\charrsid14119459 \cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow10\irowband10\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid3937665 -12\cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665 RETURN_SUIT_OR_RANK\cell }{ -\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3342996 SolveBoard(), either currentTrickSuit or currentTrickRank have wrong data.}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665\charrsid14119459 \cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow11\irowband11\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid3937665 -13\cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665 RETURN_PLAYED_CARD\cell }{ -\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3342996 SolveBoard(), card already played is also a card still remaining to play.}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665\charrsid14119459 \cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow12\irowband12\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid3937665 -14\cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665 RETURN_CARD_COUNT\cell }{ -\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3342996 SolveBoard(), wrong number of remaining cards for a hand.}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665\charrsid14119459 \cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow13\irowband13\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid3937665 -15\cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665 RETURN_THREAD_INDEX\cell }{ -\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3342996 SolveBoard(), thread number is less than 0 or higher than the maximum permitted.}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665\charrsid14119459 \cell -}\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow14\irowband14\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid3937665 -98\cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665 RETURN_PLAY_FAULT\cell }{ -\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid2449260 Analyse}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3342996 Play*() family of functions}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid5862788 .}{\rtlch\fcs1 -\ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3342996 (a) Less than 0 or more than 52 cards supplied. (b) Invalid suit or rank supplied. (c) }{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid5862788 -A played card is not held by the right player.}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665\charrsid14119459 \cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 -\rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow15\irowband15\ltrrow\ts11\trgaph70\trleft-108\trbrdrt -\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid3937665 -99\cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665 RETURN_PBN_FAULT\cell }{ -\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid5862788 Returned from a number of places if a PBN string is faulty.}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665\charrsid14119459 \cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow16\irowband16\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid3937665 -101\cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665 RETURN_TOO_MANY_THREADS\cell }{ -\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid5862788 Currently never returned.}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665\charrsid14119459 \cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow17\irowband17\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid3937665 -102\cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665 RETURN_THREAD_CREATE\cell }{ -\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid5862788 Returned from multi-threading functions.}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665\charrsid14119459 \cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow18\irowband18\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid3937665 -103\cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665 RETURN_THREAD_WAIT\cell -}\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid5862788 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid5862788 -Returned from multi-threading functions when something went wrong while waiting for all threads to complete.}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid5862788\charrsid5862788 \cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow19\irowband19\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid3937665 -201\cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665 RETURN_NO_SUIT\cell }{\rtlch\fcs1 -\ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid5054625 CalcAllTables*(), returned when the denomination filter vector has no entries}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665\charrsid14119459 \cell }\pard\plain \ltrpar -\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow20\irowband20\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid6384684 -202}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid3937665 \cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid14119459 {\rtlch\fcs1 \ab\af1\afs22 -\ltrch\fcs0 \f37\fs22\cf1\insrsid3937665 RETURN_TOO_MANY_TABLES\cell }{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid5862788 CalcAllTables*(), returned when too many tables are requested.}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid3937665\charrsid14119459 \cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 -\f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \b\f37\cf1\insrsid3937665\charrsid14119459 \trowd \irow21\irowband21\ltrrow\ts11\trgaph70\trleft-108\trbrdrt\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb -\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row \ltrrow}\pard\plain \ltrpar -\s1\qc \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid6384684 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 -\f37\fs22\cf1\insrsid6384684 -301\cell }\pard \ltrpar\s1\ql \li0\ri0\keepn\nowidctlpar\intbl\wrapdefault\faauto\outlinelevel0\rin0\lin0\pararsid6384684 {\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid6384684 RETURN_CHUNK_SIZE\cell -SolveAllChunks*(), returned when the chunk size is < 1.}{\rtlch\fcs1 \ab\af1\afs22 \ltrch\fcs0 \f37\fs22\cf1\insrsid6384684\charrsid14119459 \cell }\pard\plain \ltrpar\ql \li0\ri0\widctlpar\intbl\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0 -\rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \b\f37\cf1\insrsid6384684\charrsid14119459 \trowd \irow22\irowband22\lastrow \ltrrow\ts11\trgaph70\trleft-108\trbrdrt -\brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 -\trftsWidth1\trftsWidthB3\trftsWidthA3\trautofit1\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblrsid5054625\tbllkhdrrows\tbllkhdrcols\tbllknocolband\tblind0\tblindtype3 \clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb -\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth1101\clshdrawnil \cellx993\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth3260\clshdrawnil \cellx4253 -\clvertalt\clbrdrt\brdrs\brdrw10 \clbrdrl\brdrs\brdrw10 \clbrdrb\brdrs\brdrw10 \clbrdrr\brdrs\brdrw10 \cltxlrtb\clftsWidth3\clwWidth5185\clshdrawnil \cellx9438\row }\pard\plain \ltrpar -\s1\ql \li0\ri0\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel0\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \ab\af1 \ltrch\fcs0 -\b\f37\cf1\insrsid14119459\charrsid14119459 \page }{\rtlch\fcs1 \ab\af1 \ltrch\fcs0 \b\f37\cf1\insrsid6650094\charrsid14119459 Revision History -\par }\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1053\cgrid\langnp1033\langfenp1053 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6650094\charrsid14119459 - -\par Rev A, 2006-02-25.\tab \tab First issue. -\par -\par Rev B, 2006-03-20\tab \tab Updated issue. -\par -\par }\pard \ltrpar\ql \fi-2880\li2880\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin2880\itap0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6650094\charrsid14119459 Rev C, 2006-03-28\tab Updated issue. Addition of the SolveBoard parameter \'94mode\'94. -\par -\par Rev D, 2006-04-05\tab Updated issue. Usage of target=0 to list all cards that are legal to play. -\par -\par Rev E, 2006-05-29\tab Updated issue. New error code \endash 10 for number of cards > 52. -\par -\par Rev F, 2006-08-09\tab Updated issue. New mode parameter value = 2. New error code \endash 11 for calling SolveBoard with mode = 2 and forbidden values of other parameters. -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6650094\charrsid14119459 -\par }\pard \ltrpar\ql \fi-2880\li2880\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin2880\itap0 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6650094\charrsid14119459 Rev F1, 2006-08-14\tab -Clarifications on conditions for returning scores for the different combinations of the values for target and solutions. -\par -\par Rev F2, 2006-08-26\tab New error code \endash 12 for wrongly set valu}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9047914\charrsid14119459 es of deal.currentTrickSuit and }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6650094\charrsid14119459 -deal.currentTrickRank. -\par -\par Rev G, 2007-01-04\tab New DDS release 1.1, otherwise no change compared to isse F2. -\par -\par Rev H, 2007-04-23\tab DDS release 1.4, changes for parameter mode=2. -\par -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6309374\charrsid14119459 Rev I, }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6650094\charrsid14119459 2010-04-10\tab DDS release 2.0, multi-thread support. -\par -\par Rev J, 2010-05-29\tab DDS release 2.1, OpenMP support, reuse of previous DD transposition table results of similar deals. -\par -\par Rev K, 2010-10-27\tab Correction of fault in the description: 2nd index in resTable of the structure ddTableResults is declarer hand. -\par -\par Rev L, 2011-10-14\tab Added SolveBoardPBN and CalcDDtablePBN. -\par -\par Rev M, 2012-07-06\tab Added SolveAllBoards. -\par -\par Rev N, 2012-07-16\tab Max number of threads is 8.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid4538894\charrsid14119459 -\par -\par Rev O, 2012-10-21\tab Max number of threads is }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid4542728\charrsid14119459 configured at initial start-up, but never exceeds 16.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid4538894\charrsid14119459 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13316938\charrsid14119459 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13316938 Rev P, 2013-03-16}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13316938\charrsid13316938 \tab }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13316938 Added functions CalcPar and CalcParPBN}{ -\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13316938\charrsid13316938 .}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13316938 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6950962 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9530285 Rev Q, 2014-01-09}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6950962\charrsid6950962 \tab Added functions Calc}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6950962 AllTables/CalcAllTablesPBN. - -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12595779 -\par Rev R, 2014-01-13\tab Updated }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12595779\charrsid12595779 functions CalcAllTables/CalcAllTablesPBN.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid12595779 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid7089377 -\par Rev S}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid7089377\charrsid7089377 , 2014-01-13\tab Updated functions CalcAllTables/CalcAllTablesPBN.}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid7089377 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10245607 -\par }\pard \ltrpar\ql \fi-2880\li2880\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin2880\itap0\pararsid16724586 {\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10245607 Rev T, 2014-03-01}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10245607\charrsid10245607 \tab -}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10245607 Added function}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid10245607\charrsid10245607 }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13336457 SolveAll}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid10245607 Chunk}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid13336457 s}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid16724586 .}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid6650094 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid16217378 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9572146 Rev U, 2014-09-15}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid16217378 \tab }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9572146 Added functions DealerPar, SidesPar, }{\rtlch\fcs1 \af1 -\ltrch\fcs0 \f37\cf1\insrsid9572146\charrsid9572146 AnalysePlayBin}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9572146 , }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9572146\charrsid9572146 AnalysePlayPBN}{\rtlch\fcs1 \af1 \ltrch\fcs0 -\f37\cf1\insrsid9572146 , }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9572146\charrsid9572146 AnalyseAllPlaysBin}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9572146 , }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9572146\charrsid9572146 -AnalyseAllPlaysPBN}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9572146 .}{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid16217378 -\par }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9572146 \tab }{\rtlch\fcs1 \af1 \ltrch\fcs0 \f37\cf1\insrsid9572146\charrsid16724586 -\par }{\*\themedata 504b030414000600080000002100e9de0fbfff0000001c020000130000005b436f6e74656e745f54797065735d2e786d6cac91cb4ec3301045f748fc83e52d4a -9cb2400825e982c78ec7a27cc0c8992416c9d8b2a755fbf74cd25442a820166c2cd933f79e3be372bd1f07b5c3989ca74aaff2422b24eb1b475da5df374fd9ad -5689811a183c61a50f98f4babebc2837878049899a52a57be670674cb23d8e90721f90a4d2fa3802cb35762680fd800ecd7551dc18eb899138e3c943d7e503b6 -b01d583deee5f99824e290b4ba3f364eac4a430883b3c092d4eca8f946c916422ecab927f52ea42b89a1cd59c254f919b0e85e6535d135a8de20f20b8c12c3b0 -0c895fcf6720192de6bf3b9e89ecdbd6596cbcdd8eb28e7c365ecc4ec1ff1460f53fe813d3cc7f5b7f020000ffff0300504b030414000600080000002100a5d6 -a7e7c0000000360100000b0000005f72656c732f2e72656c73848fcf6ac3300c87ef85bd83d17d51d2c31825762fa590432fa37d00e1287f68221bdb1bebdb4f -c7060abb0884a4eff7a93dfeae8bf9e194e720169aaa06c3e2433fcb68e1763dbf7f82c985a4a725085b787086a37bdbb55fbc50d1a33ccd311ba548b6309512 -0f88d94fbc52ae4264d1c910d24a45db3462247fa791715fd71f989e19e0364cd3f51652d73760ae8fa8c9ffb3c330cc9e4fc17faf2ce545046e37944c69e462 -a1a82fe353bd90a865aad41ed0b5b8f9d6fd010000ffff0300504b0304140006000800000021006b799616830000008a0000001c0000007468656d652f746865 -6d652f7468656d654d616e616765722e786d6c0ccc4d0ac3201040e17da17790d93763bb284562b2cbaebbf600439c1a41c7a0d29fdbd7e5e38337cedf14d59b -4b0d592c9c070d8a65cd2e88b7f07c2ca71ba8da481cc52c6ce1c715e6e97818c9b48d13df49c873517d23d59085adb5dd20d6b52bd521ef2cdd5eb9246a3d8b -4757e8d3f729e245eb2b260a0238fd010000ffff0300504b03041400060008000000210036cc113fa8060000a31b0000160000007468656d652f7468656d652f -7468656d65312e786d6cec594f6f1b4514bf23f11d467b6f6327761a4775aad8b11b48d346b15bd4e37877bc3bcdecce6a669cd437d41e9190100571a012370e -08a8d44a5ccaa709144191fa157833b3bbde89d7246923a8a039b4f6ec6fdefff79b37ebabd7eec70c1d1221294fda5efd72cd4324f1794093b0eddd1ef62fad -79482a9c0498f184b4bd2991deb58df7dfbb8ad755446282607f22d771db8b944ad79796a40fcb585ee62949e0d9988b182bf82ac2a540e023901bb3a5e55a6d -7529c634f1508263107b6b3ca63eb9a460abb791cbee31509028a9177c26065a327136186c7050d70839955d26d021666d0fd404fc6848ee2b0f312c153c687b -35f3e72d6d5c5dc2ebd926a616ec2dedeb9bbf6c5fb6213858363a45382a94d6fb8dd695ad42be0130358febf57add5ebd906700d8f7c1536b4b5966a3bf56ef -e4324b20fb715e76b7d6ac355c7c49feca9ccdad4ea7d36c65b658a106643f36e6f06bb5d5c6e6b28337208b6fcee11b9dcd6e77d5c11b90c5afcee1fb575aab -0d176f4011a3c9c11c5a27b4dfcfa417903167db95f03580afd532f80c05d55054975631e6895a546b31bec7451f001ac8b0a20952d3948cb10f45dcc5f14850 -ac15e075824b4fec922fe796b42e247d4153d5f63e4c3134c44cdeabe7dfbf7afe141d3f7876fce0a7e3870f8f1ffc680539bbb671129677bdfcf6b33f1f7f8c -fe78facdcb475f54e36519ffeb0f9ffcf2f3e7d540689f99392fbe7cf2dbb3272fbefaf4f7ef1e55c037051e95e1431a13896e9223b4cf6370cc44c5b59c8cc4 -f9760c234ccb3b369350e2046b2d15f27b2a72d037a79865d971ece81037827704d04715f0fae49e63f0201213452b34ef44b103dce59c75b8a88cc28ed6550a -f3709284d5cac5a48cdbc7f8b04a7717274e7e7b931478332f4bc7f16e441c33f7184e140e494214d2cff8012115dedda5d489eb2ef505977cacd05d8a3a9856 -866448474e35cd366dd318f232adf219f2edc466f70eea7056e5f516397491d0159855183f24cc09e3753c5138ae1239c4312b07fc065651959183a9f0cbb89e -5490e990308e7a0191b26acf2d01fe9692be8381b12ad3becba6b18b148a1e54c9bc81392f23b7f84137c2715a851dd0242a633f900750a218ed715505dfe56e -87e8ef90079c2c4cf71d4a9c749fce06b769e898342b10fd64222a72799d70a77e075336c6c4500d90bac3d5314dfe8eb81905e6b61a2e8eb8812a5f7cfdb8c2 -eeb795b237e1f4aaea99ed1344bd0877929ebb5c04f4ed67e72d3c49f60834c4fc11f58e9cdf91b3f79f27e745fd7cf1943c636120683d8bd841db8cddf1c2a9 -7b4c191ba8292337a419bc259c3d411f16f53e73e124c52d2c8de0a3ee6450e0e04281cd1e24b8fa88aa6810e11486f6baa7858432131d4a9472099745b35c29 -5be361f057f6aad9d49710cb1c12ab5d1ed8e515bd9cdf350a31c6aad05c6873452b5ac05995ad5cc984826fafa3acae8d3ab3b6ba31cd90a2a3ad705987d85c -ca21e4856bb0584413861a04a310447915aefc5a355c763023818ebbcd519e1693858b4c918c7040b21c69bfe773543749ca6b65ce11ed872d067d713c256a25 -6d2d2df60db49d254965758d05eaf2ecbd4996f20a9e6509a49d6c4796949b9325e8a8edb59acb4d0ff9386d7b63b827c3c73885ac4b3d476216c2bb265f095b -f6a736b3e9f259365bb9636e13d4e1d5878dfb9cc30e0fa442aa2d2c235b1ae65156022cd19aacfdcb4d08eb453950c14667b362650d8ae15fb302e2e8a6968c -c7c457e564975674ececd78c4af9441131888223346213b18f21fdba54c19f804a78dd6118417f8177733adae6914bce59d395df88199c5dc72c8d7046b7ba45 -f34eb6704348850de65bc93cf0add276e3dcf95d312d7f41ae94cbf87fe68a3e4fe0edc34aa033e0c39b618191ee94b6c7858a38b0501a51bf2f607030dc01d5 -02ef77e1311415bc9f36ff0b72a8ffb73d676598b6864ba4daa7211214ce23150942f680964cf59d22ac9e9d5d5624cb04998a2a992b536bf6881c1236d41cb8 -aacf760f4550ea864d321a30b893f5e77ecf3a6814ea21a7dc6f0e931567afed817f7af2b1cd0c4eb93c6c069a3cfe8589c578303b55ed7eb33d3f7bcb8ee807 -b331ab917705282b1d05adaced5fd384731eb596b1e63c5e6ee6c64116e73d86c562204ae11d12d2ffc0f94785cf8829637da00ef93e702b821f2fb430281ba8 -ea4b76f0409a20ede2080627bb688b498bb2a1cd46271db5fcb0bee049b7d07b22d8dab2b3e4fb9cc12e8633579dd38b1719ec2cc24eaceddac25043664fb628 -2c8df38b8c498cf995acfc4b161fdd83446fc16f0613a6a42926f89d4a6098a107a60fa0f9ad46b375e32f000000ffff0300504b030414000600080000002100 -0dd1909fb60000001b010000270000007468656d652f7468656d652f5f72656c732f7468656d654d616e616765722e786d6c2e72656c73848f4d0ac2301484f7 -8277086f6fd3ba109126dd88d0add40384e4350d363f2451eced0dae2c082e8761be9969bb979dc9136332de3168aa1a083ae995719ac16db8ec8e4052164e89 -d93b64b060828e6f37ed1567914b284d262452282e3198720e274a939cd08a54f980ae38a38f56e422a3a641c8bbd048f7757da0f19b017cc524bd62107bd500 -1996509affb3fd381a89672f1f165dfe514173d9850528a2c6cce0239baa4c04ca5bbabac4df000000ffff0300504b01022d0014000600080000002100e9de0f -bfff0000001c0200001300000000000000000000000000000000005b436f6e74656e745f54797065735d2e786d6c504b01022d0014000600080000002100a5d6 -a7e7c0000000360100000b00000000000000000000000000300100005f72656c732f2e72656c73504b01022d00140006000800000021006b799616830000008a -0000001c00000000000000000000000000190200007468656d652f7468656d652f7468656d654d616e616765722e786d6c504b01022d00140006000800000021 -0036cc113fa8060000a31b00001600000000000000000000000000d60200007468656d652f7468656d652f7468656d65312e786d6c504b01022d001400060008 -00000021000dd1909fb60000001b0100002700000000000000000000000000b20900007468656d652f7468656d652f5f72656c732f7468656d654d616e616765722e786d6c2e72656c73504b050600000000050005005d010000ad0a00000000} -{\*\colorschememapping 3c3f786d6c2076657273696f6e3d22312e302220656e636f64696e673d225554462d3822207374616e64616c6f6e653d22796573223f3e0d0a3c613a636c724d -617020786d6c6e733a613d22687474703a2f2f736368656d61732e6f70656e786d6c666f726d6174732e6f72672f64726177696e676d6c2f323030362f6d6169 -6e22206267313d226c743122207478313d22646b3122206267323d226c743222207478323d22646b322220616363656e74313d22616363656e74312220616363 -656e74323d22616363656e74322220616363656e74333d22616363656e74332220616363656e74343d22616363656e74342220616363656e74353d22616363656e74352220616363656e74363d22616363656e74362220686c696e6b3d22686c696e6b2220666f6c486c696e6b3d22666f6c486c696e6b222f3e} -{\*\latentstyles\lsdstimax371\lsdlockeddef0\lsdsemihiddendef0\lsdunhideuseddef0\lsdqformatdef0\lsdprioritydef99{\lsdlockedexcept \lsdqformat1 \lsdpriority0 \lsdlocked0 Normal;\lsdqformat1 \lsdlocked0 heading 1;\lsdqformat1 \lsdlocked0 heading 2; -\lsdqformat1 \lsdlocked0 heading 3;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 4;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 5; -\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 6;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 7;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 8; -\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 9;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 1;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 2; -\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 3;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 4;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 5; -\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 6;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 7;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 8; -\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 9;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority35 \lsdlocked0 caption;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Number;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List 4; -\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List 5;\lsdqformat1 \lsdpriority10 \lsdlocked0 Title;\lsdsemihidden1 \lsdunhideused1 \lsdpriority1 \lsdlocked0 Default Paragraph Font;\lsdqformat1 \lsdpriority11 \lsdlocked0 Subtitle; -\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Salutation;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Date;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text First Indent;\lsdqformat1 \lsdpriority22 \lsdlocked0 Strong; -\lsdqformat1 \lsdpriority20 \lsdlocked0 Emphasis;\lsdpriority59 \lsdlocked0 Table Grid;\lsdsemihidden1 \lsdlocked0 Placeholder Text;\lsdqformat1 \lsdpriority1 \lsdlocked0 No Spacing;\lsdpriority60 \lsdlocked0 Light Shading; -\lsdpriority61 \lsdlocked0 Light List;\lsdpriority62 \lsdlocked0 Light Grid;\lsdpriority63 \lsdlocked0 Medium Shading 1;\lsdpriority64 \lsdlocked0 Medium Shading 2;\lsdpriority65 \lsdlocked0 Medium List 1;\lsdpriority66 \lsdlocked0 Medium List 2; -\lsdpriority67 \lsdlocked0 Medium Grid 1;\lsdpriority68 \lsdlocked0 Medium Grid 2;\lsdpriority69 \lsdlocked0 Medium Grid 3;\lsdpriority70 \lsdlocked0 Dark List;\lsdpriority71 \lsdlocked0 Colorful Shading;\lsdpriority72 \lsdlocked0 Colorful List; -\lsdpriority73 \lsdlocked0 Colorful Grid;\lsdpriority60 \lsdlocked0 Light Shading Accent 1;\lsdpriority61 \lsdlocked0 Light List Accent 1;\lsdpriority62 \lsdlocked0 Light Grid Accent 1;\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 1; -\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 1;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 1;\lsdsemihidden1 \lsdlocked0 Revision;\lsdqformat1 \lsdpriority34 \lsdlocked0 List Paragraph;\lsdqformat1 \lsdpriority29 \lsdlocked0 Quote; -\lsdqformat1 \lsdpriority30 \lsdlocked0 Intense Quote;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 1;\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 1;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 1;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 1; -\lsdpriority70 \lsdlocked0 Dark List Accent 1;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 1;\lsdpriority72 \lsdlocked0 Colorful List Accent 1;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 1;\lsdpriority60 \lsdlocked0 Light Shading Accent 2; -\lsdpriority61 \lsdlocked0 Light List Accent 2;\lsdpriority62 \lsdlocked0 Light Grid Accent 2;\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 2;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 2;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 2; -\lsdpriority66 \lsdlocked0 Medium List 2 Accent 2;\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 2;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 2;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 2;\lsdpriority70 \lsdlocked0 Dark List Accent 2; -\lsdpriority71 \lsdlocked0 Colorful Shading Accent 2;\lsdpriority72 \lsdlocked0 Colorful List Accent 2;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 2;\lsdpriority60 \lsdlocked0 Light Shading Accent 3;\lsdpriority61 \lsdlocked0 Light List Accent 3; -\lsdpriority62 \lsdlocked0 Light Grid Accent 3;\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 3;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 3;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 3;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 3; -\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 3;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 3;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 3;\lsdpriority70 \lsdlocked0 Dark List Accent 3;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 3; -\lsdpriority72 \lsdlocked0 Colorful List Accent 3;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 3;\lsdpriority60 \lsdlocked0 Light Shading Accent 4;\lsdpriority61 \lsdlocked0 Light List Accent 4;\lsdpriority62 \lsdlocked0 Light Grid Accent 4; -\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 4;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 4;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 4;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 4; -\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 4;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 4;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 4;\lsdpriority70 \lsdlocked0 Dark List Accent 4;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 4; -\lsdpriority72 \lsdlocked0 Colorful List Accent 4;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 4;\lsdpriority60 \lsdlocked0 Light Shading Accent 5;\lsdpriority61 \lsdlocked0 Light List Accent 5;\lsdpriority62 \lsdlocked0 Light Grid Accent 5; -\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 5;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 5;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 5;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 5; -\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 5;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 5;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 5;\lsdpriority70 \lsdlocked0 Dark List Accent 5;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 5; -\lsdpriority72 \lsdlocked0 Colorful List Accent 5;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 5;\lsdpriority60 \lsdlocked0 Light Shading Accent 6;\lsdpriority61 \lsdlocked0 Light List Accent 6;\lsdpriority62 \lsdlocked0 Light Grid Accent 6; -\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 6;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 6;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 6;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 6; -\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 6;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 6;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 6;\lsdpriority70 \lsdlocked0 Dark List Accent 6;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 6; -\lsdpriority72 \lsdlocked0 Colorful List Accent 6;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 6;\lsdqformat1 \lsdpriority19 \lsdlocked0 Subtle Emphasis;\lsdqformat1 \lsdpriority21 \lsdlocked0 Intense Emphasis; -\lsdqformat1 \lsdpriority31 \lsdlocked0 Subtle Reference;\lsdqformat1 \lsdpriority32 \lsdlocked0 Intense Reference;\lsdqformat1 \lsdpriority33 \lsdlocked0 Book Title;\lsdsemihidden1 \lsdunhideused1 \lsdpriority37 \lsdlocked0 Bibliography; -\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority39 \lsdlocked0 TOC Heading;\lsdpriority41 \lsdlocked0 Plain Table 1;\lsdpriority42 \lsdlocked0 Plain Table 2;\lsdpriority43 \lsdlocked0 Plain Table 3;\lsdpriority44 \lsdlocked0 Plain Table 4; -\lsdpriority45 \lsdlocked0 Plain Table 5;\lsdpriority40 \lsdlocked0 Grid Table Light;\lsdpriority46 \lsdlocked0 Grid Table 1 Light;\lsdpriority47 \lsdlocked0 Grid Table 2;\lsdpriority48 \lsdlocked0 Grid Table 3;\lsdpriority49 \lsdlocked0 Grid Table 4; -\lsdpriority50 \lsdlocked0 Grid Table 5 Dark;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 1;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 1; -\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 1;\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 1;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 1;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 1; -\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 1;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 2;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 2;\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 2; -\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 2;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 2;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 2;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 2; -\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 3;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 3;\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 3;\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 3; -\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 3;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 3;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 3;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 4; -\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 4;\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 4;\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 4;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 4; -\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 4;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 4;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 5;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 5; -\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 5;\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 5;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 5;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 5; -\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 5;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 6;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 6;\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 6; -\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 6;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 6;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 6;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 6; -\lsdpriority46 \lsdlocked0 List Table 1 Light;\lsdpriority47 \lsdlocked0 List Table 2;\lsdpriority48 \lsdlocked0 List Table 3;\lsdpriority49 \lsdlocked0 List Table 4;\lsdpriority50 \lsdlocked0 List Table 5 Dark; -\lsdpriority51 \lsdlocked0 List Table 6 Colorful;\lsdpriority52 \lsdlocked0 List Table 7 Colorful;\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 1;\lsdpriority47 \lsdlocked0 List Table 2 Accent 1;\lsdpriority48 \lsdlocked0 List Table 3 Accent 1; -\lsdpriority49 \lsdlocked0 List Table 4 Accent 1;\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 1;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 1;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 1; -\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 2;\lsdpriority47 \lsdlocked0 List Table 2 Accent 2;\lsdpriority48 \lsdlocked0 List Table 3 Accent 2;\lsdpriority49 \lsdlocked0 List Table 4 Accent 2; -\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 2;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 2;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 2;\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 3; -\lsdpriority47 \lsdlocked0 List Table 2 Accent 3;\lsdpriority48 \lsdlocked0 List Table 3 Accent 3;\lsdpriority49 \lsdlocked0 List Table 4 Accent 3;\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 3; -\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 3;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 3;\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 4;\lsdpriority47 \lsdlocked0 List Table 2 Accent 4; -\lsdpriority48 \lsdlocked0 List Table 3 Accent 4;\lsdpriority49 \lsdlocked0 List Table 4 Accent 4;\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 4;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 4; -\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 4;\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 5;\lsdpriority47 \lsdlocked0 List Table 2 Accent 5;\lsdpriority48 \lsdlocked0 List Table 3 Accent 5; -\lsdpriority49 \lsdlocked0 List Table 4 Accent 5;\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 5;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 5;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 5; -\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 6;\lsdpriority47 \lsdlocked0 List Table 2 Accent 6;\lsdpriority48 \lsdlocked0 List Table 3 Accent 6;\lsdpriority49 \lsdlocked0 List Table 4 Accent 6; -\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 6;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 6;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 6;}}{\*\datastore 010500000200000018000000 -4d73786d6c322e534158584d4c5265616465722e362e3000000000000000000000060000 -d0cf11e0a1b11ae1000000000000000000000000000000003e000300feff090006000000000000000000000001000000010000000000000000100000feffffff00000000feffffff0000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff -ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff -ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff -ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff -fffffffffffffffffdfffffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff -ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff -ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff -ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff -ffffffffffffffffffffffffffffffff52006f006f007400200045006e00740072007900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016000500ffffffffffffffffffffffff0c6ad98892f1d411a65f0040963251e50000000000000000000000000067 -583aafd0cf01feffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000 -00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff0000000000000000000000000000000000000000000000000000 -000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff000000000000000000000000000000000000000000000000 -0000000000000000000000000000000000000000000000000105000000000000}} \ No newline at end of file diff --git a/DLL-dds_270_v.rtf b/DLL-dds_270_v.rtf new file mode 100644 index 0000000000000000000000000000000000000000..aba3b02fa5c2f12748e35dea7742be0c2103df79 GIT binary patch literal 58941 zcmeFX^LHiDw=WuYoQ~~|?T&359oy*GPCB-2n;qNEj%^z|PG0(Z#vSjzckX|1Zv9Ye z)TmXp$J}$y^+7EKX>bTMkZ&N+ARr*bATIld9%-N;Aazh6AgCbFU|PaB_qc0^6GdmsR(8u{Gno>+$<3J|*Jfuty$uro!gZ9;(*_Hl2(I+uk6 zlk#ou1ZJ^q1L!9K?hRs{$c>D_=zbQpo8m?xal*?LdUQoo9I&Oy|Tve0&a& zFyrBvDdxPLsB?{ztcnoc3A6aD+pqQ7;Rccv+)>2jwrIZ#pK%B@eINTFNi`N2p@|+o zjq@$;DKvGm2laqj1b9#aXF)}swb?GtHhb1?SX<^Y)Ldz4XoL96f1ix(x z+XvQ^zb=J^E;gobvtDOFJ0+!JVzpVfA&#^BV{V9tbq3tDS=} z!+$l2v7M2#%@_FnL%sjiFrZ)1_ci-}_EDKMDc8@46m%ugA-vD+GB>BB0MG>~gQ8a; zt(L2QR!ndSJZ~CyuLh} z4uJ`yuxQc*rC#*b9_+qYe!w=7dX6NjT7jJfkeiYzz7hpVN}Ct%ltVVkI~3tcy37Zg zo3zD2hALvo1rvDG4yKvaju{rKr)_j^wpZzDwXS+b)m`o0sEZ50v2*0itZzK?y+IoNd@;!3o z)ei{|0TCYzX1opaTO$XxscES`9VhAIqIT}6B&StDp5$+jBF0Fa^Q2iwT$f9o&Eic zfzurn0);4uR3d(1R#8JcUOPqmQTy$Lzl&b>J`#Vaw(1dc%;XHrz{>V4a0AxV!+65@puGQaqDdt z9qQ6YwHmbp16?^=QtU4NKp91EbuCAKsM%1_0hh+=j+UKAUx(5kDqAr>?8i4|&(WJl z2BFq8EeW1ac)D~frvM%gyx87F?n4ud2vf){%U2AG(GOFEyRY^__i?UXLLbC# zeWQ1}A0q?9Af9_#P#MOE%?I?63*RF13*sUo^ka``iLz5n?YG9IPVmG7!wNcM`%Qaz z087up(h1W%o+3p_fh10$*I_)$q1`O0qe?85lM!%vzz0kWrqZ;*$ z*~mSy*I5tP;e47`zdA1xaY4tJjEM~)tvK|*ncc59v-S8krt#Rw@x%enA}cSu=@OY~ zRo!!Yu$>)0P^7!PeFYEaF7!6mwINFQxbOE1x6~J0+#CW38=Fobk&!c5YAvYui)R`gYOD_2FZ>8W?yum z0R9NuD=q78PTBy9jrgp{@oPk%g7q|@D9Y|xZrHh>>hBK@4jhWx?VZOHYOb3!JEA#LEmpU;6iLdTFnbFWZwp5J;lCFnKe=5J zo+}qt$IU2^rb|-49qdacCr*-xETG0f6TSLFlTGZ;_phe2$b+<=EsVMFRQ~7}N>gw_ zZ{j~uM~v+(zICkErPrG^8z$#ZKAvI^`x81p{^5hqrs7ex!|_;tV`tWnrZ-)-o%|yp z9>b%3J=n*V&U>4cG9|X8l^IdJ-{%rL#v?(HL9rv63n1CTD#pqC0W_jrd26L$Ht7nK zD&!m(W0DoI%{0my!8AoLg26%*hWKN_xNJ2{B>j%+6V`{!&+WQbQhyNjYGtqXkd*U! zmfFSaKu@mN?Xg@p0~tsB`H~WSRNUToXXgZ9O;(Bbk%lM}ul}1YS67c<|9synQl_zm zVtgK%md57+zzc&grxbt z$Pt5Zqkp;=ES7Wk*+!xL{9zbEh(PmKIdcUk`Hb^X2dl1gT0H|Y@RlP`|p_!=PB;@H5{&jJ52y31Io!Nh5h z7e_gS`bvIEle(i>>J&VcLuMm zMn%&fH|mJgcmTrCp<~DG$f_7i|6Hbeq0uC14-SO0@g&jhP@F-hAkOoe)-ruG&yD*% z)sBlt@^-d-Iy9rq=Fj_BD+U-FYfH7g8slOoKf2uHRho3EbF#`)TBY&4!w_?R- z(>qe5&37<;?g)VlhZV`pe+_1rE)Gz-NyZ#T!9}(W9$tAxK}I6M2L(y6%zV7J+ag() zQtddpiQiZ*fq(FkHALaF;t1YSnSjfsC>T+AE9nI+D=p8G2N}}7CS3b`o8x~Vt?o8J zWS;>uNI$V=0}N{nWpn_X3P~q)p-Kzgu1!#xY(=w;&Hx-$fsUVsxARJ#`KPPbpc!fq(|rBX`Y<1g$MjkseOv%xLk847wsx6?UZng zo$FWlP|&c`nwZ4L)8FnSGsIRx4Y+9k$dsA;Q0)`=hgZanjd=~^?M zW;2&(j(zkRVPQ4*{SpJps5Edh<+Mt>qACiRyCsG7bWj%a71Uw^>*c-W(*Xuhl|r-c z5iPbCI^dnlX}BxIai2^}?aEy>wUCA&vpbQ>>Md*faSjEZCSG2!LNhleVg{?)fHdEF zD)XwU(a|ORi`U~&#SdAp$dFwsJJZIX4NXcXVHU)7!D?J|KkV6f_Xbw4{`N;Ve+-|F zscbEq;;##-{bSw+*!}=~&+1vr9`rbM?U2EeclJ@P8w$eAa1DwZ8lemgXYk#1>9b8S z;6#CxbqH@h%gic^%$|DjUFsMdjhmbGg#1rYgj(7VJ9$sxrYDThA6Oq5qx);8qMU|? zy`qj$Bv`z2Rm#R2Rb|zJU6crgTE)i7YyDHIkZ$|U-_d^y13Hd+NJXuu#|rC~u11yz zocZu*Hgr>OqD@YX)Ppe8P6VFL$~F6_(}XQ5{i?|cO71b!<(3v5vSLp|cUzcSOf9$% zaMG7Pbx|o=4Yjp1xZCo*=C8&!$>2yF9xz-p>#rAZ@6p-X!=KH)c$cF=pewN8PWVuY zjLITH!*R0b^f{4spMF?%W+GRF)uN>ESJqA}-O^$V-e#u3)ogWH{BHH`3LcJlEK_bZ zaoUHkp%xa!FOy6kX_0xOiCPj#U8dR_T=j4e_tB?}0FtE+Yc;GM<*8wwj4#fU(Z

yepMFyhFB1s?`f(>wg1(YPyqJy-YYrDW6jodLu=nGv z5*7OI?^FG^xGIZV&x`m6IS4Z6_G8l@jk?5v9qPVKjYSNqKU=Z%(9Vza$(odCeMGIv z@Sp;gh#sKcr&#OqyNpMoEBxn&kMZrz7JkmAbr=zbW$mD<*9 zw5MgFm!cV+iAP+DdWj-FlpWzL;D`JPeZMgH)8S(<@%+{RE`=(JuQDsxYZ@${sFp6y z-Ndz@m1xU{ut~Isq9>LY${Pzg=a=4XhS-Q|cGPRH-HabUk!o>b6Fr`n<}J-Dxjj$~ zO~(e6FlC=f$@boa4B6M+Dn$gAO{H$xWt?JGRsgj3FfHCFyD`FDWl5O}`DK=|(2mN0 z3d%t{&AgMWXSYg-DBMm0tNG^gZN+{DAHk3gJoI(^lX1d~B@;7;rWIH~ka_k3fG3P) zrWBn-NfDRb3^7b?@X)V9>ZUT^6wIVbw>NslEemNa#8G8QX&!F}u}_k6M!}9%2$uP& zoPfx6fq3=k$=4)YEE1!n$-CQ{i#L%-&>K&KCCZ_6Dn4rV9gAGjA*xmp6~P z=FWoYs?rnVOtkgg4T$+n3=NN!0y!f5*DU2vRFOgQU!_8|Lo-e~265{2TS~mt?nUv8 zx{Fk^2XfK4LjkWp?zyr?IjnV-o?;)#2i`Ru>$759v^tf_HI!WExkvy;a8`YZ4DU&7 z>O~cZQ#O+)9VU3_Vt2B0L{@4hDuHixhK+^oL*MKYl!~Ec(k2{a@#%`S+*)kg@ZA6= z@)Gb$^GOwaLdC#wncc~68Y@#QHteyZH=WtcT#g1;(U3liEeA8X4$JxLeo`PLK1Gtv z=7ncjHSqzvKn0pvRGML*Vt>AF<-bd!*H7g9^qPh-CsTI)JX#wV-q!rpfE_v#x)R*%@04|jwV#dSVbi9UU z$9%JRRwM+fX#AU$kVr|DFv$tarUmDsN@9#CzJqs7Efq%N;tDP%J*w@FDy|E7rTVx9 z_2i10=)qf%#OtRXVPa<+`CGR~2X-V8w=6WhJ~QT%%LElI09CsevqRegLkC^6Uvp&o zL}|93K(a(XOz(>zTB99tfLq~FV2osMNq2`5< z13N5Mg-ql@*hPumWP~2_>dYFL;Z||Kq`2yE)f^GG6JRH8ON5hTG4Xx8t56-oW14>@ z5t6Nu^=^T;GOZ(Wf}RIS{I?ULZZt)`SM!s#WzG4kbKKUz1A;HAZ)!Gd2B(dj86AY4 zeI_~{JKakamAog4V0S$pVHzqE?~|NNIMaP8-D9GRd>cTJj0}L7v0hE(u2x=$(yD(2 zyGPkQHO+t)wt&OaAdj=JFs0;$KKxm0YEKQ^StTWIenvDS;*-j8cxx#4EWsO-G(^y1>|N&Lz39ytBRa(A^KhsliRP34=|jJ3-^nj+p@U^HyfZ5?h7 zbolJ=+b?-NdyPPR4P-E7N6avHB0}YN6U`xeyIQ%&#SYGPi5wQ)QO6DX#`R&pzNZ(? zD+eiq_s()hvE~DNvV~ngygZe!l@S{ohPLP%@Ug0mw|3}ZAzBSZu}qizZXjZ;`*a5P zS!8{PR6q7TIuF24I2sq}kF{5-o&^f^)5l}xj4V@a6?Uz%&bwvo>W~3`b5GF)5!1!9 z(y6Ao1#|!t$jgnn(tk4f+|38=n6t9r-zP&ib@if7=hos|0L^Tl+_X;x2Wh6t#=%lt zAU;I~og+dSlxpm9me`{xG1DGti#=fbda>uXOoF`DPQVp&MpjoJ@73+is=B(-Fzdu~ zPGgh(ju~5=AIq@fca%gR$vNhYrn*3bGzwNdSJzn>!J3tS-*bgPTo%_Ho$LAC>PxZp zAif0Y<)_BvWVPQYOBNot3~?6{U0=kKaI_%GJss|arAi3chqhY&(^TS*pKWHOIXmM0 zu$PI@+Pj2ql>+o+UXGqDQ9gB#DUd?lUVr#D*FWr8-k*Vc*V!jULZOLVcQvi+>qY{QPalo;YQOowVKkr0$0Mjey_iM@j*5 zLS%wdM?~RU_$1GQ2f2e6@3d{lQl}-=#pF+ZoZ`!(egOhFKbI%U{8utzHKUY3H;g`a zI`FY8SxkQ>7Gf~p4L0p!+l=V71Q%d+@>p-%;^dQ@s%^hNI{Eh)9M+o}&X{G-hKF~W z+@{Dz7aPaP(-^;XS)#|e#hb-wGa@H&-jlj~#5O9JaAu#IMyEG6|Jr+*K~*Ki zW)8;(SF}K~B$+H@@-k_c0j+v;B5RmICB?o&y{iKhcI3j-vPl=Vn=1s(}dN92B&_N@+jg6mZF z)$MK8uB8>us3)_<<8%LuwW1dG7fAe0MIB9kSg;0mvY_%vHU?Ai)z$q=m4Qo%zF-sH z+~aIB#({=HBznq(LL_8kh#@VJtLzBEpvJZW;HMB12AYu|liH6INHin16re(+YQ--6 zXccDZ-?1M3N$TqAM~Iesd%gGbJL~L;;n<@}v_4eTn z-)Mb~Jo#JyPH;rqX&BLHDT1gD(K~CT ze>NOMre$p1Bqv8bJxs@f{J~XT>0H8ibvZg|kymlr8F9)tyr=BiG!lRIPN=?7i*2{$ z?^CWY@`))U!O;-~*?|({p?}xyBr|!{D4!Nh4~8GVhM&C0<&K?Y1BiU_kdu_-xG%rt zQ2)^55OV#OHr1eM8cck%zp83d%5R7+e%(QWS}Zj-o*^T! z5#9az44&PdILp3ulIU6_V@i|gDqqXb)QI`6+LFwDrFA8g%@0*?qBp5;MFeF%9Hx zoihw~K|v~tbAuCJ;Rvm$@mXHG(O-4`g*UCspx#S1Ysu+c|I|Z{MB#a?^^OB1VSw?W z8!=|%m&Sgb0nk6i-}VXdGA5#D&)4%T;mo(bX82od z)P8YUbyi_3u-+R0ncq#ZzD0;^QUOiHx~e z(~=+cbAv!Ee$_-#z&WL{c!M-cjJX0N_S{QNB)PiT<%t5M<{Z}_ly@-MUSMdTzoVfL zp;BYof&(J74!BT?>M#r`)DdJRW?dF0TSy}~L?QIERMpP{RNe~1oxCnm_sXmniuv75CjetUFPWW)DmOQ;k47Hn*v0hyG}?H zbsIvIvE$DagM=LL4x zHukWBza&o6?II8lfgIJv*6cVL-Hh!t3Kw%J7w&S!yh0)f_F~xgeBAdWURhg*oSiVX z0}SS_r)?_b8^@lauO$1cFcf+aFRYE2fR=3@&gs6WT;YnW?MzyDolQNVQ($r3!yEhT z9myHMg*^}A!6>IcFF$3bZPw*C*Ld_axU+Q9o_9Se3n+QRKs)rrf>)R2pvlJzf@z3- zgg`JJT%?A_W$hnLeaLyf%b9fyGM%uiyt!A_n~}z zso9-Srh~EhqtC>5l9Z^akpOREl%(FSSg3VohbnzTzc9tTFk}^ZaFX&ICQC_+IC+sk9?=32A6fW|zVkMDDY zw!&nY#RjD4Pg<++_&*~+BhZKsG^R;{C0(0KuMz5ADf_#D%J;qAY4;x zP%m1R`k`EZ93`MilaNLSWk_TMb(Rw*frqU5Hb6k5L9eJTvJXSV|N z)|jo@j}Se!8Q_rxOExYa(3^53FB=LYQMWR(nWML+mM8d=0w)KYC~jF-k>dk;4;`C&Z=#i-UmAcR7nildBEjr5S%U1@nb4Eib zLq;O3L`6Xw*bcMO{z9qLyo0PF*o1Iv#UAfr)ShOrq3DqpLv}vu zOy@{_fC3txh4njfkrLowt$lOxL=S?N0&kDD(#0C}Hte|_t`baKNS$C!t!h|+ElduX zCo7>G+lLL^Ev7#ZRzi!9rzLbGOw0#4q)%(Dxr!_@K&hE+I6+Lc>+%jXwffHav}M(w zm%&4q<#H2s<903IgzD-o+s4bLi0qwKjdkq5g+7&CSD)WJOm%_#mT>gtFm2)L*wxV} z9a!#a070v;ITE}3Af`rY=Q!z;6cNXFNSTfe)*E^qc@gGOu#1)_lo3+j43gZg6G7up zRCYM9owzP=Kf_~CiGNUH3+}X7+$6Lq<9iRo!QKwy=zA}v&QUdeuJ{9D($7qw;?&TOpamgHBXZym5d&;1mQIE^MHF&6cGDEU*KYiq|0NY91nu~w|?nt=2GD%tN|0}4C`r1%h^ zK$y8=NYJ6?he-UZ%|m!etNLPE4IP0Q0TBT{t6isHjBSRI9fp~1xIYj*I!IGGsQ{^- ztJ3cp0{b}t-s7$NlAk**>^;pB&2(jl^a4GOTu@To8)+e0r2c*@5FO9ubm}6LE8j;7 z*nsN@0^g%M*WKU-U^-+fg#-r<=P$|=VDSP69(BvI4CG}EQ!Lsyl>4IeB6Z%7 z9cm+%H-#om<(|)`X6m&1F01Lt!>)zjq(tBB4I@C<9biT;YvbV99eTy8Nka{Os3V-T zb;eb||COt>b%4NfNNu`JLv@1z_uNc-dpiDE+Ys5+?)!+4zJ!CuzI#{Q@6<){9&jisv zz$e#um<~f$IXAag-VT z<`>cPv&C(dVPX|3Sd=A%Nyg?@=Y8g-8|jH~c0>=TyE?;Z&c7RStH<=#C5v&-eDq3X zWOGC(aQZTR?bdImBx{x|z85#`8fuPY_6I$bDPs>TWYqqH6PWh0Uv!pTQbF}Y^x?&6 zHMrGwZ5)a0r|C0}(QB;t6Qk7X-y1{8`>UCw)rAjR&J4QEbx{aZ+J8-yqDSk7-C_EL zx;8&Y>MSx_nnF$Hllv%BW#bB_7d708&=zo}6&Fl4kli`WWn8Z4s-w829E)R~q(WzK z&gOV57A|B=8Iy`MwEi@|K&fmHY99>(Y#Z22^7c2+jA^$YHynE1(d8EtF5dGOG6;HX z2M!4YOD!u!s+I=*(^V>cJ_OzYh8o!J?RkT>K{)`lqC{gpS6*v1cLjSCDL9A+l{^BB zQv;SW12{|H(U~uiG`k(Y49}fMHJ`%HN5gC|4NKGV84V{igbab9J$QfcY4W=vFxvA? zx^9@0MP!zr#kbxD2kz)?<;$%jfFFLawXsy6$tgbk{QtXkg_<7!C+74wy#2I^^Y0BH z@RDe!aZc?G9j#mI0y2W~mcZYteL>MzViP$tvfRWc7$Ko5dGKC7VX^^QrO82R*@1{2 z+NJg*Ep#9*u!#bw(OZ7iMnWQAdbmk!#-FizHc}hD**b_aXY#I%Yd_7~rI-C>?t1rw(bcCL2kQuca_W#G>Y5)J!e2tz2NGn108KT>!yqF1-t+ z%#5Y_76EFb0kHUOs7TuL;Dj|tf#-rE3?D|!C^YB=CkofcHW50ZWj-C%3B858*-fKf zC%%@GnZEeU%BapecC+u9X|pIPAu*eC#nj&|l|F=&nzf6tA2~ockdBY3(a)^@@WT4;0;zX)5E|CRium#q|JFlpQ;#r^{TR=>_*Z7wh({bsNjTH&wN}F&yTUP`i||kgNJSb-hG}sbGy5ZA@5C z&cgYAS0r&_a}i{v)9T~wIx$q(lo_1}p@msyR#;x$?pw?^z!|MwTy~ya9$Tyo6;}>r zxKYoRt+no{2OTeVPmaP>dqPKC@Y7NLRGnS#Tbyu1&|p(o!O4agFLsb>7+ZWcwBg;r z?lxuJla`eda<*a`6E2xOJ^q($KQyAfVzNcoT1$~cu1)W$)~^gDP_X| z7&s&oB7_->y6OxLWW)b5JV>Gmp3a0=XC#GfOsRCi=1u=u9#$+dr<|}&X>2Z@dF%~h zNOo#gIP*%(O!KDylHK(+ekHqfQl@m0Ctn&f(QMIImbHP$Q9gpcbf(fhn7r{Atl$t# z3L8hK5avQ$83C8lGH3}E=lyz^sE3E?Tl(n}uZmM=i zB!o-WoffwgATvnlL>x>adn|+l3DXu!z_*awLE*~J%*h=`O=l7hEE4$K*DTlhQW3fr zr(4-Z_~9p3WHoEhDr{hX9G3Bce3p7wnsLtSH6s*5->GxPdJAAWcJ<0CMyW4Jl@EB> zG#gCJ!{GI>n$OrkOE}C3ja><+SAW+jy1$w@d33<$T(0NIm=$L`GdG4i+G zFBEF8XmM!#p}{8ey`3+2C8lp)FkNS!NOq6~W{uo)vQnQ>G*X z@?@U_cH;Vsxme9@aQz$s01%I?k_7TP&aLd&sbzh#-1}n2T!&mYlf7K9`5&D2&E+qtc^32@UU|R!3 zFbf^cg~5eZ{d<8~>4S1Z+OEdoOq;79&PFH15^q#Y^8voW;!smo9}y&qa^jas#dhv{ zyHjcf0j$(Fe%|F|5)K&G;N*RFEk1Cmu&LB3GU-^WbIm9;RDSFv^iOrI*}Wc6*<57u z-n(mOry~kZtLU!_J<)>;@^JUjZX$|)l)K2HkolqFiR?(CJo!#2p}QF{Umvz$&2kdN zkg9o;_2T=Q;GuZ5rTGbapiqO~7YvqaY4v7iv2(8a?7?~WA*kk^{iy+Skf6IqHCI(jwdW>B&DjMfqRKZa_A(kIH zE%Z*v2;Oa3niMuAdS1JP=e>>+J!s-)9>i)VYaOdBla2fic-}=)e|GEg+g>x+|G0nO z@Co~FOtpdf{Bd={%u2zf8$M@iyF{J~Z5FWT48lQ_|W7xV!!%~G*ubQZe5 zHf&3HvsT8#UnSroU0?OKDVYxzcZ*&EwhBw_6>Pc~x0C0_DzH9UA6^`oin?532>iE8 z4aykVae?N>4VBh&y9RKp?uDAZ{f2Hr$Yn#BSVecYVY!I5iv})By#WG*4mT zDRKP(?f3_@ccX~njun{4_TwM>nHFI2sTX3?QW)pkzoMMS-3Uw5UMgw=Bgu`_M}9ZBq$;1-!~G@(bQfz^CeKj!6j znfVmNH~u@KwS5f-c^+YOA2i)`{BKuE>Bq;~XRckSgy9ymk;_C2lUNvtdArr zhPr$lEVC`6X(Me$qWDe?;}%BBhb<|*2lw*6qFt{|&tm9ayW_#~UKg(e>NULE+e30K z3(*Ymh9%rOMcvq(&!~FBMN2q`zp+USStn1=9&UZh*oHj|q?fzjkI8r{0{b|3NXx3X z372G+aLXWUDmph9(6U2wOX5dmNss4yOpyVd0PgLA`&t3%0*ZGG%fpoAFRO~C<(%*6 zXno;YCI~GIsO7-($K=Y5M|?Pa6pA~ut{gIs87s>>av>fsq{p^YLwY{O`E&$1HyfY62gB83FU;0anBrsa{4iWp^yR1X^f7CHObGhA=Fim7 ziX+a)C#zq1J6}77XBnvT^)R5{Z}DH;9AEnua6#3%J~Vs|Xy z%soJ`#Mn%R>h?5O{}9_h)TN@k4w5GvmE^UEa$r(Irck|P%J@UTVQUx(v-!;pciRT< zz-D48I*{%vJ3W^b{jZ0 z!7S1gOUvBEvPJ_+TojCPIt`-q-_LCh6~Pwf>!ued;lv)@>d-fgEGfPI^tOF~ff0#r z9WEn*7g%y#E|BU7j)XE^kvTx6yAn(C%4B6~h#`0qU`p+M2YZBDuMuLAcjz|n{|36j zaNTq(Ut_FiHK&dqY)6NJe9Ta(?pL50gH^UglO;Wqn=2?781RiZ>6=c1I^Qo5Qzg~Y z?IKf+M$x+0m?{3z&wQ#mTWNe(ieB`*y;St+pm^EeEIRMB>+1ZkXi#&tPH#!T(a`|f ziin9(q6$90U;K>IIwy)hBS$7X!$4J-h_9>n^tdL4QF?!LdQvMD?$lohT#b_JY2S1S zTC(2?J_MX5(YnHvW2)E@Lw8uIvoEw$3{zK~(&3MwR{Y&KE-z(?3b8~{xebUNWSi3rAVxWs10 zwiVi`i|8DntCmTn<+i(JLw^H=m6ljVZS?90a@wV-Ik2a>X4k&H8}rG9C5MtkiA1&( zd+GOgv-qNWc#a)yCnFF}9IFyQ>R7}usb&G;axwmxI|K`xD)7mOzd9ME%0&D3_SD;V)-+9RQvqqlrimzk9fIw=ty?rR8n!i;k8LXvrz%- zwU?aVxKOKku}Oy4ouzqs;UbOi6s@<=00`?40L#=R$+3@D*-vg5#530>i;`Y3L?o?_ z9}sOx{V8}Hfif<=YFKUmF#VW%_P9DRfQonj&Xsvo{{2JLFOPS=slt!?V`8_D2c z8W~U(5`&TU#1l3QzJ4K`DMRor!;ukMh(b=UYuv^n)+36CPt48ph-G;ls%RM2T zOmc4FC-1c*(rB;*y@KJQ;u4P+61+Jo~Rr*=mmRrjquH3MBdaWL)Y?BRX zDEC&-{`f)q*FByM+3~Vc5*HMC9{!L|t6W@y)R;{@E@MiZA{;_h;ew>zi%yK5JR$L8`6_J>Dwqtq{cix^)Ks~x;=SxZ=4L~56CLXmap^s85j z=11!o`5#M)0n-vp6VXO(-uQ}0fZvdF?(duZa@bK-iRwk2C)mjcWK&R-pcHexF|%%2gq52+S37&Hc@b+5m+X1{!vjnrag;gE?3yDKo+B z8AM@f#(uE_{9Ji$-dK#Hoz*KV5k%qGjIWHy()ZGTo`WG@S!uX9;p@5d$t{c@WD+fx z9NWAM1m7o|0)TArr!a6fm4~B9qEm(M7D>?Ma<7t$mM<19b}ph^ac6Fvx&{oq{GctB z>A#KJMNnrxrad}JAVT0id{gpxsOJlpbWBo7WnL{dKqmohQo3WVrVLr52)R+9A+Yq` zK45Z7Z;I0Pb|@3&8CvC#CrW3c`6M!u*71if-WJZKtY4cg6idL7J%uH~?b_i}CM44$ zj;H&MtAe_(ur?o)xQq9#Q-5q1l9y|d=3qwxZ#efS%_3{Gfx}r6Vx4cNNk4EjwiDcP zR$nx*saIm6LGpo7gLnAXYq8PrsrsyG)Gn&cVjqY=2D;6nw}d$|P5$JnLSNowc`nLo zrFp}mZ3BH4wx}Z;LXvqk#y61k3iIkqVW9{OWnY*uQv$wbrp$LHQ%%AK))c>>VJdXLfhmW0iVY8ZSzivh!?s!*1Yhn2DWWG^nO$ z5Vx25&CGE(7Tv&wf{>FaETC>R;e!dLHD!&_c_b@J45?+vb|hEfD+92p(E6Rj4R|CY zC@cmgS2H)fG9ohp`sd0#G8uEZElI3Hca6tLlro%8NR;8$ZmgBFwPO7^(*VQLf>Z@4 z3{N%)a$2AzDve>Cx-iTiGgLGcp+Izm#Z?5g@6&*<$ho`&*=hd8os7V=T8S)_KN^49`w#K|5s>Agowqm-w==x!`w2S@`8BinfOkC&Uws;Pn`mqjc7H}p^x~RrHDtD2uyo3O#(Ul6Y~AJriR=D9 z0JuO$zu*_)`9Yt2Gu&PuoujtYPF$k4L~RLW-fPqU(!D6ZPUiS zdV^K~xl9eFJOjzkH3L&UNs6<%3Gmhz(ZC+Y@)^CEu%_~vG9mT3FlnE>IJ$#Mo${Sf zd+LDcpRCW}L%brwfN5TlyjYIOz5jO$%d@uEh603aEPB?mz>muK#RUYYII2OiAziZvPw=iFT3%6$vU5o5z9;%d1b7 zJTP;7z{^%MutiDQrC4vXkt*jG=Z(7GgH^#)jo=B4R5TOJEYc%q*X|}Fq}|NBKUA!ORP#`AN*nH05idzOR0d?x`XY!YpGU~|0pkD| z2f#RhCN&&W$E6xal*3$sLFVks16qFH{XzB)C${4g7iu=>OeKtwR5g?8H-AChH`Aj( zkS9SgXHJ&JS97^u5_?m<>hohp`_(CYDB3a%E<4?eUS_(=ua`wcwI+%!`R=xNcX6M2 z$@1$}FBw}QU@L^GS|N1!8N!`b2pgG_*b3p|wmZ12!KTi)h2Io%%%R}bJBQbmA1I1ZxafWlw zanAVz3AcR0Vdrh+?o%6fp3=mu-Gpxb#Pb}bdgIIPcpSGBZ>|R8t6RNc4f~!41K2`h zHpmYwWV8x8f)Px?hq$In_BJDPipgFAbjM_G`r~a+_Fi7`Kxyo9?`o8g?7i5&x%^}= zERJN9yK*i@+V5hPsI)B6W13ZzMjCA($epe3TySnLgGr-bMLk;JE-tu9e( z9mOs6`eIuaQf8}p+DBxoXR{|`V$sjMJ!*sV)loQN3R01=4n_*;r*yK<9Mgrzn#eD_ z%?|ZA(|j5H?MuJ>U`3UzQDLwm5B)1x-dj?f?H-P+QIGfE@tAw(n~n`t_Xe3!!{RN8 zr_OR>+6LV5;MR=V&Qe|=(7t#^r}PX z%%5pkBZW!YcF$*96fcbmT%=@MW++pa&OR~GHFl}-B4kkh{Bj?L1tazKr+)tY^2KEz z`#NKOx#{Xamyo$CzuXgs0nab547c&8WVbLxSW%T--aOo7WupskHIY}Q5YA%^^T=n1 z_5SvyJIoc`s#r~x+%8HN1yz)4QinHVhgv^Aez^Y&9(2+TrcB3KnHP=+o%CkHb{=PC zjMqMS(UOBs$!Z)v#5*D!h>l2A#$q<33N7wbB<9(f`dHkzY-O%7^}R>mWxJKz-o48v z7~fi^mh&(J8sBJqqw$>xev6n8jqk>g>Qszx_`tfSwnK~cC|HkDbUn&wq-tMqaV6Rp z?9`+5LvJp>9t9Rh8s~~kiqj2&1Snp06}U*yP5G-%I-TsTa*@V$(ip2wT2Epfs!ntj z`dU|=aNLWk6T`ATwV?1M0!D-(m9-~>^M7Zp)Qo=d5}ijD|N^f-OcGeK}qX4M+l`L1CEEV=VgE0;R`T8mcyrLb)E|5p@jenAYhS z4^CyGia`~FDh5>ye0?~2xY^LUsqU@5i%ire{LoICI!Pm>*6?0W9eEDvOSkhk_&*Bk z;)FGP?9aKDlU|LkE4Bh@{zPdIyBJzl^iJ5e<-dw~P|Sl?l?NS2PLEz5b@&)T@n&@% zRLSxc7)lv_ch6Sq_qzRlrpW}D3W=+?YBHKgJHw zGtVl|0GxtjtA{8=eS-R=+4=;lma5yBs8CR$G*O{64T*siYnJX%&%9kQ61$dZLq5i^ zrwd5k1R2^Vc8`N#dcNbnLo$T}93{1^5eQ=>k}mv-|APG@7G4~-^5&fZs< zgNf{W#ETS6vYUCAN?&7ufdkWANBwk*ywo68I$RoQ>V`KjKEH+u!B4I^eQ87Fp!BGL zK4wAXL3-4!RS87YDyUVOtyP>?R4S-cP^q9&X`NEhcab2ZKvh`um0BowQSPGLJqfvs zBDQi7JEOLIf)7Or)j^ydE}@FNWpvZI9S&7*iQd6N zEG)z-zYyzE+3#f7Q5RzEZ-Wx!?#fhohTq+@)v$si-y%WlR8xqBG_I4zl@wwjiR&bB z-a@QX5c<0KBg#T7E<-nMP@d>lKQir6QHmvPN{vAV9*hFhCjEl$Z6*fbolzwheChq| zOSg9!;exkD<~qth@1&0&tvr~B%BaD?#N&}DFEs{AOqJLi- znCeIE7uJ68p$JtgF_3%&cu(Xx^6H1HZm)kAdv)w$_;m3@=e{$Jyjp&Fv*RX!Awk%c z@yw5pgjr()Ax6G2@?BKqyE_~zBi~n7SE|dS3x0MAnf?!NJe4T!C9!a zh0HkHQaDsYXP=np8oShZ5i%%$OuXOiW;d9T`mK+NBZ-?B6F&uYpo<5sjEQq|R>s6F z~q?#v^mP5cEVAR!3!E}&<`16jyiH!^pb8wz(P^x3p+xWt}=3k&8lpkkM2tW?hAz9(0xJorE>S>mN8!Y_*trv@$7En?kbHFb;qPDcu^c->;?%~-dn z-qn-hltUl^iq~BQE)sMTRwuTf##o)$dJTd+D&Kh;#2Qo`y)%mddWyyd0FATiG-)uX$9s`cO&k$9B-`sw<`|#6;$8QOf{GbACb_ePW$TvJAee*4QLxkBvCOBAU7EJx)7kl6eFq9!Y%a@pxT@zSi;hOZfFzJl<<3*CqKLJh`jUL zeC&XCUwTkSA2n5|f%}je7<`m zA4s=TeqQy2OmO(vpEk>$NWyefzNaxAh3TlqNvBEiGAfS(!*mqVxKJ8nI;!;~#&lFN zA#{nZDbrCLsCYW69p^&;j0i(2(^1?+Zn(=Scm#5)gXx!PT{>n#isR#YX-E`orf@EFBl{eeeuiLV0d;PX9=0lo4AdIJG&ybfOSTr8j`rYDFuV?Ylh0f8#Q zfL{A)i~+sYlNbYf$%N24pvQ3^59oQ~rHAvJP7ysX!i>t0USRE@AACG_HIZ4c2EGX8 zgmNCkdRPNrzc|B|OjrZ|K(+=DR=~HBw@1@JoLp#%mBN=}J# z`OL_Td|ju4`v?(u_nsILf{s2%Ta3Aux7}eAxGNZcWjw1DLZQ*Z$*or$;$+T>$vNsW z`OW|syVQ8$Px;pmYkTUOjvWo+2u_bN-k{gHyye}+<2)wsl(k#c`*5@I!YQ-}A3qrr zYFX~uw|(*cyy;lmu{U`|{$%E4>|swvQ?Z9V8%e|-_Gl~(o9E$8684aXh3wQn1=}A5 z`!0TYxP65>*E+cCc0~&mxFjMk@*4kgLeO9|;<7xGvW@=4UVRY#I@brG1s$jloV9P6 zHvQ!lP$FcH^fz1zVS?hnR~C_Ki;dAg)$c3<9xtl@sD67@vx*^xDt;g zgA_96uD1({NMvPLJ+M*~vRcIyqub&5c568t$`o}Nz+HuU3$7i)1~IZqOf(a!x1%CZ zgUe2rF-{ertK7FV(94KGH4EHqTx|M*gLoA?K;1(APn6Le{OP}~T#QZUVW-`lZa6ZNaw*FU` z+fPdTwKg{J9V6)~x21DrDl7?EIZGZ+*iaGv@4}_V>}PvMzaC7_UDD}5C$VyXCAAJ5 zQ@TZM3uQ`|BPO2GJz~sAX<6MYGeb5_8S52s4Rq#euGg&7nX9=jw`ymuS>P6%*llvx z{bK#NmN7m0aa)xs8U3V$UXlyPsr=BtyA(yXda1U(>Wjon*&=Y=k9zkP4|>COomgei z6v|vjlhSo=q@uYi0vH<2Xfzj>ZATtyKaY6FXWNlY+Rr9OW!sTKFhGL=8qBt1l%@@w zk5QV9I6NTRej=fo#=FzCX4~77rECgAVDg^-cYjNdhcOf2+1Wk%b&7nME5Ml9%&mTHh5XE* zU9+|Bo~0*|%15x8EB^TXU&jY7%2}FW&xlKzgJFAI2C^G$t20rkGpja^FS)^gBtmt8 zg)y_HyiDE}=5#@pU|38*;7%>Wr8D+#rqd~z8WwYCo%Eq&zL1bJo-vqW`79x(yLz^ zT~7_0@5s=01g!&MKg*(4bZhRQx!>!=&6N7YPTErCE~|c3Pm8tC=xcU?ICFA$_eeO> z83*`u!wFyjq|kvljB(&S%kxw?^&-g=gF9`tX;QsZu3s8o&E|c zj(i~7-7mio!zWWG4UUjlt`@<|mC0Nh-&|78Ky2~Twd+#bx86y2cup8MWicS51UTBN zOto~vWZ2^dNwglkI$cb(q#$BJL}-8|TI=T6SfCT?zfo$F4&Nl*0o&VCYwek@G;Q6N zSA)U5h+&o{hkj%h0o%G3GYvr4%w>yO@<{z(jjvBaCTWS>^H>Q{Y+YA37x$xa4eNSx zo+(2md(`w79I0u`?2Sh^SGVQTIIYioMX0*Iu?_3pOJ(;8P?4}r1FrYZNOam;^}K$) zFu4f;eB;8axiKrt>*v{P;>4YZ_$pdSmW09-LCwH%xHnTxQ5Fj91WnOzo|h z0AfD`y3gUFG5ST9F4-UKXTe(E{F3eXWJWCtON1`gOT#z8KY5ow##hW87RLHppM`t5 zrq4Z`34}4(j+l|T>nt~4hEMiuKRIvU44=Wb`Br1V!|RvE3)^8HwLJ>o=5Gig;cY<$ zP8QPOW$$<=p1CwF!`nQ4T7@SK8_xuDZScUAZ!p(Th7&j1Ie- zKyrqj7@V@7aUJGw&&cGRL$Jp~kxLCONe6cS`gJkgq13l#Qt+${ggKT>*0^bl8F#vu zost6sV(Z(Gdj???mJT+hGbu*Bg|oJ1{3-;v9lLfUW-vOE^>y@4LyZnSfe84aM5BY- z4RpJOyfmTJych~U*Axe*RGcz_bk-^ydcnD$s?o@WWt%Xm(wC(p(GNlz(maWTikOA_ zCu&1dsb&?VHmR5n^;Xn)G41CwX~n~S4t(rT{9T+PU=}~qsLbvr-!OmMg1W|U16zy% z!(9UKXMWrsW(&~5Tps6*xexYx=$_Qn+!cZ93Of6dGbIo*H8ON_I~d%QTw1YNIERiJ zE_10SlsRsu6N@6m78fe7td^XFJTg^d!?6&U55`OOW^``a+`{)VSRoRx!KIJ_kKWPR z3TYY;0S{HmD-Y}``uDZTo?||<2sWGvSD*Xu=JSGjToMFZ^Nepz%Xx$NLhMOmxRg+P z>VOR{-TZX5QuGeq9nD` z6}GJGR)RPr%&W-a96^ZRvo8=c6)s( zpQ4wCS0lycVSjM7eY1LaXq218@X(M{P3Sbs*1_jnX6iH>v)Ln|hiv>Ea-w(md&&$| z>ZWseok5JFPIPJ>pviWwGi@}qBFHGVG-swX4jgs(7DEm!ngg57Z2t8gld%(T1viqBl;V}Ww7wBHB1 ze&4NF{~@h%(<%?Cj*++8`F#x`R6=0fv}ZhitvH1uf~-L&1TU2FiWgi9sw3S>*b|g4BbnF z&W*3WY@8iG*QGpk@l$+U=@F0mfT5^xtN=YNP`3BOev()~Wt&5Sm#A!!ROo=BvMoq^ zRIMtQ=cX|>gsD+6PSk7RT_1En)iqjPXnA3nqZW1ECFkd)dy!1!WP)L^qZWeYAQc8X zY9Q3lb1At^k9^<#fjo)Bp;N<_trc8oGefg92u6|=Pm<0Lg#2uixiN*77(x1lSws-| zmmPlI92==q3w8eO+5eG~NL=BqjSTC}c=zD&Bp8cwBrJWUyw%YXz9xxS5cRtK&dqp) z)H}j}{mriDAbM7oi^PAKG&bogbZ?KI|5dVv|4x(uH;8wlncIYGp9h zI&ogHinQHaW7yHqZSA@fiIq&OJZ28+&Kd}{qb7OQMtZnBZ^9(8Xo7sU5x$!mMQA28 zqaI`T8K_provB-RN5wFFC?==INGj4J-QMW_VXUIFV!~5Mc2`H|Ed5dx6pw;g{@j*{ zEB_2=vLQnIJ1$%d#RB6U7cLc-hy7vDx$vNl3n5pk1iK;6dG{lIJ3Q}R2^b(NcRFKc zQTqvNk3XlcituPEpeDghU-5duf>C>O1BU9Zee&+C;W0iS?-1EpDz_Nv zG#TCYuC8iiW>KD(v|*zvC?cZaL%d@H(XM1g=UQv$y08{Pfpc9H)v`xLOQ%mZtSIf0 zqCyT*ZXeI^Xvbs?FbJ_&vO3M^I48+wat~$H+wrqWtA(}Rk9zkP4`r`4LBk(o?A3Xa zk7wprj^~*$CRT0er8qIDAqx{3bxDU@<*MaXM`@%M>m-Vh&N(QPs-;g^E34!dd?*Tv zq7_2=)efmaJ8IWm4aQfcw5zCMQ-wB;TFd?M`#*WY90q$XsbTYJy`drZiizoS*IDwL z>@BaRv-bGx`fU|4&&VuXYRqJ>MD}i`Dq;Q}_uT)T^kA5MWCy<$toirCEeC$GzgG@> zcw$;#V_9d@(U<_YI`t9ipOjKPus&sfE$SU7;_p-1T>~T zoP1;GTN`3J>it(^xw7aFB^TgEQ6r@IeFS9w?bb(KfJg;hu|tk z<>c9vg)9~npaAzfo!oN_oj&+fQ&5?EKGP}8wP<8&caWRa{fzutT6d2s-GXtwU zsrAuu(SSp-gUF&vfik<3;RJ zcutUJ#cl+Ti4E+$EDiVN5y}t%!6zYZ-jrnUp{?zv$tffG;fYL#TZjNVD$%f=U9=C)W8*Sj@ky0TYD*pvyb9Z|RE z`R;mJKzTt?ppQDY2Z6p0EHguj&%fS0aUR*cre(Zx8jSDJmEjtG zM1Mup(F0RF_uJ@;R7c`stF{Ak`nJq|Qo@hfH+qP^!<5`!MJ7thfSd)C$=3~Is8?EZ zmXCJGfm;#nkW@S5GxeDF;GrpkrpQT{B9hy zZNV)&G-cbPg?pfQM+YIZv~bbFJ(*zJuIg+z8^kT#D&Q*GnAL`06{_n^IFT`I zETWj*raLkrdaz+D(fDL8sRu|TpPi+_6>thF(NaT84K1~FOATX@XsN|yJH{e07TK0q zBz%Z#sx~$USur9Q3Z|p`rp{dG$ zui>DZ`9ewPUZf!lv|Tan)tdjcG-BPk3nK*wA^%%yC_t={ct?x!V;7SkoIE)B;t_)g zNzI%2l;4p!jHEw)|K}mUms`qDvda489`fO3ZyeMrk(JaI>tAKJrp&uEXs9V>_lj;% zm2%e1Su+}aKU*)C?}UACEqjj(`DpqkWA#B#&b@>iFa;BC_Bv$hEGH&3HFwy`ojKbV zwzHHM2tYNXQ_FCvtLw%#ZQRBgw()lvq;rNDV!D76H8LAQ117)f7ow$i_szSow}m-f zkR@1sFmgqRof-T09OgDmnaqN&ewFTZo$Q+H^T-lDH1S|e01hlZ_&g2>&D}seM~df2 z@f@i>#bbLE`q8yzLr%U;ZP|@w@i3<+H-HiYB|#I{W1F?aG?}8Jj875IBAc|l!O z3ss_FhIz`SgIh{P8D=RlOSwTp>+8udN7(>1w^x;s?;!5)t)g8@(bPdxNAQPf`+OWm z?n*plkoGeOA8h|%!Zg?~gTEoGAgiF;glol={ zu5#Ep%{FP!Y(cZ-#LX7NvOXCu9!f#OWh2wuY`8?&9ZeVg6k+JPE)i7bauOt0d|lNqVaj&M+G4hWx5pc(4N0(5MLSXwX-8T=?wq-@F>82NUiB}A z7hv>d~jk@A!4S^hD=&AN@w@s^g*KA#N zAgE_*Oc$sCw>l@4p=z`4m?osel{p6{N{N_s!9?l_Sl$q=)Yk5f_spN0Ko!|C9|XZB zr~;ujkOp)XWwH;d@YLmPr}Hq{&@B|6l6UwM64WvvhE)ZhJF7dg%S79PXKL1fEt@XT zLYQg5K7_(xE#_x%2W3fp2JV#opkd01Kd)=crmitDEz^G|-yDtm#MLL^JOzXpBw;2y=O9ZWWaZUm zNhpE1z3Gl_<3{%7!{}njhl#`?lSz&+WaZgNx|l-D8V0{*Kvs_DnLIlc%ENesy_d;< zuFJmxE}XOdCytsBZ*79tW6yx=_@!?dQzl7(7^76YtH9{nnkO077-gDfd1j%LK-&6e zGwMxUbHdy&?x~%D@G|W8Gl=`|%SIlfMl!DYI@l0kw3^BBwtA81FASf&nU)3O{a~g( z8jWUFWYVuwYduR2gx8D3x$7)B&xN$62T2b4&Sj$v9@NZ{35(woXHp*VD|)qMIaIm< zkj0?_rI^Q+(hJt6@>2D#)DbZF*N==@8oqmzs&VU;ih&bF_VwL|jk>G~XO=%9S6#;9VO7EB&g%9i zOXQuCPe&|`ujX>S43$0wnO9!;V?e@cTLmm~*E70evX?pNB07|W4b%&k%&W#Ri9A4Gk=%U*#cU4fo zz7>~Y6mQ75BSVDRz|TBaVoG|92d`C+!%>=WBxW0x8)g5$40Zfq`UMC)A{$)y zamO}h$M$f?A{$&^;Erv~jveBTMK-ujk=wXqH6vAu2ZKBIbObl<*v5n$_WQB$p=jb* z7!4}U1r?poV7JG-bkE~|Ie;YoBHOVkJmCF9J}J|d{NH@h;n!Gn4)Zy4Jjw9qJIj2} zy5{pD=g*pq5;OYKF%SPa&%=Tp!zkA?b<`hqbMfj`d1!EbDf$ zwqLxlI1});lXTc(s6@!Z(tKxK5#g>JSQ|9_RpiN4ERr&EDGQ4v;h~;B$48}T!S92Nc96{3jGbLje(Ew@&XJp;+FlBuTQNTy@AJI;C zf<@p;S~?Dc$*H6|I+)DUW2#{Cr}0O*ekD3fhAhlNJL`&R4n;8eO1=Yw$>?yQ!-Wpl zPB0n91){grLbgY5YpXantbS604@1frQbr5s1U5QaI2ck!Bj?nO91JO+a!46%9f_G% z+B$oq$LR@%5I02coCG)2jiJ(ys|WyrDfXWcIY>;@e?~+dtnZ5x0E%F}Tv7m^9+CQ( zHr@@>_a({2+RDIZvXU{AYz27D&0Y6$Tz2Qv_p{QIC2C-&xL20EckW(l;< z>YnNb>JJ7tx4kB9pmGH%v@#A@<~uT9+fy+T%(P#f7kP{C0^-qE>KYdD&829Ax@~7{ zlO;o0MRbxR#2F7!Gygx!{pO?z?OphaJ)TO zuphv8CP&XtjWwt%gG@{=Fie}y=jPO;_VgW95vrod02tpjY;WawCO2$&_gY~LJ)5r- z*pu_vHy+(Lx<1s=pb#j^8tqr>YO^FBL)LBXv|}ycHG(l}n$wry=4YSRw_%DV?ZPUD znqPklR>3ocaqwV}*p5$J$}}OUdjAddu29>(Gt%dZdmu~=q2dDt&Ij2sLt{n3-<*ec zqv?Cpnv)p}a$Yi}Do4J6J`TBm-r8F+W$Uaxu!_tjGj6iX;y|r?DwcXr8r56dS@K{f zWLz?1oAW3)>-pVoaq<}h3R zEqIpg8po#O**W9(C}<;td8fhcOaAJsD9?uk6(H;OVR$>dD^5&hHhFfZ#Fxqd*)1#+ z#@2CZ1umMH=fmCn6A>MfBT#gtaqmZmEDawH*FI=A z_$p&Km%P}{o782YN1t71y%Nvz-|)bd>=Cx^ZikBo#<5~hJ%mgh5Cv0kTq#V!;J?cU z%0eKYd)@FW7M(rQc;Kpf(Qy4!5bN-qC3C;O8sPGKKkVOX$y^$})6lJ^03t*V352~~ zihr2a_LQD964||{DY2B4xVB6i!CYDV14OjJ;wJ?kbvu#CgDb;ynFevzE~L+GADO8_W=fk$ zChX5({yESP6f{VOz&8jqAye1ygn6~>w`S&i&Mq^Po|6}zV7!ne8IL3_(sA(2C5-6> zufZ^vu)n}Jn~6LQkM#3#z>v{k3dZkN+a15BUqFud`KSh6jE&tee3Jp$x9e&cL^kDo%<$Zbm^$ z&o!o*v*mW^0Q`dSz`b?@DyM4hX>;2;>B?@!V9k zP$hc9ct*VG;1+jAd^Y30)o1FlEsm$e@s#)m3GF;39_9Cw5`pbKC(fPUOvl7yrcDI& z;3C>P&4dc=9kh4$+B-}WqOF6rPD}%|)7IJYI@&q)KLE6Fl=!0x^BgR|n2exoOq_lYJ;Hr0dxw+Fud#9NI9BA4s82`JLX+s%}VNVxO zakC9Z2y>Z(XnMZmzO$8xeGp|6$qZqPMQW>l;=f|Q2q22XW|3Z99P0Rv*W+~0G&6cIT+h$f-mKJ_5!qdB8{{J*M7XLk!^50ucE zD2>v%k-kfPpkr9JoFEj2W%semY4Cn(SQcZj7=tYn*u(VNUfp#_3|8q{BnKnVxWT|| zQeYNA9kB`qzyb#7tmqU%37qT~<4BM*+dH2i~i(J4D2`^kk) z$UcmnmJ^~Y$L!?_(Y6|0kYjRx73-<;vwnJ;hf@eGeg~ejf|An4DaJHO_A`nl`O|{J z&_X^P`zOHm2JOl_O4LsZQr_ z!9|oKC`SOetsDWRBzM)xNRbfCry@hrjZ^p#*W`fu{CyD0ob$3L+!SncrF6XQ_Xc-k z6%e8$V-^C0+_k0r2CxCMgku6?!|gE)l(mEeR-Lcysc$;Aw^Mpo{bD{D z?ityP>pA=X?0xHU+c=j0tDw5-znk>P8Hti?EAwwx>E@1i5+!Rpo!$MCf=Ec>nj$qM zWySNU-(f#()y&KFlk7PFD3UTMQ5Q;-gsODgCU`jje&>pV1H#St_{ElK6KWgtCj7gQ z1FKU@pIX#s#2+y{*N}L+<1$V>{-pyIF4ch&XFw;hY8-nRm7Qv}(vmLZc2uT}5vVpG(Ob#^yBn$% zrs{r1;wCjWd&jtlv&Ekiy{WixDcsqx5!JNBB|NfD1k=7(Y1Co^^b$}?gr1pBxv{B( zX~~QdNDUEkn!=5OF$u0_t=KztT;4z!d|u%YXq9rSC4#8ADXyifW<;HCO198Lb!y|(jY+%~Vco!q(&&mibNGA>g zipSAu8I$2&f&?9L0G`7**qDLJLXTfW{-+qn*?!R1A~>%IapA+kAs#lbEl`ZmuZr_- z*$4mTx8#jR1s~+aSnkfq$}Yv2tvd!#oWXSHbT4a-%lV8)v~Ikm(5Az&b>bkXK-1w1 zb>F<5hp#}jF^@di&dg%Qa2~M=WUy(O{!5AUr#`VAKWG(OLEjN_2Y!q1v+)FI_Z{Lg zf9l%sLsW(t0F5}BaKCO*7geZ-i2?B7BZjNzH_8Z_VGah&WwuXDn|RI`ZlEp()_}wk ze;W#ZigEhc2v>OV-TaOG4P*MmNTv5kj44BEkWy#DZ2YbTzSX;hwS+_%EktG_Fp9Sv zDKBW4)ELimJbhl^u%G9sr0J2!!0n$gqZ~;s&q-m+473NAWXx!FhYI8g2)VK%QgpC6 zTHyt3GY5rm42sr)EWW}Bmtr@}87WR*j}=Qt=1Y74upBw}E=v+QoM4>$8r-lW)E!R8 z+>8UOa74K|hk17s%&0VVY6T`;XiMU)sO@ZF*}XDB=k4MXu2_e~mj*VZusxYUW+q$( zYZC26o&ZR}kVGr-U2N_X4JR2_4lYHjQp8#cZT%fvCju<*6|;!b2brZDHNF66o;fzb zT?t%>_zeQIj%~fn-4&gu1}zmV+oip1-b>DXiQ%Di_i=KgMv?BAu(0}R0+EZ4LK$t zJP4 z`~3?8?p#pPH+}AlEgO+Wt9pCcJ%GRx>sfu~&lr<|4S(hkXX@i7lf#m1QP00;wgEI6 zU+9pvTt=VxqyA0cp;JdrB-POjTOj?V$0M>G;hZ;boH76pt#NG|XU<99veV|$*HK9n7+_)X|`^I+Qi_`Js zumc^58i5Y1*6O{uIM_{RQ@%~QKj?U3G4K6q5mZo)&VyC}u=vHao~=2<3!0(r&Iqnm zB}MZG3MjXtkOy~lIofMim)F|nia7eM-otxvjkW4SiU0VpH&lZszFK^4w|=yehMwd4 zBjM+Q`7=V+7KuU36}dYa0aa4XMXs$n$tUNoPbelSVb}BM+~}~KW7LJ0Mf@NwpD7Fn zQ6qcnvh3Z=gAiL-AIz$wM(l`OOaK7YnB=FRf zTGk7XS~J_34o4-FohHT+csN3gmXNGrCS*{xXl`g?JHM5gxKu#8C~m)r1PsnFn=NEPh@)Yz=)G1F+Nv!i5Z{Y;XOA&%k zD$o{5u31=P1`XrO8Y_T(U2U~D-|)Y(-}H5bgNG0aZ)BRw5JTj_AZA_4d!-dk+^H_xJ7i7exVI{+d3nmy6GX zwuAAl!}y9gwlH7By?6({=un+aFrEy0mm4@? zjn29Jl8IMAl-b1Cw@uv_xw#i_NgLQ>tird@m)#tnRlC({t#~^8UJkwy!?W%vEcS0v z4J|w5=BOrntsrO z&6t^)scny$8OF>sW*##$Gcz+YGq>4Z-@E%sZ>1-#v_GPyuCAy`DKe|`R79L}s+)wr zrpDUNXFBfmFOpTQ1r}mcv9*j`4yIPJ8~=1~YYMm$cqC$fBd-UAQl*L+%ZZVoGA|`6Uvxxm7r!wGA)2J45r;7m`D1ds;Nt zux1SIi@23)&&#@1DP0R&-KFx&m-uUH9Qjo+mPyd1vglyd%)(hvo{7OYve}W?@Zk3W zT0A4HL1P8DU!1W744%olU$O!fzXJVjF2>3NjNrqt+3r~G6UyRaAf*L&QA?M3(u0X_ zI1=alB`5zSHgH-@46p{c=g;Z8HSIGArUD%{ z=<>a`g8)*sN-MgoVf5%S$U(fi?PaQC*R0_BUL^0sw#rJ)cops)nxhYWH*%yu@l#HJ zdj~6Uou_EKd_h#L%(l{t^kwLGBc?RxZmSz_^iL`Fe zGZL-;MNI5?1j5M?gy%#?K!Lo9H*Dpn2l&YUddk=_V0};8%9orKZDK4EJZQI!5AK}w zXi+IQaBY{;3~xT@z%}Np_c$!7wwdXKb@AQ)D|CPWtkhhZCBI}JcP#F@jC|@x-2UeP z99M`wKZjEGKW6#5OSlc3va{f+0(F}Fa;*7!S8Fn1@7R9hLmBcz<=*Xfs`GmZm-mtA z7%~R;tEV>d^)c^Qt*_!CuzA)(Kk73iZt{3;mLn1$3P<+Xem&t%jiO>vw7MI9Hv952 z4>>g#O{VSd?i*?{ksEd`5NPSKtIa}Y{KhKXzUY2x!gxn8uZtXr?=CPxyM#ggh1#vj zt<<;Ui;e=Pj+F$ag`)Z=L{m5b>qc;@5=*k388r)W)?NOd4O z?@=ABL)EtmqAzMq)|1sA0Nu!WL*!lFz*P%Rs*gkJ>zBRUjEc-xmUELcL4kkn!J)FL z*?2?8}IebCYw=CTN0Q7yv&i?G+3sIK!mZlSxNo>Q4y>6iep-<4wbX% zC!oXpOr!x<$E`6>5V_HI$>u~*#rrk8_-KsRdn-Gq4h+-AoaPN0QxvdRPRjMP7f}<_ zPRecj2f0wzqK&y-udZX0P^RXvWdj(e)v=WbuNjVp0rb+tf6}y<-%%t!R#mtqQOCoA zQR5rSPbO++-{972?J-Jx_s5+&Fd&kxvzRJ4Y^q>|ols9b&Jo}+tb%r%jrq4$sWp_F zUQ;bO^0shy6Xgh8=lqIo^!xy_Db)<>$Ttm_A9(e#NHUn>gouo|y^~grt{JvR{gO2v z9K0%?Nuk!CGzWf$*GeJl5`GSEl{Zc%OQgVKihEsnU z*YeND5X2`P20h7{MLwPA9`R2NqOLu`2Qd*HUm&=uIJwYEgP0LT65N)7V-#a?*Jg9S zV;Wg-&vy+nMV-383m^C&#BdBk!w?x@W?BezpYR3U^&8t5vseNGY$eJU>BEcFhjqA5 z4holN^xPwz+d17`Af_{9N2E{01nVc?98`5!6e52{L`$`+)7!bPNMXT<%>+t3;UJ_t z|BSnh*(jWCJpUzGGy(J$Pa&>Oe%g`kOp+kIMuLr*R4gMA%9B2IhNus@XSZh<|L&`P zFsRA9$Y{Q1V=?OpIxQP417GBb&akd5HzQx=jckOuZr3g~hy*_a{;~%N@GkHs)(I97 z%nrE(6xLhPx ziEVfKLJhA%wjgV|=2W=Z{mst*)2L6quFc!Aa7n9>23=LDpq;KfU$IlV@p|F)v)0Wm z6t}Gmrc!$~7NIZv=&zXoNh^OMy?)0DuvAdM7+^I(D9x{{pT;%T z!Snl`D#8_TgkdmQ$?0S-E;BYYIs`U0#p5Ba;VNI3wa>G}&d!2TQ9%GW%xp?RH`ZI_ z9@KCsx5>;I3^H5u>98(jY-ynvF}I`78)i$=!o_fdeNTPbx=t~tMDJE?Ey)+WC^pBFiPS&rEFx(Eev41W*fmkM*QIi=gn*^!6 z$gwPeCkq@PJvRZUjnQsF{HaY-+!e>fX`VMRKaR%D1%)G7khz|IE|}el63?Vs@o>}Q zd*wl&ZYhC~a|zi8*RBJbP9pu#1NKr|?6c;xnwBOhnd3?*z>C$?o*I{`yicJx-Qx2a z@qWE{F-ABhOd^8l4qe4IApY9`z`B#)(jURJkpoFVG$SEYxCtYVeECQ5G@g-W18Eq6 z9dj-ZJpsvICVb+h)Qr&repB^kal-}jTJ#xoh^}YMvYE%^)Js7VG8qUpo?RJNP#Ow) z-?MP%4m#!&GlrOMsyQP+F}EuLCVDlo3q?UPV}PcUw(P#-U1=pJMB@R{5j_S68^a0kjYxv!eEQ;oU# z)B;;rFeF5)#CfbN^2mM1DGp{JOLRXrh|Ug%#=zTlHRHR2PTRLE4NNzOWFf()Ra{6w zVZh<8QFwr^_IwFiFr+_Nnl}6Eo<9t<)WoBR?3hr7HKzm1Qnc|VhA<&KpUfz;<C18)!pz-d@Xo)XpPQ_6wTbuCv;Y z%GuIGu@t)fiZO0tBiv)p^0nD2Zk3D9sC!!+HqG2kPp&h}oH%@cYn6HiJB_T3dm(0uON(>WgBcJ9Bl5P4%V464;;bj(VJlvUb@XC@N{ zS$P$XXvcx}={(_J$L5rG@?6BV*QR4)szcFiwo?J~Ne=bKfwXN>V?#=uQ@_`_SzG8; zik~Bx0!!Iz6HD`D2?1v`D%9tn%9s;MAyeKc@;-s35hs};Y2;?kPAb$sACB}Y=F8_P z!)zw!))b2pDsQK~?_S@JAeT=&1bTI^B$cHyH zp%Og&W4j)W_LX$dbZ*B7n^`;y)6zFt4|gs@b^c>xO6pTuEbVoU>XnA{G7?(6)OM!> zJ5?1~d-QDxOH%{NOEGn>iH-RcgpFZYF_?h!%#6x>tlC)VQ9zCJlIDQmh-agAseY?+ z^!J0}ag2yMQKjTSyU8$Zw}UC2s*K=X+0;(2hXQabFl|RQUNW-xrnF!%^^~!T^=bpp zRLoa;o9qK0BHpauE?+>u)pz#p}wVAfw2i?{W6_YeLjpq7@BU#qF z7|G8V(gGNGs-lm+n86al<(*~NNL5L2p)!mo^Nlm*w#}hF#hu-~ppXPO`Q`LR!s!!5Y9hr+r$8;n1-a@SUoh*dC&a@uD=QS;Ymu|K5kN zY38{n>Ews=CUBy?qv4DRr+(6o=MP+KZ|kVg(3Zj@-%_?{OxX%Q7w_D%!Kg%knermm z5$k&oLL%QFjLIsrD51lMBFD}q{9m^@K&?3AKDzWjfc!7O%!WZ ztK7J=!Nwgh3i{_`hrV`Yl3THp3X(OTYvv7VGz%tiF2(XV34Sj$OB~zhpi^ZM%T3eW z6oDaNtGATi_&VjUyn*8Z;Vr@Tqyr$_aqJ;GifxMIQaMpWBZu#Bf*rM+kf|uDj?665 ze6+LG8xpLo-5-i=nItm=vh(ucrx=ret+H|n4m6N-&F*(8R5C=F9FF05{uL zVuY~es|bK<>48*B$S)z6ecX#(S~d2?%ncqSs50Nz|9l`phP?08B7Hbbe5k3*|7o(v z%X`m1ZbYpY{#l*W~doU&gm!F0QUw@%sdXP z5loaJ_eA{{X3LmEj(bz^@y#Ij8INmt>a(xlcf0AEI)(G7wdonT@1Ga|4?7C!3=Q&< z7AX$K3Fb*NsDO};;&xWl-bN9(SM3h5Z5zp+ zO>r{(K#6#O>MgVM7g{zK%&3W-FeX4pOdLI1ENt`E*%I`ZPni&CJ*ZIh+dIly@G?aw zSffq=)ba4%+TNicP^Cm_;rTpTSy|!ceWqelYQf{VGT1+bOllO85}Pv-K9wbelq=8V z@4Pd&sk?j$IYTW30`NABYrHQiG4&iSY*-@bF!Z#zC&&~R$sjfdqXs4G{#X>MSirk1UT!kLLV+e)q5CH zlL*+XTm6(+(P3q+W`sRBH&Rh;P&C=R#6o%CNb+EjnPF2l@!{tPdb~{jB7}|LJvDz~ zA+h+o(J6^!1-bH%OSgMH8ul(hqFQPq5&X&|SCrqYqmvdyOA;M3`1|O`Y_{$V+c2oL z0GnI9O$=5dib#?_R`%v3gg+)iyl$|_bjuz2pv5<-?RT3_ z+Uq>6y2q@yDGb+bEcv*TPTSNEAE()#3&g+(hUhj+zwpv7SC%avijS@wdbavvcJc5) zR;^VnRP)r9BGBCJSrS%mRM;=cNbQuUj=hVep>cDXc(3+VwoU?mSxlZz0MqDuGjf8$ zsPHZBo)0bR{9Bsl&emhWG-EX}KDu{LZ&(>gL`ibqDF2jNrl3k`8urjwSi?ng;=tgO z@`t#auzLXC*a_X01ry6 zBe;LxK+Td(y$n~2_6P6o_K?v{+mg5G)5SjdseBWH6F{b0!{P?H>z}oJyDAWDv`CKw zB)xZN9Akk751B{T0!hJilZ|g9{VVj5CQ`zenFpShs!&l8^;KOFwW))fUdM)k1%XwN zbZfBrHod(*`8FkTD;K5WFYd2+!@{iibYugof&z_wF+7mhG@`7UF7>G=WD5(4@X-FzX?9)QuCHOZbhKLw4KsY(f zps?)6-#N+lWyxj8c}YIVz;xi@*zxZD@K!(Si?H<50b!XFgKr2C^FBtKh{ORRqqjzB zn()7iy!hty)%lKc+^H(1yC*X?7~Dc7xB{g-q)F5lcIjdaC#Lf1~hBkbWXRQ zCGgWp2p4jl9y1ssN$H>Js8Z?Q4K7$(HD!dagY(V(r|GBd>x|BBIx$CJL{QqhB9zDH zH2IN|kgOar7m7snrpjA*)CoI6M`WWG;+aaJQ{vRB{P988hs0^7@JS{!amLr`rTwv3 zX=c3!5AQq0LLWGoK8!mH^8`w$iU(3|o?2!w`}S0zSo5uTp+n-(s{H;zmyX2mOkoQG zRgUfToNl0Fb#4KM{4QpUy;k35UatNx!2az$A&oni>z+rbbT18Lf?n@I*S0uqs&U1L zcgr;=-}bd<)|DR(rW24(oQRjsMV7&(BC57wa1OFJyx{-d!ARdTfGPaWe*B?8{={!q z=mCc=yRP7|!toeWL0zU8M-QiLSuk|OD0@l|Gpot|c+6!t`X@&29MY#|=b&TIWW|`U zl&k7&IrvOcR}R}}Bf$zbf$M?s1*cizAZ_%Hy)b7=8Gz)Q?1<_ZY zRd9DN!tjCU<8scje=uX*48{A1)ZC-(AZ!;miFrd3{kZQoLl=-k`(}+_qxWM0>JNI( zUXP&FWvS;^`cWE24;;ixz#omhVUfUFZzH^L-aw++v`}b56)+sq>}z8fJO$JtTII-$ zNE{VBGXX?!l@is7-_y5yuHSV3Olu(^g};IR!8ejP83KV3sOCK-l6UkFv;uWiL`q(u z^4>A~k*PM%UnUx~@%3&RLoC3fV9jySZBwEGHD0mPL`Ij0u}7g>o|yAQyUF$qa6<=7 zQouyt;2|Dm9ZjxbjYc$COz}e|>%GJZOaDH)Sl*Gf=^ldO{ILRv)^4uiPoR^{F4vx8W!I(rgIIvb>kgX~%#`Aa}ogmd6kLNpYsup$=zbU`J<~;@*$>e3{bz}=H0wwTcR-kI&T}Vm zQv%Y_cIbO)(HjryNwnF2&DelT;qu|baZ-ysm~(JHqR^csX951Xkqjy(9U50|C07f` z3&qZvy~VcaH2f}kgtPlPg9zd|NlqJ>;?>Z_o++Xib_zAO%6DcTmTT!=E9GGShw*jV903|!qyB63XWKi`-Z zN=}`t>WE=K&XgYEg)a<19^e4@j&#@=6WF1;8)!iErBNtr>! z2z<_i5M)rU1*V2)s_{TakxX<;N?2bbn-D?bSDS8{=j!=-$4cMwog7PKQiYAAjCDIaD0Z@OEloVE ze%Bkp&iUOl2qxMM`VG6VHwA*HHOLT{2=s6T;3nC`OasFd@>Y8by_?xe^`e!wmXV*x z#gp)b23!N&WB6y-!3RWAbk9=j6v^?jXi&!oM6LcrHX*`!4&~D9udwSk0g9!BLvK3p zf?39+c70j{>VER&*+oJxL!{ysW0Bc*P=y@roqEOP?o@f{0-;9$q8U)c9Kln$HH!U? z)QsftCT9_>XtPY+igtV*)|$qS83*6&RBM+H)sUJvsA8p8s>|MAc~AhSJki|r*%6cG ze){-@@^^4ZA>6LV2fWL%E$%xK(`v7T=`Ks1=zswy{b5;hko&4K%Ru#NxcFh+;zcI* zI^5B_+f*h;Hh4UqumTRh|2JLyu?+}?qY6~OeF5X(3j*BZJFZmbSMY2KgEo3t6(zmo ztRq6Et98~2bn#|rrn*OxK`kBwV# z2i$6|SJ#8?ZCJ-h^dE$PSKwJ$73FK=Z8F$+3&-2y%vf_SyXR5en-xhrK6cVVI#T@Y zM8dxhsVe|{cP{FJ(Sq?6_F3{s;O{?&f!&pHcVIfL@;dWHOOeA}nh%A5t~uT};--LT zDPh%zieZQ!%t(>NHGlb;yoO}3vb;A-7S_Y3ygCk7obO;C=I(Aw`!(x&VSe-)8`E+e|8ZkS=qCFiiS9>Y zJ=#Oya4$E82%8LHN^8Z;)_iO9n0n=x2EU_b5~+YdFl>G$uzyJ4T#?Ce?h<+X8QyX& zx1W-;!Iw{Zl8!)J6ZLSBl0%oSj=m4qy``p>nef!!r73hCaGmKaTs$iTm*-=gx^mp1VYuc~{`Q?$X(&KLmOZC)|Ix8%Vex z{AJAj>O5inb@T-R0s`{&1rDMp0}g=!0tEu|{hbt~Al16N3-tRJNDvUz?;~z@j;722 zTT@#*XMhuvyNz{4;;8L93rff}&brVhFD#SR?f@HkT><{D~#Y8dDOj60Qvh6N% zt-88i`#s$j1oN(!QPS3y7xOcV{LEz-9+{&|F*pjWZ^{v`XD_~X<9K8+I3@CuOq(Qg zuJL-iNKO?+5U4|P;Xl*b^iJx*hV|UQI%V? z)h(5-95BwldQkJNxf!~DgJ@Z({zbNg_`BJ7eB^DIzl6@TLm6vd2E%$YIgsi=S=Zsu zgzK{Y<>HfXuzI+W(kDhMp}a=bs&M@Nd6U#M&nYOAKWG_bjbvkNayDDtI2t=|S>u>j zXbVO}-n{~u=2`sC!n!M=S|D;k9ut4Vc3d(5gQ&8nKsZ_7FE=FwC20VD@!GKW?zplN zUZjw}**l-T*m;3m6GA4moh~Fd;X}#L`IEf9o#P*REC+4gUoq!1CAZ2|$5)3uPIw&| zBz>)2(VxR31(BJPf48RR5`7!?6sEWpn9+QFwmcq+lIX-#LYwKk`R32=*yOsOP?kB~ z5N;h&pExaTwvmjt<|$DFLW;f+uMDgX3>a=VO`#9uO}gKa|F>W>X(uN3d>v-y=aJVGT`F@0-voJ8#NT7u!Ytr&b>>#HR~^f zDOxESVW=!;aVX%zTRdttyy7WNM5>jQ2r5>I!++E==^6;i$7m+`9w?_p=|Y%~l}=Gg zc93D|aaXX+x94Vl{~LtsOp2H7K2U!>UXlyDGX0@Y#Ofet?Z9DNV^|sL9hrIo@ksk3 zKI4kV{!Z({MGLQ5xrh=Pv2h;qgCuCJ<>SBM_6(|su`vc@uvR&pHs5>J+|=d&M&=ju zZI!B<6n}9rrjtLBj9md_lI;Q}mBN#tfWbm8KcGW1^nDTHI-yz)JtkjHYhAq3d176W zr}@bLh!Pk%F+8_%Z6RhVQw?Oh4nVhBw1%XyB=y>YwH@AuP%e`y%}lvPn&z+ z%$|fesNPqx1*0G~^atMDXcst)u+Ucmo_+ z|FgCSlJ)G?STI7asV{{@yD}kQ8wjly6qR5~uoqEk+Bb2Ar8-_^nn(|~r>CHE^_GQ+IMYfk|h7rz~$R%MJmFL9*UdZHN`+P}N_nrdv6{iZ&V61FZ zqDi-f5iJSc5~wJSTv;(AewhfV9kG`Xan+feqT$t1C8lNppbhY&!g|DSYs8&_0lJc! zuw|iC!h{LUaA`0NMyVNW`PD3qco54x@t2(Pg{y-d{?^-T1Ie>P)p4EU_fv*>hDM=S z?osaraK;VFpPaSW1P)|KwXxjdefOEsXi%_r=sBwCfqTHJE$EYOh>?qq{xsU!c*f{V ziT2}IuVkw;x0*8%!Hsl5g$cIMIad;qU7w-g04qz(Rq}i5MFF?U-Wfs8IeOtYNyVW{OBuo0n%b zaOmz&0Dpd$7QMhOi&x$x;7&=@uiSU!7<7cXvqlzgVP{Mz<<`o^hG4tY>?>4D=_);Gl#->fORim2=1u#tCCsNdK9gq#d z6_HgyfDwalr>dPTo_SIZ{kT;OFfsHp;Vuy5DgLvto_%-4_AH&a056Chn$BJegTRTi z_#h&08Vc(iq%{uC3MzD!&^{)DAOnfdSZyh&4|p>!Br&#xwF$2>7v#~CM~ONMkq-(C zs9CbI)?Z1-J*}=DH)@ZaZ^S+FA zlX2jr=EaY%l%4_}efn(1tN>(qIPu>%y){|M=Q-FM{KKZLJ1V8N#S z^V}UPo|Z&ps)~CTA7nd~ss}-h7N8-XQvztk+UL`K05J@R#FUFmFE9=B>2a~=N5QZH zb&uSclW#g052j>~MeGk1URz9qpv1e)8pM_4_*5nno(4=Y}0u zo$mhHyAI9C>n8GhdhgY+?O@pV`#P=P_WhVcR0ZtRR}+8S9?aI;34Yy&LL)uL^aQeX zD43AVx;RE5xg&(|K*agG3q<$^{Z2EchNYCRDRTJNPFFXxOr3f-TWfD)>~)j;2WtmR zpJ=-lLojMUQwjRU5<{m)U`i_kzF1D9v7!!pNa_TOX$Y_ZIwZlgn$`O3I!t?T_k+>K zLX?5y2{(u!l!6rQR6vky;FoKL@_4n^0=Dj5u5dH0rOBDIR1Q*wbvmkEF6#hbPZ?#; z=Edw9%hKt{xLYR1nnD%Qj43%t%eEtG7;acT+F@dB#7a|)i4vK*ubF@eQY(h!Yhhz+i80*^cSSds^ zz34P461NuKl}@7OuCI&Dc0q389K)}NDa{t?0Q+_#YU{9YBmK1VMOHcer54=asVph( z_94W|yVYjo&8){P>s7uRpyT3%cfNi|hTSwF6WHsO+p!+MJP;Nm2>i8+r`vAo>*c7U zB73@va=NXCCqMytEkv&4VL_lEim(ipe7WFs8*KvKv&Modq=fsR7!|?E0gDM^B`SXB z481I`AEub3$c!S0&74p=(GgYyzW(B%l56K9x32N%K^fMf0_YycSe?Y20g2BJKN;*w zXCcR~skX8fJP%tA=)o*pjIxZJgG>i>#t(Z>$9ULo`6RSS6ms)ZoyyD?p3!I>G~R5OpW0QbIp}!9yYu^yuM9WXgxdXrwgR$;;zR?em2 zyI5o|_v;lNj|)>UBg^jX9V9Py>w zW1bSZkC3HDkaCpy;pkv@b>VIL(v~TKq@jT&)1cfolDgU_q~&c7ZF=4JVKI^T0~p_K zPkSl*6$m1jCMweQ@x3|yU!Vvxvi;*fBoGi{!T$k8oB+j+OzpJNn z);C{>{hpWoUOrDPmt)8Un!X_$XM6eM-s`(BL9<3mO8cNsyRGZ?{CcQ#T+PpInQ?93 zub8O6dBW@D@7rL1+h)`oE_0}>7~4a}rcd)`mblJWem<(ZAKt<36V`2uepa^E-UWX0 z+XC`9vp|$k$-XN_-}5p1;`E8)Jn#erOY zYvSa^4%A71tjz^zIb_~`dU$Qy0y%*>2LjZ(us%I0BKM;B55>7UpDW0l)f8&=ZL6H{ zmiz(}3W1%T&vutAu94dw4eK@ANb; ztBbzwi@U|S`9mqkwpUUq4CiQmu8(bpwB#1{H`ju!duX}fY_74sQ7{6wZ%_rDOu{v>R(R#*EuF;qC3qXdz*J*n*+RsM9 zI8$JO;p^OptLvKcGS=ql)YrTDh5KdRC<92gMZlfCRQG%7(#Wmr1{mrqMIoz#wAt*` zyRd6mDM8(X{%GoMDu1c}FXPr@QC`q%{$nj<@@|^KMS`5DVxKr==Lv$OyD-g(e~mH6B(l7L_g7UM`clz3el zP}D&c{`4z+QFto^@d5^kDxXM;Z|yXMgkq;X#yoB(oLMINs1>{z^;@V~buIqb#&DBP zo?f1%43%FdtC^E%GCOjTns&b=q8rg$V>FvA#4=A!0KMu-JPD}eypRk!OKPfN7^84o z!FgE&%GhhFE1~S!>Xxf|2Ye14gQB%^)kB8{Ni(bOB<_lj8a)}dN zaBq-32rZlvo{maR%BnrLEckQLSN=`i<8R1@Q35WU7idk(9f|t1OP9%(&J|`jChUbS z%sr7WJd*d18RpIt@=}||mZJfMm(6DAe0HEq)3P!wnKe&r5N~mfwq-p?HE`KvB`OE5 zKW#W47gr#;2kzRQn4ZqeZ?}MTW-CYqHb=G(H!Jrs;$LcSI|`sgvuPCn_EVIv|C3B< zAdrzYJnmmk1b>z}3ax3O=2;%wFfR$kR8&#npih}BYE>v0U)sM;sj44=?Q)VsO2q}_ zfxQBh6qF30xCCYt!kPa3bir~6R{;et0t+#Tx_li(v;@OwIK8!mk|Lco)B*Zh?$*jnHt=FkWhX$tvcZj!JD zg*zwBL#5Bt-b3U5C^!QO$~7%bwEl3GF{B{L7@ns3V+ljo^xyjD{ev3LA1k%2wGP+C zd>Tz$*b~&k&I~T=YX~5!C{ttys*hfi=7oQ8EcjD#j@T=}(h^){9`TyDC^M$Yw8WBN z^@bHZgUD1$Zq5WYk~Q_^)5_^{1=7T7l*x|RV>c}E7_B1Qr*4OBAjBXyD505qu0{0J zio>SO#+W$KyI?Ht%y!r#Ifem~n?T8W@g|^oBe+9Hq7-nm67S>OV5FW!i{B$nTj~sHLMrTuL}ayhJz;7= zwZlktqGrSq+3~JpcXfAhM(ro=BJBr1jU@OOFlxw5$%GCz&TwJN-f9PB4 z=2Dv43S=A0oCs0bhqOlQG1}co2dcLuo8=v{(^Fc}yJNGx2nq!`N2V2?*M>W7M8TuF8RwlWn#mlZSrtsq$r z!_Lv@#wIXKjZk?EWlBo+78m6o@R-0BAU=z_C7$g%t>YHfn)8@v4z&SwF)eO`EH1RB ztg??$qD=&a;RF@*3^6rWbQ2f%vSgyvM(lz#bvc~1Bz1FL0Cd$RL1;!DLcz+g9dp7G zB*|^c>X9ybl>;6%=F0dqjmLlYBXCKw8%@&YH7#X$7>Opw z0<1u{q=L8YpGhKvInQX#`y8rc*^GS23-(mzB>)bC6VyB^qj%xYAmnMZx;jrKBH7?t)_r;(Uo=aqE<>?{VYgRAY;O{(rtp`{j30Qf}S{UoZ^sCWU-=$nL=QZEc_X-h1ItRmV2_j3#B{H{i5g% z@1C~v4d-+e7R2y{FzJt5AyKqtZZay0Jv?ku$ec(24vL>S@S`vU0>KmJc~fzPO705v zYN_btgnziFBN8Wf##|}#`wZkn2RV+iN`eNw2|1p)@uIXbp&147{&N>R%$xNtiwW5* ze!Ovc1CdWC2Lzd)-qGaOC+<-*u6gK*s#7FH5}@(Il86HIywdeIp8Vz9Uad}wM1GgvO^cTAP-@92JA{^ab^T;~r7v0g%*%*=e`iDVib=}SPEB5- zI>l&jGcbfBdg!Au?u_>xTH6E zeCwqpd)l*F|2~UOo91%kO$h(~PD#-6m>n`)%IfjZlh&l5keQ3CtQlTSCjTXOPd+Hs zhy3`VLnbpqx+)#R9&SzB7HpkHo6z$}C~Vw^rf462e@Ot*-)e@G{vE=_iMO0g(IEri zK>>!~Z&=ut^pphF=jfkPY`Z1wD!>>4dX37Pw;{4a1aizu^rkIg>u{3-W6`1O-?T=w z&y$w7i8;owc?T^}T6q!NKxQfIOydn zNdvFk3`&A#5hnEh)iSEjL!HC5=&u@M#(aqyXioH^b~O9gne&jj`lBw*N$;XgboXTW zFIwwc4vX+^+ENEkqgd2QdsB(tM})}50yJM_%~O~L_AtkmDUJHl=Yq;r%gl^LGK{Hu zItTdvdyMki$q?<+n!$XfpxE-Z#xn2cfX6$KOW$W-9}d0XOeS7JUpZ{Isijb&Qmt(y zJtv@18-oXrfCHa*%;r(hc9Yx3OqaMVk*&hc;2`KqWyWF|(&Qe*#iU_p_fYbB`^WX- zuIpL`HPlL*_4VgFpyG7SknjEX32_tj!*7eGPHOc-`VtV1qN=0i!~;lzF2%8FM{Nd?YfDKR--0Qu@*G4o<48IlTTky^2l|%JoLA_ zbpO0J_m^pG+IIYIo}7vLuRia&yurYrurD*C;9 zQLg8$ia8hQ($F4?-7p!f?8p=#Nb*d79iNO8XMBtPG5@b{wu%9KR2KmRgvAyFkvWtmB9z*RM7${$~UFB=~>$RTARH5POK z2o6R9S++`nFI=a?!CWg^hwLxtgJ%&Z?ECVlgXYD|@GU{5A4PRNL>^lRik$y&YW(nc zd$nVIa2T8u;ya<@%IazIajXx2&%GWYI-rW>U$R_p8Mo(fH${QSb# zWmd}FdZ4w3y=Mhs}+JsV(`| zA2kRTU;IL+eT=zwj?$o!9ef@I%`h!ioS?Z&>6^I3l0XiUDEe#2sf%GNeCh;CipEF~ zcU(cL1CqN4RMzSbg}dKZ;@yP7K;K&)Wi|-D56Ts?hkbwYCl%A(ofR`8z7%>zXYJKstu221M)nnY?2c8bS=K@?HG=*)9kr>BAYUh(1RA|RcM8TsyVxgU)e zI8W{HJ{Zd^{xaVC-UO>ntSy@R^R7Pd1@POwWWDGUk5PYldqItF6a50N>X`0eK&$C} zAkZ9Z3f^JQ_y?06C6aHa-w0WDcugBlR?c~#Q?e*=K8tCogHc?*3ertuLM%&meT0<8ykiw{^bzw%2b1*4t7T`5r{W5z!DjZ<&T{ z6yj@?9YXI&%YA@s_#UqA0^ui-nhi8uTRzz8`Y$!232nP2Pg?w$yPwEq94{ZAXvg5M z@2RwEDn9gsIAs_p!b({rC(sOu^2yBFuf9{yg^#)eUN`JtwD-&O)tTClXu`I~-t{!v z8N8VTt;BY4Jh)ryR$Ru8ja(y`$lDzfz{;DeJlQyp95{jj7YqeVT!kFhj~|4Bv~6-r z^g^+YAgug!3mem34Ccpgp%&qLlli8MpCtMJ7zx;(SNlj!h;XlXfntlnF)vH*Rc$)E ztykBdzm@iHQ_aWaE~fl3|FI*h|C!Pq*_Zo!#N@?rOW>-x*Lqdm9~bYA6rvjbRLuaF z6;Il$%ld7zB)z&0B)yqve`LEZd*X1L331pasRBnm{*`kl7*_4c2DC=7OVpczPpD-| zv1m9@_393$K{#QW*W<@BrZCWKAhJRgl&7+jY$E>n-TRkg`u$=O^}uE#+Z$TNCm0xa z3uu*`R%zTg1F5TMG7e3!fjo{l5L)finwMrsxpd^Il9tH_;S;>(@Y1a{{famz1%fy2 zIgGGr{S*GV0c3wVvJwh2gr&=1wQoKAt>%88q^q|X%!B)+og9vw`nX*)c}zWzRKKl> zWAnExmyQa5sD5{d4F-Qm;$vvNx7)~re+F&qzF^ytuhvF08>u1ai67sBws5iLVy-_r zN1z$1@3+SL0st4yyI4<26~B3_i9XJ9ya|Q>G9oWTwPT#b@VAaA!aRblkSu?TfS4FJ zoR~cKn4#V-iXPZopMIVrOA&>fN4F=e%abcR&oyBp&)155BipKGOTzhC;KlWzF7;&E zas)em7s$#8TMIFCF+PE@{Z=n26g3Hfu_Bf5q!cZz1a4-AeORv)Tqub-JvZ4*9cDu@ zfZoC`p^_v*u4&B#>yHRRHqs7?X|6C#o#Im}?G6e>E|?R2t}sTOA}NGc2}%HiDmQ38 zEauw$H_w|*5S)_rw~Yt~|35DO=bZ6Y0ZUs-)i7Z!x*!sGOyRg-y5mSMnEx*~m|tjg zEX`FeR;#95h5!HImo)tZM4@Xa{vPT&3})WSx5Wkj=Ys$5p;D+C{?Bnb z4;K5Dg>_bO=T>{>*$E=~ITzwT1~Y06&4E2Y<9VRj?u|9$NFodReOFzV8K^$wU%v!Kgs#LYKl;+?_VMFc!Y--CvBk6upkh*Q0kSAp9!F`5`gYk{V>5%K)J87wn-Jic007_NAYZ-XU7kj z>D7B#Vc`dk9duav@XshvKho!diJ9Sq*5%`kMM*byDmp;WEu!>BSb~@+a0JyA;R&xQA)=EfS%&>ATodHkhf!Ar z$MGs7P2^Za8H=&xPE;xlfl)0Z1xq>;fHuV#%C>|7$bCEJUII5s+?aq@*O24nb)c zQj`IP?rsDL1!QOtkRhbIyE}#sN$F5h>OK1Sz9P@_t#5t5zxS*)vnKX+owLv0_ulut z_kGQT2m@?!rs!~qQXL7fl7itl2TY;q=Hp2(bE2V$VgnOpR^riUc!amUCaYK;Qy&-} zA@e`gBTkLAR2jmqLJFKWS4%uALsc$OWjOnzVm26#uLyi(n)X+br&qa$w-)I2wdu5A*1v$8O?zQ2 zk@&!1LjSx$$)nFk8NO!LwwMz?aUw55tDTcbqnGx!K3W8$&q+rwGjEsg2D|6?4hxGx zu4Ko4zsrfGR_Fu$o#CxS`=bNlcM8nx#nR`W)pukyJ=u@aRrHpGzwX@GRuN(9sn>%( z3^iJ*d(R?#EHDPibodxWzBQk6_#N6y{U!;%@-}0t+*P2)EP?!nS{?KM&>kqkMyndZmw6LJR7;EP-JTn5yp`KOKF?fZfvh&B~tVx&BhiHaFV11qK=PwWWc^u zx6vu8Usc{-neRHv&~a){Nv)=`POBjcU$*(om%TdrU{qGaR=?wvXVW>eH`I7|&Q_Qi ztuM5=zwqgSddH4Ga%x8#(DW&`*?7K5{D!4VAk?_U#V;m`h!Y>GtXG{z_udtGolhMX zHV1pk651-dT3(@3CtI3djwWeK89aFr8J311RtT#}bK;DP4lOEhd$MAh1*Ft5Y4 zmiH9xLhejm*isHNto=bQ;@gr#D-iQTeJ`9?vHkE@y_oY(0*|Uk@q!C>SM&XBvGL2$ zXwlZE!iE_p*H+{~WVUx_tMkAIl>$4oT?!sx?wAkTljjh8FQI*u`boGauHeDQrzedk z6o zMSUoKXf5*1b1F6m!+h(4>f6NOP2un+_=@rEGBvkP!eaVCl}#iO?_Gy?d)L7D+bo@w>(<5uN zi$@oYxx3?LOEurDcNQLFM!kwP8e9e0#27*opyqf+>Xhf9H0A5=a?`=j^HR%RY*>;P zFUN_^*Dpz6M&=a`lP}PLbQiIvhjWIzzil|MWABNBxbJOrvKrfV>v$KmOuz1)LbEo!JyYu&JSP7?*T404RSUdE4R#2jAzn^RWh)v4;tg$N}T4m+;D9>Z8f7(|w z4(o|I2eSV_{8zHREbM{&CmUdA?MEKaX8cUp0xv=P4)Xz-Qo3&6k|0V+k7+=-Y4(gN zJTZHWo~VGgkVdevkscXq5fsO7B#^^0?;X zF5E`s-Wr|~oEF4bsv07bdJzQ+x7=oYuUC|`L^vg^FD9p|DLkEu*A`W|{iAMeT2aIt z@L6*VM9bhG*(ctRBSLhz_rVKaa-|a@N}bsAh0*JKz(A}8amG83;QJVqM$`ScpLz7P zw%I0+Bn@9Xe@PfXr#)i^t>UF5tLsaP@*RtDvX zhai6{dD-x%yS5Yd&&w|G2_RGnUwjw!vYaSc2=B)^yQz`1gX+!>%0Ed*uVn@8qfxL@`l!-omv>@BZN+4ZPUKY;h+fKKEuESoxlc*py}@3Vj}MuV`Q)Yu)NG4 z9Qf^I`QzBGN{@9Eh|4{D)3hqgI6Q<~*WSUNb&8W=W?GKt)g1@2@6CnFQ;X-Mokcm~ z{%@i((@oU-VGTJp2YgW=?AFlpxN-RY9gHP-K~9b|#igr5DapR+xQaumE4DL_Ia9U3 zET1QjIb*c|whNCrOLg4bCR`~3l&g}=R6QAH>2k}6T|0rPnxt&!V7tA22h>gqf{gVW zJ`4w4o=NdaW%K2i+9mkpe<2Ou+S*X3Gqu#KSNDNf>fOQ`o~=uweCB#OIa`CMqM+$&3Do z{YYo#cv`R@_PBwPFtTjx_uiz1Bc@_G$DvAXG`*We{`w-TtvRVbDW!<#5arc>APu zb4N5MbA{wFj#(cE7U&LK64d|IWpt0COIyWEIai{T5U%y_7rMgP^8|xd2bM%;HEJm4 z%iFt%#hb7x-3L;|)0#Nq< z_Yu-x7~ITp6ZP}?=h;RR%YL-%-CDc}O2X6?ToMoZl;{8ndHku>;RPDwrANCp602Xdyy>fS z#+r7I#c!*}$A{aROS947=J)bS1I-;q5!rX38z|>4TGJtKU&&Id)2c_%ne^YRiuX9T zsg6&Vjc)Tj7?MX(P*RI-Z8^g3jiJndVbW8@FtJKwcpgmNeR4TLz^4-A6Xn)vtGj)U zyNH+#+2>(nQs6h9BbY&_?>4Q?*Te~vjSIP(VLb&}EPL*vY9bNK`L?(tF_}__+}vli zN7^d;y)t;h_r*Gys#<|i13bPX9Mzi7cUPZsb?H=#NgfDPC-=5N(u; z8| z1~_iRjwpT7Le`BTN4{G%$+Ec4-qNqpM5$59qvh*wgy;Ma;GYC`)P5`1OPw6Y!3I9xa86}3!t&kjtA4>@e#HU zDpH%%i1B`0S0QANv|;oa>%x;rD@i4)Rm*#_S8-SFz20Zs$G3|^&C$QKsI?X#2X22^ zr0sl)%IOO!wME|(UZQ~47Oy8$%<^B(O~l+rR7bBAZE}zuJ7G{6_}%<^(Cv<#K-Yx4ZX#N@epIa87y{hzO!gQTp@6by)o~<23 z39;`iVgw19cN3z5ybdylb_0!2J< zsjDKw2z@3_i>=HJd*7#!lNGUYsRPU!03B9j+mvhq-CRpl7uHaPr;zZPRCtQ(eF=Zs``qZ`hAsxBGrdGGCRPWR%XC2E zrQ0Qf_m(w~-2U6-^naR{KJ_bL`U2vvdG`;F==@&q*mPcFiqDLS zr{q{fJd6|dpd}WwoTL26uxfKmt{WpcDrBxKMor4X=ohqT@Zsam#e{8f8acf${jqgY zsL!DG;)n6bk4t{H<{$J$N8D|RGLU1Ib$I2TZ7j#Lpv4s(h05>@Pi@yZ{;?g>H{!d5 zeY?V$z1~s|%-z8Hh{D9248cff*!fm=fWl=!); z=4fpA{7Rl^RHWQfV76`Fk#-AYavZg&ku1dli&N6-F4*@!D-V@kVC+}&PJtjP9Q0Tiu(lL%CR82}j9cQx=d(Y-OQHb-~=UFc_T6}5w zjmX-z#2ZuJBIPOdaK{X+8leThHgTiN)f-#~nebFi3lMx3K1fsT9@dGYkiUF^mHyFc zwGds{G$SWd>|ISVceI*W!f|mZu%fRA3KacuBO) zZ!XsMc57r(y6b$Y2UZetLg-kwQ~QfPU0~Fw&fq9=pp1Af*e%gI$}xZ92_VOyY4>FP z79FsRB%qxl9>`>zSntjj%sxJGhbDAPp?t*@BI(5|&07DNWTwSntFaX3 zttAw9bXwiEC~I)OZ#6u`>oEWb7yhBSgp=<@tpUxo3N#n))dAPQ%Ib$7@Za$k=)=H~ z@La+29u;n_`nsovb@*Pn4%TheFeZx0wrsx6*n(nSOf2+*J4a)VfA$HbC6j40P4@hpxAWBZk#-0ZYMa@|drlTvz$eNhxOZ4G(uwI@8L2B(kr}-%9 zW8PL}dd)hTILWil5E@Lg$#f*)bP5O(5BtOW(5t7}+>dME}HmP>;(#Z6m zj{cCWMczmwd%5AeD=xW7l`Q|Im^h8NxlRD~o&fK(+mmq(Qee-rtvx8w)nG#2v`Z!U zRw{oX_7-uk!Xb!wghN+<3nx{G{ZO~!@#i*03FHm`A-In)+mQ z39TihhQ4@BB+F@>pURqT7%$1~)&q(uU|R{Nj6(it0d`%}h6>_NoUjTs<|wR0Gkm6f zIc-A!H4O9-D{yMylJVj{jxr(=D=>2XTYu}YwBiyA7)T-T{q4W{!j)(3$AHspY+<$sPh+#E-N8Bh%hty0&Zr0zzN)&7T_L-(<-cznHFaT)&X(66D`- zqKsegtAga~@av-1-|!omzuYyj68+_XP3;f4Q@pb&4%O$_jzyiuJ z!j-W3pB7K9bNv}~U*%$hU*-BU1i#L5J@)*~0~!5Qqdy|i>-axIgx_cc1k?!xguew0 z*WrIUXIJ6fQ`al;(^b1paNWWAP0=y^>-w*`JJ%WhoO6HU0rc#Z8vL4pmE?Y?!GFZ* P_z3TSU4rQOAMgGJ5n3vV literal 0 HcmV?d00001 diff --git a/DealerPar.cpp b/DealerPar.cpp index ddf04306..f2954c0c 100644 --- a/DealerPar.cpp +++ b/DealerPar.cpp @@ -1,13 +1,11 @@ /* - DDS 2.6.0 A bridge double dummy solver. + DDS 2.7.0 A bridge double dummy solver. Copyright (C) 2006-2014 by Bo Haglund Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. The code for calculation of par score / contracts is based upon the perl code written by Matthew Kidd for ACBLmerge. He has kindly given me permission to include a C++ adaptation in DDS. -*/ -/* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at @@ -21,65 +19,162 @@ permissions and limitations under the License. */ - /* The PlayAnalyser was written by Sören Hein. Many thanks for - allowing me to include it in DDS. */ +/* + The PlayAnalyser was written by Sören Hein. Many thanks for + allowing me to include it in DDS. +*/ -/*#include "stdafx.h"*/ -#include "dll.h" #include "dds.h" -#include "DealerPar.h" -/* - This is surprisingly difficult to implement properly. - I'm reasonably confident in the below implementation, - having tested it extensively, but who knows? - The below is probably also rather fast. - I've tested it against ACBLmerge.pl (which is buggy as - of May 2014), and this is about 4 times faster (in Perl). - - - Soren Hein, June 2014 -*/ -#if 0 -int STDCALL CalcDealerParPBN( - struct ddTableDealPBN tableDealPBN, - struct ddTableResults * tablep, - int dealer, - int vulnerable, - struct parResultsDealer * presp) +/* First index: 0 nonvul, 1 vul. Second index: tricks down */ +int DOUBLED_SCORES[2][14] = { - struct ddTableDeal tableDeal; + { 0, 100, 300, 500, 800, 1100, 1400, 1700, + 2000, 2300, 2600, 2900, 3200, 3500 }, + { 0, 200, 500, 800, 1100, 1400, 1700, 2000, + 2300, 2600, 2900, 3200, 3500, 3800 } +}; - if (ConvertFromPBN(tableDealPBN.cards, tableDeal.cards) != 1) - return RETURN_PBN_FAULT; +/* First index is contract number, + 0 is pass, 1 is 1C, ..., 35 is 7NT. + Second index is 0 nonvul, 1 vul. */ - int res = CalcDealerPar(tableDeal, dealer, vulnerable, tablep, presp); - return res; -} +int SCORES[36][2] = +{ + { 0, 0}, + { 70, 70}, { 70, 70}, { 80, 80}, { 80, 80}, { 90, 90}, + { 90, 90}, { 90, 90}, { 110, 110}, { 110, 110}, { 120, 120}, + { 110, 110}, { 110, 110}, { 140, 140}, { 140, 140}, { 400, 600}, + { 130, 130}, { 130, 130}, { 420, 620}, { 420, 620}, { 430, 630}, + { 400, 600}, { 400, 600}, { 450, 650}, { 450, 650}, { 460, 660}, + { 920, 1370}, { 920, 1370}, { 980, 1430}, { 980, 1430}, { 990, 1440}, + {1440, 2140}, {1440, 2140}, {1510, 2210}, {1510, 2210}, {1520, 2220} +}; + +/* Second index is contract number, 0 .. 35. + First index is vul: none, only defender, only declarer, both. */ + +int DOWN_TARGET[36][4] = +{ + {0,0,0,0}, + {0,0,0,0}, {0,0,0,0}, {0,0,0,0}, {0,0,0,0}, {0,0,0,0}, + {0,0,0,0}, {0,0,0,0}, {1,0,1,0}, {1,0,1,0}, {1,0,1,0}, + {1,0,1,0}, {1,0,1,0}, {1,0,1,0}, {1,0,1,0}, {2,1,3,2}, + {1,0,1,0}, {1,0,1,0}, {2,1,3,2}, {2,1,3,2}, {2,1,3,2}, + {2,1,3,2}, {2,1,3,2}, {2,1,3,2}, {2,1,3,2}, {2,1,3,2}, + {4,3,5,4}, {4,3,5,4}, {4,3,6,5}, {4,3,6,5}, {4,3,6,5}, + {6,5,8,7}, {6,5,8,7}, {6,5,8,7}, {6,5,8,7}, {6,5,8,7} +}; + +int FLOOR_CONTRACT[36] = +{ + 0, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, + 1, 2, 3, 4, 15, 1, 2, 18, 19, 15, + 21, 22, 18, 19, 15, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35 +}; + +char NUMBER_TO_CONTRACT[36][3] = +{ + "0", + "1C", "1D", "1H", "1S", "1N", + "2C", "2D", "2H", "2S", "2N", + "3C", "3D", "3H", "3S", "3N", + "4C", "4D", "4H", "4S", "4N", + "5C", "5D", "5H", "5S", "5N", + "6C", "6D", "6H", "6S", "6N", + "7C", "7D", "7H", "7S", "7N" +}; + +char NUMBER_TO_PLAYER[4][2] = { "N", "E", "S", "W" }; + +/* First index is vul: none, both, NS, EW. + Second index is vul (0, 1) for NS and then EW. */ +int VUL_LOOKUP[4][2] = { {0, 0}, {1, 1}, {1, 0}, {0, 1} }; + +/* First vul is declarer (not necessarily NS), second is defender. */ +int VUL_TO_NO[2][2] = { {0, 1}, {2, 3} }; -int STDCALL CalcDealerPar( - struct ddTableDeal tableDeal, +/* Maps DDS order (S, H, D, C, NT) to par order (C, D, H, S, NT). */ +int DENOM_ORDER[5] = { 3, 2, 1, 0, 4 }; + + +struct data_type +{ + int primacy; + int highest_making_no; + int dearest_making_no; + int dearest_score; + int vul_no; +}; + +struct list_type +{ + int score; + int dno; + int no; + int tricks; + int down; +}; + + +#define BIGNUM 9999 + + +void survey_scores( + struct ddTableResults * tablep, int dealer, - int vulnerable, + int vul_by_side[2], + struct data_type * data, + int * num_candidates, + struct list_type list[2][5]); + +void best_sacrifice( struct ddTableResults * tablep, - struct parResultsDealer * presp) -{ - int STDCALL DealerPar( + int side, + int no, + int dno, + int dealer, + struct list_type list[2][5], + int sacr[5][5], + int * best_down); + +void sacrifices_as_text( struct ddTableResults * tablep, - struct parResultsDealer * presp, + int side, int dealer, - int vulnerable); + int best_down, + int no_decl, + int dno, + struct list_type list[2][5], + int sacr[5][5], + char results[10][10], + int * res_no); + +void reduce_contract( + int * no, + int sac_vul, + int down, + int * plus); + +void contract_as_text( + struct ddTableResults * tablep, + int side, + int no, + int dno, + int down, + char str[10]); + +void sacrifice_as_text( + int no, + int pno, + int down, + char str[10]); - int res = CalcDDtable(tableDeal, tablep); - if (res != RETURN_NO_FAULT) - return res; - res = DealerPar(tablep, presp, dealer, vulnerable); - return res; -} -#endif int STDCALL DealerPar( struct ddTableResults * tablep, diff --git a/Exports.def b/Exports.def new file mode 100644 index 00000000..9ecc7cd4 --- /dev/null +++ b/Exports.def @@ -0,0 +1,54 @@ +LIBRARY dds +EXPORTS + SetMaxThreads + SetMaxThreads@4 = SetMaxThreads + FreeMemory + FreeMemory@0 = FreeMemory + SolveBoard + SolveBoard@116 = SolveBoard + SolveBoardPBN + SolveBoardPBN@132 = SolveBoardPBN + CalcDDtable + CalcDDtable@68 = CalcDDtable + CalcDDtablePBN + CalcDDtablePBN@84 = CalcDDtablePBN + SolveAllBoards + SolveAllBoards@8 = SolveAllBoards + SolveAllChunks + SolveAllChunks@12 = SolveAllChunks + SolveAllChunksBin + SolveAllChunksBin@12 = SolveAllChunksBin + SolveAllChunksPBN + SolveAllChunksPBN@12 = SolveAllChunksPBN + CalcAllTables + CalcAllTables@20 = CalcAllTables + CalcAllTablesPBN + CalcAllTablesPBN@20 = CalcAllTablesPBN + CalcPar + CalcPar@76 = CalcPar + SidesPar + SidesPar@12 = SidesPar + SidesParBin + SidesParBin@12 = SidesParBin + CalcParPBN + CalcParPBN@92 = CalcParPBN + Par + Par@12 = Par + DealerPar + DealerPar@16 = DealerPar + DealerParBin + DealerParBin@12 = DealerParBin + ConvertToDealerTextFormat + ConvertToDealerTextFormat@8 = ConvertToDealerTextFormat + ConvertToSidesTextFormat + ConvertToSidesTextFormat@8 = ConvertToSidesTextFormat + AnalysePlayBin + AnalysePlayBin@524 = AnalysePlayBin + AnalysePlayPBN + AnalysePlayPBN@230 = AnalysePlayPBN + AnalyseAllPlaysBin + AnalyseAllPlaysBin@16 = AnalyseAllPlaysBin + AnalyseAllPlaysPBN + AnalyseAllPlaysPBN16 = AnalyseAllPlaysPBN + + diff --git a/Init.cpp b/Init.cpp new file mode 100644 index 00000000..89be16e0 --- /dev/null +++ b/Init.cpp @@ -0,0 +1,737 @@ +/* + DDS 2.7.0 A bridge double dummy solver. + Copyright (C) 2006-2014 by Bo Haglund + Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. + The code for calculation of par score / contracts is based upon the + perl code written by Matthew Kidd for ACBLmerge. He has kindly given + permission to include a C++ adaptation in DDS. + + The PlayAnalyser analyses the played cards of the deal and presents + their double dummy values. The par calculation function DealerPar + provides an alternative way of calculating and presenting par + results. Both these functions have been written by Soren Hein. + He has also made numerous contributions to the code, especially in + the initialization part. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + + +#include "dds.h" +#include "Init.h" +#include "Stats.h" +#include "ABsearch.h" + +inline bool WinningMove( + struct moveType * mvp1, + struct moveType * mvp2, + int trump); + +void InitConstants(); +void InitDebugFiles(); + +struct localVarType localVar[MAXNOOFTHREADS]; +int noOfThreads; + +int lho[DDS_HANDS] = { 1, 2, 3, 0 }; +int rho[DDS_HANDS] = { 3, 0, 1, 2 }; +int partner[DDS_HANDS] = { 2, 3, 0, 1 }; + +// bitMapRank[absolute rank] is the absolute suit corresponding +// to that rank. The absolute rank is 2 .. 14, but it is useful +// for some reason that I have forgotten to have number 15 +// set as well :-). + +unsigned short int bitMapRank[16] = +{ + 0x0000, 0x0000, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, + 0x0040, 0x0080, 0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000 +}; + +unsigned char cardRank[16] = +{ + 'x', 'x', '2', '3', '4', '5', '6', '7', + '8', '9', 'T', 'J', 'Q', 'K', 'A', '-' +}; + +unsigned char cardSuit[DDS_STRAINS] = +{ + 'S', 'H', 'D', 'C', 'N' +}; + + +unsigned char cardHand[DDS_HANDS] = +{ + 'N', 'E', 'S', 'W' +}; + +// There is no particular reason for the different types here, +// other than historical ones. They could all be char's for +// memory reasons, or all be int's for performance reasons. + +int highestRank[8192]; +int counttable[8192]; +char relRank[8192][15]; +unsigned short int winRanks[8192][14]; + + +int _initialized = 0; + +void STDCALL SetMaxThreads( + int userThreads) +{ + if (! _initialized) + { + noOfThreads = 0; + + InitConstants(); + + InitDebugFiles(); + } + _initialized = 1; + + InitTimer(); + InitTimerList(); + + // First figure out how much memory we have available + // and how many cores the system has. + int oldNoOfThreads = noOfThreads; + unsigned long long kilobytesFree = 0; + int ncores = 1; + +#ifdef DDS_THREADS_SINGLE + noOfThreads = 1; +#else + #if defined(_WIN32) || defined(__CYGWIN__) + /* Using GlobalMemoryStatusEx instead of GlobalMemoryStatus + was suggested by Lorne Anderson. */ + MEMORYSTATUSEX statex; + statex.dwLength = sizeof(statex); + GlobalMemoryStatusEx(&statex); + kilobytesFree = (unsigned long long) statex.ullTotalPhys / 1024; + + SYSTEM_INFO sysinfo; + GetSystemInfo(&sysinfo); + ncores = (int) sysinfo.dwNumberOfProcessors; + #endif + + #ifdef __linux__ + /* The code for linux was suggested by Antony Lee. */ + FILE* fifo = popen( + "free -k | tail -n+3 | head -n1 | awk '{print $NF}'", "r"); + fscanf(fifo, "%lld", &kilobytesFree); + fclose(fifo); + + ncores = sysconf(_SC_NPROCESSORS_ONLN); + #endif +#endif + + // 70%, capped at 2 GB. + int kilobytesUsable = (int) (0.70 * kilobytesFree); + if (kilobytesUsable > 2000000) + kilobytesUsable = 2000000; + + if (userThreads) + noOfThreads = Min(ncores, userThreads); + else + noOfThreads = ncores; + + int deltaThreads = noOfThreads - oldNoOfThreads; + + int mem_def, mem_max; + + if (deltaThreads <= 0) + { + // We already have the memory. + mem_def = THREADMEM_DEF_MB; + mem_max = THREADMEM_MAX_MB; + } + else if (kilobytesUsable == 0 || noOfThreads == 1) + { + // Take our chances with default values. + mem_def = THREADMEM_DEF_MB; + mem_max = THREADMEM_MAX_MB; + } + else if (kilobytesUsable >= 1024 * THREADMEM_MAX_MB * deltaThreads) + { + // Comfortable. + mem_def = THREADMEM_DEF_MB; + mem_max = THREADMEM_MAX_MB; + } + else if (kilobytesUsable >= 1024 * THREADMEM_DEF_MB * deltaThreads) + { + // Slightly less comfortable, cap the maximum, + // but make the maximum number of threads. + mem_def = THREADMEM_DEF_MB; + mem_max = THREADMEM_DEF_MB; + } + else + { + // Limit the number of threads to the available memory. + int fittingThreads = (int) kilobytesUsable / + ( (double) 1024. * THREADMEM_DEF_MB ); + + noOfThreads = Max(fittingThreads, 1); + mem_def = THREADMEM_DEF_MB; + mem_max = THREADMEM_DEF_MB; + } + + for (int k = 0; k < noOfThreads; k++) + { + localVar[k].transTable.SetMemoryDefault(mem_def); + localVar[k].transTable.SetMemoryMaximum(mem_max); + } + + if (noOfThreads == oldNoOfThreads) + { + // Must already have TT allocated. + } + else if (noOfThreads > oldNoOfThreads) + { + for (int k = oldNoOfThreads; k < noOfThreads; k++) + localVar[k].transTable.MakeTT(); + } + else + { + for (int k = noOfThreads; k < oldNoOfThreads; k++) + localVar[k].transTable.ReturnAllMemory(); + } + +} + + +void InitConstants() +{ + // highestRank[aggr] is the highest absolute rank in the + // suit represented by aggr. The absolute rank is 2 .. 14. + highestRank[0] = 0; + for (int aggr = 1; aggr < 8192; aggr++) + { + for (int r = 14; r >= 2; r--) + { + if (aggr & bitMapRank[r]) + { + highestRank[aggr] = r; + break; + } + } + } + + /* The use of the counttable to give the number of bits set to + one in an integer follows an implementation by Thomas Andrews. */ + + // counttable[aggr] is the number of '1' bits (binary weight) + // in aggr. + for (int aggr = 0; aggr < 8192; aggr++) + { + counttable[aggr] = 0; + for (int r = 0; r < 13; r++) + { + if (aggr & (1 << r)) + { + counttable[aggr]++; + } + } + } + + // relRank[aggr][absolute rank] is the relative rank of + // that absolute rank in the suit represented by aggr. + // The relative rank is 2 .. 14. + memset(relRank[0], 0, 15); + for (int aggr = 1; aggr < 8192; aggr++) + { + int ord = 0; + for (int r = 14; r >= 2; r--) + { + if (aggr & bitMapRank[r]) + { + ord++; + relRank[aggr][r] = ord; + } + } + } + + // winRanks[aggr][leastWin] is the absolute suit represented + // by aggr, but limited to its top "leastWin" bits. + for (int aggr = 0; aggr < 8192; aggr++) + { + winRanks[aggr][0] = 0; + for (int leastWin = 1; leastWin < 14; leastWin++) + { + int res = 0; + int nextBitNo = 1; + for (int r = 14; r >= 2; r--) + { + if (aggr & bitMapRank[r]) + { + if (nextBitNo <= leastWin) + { + res |= bitMapRank[r]; + nextBitNo++; + } + else + break; + } + } + winRanks[aggr][leastWin] = res; + } + } +} + + +void InitDebugFiles() +{ + for (int k = 0; k < noOfThreads; k++) + { +#ifdef DDS_TOP_LEVEL + InitFileTopLevel(k); +#endif + +#ifdef DDS_AB_STATS + InitFileABstats(k); +#endif + +#ifdef DDS_AB_HITS + InitFilesABhits(k); +#endif + +#ifdef DDS_TT_STATS + InitFileTTstats(k); +#endif + +#ifdef DDS_TIMING + InitFileTimer(k); +#endif + } +} + + +void CloseDebugFiles() +{ + for (int k = 0; k < noOfThreads; k++) + { +#ifdef DDS_TOP_LEVEL + CloseFileTopLevel(k); +#endif + +#ifdef DDS_AB_HITS + CloseFilesABhits(k); +#endif + } +} + + +void InitGame( + int gameNo, + bool moveTreeFlag, + int first, + int handRelFirst, + int thrId) +{ + unsigned int topBitRank = 1; + unsigned int topBitNo = 2; + struct localVarType * thrp = &localVar[thrId]; + + if (thrp->newDeal) + { + /* Initialization of the rel structure is implemented + according to a solution given by Thomas Andrews */ + + for (int s = 0; s < DDS_SUITS; s++) + { + thrp->iniPosition.aggr[s] = 0; + for (int h = 0; h < DDS_HANDS; h++) + { + thrp->iniPosition.rankInSuit[h][s] = thrp->game.suit[h][s]; + thrp->iniPosition.aggr[s] |= thrp->game.suit[h][s]; + } + } + + // rel[aggr].absRank[absolute rank][suit].hand is the hand + // (N = 0, E = 1 etc.) which holds the absolute rank in + // the suit characterized by aggr. + // rel[aggr].absRank[absolute rank][suit].rank is the + // relative rank of that card. + + for (int s = 0; s < DDS_SUITS; s++) + { + for (int ord = 1; ord <= 13; ord++) + { + thrp->rel[0].absRank[ord][s].hand = -1; + thrp->rel[0].absRank[ord][s].rank = 0; + } + } + + // handLookup[suit][absolute rank] is the hand (N = 0 etc.) + // holding the absolute rank in suit. + + int handLookup[DDS_SUITS][15]; + for (int s = 0; s < DDS_SUITS; s++) + { + for (int r = 14; r >= 2; r--) + { + handLookup[s][r] = -1; + for (int h = 0; h < DDS_HANDS; h++) + { + if (thrp->game.suit[h][s] & bitMapRank[r]) + { + handLookup[s][r] = h; + break; + } + } + } + } + + thrp->transTable.Init(handLookup); + + struct relRanksType * relp; + for (int aggr = 1; aggr < 8192; aggr++) + { + if (aggr >= (topBitRank << 1)) + { + /* Next top bit */ + topBitRank <<= 1; + topBitNo++; + } + + thrp->rel[aggr] = thrp->rel[aggr ^ topBitRank]; + relp = &thrp->rel[aggr]; + + int weight = counttable[aggr]; + for (int c = weight; c >= 2; c--) + { + for (int s = 0; s < DDS_SUITS; s++) + { + relp->absRank[c][s].hand = relp->absRank[c-1][s].hand; + relp->absRank[c][s].rank = relp->absRank[c-1][s].rank; + } + } + for (int s = 0; s < DDS_SUITS; s++) + { + relp->absRank[1][s].hand = handLookup[s][topBitNo]; + relp->absRank[1][s].rank = topBitNo; + } + } + } + + thrp->iniPosition.first[thrp->game.noOfCards - 4] = first; + thrp->iniPosition.handRelFirst = handRelFirst; + thrp->lookAheadPos = thrp->iniPosition; + + thrp->estTricks[1] = 6; + thrp->estTricks[3] = 6; + thrp->estTricks[0] = 7; + thrp->estTricks[2] = 7; + + InitSearch(&thrp->lookAheadPos, thrp->game.noOfCards - 4, + thrp->initialMoves, first, moveTreeFlag, thrId); + +} + + +void InitSearch( + struct pos * posPoint, + int depth, + struct moveType startMoves[], + int first, + bool mtd, + int thrId) +{ + + int handRelFirst, maxAgg, maxHand = 0; + int noOfStartMoves; /* Number of start moves in the 1st trick */ + int hand[3], suit[3], rank[3]; + struct moveType move; + unsigned short int startMovesBitMap[DDS_HANDS][DDS_SUITS]; + unsigned short int aggHand[DDS_HANDS][DDS_SUITS]; + + struct localVarType * thrp = &localVar[thrId]; + + for (int h = 0; h < DDS_HANDS; h++) + for (int s = 0; s < DDS_SUITS; s++) + startMovesBitMap[h][s] = 0; + + handRelFirst = posPoint->handRelFirst; + noOfStartMoves = handRelFirst; + + for (int k = 0; k <= 2; k++) + { + hand[k] = handId(first, k); + suit[k] = startMoves[k].suit; + rank[k] = startMoves[k].rank; + if (k < noOfStartMoves) + startMovesBitMap[hand[k]][suit[k]] |= bitMapRank[rank[k]]; + } + + for (int d = 0; d <= 49; d++) + { + thrp->bestMove [d].rank = 0; + thrp->bestMoveTT[d].rank = 0; + } + + if (((handId(first, handRelFirst)) == 0) || + ((handId(first, handRelFirst)) == 2)) + { + thrp->nodeTypeStore[0] = MAXNODE; + thrp->nodeTypeStore[1] = MINNODE; + thrp->nodeTypeStore[2] = MAXNODE; + thrp->nodeTypeStore[3] = MINNODE; + } + else + { + thrp->nodeTypeStore[0] = MINNODE; + thrp->nodeTypeStore[1] = MAXNODE; + thrp->nodeTypeStore[2] = MINNODE; + thrp->nodeTypeStore[3] = MAXNODE; + } + + int k = noOfStartMoves; + posPoint->first[depth] = first; + posPoint->handRelFirst = k; + + assert((posPoint->handRelFirst >= 0) && + (posPoint->handRelFirst <= 3)); + + posPoint->tricksMAX = 0; + + if (k > 0) + { + posPoint->move[depth + k] = startMoves[k - 1]; + move = startMoves[k - 1]; + } + + posPoint->high[depth + k] = first; + + while (k > 0) + { + thrp->movePly[depth + k].current = 0; + thrp->movePly[depth + k].last = 0; + thrp->movePly[depth + k].move[0].suit = startMoves[k - 1].suit; + thrp->movePly[depth + k].move[0].rank = startMoves[k - 1].rank; + if (k < noOfStartMoves) /* If there is more than one start move */ + { + if (WinningMove(&startMoves[k - 1], &move, thrp->trump)) + { + posPoint->move[depth + k].suit = startMoves[k - 1].suit; + posPoint->move[depth + k].rank = startMoves[k - 1].rank; + posPoint->high[depth + k] = handId(first, noOfStartMoves - k); + move = posPoint->move[depth + k]; + } + else + { + posPoint->move[depth + k] = posPoint->move[depth + k + 1]; + posPoint->high[depth + k] = posPoint->high[depth + k + 1]; + } + } + k--; + } + + for (int s = 0; s < DDS_SUITS; s++) + posPoint->removedRanks[s] = 0; + + for (int s = 0; s < DDS_SUITS; s++) + for (int h = 0; h < DDS_HANDS; h++) + posPoint->removedRanks[s] |= posPoint->rankInSuit[h][s]; + + for (int s = 0; s < DDS_SUITS; s++) + posPoint->removedRanks[s] = ~(posPoint->removedRanks[s]); + + for (int s = 0; s < DDS_SUITS; s++) + for (int h = 0; h < DDS_HANDS; h++) + posPoint->removedRanks[s] &= (~startMovesBitMap[h][s]); + + for (int s = 0; s < DDS_SUITS; s++) + thrp->iniRemovedRanks[s] = posPoint->removedRanks[s]; + + /* Initialize winning and second best ranks */ + for (int s = 0; s < DDS_SUITS; s++) + { + maxAgg = 0; + for (int h = 0; h < DDS_HANDS; h++) + { + aggHand[h][s] = startMovesBitMap[h][s] | thrp->game.suit[h][s]; + if (aggHand[h][s] > maxAgg) + { + maxAgg = aggHand[h][s]; + maxHand = h; + } + } + + if (maxAgg != 0) + { + posPoint->winner[s].hand = maxHand; + k = highestRank[aggHand[maxHand][s]]; + posPoint->winner[s].rank = k; + + maxAgg = 0; + for (int h = 0; h < DDS_HANDS; h++) + { + aggHand[h][s] &= (~bitMapRank[k]); + if (aggHand[h][s] > maxAgg) + { + maxAgg = aggHand[h][s]; + maxHand = h; + } + } + if (maxAgg > 0) + { + posPoint->secondBest[s].hand = maxHand; + posPoint->secondBest[s].rank = highestRank[aggHand[maxHand][s]]; + } + else + { + posPoint->secondBest[s].hand = -1; + posPoint->secondBest[s].rank = 0; + } + } + else + { + posPoint->winner[s].hand = -1; + posPoint->winner[s].rank = 0; + posPoint->secondBest[s].hand = -1; + posPoint->secondBest[s].rank = 0; + } + } + + for (int s = 0; s < DDS_SUITS; s++) + { + for (int h = 0; h < DDS_HANDS; h++) + posPoint->length[h][s] = + (unsigned char) counttable[posPoint->rankInSuit[h][s]]; + } + + // Clubs are implicit, for a given trick number. + for (int h = 0; h < DDS_HANDS; h++) + { + posPoint->handDist[h] = + (posPoint->length[h][0] << 8) | + (posPoint->length[h][1] << 4) | + (posPoint->length[h][2] ); + } + + thrp->memUsed = thrp->transTable.MemoryInUse() + + ThreadMemoryUsed(); + +#ifdef DDS_AB_STATS + thrp->ABstats.Reset(); +#endif +} + + +/* SH: Only visible in testing set-up, as not in dll.h */ + +void DDSidentify(char * s) +{ + sprintf(s, "DDS DLL\n-------\n"); +#ifdef _WIN32 + s = strcat(s, "_WIN32\n"); +#endif +#ifdef __CYGWIN__ + s = strcat(s, "__CYGWIN__\n"); +#endif +#ifdef __MINGW32__ + s = strcat(s, "__MINGW32__\n"); +#endif +#ifdef _MSC_VER + s = strcat(s, "_MSC_VER\n"); +#endif +#ifdef __cplusplus + s = strcat(s, "__cplusplus\n"); +#endif +#ifdef USES_DLLMAIN + s = strcat(s, "USES_DLLMAIN\n"); +#endif +#ifdef USES_CONSTRUCTOR + s = strcat(s, "USES_CONSTRUCTOR\n"); +#endif +#ifdef DDS_THREADS_SINGLE + s = strcat(s, "No multi-threading\n"); +#else + #ifdef _OPENMP + s = strcat(s, "OpenMP multi-threading\n"); + #else + s = strcat(s, "WIN32 multi-threading\n"); + #endif +#endif + + char t[80]; + sprintf(t, "%d threads\n\n", noOfThreads); + s = strcat(s, t); +} + + +void FreeThreadMem() +{ + for (int k = 0; k < noOfThreads; k++) + { + localVar[k].transTable.ResetMemory(); + localVar[k].memUsed = localVar[k].transTable.MemoryInUse() + + ThreadMemoryUsed(); + } +} + + +void STDCALL FreeMemory() +{ + for (int k = 0; k < noOfThreads; k++) + { + localVar[k].transTable.ReturnAllMemory(); + localVar[k].memUsed = localVar[k].transTable.MemoryInUse() + + ThreadMemoryUsed(); + } +} + + +double ConstantMemoryUsed() +{ + double memUsed = + 8192 * ( sizeof(int) // highestRank + + sizeof(int) // counttable + + 15 * sizeof(char) // relRank + + 14 * sizeof(unsigned short int)) + / (double) 1024.; + + return memUsed; +} + + +double ThreadMemoryUsed() +{ + double memUsed = + 8192 * sizeof(relRanksType) + / (double) 1024.; + + return memUsed; +} + + +inline bool WinningMove( + struct moveType * mvp1, + struct moveType * mvp2, + int trump) +{ + /* Return true if move 1 wins over move 2, with the assumption that + move 2 is the presently winning card of the trick */ + + if (mvp1->suit == mvp2->suit) + { + if ((mvp1->rank) > (mvp2->rank)) + return true; + else + return false; + } + else if ((mvp1->suit) == trump) + return true; + else + return false; +} + diff --git a/Init.h b/Init.h new file mode 100644 index 00000000..a6a85b08 --- /dev/null +++ b/Init.h @@ -0,0 +1,21 @@ +void InitGame( + int gameNo, + bool moveTreeFlag, + int first, + int handRelFirst, + int thrId); + +void InitSearch( + struct pos * posPoint, + int depth, + struct moveType startMoves[], + int first, + bool mtd, + int thrId); + +double ThreadMemoryUsed(); + +void CloseDebugFiles(); + +// Used by SH for stand-alone mode. +void DDSidentify(char * s); diff --git a/LaterTricks.cpp b/LaterTricks.cpp new file mode 100644 index 00000000..39d85b6f --- /dev/null +++ b/LaterTricks.cpp @@ -0,0 +1,314 @@ +/* + DDS 2.7.0 A bridge double dummy solver. + Copyright (C) 2006-2014 by Bo Haglund + Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. + The code for calculation of par score / contracts is based upon the + perl code written by Matthew Kidd for ACBLmerge. He has kindly given + permission to include a C++ adaptation in DDS. + + The PlayAnalyser analyses the played cards of the deal and presents + their double dummy values. The par calculation function DealerPar + provides an alternative way of calculating and presenting par + results. Both these functions have been written by Soren Hein. + He has also made numerous contributions to the code, especially in + the initialization part. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + + +#include "dds.h" + + +bool LaterTricksMIN( + struct pos * posPoint, + int hand, + int depth, + int target, + int trump, + struct localVarType * thrp) +{ + int win_trump_rank, win_trump_hand; + + win_trump_rank = posPoint->winner[trump].rank; + win_trump_hand = posPoint->winner[trump].hand; + + if ((trump == DDS_NOTRUMP) || (win_trump_rank == 0)) + { + int sum = 0; + for (int ss = 0; ss < DDS_SUITS; ss++) + { + int hh = posPoint->winner[ss].hand; + if (hh != -1) + { + if (thrp->nodeTypeStore[hh] == MAXNODE) + sum += Max(posPoint->length[hh][ss], + posPoint->length[partner[hh]][ss]); + } + } + + if ((posPoint->tricksMAX + sum < target) && (sum > 0)) + { + if ((posPoint->tricksMAX + (depth >> 2) >= target)) + return true; + + for (int ss = 0; ss < DDS_SUITS; ss++) + { + int win_hand = posPoint->winner[ss].hand; + + if (win_hand == -1) + posPoint->winRanks[depth][ss] = 0; + else if (thrp->nodeTypeStore[win_hand] == MINNODE) + { + if ((posPoint->rankInSuit[partner[win_hand]][ss] == 0) && + (posPoint->rankInSuit[lho[win_hand]][ss] == 0) && + (posPoint->rankInSuit[rho[win_hand]][ss] == 0)) + posPoint->winRanks[depth][ss] = 0; + else + posPoint->winRanks[depth][ss] = + bitMapRank[posPoint->winner[ss].rank]; + } + else + posPoint->winRanks[depth][ss] = 0; + } + return false; + } + } + else if ((trump != DDS_NOTRUMP) && (win_trump_rank != 0) && + (thrp->nodeTypeStore[win_trump_hand] == MINNODE)) + { + if ((posPoint->length[hand][trump] == 0) && + (posPoint->length[partner[hand]][trump] == 0)) + { + if (((posPoint->tricksMAX + (depth >> 2) + 1 - + Max(posPoint->length[lho[hand]][trump], + posPoint->length[rho[hand]][trump])) < target)) + { + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = 0; + return false; + } + } + else if ((posPoint->tricksMAX + (depth >> 2)) < target) + { + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = 0; + posPoint->winRanks[depth][trump] = bitMapRank[win_trump_rank]; + return false; + } + else + { + int hh = posPoint->secondBest[trump].hand; + if (hh == -1) + return true; + + int r2 = posPoint->secondBest[trump].rank; + if ((thrp->nodeTypeStore[hh] == MINNODE) && (r2 != 0)) + { + if (((posPoint->length[hh][trump] > 1) || + (posPoint->length[partner[hh]][trump] > 1)) && + ((posPoint->tricksMAX + (depth >> 2) - 1) < target)) + { + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = 0; + posPoint->winRanks[depth][trump] = bitMapRank[r2]; + return false; + } + } + } + } + else if (trump != DDS_NOTRUMP) + { + int hh = posPoint->secondBest[trump].hand; + if (hh == -1) + return true; + + if ((thrp->nodeTypeStore[hh] != MINNODE) || + (posPoint->length[hh][trump] <= 1)) + return true; + + if (posPoint->winner[trump].hand == rho[hh]) + { + if (((posPoint->tricksMAX + (depth >> 2)) < target)) + { + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = 0; + posPoint->winRanks[depth][trump] = + bitMapRank[posPoint->secondBest[trump].rank]; + return false; + } + } + else + { + unsigned short aggr = posPoint->aggr[trump]; + int h = thrp->rel[aggr].absRank[3][trump].hand; + if (h == -1) + return true; + + if ((thrp->nodeTypeStore[h] == MINNODE) && + ((posPoint->tricksMAX + (depth >> 2)) < target)) + { + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = 0; + posPoint->winRanks[depth][trump] = + bitMapRank[thrp->rel[aggr].absRank[3][trump].rank]; + return false; + } + } + } + return true; +} + + +bool LaterTricksMAX( + struct pos * posPoint, + int hand, + int depth, + int target, + int trump, + struct localVarType * thrp) +{ + int win_trump_rank, win_trump_hand; + + win_trump_rank = posPoint->winner[trump].rank; + win_trump_hand = posPoint->winner[trump].hand; + + if ((trump == DDS_NOTRUMP) || (win_trump_rank == 0)) + { + int sum = 0; + for (int ss = 0; ss < DDS_SUITS; ss++) + { + int hh = posPoint->winner[ss].hand; + if (hh != -1) + { + if (thrp->nodeTypeStore[hh] == MINNODE) + sum += Max(posPoint->length[hh][ss], + posPoint->length[partner[hh]][ss]); + } + } + + if ((posPoint->tricksMAX + (depth >> 2) + 1 - sum >= target) && + (sum > 0)) + { + if ((posPoint->tricksMAX + 1 < target)) + return false; + + for (int ss = 0; ss < DDS_SUITS; ss++) + { + int win_hand = posPoint->winner[ss].hand; + if (win_hand == -1) + posPoint->winRanks[depth][ss] = 0; + else if (thrp->nodeTypeStore[win_hand] == MAXNODE) + { + if ((posPoint->rankInSuit[partner[win_hand]][ss] == 0) && + (posPoint->rankInSuit[lho[win_hand]][ss] == 0) && + (posPoint->rankInSuit[rho[win_hand]][ss] == 0)) + posPoint->winRanks[depth][ss] = 0; + else + posPoint->winRanks[depth][ss] = + bitMapRank[posPoint->winner[ss].rank]; + } + else + posPoint->winRanks[depth][ss] = 0; + } + return true; + } + } + else if ((trump != DDS_NOTRUMP) && (win_trump_rank != 0) && + (thrp->nodeTypeStore[win_trump_hand] == MAXNODE)) + { + if ((posPoint->length[hand][trump] == 0) && + (posPoint->length[partner[hand]][trump] == 0)) + { + int maxlen = Max(posPoint->length[lho[hand]][trump], + posPoint->length[rho[hand]][trump]); + + if ((posPoint->tricksMAX + maxlen) >= target) + { + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = 0; + return true; + } + } + else if ((posPoint->tricksMAX + 1) >= target) + { + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = 0; + posPoint->winRanks[depth][trump] = + bitMapRank[posPoint->winner[trump].rank]; + return true; + } + else + { + int hh = posPoint->secondBest[trump].hand; + if (hh == -1) + return false; + + if ((thrp->nodeTypeStore[hh] == MAXNODE) && + (posPoint->secondBest[trump].rank != 0)) + { + if (((posPoint->length[hh][trump] > 1) || + (posPoint->length[partner[hh]][trump] > 1)) && + ((posPoint->tricksMAX + 2) >= target)) + { + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = 0; + posPoint->winRanks[depth][trump] = + bitMapRank[posPoint->secondBest[trump].rank]; + return true; + } + } + } + } + + else if (trump != DDS_NOTRUMP) + { + int hh = posPoint->secondBest[trump].hand; + if (hh == -1) + return false; + + if ((thrp->nodeTypeStore[hh] != MAXNODE) || + (posPoint->length[hh][trump] <= 1)) + return false; + + if (win_trump_hand == rho[hh]) + { + if ((posPoint->tricksMAX + 1) >= target) + { + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = 0; + posPoint->winRanks[depth][trump] = + bitMapRank[posPoint->secondBest[trump].rank] ; + return true; + } + } + else + { + unsigned short aggr = posPoint->aggr[trump]; + int h = thrp->rel[aggr].absRank[3][trump].hand; + if (h == -1) + return false; + + if ((thrp->nodeTypeStore[h] == MAXNODE) && + ((posPoint->tricksMAX + 1) >= target)) + { + for (int ss = 0; ss < DDS_SUITS; ss++) + posPoint->winRanks[depth][ss] = 0; + posPoint->winRanks[depth][trump] = + bitMapRank[thrp->rel[aggr].absRank[3][trump].rank]; + return true; + } + } + } + return false; +} + diff --git a/LaterTricks.h b/LaterTricks.h new file mode 100644 index 00000000..e3b5ba66 --- /dev/null +++ b/LaterTricks.h @@ -0,0 +1,15 @@ +bool LaterTricksMIN( + struct pos * posPoint, + int hand, + int depth, + int target, + int trump, + struct localVarType * thrp); + +bool LaterTricksMAX( + struct pos * posPoint, + int hand, + int depth, + int target, + int trump, + struct localVarType * thrp); diff --git a/Moves.cpp b/Moves.cpp new file mode 100644 index 00000000..585817c1 --- /dev/null +++ b/Moves.cpp @@ -0,0 +1,1383 @@ +/* + DDS 2.7.0 A bridge double dummy solver. + Copyright (C) 2006-2014 by Bo Haglund + Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. + The code for calculation of par score / contracts is based upon the + perl code written by Matthew Kidd for ACBLmerge. He has kindly given + permission to include a C++ adaptation in DDS. + + The PlayAnalyser analyses the played cards of the deal and presents + their double dummy values. The par calculation function DealerPar + provides an alternative way of calculating and presenting par + results. Both these functions have been written by Soren Hein. + He has also made numerous contributions to the code, especially in + the initialization part. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + + +#include "dds.h" + + +extern struct relRanksType * relRanks; +extern int lho[4]; +extern int rho[4]; +extern int partner[4]; +extern unsigned short int bitMapRank[16]; + +void MergeSort(int n, struct moveType *a); + +int AdjustMoveList(struct localVarType * thrp); + +int WeightAllocTrump(struct pos * posPoint, struct moveType * mp, int depth, + unsigned short notVoidInSuit, int trump, struct localVarType * thrp); +int WeightAllocNT(struct pos * posPoint, struct moveType * mp, int depth, + unsigned short notVoidInSuit, struct localVarType * thrp); + +inline bool WinningMove( + struct moveType * mvp1, + struct moveType * mvp2, + int trump); + +inline bool WinningMoveNT( + struct moveType * mvp1, + struct moveType * mvp2); + + + +int MoveGen( + struct pos * posPoint, + int depth, + int trump, + struct movePlyType * mply, + struct localVarType * thrp) +{ + int k, state = MOVESVALID; + unsigned short int bitmap_k, removed_ranks; + char *relp; + + for (int s = 0; s < DDS_SUITS; s++) + thrp->lowestWin[depth][s] = 0; + + int m = 0; + int r = posPoint->handRelFirst; + int first = posPoint->first[depth]; + int q = handId(first, r); + + if (r != 0) + { + int s = thrp->movePly[depth + r].current; + /* Current move of first hand */ + int t = thrp->movePly[depth + r].move[s].suit; + /* Suit played by first hand */ + unsigned short ris = posPoint->rankInSuit[q][t]; + relp = relRank[ris]; + + if (ris != 0) + { + /* Not first hand and not void in suit */ + removed_ranks = posPoint->removedRanks[t]; + k = 14; + while (k >= 2) + { + if (state == MOVESLOCKED) + { + bitmap_k = bitMapRank[k]; + if (relp[k]) + /* If the card is in own hand */ + mply->move[m - 1].sequence |= bitmap_k; + else if ((removed_ranks & bitmap_k) == 0) + /* If the card still exists and it is not in own hand */ + state = MOVESVALID; + } + else if (relp[k]) + { + /* Only first move in sequence is generated */ + mply->move[m].suit = t; + mply->move[m].rank = k; + mply->move[m].sequence = 0; + m++; + state = MOVESLOCKED; + } + k--; + } + if (m != 1) + { + if ((trump != DDS_NOTRUMP) && + (posPoint->winner[trump].rank != 0)) + { + for (k = 0; k <= m - 1; k++) + mply->move[k].weight = WeightAllocTrump(posPoint, + &(mply->move[k]), depth, ris, trump, thrp); + } + else + { + for (k = 0; k <= m - 1; k++) + mply->move[k].weight = WeightAllocNT(posPoint, + &(mply->move[k]), depth, ris, thrp); + } + } + + mply->last = m - 1; + if (m != 1) + MergeSort(m, mply->move); + if (depth != thrp->iniDepth) + return m; + else + { + m = AdjustMoveList(thrp); + return m; + } + } + } + + + /* First hand or void in suit */ + for (int suit = 0; suit < DDS_SUITS; suit++) + { + unsigned short ris = posPoint->rankInSuit[q][suit]; + relp = relRank[ris]; + removed_ranks = posPoint->removedRanks[suit]; + + k = 14; + state = MOVESVALID; + while (k >= 2) + { + if (state == MOVESLOCKED) + { + bitmap_k = bitMapRank[k]; + if (relp[k]) + /* If the card is in own hand */ + mply->move[m - 1].sequence |= bitmap_k; + else if ((removed_ranks & bitmap_k) == 0) + /* If the card still exists and it is not in own hand */ + state = MOVESVALID; + } + else if (relp[k]) + { + /* Only first move in sequence is generated */ + mply->move[m].suit = suit; + mply->move[m].rank = k; + mply->move[m].sequence = 0; + m++; + state = MOVESLOCKED; + } + k--; + } + } + + if ((trump != DDS_NOTRUMP) && (posPoint->winner[trump].rank != 0)) + { + for (k = 0; k <= m - 1; k++) + mply->move[k].weight = WeightAllocTrump(posPoint, + &(mply->move[k]), depth, 0, trump, thrp); + } + else + { + for (k = 0; k <= m - 1; k++) + mply->move[k].weight = WeightAllocNT(posPoint, + &(mply->move[k]), depth, 0, thrp); + } + + mply->last = m - 1; + if (m != 1) + MergeSort(m, mply->move); + + if (depth != thrp->iniDepth) + return m; + else + { + m = AdjustMoveList(thrp); + return m; + } +} + + +int WeightAllocNT(struct pos * posPoint, struct moveType * mp, int depth, + unsigned short notVoidInSuit, struct localVarType * thrp) { + int weight=0, k, l, kk, ll, suitAdd=0, leadSuit; + int suitWeightDelta; + int thirdBestHand; + bool winMove=false; /* If winMove is true, current move can win the current trick. */ + unsigned short suitCount, suitCountLH, suitCountRH; + int countLH, countRH; + + int first=posPoint->first[depth]; + int q=handId(first, posPoint->handRelFirst); + int suit=mp->suit; + unsigned short aggr=0; + for (int m=0; m<=3; m++) + aggr|=posPoint->rankInSuit[m][suit]; + int rRank=relRank[aggr][mp->rank]; + + + switch (posPoint->handRelFirst) { + case 0: + suitCount=posPoint->length[q][suit]; + suitCountLH=posPoint->length[lho[q]][suit]; + suitCountRH=posPoint->length[rho[q]][suit]; + + if (suitCountLH!=0) { + countLH=(suitCountLH<<2); + } + else + countLH=depth+4; + + if (suitCountRH!=0) { + countRH=(suitCountRH<<2); + } + else + countRH=depth+4; + + /* Discourage a suit selection where the search tree appears larger than for the + altenative suits: the search is estimated to be small when the added number of + alternative cards to play for the opponents is small. */ + + suitWeightDelta=-((countLH+countRH)<<5)/19; + + if (posPoint->length[partner[q]][suit]==0) + suitWeightDelta+=-9; + + if (posPoint->winner[suit].rank==mp->rank) + winMove=true; /* May also have 2nd best, but this card will not be searched. */ + else if (posPoint->rankInSuit[partner[first]][suit] > + (posPoint->rankInSuit[lho[first]][suit] | + posPoint->rankInSuit[rho[first]][suit])) { + winMove=true; + } + + if (winMove) { + /* Discourage suit if RHO has second best card. + Exception: RHO has singleton. */ + if (posPoint->secondBest[suit].hand==rho[q]) { + if (suitCountRH!=1) + suitWeightDelta+=-1; + } + /* Encourage playing suit if LHO has second highest rank. */ + else if (posPoint->secondBest[suit].hand==lho[q]) { + if (suitCountLH!=1) + suitWeightDelta+=22; + else + suitWeightDelta+=16; + } + + /* Higher weight if also second best rank is present on current side to play, or + if second best is a singleton at LHO or RHO. */ + + if (((posPoint->secondBest[suit].hand!=lho[first]) + ||(suitCountLH==1))&& + ((posPoint->secondBest[suit].hand!=rho[first]) + ||(suitCountRH==1))) + weight=suitWeightDelta+45+rRank; + else + weight=suitWeightDelta+18+rRank; + + /* Encourage playing cards that previously caused search cutoff + or was stored as the best move in a transposition table entry match. */ + + if ((thrp->bestMove[depth].suit==suit)&& + (thrp->bestMove[depth].rank==mp->rank)) + weight+=126; + else if ((thrp->bestMoveTT[depth].suit==suit)&& + (thrp->bestMoveTT[depth].rank==mp->rank)) + weight+=32/*24*/; + } + else { + /* Discourage suit if RHO has winning or second best card. + Exception: RHO has singleton. */ + + if ((posPoint->winner[suit].hand==rho[q])|| + (posPoint->secondBest[suit].hand==rho[q])) { + if (suitCountRH!=1) + suitWeightDelta+=-10; + } + + + /* Try suit if LHO has winning card and partner second best. + Exception: partner has singleton. */ + + else if ((posPoint->winner[suit].hand==lho[q])&& + (posPoint->secondBest[suit].hand==partner[q])) { + + /* This case was suggested by Joël Bradmetz. */ + + if (posPoint->length[partner[q]][suit]!=1) + suitWeightDelta+=31; + } + + /* Encourage playing the suit if the hand together with partner have both the 2nd highest + and the 3rd highest cards such that the side of the hand has the highest card in the + next round playing this suit. */ + + thirdBestHand=thrp->rel[aggr].absRank[3][suit].hand; + + if ((posPoint->secondBest[suit].hand==partner[first])&&(partner[first]==thirdBestHand)) + suitWeightDelta+=35; + else if(((posPoint->secondBest[suit].hand==first)&&(partner[first]==thirdBestHand)&& + (posPoint->length[partner[first]][suit]>1))||((posPoint->secondBest[suit].hand==partner[first])&& + (first==thirdBestHand)&&(posPoint->length[partner[first]][suit]>1))) + suitWeightDelta+=25; + + /* Higher weight if LHO or RHO has the highest (winning) card as a singleton. */ + + if (((suitCountLH==1)&&(posPoint->winner[suit].hand==lho[first])) + ||((suitCountRH==1)&&(posPoint->winner[suit].hand==rho[first]))) + weight=suitWeightDelta+28+rRank; + else if (posPoint->winner[suit].hand==first) { + weight=suitWeightDelta-17+rRank; + } + else if ((mp->sequence)&& + (mp->rank==posPoint->secondBest[suit].rank)) + weight=suitWeightDelta+48; + else if (mp->sequence) + weight=suitWeightDelta+29-rRank; + else + weight=suitWeightDelta+12+rRank; + + /* Encourage playing cards that previously caused search cutoff + or was stored as the best move in a transposition table entry match. */ + + if ((thrp->bestMove[depth].suit==suit)&& + (thrp->bestMove[depth].rank==mp->rank)) + weight+=47; + else if ((thrp->bestMoveTT[depth].suit==suit)&& + (thrp->bestMoveTT[depth].rank==mp->rank)) + weight+=19; + } + + break; + + case 1: + leadSuit=posPoint->move[depth+1].suit; + if (leadSuit==suit) { + if (bitMapRank[mp->rank]> + (bitMapRank[posPoint->move[depth+1].rank] | + posPoint->rankInSuit[partner[first]][suit])) + winMove=true; + else if (posPoint->rankInSuit[rho[first]][suit]> + (bitMapRank[posPoint->move[depth+1].rank] | + posPoint->rankInSuit[partner[first]][suit])) + winMove=true; + } + else { + /* Side with highest rank in leadSuit wins */ + + if (posPoint->rankInSuit[rho[first]][leadSuit] > + (posPoint->rankInSuit[partner[first]][leadSuit] | + bitMapRank[posPoint->move[depth+1].rank])) + winMove=true; + } + + if (winMove) { + if (!notVoidInSuit) { + suitCount=posPoint->length[q][suit]; + suitAdd=(suitCount<<6)/(23/*20*//*21*//*24*//*30*//*35*/); + if (posPoint->secondBest[suit].hand==q) { + /* Discourage suit discard if 2nd highest card becomes singleton. */ + + if (suitCount==2) + suitAdd+=-2; + } + /* Discourage suit discard of highest card. */ + + else if ((suitCount==1)&&(posPoint->winner[suit].hand==q)) + suitAdd+=-3; + + /*Encourage discard of low cards in long suits. */ + weight=-4-(mp->rank)+suitAdd; + } + else { + weight=81/*80*/+rRank; + } + } + else { + if (!notVoidInSuit) { + suitCount=posPoint->length[q][suit]; + suitAdd=(suitCount<<6)/33; + + /* Discourage suit discard if 2nd highest card becomes singleton. */ + if ((suitCount==2)&&(posPoint->secondBest[suit].hand==q)) + suitAdd+=-6; + + /* Discourage suit discard of highest card. */ + else if ((suitCount==1)&&(posPoint->winner[suit].hand==q)) + suitAdd+=-8; + + /*Encourage discard of low cards in long suits. */ + weight=2-(mp->rank)+suitAdd; + } + else { + + /* If lowest rank for either partner to leading hand + or rho is higher than played card for lho, + lho should play as low card as possible */ + + kk=posPoint->rankInSuit[partner[first]][leadSuit]; + ll=posPoint->rankInSuit[rho[first]][leadSuit]; + k=kk & (-kk); l=ll & (-ll); /* Only least significant 1 bit of + bit map ranks for partner and RHO. */ + + if ((k > bitMapRank[mp->rank])||(l > bitMapRank[mp->rank])) + weight=-3+rRank; + else if (mp->rank > posPoint->move[depth+1].rank) { + if (mp->sequence) { + weight=/*0*/10+rRank; + } + else { + weight=13-(mp->rank); + /*weight=-5+rRank;*/ + } + } + else { + weight=-11/*15*/+rRank; + } + } + } + + break; + + case 2: + + leadSuit=posPoint->move[depth+2].suit; + if (WinningMoveNT(mp, &(posPoint->move[depth+1]))) { + if (bitMapRank[mp->rank] > + posPoint->rankInSuit[rho[first]][suit]) + winMove=true; + } + else if (posPoint->high[depth+1]==first) { + if (posPoint->rankInSuit[rho[first]][leadSuit] + < bitMapRank[posPoint->move[depth+2].rank]) + winMove=true; + + } + + if (winMove) { + if (!notVoidInSuit) { + suitCount=posPoint->length[q][suit]; + suitAdd=(suitCount<<6)/(17/*27*//*30*//*35*/); + + /* Discourage suit discard if 2nd highest card becomes singleton. */ + if ((suitCount==2)&&(posPoint->secondBest[suit].hand==q)) + suitAdd-=(6/*2*//*5*/); + weight=-(mp->rank)+suitAdd; + } + else { + weight=60+rRank; + } + } + else { + if (!notVoidInSuit) { + suitCount=posPoint->length[q][suit]; + suitAdd=(suitCount<<6)/(24/*26*//*29*//*35*/); + if ((suitCount==2)&&(posPoint->secondBest[suit].hand==q)) + suitAdd-=(4/*5*/); + /* Discourage suit discard of highest card. */ + else if ((suitCount==1)&&(posPoint->winner[suit].hand==q)) + suitAdd-=(4/*5*/); + + weight=-(mp->rank)+suitAdd; + + } + else { + + k=posPoint->rankInSuit[rho[first]][suit]; + if ((k & (-k)) > bitMapRank[mp->rank]) + weight=-(mp->rank); + else if (WinningMoveNT(mp, &(posPoint->move[depth+1]))) { + if ((mp->rank==posPoint->secondBest[leadSuit].rank)&& + (mp->sequence)) + weight=25; + else if (mp->sequence) + weight=20-(mp->rank); + else + weight=10-(mp->rank); + } + else + weight=-10-(mp->rank); + } + } + + break; + + case 3: + if (!notVoidInSuit) { + suitCount=posPoint->length[q][suit]; + suitAdd=(suitCount<<6)/(27/*35*/); + if ((suitCount==2)&&(posPoint->secondBest[suit].hand==q)) + suitAdd-=(6/*5*/); + else if ((suitCount==1)&&(posPoint->winner[suit].hand==q)) + suitAdd-=(8/*9*//*8*//*5*/); + + weight=30-(mp->rank)+suitAdd; + } + else if ((posPoint->high[depth+1])==(lho[first])) { + /* If the current winning move is given by the partner */ + weight=30-(mp->rank); + } + else if (WinningMoveNT(mp, &(posPoint->move[depth+1]))) + /* If present move is superior to current winning move and the + current winning move is not given by the partner */ + weight=30-(mp->rank); + else { + /* If present move is not superior to current winning move and the + current winning move is not given by the partner */ + weight=14-(mp->rank); + } + } + return weight; +} + + + +int WeightAllocTrump(struct pos * posPoint, struct moveType * mp, int depth, + unsigned short notVoidInSuit, int trump, struct localVarType * thrp) { + int weight=0, k, l, kk, ll, suitAdd=0, leadSuit; + int suitWeightDelta, thirdBestHand; + int suitBonus=0; + bool winMove=false; /* If winMove is true, current move can win the current trick. */ + unsigned short suitCount, suitCountLH, suitCountRH; + int countLH, countRH; + + int first=posPoint->first[depth]; + int q=handId(first, posPoint->handRelFirst); + int suit=mp->suit; + unsigned short aggr=0; + for (int m=0; m<=3; m++) + aggr|=posPoint->rankInSuit[m][suit]; + int rRank=relRank[aggr][mp->rank]; + + switch (posPoint->handRelFirst) { + case 0: + suitCount=posPoint->length[q][suit]; + suitCountLH=posPoint->length[lho[q]][suit]; + suitCountRH=posPoint->length[rho[q]][suit]; + + /* Discourage suit if LHO or RHO can ruff. */ + + if ((suit!=trump) && + (((posPoint->rankInSuit[lho[q]][suit]==0) && + (posPoint->rankInSuit[lho[q]][trump]!=0)) || + ((posPoint->rankInSuit[rho[q]][suit]==0) && + (posPoint->rankInSuit[rho[q]][trump]!=0)))) + suitBonus=-12/*9*//*17*/; + + /* Encourage suit if partner can ruff. */ + + if ((suit!=trump)&&(posPoint->length[partner[q]][suit]==0)&& + (posPoint->length[partner[q]][trump]>0)&&(suitCountRH>0)) + suitBonus+=17/*26*/; + + /* Discourage suit if RHO has high card. */ + + if ((posPoint->winner[suit].hand==rho[q])|| + (posPoint->secondBest[suit].hand==rho[q])) { + if (suitCountRH!=1) + suitBonus+=-12/*13*//*11*/; + } + + /* Try suit if LHO has winning card and partner second best. + Exception: partner has singleton. */ + + else if ((posPoint->winner[suit].hand==lho[q])&& + (posPoint->secondBest[suit].hand==partner[q])) { + + /* This case was suggested by Joël Bradmetz. */ + + if (posPoint->length[partner[q]][suit]!=1) + suitBonus+=27/*25*//*30*/; + } + + /* Encourage play of suit where partner wins and + returns the suit for a ruff. */ + if ((suit!=trump)&&(suitCount==1)&& + (posPoint->length[q][trump]>0)&& + (posPoint->length[partner[q]][suit]>1)&& + (posPoint->winner[suit].hand==partner[q])) + suitBonus+=19/*26*//*23*/; + + if (suitCountLH!=0) + countLH=(suitCountLH<<2); + else + countLH=depth+4; + if (suitCountRH!=0) + countRH=(suitCountRH<<2); + else + countRH=depth+4; + + /* Discourage a suit selection where the search tree appears larger than for the + altenative suits: the search is estimated to be small when the added number of + alternative cards to play for the opponents is small. */ + + suitWeightDelta=suitBonus- + ((countLH+countRH)<<5)/13; + + if (posPoint->winner[suit].rank==mp->rank) { + if ((suit!=trump)) { + if ((posPoint->length[partner[first]][suit]!=0)|| + (posPoint->length[partner[first]][trump]==0)) { + if (((posPoint->length[lho[first]][suit]!=0)|| + (posPoint->length[lho[first]][trump]==0))&& + ((posPoint->length[rho[first]][suit]!=0)|| + (posPoint->length[rho[first]][trump]==0))) + winMove=true; + } + else if (((posPoint->length[lho[first]][suit]!=0)|| + (posPoint->rankInSuit[partner[first]][trump]> + posPoint->rankInSuit[lho[first]][trump]))&& + ((posPoint->length[rho[first]][suit]!=0)|| + (posPoint->rankInSuit[partner[first]][trump]> + posPoint->rankInSuit[rho[first]][trump]))) + winMove=true; + } + else + winMove=true; + } + else if (posPoint->rankInSuit[partner[first]][suit] > + (posPoint->rankInSuit[lho[first]][suit] | + posPoint->rankInSuit[rho[first]][suit])) { + if (suit!=trump) { + if (((posPoint->length[lho[first]][suit]!=0)|| + (posPoint->length[lho[first]][trump]==0))&& + ((posPoint->length[rho[first]][suit]!=0)|| + (posPoint->length[rho[first]][trump]==0))) + winMove=true; + } + else + winMove=true; + } + else if (suit!=trump) { + if ((posPoint->length[partner[first]][suit]==0)&& + (posPoint->length[partner[first]][trump]!=0)) { + if ((posPoint->length[lho[first]][suit]==0)&& + (posPoint->length[lho[first]][trump]!=0)&& + (posPoint->length[rho[first]][suit]==0)&& + (posPoint->length[rho[first]][trump]!=0)) { + if (posPoint->rankInSuit[partner[first]][trump]> + (posPoint->rankInSuit[lho[first]][trump] | + posPoint->rankInSuit[rho[first]][trump])) + winMove=true; + } + else if ((posPoint->length[lho[first]][suit]==0)&& + (posPoint->length[lho[first]][trump]!=0)) { + if (posPoint->rankInSuit[partner[first]][trump] + > posPoint->rankInSuit[lho[first]][trump]) + winMove=true; + } + else if ((posPoint->length[rho[first]][suit]==0)&& + (posPoint->length[rho[first]][trump]!=0)) { + if (posPoint->rankInSuit[partner[first]][trump] + > posPoint->rankInSuit[rho[first]][trump]) + winMove=true; + } + else + winMove=true; + } + } + + if (winMove) { + + /* Encourage ruffing LHO or RHO singleton, highest card. */ + + if (((suitCountLH==1)&&(posPoint->winner[suit].hand==lho[first])) + ||((suitCountRH==1)&&(posPoint->winner[suit].hand==rho[first]))) + weight=suitWeightDelta+35/*37*//*39*/+rRank; + + /* Lead hand has the highest card. */ + + else if (posPoint->winner[suit].hand==first) { + + /* Also, partner has second highest card. */ + + if (posPoint->secondBest[suit].hand==partner[first]) + weight=suitWeightDelta+/*47*/48+rRank; + else if (posPoint->winner[suit].rank==mp->rank) + + /* If the current card to play is the highest card. */ + + weight=suitWeightDelta+31; + else + weight=suitWeightDelta-3+rRank; + } + else if (posPoint->winner[suit].hand==partner[first]) { + /* If partner has highest card */ + if (posPoint->secondBest[suit].hand==first) + weight=suitWeightDelta+42/*35*//*46*//*50*/+rRank; + else + weight=suitWeightDelta+28/*24*/+rRank; + } + /* Encourage playing second highest rank if hand also has + third highest rank. */ + + else if ((mp->sequence)&& + (mp->rank==posPoint->secondBest[suit].rank)) + weight=suitWeightDelta+40/*41*/; + else if (mp->sequence) + weight=suitWeightDelta+22/*17*/+rRank; + else + weight=suitWeightDelta+11+rRank; + + /* Encourage playing cards that previously caused search cutoff + or was stored as the best move in a transposition table entry match. */ + + if ((thrp->bestMove[depth].suit==suit)&& + (thrp->bestMove[depth].rank==mp->rank)) + weight+=55/*53*/; + else if ((thrp->bestMoveTT[depth].suit==suit)&& + (thrp->bestMoveTT[depth].rank==mp->rank)) + weight+=/*25*/18/*14*/; + } + else { + + /* Encourage playing the suit if the hand together with partner have both the 2nd highest + and the 3rd highest cards such that the side of the hand has the highest card in the + next round playing this suit. */ + + thirdBestHand=thrp->rel[aggr].absRank[3][suit].hand; + + if ((posPoint->secondBest[suit].hand==partner[first])&&(partner[first]==thirdBestHand)) + suitWeightDelta+=20/*22*/; + else if(((posPoint->secondBest[suit].hand==first)&&(partner[first]==thirdBestHand)&& + (posPoint->length[partner[first]][suit]>1))|| + ((posPoint->secondBest[suit].hand==partner[first])&& + (first==thirdBestHand)&&(posPoint->length[partner[first]][suit]>1))) + suitWeightDelta+=13/*20*//*24*/; + + /* Higher weight if LHO or RHO has the highest (winning) card as a singleton. */ + + if (((suitCountLH==1)&&(posPoint->winner[suit].hand==lho[first])) + ||((suitCountRH==1)&&(posPoint->winner[suit].hand==rho[first]))) + weight=suitWeightDelta+rRank+2/*-2*/; + else if (posPoint->winner[suit].hand==first) { + if (posPoint->secondBest[suit].hand==partner[first]) + + /* Opponents win by ruffing */ + + weight=suitWeightDelta+33+rRank; + else if (posPoint->winner[suit].rank==mp->rank) + + /* Opponents win by ruffing */ + + weight=suitWeightDelta+38/*36*/; + else + weight=suitWeightDelta-14/*17*/+rRank; + } + else if (posPoint->winner[suit].hand==partner[first]) { + + /* Opponents win by ruffing */ + + weight=suitWeightDelta+34/*33*/+rRank; + } + /* Encourage playing second highest rank if hand also has + third highest rank. */ + + else if ((mp->sequence)&& + (mp->rank==posPoint->secondBest[suit].rank)) + weight=suitWeightDelta+35/*31*/; + else + weight=suitWeightDelta+17/*13*/-(mp->rank); + + /* Encourage playing cards that previously caused search cutoff + or was stored as the best move in a transposition table entry match. */ + + if ((thrp->bestMove[depth].suit==suit)&& + (thrp->bestMove[depth].rank==mp->rank)) + weight+=18/*17*/; + /*else if ((thrp->bestMoveTT[depth].suit==suit)&& + (thrp->bestMoveTT[depth].rank==mp->rank)) + weight+=4;*/ + } + + break; + + case 1: + leadSuit=posPoint->move[depth+1].suit; + if (leadSuit==suit) { + if (bitMapRank[mp->rank]> + (bitMapRank[posPoint->move[depth+1].rank] | + posPoint->rankInSuit[partner[first]][suit])) { + if (suit!=trump) { + if ((posPoint->length[partner[first]][suit]!=0)|| + (posPoint->length[partner[first]][trump]==0)) + winMove=true; + else if ((posPoint->length[rho[first]][suit]==0) + &&(posPoint->length[rho[first]][trump]!=0) + &&(posPoint->rankInSuit[rho[first]][trump]> + posPoint->rankInSuit[partner[first]][trump])) + winMove=true; + } + else + winMove=true; + } + else if (posPoint->rankInSuit[rho[first]][suit]> + (bitMapRank[posPoint->move[depth+1].rank] | + posPoint->rankInSuit[partner[first]][suit])) { + if (suit!=trump) { + if ((posPoint->length[partner[first]][suit]!=0)|| + (posPoint->length[partner[first]][trump]==0)) + winMove=true; + } + else + winMove=true; + } + else if (bitMapRank[posPoint->move[depth+1].rank] > + (posPoint->rankInSuit[rho[first]][suit] | + posPoint->rankInSuit[partner[first]][suit] | + bitMapRank[mp->rank])) { + if (suit!=trump) { + if ((posPoint->length[rho[first]][suit]==0)&& + (posPoint->length[rho[first]][trump]!=0)) { + if ((posPoint->length[partner[first]][suit]!=0)|| + (posPoint->length[partner[first]][trump]==0)) + winMove=true; + else if (posPoint->rankInSuit[rho[first]][trump] + > posPoint->rankInSuit[partner[first]][trump]) + winMove=true; + } + } + } + else { /* winnerHand is partner to first */ + if (suit!=trump) { + if ((posPoint->length[rho[first]][suit]==0)&& + (posPoint->length[rho[first]][trump]!=0)) + winMove=true; + } + } + } + else { + + /* Leading suit differs from suit played by LHO */ + + if (suit==trump) { + if (posPoint->length[partner[first]][leadSuit]!=0) + winMove=true; + else if (bitMapRank[mp->rank]> + posPoint->rankInSuit[partner[first]][trump]) + winMove=true; + else if ((posPoint->length[rho[first]][leadSuit]==0) + &&(posPoint->length[rho[first]][trump]!=0)&& + (posPoint->rankInSuit[rho[first]][trump] > + posPoint->rankInSuit[partner[first]][trump])) + winMove=true; + } + else if (leadSuit!=trump) { + + /* Neither suit nor leadSuit is trump */ + + if (posPoint->length[partner[first]][leadSuit]!=0) { + if (posPoint->rankInSuit[rho[first]][leadSuit] > + (posPoint->rankInSuit[partner[first]][leadSuit] | + bitMapRank[posPoint->move[depth+1].rank])) + winMove=true; + else if ((posPoint->length[rho[first]][leadSuit]==0) + &&(posPoint->length[rho[first]][trump]!=0)) + winMove=true; + } + + /* Partner to leading hand is void in leading suit */ + + else if ((posPoint->length[rho[first]][leadSuit]==0) + &&(posPoint->rankInSuit[rho[first]][trump]> + posPoint->rankInSuit[partner[first]][trump])) + winMove=true; + else if ((posPoint->length[partner[first]][trump]==0) + &&(posPoint->rankInSuit[rho[first]][leadSuit] > + bitMapRank[posPoint->move[depth+1].rank])) + winMove=true; + } + else { + /* Either no trumps or leadSuit is trump, side with + highest rank in leadSuit wins */ + if (posPoint->rankInSuit[rho[first]][leadSuit] > + (posPoint->rankInSuit[partner[first]][leadSuit] | + bitMapRank[posPoint->move[depth+1].rank])) + winMove=true; + } + } + + + kk=posPoint->rankInSuit[partner[first]][leadSuit]; + ll=posPoint->rankInSuit[rho[first]][leadSuit]; + k=kk & (-kk); l=ll & (-ll); /* Only least significant 1 bit of + bit map ranks for partner and RHO. */ + + if (winMove) { + if (!notVoidInSuit) { + suitCount=posPoint->length[q][suit]; + suitAdd=(suitCount<<6)/(44/*36*/); + + /* Discourage suit discard if 2nd highest card becomes singleton. */ + + /*if ((suitCount==2)&&(posPoint->secondBest[suit].hand==q)) + suitAdd-=2;*/ + + if (suit==trump) + weight=24-(mp->rank)+suitAdd; + else + weight=60-(mp->rank)+suitAdd; /* Better discard than ruff since rho + wins anyway */ + } + else if (k > bitMapRank[mp->rank]) + weight=40+rRank; + + /* If lowest card for partner to leading hand + is higher than lho played card, playing as low as + possible will give the cheapest win */ + + else if ((ll > bitMapRank[posPoint->move[depth+1].rank])&& + (posPoint->rankInSuit[first][leadSuit] > ll)) + weight=41+rRank; + + /* If rho has a card in the leading suit that + is higher than the trick leading card but lower + than the highest rank of the leading hand, then + lho playing the lowest card will be the cheapest + win */ + + else if (mp->rank > posPoint->move[depth+1].rank) { + if (bitMapRank[mp->rank] < ll) + weight=78-(mp->rank); /* If played card is lower than any of the cards of + rho, it will be the cheapest win */ + else if (bitMapRank[mp->rank] > kk) + weight=73-(mp->rank); /* If played card is higher than any cards at partner + of the leading hand, rho can play low, under the + condition that he has a lower card than lho played */ + else { + if (mp->sequence) + weight=62-(mp->rank); + else + weight=49-(mp->rank); + } + } + else if (posPoint->length[rho[first]][leadSuit]>0) { + /*if (mp->sequence)*/ + weight=47-(mp->rank); /* Playing a card in a sequence may promote a winner */ + + /*else + weight=47-(mp->rank);*/ + } + else + weight=40-(mp->rank); + } + else { + if (!notVoidInSuit) { + suitCount=posPoint->length[q][suit]; + suitAdd=(suitCount<<6)/36; + + /* Discourage suit discard if 2nd highest card becomes singleton. */ + + if ((suitCount==2)&&(posPoint->secondBest[suit].hand==q)) + suitAdd+=-4; + + if (suit==trump) { + weight=15-(mp->rank)+suitAdd; /* Ruffing is preferred, makes the trick + costly for the opponents */ + } + else + weight=-2-(mp->rank)+suitAdd; + } + else if ((k > bitMapRank[mp->rank])|| + (l > bitMapRank[mp->rank])) + weight=-9+rRank; + + /* If lowest rank for either partner to leading hand + or rho is higher than played card for lho, + lho should play as low card as possible */ + + else if (mp->rank > posPoint->move[depth+1].rank) { + if (mp->sequence) + weight=22-(mp->rank); + else + weight=10-(mp->rank); + } + else + weight=-16+rRank; + } + break; + + case 2: + + leadSuit=posPoint->move[depth+2].suit; + if (WinningMove(mp, &(posPoint->move[depth+1]),trump)) { + if (suit==leadSuit) { + if (leadSuit!=trump) { + if (((posPoint->length[rho[first]][suit]!=0)|| + (posPoint->length[rho[first]][trump]==0))&& + (bitMapRank[mp->rank] > + posPoint->rankInSuit[rho[first]][suit])) + winMove=true; + } + else if (bitMapRank[mp->rank] > + posPoint->rankInSuit[rho[first]][suit]) + winMove=true; + } + else { /* Suit is trump */ + if (posPoint->length[rho[first]][leadSuit]==0) { + if (bitMapRank[mp->rank] > + posPoint->rankInSuit[rho[first]][trump]) + winMove=true; + } + else + winMove=true; + } + } + else if (posPoint->high[depth+1]==first) { + if (posPoint->length[rho[first]][leadSuit]!=0) { + if (posPoint->rankInSuit[rho[first]][leadSuit] + < bitMapRank[posPoint->move[depth+2].rank]) + winMove=true; + } + else if (leadSuit==trump) + winMove=true; + else if ((leadSuit!=trump) && + (posPoint->length[rho[first]][trump]==0)) + winMove=true; + } + + if (winMove) { + if (!notVoidInSuit) { + suitCount=posPoint->length[q][suit]; + suitAdd=(suitCount<<6)/(50/*36*/); + + /* Discourage suit discard if 2nd highest card becomes singleton. */ + + /*if ((suitCount==2)&&(posPoint->secondBest[suit].hand==q)) + suitAdd-=(3);*/ + + if (posPoint->high[depth+1]==first) { + if (suit==trump) + weight=48-(mp->rank)+suitAdd; /* Ruffs partner's winner */ + else + weight=61-(mp->rank)+suitAdd; + } + else if (WinningMove(mp, &(posPoint->move[depth+1]),trump)) + + /* Own hand on top by ruffing */ + + weight=72-(mp->rank)+suitAdd; + } + else + weight=58-(mp->rank); + } + else { + if (!notVoidInSuit) { + suitCount=posPoint->length[q][suit]; + suitAdd=(suitCount<<6)/40; + + /* Discourage suit discard if 2nd highest card becomes singleton. */ + + /*if ((suitCount==2)&&(posPoint->secondBest[suit].hand==q)) + suitAdd-=(4);*/ + + if (WinningMove(mp, &(posPoint->move[depth+1]),trump)) + + /* Own hand on top by ruffing */ + + weight=40-(mp->rank)+suitAdd; + else if (suit==trump) + + /* Discard a trump but still losing */ + + weight=-32+rRank+suitAdd; + else + weight=-2-(mp->rank)+suitAdd; + } + else { + k=posPoint->rankInSuit[rho[first]][suit]; + if ((k & (-k)) > bitMapRank[mp->rank]) + + /* If least bit map rank of RHO to lead hand is higher than bit map rank + of current card move. */ + + weight=-3-(mp->rank); + + else if (WinningMove(mp, &(posPoint->move[depth+1]),trump)) { + + /* If current card move is highest so far. */ + + if (mp->rank==posPoint->secondBest[leadSuit].rank) + weight=29; + else if (mp->sequence) + weight=26/*20*/-(mp->rank); + else + weight=18-(mp->rank); + } + else + weight=-12-(mp->rank); + } + } + + break; + + case 3: + if (!notVoidInSuit) { + suitCount=posPoint->length[q][suit]; + suitAdd=(suitCount<<6)/(24/*36*/); + if ((suitCount==2)&&(posPoint->secondBest[suit].hand==q)) + suitAdd-=(2); + + if ((posPoint->high[depth+1])==lho[first]) { + + /* If the current winning move is given by the partner */ + + if (suit==trump) + + /* Ruffing partners winner? */ + + weight=2/*17*/-(mp->rank)+suitAdd; + else + weight=25-(mp->rank)+suitAdd; + } + else if (WinningMove(mp, &(posPoint->move[depth+1]),trump)) + + /* Own hand ruffs */ + + weight=33/*27*/+rRank+suitAdd; + else if (suit==trump) + weight=-13+rRank; + else + weight=14-(mp->rank)+suitAdd; + } + else if ((posPoint->high[depth+1])==(lho[first])) { + + /* If the current winning move is given by the partner */ + + if (suit==trump) + + /* Ruffs partners winner */ + + weight=11+rRank; + else + weight=17+rRank; + } + else if (WinningMove(mp, &(posPoint->move[depth+1]),trump)) + + /* If present move is superior to current winning move and the + current winning move is not given by the partner */ + + weight=22+rRank; + else { + + /* If present move is not superior to current winning move and the + current winning move is not given by the partner */ + + if (suit==trump) + + /* Ruffs but still loses */ + + weight=-13+rRank; + else + weight=1+rRank; + } + } + return weight; +} + + +void MergeSort(int n, struct moveType *a) { + + switch (n) { + case 12: + CMP_SWAP(0, 1); CMP_SWAP(2, 3); CMP_SWAP(4, 5); CMP_SWAP(6, 7); CMP_SWAP(8, 9); CMP_SWAP(10, 11); + CMP_SWAP(1, 3); CMP_SWAP(5, 7); CMP_SWAP(9, 11); + CMP_SWAP(0, 2); CMP_SWAP(4, 6); CMP_SWAP(8, 10); + CMP_SWAP(1, 2); CMP_SWAP(5, 6); CMP_SWAP(9, 10); + CMP_SWAP(1, 5); CMP_SWAP(6, 10); + CMP_SWAP(5, 9); + CMP_SWAP(2, 6); + CMP_SWAP(1, 5); CMP_SWAP(6, 10); + CMP_SWAP(0, 4); CMP_SWAP(7, 11); + CMP_SWAP(3, 7); + CMP_SWAP(4, 8); + CMP_SWAP(0, 4); CMP_SWAP(7, 11); + CMP_SWAP(1, 4); CMP_SWAP(7, 10); + CMP_SWAP(3, 8); + CMP_SWAP(2, 3); CMP_SWAP(8, 9); + CMP_SWAP(2, 4); CMP_SWAP(7, 9); + CMP_SWAP(3, 5); CMP_SWAP(6, 8); + CMP_SWAP(3, 4); CMP_SWAP(5, 6); CMP_SWAP(7, 8); + break; + case 11: + CMP_SWAP(0, 1); CMP_SWAP(2, 3); CMP_SWAP(4, 5); CMP_SWAP(6, 7); CMP_SWAP(8, 9); + CMP_SWAP(1, 3); CMP_SWAP(5, 7); + CMP_SWAP(0, 2); CMP_SWAP(4, 6); CMP_SWAP(8, 10); + CMP_SWAP(1, 2); CMP_SWAP(5, 6); CMP_SWAP(9, 10); + CMP_SWAP(1, 5); CMP_SWAP(6, 10); + CMP_SWAP(5, 9); + CMP_SWAP(2, 6); + CMP_SWAP(1, 5); CMP_SWAP(6, 10); + CMP_SWAP(0, 4); + CMP_SWAP(3, 7); + CMP_SWAP(4, 8); + CMP_SWAP(0, 4); + CMP_SWAP(1, 4); CMP_SWAP(7, 10); + CMP_SWAP(3, 8); + CMP_SWAP(2, 3); CMP_SWAP(8, 9); + CMP_SWAP(2, 4); CMP_SWAP(7, 9); + CMP_SWAP(3, 5); CMP_SWAP(6, 8); + CMP_SWAP(3, 4); CMP_SWAP(5, 6); CMP_SWAP(7, 8); + break; + case 10: + CMP_SWAP(1, 8); + CMP_SWAP(0, 4); CMP_SWAP(5, 9); + CMP_SWAP(2, 6); + CMP_SWAP(3, 7); + CMP_SWAP(0, 3); CMP_SWAP(6, 9); + CMP_SWAP(2, 5); + CMP_SWAP(0, 1); CMP_SWAP(3, 6); CMP_SWAP(8, 9); + CMP_SWAP(4, 7); + CMP_SWAP(0, 2); CMP_SWAP(4, 8); + CMP_SWAP(1, 5); CMP_SWAP(7, 9); + CMP_SWAP(1, 2); CMP_SWAP(3, 4); CMP_SWAP(5, 6); CMP_SWAP(7, 8); + CMP_SWAP(1, 3); CMP_SWAP(6, 8); + CMP_SWAP(2, 4); CMP_SWAP(5, 7); + CMP_SWAP(2, 3); CMP_SWAP(6, 7); + CMP_SWAP(3, 5); + CMP_SWAP(4, 6); + CMP_SWAP(4, 5); + break; + case 9: + CMP_SWAP(0, 1); CMP_SWAP(3, 4); CMP_SWAP(6, 7); + CMP_SWAP(1, 2); CMP_SWAP(4, 5); CMP_SWAP(7, 8); + CMP_SWAP(0, 1); CMP_SWAP(3, 4); CMP_SWAP(6, 7); + CMP_SWAP(0, 3); + CMP_SWAP(3, 6); + CMP_SWAP(0, 3); + CMP_SWAP(1, 4); + CMP_SWAP(4, 7); + CMP_SWAP(1, 4); + CMP_SWAP(2, 5); + CMP_SWAP(5, 8); + CMP_SWAP(2, 5); + CMP_SWAP(1, 3); CMP_SWAP(5, 7); + CMP_SWAP(2, 6); + CMP_SWAP(4, 6); + CMP_SWAP(2, 4); + CMP_SWAP(2, 3); CMP_SWAP(5, 6); + break; + case 8: + CMP_SWAP(0, 1); CMP_SWAP(2, 3); CMP_SWAP(4, 5); CMP_SWAP(6, 7); + CMP_SWAP(0, 2); CMP_SWAP(4, 6); CMP_SWAP(1, 3); CMP_SWAP(5, 7); + CMP_SWAP(1, 2); CMP_SWAP(5, 6); CMP_SWAP(0, 4); CMP_SWAP(1, 5); + CMP_SWAP(2, 6); CMP_SWAP(3, 7); CMP_SWAP(2, 4); CMP_SWAP(3, 5); + CMP_SWAP(1, 2); CMP_SWAP(3, 4); CMP_SWAP(5, 6); + break; + case 7: + CMP_SWAP(0, 1); CMP_SWAP(2, 3); CMP_SWAP(4, 5); + CMP_SWAP(0, 2); CMP_SWAP(4, 6); + CMP_SWAP(1, 3); + CMP_SWAP(1, 2); CMP_SWAP(5, 6); + CMP_SWAP(0, 4); CMP_SWAP(1, 5); CMP_SWAP(2, 6); + CMP_SWAP(2, 4); CMP_SWAP(3, 5); + CMP_SWAP(1, 2); CMP_SWAP(3, 4); CMP_SWAP(5, 6); + break; + case 6: + CMP_SWAP(0, 1); CMP_SWAP(2, 3); CMP_SWAP(4, 5); + CMP_SWAP(0, 2); + CMP_SWAP(1, 3); + CMP_SWAP(1, 2); + CMP_SWAP(0, 4); CMP_SWAP(1, 5); + CMP_SWAP(2, 4); CMP_SWAP(3, 5); + CMP_SWAP(1, 2); CMP_SWAP(3, 4); + break; + case 5: + CMP_SWAP(0, 1); CMP_SWAP(2, 3); + CMP_SWAP(0, 2); + CMP_SWAP(1, 3); + CMP_SWAP(1, 2); + CMP_SWAP(0, 4); + CMP_SWAP(2, 4); + CMP_SWAP(1, 2); CMP_SWAP(3, 4); + break; + case 4: + CMP_SWAP(0, 1); CMP_SWAP(2, 3); + CMP_SWAP(0, 2); + CMP_SWAP(1, 3); + CMP_SWAP(1, 2); + break; + case 3: + CMP_SWAP(0, 1); + CMP_SWAP(0, 2); + CMP_SWAP(1, 2); + break; + case 2: + CMP_SWAP(0, 1); + break; + default: + for (int i = 1; i < n; i++) { + struct moveType tmp = a[i]; + int j = i; + for (; j && tmp.weight > a[j - 1].weight ; --j) + a[j] = a[j - 1]; + a[j] = tmp; + } + } + + return; +} + + + +int AdjustMoveList(struct localVarType * thrp) { + int k, r, n, rank, suit; + int iniDepth = thrp->iniDepth; + + for (k=1; k<=13; k++) { + suit=thrp->forbiddenMoves[k].suit; + rank=thrp->forbiddenMoves[k].rank; + for (r=0; r<=thrp->movePly[iniDepth].last; r++) { + if ((suit==thrp->movePly[iniDepth].move[r].suit)&& + (rank!=0)&&(rank==thrp->movePly[iniDepth].move[r].rank)) { + /* For the forbidden move r: */ + for (n=r; n<=thrp->movePly[iniDepth].last; n++) + thrp->movePly[iniDepth].move[n]= + thrp->movePly[iniDepth].move[n+1]; + thrp->movePly[iniDepth].last--; + } + } + } + return thrp->movePly[thrp->iniDepth].last+1; +} + + +inline bool WinningMove(struct moveType * mvp1, struct moveType * mvp2, int trump) { +/* Return true if move 1 wins over move 2, with the assumption that +move 2 is the presently winning card of the trick */ + + if (mvp1->suit==mvp2->suit) { + if ((mvp1->rank)>(mvp2->rank)) + return true; + else + return false; + } + else if ((mvp1->suit)==trump) + return true; + else + return false; +} + + +inline bool WinningMoveNT(struct moveType * mvp1, struct moveType * mvp2) { +/* Return true if move 1 wins over move 2, with the assumption that +move 2 is the presently winning card of the trick */ + + if (mvp1->suit==mvp2->suit) { + if ((mvp1->rank)>(mvp2->rank)) + return true; + else + return false; + } + else + return false; +} + + diff --git a/Moves.h b/Moves.h new file mode 100644 index 00000000..54dc910d --- /dev/null +++ b/Moves.h @@ -0,0 +1,14 @@ +int MoveGen( + struct pos * posPoint, + int depth, + int trump, + struct movePlyType * mply, + struct localVarType * thrp); + + +void MergeSort( + int n, + struct moveType * a); + + + diff --git a/PBN.cpp b/PBN.cpp new file mode 100644 index 00000000..65232c09 --- /dev/null +++ b/PBN.cpp @@ -0,0 +1,193 @@ +/* + DDS 2.7.0 A bridge double dummy solver. + Copyright (C) 2006-2014 by Bo Haglund + Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. + The code for calculation of par score / contracts is based upon the + perl code written by Matthew Kidd for ACBLmerge. He has kindly given + permission to include a C++ adaptation in DDS. + + The PlayAnalyser analyses the played cards of the deal and presents + their double dummy values. The par calculation function DealerPar + provides an alternative way of calculating and presenting par + results. Both these functions have been written by Soren Hein. + He has also made numerous contributions to the code, especially in + the initialization part. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + + +#include "dds.h" + +int IsCard(char cardChar); + + +int ConvertFromPBN( + char * dealBuff, + unsigned int remainCards[DDS_HANDS][DDS_SUITS]) +{ + int bp=0, first, card, hand, handRelFirst, suitInHand, h, s; + int IsCard(char cardChar); + + for (h=0; h=3) + return 0; + + if ((dealBuff[bp]=='N')||(dealBuff[bp]=='n')) + first=0; + else if ((dealBuff[bp]=='E')||(dealBuff[bp]=='e')) + first=1; + else if ((dealBuff[bp]=='S')||(dealBuff[bp]=='s')) + first=2; + else + first=3; + + bp++; + bp++; + + handRelFirst=0; suitInHand=0; + + while ((bp<80)&&(dealBuff[bp]!='\0')) { + card=IsCard(dealBuff[bp]); + if (card) { + switch (first) { + case 0: + hand=handRelFirst; + break; + case 1: + if (handRelFirst==0) + hand=1; + else if (handRelFirst==3) + hand=0; + else + hand=handRelFirst+1; + break; + case 2: + if (handRelFirst==0) + hand=2; + else if (handRelFirst==1) + hand=3; + else + hand=handRelFirst-2; + break; + default: + if (handRelFirst==0) + hand=3; + else + hand=handRelFirst-1; + } + + remainCards[hand][suitInHand]|=(bitMapRank[card]<<2); + + } + else if (dealBuff[bp]=='.') + suitInHand++; + else if (dealBuff[bp]==' ') { + handRelFirst++; + suitInHand=0; + } + bp++; + } + return RETURN_NO_FAULT; +} + + +int IsCard(char cardChar) { + switch (cardChar) { + case '2': + return 2; + case '3': + return 3; + case '4': + return 4; + case '5': + return 5; + case '6': + return 6; + case '7': + return 7; + case '8': + return 8; + case '9': + return 9; + case 'T': + return 10; + case 'J': + return 11; + case 'Q': + return 12; + case 'K': + return 13; + case 'A': + return 14; + case 't': + return 10; + case 'j': + return 11; + case 'q': + return 12; + case 'k': + return 13; + case 'a': + return 14; + default: + return 0; + } + } + + +int ConvertPlayFromPBN( + struct playTracePBN *playPBN, + struct playTraceBin *playBin) +{ + int n = playPBN->number; + + if (n < 0 || n > 52) + return RETURN_PLAY_FAULT; + + playBin->number = n; + + for (int i = 0; i < 2*n; i += 2) + { + char suit = playPBN->cards[i]; + int s; + + if (suit == 's' || suit == 'S') + s = 0; + else if (suit == 'h' || suit == 'H') + s = 1; + else if (suit == 'd' || suit == 'D') + s = 2; + else if (suit == 'c' || suit == 'C') + s = 3; + else + return RETURN_PLAY_FAULT; + playBin->suit[i >> 1] = s; + + int rank = IsCard(playPBN->cards[i+1]); + if (rank == 0) + return RETURN_PLAY_FAULT; + + playBin->rank[i >> 1] = rank; + } + return RETURN_NO_FAULT; +} + diff --git a/PBN.h b/PBN.h new file mode 100644 index 00000000..d066422a --- /dev/null +++ b/PBN.h @@ -0,0 +1,11 @@ +int ConvertFromPBN( +char * dealBuff, + unsigned int remainCards[DDS_HANDS][DDS_SUITS]); + + +int ConvertPlayFromPBN( +struct playTracePBN * playPBN, + struct playTraceBin * playBin); + + + diff --git a/Par.cpp b/Par.cpp index 42bc6fa2..5f087141 100644 --- a/Par.cpp +++ b/Par.cpp @@ -1,5 +1,5 @@ /* - DDS 2.6.0 A bridge double dummy solver. + DDS 2.7.0 A bridge double dummy solver. Copyright (C) 2006-2014 by Bo Haglund Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. The code for calculation of par score / contracts is based upon the @@ -22,9 +22,24 @@ */ /*#include "stdafx.h"*/ -#include "dll.h" +/*#include "dll.h"*/ #include "dds.h" -#include "Par.h" + +struct par_suits_type { + int suit; + int tricks; + int score; +}; + +struct best_par_type { + int par_denom; + int par_tricks; +}; + +struct parContr2Type { + char contracts[10]; + int denom; +}; int stat_contr[5]={0,0,0,0,0}; const int max_low[3][8] = {{0,0,1,0,1,2,0,0},{0,0,1,2,0,1,0,0},{0,0,1,2,3,0,0,0}}; /* index 1: 0=NT, 1=Major, 2=Minor index 2: contract level 1-7 */ @@ -48,8 +63,9 @@ int STDCALL CalcParPBN(struct ddTableDealPBN tableDealPBN, #ifdef DEALER_PAR_ENGINE_ONLY -int STDCALL CalcPar(struct ddTableDeal tableDeal, int vulnerable, - struct ddTableResults * tablep, struct parResults *presp) { +int STDCALL Par(struct ddTableResults * tablep, struct parResults *presp, + int vulnerable) { + /* vulnerable 0: None 1: Both 2: NS 3: EW */ int res, i, k, m; struct parResultsDealer sidesRes[2]; @@ -57,11 +73,6 @@ int STDCALL CalcPar(struct ddTableDeal tableDeal, int vulnerable, int CalcMultiContracts(int max_lower, int tricks); - res=CalcDDtable(tableDeal, tablep); - - if (res!=1) - return res; - res = SidesPar(tablep, sidesRes, vulnerable); if (res != 1) return res; @@ -227,22 +238,6 @@ int STDCALL CalcPar(struct ddTableDeal tableDeal, int vulnerable, } #else -int STDCALL CalcPar(struct ddTableDeal tableDeal, int vulnerable, - struct ddTableResults * tablep, struct parResults *presp) { - - int res; - - res=CalcDDtable(tableDeal, tablep); - - if (res!=1) - return res; - - res=Par(tablep, presp, vulnerable); - - return res; - -} -#endif int STDCALL Par(struct ddTableResults * tablep, struct parResults *presp, int vulnerable) { @@ -458,7 +453,7 @@ int STDCALL Par(struct ddTableResults * tablep, struct parResults *presp, if (best_par_score[0] == 0) { /* Neither side can make anything.*/ - return 1; + return RETURN_NO_FAULT; } for (i = 0; i <= 1; i++) { @@ -560,7 +555,7 @@ int STDCALL Par(struct ddTableResults * tablep, struct parResults *presp, for the sacrifice is too small. */ } - int opp_tricks = max(t3[j], t4[j]); + int opp_tricks = Max(t3[j], t4[j]); while (max_lower > 0) { sc3 = -rawscore(-1, best_par[m][i].par_tricks - max_lower - opp_tricks, @@ -596,48 +591,7 @@ int STDCALL Par(struct ddTableResults * tablep, struct parResults *presp, } } - return 1; -} - - -int STDCALL SidesPar(struct ddTableResults * tablep, struct parResultsDealer sidesRes[2], int vulnerable) { - - int res, h, hbest[2], k; - struct parResultsDealer parRes2[4]; - - for (h = 0; h <= 3; h++) { - - res = DealerPar(tablep, &parRes2[h], h, vulnerable); - - char * p = strstr(parRes2[h].contracts[0], "pass"); - if (p != NULL) { - parRes2[h].number = 1; - parRes2[h].score = 0; - } - } - - if (parRes2[2].score > parRes2[0].score) - hbest[0] = 2; - else - hbest[0] = 0; - - if (parRes2[3].score > parRes2[1].score) - hbest[1] = 3; - else - hbest[1] = 1; - - sidesRes[0].number = parRes2[hbest[0]].number; - sidesRes[0].score = parRes2[hbest[0]].score; - sidesRes[1].number = parRes2[hbest[1]].number; - sidesRes[1].score = -parRes2[hbest[1]].score; - - for (k = 0; k < sidesRes[0].number; k++) - strcpy(sidesRes[0].contracts[k], parRes2[hbest[0]].contracts[k]); - - for (k = 0; k < sidesRes[1].number; k++) - strcpy(sidesRes[1].contracts[k], parRes2[hbest[1]].contracts[k]); - - return res; + return RETURN_NO_FAULT; } @@ -738,6 +692,29 @@ void IniSidesString(int dr, int i, int t1, int t2, char stri[]) { } +int VulnerDefSide(int side, int vulnerable) { + if (vulnerable == 0) + return 0; + else if (vulnerable == 1) + return 1; + else if (side) { + /* N/S makes par contract. */ + if (vulnerable == 2) + return 0; + else + return 1; + } + else { + if (vulnerable == 3) + return 0; + else + return 1; + } +} + +#endif + + int CalcMultiContracts(int max_lower, int tricks) { int n; @@ -764,25 +741,447 @@ int CalcMultiContracts(int max_lower, int tricks) { return n; } +int STDCALL CalcPar(struct ddTableDeal tableDeal, int vulnerable, + struct ddTableResults * tablep, struct parResults *presp) { -int VulnerDefSide(int side, int vulnerable) { - if (vulnerable == 0) - return 0; - else if (vulnerable == 1) - return 1; - else if (side) { - /* N/S makes par contract. */ - if (vulnerable == 2) - return 0; - else - return 1; + int res; + + res=CalcDDtable(tableDeal, tablep); + + if (res!=1) + return res; + + res=Par(tablep, presp, vulnerable); + + return res; +} + +#if 0 + +/* Unsorted*/ +int STDCALL DealerParBin( + struct ddTableResults * tablep, + struct parResultsMaster * presp, + int dealer, + int vulnerable) +{ + /* dealer 0: North 1: East 2: South 3: West */ + /* vulnerable 0: None 1: Both 2: NS 3: EW */ + + struct parResultsDealer parResDealer; + int k, delta; + + int res = DealerPar(tablep, &parResDealer, dealer, vulnerable); + + if (res != RETURN_NO_FAULT) + { + return res; } - else { - if (vulnerable == 3) - return 0; + + presp->score = parResDealer.score; + presp->number = parResDealer.number; + + for (k = 0; k < parResDealer.number; k++) + { + delta = 1; + + presp->contracts[k].level = int(parResDealer.contracts[k][0] - '0'); + + switch (parResDealer.contracts[k][1]) + { + case 'N': presp->contracts[k].denom = 0; break; + case 'S': presp->contracts[k].denom = 1; break; + case 'H': presp->contracts[k].denom = 2; break; + case 'D': presp->contracts[k].denom = 3; break; + case 'C': presp->contracts[k].denom = 4; break; + } + + if (strstr(parResDealer.contracts[k], "NS")) + presp->contracts[k].seats = 4; + else if (strstr(parResDealer.contracts[k], "EW")) + presp->contracts[k].seats = 5; + else if (strstr(parResDealer.contracts[k], "-N")) + { + presp->contracts[k].seats = 0; + delta = 0; + } + else if (strstr(parResDealer.contracts[k], "-E")) + { + presp->contracts[k].seats = 1; + delta = 0; + } + else if (strstr(parResDealer.contracts[k], "-S")) + { + presp->contracts[k].seats = 2; + delta = 0; + } + else if (strstr(parResDealer.contracts[k], "-W")) + { + presp->contracts[k].seats = 3; + delta = 0; + } + + if (parResDealer.contracts[0][2] == '*') + { + /* Sacrifice */ + presp->contracts[k].underTricks =(int) (parResDealer.contracts[k][6 + delta] -'0'); + presp->contracts[k].overTricks = 0; + } + else + /* Make */ + { + if (strchr(parResDealer.contracts[k], '+')) + presp->contracts[k].overTricks = (int)(parResDealer.contracts[k][5 + delta] - '0'); + else + presp->contracts[k].overTricks = 0; + presp->contracts[k].underTricks = 0; + } + } + } + return RETURN_NO_FAULT; +} +#endif + +int STDCALL DealerParBin( + struct ddTableResults * tablep, + struct parResultsMaster * presp, + int dealer, + int vulnerable) +{ + /* dealer 0: North 1: East 2: South 3: West */ + /* vulnerable 0: None 1: Both 2: NS 3: EW */ + + struct parResultsDealer parResDealer; + struct parContr2Type parContr2[10]; + int k, delta; + + int res = DealerPar(tablep, &parResDealer, dealer, vulnerable); + + if (res != RETURN_NO_FAULT) + { + return res; + } + + for (k = 0; kscore = parResDealer.score; + presp->number = parResDealer.number; + + for (k = 0; k < parResDealer.number; k++) + { + delta = 1; + + presp->contracts[k].level = int(parContr2[k].contracts[0] - '0'); + + switch (parContr2[k].contracts[1]) + { + case 'N': presp->contracts[k].denom = 0; break; + case 'S': presp->contracts[k].denom = 1; break; + case 'H': presp->contracts[k].denom = 2; break; + case 'D': presp->contracts[k].denom = 3; break; + case 'C': presp->contracts[k].denom = 4; break; + } + + if (strstr(parContr2[k].contracts, "NS")) + presp->contracts[k].seats = 4; + else if (strstr(parContr2[k].contracts, "EW")) + presp->contracts[k].seats = 5; + else if (strstr(parContr2[k].contracts, "-N")) + { + presp->contracts[k].seats = 0; + delta = 0; + } + else if (strstr(parContr2[k].contracts, "-E")) + { + presp->contracts[k].seats = 1; + delta = 0; + } + else if (strstr(parContr2[k].contracts, "-S")) + { + presp->contracts[k].seats = 2; + delta = 0; + } + else if (strstr(parContr2[k].contracts, "-W")) + { + presp->contracts[k].seats = 3; + delta = 0; + } + + if (parResDealer.contracts[0][2] == '*') + { + /* Sacrifice */ + presp->contracts[k].underTricks = (int)(parContr2[k].contracts[6 + delta] - '0'); + presp->contracts[k].overTricks = 0; + } else - return 1; + /* Make */ + + { + if (strchr(parContr2[k].contracts, '+')) + presp->contracts[k].overTricks = (int)(parContr2[k].contracts[5 + delta] - '0'); + else + presp->contracts[k].overTricks = 0; + presp->contracts[k].underTricks = 0; + } + } + return RETURN_NO_FAULT; +} + + +int STDCALL SidesPar(struct ddTableResults * tablep, struct parResultsDealer sidesRes[2], int vulnerable) { + + int res, h, hbest[2], k; + struct parResultsDealer parRes2[4]; + + for (h = 0; h <= 3; h++) { + + res = DealerPar(tablep, &parRes2[h], h, vulnerable); + + char * p = strstr(parRes2[h].contracts[0], "pass"); + if (p != NULL) { + parRes2[h].number = 1; + parRes2[h].score = 0; + } + } + + if (parRes2[2].score > parRes2[0].score) + hbest[0] = 2; + else + hbest[0] = 0; + + if (parRes2[3].score > parRes2[1].score) + hbest[1] = 3; + else + hbest[1] = 1; + + sidesRes[0].number = parRes2[hbest[0]].number; + sidesRes[0].score = parRes2[hbest[0]].score; + sidesRes[1].number = parRes2[hbest[1]].number; + sidesRes[1].score = -parRes2[hbest[1]].score; + + for (k = 0; k < sidesRes[0].number; k++) + strcpy(sidesRes[0].contracts[k], parRes2[hbest[0]].contracts[k]); + + for (k = 0; k < sidesRes[1].number; k++) + strcpy(sidesRes[1].contracts[k], parRes2[hbest[1]].contracts[k]); + + return res; +} + + +int STDCALL SidesParBin( + struct ddTableResults * tablep, + struct parResultsMaster sidesRes[2], + int vulnerable) + { + + int res, h, hbest[2], k; + struct parResultsMaster parRes2[4]; + + for (h = 0; h <= 3; h++) { + + res = DealerParBin(tablep, &parRes2[h], h, vulnerable); + + if (res != RETURN_NO_FAULT) + return res; + + if (parRes2[h].score == 0) + { + if ((h == 0) || (h == 2)) + { + sidesRes[0].number = 1; + sidesRes[0].score = 0; + } + else { + sidesRes[1].number = 1; + sidesRes[1].score = 0; + } + } } + + if (parRes2[2].score > parRes2[0].score) + hbest[0] = 2; + else + hbest[0] = 0; + + if (parRes2[3].score > parRes2[1].score) + hbest[1] = 3; + else + hbest[1] = 1; + + sidesRes[0].number = parRes2[hbest[0]].number; + sidesRes[0].score = parRes2[hbest[0]].score; + sidesRes[1].number = parRes2[hbest[1]].number; + sidesRes[1].score = -parRes2[hbest[1]].score; + + for (k = 0; k < sidesRes[0].number; k++) + sidesRes[0].contracts[k] = parRes2[hbest[0]].contracts[k]; + + for (k = 0; k < sidesRes[1].number; k++) + sidesRes[1].contracts[k] = parRes2[hbest[1]].contracts[k]; + + return RETURN_NO_FAULT; +} + + +int STDCALL ConvertToDealerTextFormat(struct parResultsMaster *pres, char *resp) { + int k, i; + char buff[20]; + + sprintf(resp, "Par %d: ", pres->score); + + for (k = 0; k < pres->number; k++) { + + if (k != 0) + strcat(resp, " "); + + switch (pres->contracts[k].seats) { + case 0: strcat(resp, "N "); break; + case 1: strcat(resp, "E "); break; + case 2: strcat(resp, "S "); break; + case 3: strcat(resp, "W "); break; + case 4: strcat(resp, "NS "); break; + case 5: strcat(resp, "EW "); break; + } + + for (i = 0; i < 10; i++) + buff[i] = '\0'; + sprintf(buff, "%d", pres->contracts[k].level); + strcat(resp, buff); + + switch (pres->contracts[k].denom) { + case 0: strcat(resp, "N"); break; + case 1: strcat(resp, "S"); break; + case 2: strcat(resp, "H"); break; + case 3: strcat(resp, "D"); break; + case 4: strcat(resp, "C"); break; + } + + if (pres->contracts[k].underTricks > 0) { + strcat(resp, "x-"); + for (i = 0; i < 10; i++) + buff[i] = '\0'; + sprintf(buff, "%d", pres->contracts[k].underTricks); + strcat(resp, buff); + } + else if (pres->contracts[k].overTricks > 0) { + strcat(resp, "+"); + for (i = 0; i < 10; i++) + buff[i] = '\0'; + sprintf(buff, "%d", pres->contracts[k].overTricks); + strcat(resp, buff); + } + } + return RETURN_NO_FAULT; +} + + + + +int STDCALL ConvertToSidesTextFormat(struct parResultsMaster *pres, struct parTextResults *resp) { + int k, i, j; + char buff[20]; + + for (i = 0; i < 2; i++) + for (k = 0; k < 128; k++) + resp->parText[i][k] = '\0'; + + if (pres->score == 0) { + sprintf(resp->parText[0], "Par 0"); + return RETURN_NO_FAULT; + } + + for (i = 0; i < 2; i++) { + + sprintf(resp->parText[i], "Par %d: ", (pres + i)->score); + + for (k = 0; k < (pres + i)->number; k++) { + + if (k != 0) + strcat(resp->parText[i], " "); + + switch ((pres + i)->contracts[k].seats) { + case 0: strcat(resp->parText[i], "N "); break; + case 1: strcat(resp->parText[i], "E "); break; + case 2: strcat(resp->parText[i], "S "); break; + case 3: strcat(resp->parText[i], "W "); break; + case 4: strcat(resp->parText[i], "NS "); break; + case 5: strcat(resp->parText[i], "EW "); break; + } + + for (j = 0; j < 10; j++) + buff[j] = '\0'; + sprintf(buff, "%d", (pres + i)->contracts[k].level); + strcat(resp->parText[i], buff); + + switch ((pres + i)->contracts[k].denom) { + case 0: strcat(resp->parText[i], "NT"); break; + case 1: strcat(resp->parText[i], "S"); break; + case 2: strcat(resp->parText[i], "H"); break; + case 3: strcat(resp->parText[i], "D"); break; + case 4: strcat(resp->parText[i], "C"); break; + } + + if ((pres + i)->contracts[k].underTricks > 0) { + strcat(resp->parText[i], "x-"); + for (j = 0; j < 10; j++) + buff[j] = '\0'; + sprintf(buff, "%d", (pres + i)->contracts[k].underTricks); + strcat(resp->parText[i], buff); + } + else if ((pres + i)->contracts[k].overTricks > 0) { + strcat(resp->parText[i], "+"); + for (j = 0; j < 10; j++) + buff[j] = '\0'; + sprintf(buff, "%d", (pres + i)->contracts[k].overTricks); + strcat(resp->parText[i], buff); + } + } + + if (i == 0){ + if ((pres->score != -(pres + 1)->score) || (pres->number != (pres + 1)->number)) { + resp->equal = FALSE; + } + else { + resp->equal = TRUE; + for (k = 0; k < pres->number; k++) { + if ((pres->contracts[k].denom != (pres + 1)->contracts[k].denom) || + (pres->contracts[k].level != (pres + 1)->contracts[k].level) || + (pres->contracts[k].overTricks != (pres + 1)->contracts[k].overTricks) || + (pres->contracts[k].seats != (pres + 1)->contracts[k].seats) || + (pres->contracts[k].underTricks != (pres + 1)->contracts[k].underTricks)) { + resp->equal = FALSE; + break; + } + } + } + } + } + + return RETURN_NO_FAULT; } diff --git a/PlayAnalyser.cpp b/PlayAnalyser.cpp index 57e019b8..71df3123 100644 --- a/PlayAnalyser.cpp +++ b/PlayAnalyser.cpp @@ -1,42 +1,49 @@ -/* - DDS 2.6.0 A bridge double dummy solver. - Copyright (C) 2006-2014 by Bo Haglund +/* + DDS 2.7.0 A bridge double dummy solver. + Copyright (C) 2006-2014 by Bo Haglund Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. The code for calculation of par score / contracts is based upon the - perl code written by Matthew Kidd for ACBLmerge. He has kindly given - me permission to include a C++ adaptation in DDS. -*/ + perl code written by Matthew Kidd for ACBLmerge. He has kindly given + permission to include a C++ adaptation in DDS. + + The PlayAnalyser analyses the played cards of the deal and presents + their double dummy values. The par calculation function DealerPar + provides an alternative way of calculating and presenting par + results. Both these functions have been written by Soren Hein. + He has also made numerous contributions to the code, especially in + the initialization part. -/* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at - http://www.apache.org/licenses/LICENSE-2.0 - Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied. See the License for the specific language governing - permissions and limitations under the License. + implied. + See the License for the specific language governing permissions and + limitations under the License. */ -/* The PlayAnalyser was written by Sören Hein. Many thanks for - allowing me to include it in DDS. */ - - -/*#include "stdafx.h"*/ - -#include "PlayAnalyser.h" -#include "dll.h" #include "dds.h" +#include "PBN.h" +// Only single-threaded debugging here. #define DEBUG 0 FILE *fp; +struct playparamType { + int noOfBoards; + struct boards * bop; + struct playTracesBin * plp; + struct solvedPlays * solvedp; + int error; +}; + + int STDCALL AnalysePlayBin( struct deal dl, struct playTraceBin play, @@ -51,7 +58,7 @@ int STDCALL AnalysePlayBin( int last_card = ((play.number+3) % 4) + 1; solvedp->number = 0; - ret = SolveBoard(dl, -1, 3, 1, &fut, thrId); + ret = SolveBoard(dl, -1, 1, 1, &fut, thrId); if (ret != RETURN_NO_FAULT) return ret; @@ -66,17 +73,16 @@ int STDCALL AnalysePlayBin( int declarer = (dl.first + 3) % 4; int dummy = (dl.first + 1) % 4; int initial_par = solved_declarer; - if (DEBUG) - { - fp = fopen("trace.txt", "a"); - fprintf(fp, "Initial solve: %d\n", initial_par); - fprintf(fp, "no %d, Last trick %d, last card %d\n", - play.number, last_trick, last_card); - fprintf(fp, "%5s %5s %5s %8s %6s %6s %5s %5s %5s\n", - "trick", "card", "rest", "declarer", - "player", "side", "soln0", "soln1", "diff"); - fclose(fp); - } +#if DEBUG + fp = fopen("trace.txt", "a"); + fprintf(fp, "Initial solve: %d\n", initial_par); + fprintf(fp, "no %d, Last trick %d, last card %d\n", + play.number, last_trick, last_card); + fprintf(fp, "%5s %5s %5s %8s %6s %6s %5s %5s %5s\n", + "trick", "card", "rest", "declarer", + "player", "side", "soln0", "soln1", "diff"); + fclose(fp); +#endif for (int trick = 1; trick <= last_trick; trick++) { @@ -115,13 +121,12 @@ int STDCALL AnalysePlayBin( if ((dl.remainCards[running_player][suit] & hold) == 0) { - if (DEBUG) - { - fp = fopen("trace.txt", "a"); - fprintf(fp, "ERR Trick %d card %d pl %d: suit %d hold %d\n", - trick, card, running_player, suit, hold); - fclose(fp); - } +#if DEBUG + fp = fopen("trace.txt", "a"); + fprintf(fp, "ERR Trick %d card %d pl %d: suit %d hold %d\n", + trick, card, running_player, suit, hold); + fclose(fp); +#endif return RETURN_PLAY_FAULT; } @@ -150,14 +155,13 @@ int STDCALL AnalysePlayBin( dl.currentTrickRank[card-1] = rr; } - if ((ret = SolveBoard(dl, -1, 2/*3*/, 1, &fut, thrId)) + if ((ret = SolveBoard(dl, -1, 1, 1, &fut, thrId)) != RETURN_NO_FAULT) { - if (DEBUG) - { - fp = fopen("trace.txt", "a"); - fprintf(fp, "SolveBoard failed, ret %d\n", ret); - } +#if DEBUG + fp = fopen("trace.txt", "a"); + fprintf(fp, "SolveBoard failed, ret %d\n", ret); +#endif return ret; } @@ -166,16 +170,15 @@ int STDCALL AnalysePlayBin( solvedp->tricks[offset + card] = new_solved_decl; - if (DEBUG) - { - fp = fopen("trace.txt", "a"); - fprintf(fp, "%5d %5d %5d %8d %6c %6d %5d %5d %5d\n", - trick, card, running_remainder, running_declarer, - cardHand[resp_player], running_side, - solved_declarer, new_solved_decl, - new_solved_decl - solved_declarer); - fclose(fp); - } +#if DEBUG + fp = fopen("trace.txt", "a"); + fprintf(fp, "%5d %5d %5d %8d %6c %6d %5d %5d %5d\n", + trick, card, running_remainder, running_declarer, + cardHand[resp_player], running_side, + solved_declarer, new_solved_decl, + new_solved_decl - solved_declarer); + fclose(fp); +#endif solved_declarer = new_solved_decl; } @@ -192,10 +195,6 @@ int STDCALL AnalysePlayPBN( struct solvedPlay * solvedp, int thrId) { - int ConvertPlayFromPBN( - struct playTracePBN *playPBN, - struct playTraceBin *playBin); - struct deal dl; struct playTraceBin play; @@ -219,50 +218,12 @@ int STDCALL AnalysePlayPBN( } -int ConvertPlayFromPBN( - struct playTracePBN *playPBN, - struct playTraceBin *playBin) -{ - int n = playPBN->number; - - if (n < 0 || n > 52) - return RETURN_PLAY_FAULT; - - playBin->number = n; - - for (int i = 0; i < 2*n; i += 2) - { - char suit = playPBN->cards[i]; - int s; - - if (suit == 's' || suit == 'S') - s = 0; - else if (suit == 'h' || suit == 'H') - s = 1; - else if (suit == 'd' || suit == 'D') - s = 2; - else if (suit == 'c' || suit == 'C') - s = 3; - else - return RETURN_PLAY_FAULT; - playBin->suit[i >> 1] = s; - - int rank = IsCard(playPBN->cards[i+1]); - if (rank == 0) - return RETURN_PLAY_FAULT; - - // playBin->rank[i >> 1] = bitMapRank[rank]; - playBin->rank[i >> 1] = rank; - } - return RETURN_NO_FAULT; -} - - long pchunk = 0; int pfail; -#if defined(_WIN32) && !defined(_OPENMP) && !defined(DDS_THREADS_SINGLE) +#if (defined(_WIN32) || defined(__CYGWIN__)) && \ + !defined(_OPENMP) && !defined(DDS_THREADS_SINGLE) HANDLE solveAllPlayEvents[MAXNOOFTHREADS]; LONG volatile pthreadIndex; @@ -329,14 +290,14 @@ int STDCALL AnalyseAllPlaysBin( playparam.noOfBoards = bop->noOfBoards; playparam.solvedp = solvedp; - for (int k = 0; k < noOfCores; k++) + for (int k = 0; k < noOfThreads; k++) { solveAllPlayEvents[k] = CreateEvent(NULL, FALSE, FALSE, 0); if (solveAllPlayEvents[k] == 0) return RETURN_THREAD_CREATE; } - for (int k = 0; k < noOfCores; k++) + for (int k = 0; k < noOfThreads; k++) { res = QueueUserWorkItem(SolveChunkTracePlay, NULL, WT_EXECUTELONGFUNCTION); @@ -344,13 +305,13 @@ int STDCALL AnalyseAllPlaysBin( return res; } - solveAllWaitResult = WaitForMultipleObjects(noOfCores, + solveAllWaitResult = WaitForMultipleObjects(noOfThreads, solveAllPlayEvents, TRUE, INFINITE); if (solveAllWaitResult != WAIT_OBJECT_0) return RETURN_THREAD_WAIT; - for (int k = 0; k < noOfCores; k++) + for (int k = 0; k < noOfThreads; k++) CloseHandle(solveAllPlayEvents[k]); solvedp->noOfBoards = bop->noOfBoards; @@ -381,7 +342,7 @@ int STDCALL AnalyseAllPlaysBin( #if defined (_OPENMP) && !defined(DDS_THREADS_SINGLE) if (omp_get_dynamic()) omp_set_dynamic(0); - omp_set_num_threads(noOfCores); + omp_set_num_threads(noOfThreads); #elif defined (_OPENMP) omp_set_num_threads(1); #endif diff --git a/QuickTricks.cpp b/QuickTricks.cpp new file mode 100644 index 00000000..92e88d5f --- /dev/null +++ b/QuickTricks.cpp @@ -0,0 +1,1235 @@ +/* + DDS 2.7.0 A bridge double dummy solver. + Copyright (C) 2006-2014 by Bo Haglund + Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. + The code for calculation of par score / contracts is based upon the + perl code written by Matthew Kidd for ACBLmerge. He has kindly given + permission to include a C++ adaptation in DDS. + + The PlayAnalyser analyses the played cards of the deal and presents + their double dummy values. The par calculation function DealerPar + provides an alternative way of calculating and presenting par + results. Both these functions have been written by Soren Hein. + He has also made numerous contributions to the code, especially in + the initialization part. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + + +#include "dds.h" + + +int QtricksLeadHandNT( + int hand, + struct pos * posPoint, + int cutoff, + int depth, + int countLho, + int countRho, + int * lhoTrumpRanks, + int * rhoTrumpRanks, + bool commPartner, + int commSuit, + int countOwn, + int countPart, + int suit, + int qtricks, + int trump, + int * res, + struct localVarType * thrp); + +int QtricksLeadHandTrump( + int hand, + struct pos * posPoint, + int cutoff, + int depth, + int countLho, + int countRho, + int lhoTrumpRanks, + int rhoTrumpRanks, + int countOwn, + int countPart, + int suit, + int qtricks, + int trump, + int * res, + struct localVarType * thrp); + +int QuickTricksPartnerHandTrump( + int hand, + struct pos * posPoint, + int cutoff, + int depth, + int countLho, + int countRho, + int lhoTrumpRanks, + int rhoTrumpRanks, + int countOwn, + int countPart, + int suit, + int qtricks, + int commSuit, + int commRank, + int trump, + int * res, + struct localVarType * thrp); + +int QuickTricksPartnerHandNT( + int hand, + struct pos * posPoint, + int cutoff, + int depth, + int countLho, + int countRho, + int countOwn, + int countPart, + int suit, + int qtricks, + int commSuit, + int commRank, + int trump, + int * res, + struct localVarType * thrp); + + +int QuickTricks( + struct pos * posPoint, + int hand, + int depth, + int target, + int trump, + bool * result, + struct localVarType * thrp) +{ + int suit, commRank = 0, commSuit = -1; + int res; + int lhoTrumpRanks, rhoTrumpRanks; + int cutoff, lowestQtricks = 0; + + *result = true; + int qtricks = 0; + + if (thrp->nodeTypeStore[hand] == MAXNODE) + cutoff = target - posPoint->tricksMAX; + else + cutoff = posPoint->tricksMAX - target + (depth >> 2) + 2; + + bool commPartner = false; + unsigned short (* ris)[DDS_SUITS] = posPoint->rankInSuit; + unsigned char (* len)[DDS_SUITS] = posPoint->length; + struct highCardType * winner = posPoint->winner; + + for (int s = 0; s < DDS_SUITS; s++) + { + if ((trump != DDS_NOTRUMP) && (trump != s)) + { + /* Trump game, and we lead a non-trump suit */ + if (winner[s].hand == partner[hand]) + { + /* Partner has winning card */ + if (ris[hand][s] != 0 && /* Own hand has card */ + (((ris[lho[hand]][s] != 0) || /* LHO not void */ + (ris[lho[hand]][trump] == 0)) && /* LHO no trump */ + ((ris[rho[hand]][s] != 0) || /* RHO not void */ + (ris[rho[hand]][trump] == 0)))) /* RHO no trump */ + { + commPartner = true; + commSuit = s; + commRank = winner[s].rank; + break; + } + } + else if ((posPoint->secondBest[s].hand == partner[hand]) && + (winner[s].hand == hand) && + (len[hand][s] >= 2) && + (len[partner[hand]][s] >= 2)) + { + /* Can cross to partner's card: Type Kx opposite Ax */ + if (((ris[lho[hand]][s] != 0) || /* LHO not void */ + (ris[lho[hand]][trump] == 0)) /* LHO no trump */ + && ((ris[rho[hand]][s] != 0) || /* RHO not void */ + (ris[rho[hand]][trump] == 0))) /* RHO no trump */ + { + commPartner = true; + commSuit = s; + commRank = posPoint->secondBest[s].rank; + break; + } + } + } + else if (trump == DDS_NOTRUMP) + { + if (winner[s].hand == partner[hand]) + { + /* Partner has winning card in NT */ + if (ris[hand][s] != 0) /* Own hand has card */ + { + commPartner = true; + commSuit = s; + commRank = winner[s].rank; + break; + } + } + else if ((posPoint->secondBest[s].hand == partner[hand]) && + (winner[s].hand == hand) && + (len[hand][s] >= 2) && + (len[partner[hand]][s] >= 2)) + { + /* Can cross to partner's card: Type Kx opposite Ax */ + commPartner = true; + commSuit = s; + commRank = posPoint->secondBest[s].rank; + break; + } + } + } + + if ((trump != DDS_NOTRUMP) && (!commPartner) && + (ris[hand][trump] != 0) && + (winner[trump].hand == partner[hand])) + { + /* Communication in trump suit */ + commPartner = true; + commSuit = trump; + commRank = winner[trump].rank; + } + + if (trump != DDS_NOTRUMP) + { + suit = trump; + lhoTrumpRanks = len[lho[hand]][trump]; + rhoTrumpRanks = len[rho[hand]][trump]; + } + else + suit = 0; + + do + { + int countOwn = len[hand][suit]; + int countLho = len[lho[hand]][suit]; + int countRho = len[rho[hand]][suit]; + int countPart = len[partner[hand]][suit]; + int opps = countLho | countRho; + + if (!opps && (countPart == 0)) + { + if (countOwn == 0) + { + /* Continue with next suit. */ + if ((trump != DDS_NOTRUMP) && (trump != suit)) + { + suit++; + if ((trump != DDS_NOTRUMP) && (suit == trump)) + suit++; + } + else + { + if ((trump != DDS_NOTRUMP) && (trump == suit)) + { + if (trump == 0) + suit = 1; + else + suit = 0; + } + else + suit++; + } + continue; + } + + /* Long tricks when only leading hand have cards in the suit. */ + if ((trump != DDS_NOTRUMP) && (trump != suit)) + { + if ((lhoTrumpRanks == 0) && (rhoTrumpRanks == 0)) + { + qtricks += countOwn; + if (qtricks >= cutoff) + return qtricks; + suit++; + if ((trump != DDS_NOTRUMP) && (suit == trump)) + suit++; + continue; + } + else + { + suit++; + if ((trump != DDS_NOTRUMP) && (suit == trump)) + suit++; + continue; + } + } + else + { + qtricks += countOwn; + if (qtricks >= cutoff) + return qtricks; + + if ((trump != DDS_NOTRUMP) && (suit == trump)) + { + if (trump == 0) + suit = 1; + else + suit = 0; + } + else + { + suit++; + if ((trump != DDS_NOTRUMP) && (suit == trump)) + suit++; + } + continue; + } + } + else + { + if (!opps && (trump != DDS_NOTRUMP) && (suit == trump)) + { + /* The partner but not the opponents have cards in + the trump suit. */ + + int sum = Max(countOwn, countPart); + for (int s = 0; s < DDS_SUITS; s++) + { + if ((sum > 0) && + (s != trump) && + (countOwn >= countPart) && + (len[hand][s] > 0) && + (len[partner[hand]][s] == 0)) + { + sum++; + break; + } + } + /* If the additional trick by ruffing causes a cutoff. + (qtricks not incremented.) */ + if (sum >= cutoff) + return sum; + } + else if (!opps) + { + /* The partner but not the opponents have cards in the suit. */ + int sum = Min(countOwn, countPart); + if (trump == DDS_NOTRUMP) + { + if (sum >= cutoff) + return sum; + } + else if ((suit != trump) && + (lhoTrumpRanks == 0) && + (rhoTrumpRanks == 0)) + { + if (sum >= cutoff) + return sum; + } + } + + if (commPartner) + { + if (!opps && (countOwn == 0)) + { + if ((trump != DDS_NOTRUMP) && (trump != suit)) + { + if ((lhoTrumpRanks == 0) && (rhoTrumpRanks == 0)) + { + qtricks += countPart; + posPoint->winRanks[depth][commSuit] |= + bitMapRank[commRank]; + + if (qtricks >= cutoff) + return qtricks; + + suit++; + if ((trump != DDS_NOTRUMP) && (suit == trump)) + suit++; + continue; + } + else + { + suit++; + if ((trump != DDS_NOTRUMP) && (suit == trump)) + suit++; + continue; + } + } + else + { + qtricks += countPart; + posPoint->winRanks[depth][commSuit] |= + bitMapRank[commRank]; + + if (qtricks >= cutoff) + return qtricks; + + if ((trump != DDS_NOTRUMP) && (suit == trump)) + { + if (trump == 0) + suit = 1; + else + suit = 0; + } + else + { + suit++; + if ((trump != DDS_NOTRUMP) && (suit == trump)) + suit++; + } + continue; + } + } + else + { + if (!opps && (trump != DDS_NOTRUMP) && (suit == trump)) + { + int sum = Max(countOwn, countPart); + for (int s = 0; s < DDS_SUITS; s++) + { + if ((sum > 0) && + (s != trump) && + (countOwn <= countPart) && + (len[partner[hand]][s] > 0) && + (len[hand][s] == 0)) + { + sum++; + break; + } + } + if (sum >= cutoff) + { + posPoint->winRanks[depth][commSuit] |= + bitMapRank[commRank]; + return sum; + } + } + else if (!opps) + { + int sum = Min(countOwn, countPart); + if (trump == DDS_NOTRUMP) + { + if (sum >= cutoff) + return sum; + } + else if ((suit != trump) && + (lhoTrumpRanks == 0) && + (rhoTrumpRanks == 0)) + { + if (sum >= cutoff) + return sum; + } + } + } + } + } + + if (winner[suit].rank == 0) + { + if ((trump != DDS_NOTRUMP) && (suit == trump)) + { + if (trump == 0) + suit = 1; + else + suit = 0; + } + else + { + suit++; + if ((trump != DDS_NOTRUMP) && (suit == trump)) + suit++; + } + continue; + } + + if (winner[suit].hand == hand) + { + if ((trump != DDS_NOTRUMP) && (trump != suit)) + { + qtricks = QtricksLeadHandTrump(hand, posPoint, cutoff, depth, + countLho, countRho, lhoTrumpRanks, rhoTrumpRanks, + countOwn, countPart, suit, qtricks, trump, &res, thrp); + + if (res == 1) + return qtricks; + else if (res == 2) + { + suit++; + if ((trump != DDS_NOTRUMP) && (suit == trump)) + suit++; + continue; + } + } + else + { + qtricks = QtricksLeadHandNT(hand, posPoint, cutoff, depth, + countLho, countRho, &lhoTrumpRanks, &rhoTrumpRanks, + commPartner, commSuit, countOwn, countPart, + suit, qtricks, trump, &res, thrp); + + if (res == 1) + return qtricks; + else if (res == 2) + { + if ((trump != DDS_NOTRUMP) && (trump == suit)) + { + if (trump == 0) + suit = 1; + else + suit = 0; + } + else + suit++; + continue; + } + } + } + + /* It was not possible to take a quick trick by own winning + card in the suit */ + else + { + /* Partner winning card? */ + if ((winner[suit].hand == partner[hand])) + { + /* Winner found at partner*/ + if (commPartner) + { + /* There is communication with the partner */ + if ((trump != DDS_NOTRUMP) && (trump != suit)) + { + qtricks = QuickTricksPartnerHandTrump(hand, posPoint, + cutoff, depth, countLho, countRho, + lhoTrumpRanks, rhoTrumpRanks, countOwn, + countPart, suit, qtricks, commSuit, commRank, + trump, &res, thrp); + + if (res == 1) + return qtricks; + else if (res == 2) + { + suit++; + if ((trump != DDS_NOTRUMP) && (suit == trump)) + suit++; + continue; + } + } + else + { + qtricks = QuickTricksPartnerHandNT(hand, posPoint, cutoff, + depth, countLho, countRho, countOwn, countPart, + suit, qtricks, commSuit, commRank, trump, &res, thrp); + + if (res == 1) + return qtricks; + else if (res == 2) + { + if ((trump != DDS_NOTRUMP) && (trump == suit)) + { + if (trump == 0) + suit = 1; + else + suit = 0; + } + else + suit++; + continue; + } + } + } + } + } + if ((trump != DDS_NOTRUMP) && (suit != trump) && + (countOwn > 0) && (lowestQtricks == 0) && + ((qtricks == 0) || + ((winner[suit].hand != hand) && + (winner[suit].hand != partner[hand]) && + (winner[trump].hand != hand) && + (winner[trump].hand != partner[hand])))) + { + if ((countPart == 0) && (len[partner[hand]][trump] > 0)) + { + if (((countRho > 0) || (len[rho[hand]][trump] == 0)) && + ((countLho > 0) || (len[lho[hand]][trump] == 0))) + { + lowestQtricks = 1; + if (1 >= cutoff) + return 1; + suit++; + if ((trump != DDS_NOTRUMP) && (suit == trump)) + suit++; + continue; + } + else if ((countRho == 0) && (countLho == 0)) + { + if ((ris[lho[hand]][trump] | + ris[rho[hand]][trump]) < + ris[partner[hand]][trump]) + { + lowestQtricks = 1; + + int rr = highestRank[ris[partner[hand]][trump]]; + if (rr != 0) + { + posPoint->winRanks[depth][trump] |= bitMapRank[rr]; + if (1 >= cutoff) + return 1; + } + } + suit++; + if ((trump != DDS_NOTRUMP) && (suit == trump)) + suit++; + continue; + } + else if (countLho == 0) + { + if (ris[lho[hand]][trump] < + ris[partner[hand]][trump]) + { + lowestQtricks = 1; + for (int rr = 14; rr >= 2; rr--) + { + if ((ris[partner[hand]][trump] & bitMapRank[rr]) != 0) + { + posPoint->winRanks[depth][trump] |= bitMapRank[rr]; + break; + } + } + if (1 >= cutoff) + return 1; + } + suit++; + if ((trump != DDS_NOTRUMP) && (suit == trump)) + suit++; + continue; + } + else if (countRho == 0) + { + if (ris[rho[hand]][trump] < + ris[partner[hand]][trump]) + { + lowestQtricks = 1; + for (int rr = 14; rr >= 2; rr--) + { + if ((ris[partner[hand]][trump] & bitMapRank[rr]) != 0) + { + posPoint->winRanks[depth][trump] |= bitMapRank[rr]; + break; + } + } + if (1 >= cutoff) + return 1; + } + suit++; + if ((trump != DDS_NOTRUMP) && (suit == trump)) + suit++; + continue; + } + } + } + + if (qtricks >= cutoff) + return qtricks; + + if ((trump != DDS_NOTRUMP) && (suit == trump)) + { + if (trump == 0) + suit = 1; + else + suit = 0; + } + else + { + suit++; + if ((trump != DDS_NOTRUMP) && (suit == trump)) + suit++; + } + } + while (suit <= 3); + + if (qtricks == 0) + { + if ((trump == DDS_NOTRUMP) || (winner[trump].hand == -1)) + { + for (int ss = 0; ss < DDS_SUITS; ss++) + { + if (winner[ss].hand == -1) + continue; + if (len[hand][ss] > 0) + { + posPoint->winRanks[depth][ss] = bitMapRank[winner[ss].rank]; + } + } + + if (thrp->nodeTypeStore[hand] != MAXNODE) + cutoff = target - posPoint->tricksMAX; + else + { + cutoff = posPoint->tricksMAX - target + (depth >> 2) + 2; + } + + if (1 >= cutoff) + return 0; + } + } + + *result = false; + return qtricks; +} + + +int QtricksLeadHandTrump( + int hand, + struct pos * posPoint, + int cutoff, + int depth, + int countLho, + int countRho, + int lhoTrumpRanks, + int rhoTrumpRanks, + int countOwn, + int countPart, + int suit, + int qtricks, + int trump, + int * res, + struct localVarType * thrp) +{ + /* res=0 Continue with same suit. + res=1 Cutoff. + res=2 Continue with next suit. */ + + *res = 1; + int qt = qtricks; + if (((countLho != 0) || + (lhoTrumpRanks == 0)) && + ((countRho != 0) || (rhoTrumpRanks == 0))) + { + posPoint->winRanks[depth][suit] |= + bitMapRank[posPoint->winner[suit].rank]; + qt++; + if (qt >= cutoff) + return qt; + + if ((countLho <= 1) && + (countRho <= 1) && + (countPart <= 1) && + (lhoTrumpRanks == 0) && + (rhoTrumpRanks == 0)) + { + qt += countOwn - 1; + if (qt >= cutoff) + return qt; + *res = 2; + return qt; + } + } + + if (posPoint->secondBest[suit].hand == hand) + { + if ((lhoTrumpRanks == 0) && (rhoTrumpRanks == 0)) + { + posPoint->winRanks[depth][suit] |= + bitMapRank[posPoint->secondBest[suit].rank]; + qt++; + if (qt >= cutoff) + return qt; + if ((countLho <= 2) && (countRho <= 2) && (countPart <= 2)) + { + qt += countOwn - 2; + if (qt >= cutoff) + return qt; + *res = 2; + return qt; + } + } + } + else if ((posPoint->secondBest[suit].hand == partner[hand]) + && (countOwn > 1) && (countPart > 1)) + { + /* Second best at partner and suit length of own + hand and partner > 1 */ + if ((lhoTrumpRanks == 0) && (rhoTrumpRanks == 0)) + { + posPoint->winRanks[depth][suit] |= + bitMapRank[posPoint->secondBest[suit].rank]; + qt++; + if (qt >= cutoff) + return qt; + if ((countLho <= 2) && + (countRho <= 2) && + ((countPart <= 2) || (countOwn <= 2))) + { + qt += Max(countOwn - 2, countPart - 2); + if (qt >= cutoff) + return qt; + *res = 2; + return qt; + } + } + } + *res = 0; + return qt; +} + +int QtricksLeadHandNT( + int hand, + struct pos * posPoint, + int cutoff, + int depth, + int countLho, + int countRho, + int * lhoTrumpRanks, + int * rhoTrumpRanks, + bool commPartner, + int commSuit, + int countOwn, + int countPart, + int suit, + int qtricks, + int trump, + int * res, + struct localVarType * thrp) +{ + /* res=0 Continue with same suit. + res=1 Cutoff. + res=2 Continue with next suit. */ + + *res = 1; + int qt = qtricks; + posPoint->winRanks[depth][suit] |= + bitMapRank[posPoint->winner[suit].rank]; + + qt++; + if (qt >= cutoff) + return qt; + if ((trump == suit) && ((!commPartner) || (suit != commSuit))) + { + (*lhoTrumpRanks) = Max(0, (*lhoTrumpRanks) - 1); + (*rhoTrumpRanks) = Max(0, (*rhoTrumpRanks) - 1); + } + + if ((countLho <= 1) && (countRho <= 1) && (countPart <= 1)) + { + qt += countOwn - 1; + if (qt >= cutoff) + return qt; + *res = 2; + return qt; + } + + if (posPoint->secondBest[suit].hand == hand) + { + posPoint->winRanks[depth][suit] |= + bitMapRank[posPoint->secondBest[suit].rank]; + qt++; + if (qt >= cutoff) + return qt; + if ((trump == suit) && ((!commPartner) || (suit != commSuit))) + { + (*lhoTrumpRanks) = Max(0, (*lhoTrumpRanks) - 1); + (*rhoTrumpRanks) = Max(0, (*rhoTrumpRanks) - 1); + } + if ((countLho <= 2) && (countRho <= 2) && (countPart <= 2)) + { + qt += countOwn - 2; + if (qt >= cutoff) + return qt; + *res = 2; + return qt; + } + } + else if ((posPoint->secondBest[suit].hand == partner[hand]) + && (countOwn > 1) && (countPart > 1)) + { + /* Second best at partner and suit length of own + hand and partner > 1 */ + posPoint->winRanks[depth][suit] |= + bitMapRank[posPoint->secondBest[suit].rank]; + qt++; + if (qt >= cutoff) + return qt; + if ((trump == suit) && ((!commPartner) || (suit != commSuit))) + { + (*lhoTrumpRanks) = Max(0, (*lhoTrumpRanks) - 1); + (*rhoTrumpRanks) = Max(0, (*rhoTrumpRanks) - 1); + } + if ((countLho <= 2) && + (countRho <= 2) && + ((countPart <= 2) || (countOwn <= 2))) + { + qt += Max(countOwn - 2, countPart - 2); + if (qt >= cutoff) + return qt; + *res = 2; + return qt; + } + } + + *res = 0; + return qt; +} + + +int QuickTricksPartnerHandTrump( + int hand, + struct pos * posPoint, + int cutoff, + int depth, + int countLho, + int countRho, + int lhoTrumpRanks, + int rhoTrumpRanks, + int countOwn, + int countPart, + int suit, + int qtricks, + int commSuit, + int commRank, + int trump, + int * res, + struct localVarType * thrp) +{ + /* res=0 Continue with same suit. + res=1 Cutoff. + res=2 Continue with next suit. */ + + *res = 1; + int qt = qtricks; + if (((countLho != 0) || (lhoTrumpRanks == 0)) && + ((countRho != 0) || (rhoTrumpRanks == 0))) + { + posPoint->winRanks[depth][suit] |= + bitMapRank[posPoint->winner[suit].rank]; + + posPoint->winRanks[depth][commSuit] |= bitMapRank[commRank]; + + qt++; /* A trick can be taken */ + if (qt >= cutoff) + return qt; + if ((countLho <= 1) && + (countRho <= 1) && + (countOwn <= 1) && + (lhoTrumpRanks == 0) && + (rhoTrumpRanks == 0)) + { + qt += countPart - 1; + if (qt >= cutoff) + return qt; + *res = 2; + return qt; + } + } + + if (posPoint->secondBest[suit].hand == partner[hand]) + { + /* Second best found in partners hand */ + if ((lhoTrumpRanks == 0) && (rhoTrumpRanks == 0)) + { + /* Opponents have no trump */ + posPoint->winRanks[depth][suit] |= + bitMapRank[posPoint->secondBest[suit].rank]; + + posPoint->winRanks[depth][commSuit] |= bitMapRank[commRank]; + qt++; + if (qt >= cutoff) + return qt; + if ((countLho <= 2) && (countRho <= 2) && (countOwn <= 2)) + { + qt += countPart - 2; + if (qt >= cutoff) + return qt; + *res = 2; + return qt; + } + } + } + else if ((posPoint->secondBest[suit].hand == hand) && + (countPart > 1) && + (countOwn > 1)) + { + /* Second best found in own hand and suit lengths of own hand + and partner > 1*/ + + if ((lhoTrumpRanks == 0) && (rhoTrumpRanks == 0)) + { + /* Opponents have no trump */ + posPoint->winRanks[depth][suit] |= + bitMapRank[posPoint->secondBest[suit].rank]; + + posPoint->winRanks[depth][commSuit] |= bitMapRank[commRank]; + + qt++; + if (qt >= cutoff) + return qt; + if ((countLho <= 2) && + (countRho <= 2) && + ((countOwn <= 2) || (countPart <= 2))) + { + qt += Max(countPart - 2, countOwn - 2); + if (qt >= cutoff) + return qt; + *res = 2; + return qt; + } + } + } + else if ((suit == commSuit) && + (posPoint->secondBest[suit].hand == lho[hand]) && + ((countLho >= 2) || (lhoTrumpRanks == 0)) && + ((countRho >= 2) || (rhoTrumpRanks == 0))) + { + unsigned short ranks = 0; + for (int h = 0; h < DDS_HANDS; h++) + ranks |= posPoint->rankInSuit[h][suit]; + + if (thrp->rel[ranks].absRank[3][suit].hand == partner[hand]) + { + posPoint->winRanks[depth][suit] |= + bitMapRank[thrp->rel[ranks].absRank[3][suit].rank]; + + posPoint->winRanks[depth][commSuit] |= bitMapRank[commRank]; + + qt++; + if (qt >= cutoff) + return qt; + if ((countOwn <= 2) && + (countLho <= 2) && + (countRho <= 2) && + (lhoTrumpRanks == 0) && + (rhoTrumpRanks == 0)) + { + qt += countPart - 2; + if (qt >= cutoff) + return qt; + } + } + } + *res = 0; + return qt; +} + + +int QuickTricksPartnerHandNT( + int hand, + struct pos * posPoint, + int cutoff, + int depth, + int countLho, + int countRho, + int countOwn, + int countPart, + int suit, + int qtricks, + int commSuit, + int commRank, + int trump, + int * res, + struct localVarType * thrp) +{ + *res = 1; + int qt = qtricks; + + posPoint->winRanks[depth][suit] |= + bitMapRank[posPoint->winner[suit].rank]; + + posPoint->winRanks[depth][commSuit] |= bitMapRank[commRank]; + + qt++; + if (qt >= cutoff) + return qt; + if ((countLho <= 1) && (countRho <= 1) && (countOwn <= 1)) + { + qt += countPart - 1; + if (qt >= cutoff) + return qt; + *res = 2; + return qt; + } + + if (posPoint->secondBest[suit].hand == partner[hand]) + { + /* Second best found in partners hand */ + posPoint->winRanks[depth][suit] |= + bitMapRank[posPoint->secondBest[suit].rank]; + + qt++; + if (qt >= cutoff) + return qt; + if ((countLho <= 2) && (countRho <= 2) && (countOwn <= 2)) + { + qt += countPart - 2; + if (qt >= cutoff) + return qt; + *res = 2; + return qt; + } + } + else if ((posPoint->secondBest[suit].hand == hand) + && (countPart > 1) && (countOwn > 1)) + { + /* Second best found in own hand and own and + partner's suit length > 1 */ + posPoint->winRanks[depth][suit] |= + bitMapRank[posPoint->secondBest[suit].rank]; + + qt++; + if (qt >= cutoff) + return qt; + if ((countLho <= 2) && + (countRho <= 2) && + ((countOwn <= 2) || (countPart <= 2))) + { + qt += Max(countPart - 2, countOwn - 2); + if (qt >= cutoff) + return qt; + *res = 2; + return qt; + } + } + else if ((suit == commSuit) && + (posPoint->secondBest[suit].hand == lho[hand])) + { + unsigned short ranks = 0; + for (int h = 0; h < DDS_HANDS; h++) + ranks |= posPoint->rankInSuit[h][suit]; + + if (thrp->rel[ranks].absRank[3][suit].hand == partner[hand]) + { + posPoint->winRanks[depth][suit] |= + bitMapRank[thrp->rel[ranks].absRank[3][suit].rank]; + qt++; + if (qt >= cutoff) + return qt; + if ((countOwn <= 2) && (countLho <= 2) && (countRho <= 2)) + { + qtricks += countPart - 2; + if (qt >= cutoff) + return qt; + } + } + } + *res = 0; + return qt; +} + + +bool QuickTricksSecondHand( + struct pos * posPoint, + int hand, + int depth, + int target, + int trump, + struct localVarType * thrp) +{ + if (depth == thrp->iniDepth) + return false; + + int ss = posPoint->move[depth + 1].suit; + unsigned short (*ris)[DDS_SUITS] = posPoint->rankInSuit; + unsigned short ranks = ris[hand][ss] | ris[partner[hand]][ss]; + + for (int s = 0; s < DDS_SUITS; s++) + posPoint->winRanks[depth][s] = 0; + + if ((trump != DDS_NOTRUMP) && (ss != trump) && + (((ris[hand][ss] == 0) && (ris[hand][trump] != 0)) || + ((ris[partner[hand]][ss] == 0) && + (ris[partner[hand]][trump] != 0)))) + { + if ((ris[lho[hand]][ss] == 0) && + (ris[lho[hand]][trump] != 0)) + return false; + + /* Own side can ruff, their side can't. */ + } + + else if (ranks > (bitMapRank[posPoint->move[depth + 1].rank] | + ris[lho[hand]][ss])) + { + if ((trump != DDS_NOTRUMP) && (ss != trump) && + (ris[lho[hand]][trump] != 0) && + (ris[lho[hand]][ss] == 0)) + return false; + + /* Own side has highest card in suit, which LHO can't ruff. */ + + int rr = highestRank[ranks]; + posPoint->winRanks[depth][ss] = bitMapRank[rr]; + } + else + { + /* No easy way to win current trick for own side. */ + return false; + } + + int qtricks = 1; + + int cutoff; + if (thrp->nodeTypeStore[hand] == MAXNODE) + cutoff = target - posPoint->tricksMAX; + else + cutoff = posPoint->tricksMAX - target + (depth >> 2) + 3; + + if (qtricks >= cutoff) + return true; + + if (trump != DDS_NOTRUMP) + return false; + + /* In NT, second winner (by rank) in same suit. */ + + int hh; + if (ris[hand][ss] > ris[partner[hand]][ss]) + hh = hand; /* Hand to lead next trick */ + else + hh = partner[hand]; + + if ((posPoint->winner[ss].hand == hh) && + (posPoint->secondBest[ss].rank != 0) && + (posPoint->secondBest[ss].hand == hh)) + { + qtricks++; + posPoint->winRanks[depth][ss] |= + bitMapRank[posPoint->secondBest[ss].rank]; + + if (qtricks >= cutoff) + return true; + } + + for (int s = 0; s < DDS_SUITS; s++) + { + if ((s == ss) || (posPoint->length[hh][s] == 0)) + continue; + + if ((posPoint->length[lho[hh]][s] == 0) && + (posPoint->length[rho[hh]][s] == 0) && + (posPoint->length[partner[hh]][s] == 0)) + { + /* Long other suit which nobody else holds. */ + qtricks += counttable[ris[hh][s]]; + if (qtricks >= cutoff) + return true; + } + else if ((posPoint->winner[s].rank != 0) && + (posPoint->winner[s].hand == hh)) + { + /* Top winners in other suits. */ + qtricks++; + posPoint->winRanks[depth][s] |= + bitMapRank[posPoint->winner[s].rank]; + + if (qtricks >= cutoff) + return true; + } + } + + return false; +} + diff --git a/QuickTricks.h b/QuickTricks.h new file mode 100644 index 00000000..7b5894a9 --- /dev/null +++ b/QuickTricks.h @@ -0,0 +1,17 @@ +int QuickTricks( + struct pos * posPoint, + int hand, + int depth, + int target, + int trump, + bool * result, + struct localVarType * thrp); + +bool QuickTricksSecondHand( + struct pos * posPoint, + int hand, + int depth, + int target, + int trump, + struct localVarType * thrp); + diff --git a/SolveBoard.cpp b/SolveBoard.cpp new file mode 100644 index 00000000..a6a2b2a7 --- /dev/null +++ b/SolveBoard.cpp @@ -0,0 +1,326 @@ +/* + DDS 2.7.0 A bridge double dummy solver. + Copyright (C) 2006-2014 by Bo Haglund + Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. + The code for calculation of par score / contracts is based upon the + perl code written by Matthew Kidd for ACBLmerge. He has kindly given + permission to include a C++ adaptation in DDS. + + The PlayAnalyser analyses the played cards of the deal and presents + their double dummy values. The par calculation function DealerPar + provides an alternative way of calculating and presenting par + results. Both these functions have been written by Soren Hein. + He has also made numerous contributions to the code, especially in + the initialization part. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + + +#include "dds.h" +#include "PBN.h" + +extern int noOfThreads; + +#if (defined(_WIN32) || defined(__CYGWIN__)) && \ + !defined(_OPENMP) && !defined(DDS_THREADS_SINGLE) +HANDLE solveAllEvents[MAXNOOFTHREADS]; +struct paramType param; +LONG volatile threadIndex; +LONG volatile current; + +long chunk; + +DWORD CALLBACK SolveChunk (void *) { + struct futureTricks fut[MAXNOOFBOARDS]; + int thid; + long j; + + thid=InterlockedIncrement(&threadIndex); + + while ((j=(InterlockedIncrement(¤t)-1))deals[j], param.bop->target[j], + param.bop->solutions[j], param.bop->mode[j], &fut[j], thid); + if (res==1) { + param.solvedp->solvedBoard[j]=fut[j]; + /*param.error=0;*/ + } + else { + param.error=res; + } + } + + if (SetEvent(solveAllEvents[thid])==0) { + /*int errCode=GetLastError();*/ + return 0; + } + + return 1; + +} + + +DWORD CALLBACK SolveChunkDDtable (void *) { + struct futureTricks fut[MAXNOOFBOARDS]; + int thid; + long j; + + thid=InterlockedIncrement(&threadIndex); + + while ((j=InterlockedExchangeAdd(¤t, chunk))deals[j+k], param.bop->target[j+k], + param.bop->solutions[j+k], param.bop->mode[j+k], + &fut[j+k], thid); + if (res==1) { + param.solvedp->solvedBoard[j+k]=fut[j+k]; + /*param.error=0;*/ + } + else { + param.error=res; + } + } + } + + if (SetEvent(solveAllEvents[thid])==0) { + /*int errCode=GetLastError();*/ + return 0; + } + + return 1; + +} + + +int SolveAllBoardsN(struct boards *bop, struct solvedBoards *solvedp, int chunkSize) { + int k/*, errCode*/; + DWORD res; + DWORD solveAllWaitResult; + + current = 0; + threadIndex = -1; + chunk = chunkSize; + param.error = 0; + + if (bop->noOfBoards > MAXNOOFBOARDS) + return RETURN_TOO_MANY_BOARDS; + + for (k = 0; knoOfBoards; + + for (k = 0; ksolvedBoard[k].cards = 0; + + if (chunkSize != 1) { + for (k = 0; knoOfBoards = 0; + for (k = 0; ksolvedBoard[k].cards != 0) + solvedp->noOfBoards++; + } + + if (param.error == 0) + return 1; + else + return param.error; +} + +#else + +int SolveAllBoardsN(struct boards *bop, struct solvedBoards *solvedp, int chunkSize) { + int k, i, res, chunk, fail; + struct futureTricks fut[MAXNOOFBOARDS]; + + chunk=chunkSize; fail=1; + + if (bop->noOfBoards > MAXNOOFBOARDS) + return RETURN_TOO_MANY_BOARDS; + + for (i=0; isolvedBoard[i].cards=0; + +#if defined (_OPENMP) && !defined(DDS_THREADS_SINGLE) + if (omp_get_dynamic()) + omp_set_dynamic(0); + omp_set_num_threads(noOfThreads); /* Added after suggestion by Dirk Willecke. */ +#elif defined (_OPENMP) + omp_set_num_threads(1); +#endif + + #pragma omp parallel shared(bop, solvedp, chunk, fail) private(k) + { + + #pragma omp for schedule(dynamic, chunk) + + for (k=0; knoOfBoards; k++) { + res=SolveBoard(bop->deals[k], bop->target[k], bop->solutions[k], + bop->mode[k], &fut[k], + +#if defined (_OPENMP) && !defined(DDS_THREADS_SINGLE) + omp_get_thread_num() +#else + 0 +#endif + ); + if (res==1) { + solvedp->solvedBoard[k]=fut[k]; + } + else + fail=res; + } + } + + if (fail!=1) + return fail; + + solvedp->noOfBoards=0; + for (i=0; isolvedBoard[i].cards!=0) + solvedp->noOfBoards++; + } + + return 1; +} + +#endif + + +int STDCALL SolveBoardPBN(struct dealPBN dlpbn, int target, + int solutions, int mode, struct futureTricks *futp, int threadIndex) { + + int res, k; + struct deal dl; + + if (ConvertFromPBN(dlpbn.remainCards, dl.remainCards)!=RETURN_NO_FAULT) + return RETURN_PBN_FAULT; + + for (k=0; k<=2; k++) { + dl.currentTrickRank[k]=dlpbn.currentTrickRank[k]; + dl.currentTrickSuit[k]=dlpbn.currentTrickSuit[k]; + } + dl.first=dlpbn.first; + dl.trump=dlpbn.trump; + + res=SolveBoard(dl, target, solutions, mode, futp, threadIndex); + + return res; +} + + +int STDCALL SolveAllBoards(struct boardsPBN *bop, struct solvedBoards *solvedp) { + struct boards bo; + int k, i, res; + + bo.noOfBoards=bop->noOfBoards; + for (k=0; knoOfBoards; k++) { + bo.mode[k]=bop->mode[k]; + bo.solutions[k]=bop->solutions[k]; + bo.target[k]=bop->target[k]; + bo.deals[k].first=bop->deals[k].first; + bo.deals[k].trump=bop->deals[k].trump; + for (i=0; i<=2; i++) { + bo.deals[k].currentTrickSuit[i]=bop->deals[k].currentTrickSuit[i]; + bo.deals[k].currentTrickRank[i]=bop->deals[k].currentTrickRank[i]; + } + if (ConvertFromPBN(bop->deals[k].remainCards, bo.deals[k].remainCards)!=1) + return RETURN_PBN_FAULT; + } + + res=SolveAllBoardsN(&bo, solvedp, 1); + + return res; +} + +int STDCALL SolveAllChunksPBN(struct boardsPBN *bop, struct solvedBoards *solvedp, int chunkSize) { + struct boards bo; + int k, i, res; + + if (chunkSize < 1) + return RETURN_CHUNK_SIZE; + + bo.noOfBoards = bop->noOfBoards; + for (k = 0; knoOfBoards; k++) { + bo.mode[k] = bop->mode[k]; + bo.solutions[k] = bop->solutions[k]; + bo.target[k] = bop->target[k]; + bo.deals[k].first = bop->deals[k].first; + bo.deals[k].trump = bop->deals[k].trump; + for (i = 0; i <= 2; i++) { + bo.deals[k].currentTrickSuit[i] = bop->deals[k].currentTrickSuit[i]; + bo.deals[k].currentTrickRank[i] = bop->deals[k].currentTrickRank[i]; + } + if (ConvertFromPBN(bop->deals[k].remainCards, bo.deals[k].remainCards) != 1) + return RETURN_PBN_FAULT; + } + + res = SolveAllBoardsN(&bo, solvedp, chunkSize); + return res; +} + + +int STDCALL SolveAllChunks(struct boardsPBN *bop, struct solvedBoards *solvedp, int chunkSize) { + + int res = SolveAllChunksPBN(bop, solvedp, chunkSize); + + return res; +} + + +int STDCALL SolveAllChunksBin(struct boards *bop, struct solvedBoards *solvedp, int chunkSize) { + int res; + + if (chunkSize < 1) + return RETURN_CHUNK_SIZE; + + res = SolveAllBoardsN(bop, solvedp, chunkSize); + return res; +} + + diff --git a/SolveBoard.h b/SolveBoard.h new file mode 100644 index 00000000..5f55e7aa --- /dev/null +++ b/SolveBoard.h @@ -0,0 +1,6 @@ +int SolveAllBoardsN( +struct boards * bop, + struct solvedBoards * solvedp, + int chunkSize); + + diff --git a/SolverIF.cpp b/SolverIF.cpp new file mode 100644 index 00000000..86112551 --- /dev/null +++ b/SolverIF.cpp @@ -0,0 +1,1122 @@ +/* + DDS 2.7.0 A bridge double dummy solver. + Copyright (C) 2006-2014 by Bo Haglund + Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. + The code for calculation of par score / contracts is based upon the + perl code written by Matthew Kidd for ACBLmerge. He has kindly given + permission to include a C++ adaptation in DDS. + + The PlayAnalyser analyses the played cards of the deal and presents + their double dummy values. The par calculation function DealerPar + provides an alternative way of calculating and presenting par + results. Both these functions have been written by Soren Hein. + He has also made numerous contributions to the code, especially in + the initialization part. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + + +#include "dds.h" +#include "Init.h" +#include "Moves.h" +#include "ABsearch.h" + + +int CheckDeal( + struct gameInfo * gamep); + +int DumpInput( + int errCode, + struct deal dl, + int target, + int solutions, + int mode); + +void PrintDeal( + FILE * fp, + unsigned short ranks[][DDS_SUITS]); + +int InvBitMapRank( + unsigned short bitMap); + + +extern int noOfThreads; /* The number of entries to the transposition tables. There is + one entry per thread. */ + + + +bool (* AB_ptr_list[DDS_HANDS])( + struct pos * posPoint, + int target, + int depth, + struct localVarType * thrp) + = { ABsearch, ABsearch1, ABsearch2, ABsearch3 }; + + +int STDCALL SolveBoard( + struct deal dl, + int target, + int solutions, + int mode, + struct futureTricks * futp, + int thrId) +{ + int noStartMoves, noMoves, cardCount, totalTricks, handRelFirst; + int noOfCardsPerHand[DDS_HANDS]; + int latestTrickSuit[DDS_HANDS]; + int latestTrickRank[DDS_HANDS]; + int maxHand = 0, maxSuit = 0, maxRank; + int first, last; + struct movePlyType temp; + struct moveType mv; + struct localVarType * thrp = &localVar[thrId]; + +// printf("SolveBoard\n"); +// fflush(stdout); + + if ((thrId < 0) || (thrId >= noOfThreads)) + /* Fault corrected after suggestion by Dirk Willecke. */ + { + DumpInput(RETURN_THREAD_INDEX, dl, target, solutions, mode); + return RETURN_THREAD_INDEX; + } + + for (int k = 0; k <= 13; k++) + { + thrp->forbiddenMoves[k].rank = 0; + thrp->forbiddenMoves[k].suit = 0; + } + + if (target < -1) + { + DumpInput(RETURN_TARGET_WRONG_LO, dl, target, solutions, mode); + return RETURN_TARGET_WRONG_LO; + } + + if (target > 13) + { + DumpInput(RETURN_TARGET_WRONG_HI, dl, target, solutions, mode); + return RETURN_TARGET_WRONG_HI; + } + + if (solutions < 1) + { + DumpInput(RETURN_SOLNS_WRONG_LO, dl, target, solutions, mode); + return RETURN_SOLNS_WRONG_LO; + } + + if (solutions > 3) + { + DumpInput(RETURN_SOLNS_WRONG_HI, dl, target, solutions, mode); + return RETURN_SOLNS_WRONG_HI; + } + + for (int k = 0; k < DDS_HANDS; k++) + noOfCardsPerHand[handId(dl.first, k)] = 0; + + for (int k = 0; k <= 2; k++) + { + if (dl.currentTrickRank[k] != 0) + { + noOfCardsPerHand[handId(dl.first, k)] = 1; + unsigned short int aggrRemain = 0; + for (int h = 0; h < DDS_HANDS; h++) + aggrRemain |= (dl.remainCards[h][dl.currentTrickSuit[k]] >> 2); + if ((aggrRemain & bitMapRank[dl.currentTrickRank[k]]) != 0) + { + DumpInput(RETURN_PLAYED_CARD, dl, target, solutions, mode); + return RETURN_PLAYED_CARD; + } + } + } + + if (target == -1) + thrp->tricksTarget = 99; + else + thrp->tricksTarget = target; + + thrp->newDeal = false; + thrp->newTrump = false; + thrp->diffDeal = 0; + thrp->aggDeal = 0; + cardCount = 0; + + for (int h = 0; h < DDS_HANDS; h++) + { + for (int s = 0; s < DDS_SUITS; s++) + { + int c = dl.remainCards[h][s] >> 2; + + cardCount += counttable[c]; + thrp->diffDeal += (c ^ (thrp->game.suit[h][s])); + thrp->aggDeal += c; + + if (thrp->game.suit[h][s] != c) + { + thrp->game.suit[h][s] = c; + thrp->newDeal = true; + } + } + } + + if (thrp->newDeal) + { + if (thrp->diffDeal == 0) + thrp->similarDeal = true; + else if ((thrp->aggDeal / thrp->diffDeal) > SIMILARDEALLIMIT) + thrp->similarDeal = true; + else + thrp->similarDeal = false; + } + else + thrp->similarDeal = false; + + if (dl.trump != thrp->trump) + thrp->newTrump = true; + + for (int h = 0; h < DDS_HANDS; h++) + for (int s = 0; s < DDS_SUITS; s++) + noOfCardsPerHand[h] += counttable[thrp->game.suit[h][s]]; + + for (int h = 1; h < DDS_HANDS; h++) + { + if (noOfCardsPerHand[h] != noOfCardsPerHand[0]) + { + DumpInput(RETURN_CARD_COUNT, dl, target, solutions, mode); + return RETURN_CARD_COUNT; + } + } + + if (dl.currentTrickRank[2]) + { + if ((dl.currentTrickRank[2] < 2) || + (dl.currentTrickRank[2] > 14) || + (dl.currentTrickSuit[2] < 0) || + (dl.currentTrickSuit[2] > 3)) + { + DumpInput(RETURN_SUIT_OR_RANK, dl, target, solutions, mode); + return RETURN_SUIT_OR_RANK; + } + + thrp->handToPlay = handId(dl.first, 3); + handRelFirst = 3; + noStartMoves = 3; + + if (cardCount <= 4) + { + int htp = thrp->handToPlay; + for (int s = 0; s < DDS_SUITS; s++) + { + if (thrp->game.suit[htp][s] != 0) + { + latestTrickSuit[htp] = s; + latestTrickRank[htp] = InvBitMapRank(thrp->game.suit[htp][s]); + break; + } + } + latestTrickSuit[handId(dl.first, 2)] = dl.currentTrickSuit[2]; + latestTrickRank[handId(dl.first, 2)] = dl.currentTrickRank[2]; + latestTrickSuit[handId(dl.first, 1)] = dl.currentTrickSuit[1]; + latestTrickRank[handId(dl.first, 1)] = dl.currentTrickRank[1]; + latestTrickSuit[dl.first] = dl.currentTrickSuit[0]; + latestTrickRank[dl.first] = dl.currentTrickRank[0]; + } + } + else if (dl.currentTrickRank[1]) + { + if ((dl.currentTrickRank[1] < 2) || + (dl.currentTrickRank[1] > 14) || + (dl.currentTrickSuit[1] < 0) || + (dl.currentTrickSuit[1] > 3)) + { + DumpInput(RETURN_SUIT_OR_RANK, dl, target, solutions, mode); + return RETURN_SUIT_OR_RANK; + } + + thrp->handToPlay = handId(dl.first, 2); + handRelFirst = 2; + noStartMoves = 2; + + if (cardCount <= 4) + { + int htp = thrp->handToPlay; + for (int s = 0; s < DDS_SUITS; s++) + { + if (thrp->game.suit[htp][s] != 0) + { + latestTrickSuit[htp] = s; + latestTrickRank[htp] = InvBitMapRank(thrp->game.suit[htp][s]); + break; + } + } + + for (int s = 0; s < DDS_SUITS; s++) + { + if (thrp->game.suit[handId(dl.first, 3)][s] != 0) + { + latestTrickSuit[handId(dl.first, 3)] = s; + latestTrickRank[handId(dl.first, 3)] = + InvBitMapRank(thrp->game.suit[handId(dl.first, 3)][s]); + break; + } + } + + latestTrickSuit[handId(dl.first, 1)] = dl.currentTrickSuit[1]; + latestTrickRank[handId(dl.first, 1)] = dl.currentTrickRank[1]; + latestTrickSuit[dl.first] = dl.currentTrickSuit[0]; + latestTrickRank[dl.first] = dl.currentTrickRank[0]; + } + } + else if (dl.currentTrickRank[0]) + { + if ((dl.currentTrickRank[0] < 2) || + (dl.currentTrickRank[0] > 14) || + (dl.currentTrickSuit[0] < 0) || + (dl.currentTrickSuit[0] > 3)) + { + DumpInput(RETURN_SUIT_OR_RANK, dl, target, solutions, mode); + return RETURN_SUIT_OR_RANK; + } + + thrp->handToPlay = handId(dl.first, 1); + handRelFirst = 1; + noStartMoves = 1; + if (cardCount <= 4) + { + for (int s = 0; s < DDS_SUITS; s++) + { + int htp = thrp->handToPlay; + if (thrp->game.suit[htp][s] != 0) + { + latestTrickSuit[htp] = s; + latestTrickRank[htp] = InvBitMapRank(thrp->game.suit[htp][s]); + break; + } + } + + for (int s = 0; s < DDS_SUITS; s++) + { + if (thrp->game.suit[handId(dl.first, 3)][s] != 0) + { + latestTrickSuit[handId(dl.first, 3)] = s; + latestTrickRank[handId(dl.first, 3)] = + InvBitMapRank(thrp->game.suit[handId(dl.first, 3)][s]); + break; + } + } + + for (int s = 0; s < DDS_SUITS; s++) + { + if (thrp->game.suit[handId(dl.first, 2)][s] != 0) + { + latestTrickSuit[handId(dl.first, 2)] = s; + latestTrickRank[handId(dl.first, 2)] = + InvBitMapRank(thrp->game.suit[handId(dl.first, 2)][s]); + break; + } + } + + latestTrickSuit[dl.first] = dl.currentTrickSuit[0]; + latestTrickRank[dl.first] = dl.currentTrickRank[0]; + } + } + else + { + thrp->handToPlay = dl.first; + handRelFirst = 0; + noStartMoves = 0; + if (cardCount <= 4) + { + for (int s = 0; s < DDS_SUITS; s++) + { + int htp = thrp->handToPlay; + if (thrp->game.suit[htp][s] != 0) + { + latestTrickSuit[htp] = s; + latestTrickRank[htp] = InvBitMapRank(thrp->game.suit[htp][s]); + break; + } + } + + for (int s = 0; s < DDS_SUITS; s++) + { + if (thrp->game.suit[handId(dl.first, 3)][s] != 0) + { + latestTrickSuit[handId(dl.first, 3)] = s; + latestTrickRank[handId(dl.first, 3)] = + InvBitMapRank(thrp->game.suit[handId(dl.first, 3)][s]); + break; + } + } + + for (int s = 0; s < DDS_SUITS; s++) + { + if (thrp->game.suit[handId(dl.first, 2)][s] != 0) + { + latestTrickSuit[handId(dl.first, 2)] = s; + latestTrickRank[handId(dl.first, 2)] = + InvBitMapRank(thrp->game.suit[handId(dl.first, 2)][s]); + break; + } + } + + for (int s = 0; s < DDS_SUITS; s++) + { + if (thrp->game.suit[handId(dl.first, 1)][s] != 0) + { + latestTrickSuit[handId(dl.first, 1)] = s; + latestTrickRank[handId(dl.first, 1)] = + InvBitMapRank(thrp->game.suit[handId(dl.first, 1)][s]); + break; + } + } + } + } + + thrp->trump = dl.trump; + thrp->game.first = dl.first; + first = dl.first; + thrp->game.noOfCards = cardCount; + if (dl.currentTrickRank[0] != 0) + { + thrp->game.leadHand = dl.first; + thrp->game.leadSuit = dl.currentTrickSuit[0]; + thrp->game.leadRank = dl.currentTrickRank[0]; + } + else + { + thrp->game.leadHand = 0; + thrp->game.leadSuit = 0; + thrp->game.leadRank = 0; + } + + for (int k = 0; k <= 2; k++) + { + thrp->initialMoves[k].suit = 255; + thrp->initialMoves[k].rank = 255; + } + + for (int k = 0; k < noStartMoves; k++) + { + thrp->initialMoves[noStartMoves - 1 - k].suit = + dl.currentTrickSuit[k]; + thrp->initialMoves[noStartMoves - 1 - k].rank = + dl.currentTrickRank[k]; + } + + if (cardCount % 4) + totalTricks = ((cardCount - 4) >> 2) + 2; + else + totalTricks = ((cardCount - 4) >> 2) + 1; + + if (thrp->game.noOfCards <= 0) + { + DumpInput(RETURN_ZERO_CARDS, dl, target, solutions, mode); + return RETURN_ZERO_CARDS; + } + + if (thrp->game.noOfCards > 52) + { + DumpInput(RETURN_TOO_MANY_CARDS, dl, target, solutions, mode); + return RETURN_TOO_MANY_CARDS; + } + + if (totalTricks < target) + { + DumpInput(RETURN_TARGET_TOO_HIGH, dl, target, solutions, mode); + return RETURN_TARGET_TOO_HIGH; + } + + if (CheckDeal(&thrp->game)) + { + DumpInput(RETURN_DUPLICATE_CARDS, dl, target, solutions, mode); + return RETURN_DUPLICATE_CARDS; + } + + if (cardCount <= 4) + { + maxRank = 0; + /* Highest trump? */ + if (dl.trump != DDS_NOTRUMP) + { + for (int h = 0; h < DDS_HANDS; h++) + { + if ((latestTrickSuit[h] == dl.trump) && + (latestTrickRank[h] > maxRank)) + { + maxRank = latestTrickRank[h]; + maxSuit = dl.trump; + maxHand = h; + } + } + } + + /* Highest card in leading suit */ + if (maxRank == 0) + { + for (int h = 0; h < DDS_HANDS; h++) + { + if (h == dl.first) + { + maxSuit = latestTrickSuit[dl.first]; + maxHand = dl.first; + maxRank = latestTrickRank[dl.first]; + break; + } + } + for (int h = 0; h < DDS_HANDS; h++) + { + if ((h != dl.first) && (latestTrickSuit[h] == maxSuit) && + (latestTrickRank[h] > maxRank)) + { + maxHand = h; + maxRank = latestTrickRank[h]; + } + } + } + futp->nodes = 0; + futp->cards = 1; + futp->suit[0] = latestTrickSuit[thrp->handToPlay]; + futp->rank[0] = latestTrickRank[thrp->handToPlay]; + futp->equals[0] = 0; + + if ((target == 0) && (solutions < 3)) + futp->score[0] = 0; + else if ((thrp->handToPlay == maxHand) || + (partner[thrp->handToPlay] == maxHand)) + futp->score[0] = 1; + else + futp->score[0] = 0; + +#ifdef DDS_MEMORY_LEAKS_WIN32 + _CrtDumpMemoryLeaks(); +#endif + return RETURN_NO_FAULT; + } + + if ((mode != 2) && + (((thrp->newDeal) && (! thrp->similarDeal)) || + thrp->newTrump || + (thrp->nodes > SIMILARMAXWINNODES))) + { + thrp->transTable.ResetMemory(); + + InitGame(0, false, first, handRelFirst, thrId); + } + else + { + InitGame(0, true, first, handRelFirst, thrId); + } + +#ifdef DDS_AB_STATS + thrp->ABstats.ResetCum(); +#endif + +#ifdef DDS_TOP_LEVEL + thrp->nodes = 0; +#endif + + thrp->trickNodes = 0; + thrp->iniDepth = cardCount - 4; + + if (mode == 0) + { + int iniDepth = thrp->iniDepth; + MoveGen(&thrp->lookAheadPos, + thrp->iniDepth, + thrp->trump, + &thrp->movePly[iniDepth], + thrp); + + if (thrp->movePly[iniDepth].last == 0) + { + futp->nodes = 0; + futp->cards = 1; + futp->suit[0] = thrp->movePly[iniDepth].move[0].suit; + futp->rank[0] = thrp->movePly[iniDepth].move[0].rank; + futp->equals[0] = thrp->movePly[iniDepth].move[0].sequence << 2; + futp->score[0] = -2; + +#ifdef DDS_MEMORY_LEAKS_WIN32 + _CrtDumpMemoryLeaks(); +#endif + return RETURN_NO_FAULT; + } + } + if ((target == 0) && (solutions < 3)) + { + MoveGen(&thrp->lookAheadPos, + thrp->iniDepth, + thrp->trump, + &thrp->movePly[thrp->iniDepth], + thrp); + + futp->nodes = 0; + int iniDepth = thrp->iniDepth; + for (int k = 0; k <= thrp->movePly[iniDepth].last; k++) + { + futp->suit[k] = thrp->movePly[iniDepth].move[k].suit; + futp->rank[k] = thrp->movePly[iniDepth].move[k].rank; + futp->equals[k] = thrp->movePly[iniDepth].move[k].sequence << 2; + futp->score[k] = 0; + } + if (solutions == 1) + futp->cards = 1; + else + futp->cards = thrp->movePly[iniDepth].last + 1; + +#ifdef DDS_MEMORY_LEAKS_WIN32 + _CrtDumpMemoryLeaks(); +#endif + return RETURN_NO_FAULT; + } + + if ((target != -1) && (solutions != 3)) + { + int fnc = (48 - thrp->iniDepth) % 4; + TIMER_START(TIMER_AB + thrp->iniDepth); + thrp->val = (* AB_ptr_list[fnc])(&thrp->lookAheadPos, + thrp->tricksTarget, + thrp->iniDepth, + thrp); + TIMER_END(TIMER_AB + thrp->iniDepth); + +#ifdef DDS_TOP_LEVEL + DumpTopLevel(thrp, thrp->tricksTarget, -1, -1, 0); +#endif + + temp = thrp->movePly[thrp->iniDepth]; + last = thrp->movePly[thrp->iniDepth].last; + noMoves = last + 1; + + if (thrp->val) + thrp->payOff = thrp->tricksTarget; + else + thrp->payOff = 0; + futp->cards = 1; + + int n = thrp->game.noOfCards - 4; + if (thrp->payOff <= 0) + { + futp->suit[0] = thrp->movePly[n].move[0].suit; + futp->rank[0] = thrp->movePly[n].move[0].rank; + futp->equals[0] = thrp->movePly[n].move[0].sequence << 2; + + if (thrp->tricksTarget > 1) + futp->score[0] = -1; + else + futp->score[0] = 0; + } + else + { + futp->suit[0] = thrp->bestMove[n].suit; + futp->rank[0] = thrp->bestMove[n].rank; + futp->equals[0] = thrp->bestMove[n].sequence << 2; + futp->score[0] = thrp->payOff; + } + } + else + { + int g = thrp->estTricks[thrp->handToPlay]; + int upperbound = 13; + int lowerbound = 0; + do + { + int tricks; + if (g == lowerbound) + tricks = g + 1; + else + tricks = g; + + assert((thrp->lookAheadPos.handRelFirst >= 0) && + (thrp->lookAheadPos.handRelFirst <= 3)); + + int fnc = (48 - thrp->iniDepth) % 4; + TIMER_START(TIMER_AB + thrp->iniDepth); + thrp->val = (* AB_ptr_list[fnc])(&thrp->lookAheadPos, + tricks, + thrp->iniDepth, + thrp); + TIMER_END(TIMER_AB + thrp->iniDepth); + + if (thrp->val) + mv = thrp->bestMove[thrp->game.noOfCards - 4]; + +#ifdef DDS_TOP_LEVEL + DumpTopLevel(thrp, tricks, lowerbound, upperbound, 1); +#endif + + if (! thrp->val) + { + upperbound = tricks - 1; + g = upperbound; + } + else + { + lowerbound = tricks; + g = lowerbound; + } + + InitSearch(&thrp->iniPosition, + thrp->game.noOfCards - 4, + thrp->initialMoves, + first, + true, + thrId); + } + while (lowerbound < upperbound); + + thrp->payOff = g; + temp = thrp->movePly[thrp->iniDepth]; + last = thrp->movePly[thrp->iniDepth].last; + noMoves = last + 1; + + int n = thrp->game.noOfCards - 4; + + thrp->bestMove[n] = mv; + futp->cards = 1; + + if (thrp->payOff <= 0) + { + futp->score[0] = 0; + futp->suit[0] = thrp->movePly[n].move[0].suit; + futp->rank[0] = thrp->movePly[n].move[0].rank; + futp->equals[0] = thrp->movePly[n].move[0].sequence << 2; + } + else + { + futp->score[0] = thrp->payOff; + futp->suit[0] = thrp->bestMove[n].suit; + futp->rank[0] = thrp->bestMove[n].rank; + futp->equals[0] = thrp->bestMove[n].sequence << 2; + } + thrp->tricksTarget = thrp->payOff; + } + + if ((solutions == 2) && (thrp->payOff > 0)) + { + int forb = 1; + int ind = forb; + + while ((thrp->payOff == thrp->tricksTarget) && + (ind < (temp.last + 1))) + { + int n = thrp->game.noOfCards - 4; + thrp->forbiddenMoves[forb].suit = thrp->bestMove[n].suit; + thrp->forbiddenMoves[forb].rank = thrp->bestMove[n].rank; + forb++; + ind++; + + /* All moves before bestMove in the move list shall be + moved to the forbidden moves list, since none of them reached + the target */ + int iniDepth = thrp->iniDepth; + int k; + for (k = 0; k <= thrp->movePly[iniDepth].last; k++) + { + if ((thrp->bestMove[iniDepth].suit == + thrp->movePly[iniDepth].move[k].suit) && + (thrp->bestMove[iniDepth].rank == + thrp->movePly[iniDepth].move[k].rank)) + break; + } + + for (int i = 0; i < k; i++) /* All moves until best move */ + { + bool flag = false; + for (int j = 0; j < forb; j++) + { + if ((thrp->movePly[iniDepth].move[i].suit == + thrp->forbiddenMoves[j].suit) && + (thrp->movePly[iniDepth].move[i].rank == + thrp->forbiddenMoves[j].rank)) + { + /* If the move is already in the forbidden list */ + flag = true; + break; + } + } + + if (! flag) + { + thrp->forbiddenMoves[forb] = thrp->movePly[iniDepth].move[i]; + forb++; + } + } + + InitSearch(&thrp->iniPosition, + n, + thrp->initialMoves, + first, + true, + thrId); + + int fnc = (48 - thrp->iniDepth) % 4; + TIMER_START(TIMER_AB + thrp->iniDepth); + thrp->val = (* AB_ptr_list[fnc])(&thrp->lookAheadPos, + thrp->tricksTarget, + thrp->iniDepth, + thrp); + TIMER_END(TIMER_AB + thrp->iniDepth); + +#ifdef DDS_TOP_LEVEL + DumpTopLevel(thrp, thrp->tricksTarget, -1, -1, 2); +#endif + + if (thrp->val) + { + int n = thrp->game.noOfCards - 4; + thrp->payOff = thrp->tricksTarget; + + futp->cards = ind; + futp->suit[ind - 1] = thrp->bestMove[n].suit; + futp->rank[ind - 1] = thrp->bestMove[n].rank; + futp->equals[ind - 1] = thrp->bestMove[n].sequence << 2; + futp->score[ind - 1] = thrp->payOff; + } + else + thrp->payOff = 0; + } + } + else if ((solutions == 2) && + (thrp->payOff == 0) && + ((target == -1) || (thrp->tricksTarget == 1))) + { + futp->cards = noMoves; + /* Find the cards that were in the initial move list + but have not been listed in the current result */ + int n = 0; + for (int i = 0; i < noMoves; i++) + { + bool found = false; + if ((temp.move[i].suit == futp->suit[0]) && + (temp.move[i].rank == futp->rank[0])) + { + found = true; + } + if (! found) + { + futp->suit[1 + n] = temp.move[i].suit; + futp->rank[1 + n] = temp.move[i].rank; + futp->equals[1 + n] = temp.move[i].sequence << 2; + futp->score[1 + n] = 0; + n++; + } + } + } + + if ((solutions == 3) && (thrp->payOff > 0)) + { + int forb = 1; + int ind = forb; + for (int i = 0; i < last; i++) + { + int n = thrp->game.noOfCards - 4; + thrp->forbiddenMoves[forb].suit = thrp->bestMove[n].suit; + thrp->forbiddenMoves[forb].rank = thrp->bestMove[n].rank; + forb++; + ind++; + + int g = thrp->payOff; + int upperbound = g; + int lowerbound = 0; + + InitSearch(&thrp->iniPosition, + n, + thrp->initialMoves, + first, + true, + thrId); + + do + { + int tricks; + if (g == lowerbound) + tricks = g + 1; + else + tricks = g; + + assert((thrp->lookAheadPos.handRelFirst >= 0) && + (thrp->lookAheadPos.handRelFirst <= 3)); + + int fnc = (48 - thrp->iniDepth) % 4; + TIMER_START(TIMER_AB + thrp->iniDepth); + thrp->val = (* AB_ptr_list[fnc])(&thrp->lookAheadPos, + tricks, + thrp->iniDepth, + thrp); + TIMER_END(TIMER_AB + thrp->iniDepth); + + if (thrp->val) + mv = thrp->bestMove[thrp->game.noOfCards - 4]; + +#ifdef DDS_TOP_LEVEL + DumpTopLevel(thrp, tricks, lowerbound, upperbound, 1); +#endif + + if (! thrp->val) + { + upperbound = tricks - 1; + g = upperbound; + } + else + { + lowerbound = tricks; + g = lowerbound; + } + + InitSearch(&thrp->iniPosition, + thrp->game.noOfCards - 4, + thrp->initialMoves, + first, + true, + thrId); + } + while (lowerbound < upperbound); + + thrp->payOff = g; + if (thrp->payOff == 0) + { + int n = thrp->game.noOfCards - 4; + int iniDepth = thrp->iniDepth; + last = thrp->movePly[iniDepth].last; + futp->cards = temp.last + 1; + + for (int j = 0; j <= last; j++) + { + futp->suit[ind-1+j] = thrp->movePly[n].move[j].suit; + futp->rank[ind-1+j] = thrp->movePly[n].move[j].rank; + futp->equals[ind-1+j] = thrp->movePly[n].move[j].sequence << 2; + futp->score[ind-1+j] = thrp->payOff; + } + break; + } + else + { + thrp->bestMove[thrp->game.noOfCards - 4] = mv; + + futp->cards = ind; + futp->suit[ind - 1] = mv.suit; + futp->rank[ind - 1] = mv.rank; + futp->equals[ind - 1] = mv.sequence << 2; + futp->score[ind - 1] = thrp->payOff; + } + } + } + else if ((solutions == 3) && (thrp->payOff == 0)) + { + futp->cards = noMoves; + /* Find the cards that were in the initial move list + but have not been listed in the current result */ + int n = 0; + for (int i = 0; i < noMoves; i++) + { + bool found = false; + if ((temp.move[i].suit == futp->suit[0]) && + (temp.move[i].rank == futp->rank[0])) + { + found = true; + } + + if (! found) + { + futp->suit[1 + n] = temp.move[i].suit; + futp->rank[1 + n] = temp.move[i].rank; + futp->equals[1 + n] = temp.move[i].sequence << 2; + futp->score[1 + n] = 0; + n++; + } + } + } + + for (int k = 0; k <= 13; k++) + { + thrp->forbiddenMoves[k].suit = 0; + thrp->forbiddenMoves[k].rank = 0; + } + + futp->nodes = thrp->trickNodes; + + // printf("%8d\n", tmp_cnt, thrp->transTable.BlocksInUse()); + // thrp->memUsed = thrp->transTable.MemoryInUse() + + // ThreadMemoryUsed(); + +#ifdef DDS_TIMING + thrp->timer.PrintStats(); +#endif + +#ifdef DDS_TT_STATS + // thrp->transTable.PrintAllSuits(); + // thrp->transTable.PrintEntries(10, 0); + thrp->transTable.PrintSummarySuitStats(); + thrp->transTable.PrintSummaryEntryStats(); + // thrp->transTable.PrintPageSummary(); +#endif + +#ifdef DDS_MEMORY_LEAKS_WIN32 + _CrtDumpMemoryLeaks(); +#endif + return RETURN_NO_FAULT; +} + + + +int InvBitMapRank(unsigned short bitMap) { + + switch (bitMap) { + case 0x1000: return 14; + case 0x0800: return 13; + case 0x0400: return 12; + case 0x0200: return 11; + case 0x0100: return 10; + case 0x0080: return 9; + case 0x0040: return 8; + case 0x0020: return 7; + case 0x0010: return 6; + case 0x0008: return 5; + case 0x0004: return 4; + case 0x0002: return 3; + case 0x0001: return 2; + default: return 0; + } +} + + +int CheckDeal(struct gameInfo *gamep) { + int h, s, k; + bool found; + unsigned short int temp[DDS_HANDS][DDS_SUITS]; + + for (h=0; hsuit[h][s]; + + /* Check that all ranks appear only once within the same suit. */ + for (s=0; s>2; + } + fprintf(fp, "\n"); + fprintf(fp, "target=%d\n", target); + fprintf(fp, "solutions=%d\n", solutions); + fprintf(fp, "mode=%d\n", mode); + fprintf(fp, "\n"); + PrintDeal(fp, ranks); + fclose(fp); + return 0; +} + + +void PrintDeal(FILE *fp, unsigned short ranks[][4]) { + int i, count, trickCount=0, s, r; + bool ec[4]; + for (i=0; i<=3; i++) { + count=counttable[ranks[3][i]]; + if (count>5) + ec[i]=true; + else + ec[i]=false; + trickCount=trickCount+count; + } + fprintf(fp, "\n"); + for (s=0; s=2; r--) + if ((ranks[0][s] & bitMapRank[r])!=0) + fprintf(fp, "%c", cardRank[r]); + } + fprintf(fp, "\n"); + } + for (s=0; s=2; r--) + if ((ranks[3][s] & bitMapRank[r])!=0) + fprintf(fp, "%c", cardRank[r]); + } + if (ec[s]) + fprintf(fp, "\t%c ", cardSuit[s]); + else + fprintf(fp, "\t\t%c ", cardSuit[s]); + if (!ranks[1][s]) + fprintf(fp, "--"); + else { + for (r=14; r>=2; r--) + if ((ranks[1][s] & bitMapRank[r])!=0) + fprintf(fp, "%c", cardRank[r]); + } + fprintf(fp, "\n"); + } + for (s=0; s=2; r--) + if ((ranks[2][s] & bitMapRank[r])!=0) + fprintf(fp, "%c", cardRank[r]); + } + fprintf(fp, "\n"); + } + fprintf(fp, "\n"); + return; +} + diff --git a/Stats.cpp b/Stats.cpp new file mode 100644 index 00000000..e2a4b2ef --- /dev/null +++ b/Stats.cpp @@ -0,0 +1,248 @@ +/* + DDS 2.7.0 A bridge double dummy solver. + Copyright (C) 2006-2014 by Bo Haglund + Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. + The code for calculation of par score / contracts is based upon the + perl code written by Matthew Kidd for ACBLmerge. He has kindly given + permission to include a C++ adaptation in DDS. + + The PlayAnalyser analyses the played cards of the deal and presents + their double dummy values. The par calculation function DealerPar + provides an alternative way of calculating and presenting par + results. Both these functions have been written by Soren Hein. + He has also made numerous contributions to the code, especially in + the initialization part. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + + +#include "dds.h" +#include "Stats.h" + +#define NUM_TIMERS 2000 +#define COUNTER_SLOTS 200 + +#include + +#ifdef _WIN32 +LARGE_INTEGER timerFreq, + timerUser0, + timerUser1, + timerListUser0[NUM_TIMERS], + timerListUser1[NUM_TIMERS]; +#else +#include +int timevalDiff(timeval x, timeval y); + +timeval timerUser0, + timerUser1, + timerListUser0[NUM_TIMERS], + timerListUser1[NUM_TIMERS]; +#endif + +clock_t timerSys0, + timerSys1, + timerListSys0[NUM_TIMERS], + timerListSys1[NUM_TIMERS]; + +int timerCount, + timerListCount[NUM_TIMERS]; + +int timerNameSet; + +char timerName[80]; + +int timerUserCum, + timerSysCum, + timerListUserCum[NUM_TIMERS], + timerListSysCum[NUM_TIMERS]; + + +void InitTimer() +{ + timerCount = 0; + timerUserCum = 0; + timerSysCum = 0; + timerNameSet = 0; +} + + +void SetTimerName(char * name) +{ + strcpy(timerName, name); + timerNameSet = 1; +} + + +void StartTimer() +{ + timerCount++; + timerSys0 = clock(); + +#ifdef _WIN32 + QueryPerformanceCounter(&timerUser0); +#else + gettimeofday(&timerUser0, NULL); +#endif +} + + +void EndTimer() +{ + timerSys1 = clock(); + +#ifdef _WIN32 + // To get "real" seconds we would have to divide by + // timerFreq.QuadPart which needs to be initialized. + QueryPerformanceCounter(&timerUser1); + int timeUser = (timerUser1.QuadPart - timerUser0.QuadPart); +#else + gettimeofday(&timerUser1, NULL); + int timeUser = timevalDiff(timerUser1, timerUser0); +#endif + + timerUserCum += timeUser; + + timerSysCum += (int) (1000 * (timerSys1-timerSys0) / + (double) CLOCKS_PER_SEC); +} + + +void PrintTimer() +{ + if (timerNameSet) + printf("%-18s : %s\n", "Timer name", timerName); + + printf("%-18s : %10d\n", "Number of calls", timerCount); + if (timerCount == 0) return; + + if (timerUserCum == 0) + printf("%-18s : %s\n", "User time", "zero"); + else + { + printf("%-18s : %10d\n", "User time/ticks", timerUserCum); + printf("%-18s : %10.2f\n", "User per call", + (float) timerUserCum / timerCount); + } + + if (timerSysCum == 0) + printf("%-18s : %s\n", "Sys time", "zero"); + else + { + printf("%-18s : %10d\n", "Sys time/ticks", timerSysCum); + printf("%-18s : %10.2f\n", "Sys per call", + (float) timerSysCum / timerCount); + printf("%-18s : %10.2f\n", "Ratio", + (float) timerSysCum / timerUserCum); + } + printf("\n"); +} + + +void InitTimerList() +{ + for (int i = 0; i < NUM_TIMERS; i++) + { + timerListCount [i] = 0; + timerListUserCum[i] = 0; + timerListSysCum [i] = 0; + } +} + + +void StartTimerNo(int no) +{ + timerListCount[no]++; + timerListSys0[no] = clock(); + +#ifdef _WIN32 + QueryPerformanceCounter(&timerListUser0[no]); +#else + gettimeofday(&timerListUser0[no], NULL); +#endif +} + + +void EndTimerNo(int no) +{ + timerListSys1[no] = clock(); + +#ifdef _WIN32 + QueryPerformanceCounter(&timerListUser1[no]); + int timeUser = (timerListUser1[no].QuadPart - + timerListUser0[no].QuadPart); +#else + gettimeofday(&timerListUser1[no], NULL); + int timeUser = timevalDiff(timerListUser1[no], + timerListUser0[no]); +#endif + + timerListUserCum[no] += timeUser; + + timerListSysCum[no] += + (int) (1000 * (timerListSys1[no] - timerListSys0[no]) / + (double) CLOCKS_PER_SEC); +} + + +void PrintTimerList() +{ + printf("%5s %10s %10s %8s %10s\n", + "n", "Number", "User ticks", "Avg", "Syst time"); + + for (int no = 0; no < NUM_TIMERS; no++) + { + if (timerListCount[no] == 0) + continue; + + printf("%5d %10d %10d %8.2f %10d\n", + no, + timerListCount[no], + timerListUserCum[no], + timerListUserCum[no] / (double) timerListCount[no], + timerListSysCum[no]); + } + printf("\n"); +} + + +#ifndef _WIN32 +int timevalDiff(timeval x, timeval y) +{ + /* Elapsed time, x-y, in milliseconds */ + return 1000 * (x.tv_sec - y.tv_sec ) + + (x.tv_usec - y.tv_usec) / 1000; +} +#endif + + +long long counter[COUNTER_SLOTS]; + +void InitCounter() +{ + for (int i = 0; i < COUNTER_SLOTS; i++) + counter[i] = 0; +} + + +void PrintCounter() +{ + for (int i = 0; i < COUNTER_SLOTS; i++) + { + if (counter[i]) + printf("%d\t%12ld\n", i, counter[i]); + } + printf("\n"); +} + + diff --git a/Stats.h b/Stats.h new file mode 100644 index 00000000..d797b85b --- /dev/null +++ b/Stats.h @@ -0,0 +1,23 @@ + +void InitTimer(); + +void SetTimerName(char * name); + +void StartTimer(); + +void EndTimer(); + +void PrintTimer(); + +void InitTimerList(); + +void StartTimerNo(int n); + +void EndTimerNo(int n); + +void PrintTimerList(); + +void InitCounter(); + +void PrintCounter(); + diff --git a/Timer.cpp b/Timer.cpp new file mode 100644 index 00000000..af58beb8 --- /dev/null +++ b/Timer.cpp @@ -0,0 +1,720 @@ +/* + DDS 2.7.0 A bridge double dummy solver. + + Copyright (C) 2006-2014 by Bo Haglund + + Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. + + The code for calculation of par score / contracts is based upon the + + perl code written by Matthew Kidd for ACBLmerge. He has kindly given + + me permission to include a C++ adaptation in DDS. +*/ + + + +/* + Licensed under the Apache License, Version 2.0 (the "License"); + + you may not use this file except in compliance with the License. + + You may obtain a copy of the License at + + + http://www.apache.org/licenses/LICENSE-2.0 + + + Unless required by applicable law or agreed to in writing, software + + distributed under the License is distributed on an "AS IS" BASIS, + + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + + implied. See the License for the specific language governing + + permissions and limitations under the License. +*/ + + + +/* +This object, ABstats, was was written by Søren Hein. + + Many thanks for allowing me to include it in DDS. + + See Timer.h for some description. +*/ + + + +#include "dds.h" + +#include "Timer.h" + + + + +const char * TIMER_NAMES[TIMER_GROUPS] = +{ + + "AB", + + "Make", + + "Undo", + + "Evaluate", + + "NextMove", + + "QuickTricks", + + "LaterTricks", + + "MoveGen", + + "Lookup", + + "Build"}; + + + + +Timer::Timer() + +{ + + Timer::Reset(); + +} + + + + +Timer::~Timer() + +{ + + if (fp != stdout) + + fclose(fp); +} + + + + +void Timer::Reset() + +{ + sprintf(fname, ""); + + + for (int i = 0; i < DDS_TIMERS; i++) + + { + + sprintf(name[i], "Timer %4d", i); + + count[i] = 0; + + userCum[i] = 0; + + systCum[i] = 0.; + + } + +} + + + + +void Timer::SetFile(char * fname) + +{ + + if (strlen(fname) > DDS_FNAME_LEN) + + return; + + + strncpy(this->fname, fname, strlen(fname)); + + + fp = fopen(fname, "w"); + + if (!fp) + + fp = stdout; + +} + + + + +void Timer::SetName(int no, char * name) + +{ + + if (no < 0 || no >= DDS_TIMERS) + + return; + + + sprintf(this->name[no], "%s\0", name); + +} + + + + +void Timer::SetNames() + +{ + + char tag[LINE_LEN]; + + + for (int d = 0; d < TIMER_SPACING; d++) + + { + int c = d % 4; + + sprintf(tag, "AB%d %d", c, d); + + Timer::SetName(TIMER_AB + d, tag); + + + for (int n = 1; n < TIMER_GROUPS; n++) + + { + + sprintf(tag, "%s %d", TIMER_NAMES[n], d); + + Timer::SetName(n * TIMER_SPACING + d, tag); + + } + + } + +} + + + +void Timer::Start(int no) + +{ + + if (no < 0 || no >= DDS_TIMERS) + + return; + + + systTimes0[no] = clock(); + + +#ifdef _WIN32 + + QueryPerformanceCounter(&userTimes0[no]); + +#else + + gettimeofday(&userTimes0[no], NULL); + +#endif + +} + + + + +void Timer::End(int no) + +{ + + if (no < 0 || no >= DDS_TIMERS) + + return; + + + systTimes1[no] = clock(); + + +#ifdef _WIN32 + + QueryPerformanceCounter(&userTimes1[no]); + + int timeUser = (userTimes1[no].QuadPart - + userTimes0[no].QuadPart); + +#else + + gettimeofday(&userTimes1[no], NULL); + + int timeUser = Timer::TimevalDiff(userTimes1[no], + userTimes0[no]); + +#endif + + count[no]++; + + + + // This is more or less in milli-seconds except on Windows, + + // where it is in "wall ticks". It is possible to convert + + // to milli-seconds, but the resolution is so poor for fast + + // functions that I leave it in integer form. + + + + userCum[no] += timeUser; + + systCum[no] += systTimes1[no] - systTimes0[no]; + +} + + + + +void Timer::OutputDetails() + +{ + + fprintf(fp, "%-14s %10s %10s %10s %10s %10s\n", + + "Name", + "Number", + "User ticks", + "Avg", + "System", + "Avg ms"); + + + for (int no = 0; no < DDS_TIMERS; no++) + + { + + if (count[no] == 0) + + continue; + + + fprintf(fp, "%-14s %10d %10lld %10.2f %10.0f %10.2f\n", + + name[no], + + count[no], + + userCum[no], + + (double) userCum[no] / (double) count[no], + + 1000. * systCum[no], + + 1000. * (double) systCum[no] / (double) count[no]); + + } + + + fprintf(fp, "\n"); + +} + + + + +void Timer::PrintStats() + +{ + + bool used = false; + + for (int no = 0; no < DDS_TIMERS; no++) + + { + + if (count[no]) + + { + + used = true; + + break; + + } + + } + + + + if (! used) + return; + + + + // Approximate the exclusive times of each function. + + // The ABsearch*() functions are recursively nested, + + // so subtract out the one below. + + // The other ones are subtracted out based on knowledge + + // of the functions. + + + + __int64 AB_userCum[TIMER_SPACING]; + + double AB_systCum[TIMER_SPACING]; + + + AB_userCum[0] = userCum[0]; + + AB_systCum[0] = systCum[0]; + + + __int64 AB_ct = count[0]; + + __int64 AB_ucum = AB_userCum[0]; + + double AB_scum = AB_systCum[0]; + + + + for (int d = 1; d < TIMER_SPACING; d++) + + { + + AB_ct += count[d]; + + + if (userCum[d-1] > userCum[d]) + + { + + AB_userCum[d] = 0; + + AB_systCum[d] = 0; + + continue; + + } + + + + AB_userCum[d] = userCum[d] - userCum[d-1]; + + AB_systCum[d] = systCum[d] - systCum[d-1]; + + + for (int no = 1; no < TIMER_GROUPS; no++) + + { + + int offset = no * TIMER_SPACING; + + AB_userCum[d] -= userCum[offset + d ]; + + AB_systCum[d] -= systCum[offset + d ]; + + } + + + + AB_ucum += AB_userCum[d]; + + AB_scum += AB_systCum[d]; + + } + + + + __int64 all_ucum = AB_ucum; + + double all_scum = AB_scum; + + for (int no = TIMER_SPACING; no < DDS_TIMERS; no++) + + { + + all_ucum += userCum[no]; + + all_scum += systCum[no]; + + } + + + + fprintf(fp, "%-14s %8s %10s %6s %4s %10s %6s %4s\n", + + "Name", + "Count", + "User", + "Avg", + "%", + "Syst", + "Avg", + "%"); + + + + if (AB_ct) + + { + + fprintf(fp, "%-14s %8lld %10lld %6.2f %4.1f %10.0f %6.2f %4.1f\n", + + TIMER_NAMES[0], + + AB_ct, + + AB_ucum, + AB_ucum / (double) AB_ct, + + 100. * AB_ucum / all_ucum, + + 1000. * AB_scum, + + 1000. * AB_scum / (double) AB_ct, + + 100. * AB_scum / all_scum); + + } + + else + + { + + fprintf(fp, "%-14s %8lld %10lld %6s %4s %10.0f %6s %4s\n", + + TIMER_NAMES[0], + + AB_ct, + + AB_ucum, + + "-", + + "-", + + 1000. * AB_scum, + + "-", + + "-"); + + } + + + +__int64 ct[TIMER_GROUPS]; + + for (int no = 1; no < TIMER_GROUPS; no++) + + { + + int offset = no * TIMER_SPACING; + + + __int64 ucum = 0; + + double scum = 0; + + ct[no] = 0; + + + for (int d = 0; d < TIMER_SPACING; d++) + + { + + ct[no] += count[offset + d]; + + ucum += userCum[offset + d]; + + scum += systCum[offset + d]; + + } + + + + if (ct[no]) + + { + + fprintf(fp, "%-14s %8lld %10lld %6.2f %4.1f %10.0f %6.2f %4.1f\n", + + TIMER_NAMES[no], + + ct[no], + + ucum, + + ucum / (double) ct[no], + + 100. * ucum / all_ucum, + + 1000. * scum, + + 1000. * scum / (double) ct[no], + + 100. * scum / all_scum); + + } + + else + + { + + fprintf(fp, "%-14s %8lld %10lld %6s %4s %10.0f %6s %4s\n", + + TIMER_NAMES[no], + + ct[no], + + ucum, + + "-", + + "-", + + 1000. * scum, + + "-", + + "-"); + + } + + } + + fprintf(fp, "----------------------------------"); + + fprintf(fp, "-----------------------------------\n"); + + fprintf(fp, "%-14s %8s %10lld %6s %4s %10.0f\n\n\n", + + "Sum", + + "", + + all_ucum, + + "", + + "", + + 1000. * all_scum); + + + + // This doesn't work properly yet. The issue is that on some + + // loops there is no success, and in that case we have to try + + // all moves to see this. But no move ordering could have done + + // better. So we need to know the proportion for the successes + + // only. This probably becomes more natural when there is a Move + + // object. It doesn't really belong in Timer anyway. + + + //double genMoves = ct[TIMER_NO_MOVEGEN] + ct[TIMER_NO_NEXTMOVE]; + + //if (genMoves) + + //fprintf(fp, "Move generation quality %.1f%%\n\n\n", + + //100. * (1. - ct[TIMER_NO_MAKE] / genMoves)); + + + + if (AB_ucum > 0. && AB_scum > 0.) + + { + + fprintf(fp, "%-14s %8s %10s %6s %4s %10s %6s %4s\n", + + "Name", + + "Count", + + "User", + + "Avg", + + "%", + + "Syst", + "Avg", + + "%"); + + + for (int no = TIMER_SPACING-1; no >= 0; no--) + + { + + if (count[no] == 0) + + continue; + + + fprintf(fp, "%-14s %8d %10lld %6.2f %4.1f %10.0f %6.2f %4.1f\n", + + name[TIMER_AB + no], + + count[no], + + AB_userCum[no], + + AB_userCum[no] / (double) count[no], + + 100. * AB_userCum[no] / AB_ucum, + + 1000. * AB_systCum[no], + + 1000. * AB_systCum[no] / (double) count[no], + + 100. * AB_systCum[no] / (double) AB_scum); + + + } + + fprintf(fp, "----------------------------------"); + + fprintf(fp, "-----------------------------------\n"); + + fprintf(fp, "%-14s %8lld %10lld %6s %4s %10.0f\n\n\n", + + "Sum", + AB_ct, + AB_ucum, + "", + "", + 1000. * AB_scum); + + } + + + +#ifdef DDS_TIMING_DETAILS + + Timer::OutputDetails(); + +#endif + +} + +int Timer::TimevalDiff(timeval x, timeval y) + +{ + return 1000 * (x.tv_sec - y.tv_sec ) + + (x.tv_usec - y.tv_usec) / 1000; + +} diff --git a/Timer.h b/Timer.h new file mode 100644 index 00000000..7584a2a8 --- /dev/null +++ b/Timer.h @@ -0,0 +1,282 @@ +/* + DDS 2.7.0 A bridge double dummy solver. + + Copyright (C) 2006-2014 by Bo Haglund + + Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. + + The code for calculation of par score / contracts is based upon the + + perl code written by Matthew Kidd for ACBLmerge. He has kindly given + + me permission to include a C++ adaptation in DDS. +*/ + + + +/* + Licensed under the Apache License, Version 2.0 (the "License"); + + you may not use this file except in compliance with the License. + + You may obtain a copy of the License at + + + http://www.apache.org/licenses/LICENSE-2.0 + + + Unless required by applicable law or agreed to in writing, software + + distributed under the License is distributed on an "AS IS" BASIS, + + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + + implied. See the License for the specific language governing + + permissions and limitations under the License. +*/ + + + +/* + This object, Timer, was was written by Søren Hein. + Many thanks for allowing me to include it in DDS. + + + It is a simple object for timing functions or code pieces. + + As it stands, it is somewhat specific to AB searches, + + but it can of course be generalized. +*/ + + + +/* + There are groups of 50 timers. + Each group corresponds to + something that should be timed at multiple AB depths, i.e. + + cards played. The first card of a new game is number 48, + + and the last card is number 0. + The AB timer is special, as the AB functions are recursive + + and so their timing includes not only the other functions they + + contain, but also their own recursive calls at lower depths. + + The AB timer group must be the first one. + + + The object calculates an approximation to exclusive function + + times, so it is a "poor man's profiler". + For AB, first the + times at depth-1 are subtracted out, and then the times for + + all calls at the same depth are subtracted out. This still + + leaves the overhead of the timing itself. As an approximation, + + there is one timing overhead left for each function, and it + + is on the order of the execution time of Evaluate(), which is + + a very fast function. */ + + + + +#ifndef _DDS_TIMING + +#define _DDS_TIMING + + + +#include + +#include + +#include + + + +#ifdef _WIN32 + + #include + +#else + + #include + +#endif + + + +/* + TIMER_START and TIMER_END are macros for bracketing code + + to be timed, so + + + + TIMER_START(TIMER_AB + depth); + + ABsearch(...); + + TIMER_END; + + + + This avoid the tedious #ifdef's at every place of a timer. + +*/ + + + +#ifdef DDS_TIMING + +#define TIMER_START(a) thrp->timer.Start(a) + +#define TIMER_END(a) thrp->timer.End(a) + +#else + +#define TIMER_START(a) 1 + +#define TIMER_END(a) 1 + +#endif + + + +#define LINE_LEN 20 + +#define TIMER_SPACING 50 + +#define TIMER_GROUPS 10 + + + +#define TIMER_NO_AB 0 + +#define TIMER_NO_MAKE 1 + +#define TIMER_NO_UNDO 2 + +#define TIMER_NO_EVALUATE 3 + +#define TIMER_NO_NEXTMOVE 4 + +#define TIMER_NO_QT 5 + +#define TIMER_NO_LT 6 + +#define TIMER_NO_MOVEGEN 7 + +#define TIMER_NO_LOOKUP 8 + +#define TIMER_NO_BUILD 9 + + + +#define TIMER_AB TIMER_NO_AB + +#define TIMER_MAKE ( TIMER_NO_MAKE * TIMER_SPACING) + +#define TIMER_UNDO ( TIMER_NO_UNDO * TIMER_SPACING) + +#define TIMER_EVALUATE ( TIMER_NO_EVALUATE * TIMER_SPACING) + +#define TIMER_NEXTMOVE ( TIMER_NO_NEXTMOVE * TIMER_SPACING) + +#define TIMER_QT ( TIMER_NO_QT * TIMER_SPACING) + +#define TIMER_LT ( TIMER_NO_LT * TIMER_SPACING) + +#define TIMER_MOVEGEN ( TIMER_NO_MOVEGEN * TIMER_SPACING) + +#define TIMER_LOOKUP ( TIMER_NO_LOOKUP * TIMER_SPACING) + +#define TIMER_BUILD ( TIMER_NO_BUILD * TIMER_SPACING) + + + +#define DDS_TIMERS (TIMER_GROUPS * TIMER_SPACING) + + + + + +class Timer +{ + private: + FILE * fp; + + char fname[DDS_FNAME_LEN]; + + char name[DDS_TIMERS][LINE_LEN]; + + + clock_t systTimes0[DDS_TIMERS], + + systTimes1[DDS_TIMERS]; + + + +#ifdef _WIN32 + + LARGE_INTEGER userTimes0[DDS_TIMERS], + + userTimes1[DDS_TIMERS]; + +#else + + timeval userTimes0[DDS_TIMERS], + + userTimes1[DDS_TIMERS]; + +#endif + + + int count[DDS_TIMERS]; + + __int64 userCum[DDS_TIMERS]; + + double systCum[DDS_TIMERS]; + + + void OutputStats(char * t); + + int TimevalDiff(timeval x, timeval y); + + void OutputDetails(); + + + + public: + + Timer(); + + ~Timer(); + + void Reset(); + + void SetFile(char * fname); + + void SetName(int no, char * name); + + void SetNames(); + + void Start(int no); + + void End(int no); + + void PrintStats(); + +}; + + + +#endif diff --git a/TransTable.cpp b/TransTable.cpp new file mode 100644 index 00000000..33f39c35 --- /dev/null +++ b/TransTable.cpp @@ -0,0 +1,1862 @@ +/* + DDS 2.7.0 A bridge double dummy solver. + Copyright (C) 2006-2014 by Bo Haglund + Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. + The code for calculation of par score / contracts is based upon the + perl code written by Matthew Kidd for ACBLmerge. He has kindly given + me permission to include a C++ adaptation in DDS. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. See the License for the specific language governing + permissions and limitations under the License. + + This object, TransTable, was was written by Søren Hein. + Many thanks for allowing me to include it in DDS. +*/ + +/* + This object arose out of Bo's implementation, but the + algorithm and data structures are completely different. + In the process of writing it, I found it necessary to + encapsulate the code that is specific to transposition + tables. One side effect of this may be that others will + want to try to improve on my work. I hope so! + + The data structures in this object are heavily optimized. + Some explanation is included in the code. + + Søren Hein, 2014-09-09. +*/ + +#include "dds.h" +#include "TransTable.h" + +extern unsigned char cardRank[16]; +extern char relRank[8192][15]; + +const char * players[DDS_HANDS] = { + "North", "East", "South", "West" +}; + + + +/* + There are some constants that only need to be calculated + once. In fact they are the same for all instances of the + object. In order to save time and memory, they share a + single memory. + + Each 13-bit number, aggr, represents a possible set of cards + remaining in a suit. For example, 0x15a2 represents + A(1) QT(5) 97(a) 3(2). + + lowestRank[aggr] gives the lowest rank that is in play in + aggr. The ace is 14, the deuce is 2. A void counts as + rank 15 ("not even the ace"). It would go horribly wrong + if this rank were chosen to be 0, as might seem intuitive. + + maskBytes[aggr][suit] is a set of 4 32-bit integers, + where suit is 0 ..3 (spades .. clubs). Each integer only + has 8 of its 32 bits set, but these 8 bits could be either + in the top byte (byte 0) or any of the others (bytes 1 ..3). + The bytes are abbreviated as B0 .. B3 below. + + int 0 int 1 int 2 int 3 + suit 0, spades B0 R0 B0 R1 B0 R2 B0 R3 + suit 1, hearts B1 R0 B1 R1 B1 R2 B1 R3 + suit 2, diamonds B2 R0 B2 R1 B2 R2 B2 + suit 3, clubs B3 R0 B3 R1 B3 R2 B3 + + R0 .. R3 are explained now. The purpose of maskBytes is + to generate 32-bit masks for later use with actual suits. + As a card can be with either of 4 players, 2 bits are needed + to encode the position of a card. Therefore the masks also + need 2 bits per card, even though the 2 bits are identical. + + In the table, R0 means the top byte (8 bits = 4 cards) of + a holding. + + R0 AKQJ + R1 T987 + R2 6543 + R3 2 + + For example, if the ace is held by North, the king by South, the + queen and jack by West, then the top byte for that SUIT would be + + 00(North) 10(South) 11(West) 11(West) + + The MASK for that holding would be 11 11 11 11, as all four + cards are in play. + + If the jack were missing, because it had already been played, + then the suit would be 00 10 11 00 (a missing card is also + encoded as 00), and the mask would be 11 11 11 00. + + Later on, when we have a specific set of spades .. clubs, + we want to check whether those cards are already in the + transposition table. As far as the necessary masks is + concerned, this is generated by an OR (|) of the four + 32-bit integers in a column of the table above. + + So the first column yields four bytes which are already + shifted in place, all corresponding to R0. The mask + corresponds to the AKQJ of the four suits in order. + + It's not really AKQJ, but the four highest cards still in + play in that suit. So missing cards are always at the end + of the list. +*/ + +bool _constantsSet = false; +int maskBytes[8192][DDS_SUITS][TT_BYTES]; +int lowestRank[8192]; + + +TransTable::TransTable() +{ + if (! _constantsSet) + { + _constantsSet = true; + TransTable::SetConstants(); + } + + poolp = NULL; + pagesDefault = NUM_PAGES_DEFAULT; + pagesMaximum = NUM_PAGES_MAXIMUM; + pagesCurrent = 0; + + memState = FROM_POOL; + harvestTrick = FIRST_HARVEST_TRICK; + harvestHand = 0; + + harvested.nextBlockNo = 0; + + timestamp = 0; + + pageStats.numResets = 0; + pageStats.numCallocs = 0; + pageStats.numFrees = 0; + pageStats.numHarvests = 0; + pageStats.lastCurrent = 0; + + TTInUse = 0; + + sprintf(fname, ""); + fp = stdout; +} + + +TransTable::~TransTable() +{ + TransTable::ReturnAllMemory(); + + if (fp != stdout) + fclose(fp); +} + + +void TransTable::SetConstants() +{ + int winMask[8192]; + + unsigned int topBitRank = 1; + winMask[0] = 0; + lowestRank[0] = 15; // Void + + for (int ind = 1; ind < 8192; ind++) + { + if (ind >= (topBitRank + topBitRank)) /* Next top bit */ + topBitRank <<= 1; + + strncpy(relRank[ind], relRank[ind ^ topBitRank], 15); + + // winMask is a growing list of 11's. In the end it will + // have 26 bits, so 13 groups of two bits. It always + // consists of all 11's, then all 00's. + + winMask[ind] = (winMask[ind ^ topBitRank] >> 2) | (3 << 24); + + maskBytes[ind][0][0] = (winMask[ind] << 6) & 0xff000000; + maskBytes[ind][0][1] = (winMask[ind] << 14) & 0xff000000; + maskBytes[ind][0][2] = (winMask[ind] << 22) & 0xff000000; + maskBytes[ind][0][3] = (winMask[ind] << 30) & 0xff000000; + + maskBytes[ind][1][0] = (winMask[ind] >> 2) & 0x00ff0000; + maskBytes[ind][1][1] = (winMask[ind] << 6) & 0x00ff0000; + maskBytes[ind][1][2] = (winMask[ind] << 14) & 0x00ff0000; + maskBytes[ind][1][3] = (winMask[ind] << 22) & 0x00ff0000; + + maskBytes[ind][2][0] = (winMask[ind] >> 10) & 0x0000ff00; + maskBytes[ind][2][1] = (winMask[ind] >> 2) & 0x0000ff00; + maskBytes[ind][2][2] = (winMask[ind] << 6) & 0x0000ff00; + maskBytes[ind][2][3] = (winMask[ind] << 14) & 0x0000ff00; + + maskBytes[ind][3][0] = (winMask[ind] >> 18) & 0x000000ff; + maskBytes[ind][3][1] = (winMask[ind] >> 10) & 0x000000ff; + maskBytes[ind][3][2] = (winMask[ind] >> 2) & 0x000000ff; + maskBytes[ind][3][3] = (winMask[ind] << 6) & 0x000000ff; + + lowestRank[ind] = lowestRank[ind ^ topBitRank] - 1; + } +} + + +void TransTable::Init(int handLookup[][15]) +{ + // This is very similar to SetConstants, except that it + // happens with actual cards. It also makes sense to + // keep a record of aggrRanks for each suit. These are + // only used later for xorSet. + + unsigned int topBitRank = 1; + unsigned int topBitNo = 2; + aggrType * ap; + + for (int s = 0; s < DDS_SUITS; s++) + aggr[0].aggrRanks[s] = 0; + + for (int ind = 1; ind < 8192; ind++) + { + if (ind >= (topBitRank << 1)) + { + /* Next top bit */ + topBitRank <<= 1; + topBitNo++; + } + + aggr[ind] = aggr[ind ^ topBitRank]; + ap = &aggr[ind]; + + for (int s = 0; s < DDS_SUITS; s++) + { + ap->aggrRanks[s] = (ap->aggrRanks[s] >> 2) | + (handLookup[s][topBitNo] << 24); + } + + ap->aggrBytes[0][0] = (ap->aggrRanks[0] << 6) & 0xff000000; + ap->aggrBytes[0][1] = (ap->aggrRanks[0] << 14) & 0xff000000; + ap->aggrBytes[0][2] = (ap->aggrRanks[0] << 22) & 0xff000000; + ap->aggrBytes[0][3] = (ap->aggrRanks[0] << 30) & 0xff000000; + + ap->aggrBytes[1][0] = (ap->aggrRanks[1] >> 2) & 0x00ff0000; + ap->aggrBytes[1][1] = (ap->aggrRanks[1] << 6) & 0x00ff0000; + ap->aggrBytes[1][2] = (ap->aggrRanks[1] << 14) & 0x00ff0000; + ap->aggrBytes[1][3] = (ap->aggrRanks[1] << 22) & 0x00ff0000; + + ap->aggrBytes[2][0] = (ap->aggrRanks[2] >> 10) & 0x0000ff00; + ap->aggrBytes[2][1] = (ap->aggrRanks[2] >> 2) & 0x0000ff00; + ap->aggrBytes[2][2] = (ap->aggrRanks[2] << 6) & 0x0000ff00; + ap->aggrBytes[2][3] = (ap->aggrRanks[2] << 14) & 0x0000ff00; + + ap->aggrBytes[3][0] = (ap->aggrRanks[3] >> 18) & 0x000000ff; + ap->aggrBytes[3][1] = (ap->aggrRanks[3] >> 10) & 0x000000ff; + ap->aggrBytes[3][2] = (ap->aggrRanks[3] >> 2) & 0x000000ff; + ap->aggrBytes[3][3] = (ap->aggrRanks[3] << 6) & 0x000000ff; + } +} + + +void TransTable::SetMemoryDefault(int megabytes) +{ + double blockMem = BLOCKS_PER_PAGE * sizeof(winBlockType) / + (double) 1024.; + + int pagesDefault = (int) (1024 * megabytes) / blockMem; +} + + +void TransTable::SetMemoryMaximum(int megabytes) +{ + double blockMem = BLOCKS_PER_PAGE * sizeof(winBlockType) / + (double) 1024.; + + int pagesMaximum = (int) (1024 * megabytes) / blockMem; +} + + +void TransTable::MakeTT() +{ + if (! TTInUse) + { + TTInUse = 1; + + for (int t = 0; t < TT_TRICKS; t++) + { + for (int h = 0; h < DDS_HANDS; h++) + { + TTroot[t][h] = (distHashType *) + malloc(256 * sizeof(distHashType)); + + if (TTroot[t][h] == NULL) + exit(1); + } + } + } + + TransTable::InitTT(); +} + + +void TransTable::InitTT() +{ + for (int c = 0; c < TT_TRICKS; c++) + { + for (int h = 0; h < DDS_HANDS; h++) + { + for (int i = 0; i < 256; i++) + { + TTroot[c][h][i].nextNo = 0; + TTroot[c][h][i].nextWriteNo = 0; + + } + lastBlockSeen[c][h] = NULL; + } + } +} + + +void TransTable::ReleaseTT() +{ + if (! TTInUse) + return; + TTInUse = 0; + + for (int t = 0; t < TT_TRICKS; t++) + { + for (int h = 0; h < DDS_HANDS; h++) + { + if (TTroot[t][h] == NULL) + continue; + + free(TTroot[t][h]); + } + } +} + + +void TransTable::ResetMemory() +{ + if (poolp == NULL) + return; + + pageStats.numResets++; + pageStats.numCallocs += pagesCurrent - pageStats.lastCurrent; + pageStats.lastCurrent = pagesCurrent; + + while (pagesCurrent > pagesDefault) + { + free(poolp->list); + poolp = poolp->prev; + + free(poolp->next); + poolp->next = NULL; + + pagesCurrent--; + } + + pageStats.numFrees += pageStats.lastCurrent - pagesCurrent; + pageStats.lastCurrent = pagesCurrent; + + while (poolp->prev) + poolp = poolp->prev; + + poolp->nextBlockNo = 0; + nextBlockp = poolp->list; + + TransTable::InitTT(); + + timestamp = 0; + + memState = FROM_POOL; + + return; +} + + +void TransTable::ReturnAllMemory() +{ + poolType * tmp; + + while (poolp) + { + free(poolp->list); + tmp = poolp; + poolp = poolp->prev; + free(tmp); + } + pagesCurrent = 0; + + pageStats.numResets = 0; + pageStats.numCallocs = 0; + pageStats.numFrees = 0; + pageStats.numHarvests = 0; + pageStats.lastCurrent = 0; + + TransTable::ReleaseTT(); + + return; +} + + +int TransTable::BlocksInUse() +{ + poolType * pp = poolp; + int count = 0; + + do + { + count += pp->nextBlockNo; + pp = pp->prev; + } + while (pp); + + return count; +} + + +double TransTable::MemoryInUse() +{ + int blockMem = BLOCKS_PER_PAGE * pagesCurrent * sizeof(winBlockType); + int aggrMem = 8192 * sizeof(aggrType); + int rootMem = TT_TRICKS * DDS_HANDS * 256 * sizeof(distHashType); + + return (blockMem + aggrMem + rootMem) / (double) 1024.; +} + + +winBlockType * TransTable::GetNextCardBlock() +{ + /* + Spaghetti code. The basic idea is that there is a pool of + pages. When a page runs out, we get a next pool. But we're + only allowed a certain maximum number, and calloc might also + fail before then. We have a default number of pages that + we don't give back voluntarily once we have acquired them, + but we give back anything more than that at the end of each + hand. If this overall mechanism fails, then we try to harvest + old entries scattered throughout the TT memory. If we get + enough for a "page", then we use that single page, and if + that runs out later, we try to harvest some more, starting + where we left off harvesting last time. If the harvesting also + fails, then we reset whatever TT memory we do have, and we + continue with that. + */ + + if (poolp == NULL) + { + // Have to be able to get at least one pool. + poolp = (poolType *) calloc(1, sizeof(poolType)); + if (poolp == NULL) + exit(1); + + poolp->list = (winBlockType *) + malloc(BLOCKS_PER_PAGE * sizeof(winBlockType)); + + if (! poolp->list) + exit(1); + + poolp->next = NULL; + poolp->prev = NULL; + poolp->nextBlockNo = 1; + + nextBlockp = poolp->list; + + pagesCurrent++; + + return nextBlockp++; + } + else if (memState == FROM_HARVEST) + { + // Not allowed to get more memory, so reuse old one. + int n = harvested.nextBlockNo; + if (n == BLOCKS_PER_PAGE) + { + if (! TransTable::Harvest()) + { + TransTable::ResetMemory(); + poolp->nextBlockNo++; + return nextBlockp++; + } + n = 0; + } + + harvested.nextBlockNo++; + return harvested.list[n]; + } + else if (poolp->nextBlockNo == BLOCKS_PER_PAGE) + { + if (poolp->next) + { + // Reuse a dormant block that has not been freed. + poolp = poolp->next; + poolp->nextBlockNo = 1; + nextBlockp = poolp->list; + + return nextBlockp++; + } + else if (pagesCurrent == pagesMaximum) + { + // Have to try to reclaim memory. + if (! TransTable::Harvest()) + { + TransTable::ResetMemory(); + poolp->nextBlockNo++; + return nextBlockp++; + } + + memState = FROM_HARVEST; + harvested.nextBlockNo++; + return harvested.list[0]; + } + else + { + // Make a new pool. + poolType * newpoolp = (poolType *) calloc(1, sizeof(poolType)); + + if (newpoolp == NULL) + { + // Unexpected, but try harvesting before we give up + // and start over. + if (! TransTable::Harvest()) + { + TransTable::ResetMemory(); + poolp->nextBlockNo++; + return nextBlockp++; + } + + memState = FROM_HARVEST; + harvested.nextBlockNo++; + return harvested.list[0]; + } + + newpoolp->list = (winBlockType *) + malloc(BLOCKS_PER_PAGE * sizeof(winBlockType)); + + if (! newpoolp->list) + { + if (! TransTable::Harvest()) + { + TransTable::ResetMemory(); + poolp->nextBlockNo++; + return nextBlockp++; + } + + memState = FROM_HARVEST; + harvested.nextBlockNo++; + return harvested.list[0]; + } + + newpoolp->nextBlockNo = 1; + newpoolp->next = NULL; + newpoolp->prev = poolp; + + poolp->next = newpoolp; + poolp = newpoolp; + + nextBlockp = newpoolp->list; + + pagesCurrent++; + + return nextBlockp++; + } + } + + poolp->nextBlockNo++; + return nextBlockp++; +} + + +bool TransTable::Harvest() +{ + distHashType * rootptr = TTroot[harvestTrick][harvestHand]; + distHashType * ptr; + winBlockType * bp; + + int trick = harvestTrick; + int hand = harvestHand; + int hash, suit, hno = 0; + + while (1) + { + for (hash = 0; hash < 256; hash++) + { + ptr = &rootptr[hash]; + for (suit = ptr->nextNo-1; suit >= 0; suit--) + { + bp = ptr->list[suit].posBlock; + if (timestamp - bp->timestampRead > HARVEST_AGE) + { + bp->nextMatchNo = 0; + bp->nextWriteNo = 0; + bp->timestampRead = timestamp; + harvested.list[hno] = bp; + + // Swap the last element down. + if (suit != ptr->nextNo-1) + ptr->list[suit] = ptr->list[ ptr->nextNo-1 ]; + + ptr->nextNo--; + ptr->nextWriteNo = ptr->nextNo; + + if (++hno == BLOCKS_PER_PAGE) + { + if (++harvestHand >= DDS_HANDS) + { + // Skip rest of this [trick][hand] for simplicity. + harvestHand = 0; + if (--harvestTrick < 0) + harvestTrick = FIRST_HARVEST_TRICK; + } + + harvested.nextBlockNo = 0; + pageStats.numHarvests++; + return true; + } + } + } + } + + if (++harvestHand >= DDS_HANDS) + { + harvestHand = 0; + if (--harvestTrick < 0) + harvestTrick = FIRST_HARVEST_TRICK; + } + + if (harvestTrick == trick && harvestHand == hand) + return false; + + rootptr = TTroot[harvestTrick][harvestHand]; + } +} + + +int TransTable::hash8(int * handDist) +{ + /* + handDist is an array of hand distributions, North .. West. + Each entry is a 12-bit number with 3 groups of 4 bits. + Each group is the binary representation of the number of + cards held in that suit. The suits are in order spades, + hearts, diamonds. Clubs can be neglected, as the total + number of cards in a hand is given by the trick number. + + For example, if handDist[1] equals 0x0433, then East holds + 4 spades, 3 hearts, 3 diamonds and the rest in clubs. + If this is after the second trick, there are 11 cards, so + East must hold 1 club. + + The hash function turns all 4 hand distributions into a + single 8-bit number. The numbers should be spread as + evenly as possible across the 256 possibilities. I've not + done extensive research into finding the best hash function, + but this one seems OK. It uses a small prime, 5, and its + powers. The shift at the end is in order to get some use + out of the bits above the first 8 ones. + */ + + int h = + (handDist[0] ^ + ((handDist[1] * 5) ) ^ + ((handDist[2] * 25) ) ^ + ((handDist[3] * 125) ) ); + + return (h ^ (h >> 5)) & 0xff; +} + + +nodeCardsType * TransTable::Lookup( + int tricks, + int hand, + unsigned short aggrTarget[], + int handDist[], + int limit, + bool * lowerFlag) +{ + // First look up distribution. + long long suitLengths = + (((long long) handDist[0]) << 36) | + (((long long) handDist[1]) << 24) | + (((long long) handDist[2]) << 12) | + (((long long) handDist[3]) ); + + int hashkey = hash8(handDist); + + bool empty; + lastBlockSeen[tricks][hand] = + LookupSuit(&TTroot[tricks][hand][hashkey], + suitLengths, &empty); + if (empty) + return NULL; + + // If that worked, look up cards. + int * ab0 = aggr[ aggrTarget[0] ].aggrBytes[0]; + int * ab1 = aggr[ aggrTarget[1] ].aggrBytes[1]; + int * ab2 = aggr[ aggrTarget[2] ].aggrBytes[2]; + int * ab3 = aggr[ aggrTarget[3] ].aggrBytes[3]; + + winMatchType TTentry; + TTentry.topSet1 = ab0[0] | ab1[0] | ab2[0] | ab3[0]; + TTentry.topSet2 = ab0[1] | ab1[1] | ab2[1] | ab3[1]; + TTentry.topSet3 = ab0[2] | ab1[2] | ab2[2] | ab3[2]; + TTentry.topSet4 = ab0[3] | ab1[3] | ab2[3] | ab3[3]; + + return TransTable::LookupCards(&TTentry, + lastBlockSeen[tricks][hand], limit, lowerFlag); +} + + +winBlockType * TransTable::LookupSuit( + distHashType * dp, + long long key, + bool * empty) +{ + /* + Always returns a valid winBlockType. + If empty == true, there was no match, so there is + no point in looking for a card match. + If empty == false, there were entries already. + */ + + int n = dp->nextNo; + for (int i = 0; i < n; i++) + { + if (dp->list[i].key == key) + { + *empty = false; + return dp->list[i].posBlock; + } + } + + *empty = true; + int m; + + if (n == DISTS_PER_ENTRY) + { + // No room for new exact suits at this hash position. + // Have to reuse an existing posBlock. + if (dp->nextWriteNo == DISTS_PER_ENTRY) + { + m = 0; + dp->nextWriteNo = 1; + } + else + m = dp->nextWriteNo++; + } + else + { + // Didn't find an exact match, but there is still room. + // The following looks a bit odd because it is possible that + // GetNextCardBlock wipes out the whole memory, so we + // have to use the up-to-date location, not m from above. + + winBlockType * bp = GetNextCardBlock(); + m = dp->nextWriteNo++; + dp->list[m].posBlock = bp; + dp->list[m].posBlock->timestampRead = timestamp; + dp->nextNo++; + } + + // As long as the secondary Lookup loop in ABsearch exists, + // it will cause spurious extra blocks to be created here + // which are not useful, because nothing is ever Add'ed. + // This is not a memory leak, as the memory is properly freed, + // but it is also a small waste of about 0.5%. I don't mind. + + dp->list[m].key = key; + dp->list[m].posBlock->nextMatchNo = 0; + dp->list[m].posBlock->nextWriteNo = 0; + + return dp->list[m].posBlock; +} + + +nodeCardsType * TransTable::LookupCards( + winMatchType * searchp, + winBlockType * bp, + int limit, + bool * lowerFlag) +{ + winMatchType * wp; + + int n = bp->nextWriteNo - 1; + wp = &bp->list[n]; + + // It may be a bit silly to duplicate the code like this. + // It could be combined to one loop with a slight overhead. + + for (int i = n; i >= 0; i--, wp--) + { + if ((wp->topSet1 ^ searchp->topSet1) & wp->topMask1) + continue; + + if (wp->lastMaskNo != 1) + { + if ((wp->topSet2 ^ searchp->topSet2) & wp->topMask2) + continue; + + if (wp->lastMaskNo != 2) + { + if ((wp->topSet3 ^ searchp->topSet3) & wp->topMask3) + continue; + } + } + + // Check bounds. + nodeCardsType * nodep = &wp->first; + if (nodep->lbound > limit) + { + bp->timestampRead = ++timestamp; + * lowerFlag = true; + return nodep; + } + else if (nodep->ubound <= limit) + { + bp->timestampRead = ++timestamp; + * lowerFlag = false; + return nodep; + } + } + + int n2 = bp->nextMatchNo-1; + wp = &bp->list[n2]; + + for (int i = n2; i > n; i--, wp--) + { + if ((wp->topSet1 ^ searchp->topSet1) & wp->topMask1) + continue; + + if (wp->lastMaskNo != 1) + { + if ((wp->topSet2 ^ searchp->topSet2) & wp->topMask2) + continue; + + if (wp->lastMaskNo != 2) + { + if ((wp->topSet3 ^ searchp->topSet3) & wp->topMask3) + continue; + } + } + + nodeCardsType * nodep = &wp->first; + if (nodep->lbound > limit) + { + * lowerFlag = true; + bp->timestampRead = ++timestamp; + return nodep; + } + else if (nodep->ubound <= limit) + { + * lowerFlag = false; + bp->timestampRead = ++timestamp; + return nodep; + } + } + + return NULL; +} + + +void TransTable::CreateOrUpdate( + winBlockType * bp, + winMatchType * searchp, + bool flag) +{ + // Either updates an existing SOP or creates a new one. + // A new one is created at the end of the bp list if this + // is not already full, or the oldest one in the list is + // overwritten. + + winMatchType * wp = bp->list; + int n = bp->nextMatchNo; + + for (int i = 0; i < n; i++, wp++) + { + if (wp->xorSet != searchp->xorSet ) continue; + if (wp->maskIndex != searchp->maskIndex) continue; + if (wp->topSet1 != searchp->topSet1 ) continue; + if (wp->topSet2 != searchp->topSet2 ) continue; + if (wp->topSet3 != searchp->topSet3 ) continue; + + nodeCardsType * nodep = &wp->first; + if (searchp->first.lbound > nodep->lbound) + nodep->lbound = searchp->first.lbound; + if (searchp->first.ubound < nodep->ubound) + nodep->ubound = searchp->first.ubound; + + nodep->bestMoveSuit = searchp->first.bestMoveSuit; + nodep->bestMoveRank = searchp->first.bestMoveRank; + return; + } + + if (n == BLOCKS_PER_ENTRY) + { + if (bp->nextWriteNo >= BLOCKS_PER_ENTRY) + bp->nextWriteNo = 0; + } + else + bp->nextMatchNo++; + + + wp = &bp->list[ bp->nextWriteNo++ ]; + *wp = *searchp; + + if (!flag) + { + wp->first.bestMoveSuit = 0; + wp->first.bestMoveRank = 0; + } +} + + +void TransTable::Add( + int tricks, + int hand, + unsigned short * aggrTarget, + unsigned short * winRanks, + nodeCardsType * first, + bool flag) +{ + if (lastBlockSeen[tricks][hand] == NULL) + { + // We have recently reset the entire memory, and we were + // in the middle of a recursion. So we'll just have to + // drop this entry that we were supposed to be adding. + return; + } + + int * ab[DDS_SUITS]; + int * mb[DDS_SUITS]; + char low[DDS_SUITS]; + unsigned short int w, ag; + winMatchType TTentry; + + // Inefficient, as it also copies leastWin. + // In fact I'm not quite happy with the treatment of + // leastWin in general. + + TTentry.first = *first; + + TTentry.xorSet = 0; + + for (int ss = 0; ss < DDS_SUITS; ss++) + { + w = winRanks[ss]; + if (w == 0) + { + ab[ss] = aggr[0].aggrBytes[ss]; + mb[ss] = maskBytes[0][ss]; + low[ss] = 15; + TTentry.first.leastWin[ss] = 0; + } + else + { + w = w & (-w); /* Only lowest win */ + ag = aggrTarget[ss] & (-w); + + ab[ss] = aggr[ag].aggrBytes[ss]; + mb[ss] = maskBytes[ag][ss]; + low[ss] = lowestRank[ag]; + + TTentry.first.leastWin[ss] = 15 - low[ss]; + TTentry.xorSet ^= aggr[ag].aggrRanks[ss]; + } + } + + // It's a bit annoying that we may be regenerating these. + // But winRanks can cause them to change after lookup(). + + TTentry.topSet1 = ab[0][0] | ab[1][0] | ab[2][0] | ab[3][0]; + TTentry.topSet2 = ab[0][1] | ab[1][1] | ab[2][1] | ab[3][1]; + TTentry.topSet3 = ab[0][2] | ab[1][2] | ab[2][2] | ab[3][2]; + TTentry.topSet4 = ab[0][3] | ab[1][3] | ab[2][3] | ab[3][3]; + + TTentry.topMask1 = mb[0][0] | mb[1][0] | mb[2][0] | mb[3][0]; + TTentry.topMask2 = mb[0][1] | mb[1][1] | mb[2][1] | mb[3][1]; + TTentry.topMask3 = mb[0][2] | mb[1][2] | mb[2][2] | mb[3][2]; + TTentry.topMask4 = mb[0][3] | mb[1][3] | mb[2][3] | mb[3][3]; + + TTentry.maskIndex = + (low[0] << 12) | (low[1] << 8) | (low[2] << 4) | low[3]; + + if (TTentry.topMask2 == 0) + TTentry.lastMaskNo = 1; + else if (TTentry.topMask3 == 0) + TTentry.lastMaskNo = 2; + else if (TTentry.topMask4 == 0) + TTentry.lastMaskNo = 3; + else + TTentry.lastMaskNo = 4; + + TransTable::CreateOrUpdate(lastBlockSeen[tricks][hand], + &TTentry, flag); +} + + + +void TransTable::PrintMatch( + winMatchType * wp, + unsigned char lengths[DDS_HANDS][DDS_SUITS]) +{ + char hands[DDS_HANDS][DDS_SUITS][TT_LINE_LEN]; + int used[DDS_HANDS][DDS_SUITS]; + + for (int h = 0; h < DDS_HANDS; h++) + { + for (int s = 0; s < DDS_SUITS; s++) + { + used[h][s] = 0; + for (int c = 0; c < TT_LINE_LEN; c++) + hands[h][s][c] = 0; + } + } + + TransTable::SetToPartialHands( + wp->topSet1, wp->topMask1, 14, 4, hands, used); + TransTable::SetToPartialHands( + wp->topSet2, wp->topMask2, 10, 4, hands, used); + TransTable::SetToPartialHands( + wp->topSet3, wp->topMask3, 6, 4, hands, used); + TransTable::SetToPartialHands( + wp->topSet4, wp->topMask4, 2, 1, hands, used); + + TransTable::DumpHands(hands, lengths); + + TransTable::PrintNodeValues(&wp->first); +} + + +void TransTable::PrintNodeValues( + nodeCardsType * np) +{ + if (!np) + { + fprintf(fp, "np == NULL\n"); + return; + } + + fprintf(fp, "Lowest used\t%c%c, %c%c, %c%c, %c%c\n", + cardSuit[0], cardRank[ 15 - (int) np->leastWin[0] ], + cardSuit[1], cardRank[ 15 - (int) np->leastWin[1] ], + cardSuit[2], cardRank[ 15 - (int) np->leastWin[2] ], + cardSuit[3], cardRank[ 15 - (int) np->leastWin[3] ]); + + fprintf(fp, "Bounds\t\t%d to %2d tricks\n", + (int) np->lbound, (int) np->ubound); + + fprintf(fp, "Best move\t%c%c\n", + cardSuit[ (int) np->bestMoveSuit ], + cardRank[ (int) np->bestMoveRank ]); + + fprintf(fp, "\n"); +} + + +void TransTable::MakeHolding( + char * high, + int len, + char * res) +{ + int l = strlen(high); + strcpy(res, high); + + if (len == 0 && (l == 0 || (l == 1 && high[0] == '\0'))) + { + res[0] = '-'; + res[1] = '\0'; + return; + } + + for (int i = l; i < len; i++) + { + res[i] = 'x'; + } + res[len] = '\0'; +} + + +void TransTable::DumpHands( + char hands[DDS_HANDS][DDS_SUITS][TT_LINE_LEN], + unsigned char lengths[DDS_HANDS][DDS_SUITS]) +{ + char res_a[TT_LINE_LEN], res_b[TT_LINE_LEN]; + + for (int i = 0; i < DDS_SUITS; i++) + { + TransTable::MakeHolding(hands[0][i], (int) lengths[0][i], res_a); + fprintf(fp, "%16s%s\n", "", res_a); + } + + for (int i = 0; i < DDS_SUITS; i++) + { + TransTable::MakeHolding(hands[3][i], (int) lengths[3][i], res_a); + TransTable::MakeHolding(hands[1][i], (int) lengths[1][i], res_b); + fprintf(fp, "%-16s%16s%-16s\n", res_a, "", res_b); + } + + for (int i = 0; i < DDS_SUITS; i++) + { + char res[16]; + TransTable::MakeHolding(hands[2][i], (int) lengths[2][i], res); + fprintf(fp, "%16s%s\n", "", res); + } + fprintf(fp, "\n"); +} + + +void TransTable::SetToPartialHands( + int set, + int mask, + int maxRank, + int numRanks, + char hands[DDS_HANDS][DDS_SUITS][TT_LINE_LEN], + int used[DDS_HANDS][DDS_SUITS]) +{ + for (int s = 0; s < DDS_SUITS; s++) + { + for (int rank = maxRank; rank > maxRank - numRanks; rank--) + { + int shift = 8*(3-s) + 2*(rank - maxRank + 3); + int maskCard = mask >> shift; + + if (maskCard & 3) + { + int player = (set >> shift) & 3; + hands[player][s][ used[player][s]++ ] = (char) cardRank[rank]; + } + } + } +} + + +void TransTable::SetFile(char * fname) +{ + if (strlen(fname) > TT_LINE_LEN) + return; + + if (fp != stdout) // Already set + return; + + strncpy(this->fname, fname, strlen(fname)); + + fp = fopen(fname, "w"); + if (! fp) + fp = stdout; +} + + +void TransTable::KeyToDist( + long long key, + int trick, + int handDist[]) +{ + handDist[0] = (key >> 36) & 0x00000fff; + handDist[1] = (key >> 24) & 0x00000fff; + handDist[2] = (key >> 12) & 0x00000fff; + handDist[3] = (key ) & 0x00000fff; +} + + +void TransTable::DistToLengths( + int trick, + int handDist[], + unsigned char lengths[DDS_HANDS][DDS_SUITS]) +{ + for (int h = 0; h < DDS_HANDS; h++) + { + lengths[h][0] = (handDist[h] >> 8) & 0xf; + lengths[h][1] = (handDist[h] >> 4) & 0xf; + lengths[h][2] = (handDist[h] ) & 0xf; + lengths[h][3] = trick + 1 + - lengths[h][0] + - lengths[h][1] + - lengths[h][2]; + } +} + + +void TransTable::LenToStr( + unsigned char len[DDS_HANDS][DDS_SUITS], + char * line) +{ + sprintf(line, + "%d=%d=%d=%d \t%d=%d=%d=%d \t%d=%d=%d=%d \t%d=%d=%d=%d", + len[0][0], len[0][1], len[0][2], len[0][3], + len[1][0], len[1][1], len[1][2], len[1][3], + len[2][0], len[2][1], len[2][2], len[2][3], + len[3][0], len[3][1], len[3][2], len[3][3]); +} + + +void TransTable::PrintSuits( + int trick, + int hand) +{ + distHashType * dp; + long long key; + int handDist[DDS_HANDS]; + unsigned char len[DDS_HANDS][DDS_SUITS]; + char line[40]; + + fprintf(fp, "%4s %2s %-8s\t%-8s\t%-8s\t%-8s\n", + "Key", + "No", + players[0], + players[1], + players[2], + players[3]); + + for (int hashkey = 0; hashkey < 256; hashkey++) + { + dp = &TTroot[trick][hand][hashkey]; + if (dp->nextNo == 0) + continue; + + for (int i = 0; i < dp->nextNo; i++) + { + if (i == 0) + fprintf(fp, "0x%02x %2d ", hashkey, dp->nextNo); + else + fprintf(fp, "%4s %2s " , "", ""); + + TransTable::KeyToDist(dp->list[i].key, trick, handDist); + TransTable::DistToLengths(trick, handDist, len); + + TransTable::LenToStr(len, line); + fprintf(fp, "%s\n", line); + } + } + fprintf(fp, "\n"); +} + + +void TransTable::PrintAllSuits() +{ + for (int trick = 11; trick >= 1; trick--) + { + for (int hand = 0; hand < DDS_HANDS; hand++) + { + fprintf(fp, "Trick %d, hand %s\n", trick, players[hand]); + fprintf(fp, "====================\n\n"); + + TransTable::PrintSuits(trick, hand); + } + } +} + + +void TransTable::MakeHistStats( + int hist[], + int * count, + int * prod_sum, + int * prod_sumsq, + int * max_len, + int last_index) +{ + *count = 0; + *prod_sum = 0; + *prod_sumsq = 0; + *max_len = 0; + + for (int i = 1; i <= last_index; i++) + { + if (hist[i]) + { + *prod_sum += i * hist[i]; + *prod_sumsq += i * i * hist[i]; + *count += hist[i]; + + if (i > *max_len) + *max_len = i; + } + } +} + + +int TransTable::CalcPercentile( + int hist[], + double threshold, + int last_index) +{ + int cum = 0; + + for (int i = 1; i <= last_index; i++) + { + cum += hist[i]; + if (cum >= threshold) + return i; + } + return -1; +} + + +void TransTable::PrintHist( + int hist[], + int num_wraps, + int last_index) +{ + int count, prod_sum, prod_sumsq, max_len; + + TransTable::MakeHistStats(hist, + &count, &prod_sum, &prod_sumsq, &max_len, last_index); + + for (int i = 1; i <= last_index; i++) + if (hist[i]) + fprintf(fp, "%7d\t%5d\n", i, hist[i]); + + fprintf(fp, "\n"); + fprintf(fp, "Entries\t%5d\n", count); + if (count) + { + fprintf(fp, "Full\t%5d\n", num_wraps); + + double mean = prod_sum / (double) count; + fprintf(fp, "Average\t%5.2f\n", mean); + + double var = prod_sumsq / (double) count - mean * mean; + if (var >= 0.) + fprintf(fp, "Std.dev\t%5.2f\n", sqrt(var)); + + fprintf(fp, "Maximum\t%5d\n", max_len); + } + fprintf(fp, "\n"); +} + + +void TransTable::UpdateSuitHist( + int trick, + int hand, + int hist[], + int * num_wraps) +{ + distHashType * dp; + + * num_wraps = 0; + for (int i = 0; i <= DISTS_PER_ENTRY; i++) + hist[i] = 0; + + for (int hashkey = 0; hashkey < 256; hashkey++) + { + dp = &TTroot[trick][hand][hashkey]; + hist [ dp->nextNo ]++; + suitHist[ dp->nextNo ]++; + + if (dp->nextNo != dp->nextWriteNo) + { + (*num_wraps)++; // Not entirely correct + suitWraps++; + } + } +} + + +void TransTable::PrintSuitStats( + int trick, + int hand) +{ + int hist[DISTS_PER_ENTRY+1]; + int num_wraps; + + TransTable::UpdateSuitHist(trick, hand, hist, &num_wraps); + + fprintf(fp, "Suit histogram for trick %d, hand %s\n", + trick, players[hand]); + TransTable::PrintHist(hist, num_wraps, DISTS_PER_ENTRY); +} + + +void TransTable::PrintAllSuitStats() +{ + suitWraps = 0; + for (int i = 0; i <= DISTS_PER_ENTRY; i++) + suitHist[i] = 0; + + for (int trick = 11; trick >= 1; trick--) + { + for (int hand = 0; hand < DDS_HANDS; hand++) + { + fprintf(fp, "Suit, Trick %d, hand %s\n", trick, players[hand]); + fprintf(fp, "==========================\n\n"); + TransTable::PrintSuitStats(trick, hand); + } + } + + fprintf(fp, "Overall suit histogram\n"); + TransTable::PrintHist(suitHist, suitWraps, DISTS_PER_ENTRY); +} + + +void TransTable::PrintSummarySuitStats() +{ + int hist[DISTS_PER_ENTRY+1]; + int count, prod_sum, prod_sumsq, + max_len, num_wraps; + + suitWraps = 0; + for (int i = 0; i <= DISTS_PER_ENTRY; i++) + suitHist[i] = 0; + + fprintf(fp, "Suit depth statistics\n\n"); + + fprintf(fp, "%5s %6s %7s %7s %7s %7s %7s P%-4.2f\n", + "Trick", + "Player", + "Entries", + "Full", + "Average", + "Std.dev", + "Maximum", + TT_PERCENTILE); + + for (int trick = 11; trick >= 1; trick--) + { + for (int hand = 0; hand < DDS_HANDS; hand++) + { + TransTable::UpdateSuitHist(trick, hand, hist, &num_wraps); + TransTable::MakeHistStats(hist, + &count, &prod_sum, &prod_sumsq, &max_len, DISTS_PER_ENTRY); + + double mean, var; + if (count > 0) + { + mean = prod_sum / (double) count; + var = prod_sumsq / (double) count - mean * mean; + if (var < 0.) + var = 0.; + } + + int percentile = + TransTable::CalcPercentile(hist, + TT_PERCENTILE * count, DISTS_PER_ENTRY); + + if (count > 0) + fprintf(fp, "%5d %-6s %7d %7d %7.2f %7.2f %7d %7d\n", + trick, + players[hand], + count, + num_wraps, + mean, + sqrt(var), + max_len, + percentile); + else + fprintf(fp, "%5d %-6s %7d %7d %7s %7s %7d %7d\n", + trick, + players[hand], + count, + num_wraps, + "-", + "-", + max_len, + percentile); + } + fprintf(fp, "\n"); + } + fprintf(fp, "\n"); +} + + +winBlockType * TransTable::FindMatchingDist( + int trick, + int hand, + int handDistSought[DDS_HANDS]) +{ + winBlockType * bp; + distHashType * dp; + int handDist[DDS_HANDS]; + + for (int hashkey = 0; hashkey < 256; hashkey++) + { + dp = &TTroot[trick][hand][hashkey]; + for (int i = 0; i < dp->nextNo; i++) + { + bp = dp->list[i].posBlock; + TransTable::KeyToDist(dp->list[i].key, trick, handDist); + + bool same = true; + for (int h = 0; h < DDS_HANDS; h++) + { + if (handDist[h] != handDistSought[h]) + { + same = false; + break; + } + } + if (same) + return bp; + } + } + return NULL; +} + + +void TransTable::PrintEntriesBlock( + winBlockType * bp, + unsigned char lengths[DDS_HANDS][DDS_SUITS]) +{ + char line[40]; + char lines[2][80]; + + TransTable::LenToStr(lengths, line); + + sprintf(lines[0], + "%d matches for %s\n", bp->nextMatchNo, line); + memset(lines[1], '=', 71); + lines[1][71] = '\0'; + + fprintf(fp, "%s%s\n\n", lines[0], lines[1]); + + for (int j = 0; j < bp->nextMatchNo; j++) + { + fprintf(fp, "Entry number %3d\n", j+1); + fprintf(fp, "----------------\n\n"); + TransTable::PrintMatch(&bp->list[j], lengths); + } +} + + + +void TransTable::PrintEntriesDistAndCards( + int trick, + int hand, + unsigned short * aggrTarget, + int handDist[DDS_HANDS]) +{ + char line[40]; + unsigned char len[DDS_HANDS][DDS_SUITS]; + + winBlockType * bp = + TransTable::FindMatchingDist(trick, hand, handDist); + + TransTable::DistToLengths(trick, handDist, len); + + fprintf(fp, "Looking up entry for trick %d, hand %d\n", + trick, hand); + TransTable::LenToStr(len, line); + fprintf(fp, "%s\n\n", line); + + if (! bp) + { + fprintf(fp, "Entry not found\n\n"); + return; + } + + int * ab0 = aggr[ aggrTarget[0] ].aggrBytes[0]; + int * ab1 = aggr[ aggrTarget[1] ].aggrBytes[1]; + int * ab2 = aggr[ aggrTarget[2] ].aggrBytes[2]; + int * ab3 = aggr[ aggrTarget[3] ].aggrBytes[3]; + + winMatchType TTentry; + TTentry.topSet1 = ab0[0] | ab1[0] | ab2[0] | ab3[0]; + TTentry.topSet2 = ab0[1] | ab1[1] | ab2[1] | ab3[1]; + TTentry.topSet3 = ab0[2] | ab1[2] | ab2[2] | ab3[2]; + TTentry.topSet4 = ab0[3] | ab1[3] | ab2[3] | ab3[3]; + + int matchNo = 1; + int n = bp->nextMatchNo - 1; + winMatchType * wp = &bp->list[n]; + + for (int i = n; i >= 0; i--, wp--) + { + if ((wp->topSet1 ^ TTentry.topSet1) & wp->topMask1) + continue; + + if (wp->lastMaskNo != 1) + { + if ((wp->topSet2 ^ TTentry.topSet2) & wp->topMask2) + continue; + + if (wp->lastMaskNo != 2) + { + if ((wp->topSet3 ^ TTentry.topSet3) & wp->topMask3) + continue; + } + } + + fprintf(fp, "Match number %d\n", matchNo++); + fprintf(fp, "---------------\n"); + TransTable::PrintMatch(&bp->list[i], len); + } + + if (matchNo == 1) + fprintf(fp, "%d matches for suit, none for cards\n\n", n); + else + fprintf(fp, "\n"); +} + + +void TransTable::PrintEntriesDist( + int trick, + int hand, + int handDist[DDS_HANDS]) +{ + unsigned char len[DDS_HANDS][DDS_SUITS]; + + winBlockType * bp = + TransTable::FindMatchingDist(trick, hand, handDist); + + TransTable::DistToLengths(trick, handDist, len); + + if (! bp) + { + fprintf(fp, "Entry not found: Trick %d, hand %d\n", + trick, hand); + char line[80]; + TransTable::LenToStr(len, line); + fprintf(fp, "%s\n\n", line); + return; + } + + TransTable::PrintEntriesBlock(bp, len); +} + + +void TransTable::PrintEntries( + int trick, + int hand) +{ + winBlockType * bp; + distHashType * dp; + int handDist[DDS_HANDS]; + unsigned char lengths[DDS_HANDS][DDS_SUITS]; + + for (int hashkey = 0; hashkey < 256; hashkey++) + { + dp = &TTroot[trick][hand][hashkey]; + for (int i = 0; i < dp->nextNo; i++) + { + bp = dp->list[i].posBlock; + TransTable::KeyToDist(dp->list[i].key, trick, handDist); + TransTable::DistToLengths(trick, handDist, lengths); + + TransTable::PrintEntriesBlock(bp, lengths); + } + } +} + + +void TransTable::PrintAllEntries() +{ + for (int trick = 11; trick >= 1; trick--) + { + for (int hand = 0; hand < DDS_HANDS; hand++) + { + fprintf(fp, "Entries, trick %d, hand %s\n", trick, players[hand]); + fprintf(fp, "==============================\n\n"); + TransTable::PrintEntries(trick, hand); + } + } + fprintf(fp, "\n"); +} + + +void TransTable::UpdateEntryHist( + int trick, + int hand, + int hist[], + int * num_wraps) +{ + distHashType * dp; + + * num_wraps = 0; + for (int i = 0; i <= BLOCKS_PER_ENTRY; i++) + hist[i] = 0; + + for (int hashkey = 0; hashkey < 256; hashkey++) + { + dp = &TTroot[trick][hand][hashkey]; + for (int i = 0; i < dp->nextNo; i++) + { + int c = dp->list[i].posBlock->nextMatchNo; + hist [c]++; + suitHist[c]++; + + if (c != dp->list[i].posBlock->nextWriteNo) + { + (*num_wraps)++; // Not entirely correct + suitWraps++; + } + } + } +} + + +void TransTable::PrintEntryStats( + int trick, + int hand) +{ + int hist[BLOCKS_PER_ENTRY+1]; + int num_wraps; + + TransTable::UpdateEntryHist(trick, hand, hist, &num_wraps); + + fprintf(fp, "Entry histogram for trick %d, hand %s\n", + trick, players[hand]); + TransTable::PrintHist(hist, num_wraps, BLOCKS_PER_ENTRY); +} + + +void TransTable::PrintAllEntryStats() +{ + suitWraps = 0; + for (int i = 0; i <= BLOCKS_PER_ENTRY; i++) + suitHist[i] = 0; + + for (int trick = 11; trick >= 1; trick--) + { + for (int hand = 0; hand < DDS_HANDS; hand++) + { + fprintf(fp, "Entry, trick %d, hand %s\n", trick, players[hand]); + fprintf(fp, "============================\n\n"); + TransTable::PrintEntryStats(trick, hand); + } + } + + fprintf(fp, "Overall entry histogram\n"); + TransTable::PrintHist(suitHist, suitWraps, BLOCKS_PER_ENTRY); +} + + +int TransTable::EffectOfBlockBound( + int hist[], + int size) +{ + // Calculates the number of blocks used if the blocks + // are divided up in units of size, rather than in units + // of BLOCKS_PER_ENTRY. Only makes sense if size is less + // than BLOCKS_PER_ENTRY, as we won't have statistics for + // how many blocks above BLOCKS_PER_ENTRY would be created + // if BLOCKS_PER_ENTRY were larger. + + int cum_memory = 0; + int unit_size = 0; + + for (int i = 1; i <= BLOCKS_PER_ENTRY; i++) + { + if ((i-1) % size == 0) + unit_size += size; + + cum_memory += hist[i] * unit_size; + } + return cum_memory; +} + + +// #define TT_MEMORY_SCENARIO + +void TransTable::PrintSummaryEntryStats() +{ + int hist[BLOCKS_PER_ENTRY+1]; + int count, prod_sum, prod_sumsq, + max_len, num_wraps; + + int cumCount = 0; + double cumProd = 0.; +#ifdef TT_MEMORY_SCENARIO + int cumMemory = 0; +#endif + + suitWraps = 0; + for (int i = 0; i <= BLOCKS_PER_ENTRY; i++) + suitHist[i] = 0; + + fprintf(fp, "Entry depth statistics\n\n"); + + fprintf(fp, "%5s %6s %7s %7s %7s %7s %7s P%-4.2f\n", + "Trick", + "Player", + "Entries", + "Full", + "Average", + "Std.dev", + "Maximum", + TT_PERCENTILE); + + for (int trick = 11; trick >= 1; trick--) + { + for (int hand = 0; hand < DDS_HANDS; hand++) + { + TransTable::UpdateEntryHist(trick, hand, hist, &num_wraps); + TransTable::MakeHistStats(hist, + &count, &prod_sum, &prod_sumsq, &max_len, BLOCKS_PER_ENTRY); + + cumCount += count; + cumProd += prod_sum; +#ifdef TT_MEMORY_SCENARIO + cumMemory += TransTable::EffectOfBlockBound(hist, 20); +#endif + + double mean = prod_sum / (double) count; + double var = prod_sumsq / (double) count - mean * mean; + if (var < 0.) + var = 0.; + + int percentile = + TransTable::CalcPercentile(hist, + TT_PERCENTILE * count, BLOCKS_PER_ENTRY); + + fprintf(fp, "%5d %-6s %7d %7d %7.2f %7.2f %7d %7d\n", + trick, + players[hand], + count, + num_wraps, + mean, + sqrt(var), + max_len, + percentile); + } + fprintf(fp, "\n"); + } + fprintf(fp, "\n"); + + fprintf(fp, "Blocks counted\t%8d\n", cumCount); + + fprintf(fp, "Blocks produced\t%8d\n", TransTable::BlocksInUse()); + +#ifdef TT_MEMORY_SCENARIO + fprintf(fp, "Mem scenario\t%7.2f%%\n", + 100. * cumMemory / ((double) BLOCKS_PER_ENTRY * cumCount)); +#endif + + if (cumCount) + fprintf(fp, "Fullness\t%7.2f%%\n", + 100. * cumProd / (BLOCKS_PER_ENTRY * cumCount)); + fprintf(fp, "\n"); +} + + +void TransTable::PrintPageSummary() +{ + if (pageStats.numResets == 0) + return; + + fprintf(fp, "Page statistics\n\n"); + + fprintf(fp, "%-10s %6s %6s\n", + "Type", "Number", "Avg"); + + fprintf(fp, "%-10s %6d\n", + "Resets", + pageStats.numResets); + fprintf(fp, "%-10s %6d %6.2f\n", + "calloc", + pageStats.numCallocs, + pageStats.numCallocs / (double) pageStats.numResets); + fprintf(fp, "%-10s %6d %6.2f\n", + "free", + pageStats.numFrees, + pageStats.numFrees / (double) pageStats.numResets); + fprintf(fp, "%-10s %6d %6.2f\n\n", + "harvest", + pageStats.numHarvests, + pageStats.numHarvests / (double) pageStats.numResets); +} diff --git a/TransTable.h b/TransTable.h new file mode 100644 index 00000000..60ba99b4 --- /dev/null +++ b/TransTable.h @@ -0,0 +1,757 @@ +/* + DDS 2.7.0 A bridge double dummy solver. + + Copyright (C) 2006-2014 by Bo Haglund + + Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. + + The code for calculation of par score / contracts is based upon the + + perl code written by Matthew Kidd for ACBLmerge. He has kindly given + + me permission to include a C++ adaptation in DDS. +*/ + + + +/* + Licensed under the Apache License, Version 2.0 (the "License"); + + you may not use this file except in compliance with the License. + + You may obtain a copy of the License at + + + http://www.apache.org/licenses/LICENSE-2.0 + + + Unless required by applicable law or agreed to in writing, software + + distributed under the License is distributed on an "AS IS" BASIS, + + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + + implied. See the License for the specific language governing + + permissions and limitations under the License. +*/ + + + +/* + This object, TransTable, was was written by Søren Hein. + + Many thanks for allowing me to include it in DDS. + + + It is an object for managing transposition tables and the + + associated memory. +*/ + + + + +#ifndef _DDS_TRANSTABLES + +#define _DDS_TRANSTABLES + + +#include + +#include + +#include + +#include "dll.h" + +#include "dds.h" + + + + +#define NUM_PAGES_DEFAULT 15 + +#define NUM_PAGES_MAXIMUM 25 + +#define BLOCKS_PER_PAGE 1000 + +#define DISTS_PER_ENTRY 32 + +#define BLOCKS_PER_ENTRY 125 + +#define FIRST_HARVEST_TRICK 8 + +#define HARVEST_AGE 10000 + + +#define TT_BYTES 4 + +#define TT_TRICKS 12 + + +#define TT_LINE_LEN 20 + + +#define TT_PERCENTILE 0.9 + + +#define HISTSIZE 100000 + + + + +struct nodeCardsType // 8 bytes + +{ + char ubound; // For N-S + + char lbound; // For N-S + + char bestMoveSuit; + + char bestMoveRank; + + char leastWin[DDS_SUITS]; + +}; + + + + +// Not clear to me why I can't put the following structs in + +// the private part of the class as well. But for some reason + +// compilation fails then. + + + +struct winMatchType // 52 bytes + +{ + + int xorSet; + + int topSet1 , topSet2 , topSet3 , topSet4 ; + + int topMask1, topMask2, topMask3, topMask4; + + int maskIndex; + + int lastMaskNo; + + nodeCardsType first; + +}; + + + +struct winBlockType // 6508 bytes when BLOCKS_PER_ENTRY == 125 + +{ + + int nextMatchNo; + + int nextWriteNo; + + // int timestampWrite; + + int timestampRead; + + winMatchType list[BLOCKS_PER_ENTRY]; + +}; + + + + + +class TransTable + +{ + + private: + + + + struct posSearchType // 16 bytes (inefficiency, 12 bytes enough) + + { + + winBlockType * posBlock; + + long long key; + + }; + + + + struct distHashType // 520 bytes when DISTS_PER_ENTRY == 32 + + { + + int nextNo; + + int nextWriteNo; + + posSearchType list[DISTS_PER_ENTRY]; + + }; + + + + struct aggrType // 80 bytes + + { + + int aggrRanks[DDS_SUITS]; + + int aggrBytes[DDS_SUITS][TT_BYTES]; + + }; + + + + struct poolType // 16 bytes + + { + poolType * next; + + poolType * prev; + + int nextBlockNo; + + winBlockType * list; + + }; + + + + struct pageStatsType + + { + + int numResets, + + numCallocs, + + numFrees, + + numHarvests, + + lastCurrent; + + }; + + + + struct harvestedType // 16 bytes + + { + + int nextBlockNo; + + winBlockType * list [BLOCKS_PER_PAGE]; + + }; + + + + enum memStateType + + { + + FROM_POOL, + + FROM_HARVEST + + }; + + memStateType memState; + + + + int timestamp; + + + + int pagesDefault, + + pagesCurrent, + + pagesMaximum; + + + + int harvestTrick, + + harvestHand; + + +pageStatsType pageStats; + + + + + + // aggr is constant for a given hand. + + aggrType aggr[8192]; // 64 KB + + + + // This is the real transposition table. + + // The last index is the hash. + + // 6240 KB with above assumptions + + // distHashType TTroot[TT_TRICKS][DDS_HANDS][256]; + + + distHashType * TTroot[TT_TRICKS][DDS_HANDS]; + + + + int TTInUse; + + + + // It is useful to remember the last block we looked at. + + winBlockType * lastBlockSeen[TT_TRICKS][DDS_HANDS]; + + + + // The pool of card entries for a given suit distribution. + + poolType * poolp; + + winBlockType * nextBlockp; + + harvestedType harvested; + + + + + void InitTT(); + + + void ReleaseTT(); + + + void SetConstants(); + + + int hash8(int * handDist); + + + // int BlocksInUse(); + + + + winBlockType * GetNextCardBlock(); + + + + winBlockType * LookupSuit( + + distHashType * dp, + + long long key, + + bool * empty); + + + + + nodeCardsType * LookupCards( + + winMatchType * searchp, + + winBlockType * bp, + + int limit, + + bool * lowerFlag); + + + + void CreateOrUpdate( + + winBlockType * bp, + + winMatchType * searchp, + + bool flag); + + + + bool Harvest(); + + + + // Debug + + + + FILE * fp; + + + char fname[TT_LINE_LEN]; + + + + // Really the maximum of BLOCKS_PER_ENTRY and DISTS_PER_ENTRY + + int suitHist[BLOCKS_PER_ENTRY+1], + + suitWraps; + + + + void KeyToDist( + + long long key, + + int trick, + + int handDist[]); + + + + void DistToLengths( + + int trick, + + int handDist[], + + unsigned char lengths[DDS_HANDS][DDS_SUITS]); + + + + void LenToStr( + + unsigned char lengths[DDS_HANDS][DDS_SUITS], + + char * line); + + + + void MakeHistStats( + + int hist[], + + int * count, + + int * prod_sum, + + int * prod_sumsq, + + int * max_len, + + int last_index); + + + + int CalcPercentile( + + int hist[], + + double threshold, + + int last_index); + + + + void PrintHist( + + int hist[], + + int num_wraps, + + int last_index); + + + + void UpdateSuitHist( + + int trick, + + int hand, + + int hist[], + + int * num_wraps); + + + + winBlockType * FindMatchingDist( + + int trick, + + int hand, + + int handDistSought[DDS_HANDS]); + + + + void PrintEntriesBlock( + + winBlockType * bp, + + unsigned char lengths[DDS_HANDS][DDS_SUITS]); + + + void UpdateEntryHist( + + int trick, + + int hand, + + int hist[], + + int * num_wraps); + + + + int EffectOfBlockBound( + + int hist[], + + int size); + + + + void PrintNodeValues( + + nodeCardsType * np); + + + + void PrintMatch( + + winMatchType * wp, + + unsigned char lengths[DDS_HANDS][DDS_SUITS]); + + + + void MakeHolding( + + char * high, + + int len, + char * res); + + + + void DumpHands( + + char hands[DDS_SUITS][DDS_HANDS][TT_LINE_LEN], + + unsigned char lengths[DDS_HANDS][DDS_SUITS]); + + + + void SetToPartialHands( + + int set, + + int mask, + + int maxRank, + + int numRanks, + + char hands[DDS_SUITS][DDS_HANDS][TT_LINE_LEN], + + int used[DDS_SUITS][DDS_HANDS]); + + + + + public: + + TransTable(); + + + + ~TransTable(); + + + + void Init(int handLookup[][15]); + + + + void SetMemoryDefault(int megabytes); + + + + void SetMemoryMaximum(int megabytes); + + + + void MakeTT(); + + void ResetMemory(); + + + + void ReturnAllMemory(); + + + + double MemoryInUse(); + + + + nodeCardsType * Lookup( + + int trick, + + int hand, + + unsigned short * aggrTarget, + + int * handDist, + + int limit, + bool * lowerFlag); + + + + void Add( + + int trick, + + int hand, + + unsigned short * aggrTarget, + + unsigned short * winRanks, + + nodeCardsType * first, + + bool flag); + + + + // Debug functions + + + + void SetFile( + char * fname); + + + +void PrintSuits( + + int trick, + + int hand); + + + + void PrintAllSuits(); + + + + void PrintSuitStats( + + int trick, + + int hand); + + + + void PrintAllSuitStats(); + + + + void PrintSummarySuitStats(); + + + + // Examples: + + // int hd[DDS_HANDS] = { 0x0342, 0x0334, 0x0232, 0x0531 }; + + // thrp->transTable.PrintEntriesDist(11, 1, hd); + + // unsigned short ag[DDS_HANDS] = + + // { 0x1fff, 0x1fff, 0x0f75, 0x1fff }; + + // thrp->transTable.PrintEntriesDistAndCards(11, 1, ag, hd); + + + + void PrintEntriesDist( + + int trick, + + int hand, + + int handDist[DDS_HANDS]); + + + + void PrintEntriesDistAndCards( + + int trick, + + int hand, + + unsigned short * aggrTarget, + + int handDist[DDS_HANDS]); + + + + void PrintEntries( + + int trick, + + int hand); + + + + void PrintAllEntries(); + + + + void PrintEntryStats( + + int trick, + + int hand); + + + + void PrintAllEntryStats(); + + + + void PrintSummaryEntryStats(); + + + + void PrintPageSummary(); + + + + + // Could also be made private, see above. + + + int BlocksInUse(); + +}; + + + +#endif diff --git a/dds.cpp b/dds.cpp index ac326ba9..30c31775 100755 --- a/dds.cpp +++ b/dds.cpp @@ -1,117 +1,74 @@ +/* + DDS 2.7.0 A bridge double dummy solver. + Copyright (C) 2006-2014 by Bo Haglund + Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. + The code for calculation of par score / contracts is based upon the + perl code written by Matthew Kidd for ACBLmerge. He has kindly given + permission to include a C++ adaptation in DDS. + + The PlayAnalyser analyses the played cards of the deal and presents + their double dummy values. The par calculation function DealerPar + provides an alternative way of calculating and presenting par + results. Both these functions have been written by Soren Hein. + He has also made numerous contributions to the code, especially in + the initialization part. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ -/* DDS 2.6.0 A bridge double dummy solver. */ -/* Copyright (C) 2006-2014 by Bo Haglund */ -/* Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. */ -/* The code for calculation of par score / contracts is based upon the */ -/* perl code written by Matthew Kidd for ACBLmerge. He has kindly given me */ -/* permission to include a C++ adaptation in DDS. */ -/* */ -/* The PlayAnalyser analyses the played cards of the deal and presents their */ -/* double dummy values. The par calculation function DealerPar provides an */ -/* alternative way of calculating and presenting par results. */ -/* Both these functions have been written by Soren Hein. */ -/* He has also made numerous contributions to the code, especially in the */ -/* initialization part. */ -/* */ -/* Licensed under the Apache License, Version 2.0 (the "License"); */ -/* you may not use this file except in compliance with the License. */ -/* You may obtain a copy of the License at */ -/* http://www.apache.org/licenses/LICENSE-2.0 */ -/* Unless required by applicable law or agreed to in writing, software */ -/* distributed under the License is distributed on an "AS IS" BASIS, */ -/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */ -/* See the License for the specific language governing permissions and */ -/* limitations under the License. */ - - -/*#include "stdafx.h"*/ #include "dll.h" #include "dds.h" -#include "Par.h" - -struct localVarType * localVar; - -int max_lower; -struct relRanksType * relRanks; -int * counttable; -int * highestRank; -int lho[4]; -int rho[4]; -int partner[4]; -unsigned short int bitMapRank[16]; -unsigned char cardRank[15]; -unsigned char cardSuit[5]; -unsigned char cardHand[4]; -void InitStart(int gb_ram, int ncores); - -#ifdef STAT - FILE * fp2; -#endif +#include "Init.h" -int noOfThreads=MAXNOOFTHREADS; /* The number of entries to the transposition tables. There is - one entry per thread. */ -int noOfCores; /* The number of processor cores, however cannot be higher than noOfThreads. */ - #ifdef _MANAGED #pragma managed(push, off) #endif -void FreeMem(void) { - - if (localVar) - free(localVar); - localVar=NULL; - - #ifdef STAT - fclose(fp2); - #endif - - if (highestRank) - free(highestRank); - highestRank=NULL; - if (counttable) - free(counttable); - counttable=NULL; - if (relRanks) - free(relRanks); - relRanks=NULL; - - return; -} - #if defined(_WIN32) || defined(USES_DLLMAIN) - extern "C" BOOL APIENTRY DllMain(HMODULE hModule, - DWORD ul_reason_for_call, LPVOID lpReserved) { +extern "C" BOOL APIENTRY DllMain(HMODULE hModule, + DWORD ul_reason_for_call, LPVOID lpReserved) +{ - if (ul_reason_for_call==DLL_PROCESS_ATTACH) { - InitStart(0, 0); + if (ul_reason_for_call==DLL_PROCESS_ATTACH) + { + SetMaxThreads(0); } - else if (ul_reason_for_call==DLL_PROCESS_DETACH) { - - FreeMem(); - - /*_CrtDumpMemoryLeaks();*/ /* MEMORY LEAK? */ + else if (ul_reason_for_call==DLL_PROCESS_DETACH) + { + CloseDebugFiles(); + FreeMemory(); +#ifdef DDS_MEMORY_LEAKS_WIN32 + _CrtDumpMemoryLeaks(); +#endif } return 1; } #elif defined(USES_CONSTRUCTOR) -void __attribute__ ((constructor)) libInit(void) { - - InitStart(0, 0); - +void __attribute__ ((constructor)) libInit(void) +{ + SetMaxThreads(0); } -void __attribute__ ((destructor)) libEnd(void) { - - FreeMem(); - +void __attribute__ ((destructor)) libEnd(void) +{ + CloseDebugFiles(); + FreeMemory(); } #endif @@ -120,6039 +77,3 @@ void __attribute__ ((destructor)) libEnd(void) { #pragma managed(pop) #endif - int STDCALL SolveBoard(struct deal dl, int target, - int solutions, int mode, struct futureTricks *futp, int threadIndex) { - - int k, n, cardCount, found, totalTricks, tricks, last, checkRes; - int g, upperbound, lowerbound, first, i, j, h, forb, ind, flag, noMoves; - int noStartMoves; - int handRelFirst; - int noOfCardsPerHand[4]; - int latestTrickSuit[4]; - int latestTrickRank[4]; - int maxHand=0, maxSuit=0, maxRank; - unsigned short int aggrRemain; - struct movePlyType temp; - struct moveType mv; - int hiwinSetSize=0, hinodeSetSize=0; - int hilenSetSize=0; - int MaxnodeSetSize=0; - int MaxwinSetSize=0; - int MaxlenSetSize=0; - struct localVarType * thrp = &localVar[threadIndex]; - - void InitGame(int gameNo, int moveTreeFlag, int first, int handRelFirst, - struct localVarType * thrp); - void InitSearch(struct pos * posPoint, int depth, struct moveType startMoves[], - int first, int mtd, struct localVarType * thrp); - - if ((threadIndex<0)||(threadIndex>=noOfThreads)) { /* Fault corrected after suggestion by Dirk Willecke. */ - DumpInput(RETURN_THREAD_INDEX, dl, target, solutions, mode); - return RETURN_THREAD_INDEX; - } - - for (k=0; k<=13; k++) { - thrp->forbiddenMoves[k].rank=0; - thrp->forbiddenMoves[k].suit=0; - } - - if (target<-1) { - DumpInput(RETURN_TARGET_WRONG_LO, dl, target, solutions, mode); - return RETURN_TARGET_WRONG_LO; - } - if (target>13) { - DumpInput(RETURN_TARGET_WRONG_HI, dl, target, solutions, mode); - return RETURN_TARGET_WRONG_HI; - } - if (solutions<1) { - DumpInput(RETURN_SOLNS_WRONG_LO, dl, target, solutions, mode); - return RETURN_SOLNS_WRONG_LO; - } - if (solutions>3) { - DumpInput(RETURN_SOLNS_WRONG_HI, dl, target, solutions, mode); - return RETURN_SOLNS_WRONG_HI; - } - - for (k=0; k<=3; k++) - noOfCardsPerHand[handId(dl.first, k)]=0; - - - for (k=0; k<=2; k++) { - if (dl.currentTrickRank[k]!=0) { - noOfCardsPerHand[handId(dl.first, k)]=1; - aggrRemain=0; - for (h=0; h<=3; h++) - aggrRemain|=(dl.remainCards[h][dl.currentTrickSuit[k]]>>2); - if ((aggrRemain & bitMapRank[dl.currentTrickRank[k]])!=0) { - DumpInput(RETURN_PLAYED_CARD, dl, target, solutions, mode); - return RETURN_PLAYED_CARD; - } - } - } - - if (target==-1) - thrp->tricksTarget=99; - else - thrp->tricksTarget=target; - - thrp->newDeal=FALSE; thrp->newTrump=FALSE; - thrp->diffDeal=0; thrp->aggDeal=0; - cardCount=0; - for (i=0; i<=3; i++) { - for (j=0; j<=3; j++) { - cardCount+=counttable[dl.remainCards[i][j]>>2]; - thrp->diffDeal+=((dl.remainCards[i][j]>>2)^ - (thrp->game.suit[i][j])); - thrp->aggDeal+=(dl.remainCards[i][j]>>2); - if (thrp->game.suit[i][j]!=dl.remainCards[i][j]>>2) { - thrp->game.suit[i][j]=dl.remainCards[i][j]>>2; - thrp->newDeal=TRUE; - } - } - } - - if (thrp->newDeal) { - if (thrp->diffDeal==0) - thrp->similarDeal=TRUE; - else if ((thrp->aggDeal/thrp->diffDeal) - > SIMILARDEALLIMIT) - thrp->similarDeal=TRUE; - else - thrp->similarDeal=FALSE; - } - else - thrp->similarDeal=FALSE; - - if (dl.trump!=thrp->trump) - thrp->newTrump=TRUE; - - for (i=0; i<=3; i++) - for (j=0; j<=3; j++) - noOfCardsPerHand[i]+=counttable[thrp->game.suit[i][j]]; - - for (i=1; i<=3; i++) { - if (noOfCardsPerHand[i]!=noOfCardsPerHand[0]) { - DumpInput(RETURN_CARD_COUNT, dl, target, solutions, mode); - return RETURN_CARD_COUNT; - } - } - - if (dl.currentTrickRank[2]) { - if ((dl.currentTrickRank[2]<2)||(dl.currentTrickRank[2]>14) - ||(dl.currentTrickSuit[2]<0)||(dl.currentTrickSuit[2]>3)) { - DumpInput(RETURN_SUIT_OR_RANK, dl, target, solutions, mode); - return RETURN_SUIT_OR_RANK; - } - thrp->handToPlay=handId(dl.first, 3); - handRelFirst=3; - noStartMoves=3; - if (cardCount<=4) { - for (k=0; k<=3; k++) { - if (thrp->game.suit[thrp->handToPlay][k]!=0) { - latestTrickSuit[thrp->handToPlay]=k; - latestTrickRank[thrp->handToPlay]= - InvBitMapRank(thrp->game.suit[thrp->handToPlay][k]); - break; - } - } - latestTrickSuit[handId(dl.first, 2)]=dl.currentTrickSuit[2]; - latestTrickRank[handId(dl.first, 2)]=dl.currentTrickRank[2]; - latestTrickSuit[handId(dl.first, 1)]=dl.currentTrickSuit[1]; - latestTrickRank[handId(dl.first, 1)]=dl.currentTrickRank[1]; - latestTrickSuit[dl.first]=dl.currentTrickSuit[0]; - latestTrickRank[dl.first]=dl.currentTrickRank[0]; - } - } - else if (dl.currentTrickRank[1]) { - if ((dl.currentTrickRank[1]<2)||(dl.currentTrickRank[1]>14) - ||(dl.currentTrickSuit[1]<0)||(dl.currentTrickSuit[1]>3)) { - DumpInput(RETURN_SUIT_OR_RANK, dl, target, solutions, mode); - return RETURN_SUIT_OR_RANK; - } - thrp->handToPlay=handId(dl.first, 2); - handRelFirst=2; - noStartMoves=2; - if (cardCount<=4) { - for (k=0; k<=3; k++) { - if (thrp->game.suit[thrp->handToPlay][k]!=0) { - latestTrickSuit[thrp->handToPlay]=k; - latestTrickRank[thrp->handToPlay]= - InvBitMapRank(thrp->game.suit[thrp->handToPlay][k]); - break; - } - } - for (k=0; k<=3; k++) { - if (thrp->game.suit[handId(dl.first, 3)][k]!=0) { - latestTrickSuit[handId(dl.first, 3)]=k; - latestTrickRank[handId(dl.first, 3)]= - InvBitMapRank(thrp->game.suit[handId(dl.first, 3)][k]); - break; - } - } - latestTrickSuit[handId(dl.first, 1)]=dl.currentTrickSuit[1]; - latestTrickRank[handId(dl.first, 1)]=dl.currentTrickRank[1]; - latestTrickSuit[dl.first]=dl.currentTrickSuit[0]; - latestTrickRank[dl.first]=dl.currentTrickRank[0]; - } - } - else if (dl.currentTrickRank[0]) { - if ((dl.currentTrickRank[0]<2)||(dl.currentTrickRank[0]>14) - ||(dl.currentTrickSuit[0]<0)||(dl.currentTrickSuit[0]>3)) { - DumpInput(RETURN_SUIT_OR_RANK, dl, target, solutions, mode); - return RETURN_SUIT_OR_RANK; - } - thrp->handToPlay=handId(dl.first,1); - handRelFirst=1; - noStartMoves=1; - if (cardCount<=4) { - for (k=0; k<=3; k++) { - if (thrp->game.suit[thrp->handToPlay][k]!=0) { - latestTrickSuit[thrp->handToPlay]=k; - latestTrickRank[thrp->handToPlay]= - InvBitMapRank(thrp->game.suit[thrp->handToPlay][k]); - break; - } - } - for (k=0; k<=3; k++) { - if (thrp->game.suit[handId(dl.first, 3)][k]!=0) { - latestTrickSuit[handId(dl.first, 3)]=k; - latestTrickRank[handId(dl.first, 3)]= - InvBitMapRank(thrp->game.suit[handId(dl.first, 3)][k]); - break; - } - } - for (k=0; k<=3; k++) { - if (thrp->game.suit[handId(dl.first, 2)][k]!=0) { - latestTrickSuit[handId(dl.first, 2)]=k; - latestTrickRank[handId(dl.first, 2)]= - InvBitMapRank(thrp->game.suit[handId(dl.first, 2)][k]); - break; - } - } - latestTrickSuit[dl.first]=dl.currentTrickSuit[0]; - latestTrickRank[dl.first]=dl.currentTrickRank[0]; - } - } - else { - thrp->handToPlay=dl.first; - handRelFirst=0; - noStartMoves=0; - if (cardCount<=4) { - for (k=0; k<=3; k++) { - if (thrp->game.suit[thrp->handToPlay][k]!=0) { - latestTrickSuit[thrp->handToPlay]=k; - latestTrickRank[thrp->handToPlay]= - InvBitMapRank(thrp->game.suit[thrp->handToPlay][k]); - break; - } - } - for (k=0; k<=3; k++) { - if (thrp->game.suit[handId(dl.first, 3)][k]!=0) { - latestTrickSuit[handId(dl.first, 3)]=k; - latestTrickRank[handId(dl.first, 3)]= - InvBitMapRank(thrp->game.suit[handId(dl.first, 3)][k]); - break; - } - } - for (k=0; k<=3; k++) { - if (thrp->game.suit[handId(dl.first, 2)][k]!=0) { - latestTrickSuit[handId(dl.first, 2)]=k; - latestTrickRank[handId(dl.first, 2)]= - InvBitMapRank(thrp->game.suit[handId(dl.first, 2)][k]); - break; - } - } - for (k=0; k<=3; k++) { - if (thrp->game.suit[handId(dl.first, 1)][k]!=0) { - latestTrickSuit[handId(dl.first, 1)]=k; - latestTrickRank[handId(dl.first, 1)]= - InvBitMapRank(thrp->game.suit[handId(dl.first, 1)][k]); - break; - } - } - } - } - - thrp->trump=dl.trump; - thrp->game.first=dl.first; - first=dl.first; - thrp->game.noOfCards=cardCount; - if (dl.currentTrickRank[0]!=0) { - thrp->game.leadHand=dl.first; - thrp->game.leadSuit=dl.currentTrickSuit[0]; - thrp->game.leadRank=dl.currentTrickRank[0]; - } - else { - thrp->game.leadHand=0; - thrp->game.leadSuit=0; - thrp->game.leadRank=0; - } - - for (k=0; k<=2; k++) { - thrp->initialMoves[k].suit=255; - thrp->initialMoves[k].rank=255; - } - - for (k=0; kinitialMoves[noStartMoves-1-k].suit=dl.currentTrickSuit[k]; - thrp->initialMoves[noStartMoves-1-k].rank=dl.currentTrickRank[k]; - } - - if (cardCount % 4) - totalTricks=((cardCount-4)>>2)+2; - else - totalTricks=((cardCount-4)>>2)+1; - checkRes=CheckDeal(&localVar[threadIndex].cd, threadIndex); - if (thrp->game.noOfCards<=0) { - DumpInput(RETURN_ZERO_CARDS, dl, target, solutions, mode); - return RETURN_ZERO_CARDS; - } - if (thrp->game.noOfCards>52) { - DumpInput(RETURN_TOO_MANY_CARDS, dl, target, solutions, mode); - return RETURN_TOO_MANY_CARDS; - } - if (totalTricksmaxRank)) { - maxRank=latestTrickRank[k]; - maxSuit=dl.trump; - maxHand=k; - } - } - } - /* Highest card in leading suit */ - if (maxRank==0) { - for (k=0; k<=3; k++) { - if (k==dl.first) { - maxSuit=latestTrickSuit[dl.first]; - maxHand=dl.first; - maxRank=latestTrickRank[dl.first]; - break; - } - } - for (k=0; k<=3; k++) { - if ((k!=dl.first)&&(latestTrickSuit[k]==maxSuit)&& - (latestTrickRank[k]>maxRank)) { - maxHand=k; - maxRank=latestTrickRank[k]; - } - } - } - futp->nodes=0; - futp->cards=1; - futp->suit[0]=latestTrickSuit[thrp->handToPlay]; - futp->rank[0]=latestTrickRank[thrp->handToPlay]; - futp->equals[0]=0; - if ((target==0)&&(solutions<3)) - futp->score[0]=0; - else if ((thrp->handToPlay==maxHand)|| - (partner[thrp->handToPlay]==maxHand)) - futp->score[0]=1; - else - futp->score[0]=0; - - /*_CrtDumpMemoryLeaks();*/ /* MEMORY LEAK? */ - return RETURN_NO_FAULT; - } - - if ((mode!=2)&& - (((thrp->newDeal)&&(!(thrp->similarDeal))) - || thrp->newTrump || - (thrp->winSetSize > SIMILARMAXWINNODES))) { - - Wipe(&localVar[threadIndex]); - thrp->winSetSizeLimit=WINIT; - thrp->nodeSetSizeLimit=NINIT; - thrp->lenSetSizeLimit=LINIT; - thrp->allocmem=(WINIT+1)*sizeof(struct winCardType); - thrp->allocmem+=(NINIT+1)*sizeof(struct nodeCardsType); - thrp->allocmem+=(LINIT+1)*sizeof(struct posSearchType); - thrp->winCards=thrp->pw[0]; - thrp->nodeCards=thrp->pn[0]; - thrp->posSearch=thrp->pl[0]; - thrp->wcount=0; thrp->ncount=0; thrp->lcount=0; - InitGame(0, FALSE, first, handRelFirst, thrp); - } - else { - InitGame(0, TRUE, first, handRelFirst, thrp); - } - - #ifdef STAT - thrp->nodes=0; - #endif - thrp->trickNodes=0; - thrp->iniDepth=cardCount-4; - hiwinSetSize=0; - hinodeSetSize=0; - - if (mode==0) { - MoveGen(&(thrp->lookAheadPos), thrp->iniDepth, thrp->trump, - &(thrp->movePly[thrp->iniDepth]), thrp); - if (thrp->movePly[thrp->iniDepth].last==0) { - futp->nodes=0; - futp->cards=1; - futp->suit[0]=thrp->movePly[thrp->iniDepth].move[0].suit; - futp->rank[0]=thrp->movePly[thrp->iniDepth].move[0].rank; - futp->equals[0]=thrp->movePly[thrp->iniDepth].move[0].sequence<<2; - futp->score[0]=-2; - - /*_CrtDumpMemoryLeaks();*/ /* MEMORY LEAK? */ - return RETURN_NO_FAULT; - } - } - if ((target==0)&&(solutions<3)) { - MoveGen(&(thrp->lookAheadPos), thrp->iniDepth, thrp->trump, - &(thrp->movePly[thrp->iniDepth]), thrp); - futp->nodes=0; - for (k=0; k<=thrp->movePly[thrp->iniDepth].last; k++) { - futp->suit[k]=thrp->movePly[thrp->iniDepth].move[k].suit; - futp->rank[k]=thrp->movePly[thrp->iniDepth].move[k].rank; - futp->equals[k]=thrp->movePly[thrp->iniDepth].move[k].sequence<<2; - futp->score[k]=0; - } - if (solutions==1) - futp->cards=1; - else - futp->cards=thrp->movePly[thrp->iniDepth].last+1; - - /*_CrtDumpMemoryLeaks(); */ /* MEMORY LEAK? */ - return RETURN_NO_FAULT; - } - - if ((target!=-1)&&(solutions!=3)) { - thrp->val=ABsearch(&(thrp->lookAheadPos), - thrp->tricksTarget, thrp->iniDepth, thrp); - - temp=thrp->movePly[thrp->iniDepth]; - last=thrp->movePly[thrp->iniDepth].last; - noMoves=last+1; - hiwinSetSize=thrp->winSetSize; - hinodeSetSize=thrp->nodeSetSize; - hilenSetSize=thrp->lenSetSize; - if (thrp->nodeSetSize>MaxnodeSetSize) - MaxnodeSetSize=thrp->nodeSetSize; - if (thrp->winSetSize>MaxwinSetSize) - MaxwinSetSize=thrp->winSetSize; - if (thrp->lenSetSize>MaxlenSetSize) - MaxlenSetSize=thrp->lenSetSize; - if (thrp->val==1) - thrp->payOff=thrp->tricksTarget; - else - thrp->payOff=0; - futp->cards=1; - ind=2; - - if (thrp->payOff<=0) { - futp->suit[0]=thrp->movePly[thrp->game.noOfCards-4].move[0].suit; - futp->rank[0]=thrp->movePly[thrp->game.noOfCards-4].move[0].rank; - futp->equals[0]=(thrp->movePly[thrp->game.noOfCards-4].move[0].sequence)<<2; - if (thrp->tricksTarget>1) - futp->score[0]=-1; - else - futp->score[0]=0; - } - else { - futp->suit[0]=thrp->bestMove[thrp->game.noOfCards-4].suit; - futp->rank[0]=thrp->bestMove[thrp->game.noOfCards-4].rank; - futp->equals[0]=(thrp->bestMove[thrp->game.noOfCards-4].sequence)<<2; - futp->score[0]=thrp->payOff; - } - } - else { - g=thrp->estTricks[thrp->handToPlay]; - upperbound=13; - lowerbound=0; - do { - if (g==lowerbound) - tricks=g+1; - else - tricks=g; - assert((thrp->lookAheadPos.handRelFirst>=0)&& - (thrp->lookAheadPos.handRelFirst<=3)); - thrp->val=ABsearch(&(thrp->lookAheadPos), tricks, thrp->iniDepth, thrp); - - if (thrp->val==TRUE) - mv=thrp->bestMove[thrp->game.noOfCards-4]; - hiwinSetSize=Max(hiwinSetSize, thrp->winSetSize); - hinodeSetSize=Max(hinodeSetSize, thrp->nodeSetSize); - hilenSetSize=Max(hilenSetSize, thrp->lenSetSize); - if (thrp->nodeSetSize>MaxnodeSetSize) - MaxnodeSetSize=thrp->nodeSetSize; - if (thrp->winSetSize>MaxwinSetSize) - MaxwinSetSize=thrp->winSetSize; - if (thrp->lenSetSize>MaxlenSetSize) - MaxlenSetSize=thrp->lenSetSize; - if (thrp->val==FALSE) { - upperbound=tricks-1; - g=upperbound; - } - else { - lowerbound=tricks; - g=lowerbound; - } - InitSearch(&(thrp->iniPosition), thrp->game.noOfCards-4, - thrp->initialMoves, first, TRUE, thrp); - } - while (lowerboundpayOff=g; - temp=thrp->movePly[thrp->iniDepth]; - last=thrp->movePly[thrp->iniDepth].last; - noMoves=last+1; - ind=2; - thrp->bestMove[thrp->game.noOfCards-4]=mv; - futp->cards=1; - if (thrp->payOff<=0) { - futp->score[0]=0; - futp->suit[0]=thrp->movePly[thrp->game.noOfCards-4].move[0].suit; - futp->rank[0]=thrp->movePly[thrp->game.noOfCards-4].move[0].rank; - futp->equals[0]=(thrp->movePly[thrp->game.noOfCards-4].move[0].sequence)<<2; - } - else { - futp->score[0]=thrp->payOff; - futp->suit[0]=thrp->bestMove[thrp->game.noOfCards-4].suit; - futp->rank[0]=thrp->bestMove[thrp->game.noOfCards-4].rank; - futp->equals[0]=(thrp->bestMove[thrp->game.noOfCards-4].sequence)<<2; - } - thrp->tricksTarget=thrp->payOff; - } - - if ((solutions==2)&&(thrp->payOff>0)) { - forb=1; - ind=forb; - while ((thrp->payOff==thrp->tricksTarget)&&(ind<(temp.last+1))) { - thrp->forbiddenMoves[forb].suit=thrp->bestMove[thrp->game.noOfCards-4].suit; - thrp->forbiddenMoves[forb].rank=thrp->bestMove[thrp->game.noOfCards-4].rank; - forb++; ind++; - /* All moves before bestMove in the move list shall be - moved to the forbidden moves list, since none of them reached - the target */ - for (k=0; k<=thrp->movePly[thrp->iniDepth].last; k++) - if ((thrp->bestMove[thrp->iniDepth].suit== - thrp->movePly[thrp->iniDepth].move[k].suit) - &&(thrp->bestMove[thrp->iniDepth].rank== - thrp->movePly[thrp->iniDepth].move[k].rank)) - break; - for (i=0; imovePly[thrp->iniDepth].move[i].suit==thrp->forbiddenMoves[j].suit) - &&(thrp->movePly[thrp->iniDepth].move[i].rank==thrp->forbiddenMoves[j].rank)) { - /* If the move is already in the forbidden list */ - flag=TRUE; - break; - } - } - if (!flag) { - thrp->forbiddenMoves[forb]=thrp->movePly[thrp->iniDepth].move[i]; - forb++; - } - } - InitSearch(&(thrp->iniPosition), thrp->game.noOfCards-4, - thrp->initialMoves, first, TRUE, thrp); - thrp->val=ABsearch(&(thrp->lookAheadPos), thrp->tricksTarget, - thrp->iniDepth, thrp); - - hiwinSetSize=thrp->winSetSize; - hinodeSetSize=thrp->nodeSetSize; - hilenSetSize=thrp->lenSetSize; - if (thrp->nodeSetSize>MaxnodeSetSize) - MaxnodeSetSize=thrp->nodeSetSize; - if (thrp->winSetSize>MaxwinSetSize) - MaxwinSetSize=localVar[threadIndex].winSetSize; - if (thrp->lenSetSize>MaxlenSetSize) - MaxlenSetSize=localVar[threadIndex].lenSetSize; - if (thrp->val==TRUE) { - thrp->payOff=thrp->tricksTarget; - futp->cards=ind; - futp->suit[ind-1]=thrp->bestMove[thrp->game.noOfCards-4].suit; - futp->rank[ind-1]=thrp->bestMove[thrp->game.noOfCards-4].rank; - futp->equals[ind-1]=(thrp->bestMove[thrp->game.noOfCards-4].sequence)<<2; - futp->score[ind-1]=thrp->payOff; - } - else - thrp->payOff=0; - } - } - else if ((solutions==2)&&(thrp->payOff==0)&& - ((target==-1)||(thrp->tricksTarget==1))) { - futp->cards=noMoves; - /* Find the cards that were in the initial move list - but have not been listed in the current result */ - n=0; - for (i=0; isuit[0])&& - (temp.move[i].rank==futp->rank[0])) { - found=TRUE; - } - if (!found) { - futp->suit[1+n]=temp.move[i].suit; - futp->rank[1+n]=temp.move[i].rank; - futp->equals[1+n]=(temp.move[i].sequence)<<2; - futp->score[1+n]=0; - n++; - } - } - } - - if ((solutions==3)&&(thrp->payOff>0)) { - forb=1; - ind=forb; - for (i=0; iforbiddenMoves[forb].suit=thrp->bestMove[thrp->game.noOfCards-4].suit; - thrp->forbiddenMoves[forb].rank=thrp->bestMove[thrp->game.noOfCards-4].rank; - forb++; ind++; - - g=thrp->payOff; - upperbound=thrp->payOff; - lowerbound=0; - - InitSearch(&(thrp->iniPosition), thrp->game.noOfCards-4, - thrp->initialMoves, first, TRUE, thrp); - do { - if (g==lowerbound) - tricks=g+1; - else - tricks=g; - assert((thrp->lookAheadPos.handRelFirst>=0)&& - (thrp->lookAheadPos.handRelFirst<=3)); - thrp->val=ABsearch(&(thrp->lookAheadPos), tricks, thrp->iniDepth, thrp); - - if (thrp->val==TRUE) - mv=thrp->bestMove[thrp->game.noOfCards-4]; - hiwinSetSize=Max(hiwinSetSize, thrp->winSetSize); - hinodeSetSize=Max(hinodeSetSize, thrp->nodeSetSize); - hilenSetSize=Max(hilenSetSize, thrp->lenSetSize); - if (thrp->nodeSetSize>MaxnodeSetSize) - MaxnodeSetSize=thrp->nodeSetSize; - if (thrp->winSetSize>MaxwinSetSize) - MaxwinSetSize=thrp->winSetSize; - if (thrp->lenSetSize>MaxlenSetSize) - MaxlenSetSize=thrp->lenSetSize; - if (thrp->val==FALSE) { - upperbound=tricks-1; - g=upperbound; - } - else { - lowerbound=tricks; - g=lowerbound; - } - - InitSearch(&(thrp->iniPosition), thrp->game.noOfCards-4, - thrp->initialMoves, first, TRUE, thrp); - } - while (lowerboundpayOff=g; - if (thrp->payOff==0) { - last=thrp->movePly[thrp->iniDepth].last; - futp->cards=temp.last+1; - for (j=0; j<=last; j++) { - futp->suit[ind-1+j]=thrp->movePly[thrp->game.noOfCards-4].move[j].suit; - futp->rank[ind-1+j]=thrp->movePly[thrp->game.noOfCards-4].move[j].rank; - futp->equals[ind-1+j]=(thrp->movePly[thrp->game.noOfCards-4].move[j].sequence)<<2; - futp->score[ind-1+j]=thrp->payOff; - } - break; - } - else { - thrp->bestMove[thrp->game.noOfCards-4]=mv; - - futp->cards=ind; - futp->suit[ind-1]=thrp->bestMove[thrp->game.noOfCards-4].suit; - futp->rank[ind-1]=thrp->bestMove[thrp->game.noOfCards-4].rank; - futp->equals[ind-1]=(thrp->bestMove[thrp->game.noOfCards-4].sequence)<<2; - futp->score[ind-1]=thrp->payOff; - } - } - } - else if ((solutions==3)&&(thrp->payOff==0)) { - futp->cards=noMoves; - /* Find the cards that were in the initial move list - but have not been listed in the current result */ - n=0; - for (i=0; isuit[0])&& - (temp.move[i].rank==futp->rank[0])) { - found=TRUE; - } - if (!found) { - futp->suit[1+n]=temp.move[i].suit; - futp->rank[1+n]=temp.move[i].rank; - futp->equals[1+n]=(temp.move[i].sequence)<<2; - futp->score[1+n]=0; - n++; - } - } - } - - for (k=0; k<=13; k++) { - thrp->forbiddenMoves[k].suit=0; - thrp->forbiddenMoves[k].rank=0; - } - - futp->nodes=thrp->trickNodes; - - /*_CrtDumpMemoryLeaks();*/ /* MEMORY LEAK? */ - - return RETURN_NO_FAULT; -} - - -int _initialized=0; - -void InitStart(int gb_ram, int ncores) { - int k, r, i, j, m, ind; - unsigned short int res; - unsigned int topBitRank = 1; - unsigned long long pcmem; /* kbytes */ - - if (_initialized) - return; - _initialized = 1; - - if (gb_ram==0) { /* Autoconfig */ - - #ifdef _WIN32 - - SYSTEM_INFO temp; - - MEMORYSTATUSEX statex; - statex.dwLength = sizeof (statex); - - GlobalMemoryStatusEx (&statex); /* Using GlobalMemoryStatusEx instead of GlobalMemoryStatus - was suggested by Lorne Anderson. */ - - pcmem=(unsigned long long)statex.ullTotalPhys/1024; - - #ifdef DDS_THREADS_SINGLE - - noOfThreads = 1; - - noOfCores = 1; - - #else - - if (pcmem < 1500000) - noOfThreads=Min(MAXNOOFTHREADS, 2); - else if (pcmem < 2500000) - noOfThreads=Min(MAXNOOFTHREADS, 4); - else - noOfThreads=MAXNOOFTHREADS; - - GetSystemInfo(&temp); - noOfCores=Min(noOfThreads, (int)temp.dwNumberOfProcessors); - - #endif - - #endif - #ifdef __linux__ /* The code for linux was suggested by Antony Lee. */ - - #ifdef DDS_THREADS_SINGLE - - noOfThreads = 1; - - noOfCores = 1; - - #else - - ncores = sysconf(_SC_NPROCESSORS_ONLN); - FILE* fifo = popen("free -k | tail -n+3 | head -n1 | awk '{print $NF}'", "r"); - fscanf(fifo, "%lld", &pcmem); - fclose(fifo); - - #endif - #endif - - } - else { - #ifdef DDS_THREADS_SINGLE - - noOfThreads = 1; - - noOfCores = 1; - - #else - - if (gb_ram < 2) - noOfThreads=Min(MAXNOOFTHREADS, 2); - else if (gb_ram < 3) - noOfThreads=Min(MAXNOOFTHREADS, 4); - else - noOfThreads=Min(MAXNOOFTHREADS, 8); - - noOfCores=Min(noOfThreads, ncores); - - #endif - - pcmem=(unsigned long long)(1000000 * gb_ram); - } - - /*printf("noOfThreads: %d noOfCores: %d\n", noOfThreads, noOfCores);*/ - - localVar = (struct localVarType *)calloc(noOfThreads, sizeof(struct localVarType)); - - for (k=0; k=2; r--) { - if ((k & bitMapRank[r])!=0) { - highestRank[k]=r; - break; - } - } - } - - relRanks = (relRanksType *)calloc(1, sizeof(relRanksType)); - - /* The use of the counttable to give the number of bits set to - one in an integer follows an implementation by Thomas Andrews. */ - - counttable = (int *)calloc(8192, sizeof(int)); - if (counttable==NULL) - exit(1); - - for (i=0; i<8192; i++) { - counttable[i]=0; - for (j=0; j<13; j++) { - if (i & (1<=2; r--) { - if ((i & bitMapRank[r])!=0) { - if (k <= j) { - res|=bitMapRank[r]; - k++; - } - else - break; - } - } - for (m=0; mrelRank[0][r] = 0; - - for (ind = 1; ind < 8192; ind++) { - if (ind >= (topBitRank + topBitRank)) /* Next top bit */ - topBitRank <<= 1; - - for (r = 0; r <= 14; r++) - relRanks->relRank[ind][r] = relRanks->relRank[ind ^ topBitRank][r]; - - int ord = 0; - for (r = 14; r >= 2; r--) { - - if ((ind & bitMapRank[r]) != 0) { - ord++; - relRanks->relRank[ind][r] = ord; - } - } - } - - - return; -} - - -void InitGame(int gameNo, int moveTreeFlag, int first, int handRelFirst, - struct localVarType * thrp) { - - int k, s, h, m, ord, r, ind; - unsigned int topBitRank=1; - unsigned int topBitNo=2; - void InitSearch(struct pos * posPoint, int depth, - struct moveType startMoves[], int first, int mtd, - struct localVarType * thrp); - - if (thrp->newDeal) { - - /* Initialization of the abs structure is implemented - according to a solution given by Thomas Andrews */ - - for (k=0; k<=3; k++) - for (m=0; m<=3; m++) - thrp->iniPosition.rankInSuit[k][m]=thrp->game.suit[k][m]; - - for (s=0; s<4; s++) { - thrp->abs[0].aggrRanks[s]=0; - thrp->abs[0].winMask[s]=0; - for (ord=1; ord<=13; ord++) { - thrp->abs[0].absRank[ord][s].hand=-1; - thrp->abs[0].absRank[ord][s].rank=0; - } - } - - int hand_lookup[4][15]; - - /* credit Soren Hein */ - - for (s = 0; s < 4; s++) { - for (r = 14; r >= 2; r--) { - hand_lookup[s][r] = -1; - for (h = 0; h < 4; h++) { - if ((thrp->game.suit[h][s] & bitMapRank[r]) != 0) { - hand_lookup[s][r] = h; - break; - } - } - } - } - - struct absRanksType * absp; - - for (ind=1; ind<8192; ind++) { - if (ind>=(topBitRank+topBitRank)) { - /* Next top bit */ - topBitRank <<=1; - topBitNo++; - } - - thrp->abs[ind] = thrp->abs[ind ^ topBitRank]; - absp = &thrp->abs[ind]; - int weight = counttable[ind]; - for (int c = weight; c >= 2; c--) { - for (int s = 0; s < 4; s++) { - absp->absRank[c][s].hand = absp->absRank[c-1][s].hand; - absp->absRank[c][s].rank = absp->absRank[c-1][s].rank; - } - } - - - for (s = 0; s < 4; s++) { - absp->absRank[1][s].hand = hand_lookup[s][topBitNo]; - absp->absRank[1][s].rank = topBitNo; - absp->aggrRanks[s] = (absp->aggrRanks[s] >> 2) | - (hand_lookup[s][topBitNo] << 24); - absp->winMask[s] = (absp->winMask[s] >> 2) | (3 << 24); - } - } - } - - - thrp->iniPosition.first[thrp->game.noOfCards-4]=first; - thrp->iniPosition.handRelFirst=handRelFirst; - thrp->lookAheadPos=thrp->iniPosition; - - thrp->estTricks[1]=6; - thrp->estTricks[3]=6; - thrp->estTricks[0]=7; - thrp->estTricks[2]=7; - - #ifdef STAT - fprintf(fp2, "Estimated tricks for hand to play:\n"); - fprintf(fp2, "hand=%d est tricks=%d\n", - thrp->handToPlay, thrp->estTricks[thrp->handToPlay]); - #endif - - InitSearch(&(thrp->lookAheadPos), thrp->game.noOfCards-4, - thrp->initialMoves, first, moveTreeFlag, thrp); - return; -} - - -void InitSearch(struct pos * posPoint, int depth, struct moveType startMoves[], - int first, int mtd, struct localVarType * thrp) { - - int s, d, h, handRelFirst, maxAgg, maxHand=0; - int k, noOfStartMoves; /* Number of start moves in the 1st trick */ - int hand[3], suit[3], rank[3]; - struct moveType move; - unsigned short int startMovesBitMap[4][4]; /* Indices are hand and suit */ - unsigned short int aggHand[4][4]; - - for (h=0; h<=3; h++) - for (s=0; s<=3; s++) - startMovesBitMap[h][s]=0; - - handRelFirst=posPoint->handRelFirst; - noOfStartMoves=handRelFirst; - - for (k=0; k<=2; k++) { - hand[k]=handId(first, k); - suit[k]=startMoves[k].suit; - rank[k]=startMoves[k].rank; - if (kbestMove[d].rank=0; - thrp->bestMoveTT[d].rank=0; - } - - if (((handId(first, handRelFirst))==0)|| - ((handId(first, handRelFirst))==2)) { - thrp->nodeTypeStore[0]=MAXNODE; - thrp->nodeTypeStore[1]=MINNODE; - thrp->nodeTypeStore[2]=MAXNODE; - thrp->nodeTypeStore[3]=MINNODE; - } - else { - thrp->nodeTypeStore[0]=MINNODE; - thrp->nodeTypeStore[1]=MAXNODE; - thrp->nodeTypeStore[2]=MINNODE; - thrp->nodeTypeStore[3]=MAXNODE; - } - - k=noOfStartMoves; - posPoint->first[depth]=first; - posPoint->handRelFirst=k; - assert((posPoint->handRelFirst>=0)&&(posPoint->handRelFirst<=3)); - posPoint->tricksMAX=0; - - if (k>0) { - posPoint->move[depth+k]=startMoves[k-1]; - move=startMoves[k-1]; - } - - posPoint->high[depth+k]=first; - - while (k>0) { - thrp->movePly[depth+k].current=0; - thrp->movePly[depth+k].last=0; - thrp->movePly[depth+k].move[0].suit=startMoves[k-1].suit; - thrp->movePly[depth+k].move[0].rank=startMoves[k-1].rank; - if (ktrump)) { - posPoint->move[depth+k].suit=startMoves[k-1].suit; - posPoint->move[depth+k].rank=startMoves[k-1].rank; - posPoint->high[depth+k]=handId(first, noOfStartMoves-k); - move=posPoint->move[depth+k]; - } - else { - posPoint->move[depth+k]=posPoint->move[depth+k+1]; - posPoint->high[depth+k]=posPoint->high[depth+k+1]; - } - } - k--; - } - - for (s=0; s<=3; s++) - posPoint->removedRanks[s]=0; - - for (s=0; s<=3; s++) /* Suit */ - for (h=0; h<=3; h++) /* Hand */ - posPoint->removedRanks[s]|= - posPoint->rankInSuit[h][s]; - for (s=0; s<=3; s++) - posPoint->removedRanks[s]=~(posPoint->removedRanks[s]); - - for (s=0; s<=3; s++) /* Suit */ - for (h=0; h<=3; h++) /* Hand */ - posPoint->removedRanks[s]&= - (~startMovesBitMap[h][s]); - - for (s=0; s<=3; s++) - thrp->iniRemovedRanks[s]=posPoint->removedRanks[s]; - - /*for (d=0; d<=49; d++) { - for (s=0; s<=3; s++) - posPoint->winRanks[d][s]=0; - }*/ - - /* Initialize winning and second best ranks */ - for (s=0; s<=3; s++) { - maxAgg=0; - for (h=0; h<=3; h++) { - aggHand[h][s]=startMovesBitMap[h][s] | thrp->game.suit[h][s]; - if (aggHand[h][s]>maxAgg) { - maxAgg=aggHand[h][s]; - maxHand=h; - } - } - if (maxAgg!=0) { - posPoint->winner[s].hand=maxHand; - k=highestRank[aggHand[maxHand][s]]; - posPoint->winner[s].rank=k; - - maxAgg=0; - for (h=0; h<=3; h++) { - aggHand[h][s]&=(~bitMapRank[k]); - if (aggHand[h][s]>maxAgg) { - maxAgg=aggHand[h][s]; - maxHand=h; - } - } - if (maxAgg>0) { - posPoint->secondBest[s].hand=maxHand; - posPoint->secondBest[s].rank=highestRank[aggHand[maxHand][s]]; - } - else { - posPoint->secondBest[s].hand=-1; - posPoint->secondBest[s].rank=0; - } - } - else { - posPoint->winner[s].hand=-1; - posPoint->winner[s].rank=0; - posPoint->secondBest[s].hand=-1; - posPoint->secondBest[s].rank=0; - } - } - - - for (s=0; s<=3; s++) - for (h=0; h<=3; h++) - posPoint->length[h][s]= - (unsigned char)counttable[posPoint->rankInSuit[h][s]]; - - #ifdef STAT - for (d=0; d<=49; d++) { - score1Counts[d]=0; - score0Counts[d]=0; - c1[d]=0; c2[d]=0; c3[d]=0; c4[d]=0; c5[d]=0; c6[d]=0; c7[d]=0; - c8[d]=0; - thrp->no[d]=0; - } - #endif - - if (!mtd) { - thrp->lenSetSize=0; - for (k=0; k<=13; k++) { - for (h=0; h<=3; h++) { - thrp->rootnp[k][h]=&(thrp->posSearch[thrp->lenSetSize]); - thrp->posSearch[thrp->lenSetSize].suitLengths=0; - thrp->posSearch[thrp->lenSetSize].posSearchPoint=NULL; - thrp->posSearch[thrp->lenSetSize].left=NULL; - thrp->posSearch[thrp->lenSetSize].right=NULL; - thrp->lenSetSize++; - } - } - thrp->nodeSetSize=0; - thrp->winSetSize=0; - } - - return; -} - -#ifdef STAT -int score1Counts[50], score0Counts[50]; -int sumScore1Counts, sumScore0Counts, dd, suit, rank, order; -int c1[50], c2[50], c3[50], c4[50], c5[50], c6[50], c7[50], c8[50], c9[50]; -int sumc1, sumc2, sumc3, sumc4, sumc5, sumc6, sumc7, sumc8, sumc9; -#endif - -int ABsearch(struct pos * posPoint, int target, int depth, struct localVarType * thrp) { - /* posPoint points to the current look-ahead position, - target is number of tricks to take for the player, - depth is the remaining search length, must be positive, - the value of the subtree is returned. */ - - int moveExists, value, scoreFlag, found; - int hh, ss, rr, qtricks, res, k; - unsigned short int makeWinRank[4]; - struct nodeCardsType * cardsP; - struct evalType evalData; - struct winCardType * np; - struct posSearchType * pp; - struct nodeCardsType * tempP; - struct movePlyType *mply=&(thrp->movePly[depth]); - unsigned short int aggr[4]; - long long suitLengths; - - struct evalType Evaluate(struct pos * posPoint, int trump, - struct localVarType * thrp); - void Undo(struct pos * posPoint, int depth, struct movePlyType *mply, - struct localVarType * thrp); - - /*cardsP=NULL;*/ - assert((posPoint->handRelFirst>=0)&&(posPoint->handRelFirst<=3)); - int trump=thrp->trump; - int hand=handId(posPoint->first[depth], posPoint->handRelFirst); -#ifdef STAT - thrp->nodes++; -#endif - if (posPoint->handRelFirst==0) { - /*thrp->trickNodes++;*/ - if (posPoint->tricksMAX>=target) { - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth][ss]=0; - - #ifdef STAT - c1[depth]++; - - score1Counts[depth]++; - if (depth==thrp->iniDepth) { - fprintf(fp2, "score statistics:\n"); - for (dd=thrp->iniDepth; dd>=0; dd--) { - fprintf(fp2, "d=%d s1=%d s0=%d c1=%d c2=%d c3=%d c4=%d", dd, - score1Counts[dd], score0Counts[dd], c1[dd], c2[dd], - c3[dd], c4[dd]); - fprintf(fp2, " c5=%d c6=%d c7=%d c8=%d\n", c5[dd], - c6[dd], c7[dd], c8[dd]); - } - } - #endif - - return TRUE; - } - if (((posPoint->tricksMAX+(depth>>2)+1)winRanks[depth][ss]=0; - - #ifdef STAT - c2[depth]++; - score0Counts[depth]++; - if (depth==thrp->iniDepth) { - fprintf(fp2, "score statistics:\n"); - for (dd=thrp->iniDepth; dd>=0; dd--) { - fprintf(fp2, "d=%d s1=%d s0=%d c1=%d c2=%d c3=%d c4=%d", dd, - score1Counts[dd], score0Counts[dd], c1[dd], c2[dd], - c3[dd], c4[dd]); - fprintf(fp2, " c5=%d c6=%d c7=%d c8=%d\n", c5[dd], - c6[dd], c7[dd], c8[dd]); - } - } - #endif - - return FALSE; - } - - if (thrp->nodeTypeStore[hand]==MAXNODE) { - qtricks=QuickTricks(posPoint, hand, depth, target, trump, &res, thrp); - if (res) { - if (qtricks==0) - return FALSE; - else - return TRUE; - #ifdef STAT - c3[depth]++; - score1Counts[depth]++; - if (depth==thrp->iniDepth) { - fprintf(fp2, "score statistics:\n"); - for (dd=thrp->iniDepth; dd>=0; dd--) { - fprintf(fp2, "d=%d s1=%d s0=%d c1=%d c2=%d c3=%d c4=%d", dd, - score1Counts[dd], score0Counts[dd], c1[dd], c2[dd], - c3[dd], c4[dd]); - fprintf(fp2, " c5=%d c6=%d c7=%d c8=%d\n", c5[dd], - c6[dd], c7[dd], c8[dd]); - } - } - #endif - } - if (!LaterTricksMIN(posPoint,hand,depth,target,trump,thrp)) - return FALSE; - } - else { - qtricks=QuickTricks(posPoint, hand, depth, target, trump, &res, thrp); - if (res) { - if (qtricks==0) - return TRUE; - else - return FALSE; - #ifdef STAT - c4[depth]++; - score0Counts[depth]++; - if (depth==thrp->iniDepth) { - fprintf(fp2, "score statistics:\n"); - for (dd=thrp->iniDepth; dd>=0; dd--) { - fprintf(fp2, "d=%d s1=%d s0=%d c1=%d c2=%d c3=%d c4=%d", dd, - score1Counts[dd], score0Counts[dd], c1[dd], c2[dd], - c3[dd], c4[dd]); - fprintf(fp2, " c5=%d c6=%d c7=%d c8=%d\n", c5[dd], - c6[dd], c7[dd], c8[dd]); - } - } - #endif - } - if (LaterTricksMAX(posPoint,hand,depth,target,trump,thrp)) - return TRUE; - } - } - - else if (posPoint->handRelFirst==1) { - ss=posPoint->move[depth+1].suit; - unsigned short ranks=posPoint->rankInSuit[hand][ss] | - posPoint->rankInSuit[partner[hand]][ss]; - found=FALSE; rr=0; qtricks=0; - - if ((trump!=4) && (ss!=trump) && - (((posPoint->rankInSuit[hand][ss]==0) - && (posPoint->rankInSuit[hand][trump]!=0))|| - ((posPoint->rankInSuit[partner[hand]][ss]==0) - && (posPoint->rankInSuit[partner[hand]][trump]!=0)))) { - /* Own side can ruff */ - if ((posPoint->rankInSuit[lho[hand]][ss]!=0)|| - (posPoint->rankInSuit[lho[hand]][trump]==0)) { - found=TRUE; - qtricks=1; - } - } - - else if ( ranks >(bitMapRank[posPoint->move[depth+1].rank] | - posPoint->rankInSuit[lho[hand]][ss])) { - /* Own side has highest card in suit */ - if ((trump==4) || ((ss==trump)|| - (posPoint->rankInSuit[lho[hand]][trump]==0) - || (posPoint->rankInSuit[lho[hand]][ss]!=0))) { - rr=highestRank[ranks]; - if (rr!=0) { - found=TRUE; - qtricks=1; - } - else - found=FALSE; - } - } - - if ((found)&&(depth!=thrp->iniDepth)) { - for (k=0; k<=3; k++) - posPoint->winRanks[depth][k]=0; - if (rr!=0) - posPoint->winRanks[depth][ss]=bitMapRank[rr]; - - if (thrp->nodeTypeStore[hand]==MAXNODE) { - if (posPoint->tricksMAX+qtricks>=target) { - return TRUE; - } - else if (trump==4) { - if (posPoint->rankInSuit[hand][ss] > posPoint->rankInSuit[partner[hand]][ss]) - hh=hand; /* Hand to lead next trick */ - else - hh=partner[hand]; - - if ((posPoint->winner[ss].hand==hh)&&(posPoint->secondBest[ss].rank!=0)&& - (posPoint->secondBest[ss].hand==hh)) { - qtricks++; - posPoint->winRanks[depth][ss]|=bitMapRank[posPoint->secondBest[ss].rank]; - if (posPoint->tricksMAX+qtricks>=target) - return TRUE; - } - - for (k=0; k<=3; k++) { - if ((k!=ss)&&(posPoint->length[hh][k]!=0)) { /* Not lead suit, not void in suit */ - if ((posPoint->length[lho[hh]][k]==0)&&(posPoint->length[rho[hh]][k]==0) - &&(posPoint->length[partner[hh]][k]==0)) { - qtricks+=counttable[posPoint->rankInSuit[hh][k]]; - if (posPoint->tricksMAX+qtricks>=target) - return TRUE; - } - else if ((posPoint->winner[k].rank!=0)&&(posPoint->winner[k].hand==hh)) { - qtricks++; - posPoint->winRanks[depth][k]|=bitMapRank[posPoint->winner[k].rank]; - if (posPoint->tricksMAX+qtricks>=target) - return TRUE; - } - } - } - } - } - else { - /* MIN node */ - if ((posPoint->tricksMAX+((depth)>>2)+3-qtricks)<=target) { - return FALSE; - } - else if (trump==4) { - if (posPoint->rankInSuit[hand][ss] > posPoint->rankInSuit[partner[hand]][ss]) - hh=hand; /* Hand to lead next trick */ - else - hh=partner[hand]; - - if ((posPoint->winner[ss].hand==hh)&&(posPoint->secondBest[ss].rank!=0)&& - (posPoint->secondBest[ss].hand==hh)) { - qtricks++; - posPoint->winRanks[depth][ss]|=bitMapRank[posPoint->secondBest[ss].rank]; - if ((posPoint->tricksMAX+((depth)>>2)+3-qtricks)<=target) - return FALSE; - } - - for (k=0; k<=3; k++) { - if ((k!=ss)&&(posPoint->length[hh][k]!=0)) { /* Not lead suit, not void in suit */ - if ((posPoint->length[lho[hh]][k]==0)&&(posPoint->length[rho[hh]][k]==0) - &&(posPoint->length[partner[hh]][k]==0)) { - qtricks+=counttable[posPoint->rankInSuit[hh][k]]; - if ((posPoint->tricksMAX+((depth)>>2)+3-qtricks)<=target) - return FALSE; - } - else if ((posPoint->winner[k].rank!=0)&&(posPoint->winner[k].hand==hh)) { - qtricks++; - posPoint->winRanks[depth][k]|=bitMapRank[posPoint->winner[k].rank]; - if ((posPoint->tricksMAX+((depth)>>2)+3-qtricks)<=target) - return FALSE; - } - } - } - } - } - } - } - - if ((posPoint->handRelFirst==0)&& - (depth!=thrp->iniDepth)) { - for (ss=0; ss<=3; ss++) { - aggr[ss]=0; - for (hh=0; hh<=3; hh++) - aggr[ss]|=posPoint->rankInSuit[hh][ss]; - posPoint->orderSet[ss]=thrp->abs[aggr[ss]].aggrRanks[ss]; - } - suitLengths=0; - for (ss=0; ss<=2; ss++) - for (hh=0; hh<=3; hh++) { - suitLengths<<=4; - suitLengths|=posPoint->length[hh][ss]; - } - - pp=SearchLenAndInsert(thrp->rootnp[depth>>2][hand], - suitLengths, FALSE, &res, thrp); - /* Find node that fits the suit lengths */ - if (pp!=NULL) { - np=pp->posSearchPoint; - if (np==NULL) - cardsP=NULL; - else - cardsP=FindSOP(posPoint, np, hand, target, depth>>2, &scoreFlag, thrp); - - if (cardsP!=NULL) { - if (scoreFlag==1) { - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth][ss]= - thrp->adaptWins[aggr[ss]].winRanks[(int)cardsP->leastWin[ss]]; - - if (cardsP->bestMoveRank!=0) { - thrp->bestMoveTT[depth].suit=cardsP->bestMoveSuit; - thrp->bestMoveTT[depth].rank=cardsP->bestMoveRank; - } - #ifdef STAT - c5[depth]++; - if (scoreFlag==1) - score1Counts[depth]++; - else - score0Counts[depth]++; - if (depth==thrp->iniDepth) { - fprintf(fp2, "score statistics:\n"); - for (dd=thrp->iniDepth; dd>=0; dd--) { - fprintf(fp2, "d=%d s1=%d s0=%d c1=%d c2=%d c3=%d c4=%d", dd, - score1Counts[dd], score0Counts[dd], c1[dd], c2[dd],c3[dd], c4[dd]); - fprintf(fp2, " c5=%d c6=%d c7=%d c8=%d\n", c5[dd], - c6[dd], c7[dd], c8[dd]); - } - } - #endif - return TRUE; - } - else { - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth][ss]= - thrp->adaptWins[aggr[ss]].winRanks[(int)cardsP->leastWin[ss]]; - - if (cardsP->bestMoveRank!=0) { - thrp->bestMoveTT[depth].suit=cardsP->bestMoveSuit; - thrp->bestMoveTT[depth].rank=cardsP->bestMoveRank; - } - #ifdef STAT - c6[depth]++; - if (scoreFlag==1) - score1Counts[depth]++; - else - score0Counts[depth]++; - if (depth==thrp->iniDepth) { - fprintf(fp2, "score statistics:\n"); - for (dd=thrp->iniDepth; dd>=0; dd--) { - fprintf(fp2, "d=%d s1=%d s0=%d c1=%d c2=%d c3=%d c4=%d", dd, - score1Counts[dd], score0Counts[dd], c1[dd], c2[dd], c3[dd], - c4[dd]); - fprintf(fp2, " c5=%d c6=%d c7=%d c8=%d\n", c5[dd], - c6[dd], c7[dd], c8[dd]); - } - } - #endif - return FALSE; - } - } - } - } - - if (depth==0) { /* Maximum depth? */ - evalData=Evaluate(posPoint, trump, thrp); /* Leaf node */ - if (evalData.tricks>=target) - value=TRUE; - else - value=FALSE; - for (ss=0; ss<=3; ss++) { - posPoint->winRanks[depth][ss]=evalData.winRanks[ss]; - - #ifdef STAT - c7[depth]++; - if (value==1) - score1Counts[depth]++; - else - score0Counts[depth]++; - if (depth==thrp->iniDepth) { - fprintf(fp2, "score statistics:\n"); - for (dd=thrp->iniDepth; dd>=0; dd--) { - fprintf(fp2, "d=%d s1=%d s0=%d c1=%d c2=%d c3=%d c4=%d", dd, - score1Counts[dd], score0Counts[dd], c1[dd], c2[dd], c3[dd], - c4[dd]); - fprintf(fp2, " c5=%d c6=%d c7=%d c8=%d\n", c5[dd], - c6[dd], c7[dd], c8[dd]); - } - } - #endif - } - return value; - } - else { - - moveExists=MoveGen(posPoint, depth, trump, mply, thrp); - -/*#if 0*/ - if ((posPoint->handRelFirst==3)&&(depth>=/*29*//*33*/37) - &&(depth!=thrp->iniDepth)) { - mply->current=0; - int mexists=TRUE; - int ready=FALSE; - while (mexists) { - Make(posPoint, makeWinRank, depth, trump, mply, thrp); - depth--; - - for (ss=0; ss<=3; ss++) { - aggr[ss]=0; - for (hh=0; hh<=3; hh++) - aggr[ss]|=posPoint->rankInSuit[hh][ss]; - posPoint->orderSet[ss]=thrp->abs[aggr[ss]].aggrRanks[ss]; - } - int hfirst=posPoint->first[depth]; - suitLengths=0; - for (ss=0; ss<=2; ss++) - for (hh=0; hh<=3; hh++) { - suitLengths<<=4; - suitLengths|=posPoint->length[hh][ss]; - } - - pp=SearchLenAndInsert(thrp->rootnp[depth>>2][hfirst], - suitLengths, FALSE, &res, thrp); - /* Find node that fits the suit lengths */ - if (pp!=NULL) { - np=pp->posSearchPoint; - if (np==NULL) - tempP=NULL; - else - tempP=FindSOP(posPoint, np, hfirst, target, depth>>2, &scoreFlag, thrp); - - if (tempP!=NULL) { - if ((thrp->nodeTypeStore[hand]==MAXNODE)&&(scoreFlag==1)) { - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth+1][ss]= - thrp->adaptWins[aggr[ss]].winRanks[(int)tempP->leastWin[ss]]; - if (tempP->bestMoveRank!=0) { - thrp->bestMoveTT[depth+1].suit=tempP->bestMoveSuit; - thrp->bestMoveTT[depth+1].rank=tempP->bestMoveRank; - } - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth+1][ss]|=makeWinRank[ss]; - Undo(posPoint, depth+1, mply/*&(thrp->movePly[depth+1])*/,thrp); - return TRUE; - } - else if ((thrp->nodeTypeStore[hand]==MINNODE)&&(scoreFlag==0)) { - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth+1][ss]= - thrp->adaptWins[aggr[ss]].winRanks[(int)tempP->leastWin[ss]]; - if (tempP->bestMoveRank!=0) { - thrp->bestMoveTT[depth+1].suit=tempP->bestMoveSuit; - thrp->bestMoveTT[depth+1].rank=tempP->bestMoveRank; - } - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth+1][ss]|=makeWinRank[ss]; - Undo(posPoint, depth+1, mply/*&(thrp->movePly[depth+1])*/, thrp); - return FALSE; - } - else { - mply->move[mply->current].weight+=100; - /*thrp->movePly[depth+1].move[thrp->movePly[depth+1].current].weight+=100;*/ - ready=TRUE; - } - } - } - depth++; - Undo(posPoint, depth, mply, thrp); - if (ready) - break; - - if (mply->current <= (mply->last-1)) { - mply->current++; - mexists=TRUE; - } - else - mexists=FALSE; - } - if (ready) - MergeSort(mply->last+1, mply->move); - } -/*#endif*/ - - - mply->current=0; - if (thrp->nodeTypeStore[hand]==MAXNODE) { - value=FALSE; - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth][ss]=0; - - while (moveExists) { - Make(posPoint, makeWinRank, depth, trump, mply, thrp); /* Make current move */ - if (posPoint->handRelFirst==0) - thrp->trickNodes++; - assert((posPoint->handRelFirst>=0)&&(posPoint->handRelFirst<=3)); - value=ABsearch(posPoint, target, depth-1, thrp); - - Undo(posPoint, depth, mply, thrp); /* Retract current move */ - if (value==TRUE) { - /* A cut-off? */ - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth][ss]=posPoint->winRanks[depth-1][ss] | - makeWinRank[ss]; - thrp->bestMove[depth]=mply->move[mply->current]; - goto ABexit; - } - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth][ss]=posPoint->winRanks[depth][ss] | - posPoint->winRanks[depth-1][ss] | makeWinRank[ss]; - - moveExists=NextMove(posPoint, depth, mply, thrp); - } - } - else { /* A minnode */ - value=TRUE; - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth][ss]=0; - - while (moveExists) { - Make(posPoint, makeWinRank, depth, trump, mply, thrp); /* Make current move */ - if (posPoint->handRelFirst==0) - thrp->trickNodes++; - value=ABsearch(posPoint, target, depth-1, thrp); - - Undo(posPoint, depth, mply, thrp); /* Retract current move */ - if (value==FALSE) { - /* A cut-off? */ - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth][ss]=posPoint->winRanks[depth-1][ss] | - makeWinRank[ss]; - thrp->bestMove[depth]=mply->move[mply->current]; - goto ABexit; - } - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth][ss]=posPoint->winRanks[depth][ss] | - posPoint->winRanks[depth-1][ss] | makeWinRank[ss]; - - moveExists=NextMove(posPoint, depth, mply, thrp); - } - } - } - ABexit: - if (depth>=4) { - if(posPoint->handRelFirst==0) { - if (value) - k=target; - else - k=target-1; - if (depth!=thrp->iniDepth) - BuildSOP(posPoint, suitLengths, depth>>2, hand, target, depth, - value, k, thrp); - if (thrp->clearTTflag) { - /* Wipe out the TT dynamically allocated structures - except for the initially allocated structures. - Set the TT limits to the initial values. - Reset TT array indices to zero. - Reset memory chunk indices to zero. - Set allocated memory to the initial value. */ - /*fp2=fopen("dyn.txt", "a"); - fprintf(fp2, "Clear TT:\n"); - fprintf(fp2, "wcount=%d, ncount=%d, lcount=%d\n", - wcount, ncount, lcount); - fprintf(fp2, "winSetSize=%d, nodeSetSize=%d, lenSetSize=%d\n", - winSetSize, nodeSetSize, lenSetSize); - fprintf(fp2, "\n"); - fclose(fp2);*/ - - Wipe(thrp); - thrp->winSetSizeLimit=WINIT; - thrp->nodeSetSizeLimit=NINIT; - thrp->lenSetSizeLimit=LINIT; - thrp->lcount=0; - thrp->allocmem=(thrp->lenSetSizeLimit+1)*sizeof(struct posSearchType); - thrp->lenSetSize=0; - thrp->posSearch=thrp->pl[thrp->lcount]; - for (k=0; k<=13; k++) { - for (hh=0; hh<=3; hh++) { - thrp->rootnp[k][hh]=&(thrp->posSearch[thrp->lenSetSize]); - thrp->posSearch[thrp->lenSetSize].suitLengths=0; - thrp->posSearch[thrp->lenSetSize].posSearchPoint=NULL; - thrp->posSearch[thrp->lenSetSize].left=NULL; - thrp->posSearch[thrp->lenSetSize].right=NULL; - thrp->lenSetSize++; - } - } - thrp->nodeSetSize=0; - thrp->winSetSize=0; - thrp->wcount=0; thrp->ncount=0; - thrp->allocmem+=(thrp->winSetSizeLimit+1)*sizeof(struct winCardType); - thrp->winCards=thrp->pw[thrp->wcount]; - thrp->allocmem+=(thrp->nodeSetSizeLimit+1)*sizeof(struct nodeCardsType); - thrp->nodeCards=thrp->pn[thrp->ncount]; - thrp->clearTTflag=FALSE; - thrp->windex=-1; - } - } - } - - #ifdef STAT - c8[depth]++; - if (value==1) - score1Counts[depth]++; - else - score0Counts[depth]++; - if (depth==thrp->iniDepth) { - if (fp2==NULL) - exit(0); - fprintf(fp2, "\n"); - fprintf(fp2, "top level cards:\n"); - for (hh=0; hh<=3; hh++) { - fprintf(fp2, "hand=%c\n", cardHand[hh]); - for (ss=0; ss<=3; ss++) { - fprintf(fp2, "suit=%c", cardSuit[ss]); - for (rr=14; rr>=2; rr--) - if (posPoint->rankInSuit[hh][ss] & bitMapRank[rr]) - fprintf(fp2, " %c", cardRank[rr]); - fprintf(fp2, "\n"); - } - fprintf(fp2, "\n"); - } - fprintf(fp2, "top level winning cards:\n"); - for (ss=0; ss<=3; ss++) { - fprintf(fp2, "suit=%c", cardSuit[ss]); - for (rr=14; rr>=2; rr--) - if (posPoint->winRanks[depth][ss] & bitMapRank[rr]) - fprintf(fp2, " %c", cardRank[rr]); - fprintf(fp2, "\n"); - } - fprintf(fp2, "\n"); - fprintf(fp2, "\n"); - - fprintf(fp2, "score statistics:\n"); - sumScore0Counts=0; - sumScore1Counts=0; - sumc1=0; sumc2=0; sumc3=0; sumc4=0; - sumc5=0; sumc6=0; sumc7=0; sumc8=0; sumc9=0; - for (dd=thrp->iniDepth; dd>=0; dd--) { - fprintf(fp2, "depth=%d s1=%d s0=%d c1=%d c2=%d c3=%d c4=%d", dd, - score1Counts[dd], score0Counts[dd], c1[dd], c2[dd], c3[dd], c4[dd]); - fprintf(fp2, " c5=%d c6=%d c7=%d c8=%d\n", c5[dd], c6[dd], - c7[dd], c8[dd]); - sumScore0Counts=sumScore0Counts+score0Counts[dd]; - sumScore1Counts=sumScore1Counts+score1Counts[dd]; - sumc1=sumc1+c1[dd]; - sumc2=sumc2+c2[dd]; - sumc3=sumc3+c3[dd]; - sumc4=sumc4+c4[dd]; - sumc5=sumc5+c5[dd]; - sumc6=sumc6+c6[dd]; - sumc7=sumc7+c7[dd]; - sumc8=sumc8+c8[dd]; - sumc9=sumc9+c9[dd]; - } - fprintf(fp2, "\n"); - fprintf(fp2, "score sum statistics:\n"); - fprintf(fp2, "\n"); - fprintf(fp2, "sumScore0Counts=%d sumScore1Counts=%d\n", - sumScore0Counts, sumScore1Counts); - fprintf(fp2, "nodeSetSize=%d winSetSize=%d\n", thrp->nodeSetSize, - thrp->winSetSize); - fprintf(fp2, "sumc1=%d sumc2=%d sumc3=%d sumc4=%d\n", - sumc1, sumc2, sumc3, sumc4); - fprintf(fp2, "sumc5=%d sumc6=%d sumc7=%d sumc8=%d sumc9=%d\n", - sumc5, sumc6, sumc7, sumc8, sumc9); - fprintf(fp2, "\n"); - fprintf(fp2, "\n"); - fprintf(fp2, "No of searched nodes per depth:\n"); - for (dd=thrp->iniDepth; dd>=0; dd--) - fprintf(fp2, "depth=%d nodes=%d\n", dd, thrp->no[dd]); - fprintf(fp2, "\n"); - fprintf(fp2, "Total nodes=%d\n", thrp->nodes); - } - #endif - - return value; -} - - -void Make(struct pos * posPoint, unsigned short int trickCards[4], - int depth, int trump, struct movePlyType *mply, struct localVarType * thrp) { - int t, u, w; - int mcurr, q; - - assert((posPoint->handRelFirst>=0)&&(posPoint->handRelFirst<=3)); - for (int suit=0; suit<=3; suit++) - trickCards[suit]=0; - - int firstHand=posPoint->first[depth]; - int r=mply->current; - - if (posPoint->handRelFirst==3) { /* This hand is last hand */ - if (mply->move[r].suit==posPoint->move[depth+1].suit) { - if (mply->move[r].rank>posPoint->move[depth+1].rank) { - posPoint->move[depth]=mply->move[r]; - posPoint->high[depth]=handId(firstHand, 3); - } - else { - posPoint->move[depth]=posPoint->move[depth+1]; - posPoint->high[depth]=posPoint->high[depth+1]; - } - } - else if (mply->move[r].suit==trump) { - posPoint->move[depth]=mply->move[r]; - posPoint->high[depth]=handId(firstHand, 3); - } - else { - posPoint->move[depth]=posPoint->move[depth+1]; - posPoint->high[depth]=posPoint->high[depth+1]; - } - - /* Is the trick won by rank? */ - int s=posPoint->move[depth].suit; - int count=0; - if (mply->move[r].suit==s) - count++; - for (int e=1; e<=3; e++) { - mcurr=thrp->movePly[depth+e].current; - if (thrp->movePly[depth+e].move[mcurr].suit==s) { - count++; - /*if (++count>1) - break;*/ - } - } - - - if (thrp->nodeTypeStore[posPoint->high[depth]]==MAXNODE) - posPoint->tricksMAX++; - posPoint->first[depth-1]=posPoint->high[depth]; /* Defines who is first - in the next move */ - - t=handId(firstHand, 3); - posPoint->handRelFirst=0; /* Hand pointed to by posPoint->first - will lead the next trick */ - - - int done=FALSE; - for (int d=3; d>=0; d--) { - q=handId(firstHand, 3-d); - /* Add the moves to removed ranks */ - r=thrp->movePly[depth+d].current; - w=thrp->movePly[depth+d].move[r].rank; - u=thrp->movePly[depth+d].move[r].suit; - posPoint->removedRanks[u]|=bitMapRank[w]; - - if (d==0) - posPoint->rankInSuit[t][u]&=(~bitMapRank[w]); - - if ((w==posPoint->winner[u].rank)||(w==posPoint->secondBest[u].rank)) { - int aggr=0; - for (int h=0; h<=3; h++) - aggr|=posPoint->rankInSuit[h][u]; - posPoint->winner[u].rank=thrp->abs[aggr].absRank[1][u].rank; - posPoint->winner[u].hand=thrp->abs[aggr].absRank[1][u].hand; - posPoint->secondBest[u].rank=thrp->abs[aggr].absRank[2][u].rank; - posPoint->secondBest[u].hand=thrp->abs[aggr].absRank[2][u].hand; - } - - - /* Determine win-ranked cards */ - if ((q==posPoint->high[depth])&&(!done)) { - done=TRUE; - if (count>=2) { - trickCards[u]=bitMapRank[w]; - /* Mark ranks as winning if they are part of a sequence */ - trickCards[u]|=thrp->movePly[depth+d].move[r].sequence; - } - } - } - } - else if (posPoint->handRelFirst==0) { /* Is it the 1st hand? */ - posPoint->first[depth-1]=firstHand; /* First hand is not changed in - next move */ - posPoint->high[depth]=firstHand; - posPoint->move[depth]=mply->move[r]; - t=firstHand; - posPoint->handRelFirst=1; - r=mply->current; - u=mply->move[r].suit; - w=mply->move[r].rank; - posPoint->rankInSuit[t][u]&=(~bitMapRank[w]); - } - else { - r=mply->current; - u=mply->move[r].suit; - w=mply->move[r].rank; - if (u==posPoint->move[depth+1].suit) { - if (w>posPoint->move[depth+1].rank) { - posPoint->move[depth]=mply->move[r]; - posPoint->high[depth]=handId(firstHand, posPoint->handRelFirst); - } - else { - posPoint->move[depth]=posPoint->move[depth+1]; - posPoint->high[depth]=posPoint->high[depth+1]; - } - } - else if (u==trump) { - posPoint->move[depth]=mply->move[r]; - posPoint->high[depth]=handId(firstHand, posPoint->handRelFirst); - } - else { - posPoint->move[depth]=posPoint->move[depth+1]; - posPoint->high[depth]=posPoint->high[depth+1]; - } - - t=handId(firstHand, posPoint->handRelFirst); - posPoint->handRelFirst++; /* Current hand is stepped */ - assert((posPoint->handRelFirst>=0)&&(posPoint->handRelFirst<=3)); - posPoint->first[depth-1]=firstHand; /* First hand is not changed in - next move */ - - posPoint->rankInSuit[t][u]&=(~bitMapRank[w]); - } - - posPoint->length[t][u]--; - -#ifdef STAT - thrp->no[depth]++; -#endif - - return; -} - - - -void Undo(struct pos * posPoint, int depth, struct movePlyType *mply, - struct localVarType * thrp) { - int r, t, u, w; - - assert((posPoint->handRelFirst>=0)&&(posPoint->handRelFirst<=3)); - - switch (posPoint->handRelFirst) { - case 3: case 2: case 1: - posPoint->handRelFirst--; - break; - case 0: - posPoint->handRelFirst=3; - } - - int firstHand=posPoint->first[depth]; - - if (posPoint->handRelFirst==0) { /* 1st hand which won the previous - trick */ - t=firstHand; - r=mply->current; - u=mply->move[r].suit; - w=mply->move[r].rank; - } - else if (posPoint->handRelFirst==3) { /* Last hand */ - for (int d=3; d>=0; d--) { - /* Delete the moves from removed ranks */ - r=thrp->movePly[depth+d].current; - w=thrp->movePly[depth+d].move[r].rank; - u=thrp->movePly[depth+d].move[r].suit; - - posPoint->removedRanks[u]&= (~bitMapRank[w]); - - if (w>posPoint->winner[u].rank) { - /*posPoint->secondBest[u].rank=posPoint->winner[u].rank; - posPoint->secondBest[u].hand=posPoint->winner[u].hand;*/ - posPoint->secondBest[u]=posPoint->winner[u]; - posPoint->winner[u].rank=w; - posPoint->winner[u].hand=handId(firstHand, 3-d); - - } - else if (w>posPoint->secondBest[u].rank) { - posPoint->secondBest[u].rank=w; - posPoint->secondBest[u].hand=handId(firstHand, 3-d); - } - } - t=handId(firstHand, 3); - - - if (thrp->nodeTypeStore[posPoint->first[depth-1]]==MAXNODE) - /* First hand of next trick is winner of the current trick */ - posPoint->tricksMAX--; - } - else { - t=handId(firstHand, posPoint->handRelFirst); - r=mply->current; - u=mply->move[r].suit; - w=mply->move[r].rank; - } - - posPoint->rankInSuit[t][u]|=bitMapRank[w]; - - posPoint->length[t][u]++; - - return; -} - - - -struct evalType Evaluate(struct pos * posPoint, int trump, - struct localVarType * thrp) { - int s, h, hmax=0, count=0, k=0; - unsigned short rmax=0; - struct evalType eval; - - int firstHand=posPoint->first[0]; - assert((firstHand >= 0)&&(firstHand <= 3)); - - for (s=0; s<=3; s++) - eval.winRanks[s]=0; - - /* Who wins the last trick? */ - if (trump!=4) { /* Highest trump card wins */ - for (h=0; h<=3; h++) { - if (posPoint->rankInSuit[h][trump]!=0) - count++; - if (posPoint->rankInSuit[h][trump]>rmax) { - hmax=h; - rmax=posPoint->rankInSuit[h][trump]; - } - } - - if (rmax>0) { /* Trumpcard wins */ - if (count>=2) - eval.winRanks[trump]=rmax; - - if (thrp->nodeTypeStore[hmax]==MAXNODE) - goto maxexit; - else - goto minexit; - } - } - - /* Who has the highest card in the suit played by 1st hand? */ - - k=0; - while (k<=3) { /* Find the card the 1st hand played */ - if (posPoint->rankInSuit[firstHand][k]!=0) /* Is this the card? */ - break; - k++; - } - - assert(k < 4); - - for (h=0; h<=3; h++) { - if (posPoint->rankInSuit[h][k]!=0) - count++; - if (posPoint->rankInSuit[h][k]>rmax) { - hmax=h; - rmax=posPoint->rankInSuit[h][k]; - } - } - - if (count>=2) - eval.winRanks[k]=rmax; - - if (thrp->nodeTypeStore[hmax]==MAXNODE) - goto maxexit; - else - goto minexit; - - maxexit: - eval.tricks=posPoint->tricksMAX+1; - return eval; - - minexit: - eval.tricks=posPoint->tricksMAX; - return eval; -} - - -int QuickTricks(struct pos * posPoint, int hand, - int depth, int target, int trump, int *result, struct localVarType * thrp) { - int suit, sum, commRank=0, commSuit=-1, s; - int opps, res; - int countLho, countRho, countPart, countOwn, lhoTrumpRanks, rhoTrumpRanks; - int cutoff, ss, rr, lowestQtricks=0; - - int QtricksLeadHandNT(int hand, struct pos *posPoint, int cutoff, int depth, - int countLho, int countRho, int *lhoTrumpRanks, int *rhoTrumpRanks, int commPartner, - int commSuit, int countOwn, int countPart, int suit, int qtricks, int trump, int *res); - - int QtricksLeadHandTrump(int hand, struct pos *posPoint, int cutoff, int depth, - int countLho, int countRho, int lhoTrumpRanks, int rhoTrumpRanks, int countOwn, - int countPart, int suit, int qtricks, int trump, int *res); - - int QuickTricksPartnerHandTrump(int hand, struct pos *posPoint, int cutoff, int depth, - int countLho, int countRho, int lhoTrumpRanks, int rhoTrumpRanks, int countOwn, - int countPart, int suit, int qtricks, int commSuit, int commRank, int trump, int *res, - struct localVarType * thrp); - - int QuickTricksPartnerHandNT(int hand, struct pos *posPoint, int cutoff, int depth, - int countLho, int countRho, int countOwn, - int countPart, int suit, int qtricks, int commSuit, int commRank, int trump, int *res, - struct localVarType * thrp); - - *result=TRUE; - int qtricks=0; - for (s=0; s<=3; s++) - posPoint->winRanks[depth][s]=0; - - if ((depth<=0)||(depth==thrp->iniDepth)) { - *result=FALSE; - return qtricks; - } - - if (thrp->nodeTypeStore[hand]==MAXNODE) - cutoff=target-posPoint->tricksMAX; - else - cutoff=posPoint->tricksMAX-target+(depth>>2)+2; - - int commPartner=FALSE; - for (s=0; s<=3; s++) { - if ((trump!=4)&&(trump!=s)) { - if (posPoint->winner[s].hand==partner[hand]) { - /* Partner has winning card */ - if (posPoint->rankInSuit[hand][s]!=0) { - /* Own hand has card in suit */ - if (((posPoint->rankInSuit[lho[hand]][s]!=0) || - /* LHO not void */ - (posPoint->rankInSuit[lho[hand]][trump]==0)) - /* LHO has no trump */ - && ((posPoint->rankInSuit[rho[hand]][s]!=0) || - /* RHO not void */ - (posPoint->rankInSuit[rho[hand]][trump]==0))) { - /* RHO has no trump */ - commPartner=TRUE; - commSuit=s; - commRank=posPoint->winner[s].rank; - break; - } - } - } - else if (posPoint->secondBest[s].hand==partner[hand]) { - if ((posPoint->winner[s].hand==hand)&& - (posPoint->length[hand][s]>=2)&&(posPoint->length[partner[hand]][s]>=2)) { - if (((posPoint->rankInSuit[lho[hand]][s]!=0) || - (posPoint->rankInSuit[lho[hand]][trump]==0)) - && ((posPoint->rankInSuit[rho[hand]][s]!=0) || - (posPoint->rankInSuit[rho[hand]][trump]==0))) { - commPartner=TRUE; - commSuit=s; - commRank=posPoint->secondBest[s].rank; - break; - } - } - } - } - else if (trump==4) { - if (posPoint->winner[s].hand==partner[hand]) { - /* Partner has winning card */ - if (posPoint->rankInSuit[hand][s]!=0) { - /* Own hand has card in suit */ - commPartner=TRUE; - commSuit=s; - commRank=posPoint->winner[s].rank; - break; - } - } - else if (posPoint->secondBest[s].hand==partner[hand]) { - if ((posPoint->winner[s].hand==hand)&& - (posPoint->length[hand][s]>=2)&&(posPoint->length[partner[hand]][s]>=2)) { - commPartner=TRUE; - commSuit=s; - commRank=posPoint->secondBest[s].rank; - break; - } - } - } - } - - if ((trump!=4) && (!commPartner) && - (posPoint->rankInSuit[hand][trump]!=0) && - (posPoint->winner[trump].hand==partner[hand])) { - commPartner=TRUE; - commSuit=trump; - commRank=posPoint->winner[trump].rank; - } - - - if (trump!=4) { - suit=trump; - lhoTrumpRanks=posPoint->length[lho[hand]][trump]; - rhoTrumpRanks=posPoint->length[rho[hand]][trump]; - } - else - suit=0; - - do { - countOwn=posPoint->length[hand][suit]; - countLho=posPoint->length[lho[hand]][suit]; - countRho=posPoint->length[rho[hand]][suit]; - countPart=posPoint->length[partner[hand]][suit]; - opps=countLho | countRho; - - if (!opps && (countPart==0)) { - if (countOwn==0) { - /* Continue with next suit. */ - if ((trump!=4)&&(trump!=suit)) { - suit++; - if ((trump!=4) && (suit==trump)) - suit++; - } - else { - if ((trump!=4) && (trump==suit)) { - if (trump==0) - suit=1; - else - suit=0; - } - else - suit++; - } - continue; - } - - /* Long tricks when only leading hand have cards in the suit. */ - if ((trump!=4) && (trump!=suit)) { - if ((lhoTrumpRanks==0) && (rhoTrumpRanks==0)) { - qtricks+=countOwn; - if (qtricks>=cutoff) - return qtricks; - suit++; - if ((trump!=4) && (suit==trump)) - suit++; - continue; - } - else { - suit++; - if ((trump!=4) && (suit==trump)) - suit++; - continue; - } - } - else { - qtricks+=countOwn; - if (qtricks>=cutoff) - return qtricks; - - if ((trump!=4) && (suit==trump)) { - if (trump==0) - suit=1; - else - suit=0; - } - else { - suit++; - if ((trump!=4) && (suit==trump)) - suit++; - } - continue; - } - } - else { - if (!opps && (trump!=4) && (suit==trump)) { - /* The partner but not the opponents have cards in the trump suit. */ - sum=Max(countOwn, countPart); - for (s=0; s<=3; s++) { - if ((sum>0)&&(s!=trump)&&(countOwn>=countPart)&&(posPoint->length[hand][s]>0)&& - (posPoint->length[partner[hand]][s]==0)) { - sum++; - break; - } - } - /* If the additional trick by ruffing causes a cutoff. (qtricks not incremented.) */ - if (sum>=cutoff) - return sum; - } - else if (!opps) { - /* The partner but not the opponents have cards in the suit. */ - sum=Min(countOwn,countPart); - if (trump==4) { - if (sum>=cutoff) - return sum; - } - else if ((suit!=trump)&&(lhoTrumpRanks==0)&&(rhoTrumpRanks==0)) { - if (sum>=cutoff) - return sum; - } - } - - if (commPartner) { - if (!opps && (countOwn==0)) { - if ((trump!=4) && (trump!=suit)) { - if ((lhoTrumpRanks==0) && (rhoTrumpRanks==0)) { - qtricks+=countPart; - posPoint->winRanks[depth][commSuit]|=bitMapRank[commRank]; - if (qtricks>=cutoff) - return qtricks; - suit++; - if ((trump!=4) && (suit==trump)) - suit++; - continue; - } - else { - suit++; - if ((trump!=4) && (suit==trump)) - suit++; - continue; - } - } - else { - qtricks+=countPart; - posPoint->winRanks[depth][commSuit]|=bitMapRank[commRank]; - if (qtricks>=cutoff) - return qtricks; - if ((trump!=4) && (suit==trump)) { - if (trump==0) - suit=1; - else - suit=0; - } - else { - suit++; - if ((trump!=4) && (suit==trump)) - suit++; - } - continue; - } - } - else { - if (!opps && (trump!=4) && (suit==trump)) { - sum=Max(countOwn, countPart); - for (s=0; s<=3; s++) { - if ((sum>0)&&(s!=trump)&&(countOwn<=countPart)&&(posPoint->length[partner[hand]][s]>0)&& - (posPoint->length[hand][s]==0)) { - sum++; - break; - } - } - if (sum>=cutoff) { - posPoint->winRanks[depth][commSuit]|=bitMapRank[commRank]; - return sum; - } - } - else if (!opps) { - sum=Min(countOwn,countPart); - if (trump==4) { - if (sum>=cutoff) - return sum; - } - else if ((suit!=trump)&&(lhoTrumpRanks==0)&&(rhoTrumpRanks==0)) { - if (sum>=cutoff) - return sum; - } - } - } - } - } - - if (posPoint->winner[suit].rank==0) { - if ((trump!=4) && (suit==trump)) { - if (trump==0) - suit=1; - else - suit=0; - } - else { - suit++; - if ((trump!=4) && (suit==trump)) - suit++; - } - continue; - } - - if (posPoint->winner[suit].hand==hand) { - if ((trump!=4)&&(trump!=suit)) { - qtricks=QtricksLeadHandTrump(hand, posPoint, cutoff, depth, - countLho, countRho, lhoTrumpRanks, rhoTrumpRanks, countOwn, - countPart, suit, qtricks, trump, &res); - if (res==1) - return qtricks; - else if (res==2) { - suit++; - if ((trump!=4) && (suit==trump)) - suit++; - continue; - } - } - else { - qtricks=QtricksLeadHandNT(hand, posPoint, cutoff, depth, - countLho, countRho, &lhoTrumpRanks, &rhoTrumpRanks, - commPartner, commSuit, countOwn, - countPart, suit, qtricks, trump, &res); - if (res==1) - return qtricks; - else if (res==2) { - if ((trump!=4) && (trump==suit)) { - if (trump==0) - suit=1; - else - suit=0; - } - else - suit++; - continue; - } - } - } - - /* It was not possible to take a quick trick by own winning card in - the suit */ - else { - /* Partner winning card? */ - if ((posPoint->winner[suit].hand==partner[hand])&&(1/*countPart>0*/)) { - /* Winner found at partner*/ - if (commPartner) { - /* There is communication with the partner */ - if ((trump!=4)&&(trump!=suit)) { - qtricks=QuickTricksPartnerHandTrump(hand, posPoint, cutoff, depth, - countLho, countRho, lhoTrumpRanks, rhoTrumpRanks, countOwn, - countPart, suit, qtricks, commSuit, commRank, trump, &res, thrp); - if (res==1) - return qtricks; - else if (res==2) { - suit++; - if ((trump!=4) && (suit==trump)) - suit++; - continue; - } - } - else { - qtricks=QuickTricksPartnerHandNT(hand, posPoint, cutoff, depth, - countLho, countRho, countOwn, - countPart, suit, qtricks, commSuit, commRank, trump, &res, thrp); - if (res==1) - return qtricks; - else if (res==2) { - if ((trump!=4) && (trump==suit)) { - if (trump==0) - suit=1; - else - suit=0; - } - else - suit++; - continue; - } - } - } - } - } - if ((trump!=4) &&(suit!=trump)&& - (countOwn>0)&&(lowestQtricks==0)&& - ((qtricks==0)||((posPoint->winner[suit].hand!=hand)&& - (posPoint->winner[suit].hand!=partner[hand])&& - (posPoint->winner[trump].hand!=hand)&& - (posPoint->winner[trump].hand!=partner[hand])))) { - if ((countPart==0)&&(posPoint->length[partner[hand]][trump]>0)) { - if (((countRho>0)||(posPoint->length[rho[hand]][trump]==0))&& - ((countLho>0)||(posPoint->length[lho[hand]][trump]==0))) { - lowestQtricks=1; - if (1>=cutoff) - return 1; - suit++; - if ((trump!=4) && (suit==trump)) - suit++; - continue; - } - else if ((countRho==0)&&(countLho==0)) { - if ((posPoint->rankInSuit[lho[hand]][trump] | - posPoint->rankInSuit[rho[hand]][trump]) < - posPoint->rankInSuit[partner[hand]][trump]) { - lowestQtricks=1; - - rr=highestRank[posPoint->rankInSuit[partner[hand]][trump]]; - if (rr!=0) { - posPoint->winRanks[depth][trump]|=bitMapRank[rr]; - if (1>=cutoff) - return 1; - } - } - suit++; - if ((trump!=4) && (suit==trump)) - suit++; - continue; - } - else if (countLho==0) { - if (posPoint->rankInSuit[lho[hand]][trump] < - posPoint->rankInSuit[partner[hand]][trump]) { - lowestQtricks=1; - for (rr=14; rr>=2; rr--) { - if ((posPoint->rankInSuit[partner[hand]][trump] & - bitMapRank[rr])!=0) { - posPoint->winRanks[depth][trump]|=bitMapRank[rr]; - break; - } - } - if (1>=cutoff) - return 1; - } - suit++; - if ((trump!=4) && (suit==trump)) - suit++; - continue; - } - else if (countRho==0) { - if (posPoint->rankInSuit[rho[hand]][trump] < - posPoint->rankInSuit[partner[hand]][trump]) { - lowestQtricks=1; - for (rr=14; rr>=2; rr--) { - if ((posPoint->rankInSuit[partner[hand]][trump] & - bitMapRank[rr])!=0) { - posPoint->winRanks[depth][trump]|=bitMapRank[rr]; - break; - } - } - if (1>=cutoff) - return 1; - } - suit++; - if ((trump!=4) && (suit==trump)) - suit++; - continue; - } - } - } - if (qtricks>=cutoff) - return qtricks; - if ((trump!=4) && (suit==trump)) { - if (trump==0) - suit=1; - else - suit=0; - } - else { - suit++; - if ((trump!=4) && (suit==trump)) - suit++; - } - } - while (suit<=3); - - if (qtricks==0) { - if ((trump==4)||(posPoint->winner[trump].hand==-1)) { - for (ss=0; ss<=3; ss++) { - if (posPoint->winner[ss].hand==-1) - continue; - if (posPoint->length[hand][ss]>0) { - posPoint->winRanks[depth][ss]= - bitMapRank[posPoint->winner[ss].rank]; - } - } - if (thrp->nodeTypeStore[hand]!=MAXNODE) - cutoff=target-posPoint->tricksMAX; - else - cutoff=posPoint->tricksMAX-target+(depth>>2)+2; - - if (1>=cutoff) - return 0; - } - } - - *result=FALSE; - return qtricks; -} - - -int QtricksLeadHandTrump(int hand, struct pos *posPoint, int cutoff, int depth, - int countLho, int countRho, int lhoTrumpRanks, int rhoTrumpRanks, int countOwn, - int countPart, int suit, int qtricks, int trump, int *res) { - /* res=0 Continue with same suit. - res=1 Cutoff. - res=2 Continue with next suit. */ - - - *res=1; - int qt=qtricks; - if (((countLho!=0) || (lhoTrumpRanks==0)) && ((countRho!=0) || (rhoTrumpRanks==0))) { - posPoint->winRanks[depth][suit]|= - bitMapRank[posPoint->winner[suit].rank]; - qt++; - if (qt>=cutoff) - return qt; - - if ((countLho<=1)&&(countRho<=1)&&(countPart<=1)&& - (lhoTrumpRanks==0)&&(rhoTrumpRanks==0)) { - qt+=countOwn-1; - if (qt>=cutoff) - return qt; - *res=2; - return qt; - } - } - - if (posPoint->secondBest[suit].hand==hand) { - if ((lhoTrumpRanks==0)&&(rhoTrumpRanks==0)) { - posPoint->winRanks[depth][suit]|= - bitMapRank[posPoint->secondBest[suit].rank]; - qt++; - if (qt>=cutoff) - return qt; - if ((countLho<=2)&&(countRho<=2)&&(countPart<=2)) { - qt+=countOwn-2; - if (qt>=cutoff) - return qt; - *res=2; - return qt; - } - /*else { - aggr=0; - for (k=0; k<=3; k++) - aggr|=posPoint->rankInSuit[k][suit]; - if (rel[aggr].absRank[3][suit].hand==hand) { - qt++; - posPoint->winRanks[depth][suit]|= - bitMapRank[rel[aggr].absRank[3][suit].rank]; - if (qt>=cutoff) - return qt; - if ((countLho<=3)&&(countRho<=3)&&(countPart<=3)) { - qt+=countOwn-3; - if (qt>=cutoff) - return qt; - } - *res=2; - return qt; - } - }*/ - } - } - else if ((posPoint->secondBest[suit].hand==partner[hand]) - &&(countOwn>1)&&(countPart>1)) { - /* Second best at partner and suit length of own - hand and partner > 1 */ - if ((lhoTrumpRanks==0)&&(rhoTrumpRanks==0)) { - posPoint->winRanks[depth][suit]|= - bitMapRank[posPoint->secondBest[suit].rank]; - qt++; - if (qt>=cutoff) - return qt; - if ((countLho<=2)&&(countRho<=2)&&((countPart<=2)||(countOwn<=2))) { - qt+=Max(countOwn-2, countPart-2); - if (qt>=cutoff) - return qt; - *res=2; - return qt; - } - } - } - *res=0; - return qt; -} - -int QtricksLeadHandNT(int hand, struct pos *posPoint, int cutoff, int depth, - int countLho, int countRho, int *lhoTrumpRanks, int *rhoTrumpRanks, - int commPartner, int commSuit, int countOwn, - int countPart, int suit, int qtricks, int trump, int *res) { - /* res=0 Continue with same suit. - res=1 Cutoff. - res=2 Continue with next suit. */ - - - *res=1; - int qt=qtricks; - posPoint->winRanks[depth][suit]|=bitMapRank[posPoint->winner[suit].rank]; - qt++; - if (qt>=cutoff) - return qt; - if ((trump==suit) && ((!commPartner) || (suit!=commSuit))) { - /*if (trump==suit) {*/ - (*lhoTrumpRanks)=Max(0, (*lhoTrumpRanks)-1); - (*rhoTrumpRanks)=Max(0, (*rhoTrumpRanks)-1); - } - - if ((countLho<=1)&&(countRho<=1)&&(countPart<=1)) { - qt+=countOwn-1; - if (qt>=cutoff) - return qt; - *res=2; - return qt; - } - - if (posPoint->secondBest[suit].hand==hand) { - posPoint->winRanks[depth][suit]|= - bitMapRank[posPoint->secondBest[suit].rank]; - qt++; - if (qt>=cutoff) - return qt; - if ((trump==suit) && ((!commPartner) || (suit!=commSuit))) { - (*lhoTrumpRanks)=Max(0, (*lhoTrumpRanks)-1); - (*rhoTrumpRanks)=Max(0, (*rhoTrumpRanks)-1); - } - if ((countLho<=2)&&(countRho<=2)&&(countPart<=2)) { - qt+=countOwn-2; - if (qt>=cutoff) - return qt; - *res=2; - return qt; - } - /*else { - aggr=0; - for (k=0; k<=3; k++) - aggr|=posPoint->rankInSuit[k][suit]; - if (rel[aggr].absRank[3][suit].hand==hand) { - qt++; - posPoint->winRanks[depth][suit]|= - bitMapRank[rel[aggr].absRank[3][suit].rank]; - if (qt>=cutoff) - return qt; - if ((countLho<=3)&&(countRho<=3)&&(countPart<=3)) { - qt+=countOwn-3; - if (qt>=cutoff) - return qt; - } - *res=2; - return qt; - } - }*/ - } - else if ((posPoint->secondBest[suit].hand==partner[hand]) - &&(countOwn>1)&&(countPart>1)) { - /* Second best at partner and suit length of own - hand and partner > 1 */ - posPoint->winRanks[depth][suit]|= - bitMapRank[posPoint->secondBest[suit].rank]; - qt++; - if (qt>=cutoff) - return qt; - if ((trump==suit) && ((!commPartner) || (suit!=commSuit))) { - (*lhoTrumpRanks)=Max(0, (*lhoTrumpRanks)-1); - (*rhoTrumpRanks)=Max(0, (*rhoTrumpRanks)-1); - } - if ((countLho<=2)&&(countRho<=2)&&((countPart<=2)||(countOwn<=2))) { - qt+=Max(countOwn-2,countPart-2); - if (qt>=cutoff) - return qt; - *res=2; - return qt; - } - /*else if (countPart>2) { - aggr=0; - for (k=0; k<=3; k++) - aggr|=posPoint->rankInSuit[k][suit]; - if (rel[aggr].absRank[3][suit].hand==hand) { - qt++; - posPoint->winRanks[depth][suit]|= - bitMapRank[rel[aggr].absRank[3][suit].rank]; - if (qt>=cutoff) - return qt; - *res=2; - return qt; - } - }*/ - } - - *res=0; - return qt; -} - - -int QuickTricksPartnerHandTrump(int hand, struct pos *posPoint, int cutoff, int depth, - int countLho, int countRho, int lhoTrumpRanks, int rhoTrumpRanks, int countOwn, - int countPart, int suit, int qtricks, int commSuit, int commRank, int trump, int *res, - struct localVarType * thrp) { - /* res=0 Continue with same suit. - res=1 Cutoff. - res=2 Continue with next suit. */ - - - *res=1; - int qt=qtricks; - if (((countLho!=0) || (lhoTrumpRanks==0)) && ((countRho!=0) || (rhoTrumpRanks==0))) { - posPoint->winRanks[depth][suit]|=bitMapRank[posPoint->winner[suit].rank]; - posPoint->winRanks[depth][commSuit]|=bitMapRank[commRank]; - qt++; /* A trick can be taken */ - if (qt>=cutoff) - return qt; - if ((countLho<=1)&&(countRho<=1)&&(countOwn<=1)&&(lhoTrumpRanks==0)&& - (rhoTrumpRanks==0)) { - qt+=countPart-1; - if (qt>=cutoff) - return qt; - *res=2; - return qt; - } - } - - if (posPoint->secondBest[suit].hand==partner[hand]) { - /* Second best found in partners hand */ - if ((lhoTrumpRanks==0)&&(rhoTrumpRanks==0)) { - /* Opponents have no trump */ - posPoint->winRanks[depth][suit]|=bitMapRank[posPoint->secondBest[suit].rank]; - posPoint->winRanks[depth][commSuit]|=bitMapRank[commRank]; - qt++; - if (qt>=cutoff) - return qt; - if ((countLho<=2)&&(countRho<=2)&&(countOwn<=2)) { - qt+=countPart-2; - if (qt>=cutoff) - return qt; - *res=2; - return qt; - } - } - } - else if ((posPoint->secondBest[suit].hand==hand)&&(countPart>1)&&(countOwn>1)) { - /* Second best found in own hand and suit lengths of own hand and partner > 1*/ - if ((lhoTrumpRanks==0)&&(rhoTrumpRanks==0)) { - /* Opponents have no trump */ - posPoint->winRanks[depth][suit]|=bitMapRank[posPoint->secondBest[suit].rank]; - posPoint->winRanks[depth][commSuit]|=bitMapRank[commRank]; - qt++; - if (qt>=cutoff) - return qt; - if ((countLho<=2)&&(countRho<=2)&&((countOwn<=2)||(countPart<=2))) { - qt+=Max(countPart-2,countOwn-2); - if (qt>=cutoff) - return qt; - *res=2; - return qt; - } - } - } - else if ((suit==commSuit)&&(posPoint->secondBest[suit].hand==lho[hand])&& - ((countLho>=2)||(lhoTrumpRanks==0))&&((countRho>=2)||(rhoTrumpRanks==0))) { - unsigned short ranks=0; - for (int k=0; k<=3; k++) - ranks|=posPoint->rankInSuit[k][suit]; - if (thrp->abs[ranks].absRank[3][suit].hand==partner[hand]) { - posPoint->winRanks[depth][suit]|=bitMapRank[thrp->abs[ranks].absRank[3][suit].rank]; - posPoint->winRanks[depth][commSuit]|=bitMapRank[commRank]; - qt++; - if (qt>=cutoff) - return qt; - if ((countOwn<=2)&&(countLho<=2)&&(countRho<=2)&&(lhoTrumpRanks==0)&&(rhoTrumpRanks==0)) { - qt+=countPart-2; - if (qt>=cutoff) - return qt; - } - } - } - *res=0; - return qt; -} - - -int QuickTricksPartnerHandNT(int hand, struct pos *posPoint, int cutoff, int depth, - int countLho, int countRho, int countOwn, - int countPart, int suit, int qtricks, int commSuit, int commRank, int trump, - int *res, struct localVarType * thrp) { - - *res=1; - int qt=qtricks; - - posPoint->winRanks[depth][suit]|=bitMapRank[posPoint->winner[suit].rank]; - posPoint->winRanks[depth][commSuit]|=bitMapRank[commRank]; - qt++; - if (qt>=cutoff) - return qt; - if ((countLho<=1)&&(countRho<=1)&&(countOwn<=1)) { - qt+=countPart-1; - if (qt>=cutoff) - return qt; - *res=2; - return qt; - } - - if ((posPoint->secondBest[suit].hand==partner[hand])&&(1/*countPart>0*/)) { - /* Second best found in partners hand */ - posPoint->winRanks[depth][suit]|=bitMapRank[posPoint->secondBest[suit].rank]; - qt++; - if (qt>=cutoff) - return qt; - if ((countLho<=2)&&(countRho<=2)&&(countOwn<=2)) { - qt+=countPart-2; - if (qt>=cutoff) - return qt; - *res=2; - return qt; - } - } - else if ((posPoint->secondBest[suit].hand==hand) - &&(countPart>1)&&(countOwn>1)) { - /* Second best found in own hand and own and - partner's suit length > 1 */ - posPoint->winRanks[depth][suit]|=bitMapRank[posPoint->secondBest[suit].rank]; - qt++; - if (qt>=cutoff) - return qt; - if ((countLho<=2)&&(countRho<=2)&&((countOwn<=2)||(countPart<=2))) { - qt+=Max(countPart-2,countOwn-2); - if (qt>=cutoff) - return qt; - *res=2; - return qt; - } - } - else if ((suit==commSuit)&&(posPoint->secondBest[suit].hand==lho[hand])) { - unsigned short ranks=0; - for (int k=0; k<=3; k++) - ranks|=posPoint->rankInSuit[k][suit]; - if (thrp->abs[ranks].absRank[3][suit].hand==partner[hand]) { - posPoint->winRanks[depth][suit]|=bitMapRank[thrp->abs[ranks].absRank[3][suit].rank]; - qt++; - if (qt>=cutoff) - return qt; - if ((countOwn<=2)&&(countLho<=2)&&(countRho<=2)) { - qtricks+=countPart-2; - if (qt>=cutoff) - return qt; - } - } - } - *res=0; - return qt; -} - - -int LaterTricksMIN(struct pos *posPoint, int hand, int depth, int target, - int trump, struct localVarType * thrp) { - int hh, ss, k, h, sum=0; - /*unsigned short aggr;*/ - - if ((trump==4)||(posPoint->winner[trump].rank==0)) { - for (ss=0; ss<=3; ss++) { - hh=posPoint->winner[ss].hand; - if (hh!=-1) { - if (thrp->nodeTypeStore[hh]==MAXNODE) - sum+=Max(posPoint->length[hh][ss], posPoint->length[partner[hh]][ss]); - } - } - if ((posPoint->tricksMAX+sum0)&&(depth>0)&&(depth!=thrp->iniDepth)) { - if ((posPoint->tricksMAX+(depth>>2)winner[ss].hand==-1) - posPoint->winRanks[depth][ss]=0; - else if (thrp->nodeTypeStore[posPoint->winner[ss].hand]==MINNODE) { - if ((posPoint->rankInSuit[partner[posPoint->winner[ss].hand]][ss]==0)&& - (posPoint->rankInSuit[lho[posPoint->winner[ss].hand]][ss]==0)&& - (posPoint->rankInSuit[rho[posPoint->winner[ss].hand]][ss]==0)) - posPoint->winRanks[depth][ss]=0; - else - posPoint->winRanks[depth][ss]=bitMapRank[posPoint->winner[ss].rank]; - } - else - posPoint->winRanks[depth][ss]=0; - } - return FALSE; - } - } - } - else if ((trump!=4) && (posPoint->winner[trump].rank!=0) && - (thrp->nodeTypeStore[posPoint->winner[trump].hand]==MINNODE)) { - if ((posPoint->length[hand][trump]==0)&& - (posPoint->length[partner[hand]][trump]==0)) { - if (((posPoint->tricksMAX+(depth>>2)+1- - Max(posPoint->length[lho[hand]][trump], - posPoint->length[rho[hand]][trump]))0)&&(depth!=thrp->iniDepth)) { - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth][ss]=0; - return FALSE; - } - } - else if (((posPoint->tricksMAX+(depth>>2))0)&&(depth!=thrp->iniDepth)) { - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth][ss]=0; - posPoint->winRanks[depth][trump]= - bitMapRank[posPoint->winner[trump].rank]; - return FALSE; - } - else { - hh=posPoint->secondBest[trump].hand; - if (hh!=-1) { - if ((thrp->nodeTypeStore[hh]==MINNODE)&&(posPoint->secondBest[trump].rank!=0)) { - if (((posPoint->length[hh][trump]>1) || - (posPoint->length[partner[hh]][trump]>1))&& - ((posPoint->tricksMAX+(depth>>2)-1)0) - &&(depth!=thrp->iniDepth)) { - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth][ss]=0; - posPoint->winRanks[depth][trump]= - bitMapRank[posPoint->secondBest[trump].rank] ; - return FALSE; - } - } - } - } - } - else if (trump!=4) { - hh=posPoint->secondBest[trump].hand; - if (hh!=-1) { - if ((thrp->nodeTypeStore[hh]==MINNODE)&& - (posPoint->length[hh][trump]>1)) { - if (posPoint->winner[trump].hand==rho[hh]) { - if (((posPoint->tricksMAX+(depth>>2))0)&&(depth!=thrp->iniDepth)) { - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth][ss]=0; - posPoint->winRanks[depth][trump]= - bitMapRank[posPoint->secondBest[trump].rank]; - return FALSE; - } - } - else { - unsigned short aggr=0; - for (k=0; k<=3; k++) - aggr|=posPoint->rankInSuit[k][trump]; - h=thrp->abs[aggr].absRank[3][trump].hand; - if (h!=-1) { - if ((thrp->nodeTypeStore[h]==MINNODE)&& - ((posPoint->tricksMAX+(depth>>2))0)&&(depth!=thrp->iniDepth)) { - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth][ss]=0; - posPoint->winRanks[depth][trump]= - bitMapRank[thrp->abs[aggr].absRank[3][trump].rank]; - return FALSE; - } - } - } - } - } - } - return TRUE; -} - - -int LaterTricksMAX(struct pos *posPoint, int hand, int depth, int target, - int trump, struct localVarType * thrp) { - int hh, ss, k, h, sum=0; - /*unsigned short aggr;*/ - - if ((trump==4)||(posPoint->winner[trump].rank==0)) { - for (ss=0; ss<=3; ss++) { - hh=posPoint->winner[ss].hand; - if (hh!=-1) { - if (thrp->nodeTypeStore[hh]==MINNODE) - sum+=Max(posPoint->length[hh][ss], posPoint->length[partner[hh]][ss]); - } - } - if ((posPoint->tricksMAX+(depth>>2)+1-sum>=target)&& - (sum>0)&&(depth>0)&&(depth!=thrp->iniDepth)) { - if ((posPoint->tricksMAX+1>=target)) { - for (ss=0; ss<=3; ss++) { - if (posPoint->winner[ss].hand==-1) - posPoint->winRanks[depth][ss]=0; - else if (thrp->nodeTypeStore[posPoint->winner[ss].hand]==MAXNODE) { - if ((posPoint->rankInSuit[partner[posPoint->winner[ss].hand]][ss]==0)&& - (posPoint->rankInSuit[lho[posPoint->winner[ss].hand]][ss]==0)&& - (posPoint->rankInSuit[rho[posPoint->winner[ss].hand]][ss]==0)) - posPoint->winRanks[depth][ss]=0; - else - posPoint->winRanks[depth][ss]=bitMapRank[posPoint->winner[ss].rank]; - } - else - posPoint->winRanks[depth][ss]=0; - } - return TRUE; - } - } - } - else if ((trump!=4) && (posPoint->winner[trump].rank!=0) && - (thrp->nodeTypeStore[posPoint->winner[trump].hand]==MAXNODE)) { - if ((posPoint->length[hand][trump]==0)&& - (posPoint->length[partner[hand]][trump]==0)) { - if (((posPoint->tricksMAX+Max(posPoint->length[lho[hand]][trump], - posPoint->length[rho[hand]][trump]))>=target) - &&(depth>0)&&(depth!=thrp->iniDepth)) { - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth][ss]=0; - return TRUE; - } - } - else if (((posPoint->tricksMAX+1)>=target) - &&(depth>0)&&(depth!=thrp->iniDepth)) { - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth][ss]=0; - posPoint->winRanks[depth][trump]= - bitMapRank[posPoint->winner[trump].rank]; - return TRUE; - } - else { - hh=posPoint->secondBest[trump].hand; - if (hh!=-1) { - if ((thrp->nodeTypeStore[hh]==MAXNODE)&&(posPoint->secondBest[trump].rank!=0)) { - if (((posPoint->length[hh][trump]>1) || - (posPoint->length[partner[hh]][trump]>1))&& - ((posPoint->tricksMAX+2)>=target)&&(depth>0) - &&(depth!=thrp->iniDepth)) { - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth][ss]=0; - posPoint->winRanks[depth][trump]= - bitMapRank[posPoint->secondBest[trump].rank]; - return TRUE; - } - } - } - } - } - - else if (trump!=4) { - hh=posPoint->secondBest[trump].hand; - if (hh!=-1) { - if ((thrp->nodeTypeStore[hh]==MAXNODE)&& - (posPoint->length[hh][trump]>1)) { - if (posPoint->winner[trump].hand==rho[hh]) { - if (((posPoint->tricksMAX+1)>=target)&&(depth>0) - &&(depth!=thrp->iniDepth)) { - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth][ss]=0; - posPoint->winRanks[depth][trump]= - bitMapRank[posPoint->secondBest[trump].rank] ; - return TRUE; - } - } - else { - unsigned short aggr=0; - for (k=0; k<=3; k++) - aggr|=posPoint->rankInSuit[k][trump]; - h=thrp->abs[aggr].absRank[3][trump].hand; - if (h!=-1) { - if ((thrp->nodeTypeStore[h]==MAXNODE)&& - ((posPoint->tricksMAX+1)>=target)&&(depth>0) - &&(depth!=thrp->iniDepth)) { - for (ss=0; ss<=3; ss++) - posPoint->winRanks[depth][ss]=0; - posPoint->winRanks[depth][trump]= - bitMapRank[thrp->abs[aggr].absRank[3][trump].rank]; - return TRUE; - } - } - } - } - } - } - return FALSE; -} - - -int MoveGen(struct pos * posPoint, int depth, int trump, struct movePlyType *mply, - struct localVarType * thrp) { - int k, state=MOVESVALID; - - int WeightAllocTrump(struct pos * posPoint, struct moveType * mp, int depth, - unsigned short notVoidInSuit, int trump, struct localVarType * thrp); - int WeightAllocNT(struct pos * posPoint, struct moveType * mp, int depth, - unsigned short notVoidInSuit, struct localVarType * thrp); - - for (k=0; k<4; k++) - thrp->lowestWin[depth][k]=0; - - int m=0; - int r=posPoint->handRelFirst; - int first=posPoint->first[depth]; - int q=handId(first, r); - - if (r!=0) { - int s=thrp->movePly[depth+r].current; /* Current move of first hand */ - int t=thrp->movePly[depth+r].move[s].suit; /* Suit played by first hand */ - unsigned short ris=posPoint->rankInSuit[q][t]; - - if (ris!=0) { - /* Not first hand and not void in suit */ - k=14; - while (k>=2) { - if ((ris & bitMapRank[k])&&(state==MOVESVALID)) { - /* Only first move in sequence is generated */ - mply->move[m].suit=t; - mply->move[m].rank=k; - mply->move[m].sequence=0; - m++; - state=MOVESLOCKED; - } - else if (state==MOVESLOCKED) { - if (ris & bitMapRank[k]) - /* If the card is in own hand */ - mply->move[m-1].sequence|=bitMapRank[k]; - else if ((posPoint->removedRanks[t] & bitMapRank[k])==0) - /* If the card still exists and it is not in own hand */ - state=MOVESVALID; - } - k--; - } - if (m!=1) { - if ((trump!=4)&&(posPoint->winner[trump].rank!=0)) { - for (k=0; k<=m-1; k++) - mply->move[k].weight=WeightAllocTrump(posPoint, - &(mply->move[k]), depth, ris, trump, thrp); - } - else { - for (k=0; k<=m-1; k++) - mply->move[k].weight=WeightAllocNT(posPoint, - &(mply->move[k]), depth, ris, thrp); - } - } - - mply->last=m-1; - if (m!=1) - MergeSort(m, mply->move); - if (depth!=thrp->iniDepth) - return m; - else { - m=AdjustMoveList(thrp); - return m; - } - } - } - - /* First hand or void in suit */ - for (int suit=0; suit<=3; suit++) { - k=14; state=MOVESVALID; - while (k>=2) { - if ((posPoint->rankInSuit[q][suit] & bitMapRank[k])&& - (state==MOVESVALID)) { - /* Only first move in sequence is generated */ - mply->move[m].suit=suit; - mply->move[m].rank=k; - mply->move[m].sequence=0; - m++; - state=MOVESLOCKED; - } - else if (state==MOVESLOCKED) { - if (posPoint->rankInSuit[q][suit] & bitMapRank[k]) - /* If the card is in own hand */ - mply->move[m-1].sequence|=bitMapRank[k]; - else if ((posPoint->removedRanks[suit] & bitMapRank[k])==0) - /* If the card still exists and it is not in own hand */ - state=MOVESVALID; - } - k--; - } - } - - if ((trump!=4)&&(posPoint->winner[trump].rank!=0)) { - for (k=0; k<=m-1; k++) - mply->move[k].weight=WeightAllocTrump(posPoint, - &(mply->move[k]), depth, 0/*ris*/, trump, thrp); - } - else { - for (k=0; k<=m-1; k++) - mply->move[k].weight=WeightAllocNT(posPoint, - &(mply->move[k]), depth, 0/*ris*/, thrp); - } - - mply->last=m-1; - if (m!=1) - MergeSort(m, mply->move); - - if (depth!=thrp->iniDepth) - return m; - else { - m=AdjustMoveList(thrp); - return m; - } -} - - -int WeightAllocNT(struct pos * posPoint, struct moveType * mp, int depth, - unsigned short notVoidInSuit, struct localVarType * thrp) { - int weight=0, k, l, kk, ll, suitAdd=0, leadSuit; - int suitWeightDelta; - int thirdBestHand; - int winMove=FALSE; /* If winMove is TRUE, current move can win the current trick. */ - unsigned short suitCount, suitCountLH, suitCountRH; - int countLH, countRH; - - int first=posPoint->first[depth]; - int q=handId(first, posPoint->handRelFirst); - int suit=mp->suit; - unsigned short aggr=0; - for (int m=0; m<=3; m++) - aggr|=posPoint->rankInSuit[m][suit]; - int rRank=relRanks->relRank[aggr][mp->rank]; - - - switch (posPoint->handRelFirst) { - case 0: - suitCount=posPoint->length[q][suit]; - suitCountLH=posPoint->length[lho[q]][suit]; - suitCountRH=posPoint->length[rho[q]][suit]; - - if (suitCountLH!=0) { - countLH=(suitCountLH<<2); - } - else - countLH=depth+4; - - if (suitCountRH!=0) { - countRH=(suitCountRH<<2); - } - else - countRH=depth+4; - - /* Discourage a suit selection where the search tree appears larger than for the - altenative suits: the search is estimated to be small when the added number of - alternative cards to play for the opponents is small. */ - - suitWeightDelta=-((countLH+countRH)<<5)/19; - - if (posPoint->length[partner[q]][suit]==0) - suitWeightDelta+=-9; - - if (posPoint->winner[suit].rank==mp->rank) - winMove=TRUE; /* May also have 2nd best, but this card will not be searched. */ - else if (posPoint->rankInSuit[partner[first]][suit] > - (posPoint->rankInSuit[lho[first]][suit] | - posPoint->rankInSuit[rho[first]][suit])) { - winMove=TRUE; - } - - if (winMove) { - /* Discourage suit if RHO has second best card. - Exception: RHO has singleton. */ - if (posPoint->secondBest[suit].hand==rho[q]) { - if (suitCountRH!=1) - suitWeightDelta+=-1; - } - /* Encourage playing suit if LHO has second highest rank. */ - else if (posPoint->secondBest[suit].hand==lho[q]) { - if (suitCountLH!=1) - suitWeightDelta+=22; - else - suitWeightDelta+=16; - } - - /* Higher weight if also second best rank is present on current side to play, or - if second best is a singleton at LHO or RHO. */ - - if (((posPoint->secondBest[suit].hand!=lho[first]) - ||(suitCountLH==1))&& - ((posPoint->secondBest[suit].hand!=rho[first]) - ||(suitCountRH==1))) - weight=suitWeightDelta+45+rRank; - else - weight=suitWeightDelta+18+rRank; - - /* Encourage playing cards that previously caused search cutoff - or was stored as the best move in a transposition table entry match. */ - - if ((thrp->bestMove[depth].suit==suit)&& - (thrp->bestMove[depth].rank==mp->rank)) - weight+=126; - else if ((thrp->bestMoveTT[depth].suit==suit)&& - (thrp->bestMoveTT[depth].rank==mp->rank)) - weight+=32/*24*/; - } - else { - /* Discourage suit if RHO has winning or second best card. - Exception: RHO has singleton. */ - - if ((posPoint->winner[suit].hand==rho[q])|| - (posPoint->secondBest[suit].hand==rho[q])) { - if (suitCountRH!=1) - suitWeightDelta+=-10; - } - - - /* Try suit if LHO has winning card and partner second best. - Exception: partner has singleton. */ - - else if ((posPoint->winner[suit].hand==lho[q])&& - (posPoint->secondBest[suit].hand==partner[q])) { - - /* This case was suggested by Joël Bradmetz. */ - - if (posPoint->length[partner[q]][suit]!=1) - suitWeightDelta+=31; - } - - /* Encourage playing the suit if the hand together with partner have both the 2nd highest - and the 3rd highest cards such that the side of the hand has the highest card in the - next round playing this suit. */ - - thirdBestHand=thrp->abs[aggr].absRank[3][suit].hand; - - if ((posPoint->secondBest[suit].hand==partner[first])&&(partner[first]==thirdBestHand)) - suitWeightDelta+=35; - else if(((posPoint->secondBest[suit].hand==first)&&(partner[first]==thirdBestHand)&& - (posPoint->length[partner[first]][suit]>1))||((posPoint->secondBest[suit].hand==partner[first])&& - (first==thirdBestHand)&&(posPoint->length[partner[first]][suit]>1))) - suitWeightDelta+=25; - - /* Higher weight if LHO or RHO has the highest (winning) card as a singleton. */ - - if (((suitCountLH==1)&&(posPoint->winner[suit].hand==lho[first])) - ||((suitCountRH==1)&&(posPoint->winner[suit].hand==rho[first]))) - weight=suitWeightDelta+28+rRank; - else if (posPoint->winner[suit].hand==first) { - weight=suitWeightDelta-17+rRank; - } - else if ((mp->sequence)&& - (mp->rank==posPoint->secondBest[suit].rank)) - weight=suitWeightDelta+48; - else if (mp->sequence) - weight=suitWeightDelta+29-rRank; - else - weight=suitWeightDelta+12+rRank; - - /* Encourage playing cards that previously caused search cutoff - or was stored as the best move in a transposition table entry match. */ - - if ((thrp->bestMove[depth].suit==suit)&& - (thrp->bestMove[depth].rank==mp->rank)) - weight+=47; - else if ((thrp->bestMoveTT[depth].suit==suit)&& - (thrp->bestMoveTT[depth].rank==mp->rank)) - weight+=19; - } - - break; - - case 1: - leadSuit=posPoint->move[depth+1].suit; - if (leadSuit==suit) { - if (bitMapRank[mp->rank]> - (bitMapRank[posPoint->move[depth+1].rank] | - posPoint->rankInSuit[partner[first]][suit])) - winMove=TRUE; - else if (posPoint->rankInSuit[rho[first]][suit]> - (bitMapRank[posPoint->move[depth+1].rank] | - posPoint->rankInSuit[partner[first]][suit])) - winMove=TRUE; - } - else { - /* Side with highest rank in leadSuit wins */ - - if (posPoint->rankInSuit[rho[first]][leadSuit] > - (posPoint->rankInSuit[partner[first]][leadSuit] | - bitMapRank[posPoint->move[depth+1].rank])) - winMove=TRUE; - } - - if (winMove) { - if (!notVoidInSuit) { - suitCount=posPoint->length[q][suit]; - suitAdd=(suitCount<<6)/(23/*20*//*21*//*24*//*30*//*35*/); - if (posPoint->secondBest[suit].hand==q) { - /* Discourage suit discard if 2nd highest card becomes singleton. */ - - if (suitCount==2) - suitAdd+=-2; - } - /* Discourage suit discard of highest card. */ - - else if ((suitCount==1)&&(posPoint->winner[suit].hand==q)) - suitAdd+=-3; - - /*Encourage discard of low cards in long suits. */ - weight=-4-(mp->rank)+suitAdd; - } - else { - weight=81/*80*/+rRank; - } - } - else { - if (!notVoidInSuit) { - suitCount=posPoint->length[q][suit]; - suitAdd=(suitCount<<6)/33; - - /* Discourage suit discard if 2nd highest card becomes singleton. */ - if ((suitCount==2)&&(posPoint->secondBest[suit].hand==q)) - suitAdd+=-6; - - /* Discourage suit discard of highest card. */ - else if ((suitCount==1)&&(posPoint->winner[suit].hand==q)) - suitAdd+=-8; - - /*Encourage discard of low cards in long suits. */ - weight=2-(mp->rank)+suitAdd; - } - else { - - /* If lowest rank for either partner to leading hand - or rho is higher than played card for lho, - lho should play as low card as possible */ - - kk=posPoint->rankInSuit[partner[first]][leadSuit]; - ll=posPoint->rankInSuit[rho[first]][leadSuit]; - k=kk & (-kk); l=ll & (-ll); /* Only least significant 1 bit of - bit map ranks for partner and RHO. */ - - if ((k > bitMapRank[mp->rank])||(l > bitMapRank[mp->rank])) - weight=-3+rRank; - else if (mp->rank > posPoint->move[depth+1].rank) { - if (mp->sequence) { - weight=/*0*/10+rRank; - } - else { - weight=13-(mp->rank); - /*weight=-5+rRank;*/ - } - } - else { - weight=-11/*15*/+rRank; - } - } - } - - break; - - case 2: - - leadSuit=posPoint->move[depth+2].suit; - if (WinningMoveNT(mp, &(posPoint->move[depth+1]))) { - if (bitMapRank[mp->rank] > - posPoint->rankInSuit[rho[first]][suit]) - winMove=TRUE; - } - else if (posPoint->high[depth+1]==first) { - if (posPoint->rankInSuit[rho[first]][leadSuit] - < bitMapRank[posPoint->move[depth+2].rank]) - winMove=TRUE; - - } - - if (winMove) { - if (!notVoidInSuit) { - suitCount=posPoint->length[q][suit]; - suitAdd=(suitCount<<6)/(17/*27*//*30*//*35*/); - - /* Discourage suit discard if 2nd highest card becomes singleton. */ - if ((suitCount==2)&&(posPoint->secondBest[suit].hand==q)) - suitAdd-=(6/*2*//*5*/); - weight=-(mp->rank)+suitAdd; - } - else { - weight=60+rRank; - } - } - else { - if (!notVoidInSuit) { - suitCount=posPoint->length[q][suit]; - suitAdd=(suitCount<<6)/(24/*26*//*29*//*35*/); - if ((suitCount==2)&&(posPoint->secondBest[suit].hand==q)) - suitAdd-=(4/*5*/); - /* Discourage suit discard of highest card. */ - else if ((suitCount==1)&&(posPoint->winner[suit].hand==q)) - suitAdd-=(4/*5*/); - - weight=-(mp->rank)+suitAdd; - - } - else { - - k=posPoint->rankInSuit[rho[first]][suit]; - if ((k & (-k)) > bitMapRank[mp->rank]) - weight=-(mp->rank); - else if (WinningMoveNT(mp, &(posPoint->move[depth+1]))) { - if ((mp->rank==posPoint->secondBest[leadSuit].rank)&& - (mp->sequence)) - weight=25; - else if (mp->sequence) - weight=20-(mp->rank); - else - weight=10-(mp->rank); - } - else - weight=-10-(mp->rank); - } - } - - break; - - case 3: - if (!notVoidInSuit) { - suitCount=posPoint->length[q][suit]; - suitAdd=(suitCount<<6)/(27/*35*/); - if ((suitCount==2)&&(posPoint->secondBest[suit].hand==q)) - suitAdd-=(6/*5*/); - else if ((suitCount==1)&&(posPoint->winner[suit].hand==q)) - suitAdd-=(8/*9*//*8*//*5*/); - - weight=30-(mp->rank)+suitAdd; - } - else if ((posPoint->high[depth+1])==(lho[first])) { - /* If the current winning move is given by the partner */ - weight=30-(mp->rank); - } - else if (WinningMoveNT(mp, &(posPoint->move[depth+1]))) - /* If present move is superior to current winning move and the - current winning move is not given by the partner */ - weight=30-(mp->rank); - else { - /* If present move is not superior to current winning move and the - current winning move is not given by the partner */ - weight=14-(mp->rank); - } - } - return weight; -} - - - -int WeightAllocTrump(struct pos * posPoint, struct moveType * mp, int depth, - unsigned short notVoidInSuit, int trump, struct localVarType * thrp) { - int weight=0, k, l, kk, ll, suitAdd=0, leadSuit; - int suitWeightDelta, thirdBestHand; - int suitBonus=0; - int winMove=FALSE; /* If winMove is true, current move can win the current trick. */ - unsigned short suitCount, suitCountLH, suitCountRH; - int countLH, countRH; - - int first=posPoint->first[depth]; - int q=handId(first, posPoint->handRelFirst); - int suit=mp->suit; - unsigned short aggr=0; - for (int m=0; m<=3; m++) - aggr|=posPoint->rankInSuit[m][suit]; - int rRank=relRanks->relRank[aggr][mp->rank]; - - switch (posPoint->handRelFirst) { - case 0: - suitCount=posPoint->length[q][suit]; - suitCountLH=posPoint->length[lho[q]][suit]; - suitCountRH=posPoint->length[rho[q]][suit]; - - /* Discourage suit if LHO or RHO can ruff. */ - - if ((suit!=trump) && - (((posPoint->rankInSuit[lho[q]][suit]==0) && - (posPoint->rankInSuit[lho[q]][trump]!=0)) || - ((posPoint->rankInSuit[rho[q]][suit]==0) && - (posPoint->rankInSuit[rho[q]][trump]!=0)))) - suitBonus=-12/*9*//*17*/; - - /* Encourage suit if partner can ruff. */ - - if ((suit!=trump)&&(posPoint->length[partner[q]][suit]==0)&& - (posPoint->length[partner[q]][trump]>0)&&(suitCountRH>0)) - suitBonus+=17/*26*/; - - /* Discourage suit if RHO has high card. */ - - if ((posPoint->winner[suit].hand==rho[q])|| - (posPoint->secondBest[suit].hand==rho[q])) { - if (suitCountRH!=1) - suitBonus+=-12/*13*//*11*/; - } - - /* Try suit if LHO has winning card and partner second best. - Exception: partner has singleton. */ - - else if ((posPoint->winner[suit].hand==lho[q])&& - (posPoint->secondBest[suit].hand==partner[q])) { - - /* This case was suggested by Joël Bradmetz. */ - - if (posPoint->length[partner[q]][suit]!=1) - suitBonus+=27/*25*//*30*/; - } - - /* Encourage play of suit where partner wins and - returns the suit for a ruff. */ - if ((suit!=trump)&&(suitCount==1)&& - (posPoint->length[q][trump]>0)&& - (posPoint->length[partner[q]][suit]>1)&& - (posPoint->winner[suit].hand==partner[q])) - suitBonus+=19/*26*//*23*/; - - if (suitCountLH!=0) - countLH=(suitCountLH<<2); - else - countLH=depth+4; - if (suitCountRH!=0) - countRH=(suitCountRH<<2); - else - countRH=depth+4; - - /* Discourage a suit selection where the search tree appears larger than for the - altenative suits: the search is estimated to be small when the added number of - alternative cards to play for the opponents is small. */ - - suitWeightDelta=suitBonus- - ((countLH+countRH)<<5)/13; - - if (posPoint->winner[suit].rank==mp->rank) { - if ((suit!=trump)) { - if ((posPoint->length[partner[first]][suit]!=0)|| - (posPoint->length[partner[first]][trump]==0)) { - if (((posPoint->length[lho[first]][suit]!=0)|| - (posPoint->length[lho[first]][trump]==0))&& - ((posPoint->length[rho[first]][suit]!=0)|| - (posPoint->length[rho[first]][trump]==0))) - winMove=TRUE; - } - else if (((posPoint->length[lho[first]][suit]!=0)|| - (posPoint->rankInSuit[partner[first]][trump]> - posPoint->rankInSuit[lho[first]][trump]))&& - ((posPoint->length[rho[first]][suit]!=0)|| - (posPoint->rankInSuit[partner[first]][trump]> - posPoint->rankInSuit[rho[first]][trump]))) - winMove=TRUE; - } - else - winMove=TRUE; - } - else if (posPoint->rankInSuit[partner[first]][suit] > - (posPoint->rankInSuit[lho[first]][suit] | - posPoint->rankInSuit[rho[first]][suit])) { - if (suit!=trump) { - if (((posPoint->length[lho[first]][suit]!=0)|| - (posPoint->length[lho[first]][trump]==0))&& - ((posPoint->length[rho[first]][suit]!=0)|| - (posPoint->length[rho[first]][trump]==0))) - winMove=TRUE; - } - else - winMove=TRUE; - } - else if (suit!=trump) { - if ((posPoint->length[partner[first]][suit]==0)&& - (posPoint->length[partner[first]][trump]!=0)) { - if ((posPoint->length[lho[first]][suit]==0)&& - (posPoint->length[lho[first]][trump]!=0)&& - (posPoint->length[rho[first]][suit]==0)&& - (posPoint->length[rho[first]][trump]!=0)) { - if (posPoint->rankInSuit[partner[first]][trump]> - (posPoint->rankInSuit[lho[first]][trump] | - posPoint->rankInSuit[rho[first]][trump])) - winMove=TRUE; - } - else if ((posPoint->length[lho[first]][suit]==0)&& - (posPoint->length[lho[first]][trump]!=0)) { - if (posPoint->rankInSuit[partner[first]][trump] - > posPoint->rankInSuit[lho[first]][trump]) - winMove=TRUE; - } - else if ((posPoint->length[rho[first]][suit]==0)&& - (posPoint->length[rho[first]][trump]!=0)) { - if (posPoint->rankInSuit[partner[first]][trump] - > posPoint->rankInSuit[rho[first]][trump]) - winMove=TRUE; - } - else - winMove=TRUE; - } - } - - if (winMove) { - - /* Encourage ruffing LHO or RHO singleton, highest card. */ - - if (((suitCountLH==1)&&(posPoint->winner[suit].hand==lho[first])) - ||((suitCountRH==1)&&(posPoint->winner[suit].hand==rho[first]))) - weight=suitWeightDelta+35/*37*//*39*/+rRank; - - /* Lead hand has the highest card. */ - - else if (posPoint->winner[suit].hand==first) { - - /* Also, partner has second highest card. */ - - if (posPoint->secondBest[suit].hand==partner[first]) - weight=suitWeightDelta+/*47*/48+rRank; - else if (posPoint->winner[suit].rank==mp->rank) - - /* If the current card to play is the highest card. */ - - weight=suitWeightDelta+31; - else - weight=suitWeightDelta-3+rRank; - } - else if (posPoint->winner[suit].hand==partner[first]) { - /* If partner has highest card */ - if (posPoint->secondBest[suit].hand==first) - weight=suitWeightDelta+42/*35*//*46*//*50*/+rRank; - else - weight=suitWeightDelta+28/*24*/+rRank; - } - /* Encourage playing second highest rank if hand also has - third highest rank. */ - - else if ((mp->sequence)&& - (mp->rank==posPoint->secondBest[suit].rank)) - weight=suitWeightDelta+40/*41*/; - else if (mp->sequence) - weight=suitWeightDelta+22/*17*/+rRank; - else - weight=suitWeightDelta+11+rRank; - - /* Encourage playing cards that previously caused search cutoff - or was stored as the best move in a transposition table entry match. */ - - if ((thrp->bestMove[depth].suit==suit)&& - (thrp->bestMove[depth].rank==mp->rank)) - weight+=55/*53*/; - else if ((thrp->bestMoveTT[depth].suit==suit)&& - (thrp->bestMoveTT[depth].rank==mp->rank)) - weight+=/*25*/18/*14*/; - } - else { - - /* Encourage playing the suit if the hand together with partner have both the 2nd highest - and the 3rd highest cards such that the side of the hand has the highest card in the - next round playing this suit. */ - - thirdBestHand=thrp->abs[aggr].absRank[3][suit].hand; - - if ((posPoint->secondBest[suit].hand==partner[first])&&(partner[first]==thirdBestHand)) - suitWeightDelta+=20/*22*/; - else if(((posPoint->secondBest[suit].hand==first)&&(partner[first]==thirdBestHand)&& - (posPoint->length[partner[first]][suit]>1))|| - ((posPoint->secondBest[suit].hand==partner[first])&& - (first==thirdBestHand)&&(posPoint->length[partner[first]][suit]>1))) - suitWeightDelta+=13/*20*//*24*/; - - /* Higher weight if LHO or RHO has the highest (winning) card as a singleton. */ - - if (((suitCountLH==1)&&(posPoint->winner[suit].hand==lho[first])) - ||((suitCountRH==1)&&(posPoint->winner[suit].hand==rho[first]))) - weight=suitWeightDelta+rRank+2/*-2*/; - else if (posPoint->winner[suit].hand==first) { - if (posPoint->secondBest[suit].hand==partner[first]) - - /* Opponents win by ruffing */ - - weight=suitWeightDelta+33+rRank; - else if (posPoint->winner[suit].rank==mp->rank) - - /* Opponents win by ruffing */ - - weight=suitWeightDelta+38/*36*/; - else - weight=suitWeightDelta-14/*17*/+rRank; - } - else if (posPoint->winner[suit].hand==partner[first]) { - - /* Opponents win by ruffing */ - - weight=suitWeightDelta+34/*33*/+rRank; - } - /* Encourage playing second highest rank if hand also has - third highest rank. */ - - else if ((mp->sequence)&& - (mp->rank==posPoint->secondBest[suit].rank)) - weight=suitWeightDelta+35/*31*/; - else - weight=suitWeightDelta+17/*13*/-(mp->rank); - - /* Encourage playing cards that previously caused search cutoff - or was stored as the best move in a transposition table entry match. */ - - if ((thrp->bestMove[depth].suit==suit)&& - (thrp->bestMove[depth].rank==mp->rank)) - weight+=18/*17*/; - /*else if ((thrp->bestMoveTT[depth].suit==suit)&& - (thrp->bestMoveTT[depth].rank==mp->rank)) - weight+=4;*/ - } - - break; - - case 1: - leadSuit=posPoint->move[depth+1].suit; - if (leadSuit==suit) { - if (bitMapRank[mp->rank]> - (bitMapRank[posPoint->move[depth+1].rank] | - posPoint->rankInSuit[partner[first]][suit])) { - if (suit!=trump) { - if ((posPoint->length[partner[first]][suit]!=0)|| - (posPoint->length[partner[first]][trump]==0)) - winMove=TRUE; - else if ((posPoint->length[rho[first]][suit]==0) - &&(posPoint->length[rho[first]][trump]!=0) - &&(posPoint->rankInSuit[rho[first]][trump]> - posPoint->rankInSuit[partner[first]][trump])) - winMove=TRUE; - } - else - winMove=TRUE; - } - else if (posPoint->rankInSuit[rho[first]][suit]> - (bitMapRank[posPoint->move[depth+1].rank] | - posPoint->rankInSuit[partner[first]][suit])) { - if (suit!=trump) { - if ((posPoint->length[partner[first]][suit]!=0)|| - (posPoint->length[partner[first]][trump]==0)) - winMove=TRUE; - } - else - winMove=TRUE; - } - else if (bitMapRank[posPoint->move[depth+1].rank] > - (posPoint->rankInSuit[rho[first]][suit] | - posPoint->rankInSuit[partner[first]][suit] | - bitMapRank[mp->rank])) { - if (suit!=trump) { - if ((posPoint->length[rho[first]][suit]==0)&& - (posPoint->length[rho[first]][trump]!=0)) { - if ((posPoint->length[partner[first]][suit]!=0)|| - (posPoint->length[partner[first]][trump]==0)) - winMove=TRUE; - else if (posPoint->rankInSuit[rho[first]][trump] - > posPoint->rankInSuit[partner[first]][trump]) - winMove=TRUE; - } - } - } - else { /* winnerHand is partner to first */ - if (suit!=trump) { - if ((posPoint->length[rho[first]][suit]==0)&& - (posPoint->length[rho[first]][trump]!=0)) - winMove=TRUE; - } - } - } - else { - - /* Leading suit differs from suit played by LHO */ - - if (suit==trump) { - if (posPoint->length[partner[first]][leadSuit]!=0) - winMove=TRUE; - else if (bitMapRank[mp->rank]> - posPoint->rankInSuit[partner[first]][trump]) - winMove=TRUE; - else if ((posPoint->length[rho[first]][leadSuit]==0) - &&(posPoint->length[rho[first]][trump]!=0)&& - (posPoint->rankInSuit[rho[first]][trump] > - posPoint->rankInSuit[partner[first]][trump])) - winMove=TRUE; - } - else if (leadSuit!=trump) { - - /* Neither suit nor leadSuit is trump */ - - if (posPoint->length[partner[first]][leadSuit]!=0) { - if (posPoint->rankInSuit[rho[first]][leadSuit] > - (posPoint->rankInSuit[partner[first]][leadSuit] | - bitMapRank[posPoint->move[depth+1].rank])) - winMove=TRUE; - else if ((posPoint->length[rho[first]][leadSuit]==0) - &&(posPoint->length[rho[first]][trump]!=0)) - winMove=TRUE; - } - - /* Partner to leading hand is void in leading suit */ - - else if ((posPoint->length[rho[first]][leadSuit]==0) - &&(posPoint->rankInSuit[rho[first]][trump]> - posPoint->rankInSuit[partner[first]][trump])) - winMove=TRUE; - else if ((posPoint->length[partner[first]][trump]==0) - &&(posPoint->rankInSuit[rho[first]][leadSuit] > - bitMapRank[posPoint->move[depth+1].rank])) - winMove=TRUE; - } - else { - /* Either no trumps or leadSuit is trump, side with - highest rank in leadSuit wins */ - if (posPoint->rankInSuit[rho[first]][leadSuit] > - (posPoint->rankInSuit[partner[first]][leadSuit] | - bitMapRank[posPoint->move[depth+1].rank])) - winMove=TRUE; - } - } - - - kk=posPoint->rankInSuit[partner[first]][leadSuit]; - ll=posPoint->rankInSuit[rho[first]][leadSuit]; - k=kk & (-kk); l=ll & (-ll); /* Only least significant 1 bit of - bit map ranks for partner and RHO. */ - - if (winMove) { - if (!notVoidInSuit) { - suitCount=posPoint->length[q][suit]; - suitAdd=(suitCount<<6)/(44/*36*/); - - /* Discourage suit discard if 2nd highest card becomes singleton. */ - - /*if ((suitCount==2)&&(posPoint->secondBest[suit].hand==q)) - suitAdd-=2;*/ - - if (suit==trump) - weight=24-(mp->rank)+suitAdd; - else - weight=60-(mp->rank)+suitAdd; /* Better discard than ruff since rho - wins anyway */ - } - else if (k > bitMapRank[mp->rank]) - weight=40+rRank; - - /* If lowest card for partner to leading hand - is higher than lho played card, playing as low as - possible will give the cheapest win */ - - else if ((ll > bitMapRank[posPoint->move[depth+1].rank])&& - (posPoint->rankInSuit[first][leadSuit] > ll)) - weight=41+rRank; - - /* If rho has a card in the leading suit that - is higher than the trick leading card but lower - than the highest rank of the leading hand, then - lho playing the lowest card will be the cheapest - win */ - - else if (mp->rank > posPoint->move[depth+1].rank) { - if (bitMapRank[mp->rank] < ll) - weight=78-(mp->rank); /* If played card is lower than any of the cards of - rho, it will be the cheapest win */ - else if (bitMapRank[mp->rank] > kk) - weight=73-(mp->rank); /* If played card is higher than any cards at partner - of the leading hand, rho can play low, under the - condition that he has a lower card than lho played */ - else { - if (mp->sequence) - weight=62-(mp->rank); - else - weight=49-(mp->rank); - } - } - else if (posPoint->length[rho[first]][leadSuit]>0) { - /*if (mp->sequence)*/ - weight=47-(mp->rank); /* Playing a card in a sequence may promote a winner */ - - /*else - weight=47-(mp->rank);*/ - } - else - weight=40-(mp->rank); - } - else { - if (!notVoidInSuit) { - suitCount=posPoint->length[q][suit]; - suitAdd=(suitCount<<6)/36; - - /* Discourage suit discard if 2nd highest card becomes singleton. */ - - if ((suitCount==2)&&(posPoint->secondBest[suit].hand==q)) - suitAdd+=-4; - - if (suit==trump) { - weight=15-(mp->rank)+suitAdd; /* Ruffing is preferred, makes the trick - costly for the opponents */ - } - else - weight=-2-(mp->rank)+suitAdd; - } - else if ((k > bitMapRank[mp->rank])|| - (l > bitMapRank[mp->rank])) - weight=-9+rRank; - - /* If lowest rank for either partner to leading hand - or rho is higher than played card for lho, - lho should play as low card as possible */ - - else if (mp->rank > posPoint->move[depth+1].rank) { - if (mp->sequence) - weight=22-(mp->rank); - else - weight=10-(mp->rank); - } - else - weight=-16+rRank; - } - break; - - case 2: - - leadSuit=posPoint->move[depth+2].suit; - if (WinningMove(mp, &(posPoint->move[depth+1]),trump)) { - if (suit==leadSuit) { - if (leadSuit!=trump) { - if (((posPoint->length[rho[first]][suit]!=0)|| - (posPoint->length[rho[first]][trump]==0))&& - (bitMapRank[mp->rank] > - posPoint->rankInSuit[rho[first]][suit])) - winMove=TRUE; - } - else if (bitMapRank[mp->rank] > - posPoint->rankInSuit[rho[first]][suit]) - winMove=TRUE; - } - else { /* Suit is trump */ - if (posPoint->length[rho[first]][leadSuit]==0) { - if (bitMapRank[mp->rank] > - posPoint->rankInSuit[rho[first]][trump]) - winMove=TRUE; - } - else - winMove=TRUE; - } - } - else if (posPoint->high[depth+1]==first) { - if (posPoint->length[rho[first]][leadSuit]!=0) { - if (posPoint->rankInSuit[rho[first]][leadSuit] - < bitMapRank[posPoint->move[depth+2].rank]) - winMove=TRUE; - } - else if (leadSuit==trump) - winMove=TRUE; - else if ((leadSuit!=trump) && - (posPoint->length[rho[first]][trump]==0)) - winMove=TRUE; - } - - if (winMove) { - if (!notVoidInSuit) { - suitCount=posPoint->length[q][suit]; - suitAdd=(suitCount<<6)/(50/*36*/); - - /* Discourage suit discard if 2nd highest card becomes singleton. */ - - /*if ((suitCount==2)&&(posPoint->secondBest[suit].hand==q)) - suitAdd-=(3);*/ - - if (posPoint->high[depth+1]==first) { - if (suit==trump) - weight=48-(mp->rank)+suitAdd; /* Ruffs partner's winner */ - else - weight=61-(mp->rank)+suitAdd; - } - else if (WinningMove(mp, &(posPoint->move[depth+1]),trump)) - - /* Own hand on top by ruffing */ - - weight=72-(mp->rank)+suitAdd; - } - else - weight=58-(mp->rank); - } - else { - if (!notVoidInSuit) { - suitCount=posPoint->length[q][suit]; - suitAdd=(suitCount<<6)/40; - - /* Discourage suit discard if 2nd highest card becomes singleton. */ - - /*if ((suitCount==2)&&(posPoint->secondBest[suit].hand==q)) - suitAdd-=(4);*/ - - if (WinningMove(mp, &(posPoint->move[depth+1]),trump)) - - /* Own hand on top by ruffing */ - - weight=40-(mp->rank)+suitAdd; - else if (suit==trump) - - /* Discard a trump but still losing */ - - weight=-32+rRank+suitAdd; - else - weight=-2-(mp->rank)+suitAdd; - } - else { - k=posPoint->rankInSuit[rho[first]][suit]; - if ((k & (-k)) > bitMapRank[mp->rank]) - - /* If least bit map rank of RHO to lead hand is higher than bit map rank - of current card move. */ - - weight=-3-(mp->rank); - - else if (WinningMove(mp, &(posPoint->move[depth+1]),trump)) { - - /* If current card move is highest so far. */ - - if (mp->rank==posPoint->secondBest[leadSuit].rank) - weight=29; - else if (mp->sequence) - weight=26/*20*/-(mp->rank); - else - weight=18-(mp->rank); - } - else - weight=-12-(mp->rank); - } - } - - break; - - case 3: - if (!notVoidInSuit) { - suitCount=posPoint->length[q][suit]; - suitAdd=(suitCount<<6)/(24/*36*/); - if ((suitCount==2)&&(posPoint->secondBest[suit].hand==q)) - suitAdd-=(2); - - if ((posPoint->high[depth+1])==lho[first]) { - - /* If the current winning move is given by the partner */ - - if (suit==trump) - - /* Ruffing partners winner? */ - - weight=2/*17*/-(mp->rank)+suitAdd; - else - weight=25-(mp->rank)+suitAdd; - } - else if (WinningMove(mp, &(posPoint->move[depth+1]),trump)) - - /* Own hand ruffs */ - - weight=33/*27*/+rRank+suitAdd; - else if (suit==trump) - weight=-13+rRank; - else - weight=14-(mp->rank)+suitAdd; - } - else if ((posPoint->high[depth+1])==(lho[first])) { - - /* If the current winning move is given by the partner */ - - if (suit==trump) - - /* Ruffs partners winner */ - - weight=11+rRank; - else - weight=17+rRank; - } - else if (WinningMove(mp, &(posPoint->move[depth+1]),trump)) - - /* If present move is superior to current winning move and the - current winning move is not given by the partner */ - - weight=22+rRank; - else { - - /* If present move is not superior to current winning move and the - current winning move is not given by the partner */ - - if (suit==trump) - - /* Ruffs but still loses */ - - weight=-13+rRank; - else - weight=1+rRank; - } - } - return weight; -} - - -/* Shell-1 */ -/* K&R page 62: */ -/*void shellSort(int n, int depth) { - int gap, i, j; - struct moveType temp; - - if (n==2) { - if (movePly[depth].move[0].weight>1; gap>0; gap>>=1) - for (i=gap; i=0 && movePly[depth].move[j].weight< - movePly[depth].move[j+gap].weight; j-=gap) { - temp=movePly[depth].move[j]; - movePly[depth].move[j]=movePly[depth].move[j+gap]; - movePly[depth].move[j+gap]=temp; - } -} */ - -/* Shell-2 */ -/*void shellSort(int n, int depth) -{ - int i, j, increment; - struct moveType temp; - - if (n==2) { - if (movePly[depth].move[0].weight 0) - { - for (i=0; i < n; i++) - { - j = i; - temp = movePly[depth].move[i]; - while ((j >= increment) && (movePly[depth].move[j-increment].weight < temp.weight)) - { - movePly[depth].move[j] = movePly[depth].move[j - increment]; - j = j - increment; - } - movePly[depth].move[j] = temp; - } - if ((increment>>1) != 0) - increment>>=1; - else if (increment == 1) - increment = 0; - else - increment = 1; - } -} */ - - -/* Insert-1 */ -/*void InsertSort(int n, int depth, struct movePlyType *mply, int thrId) { - int i, j; - struct moveType a, temp; - - if (n==2) { - if (mply->move[0].weightmove[1].weight) { - temp=mply->move[0]; - mply->move[0]=mply->move[1]; - mply->move[1]=temp; - return; - } - else - return; - } - - a=mply->move[0]; - for (i=1; i<=n-1; i++) - if (mply->move[i].weight>a.weight) { - temp=a; - a=mply->move[i]; - mply->move[i]=temp; - } - mply->move[0]=a; - for (i=2; i<=n-1; i++) { - j=i; - a=mply->move[i]; - while (a.weight>mply->move[j-1].weight) { - mply->move[j]=mply->move[j-1]; - j--; - } - mply->move[j]=a; - } -} */ - - -/* Insert-2 */ -/*void InsertSort(int n, int depth) { - int i, j; - struct moveType a; - - if (n==2) { - if (movePly[depth].move[0].weight=0)&&(movePly[depth].move[i].weight a[j - 1].weight ; --j) - a[j] = a[j - 1]; - a[j] = tmp; - } - } - - return; -} - - - -int AdjustMoveList(struct localVarType * thrp) { - int k, r, n, rank, suit; - - for (k=1; k<=13; k++) { - suit=thrp->forbiddenMoves[k].suit; - rank=thrp->forbiddenMoves[k].rank; - for (r=0; r<=thrp->movePly[thrp->iniDepth].last; r++) { - if ((suit==thrp->movePly[thrp->iniDepth].move[r].suit)&& - (rank!=0)&&(rank==thrp->movePly[thrp->iniDepth].move[r].rank)) { - /* For the forbidden move r: */ - for (n=r; n<=thrp->movePly[thrp->iniDepth].last; n++) - thrp->movePly[thrp->iniDepth].move[n]= - thrp->movePly[thrp->iniDepth].move[n+1]; - thrp->movePly[thrp->iniDepth].last--; - } - } - } - return thrp->movePly[thrp->iniDepth].last+1; -} - - -int InvBitMapRank(unsigned short bitMap) { - - switch (bitMap) { - case 0x1000: return 14; - case 0x0800: return 13; - case 0x0400: return 12; - case 0x0200: return 11; - case 0x0100: return 10; - case 0x0080: return 9; - case 0x0040: return 8; - case 0x0020: return 7; - case 0x0010: return 6; - case 0x0008: return 5; - case 0x0004: return 4; - case 0x0002: return 3; - case 0x0001: return 2; - default: return 0; - } -} - -int InvWinMask(int mask) { - - switch (mask) { - case 0x01000000: return 1; - case 0x00400000: return 2; - case 0x00100000: return 3; - case 0x00040000: return 4; - case 0x00010000: return 5; - case 0x00004000: return 6; - case 0x00001000: return 7; - case 0x00000400: return 8; - case 0x00000100: return 9; - case 0x00000040: return 10; - case 0x00000010: return 11; - case 0x00000004: return 12; - case 0x00000001: return 13; - default: return 0; - } -} - - -inline int WinningMove(struct moveType * mvp1, struct moveType * mvp2, int trump) { -/* Return TRUE if move 1 wins over move 2, with the assumption that -move 2 is the presently winning card of the trick */ - - if (mvp1->suit==mvp2->suit) { - if ((mvp1->rank)>(mvp2->rank)) - return TRUE; - else - return FALSE; - } - else if ((mvp1->suit)==trump) - return TRUE; - else - return FALSE; -} - - -inline int WinningMoveNT(struct moveType * mvp1, struct moveType * mvp2) { -/* Return TRUE if move 1 wins over move 2, with the assumption that -move 2 is the presently winning card of the trick */ - - if (mvp1->suit==mvp2->suit) { - if ((mvp1->rank)>(mvp2->rank)) - return TRUE; - else - return FALSE; - } - else - return FALSE; -} - - -struct nodeCardsType * CheckSOP(struct pos * posPoint, struct nodeCardsType - * nodep, int target, int tricks, int * result, int *value, - struct localVarType * thrp) { - /* Check SOP if it matches the - current position. If match, pointer to the SOP node is returned and - result is set to TRUE, otherwise pointer to SOP node is returned - and result set to FALSE. */ - - /* 07-04-22 */ - if (thrp->nodeTypeStore[0]==MAXNODE) { - if (nodep->lbound==-1) { /* This bound values for - this leading hand has not yet been determined */ - *result=FALSE; - return nodep; - } - else if ((posPoint->tricksMAX + nodep->lbound)>=target) { - *value=TRUE; - *result=TRUE; - return nodep; - } - else if ((posPoint->tricksMAX + nodep->ubound)ubound==-1) { /* This bound values for - this leading hand has not yet been determined */ - *result=FALSE; - return nodep; - } - else if ((posPoint->tricksMAX + (tricks + 1 - nodep->ubound))>=target) { - *value=TRUE; - *result=TRUE; - return nodep; - } - else if ((posPoint->tricksMAX + (tricks + 1 - nodep->lbound))lbound > nodep->lbound) || - (nodep->lbound==-1)) - nodep->lbound=posPoint->lbound; - if ((posPoint->ubound < nodep->ubound) || - (nodep->ubound==-1)) - nodep->ubound=posPoint->ubound; - - if (posPoint->bestMoveRank!=0) { - nodep->bestMoveSuit=posPoint->bestMoveSuit; - nodep->bestMoveRank=posPoint->bestMoveRank; - } - - return nodep; -} - - -struct nodeCardsType * FindSOP( - struct pos * posPoint, - struct winCardType * nodeP, - int firstHand, - int target, - int tricks, - int * valp, - struct localVarType * thrp) -{ - /* credit Soren Hein */ - - struct nodeCardsType * sopP; - struct winCardType * np; - int res; - - np = nodeP; - int s = 0; - - while (np) - { - if ((np->winMask & posPoint->orderSet[s]) == np->orderSet) - { - /* Winning rank set fits position */ - if (s != 3) - { - np = np->nextWin; - s++; - continue; - } - - sopP = CheckSOP(posPoint, np->first, target, tricks, - &res, valp, thrp); - if (res) - return sopP; - } - - while (np->next == NULL) - { - np = np->prevWin; - s--; - if (np == NULL) /* Previous node is header node? */ - return NULL; - } - np = np->next; - } - return NULL; -} - - -struct nodeCardsType * BuildPath(struct pos * posPoint, - struct posSearchType *nodep, int * result, struct localVarType * thrp) { - /* If result is TRUE, a new SOP has been created and BuildPath returns a - pointer to it. If result is FALSE, an existing SOP is used and BuildPath - returns a pointer to the SOP */ - - int found; - struct winCardType * np, * p2, /* * sp2,*/ * nprev, * fnp, *pnp; - struct winCardType temp; - struct nodeCardsType * sopP=0, * p/*, * sp*/; - - np=nodep->posSearchPoint; - nprev=NULL; - int suit=0; - - /* If winning node has a card that equals the next winning card deduced - from the position, then there already exists a (partial) path */ - - if (np==NULL) { /* There is no winning list created yet */ - /* Create winning nodes */ - p2=&(thrp->winCards[thrp->winSetSize]); - AddWinSet(thrp); - p2->next=NULL; - p2->nextWin=NULL; - p2->prevWin=NULL; - nodep->posSearchPoint=p2; - p2->winMask=posPoint->winMask[suit]; - p2->orderSet=posPoint->winOrderSet[suit]; - p2->first=NULL; - np=p2; /* Latest winning node */ - suit++; - while (suit<4) { - p2=&(thrp->winCards[thrp->winSetSize]); - AddWinSet(thrp); - np->nextWin=p2; - p2->prevWin=np; - p2->next=NULL; - p2->nextWin=NULL; - p2->winMask=posPoint->winMask[suit]; - p2->orderSet=posPoint->winOrderSet[suit]; - p2->first=NULL; - np=p2; /* Latest winning node */ - suit++; - } - p=&(thrp->nodeCards[thrp->nodeSetSize]); - AddNodeSet(thrp); - np->first=p; - *result=TRUE; - return p; - } - else { /* Winning list exists */ - while (1) { /* Find all winning nodes that correspond to current - position */ - found=FALSE; - while (1) { /* Find node amongst alternatives */ - if ((np->winMask==posPoint->winMask[suit])&& - (np->orderSet==posPoint->winOrderSet[suit])) { - /* Part of path found */ - found=TRUE; - nprev=np; - break; - } - if (np->next!=NULL) - np=np->next; - else - break; - } - if (found) { - suit++; - if (suit>3) { - sopP=UpdateSOP(posPoint, np->first); - - if (np->prevWin!=NULL) { - pnp=np->prevWin; - fnp=pnp->nextWin; - } - else - fnp=nodep->posSearchPoint; - - temp.orderSet=np->orderSet; - temp.winMask=np->winMask; - temp.first=np->first; - temp.nextWin=np->nextWin; - np->orderSet=fnp->orderSet; - np->winMask=fnp->winMask; - np->first=fnp->first; - np->nextWin=fnp->nextWin; - fnp->orderSet=temp.orderSet; - fnp->winMask=temp.winMask; - fnp->first=temp.first; - fnp->nextWin=temp.nextWin; - - *result=FALSE; - return sopP; - } - else { - np=np->nextWin; /* Find next winning node */ - continue; - } - } - else - break; /* Node was not found */ - } /* End outer while */ - - /* Create additional node, coupled to existing node(s) */ - p2=&(thrp->winCards[thrp->winSetSize]); - AddWinSet(thrp); - p2->prevWin=nprev; - if (nprev!=NULL) { - p2->next=nprev->nextWin; - nprev->nextWin=p2; - } - else { - p2->next=nodep->posSearchPoint; - nodep->posSearchPoint=p2; - } - p2->nextWin=NULL; - p2->winMask=posPoint->winMask[suit]; - p2->orderSet=posPoint->winOrderSet[suit]; - p2->first=NULL; - np=p2; /* Latest winning node */ - suit++; - - /* Rest of path must be created */ - while (suit<4) { - p2=&(thrp->winCards[thrp->winSetSize]); - AddWinSet(thrp); - np->nextWin=p2; - p2->prevWin=np; - p2->next=NULL; - p2->winMask=posPoint->winMask[suit]; - p2->orderSet=posPoint->winOrderSet[suit]; - p2->first=NULL; - p2->nextWin=NULL; - np=p2; /* Latest winning node */ - suit++; - } - - /* All winning nodes in SOP have been traversed and new nodes created */ - p=&(thrp->nodeCards[thrp->nodeSetSize]); - AddNodeSet(thrp); - np->first=p; - *result=TRUE; - return p; - } -} - - -struct posSearchType * SearchLenAndInsert(struct posSearchType - * rootp, long long key, int insertNode, int *result, - struct localVarType * thrp) { -/* Search for node which matches with the suit length combination - given by parameter key. If no such node is found, NULL is - returned if parameter insertNode is FALSE, otherwise a new - node is inserted with suitLengths set to key, the pointer to - this node is returned. - The algorithm used is defined in Knuth "The art of computer - programming", vol.3 "Sorting and searching", 6.2.2 Algorithm T, - page 424. */ - - struct posSearchType *np, *p, *sp; - - if (insertNode) - sp=&(thrp->posSearch[thrp->lenSetSize]); - - np=rootp; - while (1) { - if (key==np->suitLengths) { - *result=TRUE; - return np; - } - else if (key < np->suitLengths) { - if (np->left!=NULL) - np=np->left; - else if (insertNode) { - p=sp; - AddLenSet(thrp); - np->left=p; - p->posSearchPoint=NULL; - p->suitLengths=key; - p->left=NULL; p->right=NULL; - *result=TRUE; - return p; - } - else { - *result=FALSE; - return NULL; - } - } - else { /* key > suitLengths */ - if (np->right!=NULL) - np=np->right; - else if (insertNode) { - p=sp; - AddLenSet(thrp); - np->right=p; - p->posSearchPoint=NULL; - p->suitLengths=key; - p->left=NULL; p->right=NULL; - *result=TRUE; - return p; - } - else { - *result=FALSE; - return NULL; - } - } - } -} - - - -void BuildSOP(struct pos * posPoint, long long suitLengths, int tricks, int firstHand, int target, - int depth, int scoreFlag, int score, struct localVarType * thrp) { - int hh, res, wm; - unsigned short int w; - unsigned short int temp[4][4]; - unsigned short int aggr[4]; - struct nodeCardsType * cardsP; - struct posSearchType * np; - - - for (int ss=0; ss<=3; ss++) { - w=posPoint->winRanks[depth][ss]; - if (w==0) { - posPoint->winMask[ss]=0; - posPoint->winOrderSet[ss]=0; - posPoint->leastWin[ss]=0; - for (hh=0; hh<=3; hh++) - temp[hh][ss]=0; - } - else { - w=w & (-w); /* Only lowest win */ - for (hh=0; hh<=3; hh++) - temp[hh][ss]=posPoint->rankInSuit[hh][ss] & (-w); - - aggr[ss]=0; - for (hh=0; hh<=3; hh++) - aggr[ss]|=temp[hh][ss]; - posPoint->winMask[ss]=thrp->abs[aggr[ss]].winMask[ss]; - posPoint->winOrderSet[ss]=thrp->abs[aggr[ss]].aggrRanks[ss]; - wm=posPoint->winMask[ss]; - wm=wm & (-wm); - posPoint->leastWin[ss]=InvWinMask(wm); - } - } - - /* 07-04-22 */ - if (scoreFlag) { - if (thrp->nodeTypeStore[0]==MAXNODE) { - posPoint->ubound=tricks+1; - posPoint->lbound=target-posPoint->tricksMAX; - } - else { - posPoint->ubound=tricks+1-target+posPoint->tricksMAX; - posPoint->lbound=0; - } - } - else { - if (thrp->nodeTypeStore[0]==MAXNODE) { - posPoint->ubound=target-posPoint->tricksMAX-1; - posPoint->lbound=0; - } - else { - posPoint->ubound=tricks+1; - posPoint->lbound=tricks+1-target+posPoint->tricksMAX+1; - } - } - - /*long long suitLengths=0; - for (int s=0; s<=2; s++) - for (hh=0; hh<=3; hh++) { - suitLengths<<=4; - suitLengths|=posPoint->length[hh][s]; - }*/ - - np=SearchLenAndInsert(thrp->rootnp[tricks][firstHand], - suitLengths, TRUE, &res, thrp); - - cardsP=BuildPath(posPoint, np, &res, thrp); - if (res) { - cardsP->ubound=posPoint->ubound; - cardsP->lbound=posPoint->lbound; - if (((thrp->nodeTypeStore[firstHand]==MAXNODE)&&(scoreFlag))|| - ((thrp->nodeTypeStore[firstHand]==MINNODE)&&(!scoreFlag))) { - cardsP->bestMoveSuit=thrp->bestMove[depth].suit; - cardsP->bestMoveRank=thrp->bestMove[depth].rank; - } - else { - cardsP->bestMoveSuit=0; - cardsP->bestMoveRank=0; - } - posPoint->bestMoveSuit=thrp->bestMove[depth].suit; - posPoint->bestMoveRank=thrp->bestMove[depth].rank; - for (int k=0; k<=3; k++) - cardsP->leastWin[k]=posPoint->leastWin[k]; - } - - #ifdef STAT - c9[depth]++; - #endif - -} - - -int CheckDeal(struct moveType * cardp, int thrId) { - int h, s, k, found; - unsigned short int temp[4][4]; - - for (h=0; h<=3; h++) - for (s=0; s<=3; s++) - temp[h][s]=localVar[thrId].game.suit[h][s]; - - /* Check that all ranks appear only once within the same suit. */ - for (s=0; s<=3; s++) - for (k=2; k<=14; k++) { - found=FALSE; - for (h=0; h<=3; h++) { - if ((temp[h][s] & bitMapRank[k])!=0) { - if (found) { - cardp->suit=s; - cardp->rank=k; - return 1; - } - else - found=TRUE; - } - } - } - - return 0; -} - - -int NextMove(struct pos *posPoint, int depth, struct movePlyType *mply, - struct localVarType * thrp) { - /* Returns TRUE if at least one move remains to be - searched, otherwise FALSE is returned. */ - - unsigned short int lw; - int suit; - struct moveType currMove=mply->move[mply->current]; - - if (thrp->lowestWin[depth][currMove.suit]==0) { - /* A small card has not yet been identified for this suit. */ - lw=posPoint->winRanks[depth][currMove.suit]; - if (lw!=0) - lw=lw & (-lw); /* LSB */ - else - lw=bitMapRank[15]; - if (bitMapRank[currMove.rank]lowestWin[depth][currMove.suit]=lw; - while (mply->current <= (mply->last-1)) { - mply->current++; - if (bitMapRank[mply->move[mply->current].rank] >= - thrp->lowestWin[depth][mply->move[mply->current].suit]) - return TRUE; - } - return FALSE; - } - else { - while (mply->current <= (mply->last-1)) { - mply->current++; - suit=mply->move[mply->current].suit; - if ((currMove.suit==suit) || (bitMapRank[mply->move[mply->current].rank] >= - thrp->lowestWin[depth][suit])) - return TRUE; - } - return FALSE; - } - } - else { - while (mply->current<=(mply->last-1)) { - mply->current++; - if (bitMapRank[mply->move[mply->current].rank] >= - thrp->lowestWin[depth][mply->move[mply->current].suit]) - return TRUE; - } - return FALSE; - } -} - - -int DumpInput(int errCode, struct deal dl, int target, - int solutions, int mode) { - - FILE *fp; - int i, j, k; - unsigned short ranks[4][4]; - - fp=fopen("dump.txt", "w"); - if (fp==NULL) - return RETURN_UNKNOWN_FAULT; - fprintf(fp, "Error code=%d\n", errCode); - fprintf(fp, "\n"); - fprintf(fp, "Deal data:\n"); - if (dl.trump!=4) - fprintf(fp, "trump=%c\n", cardSuit[dl.trump]); - else - fprintf(fp, "trump=N\n"); - fprintf(fp, "first=%c\n", cardHand[dl.first]); - for (k=0; k<=2; k++) - if (dl.currentTrickRank[k]!=0) - fprintf(fp, "index=%d currentTrickSuit=%c currentTrickRank=%c\n", - k, cardSuit[dl.currentTrickSuit[k]], cardRank[dl.currentTrickRank[k]]); - for (i=0; i<=3; i++) - for (j=0; j<=3; j++) { - fprintf(fp, "index1=%d index2=%d remainCards=%d\n", - i, j, dl.remainCards[i][j]); - ranks[i][j]=dl.remainCards[i][/*3-*/j]>>2; - } - fprintf(fp, "\n"); - fprintf(fp, "target=%d\n", target); - fprintf(fp, "solutions=%d\n", solutions); - fprintf(fp, "mode=%d\n", mode); - fprintf(fp, "\n"); - PrintDeal(fp, ranks); - fclose(fp); - return 0; -} - -void PrintDeal(FILE *fp, unsigned short ranks[][4]) { - int i, count, ec[4], trickCount=0, s, r; - for (i=0; i<=3; i++) { - count=counttable[ranks[3][i]]; - if (count>5) - ec[i]=TRUE; - else - ec[i]=FALSE; - trickCount=trickCount+count; - } - fprintf(fp, "\n"); - for (s=0; s<=3; s++) { - fprintf(fp, "\t%c ", cardSuit[s]); - if (!ranks[0][s]) - fprintf(fp, "--"); - else { - for (r=14; r>=2; r--) - if ((ranks[0][s] & bitMapRank[r])!=0) - fprintf(fp, "%c", cardRank[r]); - } - fprintf(fp, "\n"); - } - for (s=0; s<=3; s++) { - fprintf(fp, "%c ", cardSuit[s]); - if (!ranks[3][s]) - fprintf(fp, "--"); - else { - for (r=14; r>=2; r--) - if ((ranks[3][s] & bitMapRank[r])!=0) - fprintf(fp, "%c", cardRank[r]); - } - if (ec[s]) - fprintf(fp, "\t%c ", cardSuit[s]); - else - fprintf(fp, "\t\t%c ", cardSuit[s]); - if (!ranks[1][s]) - fprintf(fp, "--"); - else { - for (r=14; r>=2; r--) - if ((ranks[1][s] & bitMapRank[r])!=0) - fprintf(fp, "%c", cardRank[r]); - } - fprintf(fp, "\n"); - } - for (s=0; s<=3; s++) { - fprintf(fp, "\t%c ", cardSuit[s]); - if (!ranks[2][s]) - fprintf(fp, "--"); - else { - for (r=14; r>=2; r--) - if ((ranks[2][s] & bitMapRank[r])!=0) - fprintf(fp, "%c", cardRank[r]); - } - fprintf(fp, "\n"); - } - fprintf(fp, "\n"); - return; -} - - - -void Wipe(struct localVarType * thrp) { - int k; - - for (k=1; k<=thrp->wcount; k++) { - if (thrp->pw[k]) - free(thrp->pw[k]); - thrp->pw[k]=NULL; - } - for (k=1; k<=thrp->ncount; k++) { - if (thrp->pn[k]) - free(thrp->pn[k]); - thrp->pn[k]=NULL; - } - for (k=1; k<=thrp->lcount; k++) { - if (thrp->pl[k]) - free(thrp->pl[k]); - thrp->pl[k]=NULL; - } - - thrp->allocmem=thrp->summem; - - return; -} - - -void AddWinSet(struct localVarType * thrp) { - if (thrp->clearTTflag) { - thrp->windex++; - thrp->winSetSize=thrp->windex; - thrp->winCards=&(thrp->temp_win[thrp->windex]); - } - else if (thrp->winSetSize>=thrp->winSetSizeLimit) { - /* The memory chunk for the winCards structure will be exceeded. */ - if ((thrp->allocmem + thrp->wmem)>thrp->maxmem) { - /* Already allocated memory plus needed allocation overshot maxmem */ - thrp->windex++; - thrp->winSetSize=thrp->windex; - thrp->clearTTflag=TRUE; - thrp->winCards=&(thrp->temp_win[thrp->windex]); - } - else { - thrp->wcount++; thrp->winSetSizeLimit=WSIZE; - thrp->pw[thrp->wcount] = - (struct winCardType *)calloc(thrp->winSetSizeLimit+1, - sizeof(struct winCardType)); - if (thrp->pw[thrp->wcount]==NULL) { - thrp->clearTTflag=TRUE; - thrp->windex++; - thrp->winSetSize=thrp->windex; - thrp->winCards=&(thrp->temp_win[thrp->windex]); - } - else { - thrp->allocmem += (thrp->winSetSizeLimit+1)*sizeof(struct winCardType); - thrp->winSetSize=0; - thrp->winCards=thrp->pw[thrp->wcount]; - } - } - } - else - thrp->winSetSize++; - return; -} - -void AddNodeSet(struct localVarType * thrp) { - if (thrp->nodeSetSize>=thrp->nodeSetSizeLimit) { - /* The memory chunk for the nodeCards structure will be exceeded. */ - if ((thrp->allocmem + thrp->nmem)>thrp->maxmem) { - /* Already allocated memory plus needed allocation overshot maxmem */ - thrp->clearTTflag=TRUE; - } - else { - thrp->ncount++; thrp->nodeSetSizeLimit=NSIZE; - thrp->pn[thrp->ncount] = - (struct nodeCardsType *)calloc(thrp->nodeSetSizeLimit+1, sizeof(struct nodeCardsType)); - if (thrp->pn[thrp->ncount]==NULL) { - thrp->clearTTflag=TRUE; - } - else { - thrp->allocmem+=(thrp->nodeSetSizeLimit+1)*sizeof(struct nodeCardsType); - thrp->nodeSetSize=0; - thrp->nodeCards=thrp->pn[thrp->ncount]; - } - } - } - else - thrp->nodeSetSize++; - return; -} - -void AddLenSet(struct localVarType * thrp) { - if (thrp->lenSetSize>=thrp->lenSetSizeLimit) { - /* The memory chunk for the posSearchType structure will be exceeded. */ - if ((thrp->allocmem + thrp->lmem)>thrp->maxmem) { - /* Already allocated memory plus needed allocation overshot maxmem */ - thrp->clearTTflag=TRUE; - } - else { - thrp->lcount++; thrp->lenSetSizeLimit=LSIZE; - thrp->pl[thrp->lcount] = - (struct posSearchType *)calloc(thrp->lenSetSizeLimit+1, sizeof(struct posSearchType)); - if (thrp->pl[thrp->lcount]==NULL) { - thrp->clearTTflag=TRUE; - } - else { - thrp->allocmem += (thrp->lenSetSizeLimit+1)*sizeof(struct posSearchType); - thrp->lenSetSize=0; - thrp->posSearch=thrp->pl[thrp->lcount]; - } - } - } - else - thrp->lenSetSize++; - return; -} - - -#if defined(_WIN32) && !defined(_OPENMP) && !defined(DDS_THREADS_SINGLE) -HANDLE solveAllEvents[MAXNOOFTHREADS]; -struct paramType param; -LONG volatile threadIndex; -LONG volatile current; - -long chunk; - -DWORD CALLBACK SolveChunk (void *) { - struct futureTricks fut[MAXNOOFBOARDS]; - int thid; - long j; - - thid=InterlockedIncrement(&threadIndex); - - while ((j=(InterlockedIncrement(¤t)-1))deals[j], param.bop->target[j], - param.bop->solutions[j], param.bop->mode[j], &fut[j], thid); - if (res==1) { - param.solvedp->solvedBoard[j]=fut[j]; - /*param.error=0;*/ - } - else { - param.error=res; - } - } - - if (SetEvent(solveAllEvents[thid])==0) { - /*int errCode=GetLastError();*/ - return 0; - } - - return 1; - -} - - -DWORD CALLBACK SolveChunkDDtable (void *) { - struct futureTricks fut[MAXNOOFBOARDS]; - int thid; - long j; - - thid=InterlockedIncrement(&threadIndex); - - while ((j=InterlockedExchangeAdd(¤t, chunk))deals[j+k], param.bop->target[j+k], - param.bop->solutions[j+k], param.bop->mode[j+k], - &fut[j+k], thid); - if (res==1) { - param.solvedp->solvedBoard[j+k]=fut[j+k]; - /*param.error=0;*/ - } - else { - param.error=res; - } - } - } - - if (SetEvent(solveAllEvents[thid])==0) { - /*int errCode=GetLastError();*/ - return 0; - } - - return 1; - -} - - -int SolveAllBoardsN(struct boards *bop, struct solvedBoards *solvedp, int chunkSize) { - int k/*, errCode*/; - DWORD res; - DWORD solveAllWaitResult; - - current = 0; - threadIndex = -1; - chunk = chunkSize; - param.error = 0; - - if (bop->noOfBoards > MAXNOOFBOARDS) - return RETURN_TOO_MANY_BOARDS; - - for (k = 0; knoOfBoards; - - for (k = 0; ksolvedBoard[k].cards = 0; - - if (chunkSize != 1) { - for (k = 0; knoOfBoards = 0; - for (k = 0; ksolvedBoard[k].cards != 0) - solvedp->noOfBoards++; - } - - if (param.error == 0) - return 1; - else - return param.error; -} - -#else - -int SolveAllBoardsN(struct boards *bop, struct solvedBoards *solvedp, int chunkSize) { - int k, i, res, chunk, fail; - struct futureTricks fut[MAXNOOFBOARDS]; - - chunk=chunkSize; fail=1; - - if (bop->noOfBoards > MAXNOOFBOARDS) - return RETURN_TOO_MANY_BOARDS; - - for (i=0; isolvedBoard[i].cards=0; - -#if defined (_OPENMP) && !defined(DDS_THREADS_SINGLE) - if (omp_get_dynamic()) - omp_set_dynamic(0); - omp_set_num_threads(noOfCores); /* Added after suggestion by Dirk Willecke. */ -#elif defined (_OPENMP) - omp_set_num_threads(1); -#endif - - #pragma omp parallel shared(bop, solvedp, chunk, fail) private(k) - { - - #pragma omp for schedule(dynamic, chunk) - - for (k=0; knoOfBoards; k++) { - res=SolveBoard(bop->deals[k], bop->target[k], bop->solutions[k], - bop->mode[k], &fut[k], - -#if defined (_OPENMP) && !defined(DDS_THREADS_SINGLE) - omp_get_thread_num() -#else - 0 -#endif - ); - if (res==1) { - solvedp->solvedBoard[k]=fut[k]; - } - else - fail=res; - } - } - - if (fail!=1) - return fail; - - solvedp->noOfBoards=0; - for (i=0; isolvedBoard[i].cards!=0) - solvedp->noOfBoards++; - } - - return 1; -} - -#endif - - -int STDCALL CalcDDtable(struct ddTableDeal tableDeal, struct ddTableResults * tablep) { - - int h, s, k, ind, tr, first, res; - struct deal dl; - struct boards bo; - struct solvedBoards solved; - - for (h=0; h<=3; h++) - for (s=0; s<=3; s++) - dl.remainCards[h][s]=tableDeal.cards[h][s]; - - for (k=0; k<=2; k++) { - dl.currentTrickRank[k]=0; - dl.currentTrickSuit[k]=0; - } - - ind=0; bo.noOfBoards=20; - - for (tr=4; tr>=0; tr--) - for (first=0; first<=3; first++) { - dl.first=first; - dl.trump=tr; - bo.deals[ind]=dl; - bo.target[ind]=-1; - bo.solutions[ind]=1; - bo.mode[ind]=1; - ind++; - } - - res=SolveAllBoardsN(&bo, &solved, 4); - if (res==1) { - for (ind=0; ind<20; ind++) { - tablep->resTable[bo.deals[ind].trump][rho[bo.deals[ind].first]]= - 13-solved.solvedBoard[ind].score[0]; - } - return 1; - } - - return res; -} - - -int STDCALL CalcAllTables(struct ddTableDeals *dealsp, int mode, int trumpFilter[5], - struct ddTablesRes *resp, struct allParResults *presp) { - - /* mode = 0: par calculation, vulnerability None - mode = 1: par calculation, vulnerability All - mode = 2: par calculation, vulnerability NS - mode = 3: par calculation, vulnerability EW - mode = -1: no par calculation */ - - int h, s, k, m, ind, tr, first, res, rs, lastIndex=0, - lastBoardIndex[MAXNOOFBOARDS>>2], okey=FALSE, count=0; - struct boards bo; - struct solvedBoards solved; - - /*int Par(struct ddTableResults * tablep, struct parResults *presp, int vulnerable);*/ - - for (k=0; k<5; k++) { - if (!trumpFilter[k]) { - okey=TRUE; - count++; - } - } - - if (!okey) - return RETURN_NO_SUIT; - - switch (count) { - case 1: if (dealsp->noOfTables > 50) return RETURN_TOO_MANY_TABLES;break; - case 2: if (dealsp->noOfTables > 25) return RETURN_TOO_MANY_TABLES;break; - case 3: if (dealsp->noOfTables > 16) return RETURN_TOO_MANY_TABLES;break; - case 4: if (dealsp->noOfTables > 12) return RETURN_TOO_MANY_TABLES;break; - case 5: if (dealsp->noOfTables > 10) return RETURN_TOO_MANY_TABLES;break; - } - - ind=0; - resp->noOfBoards=0; - - for (m=0; mnoOfTables; m++) { - for (tr=4; tr>=0; tr--) { - if (!trumpFilter[tr]) { - for (first=0; first<=3; first++) { - for (h=0; h<=3; h++) - for (s=0; s<=3; s++) - bo.deals[ind].remainCards[h][s]=dealsp->deals[m].cards[h][s]; - bo.deals[ind].first=first; - bo.deals[ind].trump=tr; - for (k=0; k<=2; k++) { - bo.deals[ind].currentTrickRank[k]=0; - bo.deals[ind].currentTrickSuit[k]=0; - } - - bo.target[ind]=-1; - bo.solutions[ind]=1; - bo.mode[ind]=1; - lastIndex=ind; - lastBoardIndex[m]=ind; - ind++; - } - } - } - } - - bo.noOfBoards=lastIndex+1; - - res=SolveAllBoardsN(&bo, &solved, 4); - if (res==1) { - resp->noOfBoards+=solved.noOfBoards; - for (ind=0; ind<=lastIndex; ind++) { - for (k=0; k<=lastIndex; k++) { - if (ind<=lastBoardIndex[k]) { - resp->results[k].resTable[bo.deals[ind].trump][rho[bo.deals[ind].first]]= - 13-solved.solvedBoard[ind].score[0]; - break; - } - } - } - - if ((mode > -1) && (mode < 4)) { - /* Calculate par */ - for (k=0; knoOfTables; k++) { - rs=Par(&(resp->results[k]), &(presp->presults[k]), mode); - /* vulnerable 0: None 1: Both 2: NS 3: EW */ - if (rs!=1) - return rs; - } - } - return 1; - } - return res; -} - - -int STDCALL CalcAllTablesPBN(struct ddTableDealsPBN *dealsp, int mode, int trumpFilter[5], - struct ddTablesRes *resp, struct allParResults *presp) { - int res, k; - struct ddTableDeals dls; - - int ConvertFromPBN(char * dealBuff, unsigned int remainCards[4][4]); - - for (k=0; knoOfTables; k++) - if (ConvertFromPBN(dealsp->deals[k].cards, dls.deals[k].cards)!=1) - return RETURN_PBN_FAULT; - - dls.noOfTables=dealsp->noOfTables; - - res=CalcAllTables(&dls, mode, trumpFilter, resp, presp); - - return res; -} - - -int ConvertFromPBN(char * dealBuff, unsigned int remainCards[4][4]) { - int bp=0, first, card, hand, handRelFirst, suitInHand, h, s; - int IsCard(char cardChar); - - for (h=0; h<=3; h++) - for (s=0; s<=3; s++) - remainCards[h][s]=0; - - while (((dealBuff[bp]!='W')&&(dealBuff[bp]!='N')&& - (dealBuff[bp]!='E')&&(dealBuff[bp]!='S')&& - (dealBuff[bp]!='w')&&(dealBuff[bp]!='n')&& - (dealBuff[bp]!='e')&&(dealBuff[bp]!='s'))&&(bp<3)) - bp++; - - if (bp>=3) - return 0; - - if ((dealBuff[bp]=='N')||(dealBuff[bp]=='n')) - first=0; - else if ((dealBuff[bp]=='E')||(dealBuff[bp]=='e')) - first=1; - else if ((dealBuff[bp]=='S')||(dealBuff[bp]=='s')) - first=2; - else - first=3; - - bp++; - bp++; - - handRelFirst=0; suitInHand=0; - - while ((bp<80)&&(dealBuff[bp]!='\0')) { - card=IsCard(dealBuff[bp]); - if (card) { - switch (first) { - case 0: - hand=handRelFirst; - break; - case 1: - if (handRelFirst==0) - hand=1; - else if (handRelFirst==3) - hand=0; - else - hand=handRelFirst+1; - break; - case 2: - if (handRelFirst==0) - hand=2; - else if (handRelFirst==1) - hand=3; - else - hand=handRelFirst-2; - break; - default: - if (handRelFirst==0) - hand=3; - else - hand=handRelFirst-1; - } - - remainCards[hand][suitInHand]|=(bitMapRank[card]<<2); - - } - else if (dealBuff[bp]=='.') - suitInHand++; - else if (dealBuff[bp]==' ') { - handRelFirst++; - suitInHand=0; - } - bp++; - } - return 1; -} - - -int IsCard(char cardChar) { - switch (cardChar) { - case '2': - return 2; - case '3': - return 3; - case '4': - return 4; - case '5': - return 5; - case '6': - return 6; - case '7': - return 7; - case '8': - return 8; - case '9': - return 9; - case 'T': - return 10; - case 'J': - return 11; - case 'Q': - return 12; - case 'K': - return 13; - case 'A': - return 14; - case 't': - return 10; - case 'j': - return 11; - case 'q': - return 12; - case 'k': - return 13; - case 'a': - return 14; - default: - return 0; - } - } - - -int STDCALL SolveBoardPBN(struct dealPBN dlpbn, int target, - int solutions, int mode, struct futureTricks *futp, int threadIndex) { - - int res, k; - struct deal dl; - int ConvertFromPBN(char * dealBuff, unsigned int remainCards[4][4]); - - if (ConvertFromPBN(dlpbn.remainCards, dl.remainCards)!=RETURN_NO_FAULT) - return RETURN_PBN_FAULT; - - for (k=0; k<=2; k++) { - dl.currentTrickRank[k]=dlpbn.currentTrickRank[k]; - dl.currentTrickSuit[k]=dlpbn.currentTrickSuit[k]; - } - dl.first=dlpbn.first; - dl.trump=dlpbn.trump; - - res=SolveBoard(dl, target, solutions, mode, futp, threadIndex); - - return res; -} - -int STDCALL CalcDDtablePBN(struct ddTableDealPBN tableDealPBN, struct ddTableResults * tablep) { - struct ddTableDeal tableDeal; - int res; - - if (ConvertFromPBN(tableDealPBN.cards, tableDeal.cards)!=1) - return RETURN_PBN_FAULT; - - res=CalcDDtable(tableDeal, tablep); - - return res; -} - - -int STDCALL SolveAllBoards(struct boardsPBN *bop, struct solvedBoards *solvedp) { - struct boards bo; - int k, i, res; - - bo.noOfBoards=bop->noOfBoards; - for (k=0; knoOfBoards; k++) { - bo.mode[k]=bop->mode[k]; - bo.solutions[k]=bop->solutions[k]; - bo.target[k]=bop->target[k]; - bo.deals[k].first=bop->deals[k].first; - bo.deals[k].trump=bop->deals[k].trump; - for (i=0; i<=2; i++) { - bo.deals[k].currentTrickSuit[i]=bop->deals[k].currentTrickSuit[i]; - bo.deals[k].currentTrickRank[i]=bop->deals[k].currentTrickRank[i]; - } - if (ConvertFromPBN(bop->deals[k].remainCards, bo.deals[k].remainCards)!=1) - return RETURN_PBN_FAULT; - } - - res=SolveAllBoardsN(&bo, solvedp, 1); - - return res; -} - -int STDCALL SolveAllChunksPBN(struct boardsPBN *bop, struct solvedBoards *solvedp, int chunkSize) { - struct boards bo; - int k, i, res; - - if (chunkSize < 1) - return RETURN_CHUNK_SIZE; - - bo.noOfBoards = bop->noOfBoards; - for (k = 0; knoOfBoards; k++) { - bo.mode[k] = bop->mode[k]; - bo.solutions[k] = bop->solutions[k]; - bo.target[k] = bop->target[k]; - bo.deals[k].first = bop->deals[k].first; - bo.deals[k].trump = bop->deals[k].trump; - for (i = 0; i <= 2; i++) { - bo.deals[k].currentTrickSuit[i] = bop->deals[k].currentTrickSuit[i]; - bo.deals[k].currentTrickRank[i] = bop->deals[k].currentTrickRank[i]; - } - if (ConvertFromPBN(bop->deals[k].remainCards, bo.deals[k].remainCards) != 1) - return RETURN_PBN_FAULT; - } - - res = SolveAllBoardsN(&bo, solvedp, chunkSize); - return res; -} - - -int STDCALL SolveAllChunks(struct boardsPBN *bop, struct solvedBoards *solvedp, int chunkSize) { - - int res = SolveAllChunksPBN(bop, solvedp, chunkSize); - - return res; -} - - -int STDCALL SolveAllChunksBin(struct boards *bop, struct solvedBoards *solvedp, int chunkSize) { - int res; - - if (chunkSize < 1) - return RETURN_CHUNK_SIZE; - - res = SolveAllBoardsN(bop, solvedp, chunkSize); - return res; -} - - - - - - - - - - diff --git a/dds.h b/dds.h index 07ffc23e..bb0f5546 100644 --- a/dds.h +++ b/dds.h @@ -1,62 +1,46 @@ - -#if defined(_WIN32) - #if defined(_MSC_VER) - #include - #endif - #define USES_DLLMAIN - /* DLL uses DllMain() for initialization */ - -#elif defined (__CYGWIN__) - #include - #include - #define USES_DLLMAIN - - -#elif defined (__linux) - #include - #define USES_CONSTRUCTOR - /* DLL uses a constructor function for initialization */ - typedef long long __int64; - -#elif defined (__APPLE__) - #include - #define USES_CONSTRUCTOR - typedef long long __int64; - +#ifndef DDS_DDSH +#define DDS_DDSH + +#include +#include +#include +#include +#include +#include + +#include "debug.h" +#include "portab.h" + +#include "TransTable.h" +#include "Timer.h" +#include "ABstats.h" + +#if defined(DDS_MEMORY_LEAKS) && defined(_MSC_VER) + #define DDS_MEMORY_LEAKS_WIN32 + #define _CRTDBG_MAP_ALLOC + #include #endif -#if defined(INFINITY) -# undef INFINITY -#endif -#define INFINITY 32000 -#define TT_MAXMEM 150000000 +#define THREADMEM_MAX_MB 160 +#define THREADMEM_DEF_MB 95 -#define MAXNODE 1 -#define MINNODE 0 - -#ifndef TRUE -#define TRUE 1 -#define FALSE 0 -#endif +#define MAXNOOFTHREADS 16 -#define MOVESVALID 1 -#define MOVESLOCKED 2 +#define MAXNODE 1 +#define MINNODE 0 -#define NSIZE 100000 -#define WSIZE 100000 -#define LSIZE 20000 -#define NINIT 250000 -#define WINIT 700000 -#define LINIT 50000 +#define MOVESVALID 1 +#define MOVESLOCKED 2 #define SIMILARDEALLIMIT 5 #define SIMILARMAXWINNODES 700000 - #define Max(x, y) (((x) >= (y)) ? (x) : (y)) #define Min(x, y) (((x) <= (y)) ? (x) : (y)) +#define DDS_NOTRUMP 4 + /* "hand" is leading hand, "relative" is hand relative leading hand. The handId macro implementation follows a solution @@ -69,88 +53,178 @@ All hand identities are given as { struct moveType tmp = a[i]; a[i] = a[j]; a[j] = tmp; } -struct localVarType { - int nodeTypeStore[4]; - int trump; - unsigned short int lowestWin[50][4]; - #ifdef STAT - int nodes; - #endif - int trickNodes; - int no[50]; - int iniDepth; - int handToPlay; - int payOff; - int val; - struct pos iniPosition; - struct pos lookAheadPos; /* Is initialized for starting - alpha-beta search */ - struct moveType forbiddenMoves[14]; - struct moveType initialMoves[4]; - struct moveType cd; - struct movePlyType movePly[50]; - int tricksTarget; - struct gameInfo game; - int newDeal; - int newTrump; - int similarDeal; - unsigned short int diffDeal; - unsigned short int aggDeal; - int estTricks[4]; - FILE *fp2; - FILE *fp7; - FILE *fp11; - struct moveType bestMove[50]; - struct moveType bestMoveTT[50]; - struct winCardType temp_win[5]; - int nodeSetSizeLimit; - int winSetSizeLimit; - int lenSetSizeLimit; - unsigned long long maxmem; /* bytes */ - unsigned long long allocmem; - unsigned long long summem; - int wmem; - int nmem; - int lmem; - int maxIndex; - int wcount; - int ncount; - int lcount; - int clearTTflag; - int windex; - struct absRanksType * abs; - struct adaptWinRanksType * adaptWins; - struct posSearchType *rootnp[14][4]; - struct winCardType **pw; - struct nodeCardsType **pn; - struct posSearchType **pl; - struct nodeCardsType * nodeCards; - struct winCardType * winCards; - struct posSearchType * posSearch; - unsigned short int iniRemovedRanks[4]; - - int nodeSetSize; /* Index with range 0 to nodeSetSizeLimit */ - int winSetSize; /* Index with range 0 to winSetSizeLimit */ - int lenSetSize; /* Index with range 0 to lenSetSizeLimit */ +extern int lho[DDS_HANDS]; +extern int rho[DDS_HANDS]; +extern int partner[DDS_HANDS]; + +extern unsigned short int bitMapRank[16]; + +extern unsigned char cardRank[16]; +extern unsigned char cardSuit[DDS_STRAINS]; +extern unsigned char cardHand[DDS_HANDS]; + +// These four together take up 408 KB +extern int highestRank[8192]; +extern int counttable[8192]; +extern char relRank[8192][15]; +extern unsigned short int winRanks[8192][14]; + +extern int noOfThreads; + + +extern int stat_contr[DDS_STRAINS]; + +struct moveType { + int suit; + int rank; + unsigned short int sequence; /* Whether or not this move is the + first in a sequence */ + short int weight; /* Weight used at sorting */ +}; + +struct movePlyType { + struct moveType move[14]; + int current; + int last; +}; + +struct highCardType { + int rank; + int hand; +}; + + +struct pos { + unsigned short int rankInSuit[DDS_HANDS][DDS_SUITS]; + unsigned short int aggr[DDS_SUITS]; + + unsigned short int removedRanks[DDS_SUITS]; + /* Ranks removed from board. */ + unsigned short int winRanks[50][DDS_SUITS]; + /* Cards that win by rank, firstindex + is depth. */ + unsigned char length[DDS_HANDS][DDS_SUITS]; + int handDist[DDS_HANDS]; + int first[50]; + /* Hand that leads the trick for each ply */ + int high[50]; + /* Hand that is presently winning the trick */ + struct moveType move[50]; + /* Presently winning move */ + int handRelFirst; + /* The current hand, relative first hand */ + int tricksMAX; + /* Aggregated tricks won by MAX */ + struct highCardType winner[DDS_SUITS]; + /* Winning rank of trick. */ + struct highCardType secondBest[DDS_SUITS]; + /* Second best rank. */ +}; + +struct evalType { + int tricks; + unsigned short int winRanks[DDS_SUITS]; +}; + +struct card { + int suit; + int rank; }; struct paramType { - int noOfBoards; - struct boards *bop; - struct solvedBoards *solvedp; - int error; + int noOfBoards; + struct boards * bop; + struct solvedBoards * solvedp; + int error; }; -struct playparamType { - int noOfBoards; - struct boards * bop; - struct playTracesBin * plp; - struct solvedPlays * solvedp; - int error; +struct gameInfo // 56 bytes +{ + /* All info of a particular deal */ + int declarer; + int leadHand; + int leadSuit; + int leadRank; + int first; + int noOfCards; + unsigned short int suit[DDS_HANDS][DDS_SUITS]; }; +struct absRankType // 2 bytes +{ + char rank; + char hand; +}; +struct relRanksType // 120 bytes +{ + struct absRankType absRank[15][DDS_SUITS]; +}; +struct localVarType +{ + int nodeTypeStore[DDS_HANDS]; + int nodes; + int trickNodes; + + double memUsed; + + int trump; + unsigned short int lowestWin[50][DDS_SUITS]; + int no[50]; + int iniDepth; + int handToPlay; + int payOff; + bool val; + + struct pos iniPosition; + struct pos lookAheadPos; + /* Is initialized for starting + alpha-beta search */ + struct moveType forbiddenMoves[14]; + struct moveType initialMoves[DDS_HANDS]; + struct movePlyType movePly[50]; + int tricksTarget; + struct gameInfo game; + bool newDeal; + bool newTrump; + bool similarDeal; + unsigned short int diffDeal; + unsigned short int aggDeal; + int estTricks[DDS_HANDS]; + + + struct moveType bestMove[50]; + struct moveType bestMoveTT[50]; + unsigned short int iniRemovedRanks[DDS_SUITS]; + + // Constant for a given hand. + // 960 KB + struct relRanksType rel[8192]; + + TransTable transTable; // Object + +#ifdef DDS_AB_STATS + ABstats ABstats; // Object +#endif +#ifdef DDS_TIMING + Timer timer; // Object +#endif +#ifdef DDS_TOP_LEVEL + FILE * fpTopLevel; +#endif + +#ifdef DDS_AB_HITS + FILE * fpRetrieved; + FILE * fpStored; +#endif + +}; + +extern struct localVarType localVar[MAXNOOFTHREADS]; + + +#endif diff --git a/debug.h b/debug.h new file mode 100644 index 00000000..504ba871 --- /dev/null +++ b/debug.h @@ -0,0 +1,116 @@ +/* + A number of debug flags cause output files to be generated. + + One file per thread is generated. + + Some example statistics on what to expect for a single + hand, single-threaded, with about 207,000 AB nodes and + about 63,000 trick nodes, called in solve mode such that + a total of 11 calls to the AB optimization are performed. + + The clock "ticks" are for that debugging mode only, with + all the other ones turned off, unless otherwise noted. + The data is of course approximate. (Of course nothing + gets faster with debugging.) + + Mode Clock "ticks" File size in KB + No debugging 66 -- + + DDS_TOP_LEVEL 63 8 + + DDS_AB_STATS 71 36 + + DDS_AB_DETAILS 75 64 + + DDS_AB_HITS 680 8624 (stored) + 12004 (retrieved) + + DDS_TT_STATS (*) 68 8 + + DDS_TIMING 125 8 + + DDS_TIMING_DETAILS 130 28 + + All together 720 -- + + (*) This depends on the stat functions called in TransTable. + Here only the summary functions are called by default. + + For comparison, the old DDS functions, which only work + single-threaded, yields three files stat.txt, storett.txt + and rectt.txt. + + 145124 56 (stat) + 6940 (store) + 7732 (rectt) + + So the speed-up is a factor of 200. +*/ + +// If you want ALL the output files, this is easier +// #define DDS_DEBUG_ALL + +#define DDS_DEBUG_SUFFIX ".txt" + +// Enables data about each call to the top-level AB routine. +// #define DDS_TOP_LEVEL +#define DDS_TOP_LEVEL_PREFIX "toplevel" + +// Enables AB statistics, node counts etc. +// #define DDS_AB_STATS +#define DDS_AB_STATS_PREFIX "ABstats" + +// Gives more detail, in combination with DDS_AB_STATS. +// #define DDS_AB_DETAILS + +// Gives information on nodes stored and retrieved from TT memory. +// #define DDS_AB_HITS +#define DDS_AB_HITS_RETRIEVED_PREFIX "retrieved" +#define DDS_AB_HITS_STORED_PREFIX "stored" + +// Gives statistics on the usage of TT memory. +// #define DDS_TT_STATS +#define DDS_TT_STATS_PREFIX "TTstats" + +// Enables timing of the AB search and related functions. +// Makes an attempt to calculate exclusive times of functions. +// #define DDS_TIMING +#define DDS_TIMING_PREFIX "timer" + +// Enables extra detail. +// #define DDS_TIMING_DETAILS + +#ifdef DDS_DEBUG_ALL +#define DDS_TOP_LEVEL + #ifndef DDS_AB_STATS + #define DDS_AB_STATS + #endif + #ifndef DDS_AB_DETAILS + #define DDS_AB_DETAILS + #endif + #ifndef DDS_AB_HITS + #define DDS_AB_HITS + #endif + #ifndef DDS_TT_STATS + #define DDS_TT_STATS + #endif + #ifndef DDS_TIMING + #define DDS_TIMING + #endif + #ifndef DDS_TIMING_DETAILS + #define DDS_TIMING_DETAILS + #endif +#endif + + +// This debugging feature only works with Microsoft's compiler. +// In fact, it doesn't seem to do anything right now :-). +// #define DDS_MEMORY_LEAKS + + +// Maximum number of characters in a debug file name. +#define DDS_FNAME_LEN 20 + + +#define COUNTER_SLOTS 200 + +extern long long counter[COUNTER_SLOTS]; + diff --git a/dll.h b/dll.h index 6ebb666a..e8e5e949 100755 --- a/dll.h +++ b/dll.h @@ -1,7 +1,6 @@ +#ifndef DDS_DLLH +#define DDS_DLLH -/* portability-macros header prefix */ - -/* Windows requires a __declspec(dllexport) tag, etc */ #if defined(_WIN32) || defined(__CYGWIN__) # define DLLEXPORT __declspec(dllexport) # define STDCALL __stdcall @@ -17,495 +16,326 @@ # define EXTERN_C #endif -#if defined(_WIN32) && defined(__MINGW32__) -#define WINVER 0x500 -# include -# include -#endif - -#if defined(_WIN32) && !defined(__MINGW32__) -# include -# include -#endif - - -#if defined(_OPENMP) -# include -#endif - - -/*#define DDS_THREADS_SINGLE*/ /* For Windows, forces DDS to use a single thread in its - multi-thread functions.This is valid both for the Win32 - thread support alternative and for OpenMP. */ - -/* When OpenMP support is included in DDS, which leads to - the macro _OPENMP definition, OpenMP - is automatically selected instead of the Win32 API. */ - -/* end of portability-macros section */ - -#define DDS_VERSION 20600 /* Version 2.6.0. Allowing for 2 digit minor versions */ - - -/*#define DEALER_PAR_ENGINE_ONLY*/ /* The DealerPar engine supplies the results - in the output format used for Par. This - facilitates comparing that the 2 engines give - the same results. */ - -#include -/*#define _CRTDBG_MAP_ALLOC */ /* MEMORY LEAK? */ -#include -/*#include */ /* MEMORY LEAK? */ -#include -#include -#include -#include - -/*#define STAT*/ /* Define STAT to generate a statistics log, stat.txt */ +/* Version 2.7.0. Allowing for 2 digit minor versions */ +#define DDS_VERSION 20700 -#ifdef STAT -#if !defined(DDS_THREADS_SINGLE) -#define DDS_THREADS_SINGLE -#endif -#endif +#define DDS_HANDS 4 +#define DDS_SUITS 4 +#define DDS_STRAINS 5 -#define MAXNOOFTHREADS 16 +#define MAXNOOFBOARDS 200 -#define MAXNOOFBOARDS 200/*100*/ - /* Error codes */ -#define RETURN_NO_FAULT 1 -#define RETURN_UNKNOWN_FAULT -1 -#define RETURN_ZERO_CARDS -2 -#define RETURN_TARGET_TOO_HIGH -3 -#define RETURN_DUPLICATE_CARDS -4 -#define RETURN_TARGET_WRONG_LO -5 -#define RETURN_TARGET_WRONG_HI -7 -#define RETURN_SOLNS_WRONG_LO -8 -#define RETURN_SOLNS_WRONG_HI -9 -#define RETURN_TOO_MANY_CARDS -10 -#define RETURN_SUIT_OR_RANK -12 -#define RETURN_PLAYED_CARD -13 -#define RETURN_CARD_COUNT -14 -#define RETURN_THREAD_INDEX -15 -#define RETURN_PLAY_FAULT -98 -#define RETURN_PBN_FAULT -99 -#define RETURN_TOO_MANY_BOARDS -101 -#define RETURN_THREAD_CREATE -102 -#define RETURN_THREAD_WAIT -103 -#define RETURN_NO_SUIT -201 -#define RETURN_TOO_MANY_TABLES -202 -#define RETURN_CHUNK_SIZE -301 - -struct gameInfo { /* All info of a particular deal */ - int declarer; - int leadHand; - int leadSuit; - int leadRank; - int first; - int noOfCards; - unsigned short int suit[4][4]; - /* 1st index is hand id, 2nd index is suit id */ -}; - -struct moveType { - int suit; - int rank; - unsigned short int sequence; /* Whether or not this move is - the first in a sequence */ - short int weight; /* Weight used at sorting */ -}; - -struct movePlyType { - struct moveType move[14]; - int current; - int last; -}; - -struct highCardType { - int rank; - int hand; -}; +#define RETURN_NO_FAULT 1 +#define RETURN_UNKNOWN_FAULT -1 +#define RETURN_ZERO_CARDS -2 +#define RETURN_TARGET_TOO_HIGH -3 +#define RETURN_DUPLICATE_CARDS -4 +#define RETURN_TARGET_WRONG_LO -5 +#define RETURN_TARGET_WRONG_HI -7 +#define RETURN_SOLNS_WRONG_LO -8 +#define RETURN_SOLNS_WRONG_HI -9 +#define RETURN_TOO_MANY_CARDS -10 +#define RETURN_SUIT_OR_RANK -12 +#define RETURN_PLAYED_CARD -13 +#define RETURN_CARD_COUNT -14 +#define RETURN_THREAD_INDEX -15 +#define RETURN_PLAY_FAULT -98 +#define RETURN_PBN_FAULT -99 +#define RETURN_TOO_MANY_BOARDS -101 +#define RETURN_THREAD_CREATE -102 +#define RETURN_THREAD_WAIT -103 +#define RETURN_NO_SUIT -201 +#define RETURN_CHUNK_SIZE -201 +#define RETURN_TOO_MANY_TABLES -202 struct futureTricks { - int nodes; - int cards; - int suit[13]; - int rank[13]; - int equals[13]; - int score[13]; + int nodes; + int cards; + int suit[13]; + int rank[13]; + int equals[13]; + int score[13]; }; struct deal { - int trump; - int first; - int currentTrickSuit[3]; - int currentTrickRank[3]; - unsigned int remainCards[4][4]; + int trump; + int first; + int currentTrickSuit[3]; + int currentTrickRank[3]; + unsigned int remainCards[DDS_HANDS][DDS_SUITS]; }; struct dealPBN { - int trump; - int first; - int currentTrickSuit[3]; - int currentTrickRank[3]; - char remainCards[80]; -}; - - -struct pos { - unsigned short int rankInSuit[4][4]; /* 1st index is hand, 2nd index is - suit id */ - int orderSet[4]; - int winOrderSet[4]; - int winMask[4]; - int leastWin[4]; - unsigned short int removedRanks[4]; /* Ranks removed from board, - index is suit */ - unsigned short int winRanks[50][4]; /* Cards that win by rank, - indices are depth and suit */ - unsigned char length[4][4]; - int ubound; - int lbound; - int bestMoveSuit; - int bestMoveRank; - int first[50]; /* Hand that leads the trick for each ply*/ - int high[50]; /* Hand that is presently winning the trick */ - struct moveType move[50]; /* Presently winning move */ - int handRelFirst; /* The current hand, relative first hand */ - int tricksMAX; /* Aggregated tricks won by MAX */ - struct highCardType winner[4]; /* Winning rank of the trick, - index is suit id. */ - struct highCardType secondBest[4]; /* Second best rank, index is suit id. */ -}; - -struct posSearchType { - struct winCardType * posSearchPoint; - long long suitLengths; - struct posSearchType * left; - struct posSearchType * right; -}; - - -struct nodeCardsType { - char ubound; /* ubound and - lbound for the N-S side */ - char lbound; - char bestMoveSuit; - char bestMoveRank; - char leastWin[4]; -}; - -struct winCardType { - int orderSet; - int winMask; - struct nodeCardsType * first; - struct winCardType * prevWin; - struct winCardType * nextWin; - struct winCardType * next; -}; - - -struct evalType { - int tricks; - unsigned short int winRanks[4]; -}; - -struct absRankType { - char rank; - char hand; + int trump; + int first; + int currentTrickSuit[3]; + int currentTrickRank[3]; + char remainCards[80]; }; -struct absRanksType { - int aggrRanks[4]; - int winMask[4]; - struct absRankType absRank[15][4]; -}; - - -struct relRanksType { - char relRank[8192][15]; -}; - -struct adaptWinRanksType { - unsigned short int winRanks[14]; -}; - - -struct card { - int suit; - int rank; -}; struct boards { - int noOfBoards; - struct deal deals[MAXNOOFBOARDS]; - int target[MAXNOOFBOARDS]; - int solutions[MAXNOOFBOARDS]; - int mode[MAXNOOFBOARDS]; + int noOfBoards; + struct deal deals[MAXNOOFBOARDS]; + int target[MAXNOOFBOARDS]; + int solutions[MAXNOOFBOARDS]; + int mode[MAXNOOFBOARDS]; }; struct boardsPBN { - int noOfBoards; - struct dealPBN deals[MAXNOOFBOARDS]; - int target[MAXNOOFBOARDS]; - int solutions[MAXNOOFBOARDS]; - int mode[MAXNOOFBOARDS]; + int noOfBoards; + struct dealPBN deals[MAXNOOFBOARDS]; + int target[MAXNOOFBOARDS]; + int solutions[MAXNOOFBOARDS]; + int mode[MAXNOOFBOARDS]; }; struct solvedBoards { - int noOfBoards; - struct futureTricks solvedBoard[MAXNOOFBOARDS]; + int noOfBoards; + struct futureTricks solvedBoard[MAXNOOFBOARDS]; }; - - struct ddTableDeal { - unsigned int cards[4][4]; + unsigned int cards[DDS_HANDS][DDS_SUITS]; }; struct ddTableDeals { - int noOfTables; - struct ddTableDeal deals[MAXNOOFBOARDS>>2]; + int noOfTables; + struct ddTableDeal deals[MAXNOOFBOARDS >> 2]; }; struct ddTableDealPBN { - char cards[80]; + char cards[80]; }; struct ddTableDealsPBN { - int noOfTables; + int noOfTables; struct ddTableDealPBN deals[MAXNOOFBOARDS>>2]; }; struct ddTableResults { - int resTable[5][4]; + int resTable[DDS_STRAINS][DDS_HANDS]; }; struct ddTablesRes { - int noOfBoards; + int noOfBoards; struct ddTableResults results[MAXNOOFBOARDS>>2]; }; struct parResults { - char parScore[2][16]; /* index = 0 is NS view and index = 1 is EW view. */ - char parContractsString[2][128]; /* index = 0 is NS view and index = 1 - is EW view. By “view” is here meant - which side that starts the bidding. */ + /* index = 0 is NS view and index = 1 + is EW view. By 'view' is here meant + which side that starts the bidding. */ + char parScore[2][16]; + char parContractsString[2][128]; }; struct allParResults { - struct parResults presults[MAXNOOFBOARDS / 20]; + struct parResults presults[MAXNOOFBOARDS / 20]; }; - struct parResultsDealer { - int number; - int score; - char contracts[10][10]; + int number; + int score; + char contracts[10][10]; }; -struct allparResultsDealer { - struct parResultsDealer presults[MAXNOOFBOARDS / 20]; +struct contractType { + int underTricks; /* 0 = make 1-13 = sacrifice */ + int overTricks; /* 0-3, e.g. 1 for 4S + 1. */ + int level; /* 1-7 */ + int denom; /* 0 = No Trumps, 1 = trump Spades, 2 = trump Hearts, + 3 = trump Diamonds, 4 = trump Clubs */ + int seats; /* One of the cases N, E, W, S, NS, EW; + 0 = N 1 = E, 2 = S, 3 = W, 4 = NS, 5 = EW */ }; -struct parContr2Type { - char contracts[10]; - int denom; +struct parResultsMaster { + int score; /* Sign according to the NS view */ + int number; /* Number of contracts giving the par score */ + struct contractType contracts[10]; /* Par contracts */ }; +struct parTextResults { + char parText[2][128]; /* Short text for par information, e.g. + Par -110: EW 2S EW 2D+1 */ + int equal; /* TRUE in the normal case when it does not matter who + starts the bidding. Otherwise, FALSE. */ +}; + + struct playTraceBin { - int number; - int suit[52]; - int rank[52]; + int number; + int suit[52]; + int rank[52]; }; struct playTracePBN { - int number; - char cards[106]; + int number; + char cards[106]; }; struct solvedPlay { - int number; - int tricks[53]; + int number; + int tricks[53]; }; struct playTracesBin { - int noOfBoards; - struct playTraceBin plays[MAXNOOFBOARDS / 10]; + int noOfBoards; + struct playTraceBin plays[MAXNOOFBOARDS / 10]; }; struct playTracesPBN { - int noOfBoards; - struct playTracePBN plays[MAXNOOFBOARDS / 10]; + int noOfBoards; + struct playTracePBN plays[MAXNOOFBOARDS / 10]; }; struct solvedPlays { - int noOfBoards; - struct solvedPlay solved[MAXNOOFBOARDS / 10]; + int noOfBoards; + struct solvedPlay solved[MAXNOOFBOARDS / 10]; }; -extern int noOfThreads; -extern int noOfCores; -extern struct localVarType * localVar; -extern int * highestRank; -extern int * counttable; -extern struct adaptWinRanksType * adaptWins; -extern unsigned short int bitMapRank[16]; -extern unsigned short int relRankInSuit[4][4]; -/*extern char relRank[8192][15];*/ -extern int sum; -extern int score1Counts[50], score0Counts[50]; -extern int c1[50], c2[50], c3[50], c4[50], c5[50], c6[50], c7[50], - c8[50], c9[50]; -extern int nodeTypeStore[4]; /* Look-up table for determining if - node is MAXNODE or MINNODE */ -extern int lho[4], rho[4], partner[4]; -extern int nodes; /* Number of nodes searched */ -extern int no[50]; /* Number of nodes searched on each - depth level */ -extern int payOff; -extern int iniDepth; -extern int treeDepth; -extern int tricksTarget; /* No of tricks for MAX in order to - meet the game goal, e.g. to make the - contract */ -extern int tricksTargetOpp; /* Target no of tricks for MAX - opponent */ -extern int targetNS; -extern int targetEW; -extern int handToPlay; -extern int searchTraceFlag; -extern int countMax; -extern int depthCount; -extern int highHand; -extern int nodeSetSizeLimit; -extern int winSetSizeLimit; -extern int lenSetSizeLimit; -extern int estTricks[4]; -extern int recInd; -extern int suppressTTlog; -extern unsigned char suitChar[4]; -extern unsigned char rankChar[15]; -extern unsigned char handChar[4]; -extern unsigned char cardRank[15], cardSuit[5], cardHand[4]; -extern int totalNodes; -extern struct futureTricks fut, ft; -extern struct futureTricks *futp; -extern char stri[128]; - -extern FILE *fp, *fpx; - /* Pointers to logs */ - -#ifdef STAT -extern FILE *fp2; -#endif +EXTERN_C DLLEXPORT void STDCALL SetMaxThreads( + int userThreads); -/* Externally accessible functions. */ +EXTERN_C DLLEXPORT void STDCALL FreeMemory(); -EXTERN_C DLLEXPORT int STDCALL SolveBoard(struct deal dl, - int target, int solutions, int mode, struct futureTricks *futp, int threadIndex); -EXTERN_C DLLEXPORT int STDCALL SolveBoardPBN(struct dealPBN dlPBN, int target, - int solutions, int mode, struct futureTricks *futp, int threadIndex); +EXTERN_C DLLEXPORT int STDCALL SolveBoard( + struct deal dl, + int target, + int solutions, + int mode, + struct futureTricks * futp, + int threadIndex); -EXTERN_C DLLEXPORT int STDCALL CalcDDtable(struct ddTableDeal tableDeal, +EXTERN_C DLLEXPORT int STDCALL SolveBoardPBN( + struct dealPBN dlpbn, + int target, + int solutions, + int mode, + struct futureTricks * futp, + int thrId); + +EXTERN_C DLLEXPORT int STDCALL CalcDDtable( + struct ddTableDeal tableDeal, struct ddTableResults * tablep); -EXTERN_C DLLEXPORT int STDCALL CalcDDtablePBN(struct ddTableDealPBN tableDealPBN, + +EXTERN_C DLLEXPORT int STDCALL CalcDDtablePBN( + struct ddTableDealPBN tableDealPBN, struct ddTableResults * tablep); -EXTERN_C DLLEXPORT int STDCALL CalcAllTables(struct ddTableDeals *dealsp, int mode, - int trumpFilter[5], struct ddTablesRes *resp, struct allParResults *presp); -EXTERN_C DLLEXPORT int STDCALL CalcAllTablesPBN(struct ddTableDealsPBN *dealsp, int mode, - int trumpFilter[5], struct ddTablesRes *resp, struct allParResults *presp); +EXTERN_C DLLEXPORT int STDCALL CalcAllTables( + struct ddTableDeals * dealsp, + int mode, + int trumpFilter[DDS_STRAINS], + struct ddTablesRes * resp, + struct allParResults * presp); + +EXTERN_C DLLEXPORT int STDCALL CalcAllTablesPBN( + struct ddTableDealsPBN * dealsp, + int mode, + int trumpFilter[DDS_STRAINS], + struct ddTablesRes * resp, + struct allParResults * presp); + +EXTERN_C DLLEXPORT int STDCALL SolveAllBoards( + struct boardsPBN * bop, + struct solvedBoards * solvedp); + +EXTERN_C DLLEXPORT int STDCALL SolveAllChunks( + struct boardsPBN * bop, + struct solvedBoards * solvedp, + int chunkSize); + +EXTERN_C DLLEXPORT int STDCALL SolveAllChunksBin( + struct boards * bop, + struct solvedBoards * solvedp, + int chunkSize); + +EXTERN_C DLLEXPORT int STDCALL SolveAllChunksPBN( + struct boardsPBN * bop, + struct solvedBoards * solvedp, + int chunkSize); + +EXTERN_C DLLEXPORT int STDCALL Par( + struct ddTableResults * tablep, + struct parResults * presp, + int vulnerable); + +EXTERN_C DLLEXPORT int STDCALL CalcPar( + struct ddTableDeal tableDeal, + int vulnerable, + struct ddTableResults * tablep, + struct parResults * presp); + +EXTERN_C DLLEXPORT int STDCALL CalcParPBN( + struct ddTableDealPBN tableDealPBN, + struct ddTableResults * tablep, + int vulnerable, + struct parResults * presp); + +EXTERN_C DLLEXPORT int STDCALL SidesPar( + struct ddTableResults * tablep, + struct parResultsDealer sidesRes[2], + int vulnerable); + +EXTERN_C DLLEXPORT int STDCALL DealerPar( + struct ddTableResults * tablep, + struct parResultsDealer * presp, + int dealer, + int vulnerable); + +EXTERN_C DLLEXPORT int STDCALL DealerParBin( + struct ddTableResults * tablep, + struct parResultsMaster * presp, + int dealer, int vulnerable); -EXTERN_C DLLEXPORT int STDCALL SolveAllChunksPBN(struct boardsPBN *bop, struct solvedBoards *solvedp, int chunkSize); -EXTERN_C DLLEXPORT int STDCALL SolveAllChunksBin(struct boards *bop, struct solvedBoards *solvedp, int chunkSize); +EXTERN_C DLLEXPORT int STDCALL SidesParBin( + struct ddTableResults * tablep, + struct parResultsMaster sidesRes[2], + int vulnerable); -EXTERN_C DLLEXPORT int STDCALL Par(struct ddTableResults * tablep, struct parResults *presp, - int vulnerable); -EXTERN_C DLLEXPORT int STDCALL DealerPar(struct ddTableResults * tablep, struct parResultsDealer * presp, - int dealer, int vulnerable); -EXTERN_C DLLEXPORT int STDCALL SidesPar(struct ddTableResults * tablep, struct parResultsDealer sidesRes[2], - int vulnerable); +EXTERN_C DLLEXPORT int STDCALL ConvertToDealerTextFormat( + struct parResultsMaster *pres, + char *resp); + +EXTERN_C DLLEXPORT int STDCALL ConvertToSidesTextFormat( + struct parResultsMaster *pres, + struct parTextResults *resp); + +EXTERN_C DLLEXPORT int STDCALL AnalysePlayBin( + struct deal dl, + struct playTraceBin play, + struct solvedPlay * solved, + int thrId); + +EXTERN_C DLLEXPORT int STDCALL AnalysePlayPBN( + struct dealPBN dlPBN, + struct playTracePBN playPBN, + struct solvedPlay * solvedp, + int thrId); -EXTERN_C DLLEXPORT int STDCALL AnalysePlayBin(struct deal dl, struct playTraceBin play, struct solvedPlay* solvedp, - int thrId); -EXTERN_C DLLEXPORT int STDCALL AnalysePlayPBN(struct dealPBN dlPBN, struct playTracePBN playPBN, - struct solvedPlay * solvedp, int thrId); EXTERN_C DLLEXPORT int STDCALL AnalyseAllPlaysBin( - struct boards * bop, struct playTracesBin * plp, struct solvedPlays * solvedp, int chunkSize); -EXTERN_C DLLEXPORT int STDCALL AnalyseAllPlaysPBN(struct boardsPBN * bopPBN, struct playTracesPBN * plpPBN, - struct solvedPlays * solvedp,int chunkSize); - -/* Remain externally accessible only for backwards compatibility. */ - -EXTERN_C DLLEXPORT int STDCALL SolveAllBoards(struct boardsPBN *bop, struct solvedBoards *solvedp); -EXTERN_C DLLEXPORT int STDCALL CalcPar(struct ddTableDeal tableDeal, int vulnerable, - struct ddTableResults * tablep, struct parResults *presp); -EXTERN_C DLLEXPORT int STDCALL CalcParPBN(struct ddTableDealPBN tableDealPBN, - struct ddTableResults * tablep, int vulnerable, struct parResults *presp); -EXTERN_C DLLEXPORT int STDCALL SolveAllChunks(struct boardsPBN *bop, struct solvedBoards *solvedp, int chunkSize); - -/* End of externally accessible functions. */ - - -int ABsearch(struct pos * posPoint, int target, int depth, struct localVarType * thrp); -void Make(struct pos * posPoint, unsigned short int trickCards[4], - int depth, int trump, struct movePlyType *mply, struct localVarType * thrp); -int MoveGen(struct pos * posPoint, int depth, int trump, struct movePlyType *mply, - struct localVarType * thrp); -void MergeSort(int n, struct moveType *a); -inline int WinningMove(struct moveType * mvp1, struct moveType * mvp2, int trump); -inline int WinningMoveNT(struct moveType * mvp1, struct moveType * mvp2); -int AdjustMoveList(struct localVarType * thrp); -int QuickTricks(struct pos * posPoint, int hand, - int depth, int target, int trump, int *result, struct localVarType * thrp); -int LaterTricksMIN(struct pos *posPoint, int hand, int depth, int target, int trump, - struct localVarType * thrp); -int LaterTricksMAX(struct pos *posPoint, int hand, int depth, int target, int trump, - struct localVarType * thrp); -struct nodeCardsType * CheckSOP(struct pos * posPoint, struct nodeCardsType - * nodep, int target, int tricks, int * result, int *value, struct localVarType * thrp); -struct nodeCardsType * UpdateSOP(struct pos * posPoint, struct nodeCardsType - * nodep); -struct nodeCardsType * FindSOP(struct pos * posPoint, - struct winCardType * nodeP, int firstHand, - int target, int tricks, int * valp, struct localVarType * thrp); -struct nodeCardsType * BuildPath(struct pos * posPoint, - struct posSearchType *nodep, int * result, struct localVarType * thrp); -void BuildSOP(struct pos * posPoint, long long suitLengths, int tricks, int firstHand, int target, - int depth, int scoreFlag, int score, struct localVarType * thrp); -struct posSearchType * SearchLenAndInsert(struct posSearchType - * rootp, long long key, int insertNode, int *result, struct localVarType * thrp); -void Undo(struct pos * posPoint, int depth, struct movePlyType *mply, struct localVarType * thrp); -int CheckDeal(struct moveType * cardp, int thrId); -int InvBitMapRank(unsigned short bitMap); -int InvWinMask(int mask); -int NextMove(struct pos *posPoint, int depth, struct movePlyType *mply, - struct localVarType * thrp); -int DumpInput(int errCode, struct deal dl, int target, int solutions, int mode); -void Wipe(struct localVarType * thrp); -void AddNodeSet(struct localVarType * thrp); -void AddLenSet(struct localVarType * thrp); -void AddWinSet(struct localVarType * thrp); - -void PrintDeal(FILE *fp, unsigned short ranks[4][4]); - -int SolveAllBoardsN(struct boards *bop, struct solvedBoards *solvedp, int chunkSize); - -int IsCard(char cardChar); -void UpdateDealInfo(int card); -int IsVal(char cardChar); -int ConvertFromPBN(char * dealBuff, unsigned int remainCards[4][4]); + struct boards * bop, + struct playTracesBin * plp, + struct solvedPlays * solvedp, + int chunkSize); +EXTERN_C DLLEXPORT int STDCALL AnalyseAllPlaysPBN( + struct boardsPBN * bopPBN, + struct playTracesPBN * plpPBN, + struct solvedPlays * solvedp, + int chunkSize); +#endif diff --git a/portab.h b/portab.h new file mode 100644 index 00000000..9f7272e7 --- /dev/null +++ b/portab.h @@ -0,0 +1,60 @@ +#if defined(_WIN32) + #if defined(__MINGW32__) && !defined(WINVER) + #define WINVER 0x500 + #endif + #include + #include + + #define USES_DLLMAIN + /* DLL uses DllMain() for initialization */ + + #define MULTITHREADING_WINDOWS + /* This only means that function calls are used to determine + the number of cores etc. It does not in itself mean that + the DLL is multi-threaded, see DDS_THREADS_*. */ + + + /* SH: stdafx.h is not really required. It is used to + precompile Windows header files, but the CL compiler + is plenty fast for this particular project. */ + #if defined (_MSC_VER) + #include + /* #include stdafx.h */ + #endif + +#elif defined (__CYGWIN__) + #include + #include + #define USES_DLLMAIN + #define MULTITHREADING_WINDOWS + +#elif defined (__linux) + #include + #define USES_CONSTRUCTOR + /* DLL uses a constructor function for initialization */ + + #define MULTITHREADING_OPENMP + /* As above, this just means that OpenMP functions are + used to find the number of cores. */ + + typedef long long __int64; + +#elif defined (__APPLE__) + #include + #define USES_CONSTRUCTOR + #define MULTITHREADING_OPENMP + typedef long long __int64; + +#endif + +#if (! defined DDS_THREADS_WIN32) && \ + (! defined DDS_THREADS_OPENMP) && \ + (! defined DDS_THREADS_NONE) +# define DDS_THREADS_NONE +#endif + +#ifdef DDS_THREADS_OPENMP + #include +#endif + +/*#include "stdafx.h"*/ diff --git a/readme.txt b/readme.txt index b554b33a..b191d9ac 100755 --- a/readme.txt +++ b/readme.txt @@ -1,17 +1,15 @@ -DDS 2.6, Bo Haglund 2014-09-15 +DDS 2.7, Bo Haglund 2014-10-18 -For Win32, DDS compiles with Visual C++ 2010 and 2012 Express editions +For Win32, DDS compiles with Visual C++ 2010 Express editions or later editions and the TDM-GCC/Mingw port of gcc. -When using Visual C++, the statement -#include "stdafx.h" at the beginning of dds.cpp must be uncommented. Linking with an application using DDS ------------------------------------- -The InitStart() function of DDS should be called from inside the +The SetMaxThreads() function of DDS should be called from inside the application. Then SolveBoard in DDS can be called multiple times -without the overhead of InitStart() at each call. +without the overhead of SetMaxThreads() at each call. For this purpose, the application code must have an include statement for the dll.h file in DDS. @@ -34,14 +32,10 @@ Setting the number of simultaneous threads when calling CalcDDtable. -------------------------------------------------------------------- For Windows, this can be done either by reading out the number of processor cores and using this for setting the number of threads, or by supplying the number of -threads (ncores) in InitStart. This latter alternative needs to be used when the operating +threads (ncores) in SetMaxThreads. This latter alternative needs to be used when the operating system does not support reading out of the number of processors. -Options at DDS compilation --------------------------- -Single thread operation can be invoked by -defining DDS_THREADS_SINGLE in the dll.h file. diff --git a/release_notes.txt b/release_notes.txt index c54ec4d6..34055125 100755 --- a/release_notes.txt +++ b/release_notes.txt @@ -462,4 +462,11 @@ The Par function has been corrected. The DealerPar and the PlayAnalyser functions has been added, written by Soren Hein. 2.6.0 is 2% faster than 2.5.2. Soren Hein has contributed on numerous improvements. - +Release Notes DDS 2.7.0 +----------------------- +The transposition table solution has been replaced by a faster one. +The new solution is 8-15% faster. +Many thanks to Soren Hein for writing this part of the code. Soren has also +improved the code at numerous places. +Additional Par functions have been added to ease the use of a DDS user specific +format.