#include "StdAfx.h"
#include "GameLogic.h"

//////////////////////////////////////////////////////////////////////////
//静态变量
const BYTE	CGameLogic::m_bCardListData[CARD_COUNT]=
{
		0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,	//方块 A - K
		0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,	//梅花 A - K
		0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,	//红桃 A - K
		0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,	//黑桃 A - K
		//0x41,0x42,
};
//////////////////////////////////////////////////////////////////////////

//构造函数
CGameLogic::CGameLogic()
{
	ZeroMemory(btCardSpecialData,sizeof(btCardSpecialData));
	m_bClassicRule = true;
}

//析构函数
CGameLogic::~CGameLogic()
{
}

//获取类型
BYTE CGameLogic::GetCardType(BYTE bCardData[], BYTE bCardCount,BYTE btSpecialCard[])
{
	//数据校验
	ASSERT(bCardCount==3 || bCardCount==5||13==bCardCount) ;
	if(bCardCount!=3 && bCardCount!=5&&bCardCount!=13) return CT_INVALID ;

	tagAnalyseData AnalyseData ;
	memset(&AnalyseData , 0 , sizeof(tagAnalyseData)) ;

	//ASSERT(3==bCardCount || 5==bCardCount) ;

	AnalyseCard(bCardData , bCardCount , AnalyseData) ;

	//开始分析
	switch (bCardCount)
	{
	case 3:	//三条类型
		{
			//单牌类型
			if(3==AnalyseData.bOneCount) return CT_SINGLE;

			//对带一张
			if(1==AnalyseData.bTwoCount && 1==AnalyseData.bOneCount) return CT_ONE_DOUBLE ;

			//三张牌型
			if(1==AnalyseData.bThreeCount) return CT_THREE ;

			//错误类型
			return CT_INVALID ;
		}
	case 5:	//五张牌型
		{
			bool bFlushNoA	    = false , 	bFlushFirstA	= false ,		bFlushBackA	= false ;

			if (GetCardLogicValue(bCardData[0])>= CARD_XW && GetCardLogicValue(bCardData[1])<CARD_XW)
			{
				//A连在后
				if ((GetCardLogicValue(bCardData[4])==10 || GetCardLogicValue(bCardData[4])==11) && GetCardLogicValue(bCardData[1])==14)
				{
					bFlushBackA = true;
					for (BYTE i=1; i<4; ++i)
					{
						BYTE nValue=GetCardLogicValue(bCardData[i])-GetCardLogicValue(bCardData[i+1]);
						if (1 != nValue && nValue != 2)
						{
							bFlushBackA = false;
							break;
						}
					}
				}
				else if (14==GetCardLogicValue(bCardData[1]) && 5>=GetCardLogicValue(bCardData[2]))//A连在前
				{
                    bFlushFirstA = true;
					for (BYTE i=2; i<4; ++i)
					{
						BYTE nValue=GetCardLogicValue(bCardData[i])-GetCardLogicValue(bCardData[i+1]);
						if (1 != nValue && nValue != 2)
						{
							bFlushFirstA = false;
							break;
						}
					}
				}
				else if (5>=GetCardLogicValue(bCardData[1])
					&& (GetCardLogicValue(bCardData[0])==CARD_DW || GetCardLogicValue(bCardData[0])==CARD_XW))//A连在前
				{
					bFlushFirstA = true;
					for (BYTE i=1; i<4; ++i)
					{
						BYTE nValue=GetCardLogicValue(bCardData[i])-GetCardLogicValue(bCardData[i+1]);
						if (1 != nValue && nValue != 2)
						{
							bFlushFirstA = false;
							break;
						}
					}
				}
				else
				{
					bFlushNoA = true;
					bool bRes=false;
					for (BYTE i=1; i<4; ++i)
					{
						BYTE A=GetCardLogicValue(bCardData[i]);
						BYTE B=GetCardLogicValue(bCardData[i+1]);
						BYTE nValue=A-B;

						if (nValue==2)
						{
							if (!bRes)	//第一次进入
							{
								bRes=true;
								continue;
							}
							//第二次进入
							bFlushNoA = false;
							break;
						}

						if (1 != nValue)
						{
							bFlushNoA = false;
							break;
						}
					}
				}
			}
			else if (GetCardLogicValue(bCardData[0])== CARD_DW && GetCardLogicValue(bCardData[1])==CARD_XW)
			{
				if (GetCardLogicValue(bCardData[0])==CARD_DW&& GetCardLogicValue(bCardData[1])==CARD_XW)
				{
					bFlushBackA = true;
					BYTE bIndex = 0;
					for (BYTE i=2; i<5; ++i)
					{
						if (GetCardLogicValue(bCardData[i])>=10)
							bIndex++;
					}
					if (GetCardLogicValue(bCardData[2]) != 14)
					{
		
						for (BYTE i=2; i<4; ++i)
						{
							BYTE nValue=GetCardLogicValue(bCardData[i])-GetCardLogicValue(bCardData[i+1]);
							if ((1 != nValue && nValue != 2 )/*|| bIndex!=3*/)
							{
								bFlushBackA = false;
								break;
							}
						}
					}
					else  //16 15 14 12 10     16 15 14 11 10    16 15 14 13 10
					{	  //16 15 14 12 11     16 15 14 13 11   
						  //16 15 14 13 12        
						if (GetCardLogicValue(bCardData[4]) == 10 && bIndex == 3)
						{
							if (!(GetCardLogicValue(bCardData[3]) == 12||GetCardLogicValue(bCardData[3]) == 11||
								GetCardLogicValue(bCardData[3]) == 13))
							{
									bFlushBackA = false;
							}
						}
						else if (GetCardLogicValue(bCardData[4]) == 11 && bIndex == 3)
						{
							if (!(GetCardLogicValue(bCardData[3]) == 12||GetCardLogicValue(bCardData[3]) == 13))
							{
								bFlushBackA = false;
							}
						}
						else if (GetCardLogicValue(bCardData[4]) == 12 && bIndex == 3)
						{
							if (!(GetCardLogicValue(bCardData[3]) == 13))
							{
								bFlushBackA = false;
							}
						}
						else if ( 5>=GetCardLogicValue(bCardData[3]) && (GetCardLogicValue(bCardData[3]) != GetCardLogicValue(bCardData[4])))
						{
							bFlushFirstA = true;
							for (BYTE i=3; i<4; ++i)
							{
								BYTE nValue=GetCardLogicValue(bCardData[i])-GetCardLogicValue(bCardData[i+1]);
								if (1 != nValue && nValue != 2 && nValue !=3)
								{
									bFlushFirstA = false;
									break;
								}
							}
						}
						else  //zyy  3/18  2鬼带两张认成A在后顺子 修复
						{
							for (BYTE i=2; i<4; ++i)
							{
								BYTE nValue=GetCardLogicValue(bCardData[i])-GetCardLogicValue(bCardData[i+1]);
								if ((1 != nValue && nValue != 2 )/*|| bIndex!=3*/)
								{
									bFlushBackA = false;
									break;
								}
							}
						}
						
					}

					//zyy  3/9
					bFlushNoA = true;
					bool bRes1=false;
					bool bRes2=false;
					for (BYTE i=2; i<4; ++i)
					{
						BYTE A=GetCardLogicValue(bCardData[i]);
						BYTE B=GetCardLogicValue(bCardData[i+1]);
						BYTE nValue=A-B;

						if (nValue==3)
						{
							if (!bRes1 && !bRes2)
							{
								bRes1 = true;
								bRes2 = true;
								continue;
							}

							bFlushNoA = false;
							break;
						}

						if (nValue == 2)
						{
							if (!bRes1)
							{
								bRes1 = true;
								continue;
							}
							else if (!bRes2)
							{
								bRes2 = true;
								continue;
							}

							bFlushNoA = false;
							break;
						}

						if (1 != nValue && nValue != 2 && nValue !=3)
						{
							bFlushNoA = false;
							break;
						}

					}

				}
				else if ((GetCardLogicValue(bCardData[4])==10 || GetCardLogicValue(bCardData[4])==11 || GetCardLogicValue(bCardData[4])==12) && GetCardLogicValue(bCardData[2]==14))
				{
					bFlushBackA = true;
					for(BYTE i=2 ; i<4 ; ++i)
					{
						BYTE nValue=GetCardLogicValue(bCardData[i])-GetCardLogicValue(bCardData[i+1]);
						if (1 != nValue && nValue != 2 && nValue !=3)
						{
							bFlushBackA = false;
							break;
						}
					}

				}
			}
			else
			{
				//A连在后
				if (14 == GetCardLogicValue(bCardData[0]) && 10 == GetCardLogicValue(bCardData[4]))
				{
					bFlushBackA = true;
				}
				else
				{
					bFlushNoA = true;
				}

				for(BYTE i=0 ; i<4 ; ++i)
				{
					BYTE nValue=GetCardLogicValue(bCardData[i])-GetCardLogicValue(bCardData[i+1]);
					if(1!=nValue) 
					{
						bFlushBackA = false ;
						bFlushNoA   = false ;
						break;
					}
				}

				//A连在前
				if(false==bFlushBackA && false==bFlushNoA && 14==GetCardLogicValue(bCardData[0]))
				{
					bFlushFirstA = true ;
					for (BYTE i = 1; i < 4; ++i)
					{
						if (1 != GetCardLogicValue(bCardData[i]) - GetCardLogicValue(bCardData[i + 1]))
						{
							bFlushFirstA = false;
						}
					}

					if (2 != GetCardLogicValue(bCardData[4]))
					{
						bFlushFirstA = false;
					}
				}
			}

			//同花五牌
			if(false==bFlushBackA && false==bFlushNoA && false==bFlushFirstA)
			{
				if(true==AnalyseData.bStraight) return CT_FIVE_FLUSH ;
			}
			else if(true==bFlushNoA)
			{
				//杂顺类型
				if(false==AnalyseData.bStraight) return CT_FIVE_MIXED_FLUSH_NO_A;
				//同花顺牌
				else							 return CT_FIVE_STRAIGHT_FLUSH_NO_A ;
			}
			else if(true==bFlushFirstA)
			{
				//杂顺类型
				if(false==AnalyseData.bStraight) return CT_FIVE_MIXED_FLUSH_FIRST_A;
				//同花顺牌
				else							 return CT_FIVE_STRAIGHT_FLUSH_FIRST_A ;
			}
			else if(true==bFlushBackA)
			{
				//杂顺类型
				if(false==AnalyseData.bStraight) return CT_FIVE_MIXED_FLUSH_BACK_A;
				//同花顺牌
				else							 return CT_FIVE_STRAIGHT_FLUSH_BACK_A ;
			}

			//五带0张
			if (1==AnalyseData.bFiveCount) return CT_FIVE_BOMB;
			//四带单张
			if(1==AnalyseData.bFourCount && 1==AnalyseData.bOneCount) return	 CT_FIVE_FOUR_ONE ;
			//三条一对
			if(1==AnalyseData.bThreeCount && 1==AnalyseData.bTwoCount) return	 CT_FIVE_THREE_DEOUBLE ;
			//三条带单
			if(1==AnalyseData.bThreeCount && 2==AnalyseData.bOneCount) return	 CT_THREE ;
			//两对牌型
			if(2==AnalyseData.bTwoCount && 1==AnalyseData.bOneCount) return		 CT_FIVE_TWO_DOUBLE ;
			//只有一对
			if(1==AnalyseData.bTwoCount && 3==AnalyseData.bOneCount) return		 CT_ONE_DOUBLE ;
			//单牌类型
			if(5==AnalyseData.bOneCount && false==AnalyseData.bStraight) return  CT_SINGLE ;
			//错误类型
			return CT_INVALID;
		}
	case 13://13张特殊牌型
		{
			bool TwelveKing=false;
			//同花十三水
			if(13==AnalyseData.bOneCount&&true==AnalyseData.bStraight)
				return CT_THIRTEEN_FLUSH;
			//十三水
			if(13==AnalyseData.bOneCount)
				return CT_THIRTEEN;
			//十二皇族
			TwelveKing=true;
			for(int i=0;i<13;i++)
			{
				if(GetCardLogicValue(bCardData[i])<11)
				{
			 		TwelveKing=false;
			 		break;
				}
			}
			if(TwelveKing)
			{
				return CT_TWELVE_KING;
			}



			//三同花顺
			/*bool bThreeStraightFlush = false;
			bThreeStraightFlush = IsThreeFlushStraight(bCardData,bCardCount);
			if (bThreeStraightFlush)
			{
				return CT_THREE_STRAIGHTFLUSH;
			}*/
			//三同花顺子
			{
				BYTE bCardList[13] = {0};
				memcpy(bCardList,bCardData,sizeof(BYTE)*13);
				SortCardList(bCardList,13);
				BYTE bLeftCount = 13;
				BYTE cbStraightFlush[5] = {0};
				BYTE bTempCount = 5;
				tagAnalyseType tagCardType = GetType(bCardList,bLeftCount);
				if (tagCardType.bStraightFlush)
				{
					
					for (BYTE i = 0;i<tagCardType.btStraightFlush;++i)
					{
						CopyMemory(bCardList,bCardData,sizeof(bCardList));
						bLeftCount = 13;
						SortCardList(bCardList,13);
						ZeroMemory(cbStraightFlush,sizeof(cbStraightFlush));
						cbStraightFlush[0]=bCardList[tagCardType.cbStraightFlush[i*5]];
						cbStraightFlush[1]=bCardList[tagCardType.cbStraightFlush[i*5+1]];
						cbStraightFlush[2]=bCardList[tagCardType.cbStraightFlush[i*5+2]];
						cbStraightFlush[3]=bCardList[tagCardType.cbStraightFlush[i*5+3]];
						cbStraightFlush[4]=bCardList[tagCardType.cbStraightFlush[i*5+4]];

						//移除第一个同花顺
						RemoveCard(cbStraightFlush, bTempCount, bCardList, bLeftCount);
						bLeftCount -= bTempCount;
						
						//备份剩余牌
						BYTE bLeftCardList[13] = {0};
						CopyMemory(bLeftCardList,bCardList,bLeftCount);
						BYTE bLeftCount1 =bLeftCount;

						tagAnalyseType tagCardType1 = GetType(bCardList,bLeftCount);
						if (tagCardType1.bStraightFlush)
						{
							for (BYTE j = 0;j<tagCardType1.btStraightFlush;++j)
							{
								//重新赋值
								CopyMemory(bCardList,bLeftCardList,bLeftCount1);
								ZeroMemory(cbStraightFlush,sizeof(cbStraightFlush));
								bLeftCount =bLeftCount1;
								cbStraightFlush[0]=bCardList[tagCardType1.cbStraightFlush[j*5]];
								cbStraightFlush[1]=bCardList[tagCardType1.cbStraightFlush[j*5+1]];
								cbStraightFlush[2]=bCardList[tagCardType1.cbStraightFlush[j*5+2]];
								cbStraightFlush[3]=bCardList[tagCardType1.cbStraightFlush[j*5+3]];
								cbStraightFlush[4]=bCardList[tagCardType1.cbStraightFlush[j*5+4]];
								//移除第二个同花顺
								RemoveCard(cbStraightFlush, bTempCount, bCardList, bLeftCount);
								bLeftCount -= bTempCount;
								

								//判断剩余3张是否也符合同花顺
								bool bThreeStraightFlush = false;
								SortCardList(bCardList , bLeftCount, enDescend) ;
								
								if (GetCardLogicValue(bCardList[0]) >=CARD_XW && GetCardLogicValue(bCardList[1]) <CARD_XW)
								{
									if((GetCardColor(bCardList[1]) == GetCardColor(bCardList[2]))&&
										(GetCardLogicValue(bCardList[1])-GetCardLogicValue(bCardList[2])==1 
										|| GetCardLogicValue(bCardList[1])-GetCardLogicValue(bCardList[2])==2
										|| (GetCardLogicValue(bCardList[1]) == 14 &&GetCardLogicValue(bCardList[2])<=3))
										)
									{
										bThreeStraightFlush = true;
									}
								}
								else if (GetCardLogicValue(bCardList[0]) ==CARD_DW && GetCardLogicValue(bCardList[1]) ==CARD_XW)
								{
									bThreeStraightFlush = true;
								}
								else
								{
									if((GetCardColor(bCardList[0]) == GetCardColor(bCardList[1]) && GetCardColor(bCardList[0]) == GetCardColor(bCardList[2]))&&
										((GetCardLogicValue(bCardList[0])==GetCardLogicValue(bCardList[1])+1 && GetCardLogicValue(bCardList[1])==GetCardLogicValue(bCardList[2])+1)
										|| (GetCardLogicValue(bCardList[0]) == 14 &&GetCardLogicValue(bCardList[1])==3 &&GetCardLogicValue(bCardList[2])==2)))
									{
										bThreeStraightFlush = true;
									}
								}
								if (bThreeStraightFlush)
								{
									return CT_THREE_STRAIGHTFLUSH;
								}
							}

						}
					}
				}
			}

			//三炸弹
			if(3==AnalyseData.bFourCount)
			{
			 	return CT_THREE_BOMB;
			}
			//全大
			bool AllBig=true;
			for(int i=0;i<13;i++)
			{
			    if(GetCardLogicValue(bCardData[i])<8&&GetCardLogicValue(bCardData[i]) != CARD_XW&&GetCardLogicValue(bCardData[i]) != CARD_DW)
			 	{
			        AllBig=false;
			 		break;
			 	}
			}
			if(AllBig)
			{
			 	return CT_ALL_BIG;
			}
			//全小
			bool AllSmall=true;
			for(int i=0;i<13;i++)
			{
			 	if(GetCardLogicValue(bCardData[i])>8&&GetCardLogicValue(bCardData[i]) != CARD_XW&&GetCardLogicValue(bCardData[i]) != CARD_DW)
			 	{
			 		AllSmall=false;
			 		break;
			 	}
			}
			if(AllSmall)
			{
			 	return CT_ALL_SMALL;
			}
			//凑一色
			{
				BYTE Flush=1;
				BYTE bStartIndex = 0;
				BYTE SColor=0;
				BYTE bSameColorList[13] = {0};
				memcpy(bSameColorList, bCardData, sizeof(BYTE)*13);
				SortCardList(bSameColorList,13);
				if (GetCardLogicValue(bSameColorList[0])>= CARD_XW && GetCardLogicValue(bSameColorList[1])<CARD_XW)
				{
					bStartIndex=1;
				}else if (GetCardLogicValue(bSameColorList[0])>= CARD_XW && GetCardLogicValue(bSameColorList[1])>=CARD_XW)
				{
					bStartIndex=2;
				}

				{
					SColor=GetCardColor(bSameColorList[bStartIndex]);
					for(int i=bStartIndex+1;i<13;i++)
					{
						if(SColor==(GetCardColor(bSameColorList[i])) || SColor==((GetCardColor(bSameColorList[i])+2)%4))
						{
							Flush++;
						}
						else
						{
							break;
						}
					}
				}

				if(13-bStartIndex==Flush)
				{
					return CT_SAME_COLOR;
				}
			}
			
			
	
			//四套冲三
			if(4==AnalyseData.bThreeCount||(3==AnalyseData.bThreeCount&&1==AnalyseData.bFourCount)
				||(2==AnalyseData.bThreeCount&&1==AnalyseData.bFourCount&&(AnalyseData.bTwoCount>=1) &&(GetCardLogicValue(bCardData[0])==CARD_XW||GetCardLogicValue(bCardData[0])==CARD_DW)))
			{
				return CT_FOUR_THREESAME;
			}
			//五对冲三
			if((5==AnalyseData.bTwoCount&&1==AnalyseData.bThreeCount)||(3==AnalyseData.bTwoCount&&1==AnalyseData.bFourCount&&1==AnalyseData.bThreeCount)
				||(1==AnalyseData.bTwoCount&&2==AnalyseData.bFourCount&&1==AnalyseData.bThreeCount))
			{
				return CT_FIVEPAIR_THREE;
			}
			//六对半
			if(6==AnalyseData.bTwoCount||(4==AnalyseData.bTwoCount&&1==AnalyseData.bFourCount)||(2==AnalyseData.bTwoCount&&2==AnalyseData.bFourCount)
				||(3==AnalyseData.bFourCount))
			{
				return CT_SIXPAIR;
			}
			//三同花
			{
				//定义变量
				BYTE bCardList[13] = {0};
				memcpy(bCardList, bCardData, sizeof(BYTE)*13);
				BYTE bLeftCCount = 13;
				BYTE bTempCard[3][5] = {0};
				BYTE bTempCCount[3] = {0};
				bool Flush = true;
				//摆牌开始
				for (int i = 0; i < 3; i++)
				{
					if (!IsFlush(bCardList, bLeftCCount, bTempCard[i], bTempCCount[i], (i==2?3:5)))
					{
						Flush = false;
						break;
					}
					
					RemoveCard(bTempCard[i], bTempCCount[i], bCardList, bLeftCCount);
					bLeftCCount -= bTempCCount[i];

					if (i<2) CopyMemory(&btSpecialCard[i*5],bTempCard[i], bTempCCount[i]);
					else CopyMemory(&btSpecialCard[10],bTempCard[i], bTempCCount[i]);
				}

				if (Flush)
				{
					return CT_THREE_FLUSH;
				}

			}
		
			//三顺子
			{
				BYTE bCardList[13] = {0};
				memcpy(bCardList,bCardData,sizeof(BYTE)*13);
				SortCardList(bCardList,13);
				BYTE bLeftCount = 13;
				BYTE cbStraight[5] = {0};
				BYTE bTempCount = 5;
				bool Straight = true;
				tagAnalyseType tagCardType = GetType(bCardList,bLeftCount);
				if (tagCardType.bStraight)
				{
					int  xxx = 0;
					for(BYTE i=0;i<20;i++)
					{
						if(tagCardType.cbStraight[i*5]==0&&tagCardType.cbStraight[i*5+1]==0)
						{
							xxx = i;
							break;
						}
					}
					if (xxx>tagCardType.btStraight)
					{
						tagCardType.btStraight = xxx;
					}
					ZeroMemory(btSpecialCard,sizeof(BYTE)*13);
					for (BYTE i = 0;i<tagCardType.btStraight;++i) //zyy 特殊牌少了1次
					{
						CopyMemory(bCardList,bCardData,sizeof(bCardList));
						bLeftCount = 13;
						SortCardList(bCardList,13);
						ZeroMemory(cbStraight,sizeof(cbStraight));
						cbStraight[0]=bCardList[tagCardType.cbStraight[i*5]];
						cbStraight[1]=bCardList[tagCardType.cbStraight[i*5+1]];
						cbStraight[2]=bCardList[tagCardType.cbStraight[i*5+2]];
						cbStraight[3]=bCardList[tagCardType.cbStraight[i*5+3]];
						cbStraight[4]=bCardList[tagCardType.cbStraight[i*5+4]];
						
						//移除第一个顺子
						RemoveCard(cbStraight, bTempCount, bCardList, bLeftCount);
						bLeftCount -= bTempCount;
						CopyMemory(btSpecialCard,cbStraight, bTempCount);
						//备份剩余牌
						BYTE bLeftCardList[13] = {0};
						CopyMemory(bLeftCardList,bCardList,bLeftCount);
						BYTE bLeftCount1 =bLeftCount;
					
						tagAnalyseType tagCardType1 = GetType(bCardList,bLeftCount);
						if (tagCardType1.bStraight)
						{
							for (BYTE j = 0;j<tagCardType1.btStraight;++j)
							{
								//重新赋值
								CopyMemory(bCardList,bLeftCardList,bLeftCount1);
								ZeroMemory(cbStraight,sizeof(cbStraight));
								bLeftCount =bLeftCount1;
								cbStraight[0]=bCardList[tagCardType1.cbStraight[j*5]];
								cbStraight[1]=bCardList[tagCardType1.cbStraight[j*5+1]];
								cbStraight[2]=bCardList[tagCardType1.cbStraight[j*5+2]];
								cbStraight[3]=bCardList[tagCardType1.cbStraight[j*5+3]];
								cbStraight[4]=bCardList[tagCardType1.cbStraight[j*5+4]];
								//移除第二个顺子
								RemoveCard(cbStraight, bTempCount, bCardList, bLeftCount);
								bLeftCount -= bTempCount;
								CopyMemory(btSpecialCard+5,cbStraight, bTempCount);

								//判断剩余3张是否也符合顺子
								bool bThreeStraight = false;
								SortCardList(bCardList , bLeftCount, enDescend) ;
								if (GetCardLogicValue(bCardList[0]) >=CARD_XW && GetCardLogicValue(bCardList[1]) <CARD_XW)
								{
									if(GetCardLogicValue(bCardList[1])-GetCardLogicValue(bCardList[2])==1 
										|| GetCardLogicValue(bCardList[1])-GetCardLogicValue(bCardList[2])==2
										|| (GetCardLogicValue(bCardList[1]) == 14 &&GetCardLogicValue(bCardList[2])<=3)
										)
									{
										bThreeStraight = true;
									}
								}
								else if (GetCardLogicValue(bCardList[0]) ==CARD_DW && GetCardLogicValue(bCardList[1]) ==CARD_XW)
								{
									bThreeStraight = true;
								}
								else
								{
									if((GetCardLogicValue(bCardList[0])==GetCardLogicValue(bCardList[1])+1 && GetCardLogicValue(bCardList[1])==GetCardLogicValue(bCardList[2])+1)
										|| (GetCardLogicValue(bCardList[0]) == 14 &&GetCardLogicValue(bCardList[1])==3 &&GetCardLogicValue(bCardList[2])==2))
									{
										bThreeStraight = true;
									}
								}
								if (bThreeStraight)
								{
									CopyMemory(btSpecialCard+10,bCardList , bLeftCount);
									return CT_THREE_STRAIGHT;
								}
							}
							
						}
					}
				}
			}
		}  
	}
	return CT_INVALID;
}

//排列扑克
void CGameLogic::SortCardList(BYTE bCardData[], BYTE bCardCount,enSortCardType SortCardType)
{
	ASSERT(bCardCount>=1 && bCardCount<=13) ;
	if(bCardCount<1 || bCardCount>13) return ;

	//转换数值
	BYTE bLogicVolue[13];
	for (BYTE i=0;i<bCardCount;i++)	bLogicVolue[i]=GetCardLogicValue(bCardData[i]);	

	if(enDescend==SortCardType)
	{
		//排序操作
		bool bSorted=true;
		BYTE bTempData,bLast=bCardCount-1;
		BYTE m_bCardCount=1;
		do
		{
			bSorted=true;
			for (BYTE i=0;i<bLast;i++)
			{
				if ((bLogicVolue[i]<bLogicVolue[i+1])||
					((bLogicVolue[i]==bLogicVolue[i+1])&&(bCardData[i]<bCardData[i+1])))
				{
					//交换位置
					bTempData=bCardData[i];
					bCardData[i]=bCardData[i+1];
					bCardData[i+1]=bTempData;
					bTempData=bLogicVolue[i];
					bLogicVolue[i]=bLogicVolue[i+1];
					bLogicVolue[i+1]=bTempData;
					bSorted=false;
				}	
			}
			bLast--;
		} while(bSorted==false);
	}
	else if(enAscend==SortCardType)
	{
		//排序操作
		bool bSorted=true;
		BYTE bTempData,bLast=bCardCount-1;
		BYTE m_bCardCount=1;
		do
		{
			bSorted=true;
			for (BYTE i=0;i<bLast;i++)
			{
				if ((bLogicVolue[i]>bLogicVolue[i+1])||
					((bLogicVolue[i]==bLogicVolue[i+1])&&(bCardData[i]>bCardData[i+1])))
				{
					//交换位置
					bTempData=bCardData[i];
					bCardData[i]=bCardData[i+1];
					bCardData[i+1]=bTempData;
					bTempData=bLogicVolue[i];
					bLogicVolue[i]=bLogicVolue[i+1];
					bLogicVolue[i+1]=bTempData;
					bSorted=false;
				}	
			}
			bLast--;
		} while(bSorted==false);
	}
	else if(enColor==SortCardType)
	{
		//排序操作
		bool bSorted=true;
		BYTE bTempData,bLast=bCardCount-1;
		BYTE m_bCardCount=1;
		BYTE bColor[13];
		for (BYTE i=0;i<bCardCount;i++)	bColor[i]=GetCardColor(bCardData[i]);	
		do
		{
			bSorted=true;
			for (BYTE i=0;i<bLast;i++)
			{
				if ((bColor[i]<bColor[i+1])||
					((bColor[i]==bColor[i+1])&&(GetCardLogicValue(bCardData[i])<GetCardLogicValue(bCardData[i+1]))))
				{
					//交换位置
					bTempData=bCardData[i];
					bCardData[i]=bCardData[i+1];
					bCardData[i+1]=bTempData;
					bTempData=bColor[i];
					bColor[i]=bColor[i+1];
					bColor[i+1]=bTempData;
					bSorted=false;
				}	
			}
			bLast--;
		} while(bSorted==false);
	}
	return;
}

//混乱扑克
void CGameLogic::RandCardList(BYTE bCardBuffer[], BYTE bBufferCount)
{
	//混乱准备
	BYTE bCardData[sizeof(m_bCardListData)];
	CopyMemory(bCardData,m_bCardListData,sizeof(m_bCardListData));
	//CopyMemory(bCardBuffer,m_bCardListData,sizeof(m_bCardListData));

	//混乱扑克
	BYTE bRandCount=0,bPosition=0;
	do
	{
		bPosition=rand()%(bBufferCount-bRandCount);
		bCardBuffer[bRandCount++]=bCardData[bPosition];
		bCardData[bPosition]=bCardData[bBufferCount-bRandCount];
	} while (bRandCount<bBufferCount);
	return;
}

//删除扑克
bool CGameLogic::RemoveCard(const BYTE bRemoveCard[], BYTE bRemoveCount, BYTE bCardData[], BYTE bCardCount)
{
	//检验数据
	ASSERT(bRemoveCount<=bCardCount);

	//定义变量
	BYTE bDeleteCount=0,bTempCardData[13];
	if (bCardCount>CountArray(bTempCardData)) return false;
	CopyMemory(bTempCardData,bCardData,bCardCount*sizeof(bCardData[0]));

	//置零扑克
	for (BYTE i=0;i<bRemoveCount;i++)
	{
		for (BYTE j=0;j<bCardCount;j++)
		{
			if (bRemoveCard[i]==bTempCardData[j])
			{
				bDeleteCount++;
				bTempCardData[j]=0;
				break;
			}
		}
	}
	if (bDeleteCount!=bRemoveCount) return false;

	//清理扑克
	BYTE bCardPos=0;
	for (BYTE i=0;i<bCardCount;i++)
	{
		if (bTempCardData[i]!=0) bCardData[bCardPos++]=bTempCardData[i];
	}

	return true;
}

//逻辑数值
BYTE CGameLogic::GetCardLogicValue(BYTE bCardData)
{
	//扑克属性
	BYTE bCardValue=GetCardValue(bCardData); 
	BYTE bCardColor=GetCardColor(bCardData);
	if(bCardColor==0x04)
	{
		return bCardValue+14;
	}
	//转换数值
	return (bCardValue==1)?(bCardValue+13):bCardValue; 
}

/*
返回值:
*	bNextList>bFirstList:true
bNextList<bFirstList:false
*/
//对比扑克;
BYTE CGameLogic::CompareCard(BYTE bInFirstList[], BYTE bInNextList[], BYTE bFirstCount, BYTE bNextCount , bool bComperWithOther)
{
	tagAnalyseData FirstAnalyseData , NextAnalyseData;

	memset(&FirstAnalyseData , 0 , sizeof(tagAnalyseData)) ;
	memset(&NextAnalyseData , 0 , sizeof(tagAnalyseData)) ;

	//排列扑克;
	BYTE bFirstList[13] = {0};
	BYTE bNextList[13] = {0};
	CopyMemory(bFirstList , bInFirstList , bFirstCount) ;
	CopyMemory(bNextList , bInNextList , bNextCount) ;
	SortCardList(bFirstList , bFirstCount , enDescend) ;
	SortCardList(bNextList , bNextCount , enDescend) ;

	//ASSERT(3 == bFirstCount || 5 == bFirstCount || 3 == bNextCount || 5 == bNextCount || 13 == bFirstCount || 13 == bNextCount);

	AnalyseCard(bFirstList , bFirstCount , FirstAnalyseData);

	AnalyseCard(bNextList  , bNextCount  , NextAnalyseData);

	BYTE cbTempFirstCount = (FirstAnalyseData.bOneCount + FirstAnalyseData.bTwoCount * 2 + FirstAnalyseData.bThreeCount * 3 + FirstAnalyseData.bFourCount * 4 + FirstAnalyseData.bFiveCount * 5);
	//ASSERT(bFirstCount == cbTempFirstCount);
	if (bFirstCount != cbTempFirstCount)
	{
		return 0 ;
	}

	BYTE cbTempNextCount = (NextAnalyseData.bOneCount + NextAnalyseData.bTwoCount * 2 + NextAnalyseData.bThreeCount * 3 + NextAnalyseData.bFourCount * 4 + NextAnalyseData.bFiveCount * 5);
	//ASSERT(bNextCount = cbTempNextCount);
	if (bNextCount != cbTempNextCount)
	{
		return 0 ;
	}

	//数据验证;
	//ASSERT((bFirstCount == bNextCount) || (bFirstCount != bNextCount && (3 == bFirstCount && 5 == bNextCount || 5 == bFirstCount && 3 == bNextCount)));
	if(!((bFirstCount==bNextCount) || (bFirstCount!=bNextCount && (3==bFirstCount && 5==bNextCount || 5==bFirstCount && 3==bNextCount)))) return 0 ;

	//获取类型;
	//ASSERT(3==bNextCount || 5==bNextCount) ;
	//ASSERT(3==bFirstCount || 5==bFirstCount) ;

	BYTE bNextType = GetCardType(bNextList,bNextCount,btCardSpecialData);
	BYTE bFirstType = GetCardType(bFirstList,bFirstCount,btCardSpecialData);

	//ASSERT(SSS_CT_INVALID != bNextType && SSS_CT_INVALID != bFirstType);
	if(CT_INVALID==bFirstType || CT_INVALID==bNextType) return 0;
	
	//头段比较;
	if(true==bComperWithOther)
	{
		if(3==bFirstCount)
		{
			//开始对比;
			if(bNextType==bFirstType) 
			{
				switch(bFirstType) 
				{
				case CT_SINGLE:				//单牌类型;
					{
						//数据验证;
					//CC_//ASSERT(bNextList[0] != bFirstList[0]);
						if(bNextList[0]==bFirstList[0]) return false ;

						for (BYTE i = 0; i < 3; ++i)
						{
							BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
							BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);

							if (cbNextLogicValue != cbFirstLogicValue)
							{
								return cbNextLogicValue > cbFirstLogicValue;
							}
						}

						//表示不比水;
						return 2;

					}
				case CT_ONE_DOUBLE:			//对带一张;
					{
						//数据验证;
						BYTE cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[0]];
						BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[0]];
					//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
						if (cbNextCardValue == cbFirstCardValue) return false;

						BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
						BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
						if (cbNextLogicValue == cbFirstLogicValue)
						{
							cbNextLogicValue = GetCardLogicValue(bNextList[NextAnalyseData.bOneFirst[0]]);
							cbFirstLogicValue = GetCardLogicValue(bFirstList[FirstAnalyseData.bOneFirst[0]]);

							if (cbNextLogicValue != cbFirstLogicValue)
							{
								return cbNextLogicValue > cbFirstLogicValue;
							}
							else
							{
								return 2;
							}
						}
						else
						{
							return cbNextLogicValue > cbFirstLogicValue;
						}
					}	

				case CT_THREE:				//三张牌型;
					{
						//数据验证;
						BYTE cbNextCardValue = bNextList[NextAnalyseData.bThreeFirst[0]];
						BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bThreeFirst[0]];

					//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
						if (cbNextCardValue == cbFirstCardValue) return false;

						BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
						BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
						if (cbNextLogicValue == cbFirstLogicValue)
						{
							return 2;
						}
						else
						{
							return cbNextLogicValue > cbFirstLogicValue; 	//比较数值;
						}
					}		

				}

			}
			else
			{
				return bNextType>bFirstType;
			}
		}
		else if(5==bFirstCount)
		{
			//开始对比;
			if(bNextType==bFirstType) 
			{
				switch(bFirstType) 
				{
				case CT_SINGLE:				//单牌类型;
					{
						//数据验证;
					//CC_//ASSERT(bNextList[0] != bFirstList[0]);
						if(bNextList[0]==bFirstList[0]) return false ;

						for (BYTE i = 0; i < 5; ++i)
						{
							BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
							BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);

							if (cbNextLogicValue != cbFirstLogicValue)
							{
								return cbNextLogicValue > cbFirstLogicValue;
							}
						}

						return 2;
					}
				case CT_ONE_DOUBLE:			//对带一张;
					{
						//数据验证;
						BYTE cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[0]];
						BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[0]];

					//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
						if (cbNextCardValue == cbFirstCardValue) return false;

						BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
						BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);

						if (cbNextLogicValue == cbFirstLogicValue)
						{
							//对比单张;
							for(BYTE i=0; i<3; ++i)
							{
								cbNextCardValue = bNextList[NextAnalyseData.bOneFirst[i]];
								cbFirstCardValue = bFirstList[FirstAnalyseData.bOneFirst[i]];

								if (GetCardLogicValue(cbNextCardValue) != GetCardLogicValue(cbFirstCardValue))
								{
									return GetCardLogicValue(cbNextCardValue) > GetCardLogicValue(cbFirstCardValue);
								}
							}

							return 2;
						}
						else
						{
							return cbNextLogicValue > cbFirstLogicValue; 	//比较数值;
						}
					}
				case CT_FIVE_TWO_DOUBLE:	//两对牌型;
					{
						//数据验证;
						BYTE cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[0]];
						BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[0]];

					//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
						if (cbNextCardValue == cbFirstCardValue) return false;

						BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
						BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);

						if (cbNextLogicValue == cbFirstLogicValue)
						{
							cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[1]];
							cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[1]];

							if (GetCardLogicValue(cbNextCardValue) == GetCardLogicValue(cbFirstCardValue))
							{
								cbNextCardValue = bNextList[NextAnalyseData.bOneFirst[0]];
								cbFirstCardValue = bFirstList[FirstAnalyseData.bOneFirst[0]];

								if (GetCardLogicValue(cbNextCardValue) != GetCardLogicValue(cbFirstCardValue))
								{
									return GetCardLogicValue(cbNextCardValue) > GetCardLogicValue(cbFirstCardValue);
								}

								return 2;
							}
							else
							{
								//比较数值;
								return GetCardLogicValue(cbNextCardValue) > GetCardLogicValue(cbFirstCardValue);
							}
						}							
						else
						{
							return cbNextLogicValue > cbFirstLogicValue; 	//比较数值;
						}
					}

				case CT_THREE:				//三张牌型;
					{
						//数据验证;
						BYTE cbNextCardValue = bNextList[NextAnalyseData.bThreeFirst[0]];
						BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bThreeFirst[0]];

					//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
						if (cbNextCardValue == cbFirstCardValue) return false;

						if (GetCardLogicValue(cbNextCardValue) == GetCardLogicValue(cbFirstCardValue))
						{
							return 2;
						}
						else
						{
							return GetCardLogicValue(cbNextCardValue) > GetCardLogicValue(cbFirstCardValue); 	//比较数值
						}
					}

				case CT_FIVE_MIXED_FLUSH_FIRST_A:				//A在前顺子;
					{
						//数据验证;
					//CC_//ASSERT(bNextList[0] != bFirstList[0]);
						if(bNextList[0]==bFirstList[0]) return false ;

						return 2;  //  12345  怎么比 都是一样大;

						//zyy 如果顺子有王 就比第二张;
						if (GetCardLogicValue(bNextList[0]) == CARD_DW||GetCardLogicValue(bNextList[0]) == CARD_XW
							||GetCardLogicValue(bFirstList[0]) == CARD_DW||GetCardLogicValue(bFirstList[0]) == CARD_XW)
						{
							if(GetCardLogicValue(bNextList[2]) == GetCardLogicValue(bFirstList[2]))
								return 2;
							else
								return GetCardLogicValue(bNextList[2]) > GetCardLogicValue(bFirstList[2]) ;	//比较数值
						}

						if(GetCardLogicValue(bNextList[0]) == GetCardLogicValue(bFirstList[0]))
							return 2;
						else
							return GetCardLogicValue(bNextList[0]) > GetCardLogicValue(bFirstList[0]) ;	//比较数值

					}
				case CT_FIVE_MIXED_FLUSH_NO_A:			//没A杂顺
					{
						//数据验证;
					//CC_//ASSERT(bNextList[0] != bFirstList[0]);
						if(bNextList[0]==bFirstList[0]) return false ;

						//zyy 如果顺子有王 就比第二张;
						if (GetCardLogicValue(bNextList[0]) == CARD_DW||GetCardLogicValue(bNextList[0]) == CARD_XW
							||GetCardLogicValue(bFirstList[0]) == CARD_DW||GetCardLogicValue(bFirstList[0]) == CARD_XW)
						{
							if(GetCardLogicValue(bNextList[4]) == GetCardLogicValue(bFirstList[4]))
								return 2;
							else
								return GetCardLogicValue(bNextList[4]) > GetCardLogicValue(bFirstList[4]) ;	//比较数值;
						}

						if(GetCardLogicValue(bNextList[0])==GetCardLogicValue(bFirstList[0]))
							return 2;
						else
							return GetCardLogicValue(bNextList[0]) > GetCardLogicValue(bFirstList[0]); 	//比较数值;
					}
				case CT_FIVE_MIXED_FLUSH_BACK_A:		//A在后顺子;
					{
						//数据验证;
					//CC_//ASSERT(bNextList[0] != bFirstList[0]);
						if(bNextList[0]==bFirstList[0]) return false ;

						return 2;  //  10 J Q K 1  怎么比 都是一样大;

							//zyy 如果顺子有王 就比第二张;
						if (GetCardLogicValue(bNextList[0]) == CARD_DW||GetCardLogicValue(bNextList[0]) == CARD_XW
							||GetCardLogicValue(bFirstList[0]) == CARD_DW||GetCardLogicValue(bFirstList[0]) == CARD_XW)
						{
							if(GetCardLogicValue(bNextList[2]) == GetCardLogicValue(bFirstList[2]))
								return 2;
							else
								return GetCardLogicValue(bNextList[2]) > GetCardLogicValue(bFirstList[2]) ;	//比较数值;
						}

						if(GetCardLogicValue(bNextList[0])==GetCardLogicValue(bFirstList[0]))
							return 2;
						else
							return GetCardLogicValue(bNextList[0]) > GetCardLogicValue(bFirstList[0]); 	//比较数值;

					}

				case CT_FIVE_FLUSH:				//同花五牌;
					{
						//数据验证;
					//CC_//ASSERT(bNextList[0] != bFirstList[0]);
						if(bNextList[0]==bFirstList[0]) return false ;

						//比较数值;
						for (BYTE i = 0; i<5; ++i)
						{
							BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
							BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);

							if (cbNextLogicValue != cbFirstLogicValue)
							{
								return cbNextLogicValue > cbFirstLogicValue;
							}
						}

						//比较花色;
						return 2;			
					}

				case CT_FIVE_THREE_DEOUBLE:			//三条一对;
					{
						//数据验证;
						BYTE cbNextCardValue = bNextList[NextAnalyseData.bThreeFirst[0]];
						BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bThreeFirst[0]];

					//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
						if (cbNextCardValue == cbFirstCardValue) return false;

						if (GetCardLogicValue(cbNextCardValue) == GetCardLogicValue(cbFirstCardValue))
						{
							return 2;
						}
						else
						{
							//比较数值;
							return GetCardLogicValue(cbNextCardValue) > GetCardLogicValue(cbFirstCardValue);
						}
					}

				case CT_FIVE_FOUR_ONE:			//四带一张;
					{
						//数据验证;
						BYTE cbNextCardValue = bNextList[NextAnalyseData.bFourFirst[0]];
						BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bFourFirst[0]];

					//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
						if (cbNextCardValue == cbFirstCardValue) return false;

						//zyy 如果顺子有王 就比第三张;
						if (GetCardLogicValue(bNextList[0]) == CARD_DW||GetCardLogicValue(bNextList[0]) == CARD_XW
							||GetCardLogicValue(bFirstList[0]) == CARD_DW||GetCardLogicValue(bFirstList[0]) == CARD_XW)
						{
							if(GetCardLogicValue(bNextList[3]) == GetCardLogicValue(bFirstList[3]))
							{
								return 2;
							}
							else
							{
								return GetCardLogicValue(bNextList[3]) > GetCardLogicValue(bFirstList[3]) ;	//比较数值;
							}
						}

						if (GetCardLogicValue(cbNextCardValue) == GetCardLogicValue(cbFirstCardValue))
						{
							return 2;
						}
						else
						{
							return GetCardLogicValue(cbNextCardValue) > GetCardLogicValue(cbFirstCardValue);	//比较数值;
						}
					}
				case CT_FIVE_BOMB:      //五相  //zyy五同需要比较第二张;
					{
						BYTE cbNextCardValue = bNextList[NextAnalyseData.bFiveFirst[0]];
						BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bFiveFirst[0]];

					//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
						if (cbNextCardValue == cbFirstCardValue) return false;

						if(GetCardLogicValue(bNextList[1]) == GetCardLogicValue(bFirstList[1]))
						{
							return 2;
						}
						else
						{
							//比较数值;
							return GetCardLogicValue(bNextList[1]) > GetCardLogicValue(bFirstList[1]);
						}
					}
				case CT_FIVE_STRAIGHT_FLUSH_NO_A:   //没A同花顺
					{
						//数据验证;
					//CC_//ASSERT(bNextList[0] != bFirstList[0]);
						if(bNextList[0]==bFirstList[0]) return false ;

						//zyy 如果顺子有王 就比第二张;
						if (GetCardLogicValue(bNextList[0]) == CARD_DW||GetCardLogicValue(bNextList[0]) == CARD_XW
							||GetCardLogicValue(bFirstList[0]) == CARD_DW||GetCardLogicValue(bFirstList[0]) == CARD_XW)
						{
							//比较数值;
							//for(BYTE i=2; i<5; ++i)
								//if(GetCardLogicValue(bNextList[i]) != GetCardLogicValue(bFirstList[i]))
							
							/// zyy  3/6 2017;
							if ( GetCardLogicValue(bNextList[4]) != GetCardLogicValue(bFirstList[4]))
							{
								return GetCardLogicValue(bNextList[4]) > GetCardLogicValue(bFirstList[4]);
							}
							else
							{
								return 2;
							}
						}
						//比较数值;
						for (BYTE i = 0; i<5; ++i)
						{
							if (GetCardLogicValue(bNextList[i]) != GetCardLogicValue(bFirstList[i]))
							{
								return GetCardLogicValue(bNextList[i]) > GetCardLogicValue(bFirstList[i]);
							}
						}

						//比较花色;
						return 2;

					}
				case CT_FIVE_STRAIGHT_FLUSH_FIRST_A://A在前同花顺;
				case CT_FIVE_STRAIGHT_FLUSH_BACK_A: //A在后同花顺;
					{
						//数据验证;
					//ASSERT(bNextList[0] != bFirstList[0]);
						if(bNextList[0]==bFirstList[0]) return false ;

						return 2;  //  10 J Q K 1  怎么比 都是一样大;
					}
				default:

					return false ;
				}

			}
			else
			{
				//同花顺牌;
				//if( bNextType==CT_FIVE_STRAIGHT_FLUSH_FIRST_A || bNextType==CT_FIVE_STRAIGHT_FLUSH)
				//{
				//	if(CT_FIVE_STRAIGHT_FLUSH_FIRST_A==bFirstType || CT_FIVE_STRAIGHT_FLUSH==bFirstType)
				//	{
				//		if(bNextType!=bFirstType)
				//			return bNextType > bFirstType ;
				//	
				//		//比较数值;
				//		for(BYTE i=0; i<5; ++i)
				//			if(GetCardLogicValue(bNextList[i]) != GetCardLogicValue(bFirstList[i]))
				//				return GetCardLogicValue(bNextList[i]) > GetCardLogicValue(bFirstList[i]) ;
				//	
				//		//比较花色;
				//		return GetCardColor(bNextList[0]) > GetCardColor(bFirstList[0]) ;
				//	}
				//}
				return bNextType>bFirstType ;
			}
		}
		else
		{
			if(bNextType==bFirstType)
			{
				switch(bFirstType)
				{
				case CT_THIRTEEN_FLUSH:
					{
						return 2;
					}
				case CT_TWELVE_KING:
					{
						for (int i = 0; i < 13; i++)
						{
							BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
							BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);

							if (cbNextLogicValue != cbFirstLogicValue)
							{
								return cbNextLogicValue > cbFirstLogicValue;
							}
						}
						return 2;
					}
				case CT_THREE_STRAIGHTFLUSH:
					{
						for (int i = 0; i < 13; i++)
						{
							BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
							BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);

							if (cbNextLogicValue != cbFirstLogicValue)
							{
								return cbNextLogicValue > cbFirstLogicValue;
							}
						}

						return 2;
					}
				case CT_THREE_BOMB:
					{
						BYTE cbNextCardValue = bNextList[NextAnalyseData.bFourFirst[0]];
						BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bFourFirst[0]];

					//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
						if(cbNextCardValue==cbFirstCardValue) return false ;

						for (int i = 0; i < 3; i++)
						{
							cbNextCardValue = bNextList[NextAnalyseData.bFourFirst[i]];
							cbFirstCardValue = bFirstList[FirstAnalyseData.bFourFirst[i]];

							BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
							BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
							if (cbNextLogicValue != cbFirstLogicValue)
							{
								return cbNextLogicValue > cbFirstLogicValue;
							}
						}

						cbNextCardValue = bNextList[NextAnalyseData.bOneFirst[0]];
						cbFirstCardValue = bFirstList[FirstAnalyseData.bOneFirst[0]];

						if (GetCardLogicValue(cbNextCardValue) == GetCardLogicValue(cbFirstCardValue))
						{
							return 2;
						}
						else
						{
							return GetCardLogicValue(cbNextCardValue) > GetCardLogicValue(cbFirstCardValue);
						}
					}
				case CT_ALL_BIG:
					{
						for (int i = 0; i < 13; i++)
						{
							BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
							BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);

							if (cbNextLogicValue != cbFirstLogicValue)
							{
								return cbNextLogicValue > cbFirstLogicValue;
							}
						}
						return 2;
					}
				case CT_ALL_SMALL:
					{
						for(int i=0;i<13;i++)
						{
							BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
							BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);

							if (cbNextLogicValue != cbFirstLogicValue)
							{
								return cbNextLogicValue > cbFirstLogicValue;
							}
						}
						return 2;
					}
				case CT_SAME_COLOR:
					{
						for(int i=0;i<13;i++)
						{
							BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
							BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);

							if (cbNextLogicValue != cbFirstLogicValue)
							{
								return cbNextLogicValue > cbFirstLogicValue;
							}
						}

						return 2;
					}
				case CT_FOUR_THREESAME:
					{
						BYTE cbNextCardValue = bNextList[NextAnalyseData.bThreeFirst[0]];
						BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bThreeFirst[0]];

					//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
						if(cbNextCardValue==cbFirstCardValue) return false ;

						for (int i = 0; i < 4; i++)
						{
							cbNextCardValue = bNextList[NextAnalyseData.bThreeFirst[i]];
							cbFirstCardValue = bFirstList[FirstAnalyseData.bThreeFirst[i]];

							BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
							BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
							if (cbNextLogicValue != cbFirstLogicValue)
							{
								return cbNextLogicValue > cbFirstLogicValue;
							}
						}

						cbNextCardValue = bNextList[NextAnalyseData.bOneFirst[0]];
						cbFirstCardValue = bFirstList[FirstAnalyseData.bOneFirst[0]];
						if (GetCardLogicValue(cbNextCardValue) == GetCardLogicValue(cbFirstCardValue))
						{
							return 2;
						}
						else
						{
							return GetCardLogicValue(cbNextCardValue) > GetCardLogicValue(cbFirstCardValue);
						}
					}
				case CT_FIVEPAIR_THREE:
					{
						BYTE cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[0]];
						BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[0]];

					//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
						if (cbNextCardValue == cbFirstCardValue) return false;

						for (int i = 0; i < 5; i++)
						{
							cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[i]];
							cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[i]];

							BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
							BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
							if (cbNextLogicValue != cbFirstLogicValue)
							{
								return cbNextLogicValue > cbFirstLogicValue;
							}
						}

						cbNextCardValue = bNextList[NextAnalyseData.bThreeFirst[0]];
						cbFirstCardValue = bFirstList[FirstAnalyseData.bThreeFirst[0]];
						if (GetCardLogicValue(cbNextCardValue) == GetCardLogicValue(cbFirstCardValue))
						{
							return 2;
						}
						else
						{
							return GetCardLogicValue(cbNextCardValue) > GetCardLogicValue(cbFirstCardValue);
						}
					}

				case CT_SIXPAIR:
					{
						BYTE cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[0]];
						BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[0]];

					//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
						if (cbNextCardValue == cbFirstCardValue) return false;

						for (int i = 0; i < 6; i++)
						{
							cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[i]];
							cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[i]];

							BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
							BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
							if (cbNextLogicValue != cbFirstLogicValue)
							{
								return cbNextLogicValue > cbFirstLogicValue;
							}
						}

						cbNextCardValue = bNextList[NextAnalyseData.bOneFirst[0]];
						cbFirstCardValue = bFirstList[FirstAnalyseData.bOneFirst[0]];
						if (GetCardLogicValue(cbNextCardValue) == GetCardLogicValue(cbFirstCardValue))
						{
							return 2;
						}
						else
						{
							return GetCardLogicValue(cbNextCardValue) > GetCardLogicValue(cbFirstCardValue);
						}
					}
				case CT_THREE_FLUSH:
					{
						for(int i=0;i<13;i++)
						{
							BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
							BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);

							if (cbNextLogicValue != cbFirstLogicValue)
							{
								return cbNextLogicValue > cbFirstLogicValue;
							}
						}

						return 2;
					}
				case CT_THREE_STRAIGHT:
					{
						for(int i=0;i<13;i++)
						{
							BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
							BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);

							if (cbNextLogicValue != cbFirstLogicValue)
							{
								return cbNextLogicValue > cbFirstLogicValue;
							}
						}
						return 2;
					}
				}
			}
			else
			{
				return bNextType>bFirstType;
			}
		}
	}
	else
	{
		//开始对比;
		if(bNextType==bFirstType) 
		{
			switch(bFirstType)
			{
			case CT_SINGLE:				//单牌类型;
				{
					//数据验证;
				//CC_//ASSERT(bNextList[0] != bFirstList[0]);
					if(bNextList[0]==bFirstList[0]) return false ;

					for(BYTE i=0 ; i<3 ; ++i)
					{
						BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
						BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);

						if (cbNextLogicValue != cbFirstLogicValue)
						{
							return cbNextLogicValue > cbFirstLogicValue;
						}
					}

					//比较花色;
					return GetCardColor(bNextList[0]) > GetCardColor(bFirstList[0]);
				}
			case CT_ONE_DOUBLE:			//对带一张;
				{
					//数据验证;
					BYTE cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[0]];
					BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[0]];

					ASSERT(cbNextCardValue!=cbFirstCardValue) ;
					if(cbNextCardValue==cbFirstCardValue) return false ;

					BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
					BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);

					if (cbNextLogicValue == cbFirstLogicValue)
					{
						cbNextCardValue = bNextList[NextAnalyseData.bOneFirst[0]];
						cbFirstCardValue = bFirstList[FirstAnalyseData.bOneFirst[0]];

						cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
						cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);

						if (cbNextLogicValue != cbFirstLogicValue)
						{
							return cbNextLogicValue > cbFirstLogicValue;
						}

						//比较花色;
						return GetCardColor(cbNextCardValue) > GetCardColor(cbFirstCardValue);
					}
					else
					{
						//比较数值;
						return cbNextLogicValue > cbFirstLogicValue;
					}

					return bNextCount < bFirstCount ;
				}
			case CT_FIVE_TWO_DOUBLE:	//两对牌型;
				{
					//数据验证;
					BYTE cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[0]];
					BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[0]];

					ASSERT(cbNextCardValue!=cbFirstCardValue) ;
					if(cbNextCardValue==cbFirstCardValue) return false ;

					BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
					BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);

					if (cbNextLogicValue == cbFirstLogicValue)
					{
						cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[1]];
						cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[1]];

						cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
						cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);

						if (cbNextLogicValue == cbFirstLogicValue)
						{
							//对比单牌;
							cbNextCardValue = bNextList[NextAnalyseData.bOneFirst[0]];
							cbFirstCardValue = bFirstList[FirstAnalyseData.bOneFirst[0]];

							cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
							cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);

							if (cbNextLogicValue != cbFirstLogicValue)
							{
								return cbNextLogicValue > cbFirstLogicValue;
							}

							//比较花色;
							return GetCardColor(cbNextCardValue) > GetCardColor(cbFirstCardValue);
						}
						else
						{
							//比较数值;
							return cbNextLogicValue > cbFirstLogicValue;
						}
					}
					else
					{
						//比较数值;
						return cbNextLogicValue > cbFirstLogicValue;
					}
					//return bNextCount < bFirstCount ;
				}

			case CT_THREE:				//三张牌型;
				{
					//数据验证;
					BYTE cbNextCardValue = bNextList[NextAnalyseData.bThreeFirst[0]];
					BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bThreeFirst[0]];

				//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
					if(cbNextCardValue==cbFirstCardValue) return false ;

					BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
					BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);

					if (cbNextLogicValue == cbFirstLogicValue)
					{
						//比较花色;
						return GetCardColor(cbNextCardValue) > GetCardColor(cbFirstCardValue);
					}
					else
					{
						//比较数值;
						return cbNextLogicValue > cbFirstLogicValue;
					}
				}

			case CT_FIVE_MIXED_FLUSH_FIRST_A:				//A在前顺子;
				{
					//数据验证;
				//CC_//ASSERT(bNextList[0] != bFirstList[0]);
					if(bNextList[0]==bFirstList[0]) return false ;

					BYTE cbNextLogicValue = GetCardLogicValue(bNextList[0]);
					BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[0]);

					//zyy 如果顺子有王 就比第二张;
					if (cbNextLogicValue == CARD_DW||cbNextLogicValue == CARD_XW ||cbFirstLogicValue == CARD_DW||cbFirstLogicValue == CARD_XW)
					{
						cbNextLogicValue = GetCardLogicValue(bNextList[2]);
						cbFirstLogicValue = GetCardLogicValue(bFirstList[2]);

						if (cbNextLogicValue == cbFirstLogicValue)
						{
							//比较花色;
							return GetCardColor(bNextList[2]) > GetCardColor(bFirstList[2]);
						}
						else
						{
							//比较数值;
							return cbNextLogicValue > cbFirstLogicValue;
						}
					}

					if (cbNextLogicValue == cbFirstLogicValue)
					{
						//比较花色 A5432 比较 5的花色; 
						return GetCardColor(bNextList[1]) > GetCardColor(bFirstList[1]);
					}
					else
					{
						//比较数值;
						return cbNextLogicValue > cbFirstLogicValue;
					}
				}
			case CT_FIVE_MIXED_FLUSH_NO_A:			//没A杂顺
				{
					//数据验证;
				//CC_//ASSERT(bNextList[0] != bFirstList[0]);
					if(bNextList[0]==bFirstList[0]) return false ;

					BYTE cbNextLogicValue = GetCardLogicValue(bNextList[0]);
					BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[0]);

					//zyy 如果顺子有王 就比第二张;
					if (cbNextLogicValue == CARD_DW||cbNextLogicValue == CARD_XW||cbFirstLogicValue == CARD_DW||cbFirstLogicValue == CARD_XW)
					{
						cbNextLogicValue = GetCardLogicValue(bNextList[2]);
						cbFirstLogicValue = GetCardLogicValue(bFirstList[2]);

						if (cbNextLogicValue == cbFirstLogicValue)
						{
							//比较花色;
							return GetCardColor(bNextList[2]) > GetCardColor(bFirstList[2]);
						}
						else
						{
							//比较数值;
							return cbNextLogicValue > cbFirstLogicValue;
						}
					}

					if (cbNextLogicValue == cbFirstLogicValue)
					{
						return GetCardColor(bNextList[0]) > GetCardColor(bFirstList[0]);			//比较花色
					}
					else
					{
						return cbNextLogicValue > cbFirstLogicValue; 	//比较数值
					}
				}
			case CT_FIVE_MIXED_FLUSH_BACK_A:		//A在后顺子;
				{
					//数据验证;
				//CC_//ASSERT(bNextList[0] != bFirstList[0]);
					if(bNextList[0]==bFirstList[0]) return false ;

					BYTE cbNextLogicValue = GetCardLogicValue(bNextList[0]);
					BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[0]);

					//zyy 如果顺子有王 就比第二张;
					if (cbNextLogicValue == CARD_DW||cbNextLogicValue == CARD_XW||cbFirstLogicValue == CARD_DW||cbFirstLogicValue == CARD_XW)
					{
						cbNextLogicValue = GetCardLogicValue(bNextList[2]);
						cbFirstLogicValue = GetCardLogicValue(bFirstList[2]);

						if (cbNextLogicValue == cbFirstLogicValue)
						{
							//比较花色;
							return GetCardColor(bNextList[2]) > GetCardColor(bFirstList[2]);
						}
						else
						{
							//比较数值;
							return cbNextLogicValue > cbFirstLogicValue;
						}
					}

					if(cbNextLogicValue==cbFirstLogicValue)
					{
						//比较花色;
						return GetCardColor(bNextList[0]) > GetCardColor(bFirstList[0]);
					}
					else
					{
						//比较数值;
						return cbNextLogicValue > cbFirstLogicValue;
					}
				}

			case CT_FIVE_FLUSH:				//同花五牌;
				{
					//数据验证;
				//CC_//ASSERT(bNextList[0] != bFirstList[0]);
					if(bNextList[0]==bFirstList[0]) return false ;

					BYTE cbNextCardColor = GetCardColor(bNextList[0]);
					BYTE cbFirstCardColor = GetCardColor(bFirstList[0]);

					//先比花色;
					if (cbNextCardColor!=cbFirstCardColor)
					{
						//比较花色;
						return cbNextCardColor > cbFirstCardColor;
					}

					//比较数值;
					for(BYTE i=0; i<5; ++i)
					{
						BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
						BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);

						if (cbNextLogicValue != cbFirstLogicValue)
						{
							return cbNextLogicValue > cbFirstLogicValue;
						}
					}

					//比较花色;
					return cbNextCardColor > cbFirstCardColor;
				}

			case CT_FIVE_THREE_DEOUBLE:			//三条一对;
				{
					BYTE cbNextCardValue = bNextList[NextAnalyseData.bThreeFirst[0]];
					BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bThreeFirst[0]];

					//数据验证;
				//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
					if(cbNextCardValue==cbFirstCardValue) return false ;

					BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
					BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);

					if (cbNextLogicValue == cbFirstLogicValue)
					{
						//比较花色;
						return GetCardColor(cbNextCardValue) > GetCardColor(cbFirstCardValue);
					}
					else
					{
						//比较数值;
						return cbNextLogicValue > cbFirstLogicValue;
					}
				}
			case CT_FIVE_BOMB: //zyy
				{
					//数据验证;
				//CC_//ASSERT(bNextList[0] != bFirstList[0]);
					if(bNextList[0]==bFirstList[0]) return false ;
					
					//比较数值;
					for(BYTE i=0; i<5; ++i)
					{
						BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
						BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);

						if (cbNextLogicValue != cbFirstLogicValue && (cbNextLogicValue != 16 || cbNextLogicValue != 15))
						{
							return cbNextLogicValue > cbFirstLogicValue;
						}
					}

					//比较花色;
					return GetCardColor(bNextList[0]) > GetCardColor(bFirstList[0]);
				}
			case CT_FIVE_FOUR_ONE:			//四带一张;
				{
					//数据验证;
					BYTE cbNextCardValue = bNextList[NextAnalyseData.bFourFirst[0]];
					BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bFourFirst[0]];

				//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
					if (cbNextCardValue == cbFirstCardValue) return false;

					BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
					BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);

					if (cbNextLogicValue == cbFirstLogicValue)
					{
						//比较花色;
						return GetCardColor(cbNextCardValue) > GetCardColor(cbFirstCardValue);
					}
					else
					{
						//比较数值;
						return cbNextLogicValue > cbFirstLogicValue;
					}
				}

			case CT_FIVE_STRAIGHT_FLUSH_NO_A:   //没A同花顺;
			case CT_FIVE_STRAIGHT_FLUSH_FIRST_A://A在前同花顺;
			case CT_FIVE_STRAIGHT_FLUSH_BACK_A: //A在后同花顺;
				{
					//数据验证;
				//CC_//ASSERT(bNextList[0] != bFirstList[0]);
					if(bNextList[0]==bFirstList[0]) return false ;

					BYTE cbNextLogicValue = GetCardLogicValue(bNextList[0]);
					BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[0]);

					//zyy 如果顺子有王 就比第二张;
					if (cbNextLogicValue == CARD_DW||cbNextLogicValue == CARD_XW||cbFirstLogicValue == CARD_DW||cbFirstLogicValue == CARD_XW)
					{
						BYTE cbNextCard1Color = GetCardColor(bNextList[1]);
						BYTE cbFirstCard1Color = GetCardColor(bFirstList[1]);

						//先比花色;
						if (cbNextCard1Color != cbFirstCard1Color)
						{
							//比较花色;
							return cbNextCard1Color > cbFirstCard1Color;
						}

						//比较数值;
						for(BYTE i=2; i<5; ++i)
						{
							cbNextLogicValue = GetCardLogicValue(bNextList[i]);
							cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);

							if (cbNextLogicValue != cbFirstLogicValue)
							{
								return cbNextLogicValue > cbFirstLogicValue;
							}
						}

						//比较花色;
						return cbNextCard1Color > cbFirstCard1Color;
					}

					BYTE cbNextCardColor = GetCardColor(bNextList[0]);
					BYTE cbFirstCardColor = GetCardColor(bFirstList[0]);

					//先比花色;
					if (cbNextCardColor != cbFirstCardColor)
					{
						//比较花色;
						return cbNextCardColor > cbFirstCardColor;
					}

					//比较数值;
					for(BYTE i=0; i<5; ++i)
					{
						cbNextLogicValue = GetCardLogicValue(bNextList[i]);
						cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);

						if (cbNextLogicValue != cbFirstLogicValue)
						{
							return cbNextLogicValue > cbFirstLogicValue;
						}
					}

					//比较花色;
					return cbNextCardColor > cbFirstCardColor;
				}
			default:
				// #ifdef _DEBUG
				// 	AfxMessageBox("错误扑克类型！") ;
				// #endif
				return false ;
			}

		}
		else
		{
			
			//同花顺牌
			//if( bNextType==CT_FIVE_STRAIGHT_FLUSH_FIRST_A || bNextType==CT_FIVE_STRAIGHT_FLUSH)
			//{
			//	if(CT_FIVE_STRAIGHT_FLUSH_FIRST_A==bFirstType || CT_FIVE_STRAIGHT_FLUSH==bFirstType)
			//	{
			//		if(bNextType!=bFirstType)
			//			return bNextType > bFirstType ;
			//
			//		//比较数值
			//		for(BYTE i=0; i<5; ++i)
			//			if(GetCardLogicValue(bNextList[i]) != GetCardLogicValue(bFirstList[i]))
			//				return GetCardLogicValue(bNextList[i]) > GetCardLogicValue(bFirstList[i]) ;
			//
			//		//比较花色
			//		return GetCardColor(bNextList[0]) > GetCardColor(bFirstList[0]) ;
			//
			//	}
			//}
			if (m_bClassicRule)
			{
				return bNextType > bFirstType;
			}
			else
			{
				if ((bFirstType == CT_FIVE_MIXED_FLUSH_NO_A&&bNextType == CT_FIVE_MIXED_FLUSH_FIRST_A) ||
					(bFirstType == CT_FIVE_MIXED_FLUSH_FIRST_A&&bNextType == CT_FIVE_MIXED_FLUSH_NO_A))
				{
					return bNextType < bFirstType;
				}
				else
				{
					return bNextType > bFirstType;
				}
			}
		}
	}


	return false;
}

/*
*	分析扑克的单张，一对。。。的数目，并记录下每种类型扑克的第一张牌（也就是最大的牌）位置以便比较大小，同时判断同一花色是否有五张
*/
//分析扑克
//分析扑克
void CGameLogic::AnalyseCard(const BYTE bCardDataList[] , const BYTE bCardCount , tagAnalyseData& AnalyseData) 
{
	//排列扑克
	BYTE bCardData[13] ;
	CopyMemory(bCardData , bCardDataList , bCardCount) ;
	SortCardList(bCardData , bCardCount , enDescend) ;

	//变量定义
	BYTE bSameCount = 1 ,	bCardValueTemp=0,	bSameColorCount = 1 ,	bFirstCardIndex = 0 ;	//记录下标
	
	ASSERT(3==bCardCount || 5==bCardCount||13==bCardCount) ;

	//设置结果
	memset(&AnalyseData,0,sizeof(AnalyseData));

	if (((GetCardLogicValue(bCardData[0])==CARD_DW || GetCardLogicValue(bCardData[0]) == CARD_XW)) && GetCardLogicValue(bCardData[1])<CARD_XW)
	{
		BYTE bLogicValue=GetCardLogicValue(bCardData[1]);
		BYTE bCardColor = GetCardColor(bCardData[1]) ;
		bFirstCardIndex=1;
		//扑克分析
		for (BYTE i=2;i<bCardCount;i++)
		{
			//获取扑克
			bCardValueTemp=GetCardLogicValue(bCardData[i]);

			if (bCardValueTemp==bLogicValue) bSameCount++;

			//保存结果
			if ((bCardValueTemp!=bLogicValue)||(i==(bCardCount-1)))
			{
				switch (bSameCount)
				{
				case 1:		//一张
					break; 
				case 2:		//两张
					{
						AnalyseData.bTwoFirst[AnalyseData.bTwoCount]	 = bFirstCardIndex ;
						AnalyseData.bTwoCount++ ;
						break;
					}
				case 3:		//三张
					{
						AnalyseData.bThreeFirst[AnalyseData.bThreeCount] = bFirstCardIndex ;
						AnalyseData.bThreeCount++ ;
						break;
					}
				case 4:		//四张
					{
						AnalyseData.bFourFirst[AnalyseData.bFourCount]   = bFirstCardIndex ;
						AnalyseData.bFourCount++ ;
						break;
					}
				}
			}

			//设置变量
			if (bCardValueTemp!=bLogicValue)
			{
				if(bSameCount==1)
				{
					if(i!=bCardCount-1)
					{
						AnalyseData.bOneFirst[AnalyseData.bOneCount]	= bFirstCardIndex ;
						AnalyseData.bOneCount++ ;
					}
					else
					{
						AnalyseData.bOneFirst[AnalyseData.bOneCount]	= bFirstCardIndex ;
						AnalyseData.bOneCount++ ;
						AnalyseData.bOneFirst[AnalyseData.bOneCount]	= i ;
						AnalyseData.bOneCount++ ;				
					}
				}
				else
				{
					if(i==bCardCount-1)
					{
						AnalyseData.bOneFirst[AnalyseData.bOneCount]	= i ;
						AnalyseData.bOneCount++ ;
					}
				}
				bSameCount=1;
				bLogicValue=bCardValueTemp;
				bFirstCardIndex = i ;
			}
			if(GetCardColor(bCardData[i])!=bCardColor ) bSameColorCount = 1 ;
			else									   ++bSameColorCount ;
		}

		//是否同花
		AnalyseData.bStraight = ((bCardCount-1)==bSameColorCount) ? true : false ;

		//开始分析
		switch (bCardCount)
		{
		case 3:	//三条类型
			{
				
				//如果有一个对子的话 剩下一个王正好组成三条
				if(AnalyseData.bTwoCount ==1){ AnalyseData.bTwoCount=0; AnalyseData.bThreeCount =1;AnalyseData.bThreeFirst[0]=AnalyseData.bTwoFirst[0];}
				//如果两张都是单牌的话就组成一个对子
				if(AnalyseData.bOneCount == 2)
				{
					AnalyseData.bOneCount=1; 
					AnalyseData.bTwoCount=1;
					AnalyseData.bTwoFirst[0]=AnalyseData.bOneFirst[0];
					AnalyseData.bOneFirst[0]=AnalyseData.bOneFirst[1];
				}
				return ;
			}
		case 5:	//五张牌型
			{
				//把四带一变成五相
				if (AnalyseData.bFourCount==1)
				{
					AnalyseData.bFourCount = 0;
					AnalyseData.bFiveCount =1;
					AnalyseData.bFiveFirst[0] = AnalyseData.bFourFirst[0];
				}
				//把三带一变成4带1
				if (AnalyseData.bThreeCount==1 && AnalyseData.bOneCount==1)
				{
					AnalyseData.bThreeCount=0;
					AnalyseData.bFourCount=1;
					AnalyseData.bFourFirst[0]=AnalyseData.bThreeFirst[0];
				}//把两队改三条一对
				else if(AnalyseData.bTwoCount==2)
				{
					AnalyseData.bTwoCount=1;
					AnalyseData.bThreeCount=1;
					AnalyseData.bThreeFirst[0]=AnalyseData.bTwoFirst[0];
					AnalyseData.bTwoFirst[0]=AnalyseData.bTwoFirst[1];
				}//一对两单改成三条带单
				else if (AnalyseData.bTwoCount==1 && AnalyseData.bOneCount ==2 )
				{
					AnalyseData.bTwoCount=0;
					AnalyseData.bThreeCount=1;
					AnalyseData.bThreeFirst[0]=AnalyseData.bTwoFirst[0];

				}
				else if (AnalyseData.bOneCount==4 )
				{
					AnalyseData.bOneCount=3;
					AnalyseData.bTwoFirst[0]=AnalyseData.bOneFirst[0];
					AnalyseData.bOneFirst[0]=AnalyseData.bOneFirst[1];
					AnalyseData.bOneFirst[1]=AnalyseData.bOneFirst[2];
					AnalyseData.bOneFirst[2]=AnalyseData.bOneFirst[3];
					AnalyseData.bTwoCount=1;
				}
				return;
			}
		case 13://13张特殊牌型
			{
				//除了一张大小王  还有12张牌
				//12张  改成  13水
				if(AnalyseData.bOneCount==12)
				{
					AnalyseData.bOneFirst[AnalyseData.bOneCount++]=0;
				}
				///////////////////////////////三个炸弹///////////////////////////////
				if(AnalyseData.bFourCount==2 && AnalyseData.bThreeCount==1)
				{
					AnalyseData.bFourFirst[AnalyseData.bFourCount++]=AnalyseData.bThreeFirst[--AnalyseData.bThreeCount];
				}
				///////////////////////////////四套冲三/////////////////////////////////
				if(AnalyseData.bThreeCount==3 && AnalyseData.bTwoCount==1&&AnalyseData.bOneCount==1)
				{
					AnalyseData.bThreeFirst[AnalyseData.bThreeCount++]=AnalyseData.bTwoFirst[--AnalyseData.bTwoCount];
				}
				///////////////////////////////五对冲三/////////////////////////////////
				if (AnalyseData.bTwoCount == 6)
				{
					AnalyseData.bThreeFirst[AnalyseData.bThreeCount++] = AnalyseData.bTwoFirst[--AnalyseData.bTwoCount];
				}

				if (AnalyseData.bTwoCount == 4 && AnalyseData.bThreeCount == 1 )
				{
					AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];
				}
				if (AnalyseData.bTwoCount == 3 && AnalyseData.bThreeCount ==2 )
				{
					AnalyseData.bFourFirst[AnalyseData.bFourCount++]=AnalyseData.bThreeFirst[--AnalyseData.bThreeCount];
				}
				if (AnalyseData.bTwoCount == 2 && AnalyseData.bFourCount ==1 && AnalyseData.bThreeCount ==1)
				{
					AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];
				}
				if( AnalyseData.bTwoCount == 2 && AnalyseData.bFourCount== 2 )
				{
					AnalyseData.bThreeFirst[AnalyseData.bThreeCount++]=AnalyseData.bTwoFirst[--AnalyseData.bTwoCount];
				}
				if(AnalyseData.bFourCount == 2 && AnalyseData.bThreeCount == 1)
				{
					AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];
				}
				///////////////////////////////六对半  /////////////////////////////////
				if (AnalyseData.bTwoCount == 5 && AnalyseData.bOneCount == 2)
				{
					AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];
				}
				
				if (AnalyseData.bTwoCount ==1 && AnalyseData.bFourCount == 2)
				{
					AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];	
				}							
			}  
		}

	}
	else if (GetCardLogicValue(bCardData[0])==CARD_DW && GetCardLogicValue(bCardData[1]) == CARD_XW)
	{
		BYTE bLogicValue=GetCardLogicValue(bCardData[2]);
		BYTE bCardColor = GetCardColor(bCardData[2]) ;
		bFirstCardIndex=2;
		if (bCardCount != 3)
		{
			//扑克分析
			for (BYTE i=3;i<bCardCount;i++)
			{
				//获取扑克
				bCardValueTemp=GetCardLogicValue(bCardData[i]);

				if (bCardValueTemp==bLogicValue) bSameCount++;

				//保存结果
				if ((bCardValueTemp!=bLogicValue)||(i==(bCardCount-1)))
				{
					switch (bSameCount)
					{
					case 1:		//一张
						break; 
					case 2:		//两张
						{
							AnalyseData.bTwoFirst[AnalyseData.bTwoCount]	 = bFirstCardIndex ;
							AnalyseData.bTwoCount++ ;
							break;
						}
					case 3:		//三张
						{
							AnalyseData.bThreeFirst[AnalyseData.bThreeCount] = bFirstCardIndex ;
							AnalyseData.bThreeCount++ ;
							break;
						}
					case 4:		//四张
						{
							AnalyseData.bFourFirst[AnalyseData.bFourCount]   = bFirstCardIndex ;
							AnalyseData.bFourCount++ ;
							break;
						}
					}
				}

				//设置变量
				if (bCardValueTemp!=bLogicValue)
				{
					if(bSameCount==1)
					{
						if(i!=bCardCount-1)
						{
							AnalyseData.bOneFirst[AnalyseData.bOneCount]	= bFirstCardIndex ;
							AnalyseData.bOneCount++ ;
						}
						else
						{
							AnalyseData.bOneFirst[AnalyseData.bOneCount]	= bFirstCardIndex ;
							AnalyseData.bOneCount++ ;
							AnalyseData.bOneFirst[AnalyseData.bOneCount]	= i ;
							AnalyseData.bOneCount++ ;				
						}
					}
					else
					{
						if(i==bCardCount-1)
						{
							AnalyseData.bOneFirst[AnalyseData.bOneCount]	= i ;
							AnalyseData.bOneCount++ ;
						}
					}
					bSameCount=1;
					bLogicValue=bCardValueTemp;
					bFirstCardIndex = i ;
				}
				if(GetCardColor(bCardData[i])!=bCardColor ) bSameColorCount = 1 ;
				else									   ++bSameColorCount ;
			}
		}
		else
		{
			//zyy
			AnalyseData.bThreeFirst[AnalyseData.bThreeCount] = bFirstCardIndex ;
			AnalyseData.bThreeCount++ ;

			AnalyseData.bOneFirst[AnalyseData.bOneCount]	= bFirstCardIndex ;
			AnalyseData.bOneCount++ ;

		}
		

		//是否同花
		AnalyseData.bStraight = ((bCardCount-2)==bSameColorCount) ? true : false ;

		//开始分析
		switch (bCardCount)
		{
		case 3:	//三条类型
			{
				//一共就三张牌	大小王两张 就剩下一张了 组成个三条吧
				if(AnalyseData.bOneCount ==1)
				{ 
					AnalyseData.bOneCount=0; 
					AnalyseData.bThreeCount =1;
					AnalyseData.bThreeFirst[0]=AnalyseData.bOneFirst[0];
				}
				return ;
			}
		case 5:	//五张牌型
			{
				/////////////////一共就5张牌 大小王两张  剩下三张了/////////////////////////////
				//这三张是三条的话 就只能组成 五相
				if(AnalyseData.bThreeCount==1)
				{
					AnalyseData.bThreeCount=0;
					AnalyseData.bFiveCount=1;
					AnalyseData.bFiveFirst[0]=AnalyseData.bThreeFirst[0];
				}
				else if(AnalyseData.bTwoCount==1 && AnalyseData.bOneCount==1)
				{
					AnalyseData.bTwoCount=0;
					AnalyseData.bFourCount=1;
					AnalyseData.bFourFirst[0]=AnalyseData.bTwoFirst[0];
				}//这三张是单牌 就组成三带二 
				else if (AnalyseData.bOneCount==3)
				{
					AnalyseData.bOneCount=2;
					AnalyseData.bThreeCount=1;
					AnalyseData.bThreeFirst[0]=AnalyseData.bOneFirst[0];
					AnalyseData.bOneFirst[0]=AnalyseData.bOneFirst[1];
					AnalyseData.bOneFirst[1]=AnalyseData.bOneFirst[2];
					AnalyseData.bOneFirst[2]=AnalyseData.bOneFirst[3];
				}
				return;
			}
		case 13://13张特殊牌型
			{
				//11张改成13水
				if (AnalyseData.bOneCount==11)
				{
					AnalyseData.bOneFirst[AnalyseData.bOneCount++]=0;
					AnalyseData.bOneFirst[AnalyseData.bOneCount++]=1;
				}
				///////////////////////////////三个炸弹///////////////////////////////

				if (AnalyseData.bFourCount==2&& AnalyseData.bThreeCount==1) //2个4张+1个3张
				{
					AnalyseData.bFourFirst[AnalyseData.bFourCount++]=AnalyseData.bThreeFirst[--AnalyseData.bThreeCount];
				}

				if (AnalyseData.bFourCount==2&& AnalyseData.bTwoCount==1)//2个4张+1个2张+1个1张
				{
					AnalyseData.bFourFirst[AnalyseData.bFourCount++]=AnalyseData.bTwoFirst[--AnalyseData.bTwoCount];
				}

				if (AnalyseData.bFourCount==1&& AnalyseData.bThreeCount==2)//1个4张+2个3张
				{
					AnalyseData.bFourFirst[AnalyseData.bFourCount++]=AnalyseData.bThreeFirst[--AnalyseData.bThreeCount];
					AnalyseData.bFourFirst[AnalyseData.bFourCount++]=AnalyseData.bThreeFirst[--AnalyseData.bThreeCount];
				}

				///////////////////////////////四套冲三///////////////////////////////// 4个3张
				if(AnalyseData.bThreeCount==3 && AnalyseData.bTwoCount==1)//3个3张+1个2张
				{
					AnalyseData.bThreeFirst[AnalyseData.bThreeCount++]=AnalyseData.bTwoFirst[--AnalyseData.bTwoCount];
				}

				if(AnalyseData.bThreeCount==3 && AnalyseData.bOneCount==2)//3个3张+2个1张
				{
					AnalyseData.bThreeFirst[AnalyseData.bThreeCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];
				}

				if(AnalyseData.bThreeCount==2 && AnalyseData.bTwoCount==2)//2个3张+2个2张
				{
					AnalyseData.bThreeFirst[AnalyseData.bThreeCount++]=AnalyseData.bTwoFirst[--AnalyseData.bTwoCount];
					AnalyseData.bThreeFirst[AnalyseData.bThreeCount++]=AnalyseData.bTwoFirst[--AnalyseData.bTwoCount];
				}

				///////////////////////////////五对冲三/////////////////////////////////
				if (AnalyseData.bTwoCount == 5 && AnalyseData.bOneCount ==1)
				{
					AnalyseData.bThreeFirst[AnalyseData.bThreeCount++] = AnalyseData.bOneFirst[--AnalyseData.bOneCount];
				}

				if (AnalyseData.bTwoCount== 4 && AnalyseData.bThreeCount==1)
				{
					AnalyseData.bTwoFirst[AnalyseData.bTwoCount++] = 0;
				}

				if (AnalyseData.bTwoCount == 3 && AnalyseData.bThreeCount ==1)
				{
					AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];
					AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];
				}

				if (AnalyseData.bTwoCount == 2 && AnalyseData.bThreeCount ==2)
				{
					AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];
					AnalyseData.bFourFirst[AnalyseData.bFourCount++]=AnalyseData.bThreeFirst[--AnalyseData.bThreeCount];
				}
				
				if(AnalyseData.bTwoCount ==2 && AnalyseData.bFourCount ==1 && AnalyseData.bThreeCount==1)
				{
					AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=0;
				}

				if ((AnalyseData.bTwoCount== 3 && AnalyseData.bFourCount==1)
					||(AnalyseData.bTwoCount ==1 && AnalyseData.bFourCount ==2))
				{
					AnalyseData.bThreeFirst[AnalyseData.bThreeCount++] = AnalyseData.bOneFirst[--AnalyseData.bOneCount];
				}	

				///////////////////////////////六对半  /////////////////////////////////
				if ((AnalyseData.bTwoCount == 4 && AnalyseData.bOneCount == 3)
				   ||(AnalyseData.bFourCount == 2 && AnalyseData.bOneCount == 3))
				{
					AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];
					AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];
				}
			}  
		}
	}
	else
	{
		BYTE bLogicValue=GetCardLogicValue(bCardData[0]);
		BYTE bCardColor = GetCardColor(bCardData[0]) ;
		//扑克分析
		for (BYTE i=1;i<bCardCount;i++)
		{
			//获取扑克
			bCardValueTemp=GetCardLogicValue(bCardData[i]);

			if (bCardValueTemp==bLogicValue ) bSameCount++;

			//保存结果
			if ((bCardValueTemp!=bLogicValue)||(i==(bCardCount-1)))
			{
				switch (bSameCount)
				{
				case 1:		//一张
					break; 
				case 2:		//两张
					{
						AnalyseData.bTwoFirst[AnalyseData.bTwoCount]	 = bFirstCardIndex ;
						AnalyseData.bTwoCount++ ;
						break;
					}
				case 3:		//三张
					{
						AnalyseData.bThreeFirst[AnalyseData.bThreeCount] = bFirstCardIndex ;
						AnalyseData.bThreeCount++ ;
						break;
					}
				case 4:		//四张
					{
						AnalyseData.bFourFirst[AnalyseData.bFourCount]   = bFirstCardIndex ;
						AnalyseData.bFourCount++ ;
						break;
					}
				}
			}

			//设置变量
			if (bCardValueTemp!=bLogicValue)
			{
				if(bSameCount==1)
				{
					if(i!=bCardCount-1)
					{
						AnalyseData.bOneFirst[AnalyseData.bOneCount]	= bFirstCardIndex ;
						AnalyseData.bOneCount++ ;
					}
					else
					{
						AnalyseData.bOneFirst[AnalyseData.bOneCount]	= bFirstCardIndex ;
						AnalyseData.bOneCount++ ;
						AnalyseData.bOneFirst[AnalyseData.bOneCount]	= i ;
						AnalyseData.bOneCount++ ;				
					}
				}
				else
				{
					if(i==bCardCount-1)
					{
						AnalyseData.bOneFirst[AnalyseData.bOneCount]	= i ;
						AnalyseData.bOneCount++ ;
					}
				}
				bSameCount=1;
				bLogicValue=bCardValueTemp;
				bFirstCardIndex = i ;
			}
			if(GetCardColor(bCardData[i])!= bCardColor ) bSameColorCount = 1 ;
			else									   ++bSameColorCount ;
		}

		//是否同花
		AnalyseData.bStraight = (bCardCount==bSameColorCount) ? true : false ;

	}

	
	return;
}

//分析扑克
void CGameLogic::AnalysebCardData(const BYTE cbCardData[], BYTE cbCardCount, tagAnalyseResult & AnalyseResult)
{
	//设置结果
	ZeroMemory(&AnalyseResult,sizeof(AnalyseResult));

	//扑克分析
	for (BYTE i=0;i<cbCardCount;i++)
	{
		//变量定义
		BYTE cbSameCount=1,cbCardValueTemp=0;
		BYTE cbLogicValue=GetCardLogicValue(cbCardData[i]);

		//搜索同牌
		for (BYTE j=i+1;j<cbCardCount;j++)
		{
			//获取扑克
			if (GetCardLogicValue(cbCardData[j])!=cbLogicValue) break;

			//设置变量
			cbSameCount++;
		}

		//设置结果
		switch (cbSameCount)
		{
		case 1:		//单张
			{
				BYTE cbIndex=AnalyseResult.cbSignedCount++;
				AnalyseResult.cbSignedCardData[cbIndex*cbSameCount]=cbCardData[i];
				break;
			}
		case 2:		//两张
			{
				BYTE cbIndex=AnalyseResult.cbDoubleCount++;
				AnalyseResult.cbDoubleCardData[cbIndex*cbSameCount]=cbCardData[i];
				AnalyseResult.cbDoubleCardData[cbIndex*cbSameCount+1]=cbCardData[i+1];
				break;
			}
		case 3:		//三张
			{
				BYTE cbIndex=AnalyseResult.cbThreeCount++;
				AnalyseResult.cbThreeCardData[cbIndex*cbSameCount]=cbCardData[i];
				AnalyseResult.cbThreeCardData[cbIndex*cbSameCount+1]=cbCardData[i+1];
				AnalyseResult.cbThreeCardData[cbIndex*cbSameCount+2]=cbCardData[i+2];
				break;
			}
		case 4:		//四张
			{
				BYTE cbIndex=AnalyseResult.cbFourCount++;
				AnalyseResult.cbFourCardData[cbIndex*cbSameCount]=cbCardData[i];
				AnalyseResult.cbFourCardData[cbIndex*cbSameCount+1]=cbCardData[i+1];
				AnalyseResult.cbFourCardData[cbIndex*cbSameCount+2]=cbCardData[i+2];
				AnalyseResult.cbFourCardData[cbIndex*cbSameCount+3]=cbCardData[i+3];
				break;
			}
		}

		//设置索引
		i+=cbSameCount-1;
	}

	return;
}

tagAnalyseType CGameLogic::GetType( BYTE bCardData[], BYTE bCardCount )
{
	tagAnalyseType Type;
	ZeroMemory(&Type,sizeof(Type));
	if(bCardCount==0)
	{
		ZeroMemory(&Type,sizeof(Type));
		return Type;
	}
	//排列扑克;
	BYTE CardData[13] ;
	CopyMemory(CardData , bCardData , bCardCount) ;
	SortCardList(CardData , bCardCount , enDescend) ;

	BYTE Index[13]={0};
	BYTE Number=0;
	BYTE SameValueCount=1;

	BYTE Num[9]={0};
	if (GetCardLogicValue(CardData[0]) >=CARD_XW && GetCardLogicValue(CardData[1]) <CARD_XW)
	{
		//判断数值相同的牌
		BYTE bLogicValue=GetCardLogicValue(CardData[1]);
		Index[Number++]=1;
		for(BYTE i=2;i<bCardCount;i++)
		{
			if(bLogicValue==GetCardLogicValue(CardData[i]))
			{
				SameValueCount++;
				Index[Number++]=i;
			}
			if( bLogicValue!=GetCardLogicValue(CardData[i])||i==bCardCount-1)
			{
				if(SameValueCount==1)
				{
					Type.bOnePare=true;
					Type.cbOnePare[Num[0]++]=Index[SameValueCount-1];
					Type.cbOnePare[Num[0]++]=0;
					Type.btOnePare++;
				}
				else if(SameValueCount==2)
				{
					Type.bOnePare=true;
					Type.cbOnePare[Num[0]++]=Index[SameValueCount-2];
					Type.cbOnePare[Num[0]++]=Index[SameValueCount-1];
					Type.btOnePare++;
					Type.bThreeSame=true;
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-2];
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-1];
					Type.cbThreeSame[Num[2]++]=0;
					Type.btThreeSame++;
					//printf("%d,%d  ",Index[0],Index[1]);
				}
				else if(SameValueCount==3)
				{
					Type.bOnePare=true;
					Type.cbOnePare[Num[0]++]=Index[SameValueCount-3];
					Type.cbOnePare[Num[0]++]=Index[SameValueCount-2];
					//printf("%d,%d  ",Index[0],Index[1]);
					Type.bThreeSame=true;
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-3];
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-2];
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-1];
					Type.btThreeSame++;
					Type.bFourSame=true;
					Type.cbFourSame[Num[6]++]=Index[SameValueCount-3];
					Type.cbFourSame[Num[6]++]=Index[SameValueCount-2];
					Type.cbFourSame[Num[6]++]=Index[SameValueCount-1];
					Type.cbFourSame[Num[6]++]=0;
					Type.btFourSame++;
				}
				else if(SameValueCount==4)
				{
					Type.bOnePare=true;
					Type.cbOnePare[Num[0]++]=Index[SameValueCount-4];
					Type.cbOnePare[Num[0]++]=Index[SameValueCount-3];
					//printf("%d,%d  ",Index[0],Index[1]);
					Type.bThreeSame=true;
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-4];
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-3];
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-2];
					Type.bFourSame=true;
					Type.cbFourSame[Num[6]++]=Index[SameValueCount-4];
					Type.cbFourSame[Num[6]++]=Index[SameValueCount-3];
					Type.cbFourSame[Num[6]++]=Index[SameValueCount-2];
					Type.cbFourSame[Num[6]++]=Index[SameValueCount-1];
					Type.btFourSame++;

					Type.bFiveSame = true;
					Type.cbFiveSame[Num[8]++] = Index[SameValueCount-4];
					Type.cbFiveSame[Num[8]++] =	Index[SameValueCount-3];
					Type.cbFiveSame[Num[8]++] =	Index[SameValueCount-2];
					Type.cbFiveSame[Num[8]++] =	Index[SameValueCount-1];
					Type.cbFiveSame[Num[8]++] = 0;
					Type.btFiveSame++;
					

				}
				Number=0; 
				ZeroMemory(Index,sizeof(Index));
				Index[Number++]=i;
				SameValueCount=1;
				bLogicValue=GetCardLogicValue(CardData[i]);
			}

		}
	}
	else if (GetCardLogicValue(CardData[0]) ==CARD_DW && GetCardLogicValue(CardData[1]) ==CARD_XW)
	{
		//判断数值相同的牌
		BYTE bLogicValue=GetCardLogicValue(CardData[2]);
		Index[Number++]=2;
		for(BYTE i=3;i<bCardCount;i++)
		{
			if(bLogicValue==GetCardLogicValue(CardData[i]))
			{
				SameValueCount++;
				Index[Number++]=i;
			}
			if( bLogicValue!=GetCardLogicValue(CardData[i])||i==bCardCount-1)
			{
				if(SameValueCount==1)
				{
					Type.bOnePare=true;
					Type.cbOnePare[Num[0]++]=Index[SameValueCount-1];
					Type.cbOnePare[Num[0]++]=0;
					Type.btOnePare++;
					/*Type.bThreeSame=true;
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-1];
					Type.cbThreeSame[Num[2]++]=0;
					Type.cbThreeSame[Num[2]++]=1;
					Type.btThreeSame++;*/
				}
				else if(SameValueCount==2)
				{
					Type.bOnePare=true;
					Type.cbOnePare[Num[0]++]=Index[SameValueCount-2];
					Type.cbOnePare[Num[0]++]=Index[SameValueCount-1];
					Type.btOnePare++;
					//printf("%d,%d  ",Index[0],Index[1]);
					Type.bThreeSame=true;
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-2];
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-1];
					Type.cbThreeSame[Num[2]++]=0;
					Type.btThreeSame++;
					Type.bFourSame=true;
					Type.cbFourSame[Num[6]++]=Index[SameValueCount-2];
					Type.cbFourSame[Num[6]++]=Index[SameValueCount-1];
					Type.cbFourSame[Num[6]++]=0;
					Type.cbFourSame[Num[6]++]=1;
					Type.btFourSame++;
				}
				else if(SameValueCount==3)
				{
					Type.bOnePare=true;
					Type.cbOnePare[Num[0]++]=Index[SameValueCount-3];
					Type.cbOnePare[Num[0]++]=Index[SameValueCount-2];
					//printf("%d,%d  ",Index[0],Index[1]);
					Type.bThreeSame=true;
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-3];
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-2];
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-1];
					Type.btThreeSame++;
					Type.bFourSame=true;
					Type.cbFourSame[Num[6]++]=Index[SameValueCount-3];
					Type.cbFourSame[Num[6]++]=Index[SameValueCount-2];
					Type.cbFourSame[Num[6]++]=Index[SameValueCount-1];
					Type.cbFourSame[Num[6]++]=0;
					Type.btFourSame++;

					Type.bFiveSame = true;
					Type.cbFiveSame[Num[8]++] =	Index[SameValueCount-3];
					Type.cbFiveSame[Num[8]++] =	Index[SameValueCount-2];
					Type.cbFiveSame[Num[8]++] =	Index[SameValueCount-1];
					Type.cbFiveSame[Num[8]++] = 0;
					Type.cbFiveSame[Num[8]++] = 1;
					Type.btFiveSame++;
				}
				else if(SameValueCount==4)
				{
					Type.bOnePare=true;
					Type.cbOnePare[Num[0]++]=Index[SameValueCount-4];
					Type.cbOnePare[Num[0]++]=Index[SameValueCount-3];
					//printf("%d,%d  ",Index[0],Index[1]);
					Type.bThreeSame=true;
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-4];
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-3];
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-2];
					Type.bFourSame=true;
					Type.cbFourSame[Num[6]++]=Index[SameValueCount-4];
					Type.cbFourSame[Num[6]++]=Index[SameValueCount-3];
					Type.cbFourSame[Num[6]++]=Index[SameValueCount-2];
					Type.cbFourSame[Num[6]++]=Index[SameValueCount-1];
					Type.btFourSame++;

					Type.bFiveSame = true;
					Type.cbFiveSame[Num[8]++] = Index[SameValueCount-4];
					Type.cbFiveSame[Num[8]++] =	Index[SameValueCount-3];
					Type.cbFiveSame[Num[8]++] =	Index[SameValueCount-2];
					Type.cbFiveSame[Num[8]++] =	Index[SameValueCount-1];
					Type.cbFiveSame[Num[8]++] = 0;
					Type.btFiveSame++;


				}
				Number=0; 
				ZeroMemory(Index,sizeof(Index));
				Index[Number++]=i;
				SameValueCount=1;
				bLogicValue=GetCardLogicValue(CardData[i]);
			}

		}
	}
	else
	{
		//判断数值相同的牌
		BYTE bLogicValue=GetCardLogicValue(CardData[0]);
		Index[Number++]=0;
		for(BYTE i=1;i<bCardCount;i++)
		{
			if(bLogicValue==GetCardLogicValue(CardData[i]))
			{
				SameValueCount++;
				Index[Number++]=i;
			}
			if(bLogicValue!=GetCardLogicValue(CardData[i])||i==bCardCount-1)
			{
				if(SameValueCount==1)
				{

				}
				else if(SameValueCount==2)
				{
					Type.bOnePare=true;
					Type.cbOnePare[Num[0]++]=Index[SameValueCount-2];
					Type.cbOnePare[Num[0]++]=Index[SameValueCount-1];
					Type.btOnePare++;
					//printf("%d,%d  ",Index[0],Index[1]);
				}
				else if(SameValueCount==3)
				{
					Type.bOnePare=true;
					Type.cbOnePare[Num[0]++]=Index[SameValueCount-3];
					Type.cbOnePare[Num[0]++]=Index[SameValueCount-2];
					//printf("%d,%d  ",Index[0],Index[1]);
					Type.bThreeSame=true;
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-3];
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-2];
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-1];
					Type.btThreeSame++;
				}
				else if(SameValueCount==4)
				{
					Type.bOnePare=true;
					Type.cbOnePare[Num[0]++]=Index[SameValueCount-4];
					Type.cbOnePare[Num[0]++]=Index[SameValueCount-3];
					//printf("%d,%d  ",Index[0],Index[1]);
					Type.bThreeSame=true;
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-4];
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-3];
					Type.cbThreeSame[Num[2]++]=Index[SameValueCount-2];
					Type.bFourSame=true;
					Type.cbFourSame[Num[6]++]=Index[SameValueCount-4];
					Type.cbFourSame[Num[6]++]=Index[SameValueCount-3];
					Type.cbFourSame[Num[6]++]=Index[SameValueCount-2];
					Type.cbFourSame[Num[6]++]=Index[SameValueCount-1];
					Type.btFourSame++;
				}
				Number=0; 
				ZeroMemory(Index,sizeof(Index));
				Index[Number++]=i;
				SameValueCount=1;
				bLogicValue=GetCardLogicValue(CardData[i]);
			}

		}
	}


	


	//判断两对   
	BYTE OnePareCount=Num[0]/2;
	BYTE ThreeSameCount=Num[2]/3;
	if(OnePareCount>=2)
	{
		Type.bTwoPare=false;
		for(BYTE i=0;i<OnePareCount;i++)
		{
			for(BYTE j=i+1;j<OnePareCount;j++)
			{
				if (CardData[Type.cbOnePare[i*2]] == CardData[Type.cbOnePare[i*2+1]] || CardData[Type.cbOnePare[i*2]] == CardData[Type.cbOnePare[j*2]]
				 || CardData[Type.cbOnePare[i*2+1]] == CardData[Type.cbOnePare[j*2]] || CardData[Type.cbOnePare[i*2+1]] == CardData[Type.cbOnePare[j*2+1]] 
				 || CardData[Type.cbOnePare[j*2+1]] == CardData[Type.cbOnePare[i*2]] || CardData[Type.cbOnePare[j*2+1]] == CardData[Type.cbOnePare[j*2]])	continue;
				Type.cbTwoPare[Num[1]++]=Type.cbOnePare[i*2];
				Type.cbTwoPare[Num[1]++]=Type.cbOnePare[i*2+1];
				Type.cbTwoPare[Num[1]++]=Type.cbOnePare[j*2];
				Type.cbTwoPare[Num[1]++]=Type.cbOnePare[j*2+1];
				Type.btTwoPare++;
				Type.bTwoPare=true;
			}
		}
	}


	//判断葫芦
	if(OnePareCount>0&&ThreeSameCount>0)
	{
		for(BYTE i=0;i<ThreeSameCount;i++)
		{
			for(BYTE j=0;j<OnePareCount;j++)
			{
				if(bCardData [Type.cbThreeSame[i*3]] == bCardData [Type.cbThreeSame[i*3+1]] 
				|| bCardData [Type.cbThreeSame[i*3]] == bCardData[Type.cbThreeSame[i*3+2]] 
				|| bCardData [Type.cbThreeSame[i*3]] == bCardData [Type.cbOnePare[j*2]] 
				|| bCardData [Type.cbThreeSame[i*3]] == bCardData [Type.cbOnePare[j*2+1]] 
				|| bCardData [Type.cbThreeSame[i*3+1]] == bCardData[Type.cbThreeSame[i*3+2]] 
				|| bCardData [Type.cbThreeSame[i*3+1]] == bCardData [Type.cbOnePare[j*2]] 
				|| bCardData [Type.cbThreeSame[i*3+1]] == bCardData [Type.cbOnePare[j*2+1]] 
				|| bCardData [Type.cbThreeSame[i*3+2]] == bCardData [Type.cbOnePare[j*2]] 
				|| bCardData [Type.cbThreeSame[i*3+2]] == bCardData [Type.cbOnePare[j*2+1]] 
				|| bCardData [Type.cbOnePare[j*2]] == bCardData[Type.cbThreeSame[i*3+2]])
				{
					continue;
				}

				/*if (bCardData [Type.cbThreeSame[i*3]] != bCardData [Type.cbOnePare[j*2]] 
				&& bCardData [Type.cbThreeSame[i*3]] != bCardData [Type.cbOnePare[j*2+1]]
				&& bCardData [Type.cbThreeSame[i*3+1]] != bCardData [Type.cbOnePare[j*2]] 
				&& bCardData [Type.cbThreeSame[i*3+1]] != bCardData [Type.cbOnePare[j*2+1]]
				&& bCardData [Type.cbThreeSame[i*3+2]] != bCardData [Type.cbOnePare[j*2]] 
				&& bCardData [Type.cbThreeSame[i*3+2]] != bCardData [Type.cbOnePare[j*2+1]])*/
				{
					Type.bGourd=true;
					Type.cbGourd[Num[5]++]=Type.cbThreeSame[i*3];
					Type.cbGourd[Num[5]++]=Type.cbThreeSame[i*3+1];
					Type.cbGourd[Num[5]++]=Type.cbThreeSame[i*3+2];
					Type.cbGourd[Num[5]++]=Type.cbOnePare[j*2];
					Type.cbGourd[Num[5]++]=Type.cbOnePare[j*2+1];
					Type.btGourd++;
				}
			}
		}
	}

	
	//判断顺子及同花顺
	Number=0;
	ZeroMemory(Index,sizeof(Index));
	BYTE Straight=1;
	BYTE bStraight=GetCardLogicValue(CardData[0]);
	if (GetCardLogicValue(CardData[0]) >=CARD_XW && GetCardLogicValue(CardData[1]) <CARD_XW)
	{
		bStraight=GetCardLogicValue(CardData[1]);
		Index[Number++]=1;
		bool bUsedW = false;
		for(BYTE i=2;i<bCardCount;i++)
		{
			if(bStraight==GetCardLogicValue(CardData[i])+1)
			{
				Straight++;
				Index[Number++]=i;
				bStraight=GetCardLogicValue(CardData[i]);
			}
			else if ((bStraight==GetCardLogicValue(CardData[i])+2)&&(bUsedW == false))
			{
				bUsedW = true;
				Straight++;
				Index[Number++]=0;
				Straight++;
				Index[Number++]=i;
				bStraight=GetCardLogicValue(CardData[i]);
			}
			if(bStraight>GetCardLogicValue(CardData[i])+1||i==bCardCount-1)
			{
				if (Straight == 4 && bUsedW == false)
				{
					Straight++;
					Index[Number++]=0;
				}
				if(Straight>=5)
				{
					Type.bStraight=true;
					for(BYTE j=0;j<Straight;j++)
					{
						if(Straight-j>=5)
						{
							if (bCardData[Index[j]] == bCardData[Index[j+1]]	||  bCardData[Index[j]] == bCardData[Index[j+2]]
							||  bCardData[Index[j]] == bCardData[Index[j+3]]	||  bCardData[Index[j]] == bCardData[Index[j+4]]
							||  bCardData[Index[j+1]] == bCardData[Index[j+2]]	||  bCardData[Index[j+1]] == bCardData[Index[j+3]]
							||  bCardData[Index[j+1]] == bCardData[Index[j+4]]	||  bCardData[Index[j+2]] == bCardData[Index[j+3]]
							||  bCardData[Index[j+2]] == bCardData[Index[j+4]]	||  bCardData[Index[j+3]] == bCardData[Index[j+4]]
							)
							{
								continue;
							}
							Type.cbStraight[Num[3]++]=Index[j];
							Type.cbStraight[Num[3]++]=Index[j+1];
							Type.cbStraight[Num[3]++]=Index[j+2];
							Type.cbStraight[Num[3]++]=Index[j+3];
							Type.cbStraight[Num[3]++]=Index[j+4];
							Type.btStraight++;

							//从手牌中找到和顺子5张中其中一张数值相同的牌，组成另一种顺子
							for(int k=j;k<j+5;k++)
							{
								for(int m=0;m<bCardCount;m++)
								{
									if(GetCardLogicValue(CardData[Index[k]])==GetCardLogicValue(CardData[m])&&GetCardColor(CardData[Index[k]])!=GetCardColor(CardData[m]))
									{
										for(int n=j;n<j+5;n++)
										{
											if(n==k)
											{
												Type.cbStraight[Num[3]++]=m;
											}
											else
											{
												Type.cbStraight[Num[3]++]=Index[n];
											}
										}
										Type.btStraight++;

									}
								}
							}
						}
						else
						{
							break;
						}
					}

				}
				if(bCardCount-i<5)
				{
					break;
				}
				bStraight=GetCardLogicValue(CardData[i]);
				Straight=1;
				Number=0;
				ZeroMemory(Index,sizeof(Index));
				Index[Number++]=i;
				bUsedW = false;
			}
		}


		//存在2 检测A2345顺子
		if(GetCardLogicValue(CardData[bCardCount-1])==2)  
		{
			Number=0;
			Straight=2;
			bStraight=GetCardLogicValue(CardData[1]);
			ZeroMemory(Index,sizeof(Index));
			bool bFind = false;
			
			if (bStraight==14)
			{
				Index[Number++]=1;
				bStraight=GetCardLogicValue(CardData[bCardCount-1]);
				Index[Number++]=bCardCount-1;

				bUsedW = false;
				for(int i=bCardCount-2;i>=0;i--)
				{
					if(bStraight==GetCardLogicValue(CardData[i])-1)
					{
						Straight++;
						Index[Number++]=i;
						bStraight=GetCardLogicValue(CardData[i]);
						continue;
					}

					if((bStraight==GetCardLogicValue(CardData[i])-2)
					&&(false == bUsedW))//保证鬼只使用一次
					{
						Straight++;
						Index[Number++]=0;
						Straight++;
						Index[Number++]=i;
						bStraight=GetCardLogicValue(CardData[i]);
						bUsedW = true;
					}
				}

				if (Straight == 4 && bUsedW == false)
				{
					Straight++;
					Index[Number++]=0;
				}
			}
			else
			{
				Index[Number++]=0;
				bStraight=GetCardLogicValue(CardData[bCardCount-1]);
				Index[Number++]=bCardCount-1;
				for(int i=bCardCount-2;i>=0;i--)
				{
					if(bStraight==GetCardLogicValue(CardData[i])-1)
					{
						Straight++;
						Index[Number++]=i;
						bStraight=GetCardLogicValue(CardData[i]);
					}
				}
			}
			
			if(Straight>=5)
			{
				Type.bStraight=true;
				for(BYTE j=0;j<5;j++)
				{
					Type.cbStraight[Num[3]++]=Index[j];	
				}
				Type.btStraight++;

				//从手牌中找到和顺子5张中其中一张数值相同的牌，组成另一种顺子
				for(int k=0;k<5;k++)
				{
					for(int m=0;m<bCardCount;m++)
					{
						if(GetCardLogicValue(CardData[Index[k]])==GetCardLogicValue(CardData[m])&&GetCardColor(CardData[Index[k]])!=GetCardColor(CardData[m]))
						{
							for(int n=0;n<5;n++)
							{
								if(n==k)
								{
									Type.cbStraight[Num[3]++]=m;
								}
								else
								{
									Type.cbStraight[Num[3]++]=Index[n];
								}
							}
							Type.btStraight++;
						}
					}
				}

			}
		}  

		//存在3并且存在A 检测A2345顺子
		if((GetCardLogicValue(CardData[bCardCount-1])==3)
			&&(GetCardLogicValue(CardData[1])==14))
		{
			Number=0;
			Straight=3;
			ZeroMemory(Index,sizeof(Index));
			
			Index[Number++]=0;
			Index[Number++]=1;
			bStraight=GetCardLogicValue(CardData[bCardCount-1]);
			Index[Number++]=bCardCount-1;

			for(int i=bCardCount-2;i>=0;i--)
			{
				if(bStraight==GetCardLogicValue(CardData[i])-1)
				{
					Straight++;
					Index[Number++]=i;
					bStraight=GetCardLogicValue(CardData[i]);
				}
			}
			
			
			if(Straight>=5)
			{
				Type.bStraight=true;
				for(BYTE j=0;j<5;j++)
				{
					Type.cbStraight[Num[3]++]=Index[j];	
				}
				Type.btStraight++;

				//从手牌中找到和顺子5张中其中一张数值相同的牌，组成另一种顺子
				for(int k=0;k<5;k++)
				{
					for(int m=0;m<bCardCount;m++)
					{
						if(GetCardLogicValue(CardData[Index[k]])==GetCardLogicValue(CardData[m])&&GetCardColor(CardData[Index[k]])!=GetCardColor(CardData[m]))
						{
							for(int n=0;n<5;n++)
							{
								if(n==k)
								{
									Type.cbStraight[Num[3]++]=m;
								}
								else
								{
									Type.cbStraight[Num[3]++]=Index[n];
								}
							}
							Type.btStraight++;
						}
					}
				}

			}
		} 
	}
	else if (GetCardLogicValue(CardData[0]) ==CARD_DW && GetCardLogicValue(CardData[1]) ==CARD_XW)
	{
		bStraight=GetCardLogicValue(CardData[2]);
		Index[Number++]=2;

		bool bUsedDW = false;
		bool bUsedXW = false;
		for(BYTE i=3;i<bCardCount;i++)
		{
			if(bStraight==GetCardLogicValue(CardData[i])+1)
			{
				Straight++;
				Index[Number++]=i;
				bStraight=GetCardLogicValue(CardData[i]);
			}
			else if ((bStraight==GetCardLogicValue(CardData[i])+2)&&((bUsedDW==false)||(bUsedXW==false)))
			{
				if (bUsedDW == false)
				{
					Straight++;
					Index[Number++]=0;
					bUsedDW = true;
				}
				else if (bUsedXW == false)
				{
					Straight++;
					Index[Number++]=1;
					bUsedXW = true;
				}
				
				Straight++;
				Index[Number++]=i;
				bStraight=GetCardLogicValue(CardData[i]);
			}
			else if ((bStraight == GetCardLogicValue(CardData[i]+3))&&(bUsedDW==false)&&(bUsedXW==false))
			{
				Straight++;
				Index[Number++]=0;
				Straight++;
				Index[Number++]=1;
				Straight++;
				Index[Number++]=i;
				bStraight=GetCardLogicValue(CardData[i]);
				bUsedDW = true;
				bUsedXW = true;
			}
			if(bStraight>GetCardLogicValue(CardData[i])+1||i==bCardCount-1)
			{
				if (Straight==4&&((bUsedDW==false)||(bUsedXW==false)))
				{
					if (bUsedDW == false)
					{
						Straight++;
						Index[Number++]=0;
						bUsedDW = true;
					}
					else if (bUsedXW == false)
					{
						Straight++;
						Index[Number++]=1;
						bUsedXW = true;
					}
				}

				if (Straight==3&&((bUsedDW==false)&&(bUsedXW==false)))
				{
					Straight++;
					Index[Number++]=0;
					Straight++;
					Index[Number++]=1;
				}

				if(Straight>=5)
				{
					Type.bStraight=true;
					for(BYTE j=0;j<Straight;j++)
					{
						if(Straight-j>=5)
						{
							if (bCardData[Index[j]] == bCardData[Index[j+1]]	||  bCardData[Index[j]] == bCardData[Index[j+2]]
							||  bCardData[Index[j]] == bCardData[Index[j+3]]	||  bCardData[Index[j]] == bCardData[Index[j+4]]
							||  bCardData[Index[j+1]] == bCardData[Index[j+2]]	||  bCardData[Index[j+1]] == bCardData[Index[j+3]]
							||  bCardData[Index[j+1]] == bCardData[Index[j+4]]	||  bCardData[Index[j+2]] == bCardData[Index[j+3]]
							||  bCardData[Index[j+2]] == bCardData[Index[j+4]]	||  bCardData[Index[j+3]] == bCardData[Index[j+4]]
							)
							{
								continue;
							}
							Type.cbStraight[Num[3]++]=Index[j];
							Type.cbStraight[Num[3]++]=Index[j+1];
							Type.cbStraight[Num[3]++]=Index[j+2];
							Type.cbStraight[Num[3]++]=Index[j+3];
							Type.cbStraight[Num[3]++]=Index[j+4];
							Type.btStraight++;
							//从手牌中找到和顺子5张中其中一张数值相同的牌，组成另一种顺子
							for(int k=j;k<j+5;k++)
							{
								for(int m=0;m<bCardCount;m++)
								{
									if(GetCardLogicValue(CardData[Index[k]])==GetCardLogicValue(CardData[m])&&GetCardColor(CardData[Index[k]])!=GetCardColor(CardData[m]))
									{
										for(int n=j;n<j+5;n++)
										{
											if(n==k)
											{
												Type.cbStraight[Num[3]++]=m;
											}
											else
											{
												Type.cbStraight[Num[3]++]=Index[n];
											}
										}
										Type.btStraight++;
									}
								}
							}
						}
						else
						{
							break;
						}
					}

				}
				if(bCardCount-i<5)
				{
					break;
				}
				bStraight=GetCardLogicValue(CardData[i]);
				Straight=1;
				Number=0;
				ZeroMemory(Index,sizeof(Index));
				Index[Number++]=i;
				bUsedDW = false;
				bUsedXW = false;
			}
		}



		//存在2 检测A2345顺子
		if(GetCardLogicValue(CardData[bCardCount-1])==2)  
		{
			Number=0;
			Straight=2;
			bStraight=GetCardLogicValue(CardData[2]);
			ZeroMemory(Index,sizeof(Index));
			bool bFind = false;
			if (bStraight==14)
			{
				//Index[Number++]=1;
				Index[Number++]=2;		//下标0,1位置是鬼，所以是从下标2位置的A开始
				bStraight=GetCardLogicValue(CardData[bCardCount-1]);
				Index[Number++]=bCardCount-1;

				bool bDWused = false;
				bool bXWused = false;
				for(int i=bCardCount-2;i>=0;i--)
				{
					if(bStraight==GetCardLogicValue(CardData[i])-1)
					{
						Straight++;
						Index[Number++]=i;
						bStraight=GetCardLogicValue(CardData[i]);
						continue;
					}
					else if((bStraight==GetCardLogicValue(CardData[i])-2)
						&&((false == bDWused)||(false == bDWused)))//保证大小鬼只使用一次
					{
						if (bDWused == false)
						{
							bDWused = true;
							Straight++;
							Index[Number++]=0;
							Straight++;
							Index[Number++]=i;
							bStraight=GetCardLogicValue(CardData[i]);
						}
						else if (bXWused == false)
						{
							bXWused = true;
							Straight++;
							Index[Number++]=1;
							Straight++;
							Index[Number++]=i;
							bStraight=GetCardLogicValue(CardData[i]);
						}
					}
					else if ((bStraight == GetCardLogicValue(CardData[i]-3))
						&&(false == bDWused)&&(false == bDWused))//保证大小鬼只使用一次
					{
						Straight++;
						Index[Number++]=0;
						Straight++;
						Index[Number++]=1;
						Straight++;
						Index[Number++]=i;
						bStraight=GetCardLogicValue(CardData[i]);
					}
				}
			}
			else
			{
				Index[Number++]=rand()%2;//大小鬼任取一张
				bStraight=GetCardLogicValue(CardData[bCardCount-1]);
				Index[Number++]=bCardCount-1;
				for(int i=bCardCount-2;i>=0;i--)
				{
					if(bStraight==GetCardLogicValue(CardData[i])-1)
					{
						Straight++;
						Index[Number++]=i;
						bStraight=GetCardLogicValue(CardData[i]);
					}
				}
			}
			if(Straight>=5)
			{
				Type.bStraight=true;
				for(BYTE j=0;j<5;j++)
				{
					Type.cbStraight[Num[3]++]=Index[j];	
				}
				Type.btStraight++;

				//从手牌中找到和顺子5张中其中一张数值相同的牌，组成另一种顺子
				for(int k=0;k<5;k++)
				{
					for(int m=0;m<bCardCount;m++)
					{
						if(GetCardLogicValue(CardData[Index[k]])==GetCardLogicValue(CardData[m])&&GetCardColor(CardData[Index[k]])!=GetCardColor(CardData[m]))
						{
							for(int n=0;n<5;n++)
							{
								if(n==k)
								{
									Type.cbStraight[Num[3]++]=m;
								}
								else
								{
									Type.cbStraight[Num[3]++]=Index[n];
								}
							}
							Type.btStraight++;
						}
					}
				}

			}
		} 

		//存在3 检测A2345顺子
		if(GetCardLogicValue(CardData[bCardCount-1])==3)  
		{
			Number=0;
			Straight=3;
			bStraight=GetCardLogicValue(CardData[2]);
			ZeroMemory(Index,sizeof(Index));
			bool bFind = false;
			if (bStraight==14)
			{
				Index[Number++]=1;
				Index[Number++] = 2;
				bStraight=GetCardLogicValue(CardData[bCardCount-1]);
				Index[Number++]=bCardCount-1;

				bool bDWused = false;
				
				for(int i=bCardCount-2;i>=0;i--)
				{
					if(bStraight==GetCardLogicValue(CardData[i])-1)
					{
						Straight++;
						Index[Number++]=i;
						bStraight=GetCardLogicValue(CardData[i]);
						continue;
					}
					else if((bStraight==GetCardLogicValue(CardData[i])-2)
						&&(false == bDWused))//保证大鬼只使用一次
					{
						if (bDWused == false)
						{
							bDWused = true;
							Straight++;
							Index[Number++]=0;
							Straight++;
							Index[Number++]=i;
							bStraight=GetCardLogicValue(CardData[i]);
						}
					}
				}
			}
			else
			{
				Index[Number++]=0;
				Index[Number++]=1;
				bStraight=GetCardLogicValue(CardData[bCardCount-1]);
				Index[Number++]=bCardCount-1;
				for(int i=bCardCount-2;i>=0;i--)
				{
					if(bStraight==GetCardLogicValue(CardData[i])-1)
					{
						Straight++;
						Index[Number++]=i;
						bStraight=GetCardLogicValue(CardData[i]);
					}
				}
			}
			if(Straight>=5)
			{
				Type.bStraight=true;
				for(BYTE j=0;j<5;j++)
				{
					Type.cbStraight[Num[3]++]=Index[j];	
				}
				Type.btStraight++;
				//从手牌中找到和顺子5张中其中一张数值相同的牌，组成另一种顺子
				for(int k=0;k<5;k++)
				{
					for(int m=0;m<bCardCount;m++)
					{
						if(GetCardLogicValue(CardData[Index[k]])==GetCardLogicValue(CardData[m])&&GetCardColor(CardData[Index[k]])!=GetCardColor(CardData[m]))
						{
							for(int n=0;n<5;n++)
							{
								if(n==k)
								{
									Type.cbStraight[Num[3]++]=m;
								}
								else
								{
									Type.cbStraight[Num[3]++]=Index[n];
								}
							}
							Type.btStraight++;

							
						}
					}
				}

			}
		} 



		//存在4和A 检测A2345顺子
		if((GetCardLogicValue(CardData[bCardCount-1])==4)
				&&(GetCardLogicValue(CardData[2])==14))
		{
			Number=0;
			Straight=4;
			bStraight=GetCardLogicValue(CardData[2]);
			ZeroMemory(Index,sizeof(Index));
			
			Index[Number++]=0;
			Index[Number++]=1;
			Index[Number++]=2;
			bStraight=GetCardLogicValue(CardData[bCardCount-1]);
			Index[Number++]=bCardCount-1;
			for(int i=bCardCount-2;i>=0;i--)
			{
				if(bStraight==GetCardLogicValue(CardData[i])-1)
				{
					Straight++;
					Index[Number++]=i;
					bStraight=GetCardLogicValue(CardData[i]);
				}
			}
				
			if(Straight>=5)
			{
				Type.bStraight=true;
				for(BYTE j=0;j<5;j++)
				{
					Type.cbStraight[Num[3]++]=Index[j];	
				}
				Type.btStraight++;

				
				//从手牌中找到和顺子5张中其中一张数值相同的牌，组成另一种顺子
				for(int k=0;k<5;k++)
				{
					for(int m=0;m<bCardCount;m++)
					{
						if(GetCardLogicValue(CardData[Index[k]])==GetCardLogicValue(CardData[m])&&GetCardColor(CardData[Index[k]])!=GetCardColor(CardData[m]))
						{
							for(int n=0;n<5;n++)
							{
								if(n==k)
								{
									Type.cbStraight[Num[3]++]=m;
								}
								else
								{
									Type.cbStraight[Num[3]++]=Index[n];
								}
							}
							Type.btStraight++;

   						}
					}
				}

			}
		} 
		
	}
	else  //没有王的
	{

		bStraight=GetCardLogicValue(CardData[0]);
		Index[Number++]=0;
		if(bStraight!=14)
		{
			for(BYTE i=1;i<bCardCount;i++)
			{
				if(bStraight==GetCardLogicValue(CardData[i])+1)
				{
					Straight++;
					Index[Number++]=i;
					bStraight=GetCardLogicValue(CardData[i]);
				}
				if(bStraight>GetCardLogicValue(CardData[i])+1||i==bCardCount-1)
				{
					if(Straight>=5)
					{
						Type.bStraight=true;
						for(BYTE j=0;j<Straight;j++)
						{
							if(Straight-j>=5)
							{
								Type.cbStraight[Num[3]++]=Index[j];
								Type.cbStraight[Num[3]++]=Index[j+1];
								Type.cbStraight[Num[3]++]=Index[j+2];
								Type.cbStraight[Num[3]++]=Index[j+3];
								Type.cbStraight[Num[3]++]=Index[j+4];
								Type.btStraight++;
								//从手牌中找到和顺子5张中其中一张数值相同的牌，组成另一种顺子
								for(int k=j;k<j+5;k++)
								{
									for(int m=0;m<bCardCount;m++)
									{
										if(GetCardLogicValue(CardData[Index[k]])==GetCardLogicValue(CardData[m])&&GetCardColor(CardData[Index[k]])!=GetCardColor(CardData[m]))
										{
											for(int n=j;n<j+5;n++)
											{
												if(n==k)
												{
													Type.cbStraight[Num[3]++]=m;
												}
												else
												{
													Type.cbStraight[Num[3]++]=Index[n];
												}
											}
											Type.btStraight++;
										}
									}
								}
							}
							else
							{
								break;
							}
						}

					}
					if(bCardCount-i<5)
					{
						break;
					}
					bStraight=GetCardLogicValue(CardData[i]);
					Straight=1;
					Number=0;
					ZeroMemory(Index,sizeof(Index));
					Index[Number++]=i;
				}
			}

		}
		if(bStraight==14)  ///zyy 要是出现A的 就会有问题
		{
			for(BYTE i=1;i<bCardCount;i++)
			{
				if(bStraight==GetCardLogicValue(CardData[i])+1)
				{
					Straight++;
					Index[Number++]=i;
					bStraight=GetCardLogicValue(CardData[i]);

				}
				if(bStraight>GetCardLogicValue(CardData[i])+1||i==bCardCount-1)
				{
					if(Straight>=5)
					{
						
						Type.bStraight=true;
						for(BYTE j=0;j<Straight;j++)
						{
							if(Straight-j>=5 )
							{
								
								Type.cbStraight[Num[3]++]=Index[j];
								Type.cbStraight[Num[3]++]=Index[j+1];
								Type.cbStraight[Num[3]++]=Index[j+2];
								Type.cbStraight[Num[3]++]=Index[j+3];
								Type.cbStraight[Num[3]++]=Index[j+4];
								Type.btStraight++;
								//从手牌中找到和顺子5张中其中一张数值相同的牌，组成另一种顺子
								for(int k=j;k<j+5;k++)
								{
									for(int m=0;m<bCardCount;m++)
									{
										if(GetCardLogicValue(CardData[Index[k]])==GetCardLogicValue(CardData[m])&&GetCardColor(CardData[Index[k]])!=GetCardColor(CardData[m]))
										{
											for(int n=j;n<j+5;n++)
											{
												if(n==k)
												{
													Type.cbStraight[Num[3]++]=m;
												}
												else
												{
													Type.cbStraight[Num[3]++]=Index[n];
												}
											}
											Type.btStraight++;
										}
									}
								}
							}
							else
							{
								break;
							}
						}
					}
					if((bCardCount-i)<5)
					{
						break;
					}
					bStraight=GetCardLogicValue(CardData[i]);
					Straight=1;
					Number=0;
					ZeroMemory(Index,sizeof(Index));
					Index[Number++]=i; 
				}
			}

			if(GetCardLogicValue(CardData[bCardCount-1])==2)
			{
				Number=0;
				BYTE BackA=1;
				BYTE FrontA=1;
				bStraight=GetCardLogicValue(CardData[0]);
				ZeroMemory(Index,sizeof(Index));
				Index[Number++]=0;
				bStraight=GetCardLogicValue(CardData[bCardCount-1]);
				Index[Number++]=bCardCount-1;
				for(int i=bCardCount-2;i>=0;i--)
				{
					if(bStraight==GetCardLogicValue(CardData[i])-1)
					{
						FrontA++;
						Index[Number++]=i;
						bStraight=GetCardLogicValue(CardData[i]);
					}
				}
				if(FrontA+BackA>=5)
				{
					Type.bStraight=true;
					for(BYTE i=BackA;i>0;i--)
					{
						for(BYTE j=1;j<=FrontA;j++)
						{
							if(i+j==5)
							{
								for(BYTE k=0;k<i;k++)
								{
									Type.cbStraight[Num[3]++]=Index[k];
								}
								for(BYTE k=0;k<j;k++)
								{
									Type.cbStraight[Num[3]++]=Index[k+BackA];
								}

								Type.btStraight++;
								break;
							}
						}
					}
				}
			}  

		}
	}

	//判断同花
	Number=0;
	ZeroMemory(Index,sizeof(Index));
	SortCardList(CardData , bCardCount , enColor) ;
	BYTE cbCardData[13];
	CopyMemory(cbCardData , bCardData , bCardCount) ;
	SortCardList(cbCardData , bCardCount , enDescend) ;
	if (GetCardLogicValue(CardData[0]) >=CARD_XW && GetCardLogicValue(CardData[1]) <CARD_XW)
	{
		BYTE SameColorCount=1;
		BYTE bCardColor = GetCardColor(CardData[1]) ;
		Index[Number++]=1;

		for(BYTE i=2;i<bCardCount;i++)
		{
			if(bCardColor==GetCardColor(CardData[i]))
			{
				SameColorCount++;
				Index[Number++]=i;
			}
			if(bCardColor!=GetCardColor(CardData[i])||i==bCardCount-1)
			{
				if (SameColorCount==4)
				{
					SameColorCount++;
					Index[Number++]=0;
				}
				if(SameColorCount>=5)
				{
					Type.bFlush=true;
					//切换位置
					for(BYTE j=0;j<SameColorCount;j++)
					{
						for(BYTE k=0;k<bCardCount;k++)
						{
							if(GetCardLogicValue(CardData[Index[j]])==GetCardLogicValue(cbCardData[k])
								&&GetCardColor(CardData[Index[j]])==GetCardColor(cbCardData[k]))
							{
								Index[j]=k;
								break;
							}
						}
					} 
					//排序位置
					BYTE SaveIndex=0;
					for(BYTE j=0;j<SameColorCount;j++)
					{
						for(BYTE k=j+1;k<SameColorCount;k++)
						{
							if(Index[j]>Index[k])
							{
								SaveIndex=Index[j];
								Index[j]=Index[k];
								Index[k]=SaveIndex;
							}
						}
					}


					//同花顺
					if (GetCardLogicValue(cbCardData[Index[0]])>=CARD_XW)
					{
						if (((GetCardLogicValue(cbCardData[Index[1]])==14)&&((GetCardLogicValue(cbCardData[Index[2]])==5)||(GetCardLogicValue(cbCardData[Index[2]])==4)))
							||(4>=(GetCardLogicValue(cbCardData[Index[1]])-GetCardLogicValue(cbCardData[Index[4]]))))
						{
							Type.bStraightFlush=true;
							Type.cbStraightFlush[Num[7]++]=Index[0];
							Type.cbStraightFlush[Num[7]++]=Index[1];
							Type.cbStraightFlush[Num[7]++]=Index[2];
							Type.cbStraightFlush[Num[7]++]=Index[3];
							Type.cbStraightFlush[Num[7]++]=Index[4];
							Type.btStraightFlush++;
						}																																									
					}
					else
					{
						//同花A2345特殊处理
						if (GetCardLogicValue(cbCardData[Index[0]])==14)
						{
							for (BYTE i=1;i<SameColorCount;i++)
							{

								if(GetCardLogicValue(cbCardData[Index[i]])==5)
								{
									if (SameColorCount-i==4)
									{
										Type.bStraightFlush=true;
										Type.cbStraightFlush[Num[7]++]=Index[0];
										Type.cbStraightFlush[Num[7]++]=Index[i];
										Type.cbStraightFlush[Num[7]++]=Index[i+1];
										Type.cbStraightFlush[Num[7]++]=Index[i+2];
										Type.cbStraightFlush[Num[7]++]=Index[i+3];
										Type.btStraightFlush++;
									}
									else if (SameColorCount-i==3)
									{
										Type.bStraightFlush=true;
										Type.cbStraightFlush[Num[7]++]=0;//鬼
										Type.cbStraightFlush[Num[7]++]=Index[0];//A
										Type.cbStraightFlush[Num[7]++]=Index[i];
										Type.cbStraightFlush[Num[7]++]=Index[i+1];
										Type.cbStraightFlush[Num[7]++]=Index[i+2];
										Type.btStraightFlush++;
									}

								}

								if(GetCardLogicValue(cbCardData[Index[i]])==4)
								{
									if (SameColorCount-i==3)												
									{
										Type.bStraightFlush=true;
										Type.cbStraightFlush[Num[7]++]=0;//鬼
										Type.cbStraightFlush[Num[7]++]=Index[0];//A
										Type.cbStraightFlush[Num[7]++]=Index[i];
										Type.cbStraightFlush[Num[7]++]=Index[i+1];
										Type.cbStraightFlush[Num[7]++]=Index[i+2];
										Type.btStraightFlush++;
									}
								}
							}
						}


						for (BYTE i=0;i<SameColorCount;i++)
						{
							if (SameColorCount-i>=5)
							{
								if (4==(GetCardLogicValue(cbCardData[Index[i]])-GetCardLogicValue(cbCardData[Index[i+4]])))
								{
									Type.bStraightFlush=true;
									Type.cbStraightFlush[Num[7]++]=Index[i];
									Type.cbStraightFlush[Num[7]++]=Index[i+1];
									Type.cbStraightFlush[Num[7]++]=Index[i+2];
									Type.cbStraightFlush[Num[7]++]=Index[i+3];
									Type.cbStraightFlush[Num[7]++]=Index[i+4];
									Type.btStraightFlush++;
								}
								else if (4>=(GetCardLogicValue(cbCardData[Index[i]])-GetCardLogicValue(cbCardData[Index[i+3]])))
								{
									Type.bStraightFlush=true;
									Type.cbStraightFlush[Num[7]++]=0;
									Type.cbStraightFlush[Num[7]++]=Index[i];
									Type.cbStraightFlush[Num[7]++]=Index[i+1];
									Type.cbStraightFlush[Num[7]++]=Index[i+2];
									Type.cbStraightFlush[Num[7]++]=Index[i+3];
									Type.btStraightFlush++;
								}

							}
							else if(SameColorCount-i==4)
							{
								if (4>=(GetCardLogicValue(cbCardData[Index[i]])-GetCardLogicValue(cbCardData[Index[i+3]])))
								{
									Type.bStraightFlush=true;
									Type.cbStraightFlush[Num[7]++]=0;
									Type.cbStraightFlush[Num[7]++]=Index[i];
									Type.cbStraightFlush[Num[7]++]=Index[i+1];
									Type.cbStraightFlush[Num[7]++]=Index[i+2];
									Type.cbStraightFlush[Num[7]++]=Index[i+3];
									Type.btStraightFlush++;
								}
							}

						}

					}


					for(BYTE j=0;j<SameColorCount;j++)
					{
						if(SameColorCount-j>=5)
						{
							Type.cbFlush[Num[4]++]=Index[j];
							Type.cbFlush[Num[4]++]=Index[j+1];
							Type.cbFlush[Num[4]++]=Index[j+2];
							Type.cbFlush[Num[4]++]=Index[j+3];
							Type.cbFlush[Num[4]++]=Index[j+4];
							Type.btFlush++;							
						}
						else
						{
							break;
						}
					}
				}
				if(bCardCount-i<4)
				{
					break;
				}
				Number=0;
				ZeroMemory(Index,sizeof(Index));
				SameColorCount=1;
				Index[Number++]=i;
				bCardColor=GetCardColor(CardData[i]);
			}
		}
	}
	else if (GetCardLogicValue(CardData[0]) ==CARD_DW && GetCardLogicValue(CardData[1]) ==CARD_XW)
	{
		BYTE SameColorCount=1;
		BYTE bCardColor = GetCardColor(CardData[2]) ;
		Index[Number++]=2;

		for(BYTE i=3;i<bCardCount;i++)
		{
			if(bCardColor==GetCardColor(CardData[i]))
			{
				SameColorCount++;
				Index[Number++]=i;
			}
			if(bCardColor!=GetCardColor(CardData[i])||i==bCardCount-1)
			{
				if (SameColorCount==4)
				{
					SameColorCount++;
					Index[Number++]=0;
				}
				if (SameColorCount == 3)
				{
					SameColorCount++;
					Index[Number++]=0;
					SameColorCount++;
					Index[Number++]=1;
				}
				if(SameColorCount>=5)
				{
					Type.bFlush=true;

					for(BYTE j=0;j<SameColorCount;j++)
					{
						for(BYTE k=0;k<bCardCount;k++)
						{
							if(GetCardLogicValue(CardData[Index[j]])==GetCardLogicValue(cbCardData[k])
								&&GetCardColor(CardData[Index[j]])==GetCardColor(cbCardData[k]))
							{
								Index[j]=k;
								break;
							}
						}
					} 
					BYTE SaveIndex=0;
					for(BYTE j=0;j<SameColorCount;j++)
					{
						for(BYTE k=j+1;k<SameColorCount;k++)
						{
							if(Index[j]>Index[k])
							{
								SaveIndex=Index[j];
								Index[j]=Index[k];
								Index[k]=SaveIndex;
							}
						}
					}

					//同花顺
					if (GetCardLogicValue(cbCardData[Index[0]]) ==CARD_DW && GetCardLogicValue(cbCardData[Index[1]]) ==CARD_XW)
					{
						if (((GetCardLogicValue(cbCardData[Index[2]])==14)&&((GetCardLogicValue(cbCardData[Index[3]])==5)||(GetCardLogicValue(cbCardData[Index[3]])==4)||(GetCardLogicValue(cbCardData[Index[3]])==3)))
							||(4>=(GetCardLogicValue(cbCardData[Index[2]])-GetCardLogicValue(cbCardData[Index[4]]))))
						{
							Type.bStraightFlush=true;
							Type.cbStraightFlush[Num[7]++]=Index[0];
							Type.cbStraightFlush[Num[7]++]=Index[1];
							Type.cbStraightFlush[Num[7]++]=Index[2];
							Type.cbStraightFlush[Num[7]++]=Index[3];
							Type.cbStraightFlush[Num[7]++]=Index[4];
							Type.btStraightFlush++;
						}
					}
					else if (GetCardLogicValue(cbCardData[Index[0]])>=CARD_XW && GetCardLogicValue(cbCardData[Index[1]]) <CARD_XW)
					{
						if (((GetCardLogicValue(cbCardData[Index[1]])==14)&&((GetCardLogicValue(cbCardData[Index[2]])==5)||(GetCardLogicValue(cbCardData[Index[2]])==4)))
							||(4>=(GetCardLogicValue(cbCardData[Index[1]])-GetCardLogicValue(cbCardData[Index[4]]))))
						{
							Type.bStraightFlush=true;
							Type.cbStraightFlush[Num[7]++]=Index[0];
							Type.cbStraightFlush[Num[7]++]=Index[1];
							Type.cbStraightFlush[Num[7]++]=Index[2];
							Type.cbStraightFlush[Num[7]++]=Index[3];
							Type.cbStraightFlush[Num[7]++]=Index[4];
							Type.btStraightFlush++;
						}																																									
					}
					else
					{
						//同花A2345特殊处理
						if (GetCardLogicValue(cbCardData[Index[0]])==14)
						{
							for (BYTE i=1;i<SameColorCount;i++)
							{

								if(GetCardLogicValue(cbCardData[Index[i]])==5)
								{
									if (SameColorCount-i==4)
									{
										Type.bStraightFlush=true;
										Type.cbStraightFlush[Num[7]++]=Index[0];
										Type.cbStraightFlush[Num[7]++]=Index[i];
										Type.cbStraightFlush[Num[7]++]=Index[i+1];
										Type.cbStraightFlush[Num[7]++]=Index[i+2];
										Type.cbStraightFlush[Num[7]++]=Index[i+3];
										Type.btStraightFlush++;
									}
									else if (SameColorCount-i==3)
									{
										Type.bStraightFlush=true;
										Type.cbStraightFlush[Num[7]++]=0;//鬼
										Type.cbStraightFlush[Num[7]++]=Index[0];//A
										Type.cbStraightFlush[Num[7]++]=Index[i];
										Type.cbStraightFlush[Num[7]++]=Index[i+1];
										Type.cbStraightFlush[Num[7]++]=Index[i+2];
										Type.btStraightFlush++;
									}
									else if (SameColorCount-i==2)
									{
										Type.bStraightFlush=true;
										Type.cbStraightFlush[Num[7]++]=0;//鬼
										Type.cbStraightFlush[Num[7]++]=1;
										Type.cbStraightFlush[Num[7]++]=Index[0];//A
										Type.cbStraightFlush[Num[7]++]=Index[i];
										Type.cbStraightFlush[Num[7]++]=Index[i+1];										
										Type.btStraightFlush++;
									}

								}
								else if(GetCardLogicValue(cbCardData[Index[i]])==4)
								{
									if (SameColorCount-i==3)												
									{
										Type.bStraightFlush=true;
										Type.cbStraightFlush[Num[7]++]=0;//鬼
										Type.cbStraightFlush[Num[7]++]=Index[0];//A
										Type.cbStraightFlush[Num[7]++]=Index[i];
										Type.cbStraightFlush[Num[7]++]=Index[i+1];
										Type.cbStraightFlush[Num[7]++]=Index[i+2];
										Type.btStraightFlush++;
									}
									else if (SameColorCount-i==2)												
									{
										Type.bStraightFlush=true;
										Type.cbStraightFlush[Num[7]++]=0;//鬼
										Type.cbStraightFlush[Num[7]++]=1;
										Type.cbStraightFlush[Num[7]++]=Index[0];//A
										Type.cbStraightFlush[Num[7]++]=Index[i];
										Type.cbStraightFlush[Num[7]++]=Index[i+1];
										
										Type.btStraightFlush++;
									}
								}
								else if(GetCardLogicValue(cbCardData[Index[i]])==3)
								{
								    if (SameColorCount-i==2)												
									{
										Type.bStraightFlush=true;
										Type.cbStraightFlush[Num[7]++]=0;//鬼
										Type.cbStraightFlush[Num[7]++]=1;
										Type.cbStraightFlush[Num[7]++]=Index[0];//A
										Type.cbStraightFlush[Num[7]++]=Index[i];
										Type.cbStraightFlush[Num[7]++]=Index[i+1];
										Type.btStraightFlush++;
									}
								}
							}
						}

						
						for (BYTE i=0;i<SameColorCount;i++)
						{
							if (SameColorCount-i>=5)
							{
								if (4==(GetCardLogicValue(cbCardData[Index[i]])-GetCardLogicValue(cbCardData[Index[i+4]])))
								{
									Type.bStraightFlush=true;
									Type.cbStraightFlush[Num[7]++]=Index[i];
									Type.cbStraightFlush[Num[7]++]=Index[i+1];
									Type.cbStraightFlush[Num[7]++]=Index[i+2];
									Type.cbStraightFlush[Num[7]++]=Index[i+3];
									Type.cbStraightFlush[Num[7]++]=Index[i+4];
									Type.btStraightFlush++;
								}
								else if (4>=(GetCardLogicValue(cbCardData[Index[i]])-GetCardLogicValue(cbCardData[Index[i+3]])))
								{
									Type.bStraightFlush=true;
									Type.cbStraightFlush[Num[7]++]=0;
									Type.cbStraightFlush[Num[7]++]=Index[i];
									Type.cbStraightFlush[Num[7]++]=Index[i+1];
									Type.cbStraightFlush[Num[7]++]=Index[i+2];
									Type.cbStraightFlush[Num[7]++]=Index[i+3];
									Type.btStraightFlush++;
								}
								else if (4>=(GetCardLogicValue(cbCardData[Index[i]])-GetCardLogicValue(cbCardData[Index[i+2]])))
								{
									Type.bStraightFlush=true;
									Type.cbStraightFlush[Num[7]++]=0;
									Type.cbStraightFlush[Num[7]++]=1;
									Type.cbStraightFlush[Num[7]++]=Index[i];
									Type.cbStraightFlush[Num[7]++]=Index[i+1];
									Type.cbStraightFlush[Num[7]++]=Index[i+2];
									Type.btStraightFlush++;
								}

							}
							else if(SameColorCount-i==4)
							{
								if (4>=(GetCardLogicValue(cbCardData[Index[i]])-GetCardLogicValue(cbCardData[Index[i+3]])))
								{
									Type.bStraightFlush=true;
									Type.cbStraightFlush[Num[7]++]=0;
									Type.cbStraightFlush[Num[7]++]=Index[i];
									Type.cbStraightFlush[Num[7]++]=Index[i+1];
									Type.cbStraightFlush[Num[7]++]=Index[i+2];
									Type.cbStraightFlush[Num[7]++]=Index[i+3];
									Type.btStraightFlush++;
								}
								else if (4>=(GetCardLogicValue(cbCardData[Index[i]])-GetCardLogicValue(cbCardData[Index[i+2]])))
								{
									Type.bStraightFlush=true;
									Type.cbStraightFlush[Num[7]++]=0;
									Type.cbStraightFlush[Num[7]++]=1;
									Type.cbStraightFlush[Num[7]++]=Index[i];
									Type.cbStraightFlush[Num[7]++]=Index[i+1];
									Type.cbStraightFlush[Num[7]++]=Index[i+2];

									Type.btStraightFlush++;
								}
							}
							else if(SameColorCount-i==3)
							{
							    if (4>=(GetCardLogicValue(cbCardData[Index[i]])-GetCardLogicValue(cbCardData[Index[i+2]])))
								{
									Type.bStraightFlush=true;
									Type.cbStraightFlush[Num[7]++]=0;
									Type.cbStraightFlush[Num[7]++]=1;
									Type.cbStraightFlush[Num[7]++]=Index[i];
									Type.cbStraightFlush[Num[7]++]=Index[i+1];
									Type.cbStraightFlush[Num[7]++]=Index[i+2];

									Type.btStraightFlush++;
								}
							}
						}

					}
					
					
					for(BYTE j=0;j<SameColorCount;j++)
					{
						if(SameColorCount-j>=5)
						{
							Type.cbFlush[Num[4]++]=Index[j];
							Type.cbFlush[Num[4]++]=Index[j+1];
							Type.cbFlush[Num[4]++]=Index[j+2];
							Type.cbFlush[Num[4]++]=Index[j+3];
							Type.cbFlush[Num[4]++]=Index[j+4];
							Type.btFlush++;																
						}	
						else
						{
							break;
						}
					}
				}
				if(bCardCount-i<3)
				{
					break;
				}
				Number=0;
				ZeroMemory(Index,sizeof(Index));
				SameColorCount=1;
				Index[Number++]=i;
				bCardColor=GetCardColor(CardData[i]);
			}
		}
	}
	else
	{
		BYTE SameColorCount=1;
		BYTE bCardColor = GetCardColor(CardData[0]) ;
		Index[Number++]=0;

		for(BYTE i=1;i<bCardCount;i++)
		{
			if(bCardColor==GetCardColor(CardData[i]))
			{
				SameColorCount++;
				Index[Number++]=i;
			}
			if(bCardColor!=GetCardColor(CardData[i])||i==bCardCount-1)
			{
				if(SameColorCount>=5)
				{
					Type.bFlush=true;

					for(BYTE j=0;j<SameColorCount;j++)
					{
						for(BYTE k=0;k<bCardCount;k++)
						{
							if(GetCardLogicValue(CardData[Index[j]])==GetCardLogicValue(cbCardData[k])
								&&GetCardColor(CardData[Index[j]])==GetCardColor(cbCardData[k]))
							{
								Index[j]=k;
								break;
							}
						}
					} 
					BYTE SaveIndex=0;
					for(BYTE j=0;j<SameColorCount;j++)
					{
						for(BYTE k=j+1;k<SameColorCount;k++)
						{
							if(Index[j]>Index[k])
							{
								SaveIndex=Index[j];
								Index[j]=Index[k];
								Index[k]=SaveIndex;
							}
						}
					}

					

					for(BYTE j=0;j<SameColorCount;j++)
					{
						if(SameColorCount-j>=5)
						{
							Type.cbFlush[Num[4]++]=Index[j];
							Type.cbFlush[Num[4]++]=Index[j+1];
							Type.cbFlush[Num[4]++]=Index[j+2];
							Type.cbFlush[Num[4]++]=Index[j+3];
							Type.cbFlush[Num[4]++]=Index[j+4];
							Type.btFlush++;
							
							//同花A2345特殊处理
							if (GetCardLogicValue(cbCardData[Index[j]])==14)
							{
								for (BYTE i=j+1;i<SameColorCount;i++)
								{
									
									if(GetCardLogicValue(cbCardData[Index[i]])==5)
									{
										if (SameColorCount-i>=4)
										{
											Type.bStraightFlush=true;
											Type.cbStraightFlush[Num[7]++]=Index[j];//A
											Type.cbStraightFlush[Num[7]++]=Index[i];//5
											Type.cbStraightFlush[Num[7]++]=Index[i+1];//4
											Type.cbStraightFlush[Num[7]++]=Index[i+2];//3
											Type.cbStraightFlush[Num[7]++]=Index[i+3];//2
											Type.btStraightFlush++;
										}
									}

								}
							}

							if(GetCardLogicValue(cbCardData[Index[j]])-GetCardLogicValue(cbCardData[Index[j+4]])==4)
							{
								Type.bStraightFlush=true;
								Type.cbStraightFlush[Num[7]++]=Index[j];
								Type.cbStraightFlush[Num[7]++]=Index[j+1];
								Type.cbStraightFlush[Num[7]++]=Index[j+2];
								Type.cbStraightFlush[Num[7]++]=Index[j+3];
								Type.cbStraightFlush[Num[7]++]=Index[j+4];
								Type.btStraightFlush++;
							}
						}
						else
						{
							break;
						}
					}
				}
				if(bCardCount-i<5)
				{
					break;
				}
				Number=0;
				ZeroMemory(Index,sizeof(Index));
				SameColorCount=1;
				Index[Number++]=i;
				bCardColor=GetCardColor(CardData[i]);
			}
		}

	}
	return Type;
}

bool CGameLogic::AppendCard( const BYTE bAppendCard[],BYTE bAppendCount,BYTE bCardData[],BYTE &bCardCount )
{
	ASSERT(bAppendCount+bCardCount<=13);
	for(int i=0;i<bAppendCount;i++)
	{
		bCardData[bCardCount+i]=bAppendCard[i];
	}
	bCardCount+=bAppendCount;
	return true;
}

BYTE CGameLogic::GetCardCount( BYTE bCardData[] )
{
	BYTE Number=0;
	if(0==GetCardLogicValue(bCardData[1])&&0==GetCardLogicValue(bCardData[2]))
	{
		return 0;
	}
	else
	{
		for(BYTE i=0;i<5;i++)
		{
			if(GetCardLogicValue(bCardData[i])>0)
			{
				Number++;
			}
			else
			{
				break;
			}
		}
	}
	return Number;
}

//void CGameLogic::TheBestCard(tagAnalyseType tagCardType,BYTE btHandCardData[],BYTE btHandCardCount,BYTE btFrontCard[],BYTE btMidCard[],BYTE btBackCard[] )
//{
//	if(btHandCardCount!=13)
//	{
//		return;
//	}
//	BYTE btCardCount=btHandCardCount;
//	BYTE btCardData[13];
//	CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//	BYTE btCardData1[13];
//	BYTE btCardData2[13];
//	ZeroMemory(btCardData1,sizeof(btCardData1));
//	ZeroMemory(btCardData2,sizeof(btCardData2));
//	BYTE btCardCount1=0;
//	BYTE btCardCount2=0;
//	BYTE FrontCard[3];
//	BYTE MidCard[5];
//	BYTE BackCard[5];
//	BYTE btAllShuiShu=0;
//	ZeroMemory(FrontCard,sizeof(FrontCard));
//	ZeroMemory(MidCard,sizeof(MidCard));
//	ZeroMemory(BackCard,sizeof(BackCard));
//	BYTE FrontFrontCard[3];
//	BYTE FrontMidCard[5];
//	BYTE FrontBackCard[5];
//	BYTE btFrontAllShuiShu=0;
//	ZeroMemory(FrontFrontCard,sizeof(FrontFrontCard));
//	ZeroMemory(FrontMidCard,sizeof(FrontMidCard));
//	ZeroMemory(FrontBackCard,sizeof(FrontBackCard));
//	bool bCycling=true;
//	bool bFront=false;
//	bool bMid=false;
//	bool bBack=false;
//	bool bFirst=true;
//	BYTE btFront=0;
//	BYTE btMid=0;
//	BYTE btBack=0;
//	tagAnalyseType tagCardType1;
//	tagAnalyseType tagCardType2;
//	ZeroMemory(&tagCardType1,sizeof(tagCardType1));
//	ZeroMemory(&tagCardType2,sizeof(tagCardType2));
//	BYTE btTemp[13];
//	ZeroMemory(btTemp,sizeof(btTemp));
//
//	if(tagCardType.bStraightFlush)    //有同花顺
//	{
//		for(int i=0;i<tagCardType.btStraightFlush;i++)
//		{
//			CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//			btCardCount=btHandCardCount;
//			for(int j=0;j<5;j++)
//			{
//				BackCard[j]=btCardData[tagCardType.cbStraightFlush[i*5+j]];
//			}
//			RemoveCard(BackCard,5,btCardData,btCardCount);
//			btCardCount1= btCardCount-=5;
//			CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//			tagCardType1=GetType(btCardData1,btCardCount1);
//			if(tagCardType1.bStraightFlush)      //有同花顺
//			{
//				for(int j=0;j<tagCardType1.btStraightFlush;j++)
//				{
//					btCardCount1=btCardCount;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//
//					for(int k=0;k<5;k++)
//					{
//						MidCard[k]=btCardData1[tagCardType1.cbStraightFlush[j*5+k]];
//					}
//					RemoveCard(MidCard,5,btCardData1,btCardCount1);
//					for(int k=0;k<3;k++)
//					{
//						FrontCard[k]=btCardData1[k];
//					}
//					if(bFirst)
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//						{
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//							bFirst=false;
//						}
//					}
//					else 
//					{
//						btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//							||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//						{
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							btFrontAllShuiShu=btAllShuiShu;
//						}
//					}
//				}
//
//			}
//			else if(tagCardType1.bFourSame)      //有铁支
//			{
//				for(int j=0;j<tagCardType1.btFourSame;j++)
//				{
//					btCardCount1=btCardCount;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//
//					for(int k=0;k<4;k++)
//					{
//						MidCard[k]=btCardData1[tagCardType1.cbFourSame[j*4+k]];
//					}
//					RemoveCard(MidCard,4,btCardData1,btCardCount1);
//					btCardCount2=btCardCount1-=4;
//					CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//					tagCardType2=GetType(btCardData2,btCardCount2);
//					if(tagCardType2.bThreeSame)  //剩下三条
//					{
//						for(int k=3;k>=0;k--)
//						{
//							if(GetCardLogicValue(btCardData2[k])!=GetCardLogicValue(btCardData2[tagCardType2.cbThreeSame[0]]))
//							{
//								btTemp[0]=MidCard[4]=btCardData2[k];
//								break;
//							}
//						}
//						RemoveCard(btTemp,1,btCardData2,btCardCount2);
//						CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
//					}
//					else if(tagCardType2.bTwoPare)//剩下两对
//					{
//						MidCard[4]=btCardData2[tagCardType2.cbTwoPare[3]];
//						FrontCard[0]=btCardData2[tagCardType2.cbTwoPare[0]];
//						FrontCard[1]=btCardData2[tagCardType2.cbTwoPare[1]];
//						FrontCard[2]=btCardData2[tagCardType2.cbTwoPare[2]];
//					}
//					else if(tagCardType2.bOnePare)//剩下一对
//					{
//						for(int k=3;k>=0;k--)
//						{
//							if(GetCardLogicValue(btCardData2[k])!=GetCardLogicValue(btCardData2[tagCardType2.cbOnePare[0]]))
//							{
//								btTemp[0]=MidCard[4]=btCardData2[k];
//								break;
//							}
//						}
//						RemoveCard(btTemp,1,btCardData2,btCardCount2);
//						CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
//					}
//					else                         //剩下散牌        
//					{
//						MidCard[4]=btCardData2[3];
//						CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
//					}
//					if(bFirst)
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//						{
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//							bFirst=false;
//						}
//					}
//					else 
//					{
//						btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//							||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//						{
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							btFrontAllShuiShu=btAllShuiShu;
//						}
//					}
//				}
//			}
//			else
//			{
//				if(tagCardType1.bGourd)         //有葫芦
//				{
//					bool bThreeSame=false;
//					for(int j=0;j<tagCardType1.btThreeSame;j++)     //前敦三条
//					{
//						btCardCount1=btCardCount;
//						CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//
//						for(int k=0;k<3;k++)
//						{
//							FrontCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
//						}
//						RemoveCard(FrontCard,3,btCardData1,btCardCount1);
//						btCardCount2=btCardCount1-=3;
//						CopyMemory(MidCard,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//						if(bFirst)
//						{
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//							{
//								bThreeSame=true;
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//								bFirst=false;
//							}
//						}
//						else 
//						{
//							btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//								||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//							{
//								bThreeSame=true;
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								btFrontAllShuiShu=btAllShuiShu;
//							}
//						}
//					}
//					if(bThreeSame==false)                          //前敦不能为三条
//					{
//						for(int j=0;j<tagCardType1.btGourd;j++)     //中敦葫芦
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<5;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbGourd[j*5+k]];
//							}
//							RemoveCard(MidCard,5,btCardData1,btCardCount1);
//							CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//									||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//					}
//
//				}
//				else if(tagCardType1.bFlush)         //有同花
//				{
//					bool bThreeSame=false;
//					if(tagCardType1.bThreeSame)      //有三条
//					{
//						for(int j=0;j<tagCardType1.btThreeSame;j++)     //前敦三条
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//
//							for(int k=0;k<3;k++)
//							{
//								FrontCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
//							}
//							RemoveCard(FrontCard,3,btCardData1,btCardCount1);
//							btCardCount2=btCardCount1-=3;
//							CopyMemory(MidCard,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									bThreeSame=true;
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//									||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//								{
//									bThreeSame=true;
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//					}
//					if(bThreeSame==false)                          //前敦不能为三条
//					{
//						for(int j=0;j<tagCardType1.btFlush;j++)    //中敦同花
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<5;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbFlush[j*5+k]];
//							}
//							RemoveCard(MidCard,5,btCardData1,btCardCount1);
//							CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//									||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//						if(tagCardType1.bStraight)                 //有顺子
//						{
//							for(int j=0;j<tagCardType1.btStraight;j++)    //中敦顺子
//							{
//								btCardCount1=btCardCount;
//								CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//								for(int k=0;k<5;k++)
//								{
//									MidCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
//								}
//								RemoveCard(MidCard,5,btCardData1,btCardCount1);
//								CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
//								if(bFirst)
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//										bFirst=false;
//									}
//								}
//								else 
//								{
//									btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//										||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										btFrontAllShuiShu=btAllShuiShu;
//									}
//								}
//							}
//						}
//						if(tagCardType1.bThreeSame)                //有三条
//						{
//							for(int j=0;j<tagCardType1.btThreeSame;j++)    //中敦三条
//							{
//								btCardCount1=btCardCount;
//								CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//								for(int k=0;k<3;k++)
//								{
//									MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
//								}
//								RemoveCard(MidCard,3,btCardData1,btCardCount1);
//								MidCard[3]=btCardData1[3];
//								MidCard[4]=btCardData1[4];
//								CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
//								if(bFirst)
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//										bFirst=false;
//									}
//								}
//								else 
//								{
//									btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//										||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										btFrontAllShuiShu=btAllShuiShu;
//									}
//								}
//							}
//						}
//					}
//
//				}
//				else if(tagCardType1.bStraight)      //有顺子
//				{
//					bool bThreeSame=false;
//					if(tagCardType1.bThreeSame)      //有三条
//					{
//						for(int j=0;j<tagCardType1.btThreeSame;j++)     //前敦三条
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//
//							for(int k=0;k<3;k++)
//							{
//								FrontCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
//							}
//							RemoveCard(FrontCard,3,btCardData1,btCardCount1);
//							btCardCount2=btCardCount1-=3;
//							CopyMemory(MidCard,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									bThreeSame=true;
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//									||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//								{
//									bThreeSame=true;
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//					}
//					if(bThreeSame==false)                          //前敦不能为三条
//					{
//						for(int j=0;j<tagCardType1.btStraight;j++)    //中敦顺子
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<5;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
//							}
//							RemoveCard(MidCard,5,btCardData1,btCardCount1);
//							CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//									||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//						if(tagCardType1.bThreeSame)                //有三条
//						{
//							for(int j=0;j<tagCardType1.btThreeSame;j++)    //中敦三条
//							{
//								btCardCount1=btCardCount;
//								CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//								for(int k=0;k<3;k++)
//								{
//									MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
//								}
//								RemoveCard(MidCard,3,btCardData1,btCardCount1);
//								MidCard[3]=btCardData1[3];
//								MidCard[4]=btCardData1[4];
//								CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
//								if(bFirst)
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//										bFirst=false;
//									}
//								}
//								else 
//								{
//									btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//										||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										btFrontAllShuiShu=btAllShuiShu;
//									}
//								}
//							}
//						}
//					}
//				}
//				else if(tagCardType1.bThreeSame)     //有三条
//				{
//					for(int j=0;j<tagCardType1.btThreeSame;j++)    //中敦三条
//					{
//						btCardCount1=btCardCount;
//						CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//						for(int k=0;k<3;k++)
//						{
//							MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
//						}
//						RemoveCard(MidCard,3,btCardData1,btCardCount1);
//						MidCard[3]=btCardData1[3];
//						MidCard[4]=btCardData1[4];
//						CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
//						if(bFirst)
//						{
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//								bFirst=false;
//							}
//						}
//						else 
//						{
//							btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//								||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								btFrontAllShuiShu=btAllShuiShu;
//							}
//						}
//					}
//				}
//				else if(tagCardType1.bTwoPare)       //有两对
//				{
//					if(tagCardType1.btOnePare>=3)
//					{
//						btCardCount1=btCardCount;
//						CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//                        btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
//						btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
//						btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
//						btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
//						btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
//						btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
//						RemoveCard(btTemp,6,btCardData1,btCardCount1);
//						FrontCard[2]=btCardData1[0];
//						MidCard[4]=btCardData1[1];
//						if(bFirst)
//						{
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//								bFirst=false;
//							}
//						}
//						else 
//						{
//							btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//								||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								btFrontAllShuiShu=btAllShuiShu;
//							}
//						}
//					}
//					else
//					{
//						for(int j=0;j<tagCardType1.btTwoPare;j++)    //中敦两对
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<4;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
//							}
//							RemoveCard(MidCard,4,btCardData1,btCardCount1);
//							btCardCount2=btCardCount1-=4;
//							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//							tagCardType2=GetType(btCardData2,btCardCount2);
//							if(tagCardType2.bTwoPare)     //剩下两对
//							{
//								MidCard[4]=btCardData2[tagCardType2.cbTwoPare[3]];
//								FrontCard[0]=btCardData2[tagCardType2.cbTwoPare[0]];
//								FrontCard[1]=btCardData2[tagCardType2.cbTwoPare[1]];
//								FrontCard[2]=btCardData2[tagCardType2.cbTwoPare[2]];
//							}
//							else if(tagCardType2.bOnePare) //剩下一对
//							{
//								for(int k=3;k>=0;k--)
//								{
//									if(GetCardLogicValue(btCardData2[k])!=GetCardLogicValue(btCardData2[tagCardType2.cbOnePare[0]]))
//									{
//										btTemp[0]=MidCard[4]=btCardData2[k];
//										break;
//									}
//								}
//								RemoveCard(btTemp,1,btCardData2,btCardCount2);
//								CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
//							}
//							else                           //剩下散牌
//							{
//								MidCard[4]=btCardData2[3];
//								CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
//							}
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//									||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//					}
//					
//				}
//				else if(tagCardType1.bOnePare)       //有一对
//				{
//					for(int j=0;j<tagCardType1.btOnePare;j++)    //中敦一对
//					{
//						btCardCount1=btCardCount;
//						CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//						for(int k=0;k<2;k++)
//						{
//							MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
//						}
//						RemoveCard(MidCard,2,btCardData1,btCardCount1);
//						btCardCount2=btCardCount1-=2;
//						CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//						for(int k=0;k<6;k++)
//						{
//							if(k<3)
//							{
//								FrontCard[k]=btCardData2[k];
//							}
//							else
//							{
//								MidCard[k-1]=btCardData2[k];
//							}
//						}
//						if(bFirst)
//						{
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//								bFirst=false;
//							}
//						}
//						else 
//						{
//							btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//								||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								btFrontAllShuiShu=btAllShuiShu;
//							}
//						}
//					}
//				}
//				else                                 //散牌 
//				{
//					btCardCount1=btCardCount;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//					MidCard[0]=btCardData1[0];
//					MidCard[1]=btCardData1[4];
//					MidCard[2]=btCardData1[5];
//					MidCard[3]=btCardData1[6];
//					MidCard[4]=btCardData1[7];
//
//					FrontCard[0]=btCardData1[1];
//					FrontCard[1]=btCardData1[2];
//					FrontCard[2]=btCardData1[3];
//					if(bFirst)
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//						{
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//							bFirst=false;
//						}
//					}
//					else 
//					{
//						btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//							||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//						{
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							btFrontAllShuiShu=btAllShuiShu;
//						}
//					}
//				}
//			}
//
//		}
//	}
//	else if(tagCardType.bFourSame)   //铁支
//	{ 
//		for(int i=0;i<tagCardType.btFourSame;i++)
//		{
//			CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//			btCardCount=btHandCardCount;
//			for(int j=0;j<4;j++)
//			{
//				BackCard[j]=btCardData[tagCardType.cbFourSame[i*4+j]];
//			}
//			RemoveCard(BackCard,4,btCardData,btCardCount);
//			btCardCount1= btCardCount-=4;
//			CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//			tagCardType1=GetType(btCardData1,btCardCount1);
//			if(tagCardType1.bFourSame)      //有铁支
//			{
//	
//				for(int j=0;j<tagCardType1.btFourSame;j++)
//				{
//					btCardCount1=btCardCount;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//					for(int k=0;k<4;k++)
//					{
//						MidCard[k]=btCardData1[tagCardType1.cbFourSame[j*4+k]];
//					}
//					RemoveCard(MidCard,4,btCardData1,btCardCount1);
//					btCardCount2=btCardCount1-=4;
//					CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//					tagCardType2=GetType(btCardData2,btCardCount2);
//					if(tagCardType2.bFourSame)    //剩下铁支
//					{
//						if(GetCardLogicValue(btCardData2[0])==GetCardLogicValue(btCardData2[1]))
//						{
//							BackCard[4]=btCardData2[4];
//							MidCard[4]=btCardData2[3];
//							CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
//						}
//						else
//						{
//							BackCard[4]=btCardData2[0];
//							MidCard[4]=btCardData2[4];
//							CopyMemory(FrontCard,&btCardData2[1],sizeof(FrontCard));
//						} 
//					}
//					else if(tagCardType2.bGourd)  //剩下葫芦
//					{
//						BackCard[4]=btCardData2[tagCardType2.cbGourd[4]];
//						MidCard[4]=btCardData2[tagCardType2.cbGourd[3]];
//						FrontCard[0]=btCardData2[tagCardType2.cbGourd[0]];
//						FrontCard[1]=btCardData2[tagCardType2.cbGourd[1]];
//						FrontCard[2]=btCardData2[tagCardType2.cbGourd[2]];
//					}
//					else if(tagCardType2.bFlush)  //剩下同花
//					{
//						BackCard[4]=btCardData2[tagCardType2.cbFlush[4]];
//						MidCard[4]=btCardData2[tagCardType2.cbFlush[3]];
//						FrontCard[0]=btCardData2[tagCardType2.cbFlush[0]];
//						FrontCard[1]=btCardData2[tagCardType2.cbFlush[1]];
//						FrontCard[2]=btCardData2[tagCardType2.cbFlush[2]];
//					}
//					else if(tagCardType2.bStraight)  //剩下顺子
//					{
//						BackCard[4]=btCardData2[tagCardType2.cbStraight[4]];
//						MidCard[4]=btCardData2[tagCardType2.cbStraight[3]];
//						FrontCard[0]=btCardData2[tagCardType2.cbStraight[0]];
//						FrontCard[1]=btCardData2[tagCardType2.cbStraight[1]];
//						FrontCard[2]=btCardData2[tagCardType2.cbStraight[2]];
//					}
//					else if(tagCardType2.bThreeSame)  //剩下三条
//					{
//						for(int k=0;k<3;k++)
//						{
//							btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
//						}
//						RemoveCard(btTemp,3,btCardData2,btCardCount2);
//						BackCard[4]=btCardData2[1];
//						MidCard[4]=btCardData2[0];
//					}
//					else if(tagCardType2.bTwoPare)//剩下两对
//					{
//						for(int k=4;k>=0;k--)
//						{
//							if(GetCardLogicValue(btCardData2[k])!=GetCardLogicValue(btCardData2[tagCardType2.cbTwoPare[0]])
//								&&GetCardLogicValue(btCardData2[k])!=GetCardLogicValue(btCardData2[tagCardType2.cbTwoPare[2]]))
//							{
//								btTemp[0]=BackCard[4]=btCardData2[k];
//								break;
//							}
//						}
//						//RemoveCard(btTemp,1,btCardData2,btCardCount2);
//						MidCard[4]=btCardData2[tagCardType2.cbTwoPare[3]];
//						FrontCard[0]=btCardData2[tagCardType2.cbTwoPare[0]];
//						FrontCard[1]=btCardData2[tagCardType2.cbTwoPare[1]];
//						FrontCard[2]=btCardData2[tagCardType2.cbTwoPare[2]];
//					}
//					else if(tagCardType2.bOnePare)//剩下一对
//					{
//						btTemp[0]=FrontCard[0]=btCardData2[tagCardType2.cbOnePare[0]];
//						btTemp[1]=FrontCard[1]=btCardData2[tagCardType2.cbOnePare[1]];
//						RemoveCard(btTemp,2,btCardData2,btCardCount2);
//						FrontCard[2]=btCardData2[0];
//						BackCard[4]=btCardData2[2];
//						MidCard[4]=btCardData2[1];
//					}
//					else                         //剩下散牌        
//					{
//						BackCard[4]=btCardData2[4];
//						MidCard[4]=btCardData2[3];
//						CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
//					}
//					if(bFirst)
//					{
//					
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//						{
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//							bFirst=false;
//						}
//					}
//					else 
//					{
//						btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//							||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//						{
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							btFrontAllShuiShu=btAllShuiShu;
//						}
//					}
//				}
//			}
//			else
//			{
//				if(tagCardType1.bGourd)         //有葫芦
//				{
//					bool bThreeSame=false;
//					for(int j=0;j<tagCardType1.btThreeSame;j++)     //前敦三条
//					{
//						btCardCount1=btCardCount;
//						CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//
//						for(int k=0;k<3;k++)
//						{
//							FrontCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
//						}
//						RemoveCard(FrontCard,3,btCardData1,btCardCount1);
//						btCardCount2=btCardCount1-=3;
//						CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//						tagCardType2=GetType(btCardData2,btCardCount2);
//						if(tagCardType2.bGourd)             //剩下葫芦
//						{
//							for(int k=0;k<5;k++)
//							{
//								btTemp[k]=MidCard[k]=btCardData2[tagCardType2.cbGourd[k]];
//							}
//							RemoveCard(btTemp,5,btCardData2,btCardCount2);
//							BackCard[4]=btCardData2[0];
//						}
//						else if(tagCardType2.bFlush)        //剩下同花
//						{
//							for(int k=0;k<5;k++)
//							{
//								btTemp[k]=MidCard[k]=btCardData2[tagCardType2.cbFlush[k]];
//							}
//							RemoveCard(btTemp,5,btCardData2,btCardCount2);
//							BackCard[4]=btCardData2[0];
//						}
//						else if(tagCardType2.bStraight)     //剩下顺子
//						{
//							for(int k=0;k<5;k++)
//							{
//								btTemp[k]=MidCard[k]=btCardData2[tagCardType2.cbStraight[k]];
//							}
//							RemoveCard(btTemp,5,btCardData2,btCardCount2);
//							BackCard[4]=btCardData2[0];
//						}
//						else if(tagCardType2.bThreeSame)    //剩下三条
//						{
//							for(int k=0;k<3;k++)
//							{
//								btTemp[k]=MidCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
//							}
//							RemoveCard(btTemp,3,btCardData2,btCardCount2);
//							MidCard[3]=btCardData2[0];
//							MidCard[4]=btCardData2[1];
//							BackCard[4]=btCardData2[2];
//						} 
//						else                                //其他
//						{
//							for(int k=0;k<5;k++)
//							{
//								MidCard[k]=btCardData2[k];
//							}
//							BackCard[4]=btCardData2[5];
//						}
//						if(bFirst)
//						{
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//							{
//								bThreeSame=true;
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//								bFirst=false;
//							}
//						}
//						else 
//						{
//							btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//								||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//							{
//								bThreeSame=true;
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								btFrontAllShuiShu=btAllShuiShu;
//							}
//						}
//					}
//					if(bThreeSame==false)                          //前敦不能为三条
//					{
//						for(int j=0;j<tagCardType1.btGourd;j++)     //中敦葫芦
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<5;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbGourd[j*5+k]];
//							}
//							RemoveCard(MidCard,5,btCardData1,btCardCount1);
//							btCardCount2=btCardCount1-=5;
//							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//							tagCardType2=GetType(btCardData2,btCardCount2);
//							if(tagCardType2.bTwoPare)            //剩下两对
//							{
//								BackCard[4]=btCardData2[tagCardType2.cbTwoPare[3]];
//								for(int k=0;k<3;k++)
//								{
//									FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
//								}
//							}
//							else if(tagCardType2.bOnePare)       //剩下一对
//							{
//								for(int k=3;k>=0;k--)
//								{
//									if(GetCardLogicValue(btCardData2[k])!=GetCardLogicValue(btCardData2[tagCardType2.cbOnePare[0]]))
//									{
//										btTemp[0]=BackCard[4]=btCardData2[k];
//										break;
//									}
//								}
//								RemoveCard(btTemp,1,btCardData2,btCardCount2);
//								CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
//							}
//							else                                 //剩下散牌
//							{
//								
//								BackCard[4]=btCardData2[3];
//								CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
//							}
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//									||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//					}
//
//				}
//				else if(tagCardType1.bFlush)         //有同花
//				{
//					bool bThreeSame=false;
//					if(tagCardType1.bThreeSame)      //有三条
//					{
//						for(int j=0;j<tagCardType1.btThreeSame;j++)     //前敦三条
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//
//							for(int k=0;k<3;k++)
//							{
//								FrontCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
//							}
//							RemoveCard(FrontCard,3,btCardData1,btCardCount1);
//							btCardCount2=btCardCount1-=3;
//							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//							tagCardType2=GetType(btCardData2,btCardCount2);
//							if(tagCardType2.bFlush)        //剩下同花
//							{
//								for(int k=0;k<5;k++)
//								{
//									btTemp[k]=MidCard[k]=btCardData2[tagCardType2.cbFlush[k]];
//								}
//								RemoveCard(btTemp,5,btCardData2,btCardCount2);
//								BackCard[4]=btCardData2[0];
//							}
//							else if(tagCardType2.bStraight)     //剩下顺子
//							{
//								for(int k=0;k<5;k++)
//								{
//									btTemp[k]=MidCard[k]=btCardData2[tagCardType2.cbStraight[k]];
//								}
//								RemoveCard(btTemp,5,btCardData2,btCardCount2);
//								BackCard[4]=btCardData2[0];
//							}
//							else                                //其他
//							{
//								for(int k=0;k<5;k++)
//								{
//									MidCard[k]=btCardData2[k];
//								}
//								BackCard[4]=btCardData2[5];
//							}
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									bThreeSame=true;
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//									||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//								{
//									bThreeSame=true;
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//					}
//					if(bThreeSame==false)                          //前敦不能为三条
//					{
//						for(int j=0;j<tagCardType1.btFlush;j++)    //中敦同花
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<5;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbFlush[j*5+k]];
//							}
//							RemoveCard(MidCard,5,btCardData1,btCardCount1);
//							btCardCount2=btCardCount1-=5;
//							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//							tagCardType2=GetType(btCardData2,btCardCount2);
//							if(tagCardType2.bTwoPare)            //剩下两对
//							{
//								BackCard[4]=btCardData2[tagCardType2.cbTwoPare[3]];
//								for(int k=0;k<3;k++)
//								{
//									FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
//								}
//							}
//							else if(tagCardType2.bOnePare)       //剩下一对
//							{
//								for(int k=3;k>=0;k--)
//								{
//									if(GetCardLogicValue(btCardData2[k])!=GetCardLogicValue(btCardData2[tagCardType2.cbOnePare[0]]))
//									{
//										btTemp[0]=BackCard[4]=btCardData2[k];
//										break;
//									}
//								}
//								RemoveCard(btTemp,1,btCardData2,btCardCount2);
//								CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
//							}
//							else                                 //剩下散牌
//							{
//								//这里有问题 zyy
//								BackCard[4]=btCardData2[3];
//								CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
//							}
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//									||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//						if(tagCardType1.bStraight)                 //有顺子
//						{
//							for(int j=0;j<tagCardType1.btStraight;j++)    //中敦顺子
//							{
//								btCardCount1=btCardCount;
//								CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//								for(int k=0;k<5;k++)
//								{
//									MidCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
//								}
//								RemoveCard(MidCard,5,btCardData1,btCardCount1);
//								btCardCount2=btCardCount1-=5;
//								CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//								tagCardType2=GetType(btCardData2,btCardCount2);
//								if(tagCardType2.bTwoPare)            //剩下两对
//								{
//									BackCard[4]=btCardData2[tagCardType2.cbTwoPare[3]];
//									for(int k=0;k<3;k++)
//									{
//										FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
//									}
//								}
//								else if(tagCardType2.bOnePare)       //剩下一对
//								{
//									for(int k=3;k>=0;k--)
//									{
//										if(GetCardLogicValue(btCardData2[k])!=GetCardLogicValue(btCardData2[tagCardType2.cbOnePare[0]]))
//										{
//											btTemp[0]=BackCard[4]=btCardData2[k];
//											break;
//										}
//									}
//									RemoveCard(btTemp,1,btCardData2,btCardCount2);
//									CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
//								}
//								else                                 //剩下散牌
//								{
//									
//									BackCard[4]=btCardData2[3];
//									CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
//								}
//								if(bFirst)
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//										bFirst=false;
//									}
//								}
//								else 
//								{
//									btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//										||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										btFrontAllShuiShu=btAllShuiShu;
//									}
//								}
//							}
//						}
//						if(tagCardType1.bThreeSame)                //有三条
//						{
//							for(int j=0;j<tagCardType1.btThreeSame;j++)    //中敦三条
//							{
//								btCardCount1=btCardCount;
//								CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//								for(int k=0;k<3;k++)
//								{
//									MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
//								}
//								RemoveCard(MidCard,3,btCardData1,btCardCount1);
//								MidCard[3]=btCardData1[3];
//								MidCard[4]=btCardData1[4];
//								btCardCount2=btCardCount1-=5;
//								CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//								//剩下散牌
//								BackCard[4]=btCardData2[3];
//								CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
//								if(bFirst)
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//										bFirst=false;
//									}
//								}
//								else 
//								{
//									btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//										||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										btFrontAllShuiShu=btAllShuiShu;
//									}
//								}
//							}
//						}
//					}
//
//				}
//				else if(tagCardType1.bStraight)      //有顺子
//				{
//					bool bThreeSame=false;
//					if(tagCardType1.bThreeSame)      //有三条
//					{
//						for(int j=0;j<tagCardType1.btThreeSame;j++)     //前敦三条
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//
//							for(int k=0;k<3;k++)
//							{
//								FrontCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
//							}
//							RemoveCard(FrontCard,3,btCardData1,btCardCount1);
//							btCardCount2=btCardCount1-=3;
//							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//							tagCardType2=GetType(btCardData2,btCardCount2);
//							if(tagCardType2.bStraight)     //剩下顺子
//							{
//								for(int k=0;k<5;k++)
//								{
//									btTemp[k]=MidCard[k]=btCardData2[tagCardType2.cbStraight[k]];
//								}
//								RemoveCard(btTemp,5,btCardData2,btCardCount2);
//								BackCard[4]=btCardData2[0];
//							}
//							else                                //其他
//							{
//								for(int k=0;k<5;k++)
//								{
//									MidCard[k]=btCardData2[k];
//								}
//								BackCard[4]=btCardData2[5];
//							}
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									bThreeSame=true;
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//									||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//								{
//									bThreeSame=true;
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//					}
//					if(bThreeSame==false)                          //前敦不能为三条
//					{
//						for(int j=0;j<tagCardType1.btStraight;j++)    //中敦顺子
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<5;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
//							}
//							RemoveCard(MidCard,5,btCardData1,btCardCount1);
//							btCardCount2=btCardCount1-=5;
//							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//							tagCardType2=GetType(btCardData2,btCardCount2);
//							if(tagCardType2.bTwoPare)            //剩下两对
//							{
//								BackCard[4]=btCardData2[tagCardType2.cbTwoPare[3]];
//								for(int k=0;k<3;k++)
//								{
//									FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
//								}
//							}
//							else if(tagCardType2.bOnePare)       //剩下一对
//							{
//								for(int k=3;k>=0;k--)
//								{
//									if(GetCardLogicValue(btCardData2[k])!=GetCardLogicValue(btCardData2[tagCardType2.cbOnePare[0]]))
//									{
//										btTemp[0]=BackCard[4]=btCardData2[k];
//										break;
//									}
//								}
//								RemoveCard(btTemp,1,btCardData2,btCardCount2);
//								CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
//							}
//							else                                 //剩下散牌
//							{
//								BackCard[4]=btCardData2[3];
//								CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
//							}
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//									||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//						if(tagCardType1.bThreeSame)                //有三条
//						{
//							for(int j=0;j<tagCardType1.btThreeSame;j++)    //中敦三条
//							{
//								btCardCount1=btCardCount;
//								CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//								for(int k=0;k<3;k++)
//								{
//									MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
//								}
//								RemoveCard(MidCard,3,btCardData1,btCardCount1);
//								MidCard[3]=btCardData1[3];
//								MidCard[4]=btCardData1[4];
//								btCardCount2=btCardCount1-=5;
//								CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//								//剩下散牌
//								BackCard[4]=btCardData2[3];
//								CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
//								if(bFirst)
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//										bFirst=false;
//									}
//								}
//								else 
//								{
//									btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//										||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										btFrontAllShuiShu=btAllShuiShu;
//									}
//								}
//							}
//						}
//					}
//				}
//				else if(tagCardType1.bThreeSame)     //有三条
//				{
//					for(int j=0;j<tagCardType1.btThreeSame;j++)    //中敦三条
//					{
//						btCardCount1=btCardCount;
//						CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//						for(int k=0;k<3;k++)
//						{
//							MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
//						}
//						RemoveCard(MidCard,3,btCardData1,btCardCount1);
//						MidCard[3]=btCardData1[3];
//						MidCard[4]=btCardData1[4];
//						BackCard[4]=btCardData1[5];
//						CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
//						if(bFirst)
//						{
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//								bFirst=false;
//							}
//						}
//						else 
//						{
//							btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//								||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								btFrontAllShuiShu=btAllShuiShu;
//							}
//						}
//					}
//				}
//				else if(tagCardType1.bTwoPare)       //有两对
//				{
//					if(tagCardType1.btOnePare>=3)
//					{
//						btCardCount1=btCardCount;
//						CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//						btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
//						btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
//						btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
//						btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
//						btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
//						btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
//						RemoveCard(btTemp,6,btCardData1,btCardCount1);
//						FrontCard[2]=btCardData1[0];
//						MidCard[4]=btCardData1[1];
//						BackCard[4]=btCardData1[2];
//						if(bFirst)
//						{
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//								bFirst=false;
//							}
//						}
//						else 
//						{
//							btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//								||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								btFrontAllShuiShu=btAllShuiShu;
//							}
//						}
//					}
//					else
//					{
//						for(int j=0;j<tagCardType1.btTwoPare;j++)    //中敦两对
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<4;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
//							}
//							RemoveCard(MidCard,4,btCardData1,btCardCount1);
//							btCardCount2=btCardCount1-=4;
//							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//							tagCardType2=GetType(btCardData2,btCardCount2);
//							if(tagCardType2.bTwoPare)     //剩下两对
//							{
//								btTemp[0]=MidCard[4]=btCardData2[tagCardType2.cbTwoPare[3]];
//								btTemp[1]=FrontCard[0]=btCardData2[tagCardType2.cbTwoPare[0]];
//								btTemp[2]=FrontCard[1]=btCardData2[tagCardType2.cbTwoPare[1]];
//								btTemp[3]=FrontCard[2]=btCardData2[tagCardType2.cbTwoPare[2]];
//								RemoveCard(btTemp,4,btCardData2,btCardCount2);
//								BackCard[4]=btCardData2[0];
//							}
//							else if(tagCardType2.bOnePare) //剩下一对
//							{
//								btTemp[0]=FrontCard[0]=btCardData2[tagCardType2.cbOnePare[0]];
//								btTemp[1]=FrontCard[1]=btCardData2[tagCardType2.cbOnePare[1]];
//								RemoveCard(btTemp,2,btCardData2,btCardCount2);
//								FrontCard[2]=btCardData2[0];
//								MidCard[4]=btCardData2[1];
//								BackCard[4]=btCardData2[2];
//							}
//							else                           //剩下散牌
//							{
//								BackCard[4]=btCardData2[4];
//								MidCard[4]=btCardData2[3];
//								CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
//							}
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//									||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//					}
//					
//				}
//				else if(tagCardType1.bOnePare)       //有一对
//				{
//					for(int j=0;j<tagCardType1.btOnePare;j++)    //中敦一对
//					{
//						btCardCount1=btCardCount;
//						CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//						for(int k=0;k<2;k++)
//						{
//							MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
//						}
//						RemoveCard(MidCard,2,btCardData1,btCardCount1);
//						btCardCount2=btCardCount1-=2;
//						CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//						BackCard[4]=btCardData2[6];
//						MidCard[2]=btCardData2[5];
//						MidCard[3]=btCardData2[4];
//						MidCard[4]=btCardData2[3];
//						CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
//						if(bFirst)
//						{
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//								bFirst=false;
//							}
//						}
//						else 
//						{
//							btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//								||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								btFrontAllShuiShu=btAllShuiShu;
//							}
//						}
//					}
//				}
//				else                                 //散牌 
//				{
//					btCardCount1=btCardCount;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//					BackCard[4]=btCardData1[8];
//					MidCard[0]=btCardData1[0];
//					MidCard[1]=btCardData1[4];
//					MidCard[2]=btCardData1[5];
//					MidCard[3]=btCardData1[6];
//					MidCard[4]=btCardData1[7];
//
//					FrontCard[0]=btCardData1[1];
//					FrontCard[1]=btCardData1[2];
//					FrontCard[2]=btCardData1[3];
//					if(bFirst)
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//						{
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//							bFirst=false;
//						}
//					}
//					else 
//					{
//						btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
//							||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
//						{
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							btFrontAllShuiShu=btAllShuiShu;
//						}
//					}
//				}
//			}
//
//		}
//	}
//
//	else if(tagCardType.bGourd)      //有葫芦
//	{
//		bool bThreeSame=false;
//		for(int i=0;i<tagCardType.btThreeSame;i++)
//		{
//			CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//			btCardCount=btHandCardCount;
//			for(int j=0;j<3;j++)
//			{
//				FrontCard[j]=btCardData[tagCardType.cbThreeSame[i*3+j]];
//			}
//			RemoveCard(FrontCard,3,btCardData,btCardCount);
//			btCardCount1=btCardCount-=3;
//			CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//			tagCardType1=GetType(btCardData1,btCardCount1);
//			if(tagCardType1.bGourd)    //有葫芦
//			{
//				for(int j=0;j<tagCardType1.btGourd;j++)
//				{
//					btCardCount1=btCardCount;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);  
//					for(int k=0;k<5;k++)
//					{
//						BackCard[k]=btCardData1[tagCardType1.cbGourd[j*5+k]];
//					}
//					RemoveCard(BackCard,5,btCardData1,btCardCount1);
//					CopyMemory(MidCard,btCardData1,sizeof(MidCard));
//					if(bFirst)
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//						{
//							bThreeSame=true;
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							bFirst=false;
//						}
//					}
//					else 
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//							IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//						{
//							bThreeSame=true;
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							btFrontAllShuiShu=btAllShuiShu;
//						}
//					}
//				}
//			}
//			if(tagCardType1.bFlush)    //有同花
//			{
//				for(int j=0;j<tagCardType1.btFlush;j++)
//				{
//					btCardCount1=btCardCount;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);  
//					for(int k=0;k<5;k++)
//					{
//						BackCard[k]=btCardData1[tagCardType1.cbFlush[j*5+k]];
//					}
//					RemoveCard(BackCard,5,btCardData1,btCardCount1);
//					CopyMemory(MidCard,btCardData1,sizeof(MidCard));
//					if(bFirst)
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//						{
//							bThreeSame=true;
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							bFirst=false;
//						}
//					}
//					else 
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//							IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//						{
//							bThreeSame=true;
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							btFrontAllShuiShu=btAllShuiShu;
//						}
//					}
//				}
//			}
//			if(tagCardType1.bStraight)  //有顺子
//			{
//				for(int j=0;j<tagCardType1.btStraight;j++)
//				{
//					btCardCount1=btCardCount;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);  
//					for(int k=0;k<5;k++)
//					{
//						BackCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
//					}
//					RemoveCard(BackCard,5,btCardData1,btCardCount1);
//					CopyMemory(MidCard,btCardData1,sizeof(MidCard));
//					if(bFirst)
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//						{
//							bThreeSame=true;
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							bFirst=false;
//						}
//					}
//					else 
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//							IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//						{
//							bThreeSame=true;
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							btFrontAllShuiShu=btAllShuiShu;
//						}
//					}
//				}
//			}
//			if(tagCardType1.bThreeSame) //有三条
//			{
//				for(int j=0;j<tagCardType1.btThreeSame;j++)
//				{
//					btCardCount1=btCardCount;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);  
//					for(int k=0;k<3;k++)
//					{
//						BackCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
//					}
//					RemoveCard(BackCard,3,btCardData1,btCardCount1);
//					btCardCount2=btCardCount1-=3;
//					CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//					tagCardType2=GetType(btCardData2,btCardCount2);
//					if(tagCardType2.bThreeSame)
//					{
//						for(int k=0;k<tagCardType2.btThreeSame;k++)
//						{
//							for(int m=0;m<3;m++)
//							{
//								MidCard[m]=btCardData2[tagCardType2.cbThreeSame[k*3+m]];
//							}
//							RemoveCard(MidCard,3,btCardData2,btCardCount2);
//							BackCard[3]=btCardData2[2];
//							BackCard[4]=btCardData2[3];
//							MidCard[3]=btCardData2[0];
//							MidCard[4]=btCardData2[1];
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									bThreeSame=true;
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									bThreeSame=true;
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//					}
//				}
//			}
//		}
//		if(bThreeSame==false)
//		{
// 			for(int i=0;i<tagCardType.btGourd;i++)            //第三敦为葫芦
// 			{
// 				CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
// 				btCardCount=btHandCardCount;
// 				for(int j=0;j<5;j++)                        
// 				{
// 					BackCard[j]=btCardData[tagCardType.cbGourd[i*5+j]];
// 				}
// 				RemoveCard(BackCard,5,btCardData,btCardCount);
// 				btCardCount1=btCardCount-=5;
// 				CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 				tagCardType1=GetType(btCardData1,btCardCount1);
// 				if(tagCardType1.bGourd)        //剩下葫芦
// 				{
// 					for(int j=0;j<tagCardType1.btGourd;j++)
// 					{
// 						btCardCount1=btCardCount;
// 						CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 						for(int k=0;k<5;k++)
// 						{
// 							MidCard[k]=btCardData1[tagCardType1.cbGourd[j*5+k]];
// 						}
// 						RemoveCard(MidCard,5,btCardData1,btCardCount1);
// 						CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
// 						if(bFirst)
// 						{
// 							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
// 							{
// 								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 								bFirst=false;
// 							}
// 						}
// 						else 
// 						{
// 							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
// 								IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
// 							{
// 								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 							}
// 						}
// 					}
// 				}
// 				if(tagCardType1.bFlush)        //剩下同花
// 				{
// 					for(int j=0;j<tagCardType1.btFlush;j++)
// 					{
// 						btCardCount1=btCardCount;
// 						CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 						for(int k=0;k<5;k++)
// 						{
// 							MidCard[k]=btCardData1[tagCardType1.cbFlush[j*5+k]];
// 						}
// 						RemoveCard(MidCard,5,btCardData1,btCardCount1);
// 						CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
// 						if(bFirst)
// 						{
// 							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
// 							{
// 								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 								bFirst=false;
// 							}
// 						}
// 						else 
// 						{
// 							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
// 								IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
// 							{
// 								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 							}
// 						}
// 					}
// 				}
// 				if(tagCardType1.bStraight)     //剩下顺子
// 				{
// 					for(int j=0;j<tagCardType1.btStraight;j++)
// 					{
// 						btCardCount1=btCardCount;
// 						CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 						for(int k=0;k<5;k++)
// 						{
// 							MidCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
// 						}
// 						RemoveCard(MidCard,5,btCardData1,btCardCount1);
// 						CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
// 						if(bFirst)
// 						{
// 							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
// 							{
// 								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 								bFirst=false;
// 							}
// 						}
// 						else 
// 						{
// 							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
// 								IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
// 							{
// 								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 							}
// 						}
// 					}
// 				}
// 				if(tagCardType1.bThreeSame)    //剩下三条
// 				{
// 					for(int j=0;j<tagCardType1.btThreeSame;j++)
// 					{
// 						btCardCount1=btCardCount;
// 						CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 						for(int k=0;k<3;k++)
// 						{
// 							MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
// 						}
// 						RemoveCard(MidCard,3,btCardData1,btCardCount1);
// 						btCardCount2=btCardCount1-=3;
// 						CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
// 						tagCardType2=GetType(btCardData2,btCardCount2);
// 						if(tagCardType2.bThreeSame)  //三条
// 						{
// 							for(int k=0;k<3;k++)
// 							{
// 								FrontCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
// 							}
// 							RemoveCard(FrontCard,3,btCardData2,btCardCount2);
// 							MidCard[3]=btCardData2[0];
// 							MidCard[4]=btCardData2[1];
// 						}
// 						else if(tagCardType2.bTwoPare)  //两对
// 						{
// 							for(int k=0;k<4;k++)
// 							{
// 								if(k<2)
// 								{
// 									btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
// 								}
// 								else 
// 								{
// 									btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
// 								}
// 							}
// 							RemoveCard(btTemp,4,btCardData2,btCardCount2);
// 							FrontCard[2]=btCardData2[0];
// 						}
// 						else if(tagCardType2.bOnePare)  //一对
// 						{
// 							for(int k=0;k<2;k++)
// 							{
// 								btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
// 							}
// 							RemoveCard(btTemp,2,btCardData2,btCardCount2);
// 							FrontCard[2]=btCardData2[0];
// 							MidCard[3]=btCardData2[1];
// 							MidCard[4]=btCardData2[2];
// 						}
// 						else                            //散牌
// 						{
// 							for(int k=0;k<5;k++)
// 							{
// 								if(k<3)
// 								{
// 									FrontCard[k]=btCardData2[k];
// 								}
// 								else
// 								{
// 									MidCard[k]=btCardData2[k];
// 								}
// 							}
// 						}
// 						if(bFirst)
// 						{
// 							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
// 							{
// 								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 								bFirst=false;
// 							}
// 						}
// 						else 
// 						{
// 							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
// 								IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
// 							{
// 								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 							}
// 						}
// 					}
// 				}
//  				if(tagCardType1.bTwoPare)      //剩下两对
// 				{
//					if(tagCardType1.btOnePare>=3)
//					{
//						btCardCount1=btCardCount;
//						CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//						btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
//						btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
//						btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
//						btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
//						btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
//						btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
//						RemoveCard(btTemp,6,btCardData1,btCardCount1);
//						FrontCard[2]=btCardData1[0];
//						MidCard[4]=btCardData1[1];
//						if(bFirst)
//						{
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//								bFirst=false;
//							}
//						}
//						else 
//						{
//							btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//								IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								btFrontAllShuiShu=btAllShuiShu;
//							}
//						}
//					}
//					else
//					{
//						for(int j=0;j<tagCardType1.btTwoPare;j++)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<4;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
//							}
//							RemoveCard(MidCard,4,btCardData1,btCardCount1);
//							btCardCount2=btCardCount1-=4;
//							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//							tagCardType2=GetType(btCardData2,btCardCount2);
//							if(tagCardType2.bTwoPare)  //两对
//							{
//								for(int k=0;k<4;k++)
//								{
//									if(k<3)
//									{
//										FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
//									}
//									else 
//									{
//										MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
//									}
//								}
//							}
//							else if(tagCardType2.bOnePare)  //一对
//							{
//								for(int k=0;k<2;k++)
//								{
//									btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//								}
//								RemoveCard(btTemp,2,btCardData2,btCardCount2);
//								FrontCard[2]=btCardData2[0];
//								MidCard[4]=btCardData2[1];
//							}
//							else                            //散牌
//							{
//								for(int k=0;k<4;k++)
//								{
//									if(k<3)
//									{
//										FrontCard[k]=btCardData2[k];
//									}
//									else
//									{
//										MidCard[k+1]=btCardData2[k];
//									}
//								}
//							}
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//					}
// 					
// 				}
// 				if(tagCardType1.bOnePare)      //剩下一对
// 				{
// 					for(int j=0;j<tagCardType1.btOnePare;j++)
// 					{
// 						btCardCount1=btCardCount;
// 						CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 						for(int k=0;k<2;k++)
// 						{
// 							MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
// 						}
// 						RemoveCard(MidCard,2,btCardData1,btCardCount1);
// 						btCardCount2=btCardCount1-=2;
// 						CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
// 						tagCardType2=GetType(btCardData2,btCardCount2);
// 						if(tagCardType2.bOnePare)  //一对
// 						{
// 							for(int k=0;k<2;k++)
// 							{
// 								btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
// 							}
// 							RemoveCard(btTemp,2,btCardData2,btCardCount2);
// 							FrontCard[2]=btCardData2[0];
// 							MidCard[2]=btCardData2[1];
// 							MidCard[3]=btCardData2[2];
// 							MidCard[4]=btCardData2[3];
// 						}
// 						else                            //散牌
// 						{
// 							for(int k=0;k<6;k++)
// 							{
// 								if(k<3)
// 								{
// 									FrontCard[k]=btCardData2[k];
// 								}
// 								else
// 								{
// 									MidCard[k-1]=btCardData2[k];
// 								}
// 							}
// 						}
// 						if(bFirst)
// 						{
// 							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
// 							{
// 								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 								bFirst=false;
// 							}
// 						}
// 						else 
// 						{
// 							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
// 								IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
// 							{
// 								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 							}
// 						}
// 					}
// 				}
// 				//散牌
// 				btCardCount1=btCardCount;
// 				CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 				MidCard[0]=btCardData1[0];
// 				MidCard[1]=btCardData1[4];
// 				MidCard[2]=btCardData1[5];
// 				MidCard[3]=btCardData1[6];
// 				MidCard[4]=btCardData1[7];
// 				FrontCard[0]=btCardData1[1];
// 				FrontCard[1]=btCardData1[2];
// 				FrontCard[2]=btCardData1[3];                                  
// 				if(bFirst)
// 				{
// 					if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
// 					{
// 						CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 						CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 						CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 						bFirst=false;
// 					}
// 				}
// 				else 
// 				{
// 					if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
// 						IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
// 					{
// 						CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 						CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 						CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 					}
// 				}
// 			}
//			if(tagCardType.bFlush)       //第三敦为同花
//			{
//				for(int i=0;i<tagCardType.btFlush;i++)            
//				{
//					CopyMemory(btCardData,btHandCardData,sizeof(btCardData));        
//					btCardCount=btHandCardCount;
//					for(int j=0;j<5;j++)                        
//					{
//						BackCard[j]=btCardData[tagCardType.cbFlush[i*5+j]];
//					}
//					RemoveCard(BackCard,5,btCardData,btCardCount);
//					btCardCount1=btCardCount-=5;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//					tagCardType1=GetType(btCardData1,btCardCount1);
//					if(tagCardType1.bFlush)        //剩下同花
//					{
//						for(int j=0;j<tagCardType1.btFlush;j++)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<5;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbFlush[j*5+k]];
//							}
//							RemoveCard(MidCard,5,btCardData1,btCardCount1);
//							CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//					}
//					else if(tagCardType1.bStraight)     //剩下顺子
//					{
//						for(int j=0;j<tagCardType1.btStraight;j++)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<5;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
//							}
//							RemoveCard(MidCard,5,btCardData1,btCardCount1);
//							CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//					}
//					else if(tagCardType1.bThreeSame)    //剩下三条
//					{
//						for(int j=0;j<tagCardType1.btThreeSame;j++)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<3;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
//							}
//							RemoveCard(MidCard,3,btCardData1,btCardCount1);
//							btCardCount2=btCardCount1-=3;
//							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//							tagCardType2=GetType(btCardData2,btCardCount2);
//							if(tagCardType2.bThreeSame)  //三条
//							{
//								for(int k=0;k<3;k++)
//								{
//									FrontCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
//								}
//								RemoveCard(FrontCard,3,btCardData2,btCardCount2);
//								MidCard[3]=btCardData2[0];
//								MidCard[4]=btCardData2[1];
//							}
//							else if(tagCardType2.bTwoPare)  //两对
//							{
//								for(int k=0;k<4;k++)
//								{
//									if(k<2)
//									{
//										btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
//									}
//									else 
//									{
//										btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
//									}
//								}
//								RemoveCard(btTemp,4,btCardData2,btCardCount2);
//								FrontCard[2]=btCardData2[0];
//							}
//							else if(tagCardType2.bOnePare)  //一对
//							{
//								for(int k=0;k<2;k++)
//								{
//									btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//								}
//								RemoveCard(btTemp,2,btCardData2,btCardCount2);
//								FrontCard[2]=btCardData2[0];
//								MidCard[3]=btCardData2[1];
//								MidCard[4]=btCardData2[2];
//							}
//							else                            //散牌
//							{
//								for(int k=0;k<5;k++)
//								{
//									if(k<3)
//									{
//										FrontCard[k]=btCardData2[k];
//									}
//									else
//									{
//										MidCard[k]=btCardData2[k];
//									}
//								}
//							}
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//					}
//					else if(tagCardType1.bTwoPare)      //剩下两对
//					{
//						if(tagCardType1.btOnePare>=3)							
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
//							btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
//							btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
//							btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
//							btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
//							btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
//							RemoveCard(btTemp,6,btCardData1,btCardCount1);
//							FrontCard[2]=btCardData1[0];
//							MidCard[4]=btCardData1[1];
//
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//						else
//						{
//							for(int j=0;j<tagCardType1.btTwoPare;j++)
//							{
//								btCardCount1=btCardCount;
//								CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//								for(int k=0;k<4;k++)
//								{
//									MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
//								}
//								RemoveCard(MidCard,4,btCardData1,btCardCount1);
//								btCardCount2=btCardCount1-=4;
//								CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//								tagCardType2=GetType(btCardData2,btCardCount2);
//								if(tagCardType2.bTwoPare)  //两对
//								{
//									for(int k=0;k<4;k++)
//									{
//										if(k<3)
//										{
//											FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
//										}
//										else 
//										{
//											MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
//										}
//									}
//								}
//								else if(tagCardType2.bOnePare)  //一对
//								{
//									for(int k=0;k<2;k++)
//									{
//										btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//									}
//									RemoveCard(btTemp,2,btCardData2,btCardCount2);
//									FrontCard[2]=btCardData2[0];
//									MidCard[4]=btCardData2[1];
//								}
//								else                            //散牌
//								{
//									for(int k=0;k<4;k++)
//									{
//										if(k<3)
//										{
//											FrontCard[k]=btCardData2[k];
//										}
//										else
//										{
//											MidCard[k+1]=btCardData2[k];
//										}
//									}
//								}
//								if(bFirst)
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										bFirst=false;
//									}
//								}
//								else 
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//										IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									}
//								}
//							}
//						}
//						
//					}
//					else if(tagCardType1.bOnePare)      //剩下一对
//					{
//						for(int j=0;j<tagCardType1.btOnePare;j++)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<2;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
//							}
//							RemoveCard(MidCard,2,btCardData1,btCardCount1);
//							btCardCount2=btCardCount1-=2;
//							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//							tagCardType2=GetType(btCardData2,btCardCount2);
//							if(tagCardType2.bOnePare)  //一对
//							{
//								for(int k=0;k<2;k++)
//								{
//									btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//								}
//								RemoveCard(btTemp,2,btCardData2,btCardCount2);
//								FrontCard[2]=btCardData2[0];
//								MidCard[2]=btCardData2[1];
//								MidCard[3]=btCardData2[2];
//								MidCard[4]=btCardData2[3];
//							}
//							else                            //散牌
//							{
//								for(int k=0;k<6;k++)
//								{
//									if(k<3)
//									{
//										FrontCard[k]=btCardData2[k];
//									}
//									else
//									{
//										MidCard[k-1]=btCardData2[k];
//									}
//								}
//							}
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//					}
//					//散牌
//					btCardCount1=btCardCount;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//					MidCard[0]=btCardData1[0];
//					MidCard[1]=btCardData1[4];
//					MidCard[2]=btCardData1[5];
//					MidCard[3]=btCardData1[6];
//					MidCard[4]=btCardData1[7];
//					FrontCard[0]=btCardData1[1];
//					FrontCard[1]=btCardData1[2];
//					FrontCard[2]=btCardData1[3];
//					if(bFirst)
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//						{
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							bFirst=false;
//						}
//					}
//					else 
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//							IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//						{
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//						}
//					}
//				}
//			}
//			if(tagCardType.bStraight)     //第三敦为顺子
//			{
//				for(int i=0;i<tagCardType.btStraight;i++)           
//				{
//					CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//					btCardCount=btHandCardCount;
//					for(int j=0;j<5;j++)                        
//					{
//						BackCard[j]=btCardData[tagCardType.cbStraight[i*5+j]];
//					}
//					RemoveCard(BackCard,5,btCardData,btCardCount);
//					btCardCount1=btCardCount-=5;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//					tagCardType1=GetType(btCardData1,btCardCount1);
//					if(tagCardType1.bStraight)     //剩下顺子
//					{
//						for(int j=0;j<tagCardType1.btStraight;j++)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<5;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
//							}
//							RemoveCard(MidCard,5,btCardData1,btCardCount1);
//							CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//					}
//					else if(tagCardType1.bThreeSame)    //剩下三条
//					{
//						for(int j=0;j<tagCardType1.btThreeSame;j++)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<3;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
//							}
//							RemoveCard(MidCard,3,btCardData1,btCardCount1);
//							btCardCount2=btCardCount1-=3;
//							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//							tagCardType2=GetType(btCardData2,btCardCount2);
//							if(tagCardType2.bThreeSame)  //三条
//							{
//								for(int k=0;k<3;k++)
//								{
//									FrontCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
//								}
//								RemoveCard(FrontCard,3,btCardData2,btCardCount2);
//								MidCard[3]=btCardData2[0];
//								MidCard[4]=btCardData2[1];
//							}
//							else if(tagCardType2.bTwoPare)  //两对
//							{
//								for(int k=0;k<4;k++)
//								{
//									if(k<2)
//									{
//										btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
//									}
//									else 
//									{
//										btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
//									}
//								}
//								RemoveCard(btTemp,4,btCardData2,btCardCount2);
//								FrontCard[2]=btCardData2[0];
//							}
//							else if(tagCardType2.bOnePare)  //一对
//							{
//								for(int k=0;k<2;k++)
//								{
//									btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//								}
//								RemoveCard(btTemp,2,btCardData2,btCardCount2);
//								FrontCard[2]=btCardData2[0];
//								MidCard[3]=btCardData2[1];
//								MidCard[4]=btCardData2[2];
//							}
//							else                            //散牌
//							{
//								for(int k=0;k<5;k++)
//								{
//									if(k<3)
//									{
//										FrontCard[k]=btCardData2[k];
//									}
//									else
//									{
//										MidCard[k]=btCardData2[k];
//									}
//								}
//							}
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//					}
//					else if(tagCardType1.bTwoPare)      //剩下两对
//					{
//						if(tagCardType1.btOnePare>=3)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
//							btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
//							btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
//							btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
//							btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
//							btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
//							RemoveCard(btTemp,6,btCardData1,btCardCount1);
//							FrontCard[2]=btCardData1[0];
//							MidCard[4]=btCardData1[1];
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//						else
//						{
//							for(int j=0;j<tagCardType1.btTwoPare;j++)
//							{
//								btCardCount1=btCardCount;
//								CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//								for(int k=0;k<4;k++)
//								{
//									MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
//								}
//								RemoveCard(MidCard,4,btCardData1,btCardCount1);
//								btCardCount2=btCardCount1-=4;
//								CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//								tagCardType2=GetType(btCardData2,btCardCount2);
//								if(tagCardType2.bTwoPare)  //两对
//								{
//									for(int k=0;k<4;k++)
//									{
//										if(k<3)
//										{
//											FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
//										}
//										else 
//										{
//											MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
//										}
//									}
//								}
//								else if(tagCardType2.bOnePare)  //一对
//								{
//									for(int k=0;k<2;k++)
//									{
//										btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//									}
//									RemoveCard(btTemp,2,btCardData2,btCardCount2);
//									FrontCard[2]=btCardData2[0];
//									MidCard[4]=btCardData2[1];
//								}
//								else                            //散牌
//								{
//									for(int k=0;k<4;k++)
//									{
//										if(k<3)
//										{
//											FrontCard[k]=btCardData2[k];
//										}
//										else
//										{
//											MidCard[k+1]=btCardData2[k];
//										}
//									}
//								}
//								if(bFirst)
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										bFirst=false;
//									}
//								}
//								else 
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//										IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									}
//								}
//							}
//						}
//						
//					}
//					else if(tagCardType1.bOnePare)      //剩下一对
//					{
//						for(int j=0;j<tagCardType1.btOnePare;j++)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<2;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
//							}
//							RemoveCard(MidCard,2,btCardData1,btCardCount1);
//							btCardCount2=btCardCount1-=2;
//							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//							tagCardType2=GetType(btCardData2,btCardCount2);
//							if(tagCardType2.bOnePare)  //一对
//							{
//								for(int k=0;k<2;k++)
//								{
//									btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//								}
//								RemoveCard(btTemp,2,btCardData2,btCardCount2);
//								FrontCard[2]=btCardData2[0];
//								MidCard[2]=btCardData2[1];
//								MidCard[3]=btCardData2[2];
//								MidCard[4]=btCardData2[3];
//							}
//							else                            //散牌
//							{
//								for(int k=0;k<6;k++)
//								{
//									if(k<3)
//									{
//										FrontCard[k]=btCardData2[k];
//									}
//									else
//									{
//										MidCard[k-1]=btCardData2[k];
//									}
//								}
//							}
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//					}
//					//散牌
//					btCardCount1=btCardCount;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//					MidCard[0]=btCardData1[0];
//					MidCard[1]=btCardData1[4];
//					MidCard[2]=btCardData1[5];
//					MidCard[3]=btCardData1[6];
//					MidCard[4]=btCardData1[7];
//					FrontCard[0]=btCardData1[1];
//					FrontCard[1]=btCardData1[2];
//					FrontCard[2]=btCardData1[3];
//					if(bFirst)
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//						{
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							bFirst=false;
//						}
//					}
//					else 
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//							IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//						{
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//						}
//					}
//				}
//			}
// 			if(tagCardType.bThreeSame)    //第三敦为三条
// 			{
// 				for(int i=0;i<tagCardType.btThreeSame;i++)            
// 				{
// 					CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
// 					btCardCount=btHandCardCount;
// 					for(int j=0;j<3;j++)                        
// 					{
// 						BackCard[j]=btCardData[tagCardType.cbThreeSame[i*3+j]];
// 					}
// 					RemoveCard(BackCard,3,btCardData,btCardCount);
// 					btCardCount1=btCardCount-=3;
// 					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 					tagCardType1=GetType(btCardData1,btCardCount1);
// 					if(tagCardType1.bThreeSame)    //剩下三条
// 					{
// 						for(int j=0;j<tagCardType1.btThreeSame;j++)
// 						{
// 							btCardCount1=btCardCount;
// 							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 							for(int k=0;k<3;k++)
// 							{
// 								MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
// 							}
// 							RemoveCard(MidCard,3,btCardData1,btCardCount1);
// 							btCardCount2=btCardCount1-=3;
// 							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
// 							tagCardType2=GetType(btCardData2,btCardCount2);
// 							if(tagCardType2.bThreeSame)  //三条
// 							{
// 								for(int k=0;k<3;k++)
// 								{
// 									FrontCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
// 								}
// 								RemoveCard(FrontCard,3,btCardData2,btCardCount2);
// 								MidCard[3]=btCardData2[0];
// 								MidCard[4]=btCardData2[1];
// 								BackCard[3]=btCardData2[2];
// 								BackCard[4]=btCardData2[3];
// 							}
// 							else if(tagCardType2.bTwoPare)  //两对
// 							{
// 								for(int k=0;k<4;k++)
// 								{
// 									if(k<2)
// 									{
// 										btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
// 									}
// 									else 
// 									{
// 										btTemp[k]=BackCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
// 									}
// 								}
// 								RemoveCard(btTemp,4,btCardData2,btCardCount2);
// 								FrontCard[2]=btCardData2[0];
// 								MidCard[3]=btCardData2[1];
// 								MidCard[4]=btCardData2[2];
// 							}
// 							else if(tagCardType2.bOnePare)  //一对
// 							{
// 								for(int k=0;k<2;k++)
// 								{
// 									btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
// 								}
// 								RemoveCard(btTemp,2,btCardData2,btCardCount2);
// 								FrontCard[2]=btCardData2[0];
// 								MidCard[3]=btCardData2[1];
// 								MidCard[4]=btCardData2[2];
// 								BackCard[3]=btCardData2[3];
// 								BackCard[4]=btCardData2[4];
// 							}
// 							else                            //散牌
// 							{
// 								FrontCard[0]=btCardData2[0];
// 								FrontCard[1]=btCardData2[1];
// 								FrontCard[2]=btCardData2[2];
// 								MidCard[3]=btCardData2[3];
// 								MidCard[4]=btCardData2[4];
// 								BackCard[3]=btCardData2[5];
// 								BackCard[4]=btCardData2[6];
// 							}
// 							if(bFirst)
// 							{
// 								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
// 								{
// 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 									bFirst=false;
// 								}
// 							}
// 							else 
// 							{
// 								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
// 									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
// 								{
// 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 								}
// 							}
// 						}
// 					}
// 					else if(tagCardType1.bTwoPare)      //剩下两对
// 					{
//						if(tagCardType1.btOnePare>=3)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
//							btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
//							btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
//							btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
//							btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
//							btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
//							RemoveCard(btTemp,6,btCardData1,btCardCount1);
//							FrontCard[2]=btCardData1[0];
//							MidCard[4]=btCardData1[1];
//							BackCard[3]=btCardData1[2];
//							BackCard[4]=btCardData1[3];
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//						else
//						{
//							for(int j=0;j<tagCardType1.btTwoPare;j++)
//							{
//								btCardCount1=btCardCount;
//								CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//								for(int k=0;k<4;k++)
//								{
//									MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
//								}
//								RemoveCard(MidCard,4,btCardData1,btCardCount1);
//								btCardCount2=btCardCount1-=4;
//								CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//								tagCardType2=GetType(btCardData2,btCardCount2);
//								if(tagCardType2.bTwoPare)  //两对
//								{
//									for(int k=0;k<4;k++)
//									{
//										if(k<3)
//										{
//											btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
//										}
//										else 
//										{
//											btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
//										}
//									}
//									RemoveCard(btTemp,4,btCardData2,btCardCount2);
//									BackCard[3]=btCardData2[0];
//									BackCard[4]=btCardData2[1];
//								}
//								else if(tagCardType2.bOnePare)  //一对
//								{
//									for(int k=0;k<2;k++)
//									{
//										btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//									}
//									RemoveCard(btTemp,2,btCardData2,btCardCount2);
//									FrontCard[2]=btCardData2[0];
//									MidCard[4]=btCardData2[1];
//									BackCard[3]=btCardData2[2];
//									BackCard[4]=btCardData2[3];
//								}
//								else                            //散牌
//								{
//									FrontCard[0]=btCardData2[0];
//									FrontCard[1]=btCardData2[1];
//									FrontCard[2]=btCardData2[2];
//									MidCard[4]=btCardData2[3];
//									BackCard[3]=btCardData2[4];
//									BackCard[4]=btCardData2[5];
//								}
//								if(bFirst)
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										bFirst=false;
//									}
//								}
//								else 
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//										IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									}
//								}
//							}
//						}
// 						
// 					}
// 					else if(tagCardType1.bOnePare)      //剩下一对
// 					{
// 						for(int j=0;j<tagCardType1.btOnePare;j++)
// 						{
// 							btCardCount1=btCardCount;
// 							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 							for(int k=0;k<2;k++)
// 							{
// 								MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
// 							}
// 							RemoveCard(MidCard,2,btCardData1,btCardCount1);
// 							btCardCount2=btCardCount1-=2;
// 							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
// 							tagCardType2=GetType(btCardData2,btCardCount2);
// 							if(tagCardType2.bOnePare)  //一对
// 							{
// 								for(int k=0;k<2;k++)
// 								{
// 									btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
// 								}
// 								RemoveCard(btTemp,2,btCardData2,btCardCount2);
// 								FrontCard[2]=btCardData2[0];
// 								MidCard[2]=btCardData2[1];
// 								MidCard[3]=btCardData2[2];
// 								MidCard[4]=btCardData2[3];
// 								BackCard[3]=btCardData2[4];
// 								BackCard[4]=btCardData2[5];
// 							}
// 							else                            //散牌
// 							{
// 								FrontCard[0]=btCardData2[0];
// 								FrontCard[1]=btCardData2[1];
// 								FrontCard[2]=btCardData2[2];
// 								MidCard[2]=btCardData2[3];
// 								MidCard[3]=btCardData2[4];
// 								MidCard[4]=btCardData2[5];
// 								BackCard[3]=btCardData2[6];
// 								BackCard[4]=btCardData2[7];
// 							}
// 							if(bFirst)
// 							{
// 								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
// 								{
// 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 									bFirst=false;
// 								}
// 							}
// 							else 
// 							{
// 								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
// 									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
// 								{
// 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 								}
// 							}
// 						}
// 					}
// 					//散牌
// 					btCardCount1=btCardCount;
// 					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 					MidCard[0]=btCardData1[0];
// 					MidCard[1]=btCardData1[4];
// 					MidCard[2]=btCardData1[5];
// 					MidCard[3]=btCardData1[6];
// 					MidCard[4]=btCardData1[7];
// 					BackCard[3]=btCardData1[8];
// 					BackCard[4]=btCardData1[9];
// 					FrontCard[0]=btCardData1[1];
// 					FrontCard[1]=btCardData1[2];
// 					FrontCard[2]=btCardData1[3];
// 					if(bFirst)
// 					{
// 						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
// 						{
// 							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 							bFirst=false;
// 						}
// 					}
// 					else 
// 					{
// 						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
// 							IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
// 						{
// 							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 						}
// 					}
// 				}
// 			}
// 			if(tagCardType.bTwoPare)      //第三敦为两对
// 			{
//				if(tagCardType.btOnePare<4)
//				{
//					for(int i=0;i<tagCardType.btTwoPare;i++)            
//					{
//						CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//						btCardCount=btHandCardCount;
//						for(int j=0;j<4;j++)                        
//						{
//							BackCard[j]=btCardData[tagCardType.cbTwoPare[i*4+j]];
//						}
//						RemoveCard(BackCard,4,btCardData,btCardCount);
//						btCardCount1=btCardCount-=4;
//						CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//						tagCardType1=GetType(btCardData1,btCardCount1);
//						if(tagCardType1.bTwoPare)      //剩下两对
//						{
//							if(tagCardType1.btOnePare>=3)
//							{
//								btCardCount1=btCardCount;
//								CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//								btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
//								btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
//								btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
//								btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
//								btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
//								btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
//								RemoveCard(btTemp,6,btCardData1,btCardCount1);
//								FrontCard[2]=btCardData1[0];
//								MidCard[4]=btCardData1[1];
//								BackCard[4]=btCardData1[2];
//								if(bFirst)
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//										bFirst=false;
//									}
//								}
//								else 
//								{
//									btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//										IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										btFrontAllShuiShu=btAllShuiShu;
//									}
//								}
//							}
//							else
//							{
//								for(int j=0;j<tagCardType1.btTwoPare;j++)
//								{
//									btCardCount1=btCardCount;
//									CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//									for(int k=0;k<4;k++)
//									{
//										MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
//									}
//									RemoveCard(MidCard,4,btCardData1,btCardCount1);
//									btCardCount2=btCardCount1-=4;
//									CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//									tagCardType2=GetType(btCardData2,btCardCount2);
//									if(tagCardType2.bTwoPare)  //两对
//									{
//										for(int k=0;k<4;k++)
//										{
//											if(k<3)
//											{
//												btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
//											}
//											else 
//											{
//												btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
//											}
//										}
//										RemoveCard(btTemp,4,btCardData2,btCardCount2);
//										BackCard[4]=btCardData2[0];
//									}
//									else if(tagCardType2.bOnePare)  //一对
//									{
//										for(int k=0;k<2;k++)
//										{
//											btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//										}
//										RemoveCard(btTemp,2,btCardData2,btCardCount2);
//										FrontCard[2]=btCardData2[0];
//										MidCard[4]=btCardData2[1];
//										BackCard[4]=btCardData2[2];
//									}
//									else                            //散牌
//									{
//										FrontCard[0]=btCardData2[0];
//										FrontCard[1]=btCardData2[1];
//										FrontCard[2]=btCardData2[2];
//										MidCard[4]=btCardData2[3];
//										BackCard[4]=btCardData2[4];
//									}
//									if(bFirst)
//									{
//										if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//										{
//											CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//											CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//											CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//											bFirst=false;
//										}
//									}
//									else 
//									{
//										if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//											IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//										{
//											CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//											CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//											CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										}
//									}
//								}
//							}
//
//						}
//						else if(tagCardType1.bOnePare)      //剩下一对
//						{
//							for(int j=0;j<tagCardType1.btOnePare;j++)
//							{
//								btCardCount1=btCardCount;
//								CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//								for(int k=0;k<2;k++)
//								{
//									MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
//								}
//								RemoveCard(MidCard,2,btCardData1,btCardCount1);
//								btCardCount2=btCardCount1-=2;
//								CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//								tagCardType2=GetType(btCardData2,btCardCount2);
//								if(tagCardType2.bOnePare)  //一对
//								{
//									for(int k=0;k<2;k++)
//									{
//										btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//									}
//									RemoveCard(btTemp,2,btCardData2,btCardCount2);
//									FrontCard[2]=btCardData2[0];
//									MidCard[2]=btCardData2[1];
//									MidCard[3]=btCardData2[2];
//									MidCard[4]=btCardData2[3];
//									BackCard[4]=btCardData2[4];
//								}
//								else                            //散牌
//								{
//									FrontCard[0]=btCardData2[0];
//									FrontCard[1]=btCardData2[1];
//									FrontCard[2]=btCardData2[2];
//									MidCard[2]=btCardData2[3];
//									MidCard[3]=btCardData2[4];
//									MidCard[4]=btCardData2[5];
//									BackCard[4]=btCardData2[6];
//								}
//								if(bFirst)
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										bFirst=false;
//									}
//								}
//								else 
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//										IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									}
//								}
//							}
//						}
//						//散牌
//						btCardCount1=btCardCount;
//						CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//						MidCard[0]=btCardData1[0];
//						MidCard[1]=btCardData1[4];
//						MidCard[2]=btCardData1[5];
//						MidCard[3]=btCardData1[6];
//						MidCard[4]=btCardData1[7];
//						BackCard[4]=btCardData1[8];
//						FrontCard[0]=btCardData1[1];
//						FrontCard[1]=btCardData1[2];
//						FrontCard[2]=btCardData1[3];
//						if(bFirst)
//						{
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								bFirst=false;
//							}
//						}
//						else 
//						{
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//								IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							}
//						}
//					}
//				}
//				else
//				{
//					if(tagCardType.btOnePare==4)
//					{
//						CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//						btCardCount=btHandCardCount;
//						btTemp[0]=BackCard[0]=btCardData[tagCardType.cbOnePare[0]];
//						btTemp[1]=BackCard[1]=btCardData[tagCardType.cbOnePare[1]];
//						btTemp[2]=BackCard[2]=btCardData[tagCardType.cbOnePare[6]];
//						btTemp[3]=BackCard[3]=btCardData[tagCardType.cbOnePare[7]];
//						btTemp[4]=MidCard[0]=btCardData[tagCardType.cbOnePare[2]];
//						btTemp[5]=MidCard[1]=btCardData[tagCardType.cbOnePare[3]];
//						btTemp[6]=MidCard[2]=btCardData[tagCardType.cbOnePare[4]];
//						btTemp[7]=MidCard[3]=btCardData[tagCardType.cbOnePare[5]];
//						RemoveCard(btTemp,8,btCardData,btCardCount);
//						FrontCard[0]=btCardData[0];
//						FrontCard[1]=btCardData[1];
//						FrontCard[2]=btCardData[2];
//						MidCard[4]=btCardData[3];
//						BackCard[4]=btCardData[4];
//						if(GetCardLogicValue(FrontCard[0])==14&&GetCardLogicValue(FrontCard[1])==13)
//						{
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));   
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//						else
//						{
//							CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//							btCardCount=btHandCardCount;
//							btTemp[0]=BackCard[0]=btCardData[tagCardType.cbOnePare[4]];
//							btTemp[1]=BackCard[1]=btCardData[tagCardType.cbOnePare[5]];
//							btTemp[2]=BackCard[2]=btCardData[tagCardType.cbOnePare[6]];
//							btTemp[3]=BackCard[3]=btCardData[tagCardType.cbOnePare[7]];
//							btTemp[4]=MidCard[0]=btCardData[tagCardType.cbOnePare[0]];
//							btTemp[5]=MidCard[1]=btCardData[tagCardType.cbOnePare[1]];
//							btTemp[6]=FrontCard[0]=btCardData[tagCardType.cbOnePare[2]];
//							btTemp[7]=FrontCard[1]=btCardData[tagCardType.cbOnePare[3]];
//							RemoveCard(btTemp,8,btCardData,btCardCount);
//							FrontCard[2]=btCardData[0];
//							MidCard[2]=btCardData[1];
//							MidCard[3]=btCardData[2];
//							MidCard[4]=btCardData[3];
//							BackCard[4]=btCardData[4];
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//					}
//					else if(tagCardType.btOnePare==5)
//					{
//						CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//						btCardCount=btHandCardCount;
//						btTemp[0]=FrontCard[0]=btCardData[tagCardType.cbOnePare[0]];
//						btTemp[1]=FrontCard[1]=btCardData[tagCardType.cbOnePare[1]];
//						btTemp[2]=MidCard[0]=btCardData[tagCardType.cbOnePare[4]];
//						btTemp[3]=MidCard[1]=btCardData[tagCardType.cbOnePare[5]];
//						btTemp[4]=MidCard[2]=btCardData[tagCardType.cbOnePare[6]];
//						btTemp[5]=MidCard[3]=btCardData[tagCardType.cbOnePare[7]];
//						btTemp[6]=BackCard[0]=btCardData[tagCardType.cbOnePare[2]];
//						btTemp[7]=BackCard[1]=btCardData[tagCardType.cbOnePare[3]];
//						btTemp[8]=BackCard[2]=btCardData[tagCardType.cbOnePare[8]];
//						btTemp[9]=BackCard[3]=btCardData[tagCardType.cbOnePare[9]];
//						RemoveCard(btTemp,10,btCardData,btCardCount);
//						FrontCard[2]=btCardData[0];
//						MidCard[4]=btCardData[1];
//						BackCard[4]=btCardData[2];
//						if(bFirst)
//						{
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));   
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								bFirst=false;
//							}
//						}
//						else 
//						{
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//								IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							}
//						}
//					}
//				}
// 			}
//  			if(tagCardType.bOnePare)      //第三敦为一对
//  			{
//  				for(int i=0;i<tagCardType.btOnePare;i++)            
//  				{
//  					CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//  					btCardCount=btHandCardCount;
//  					for(int j=0;j<2;j++)                        
//  					{
//  						BackCard[j]=btCardData[tagCardType.cbOnePare[i*2+j]];
//  					}
//  					RemoveCard(BackCard,2,btCardData,btCardCount);
//  					btCardCount1=btCardCount-=2;
//  					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//  					tagCardType1=GetType(btCardData1,btCardCount1);
//  					if(tagCardType1.bOnePare)      //剩下一对
//  					{
//  						for(int j=0;j<tagCardType1.btOnePare;j++)
//  						{
//  							btCardCount1=btCardCount;
//  							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//  							for(int k=0;k<2;k++)
//  							{
//  								MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
//  							}
//  							RemoveCard(MidCard,2,btCardData1,btCardCount1);
//  							btCardCount2=btCardCount1-=2;
//  							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//  							tagCardType2=GetType(btCardData2,btCardCount2);
//  							if(tagCardType2.bOnePare)  //一对
//  							{
//  								for(int k=0;k<2;k++)
//  								{
//  									btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//  								}
//  								RemoveCard(btTemp,2,btCardData2,btCardCount2);
//  								FrontCard[2]=btCardData2[0];
//  								MidCard[2]=btCardData2[1];
//  								MidCard[3]=btCardData2[2];
//  								MidCard[4]=btCardData2[3];
//  								BackCard[2]=btCardData2[4];
//  								BackCard[3]=btCardData2[5];
//  								BackCard[4]=btCardData2[6];
//  							}
//  							else                            //散牌
//  							{
//  								FrontCard[0]=btCardData2[0];
//  								FrontCard[1]=btCardData2[1];
//  								FrontCard[2]=btCardData2[2];
//  								MidCard[2]=btCardData2[3];
//  								MidCard[3]=btCardData2[4];
//  								MidCard[4]=btCardData2[5];
//  								BackCard[2]=btCardData2[6];
//  								BackCard[3]=btCardData2[7];
//  								BackCard[4]=btCardData2[8];
//  							}
//  							if(bFirst)
//  							{
//  								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//  								{
//  									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//  									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//  									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//  									bFirst=false;
//  								}
//  							}
//  							else 
//  							{
//								
//  								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//  									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//  								{
//// 									for(int m=0;m<3;m++)
//// 									{
//// 									    printf("FrontFrontCard[%d]=%d ",m,FrontFrontCard[m]);
//// 									}
//// 									for(int m=0;m<5;m++)
//// 									{
//// 									    printf("FrontMidCard[%d]=%d ",m,FrontMidCard[m]);
//// 									}
//// 									for(int m=0;m<5;m++)
//// 									{
////                                        printf("FrontBackCard[%d]=%d ",m,FrontBackCard[m]);
//// 									}
//// 									printf("\n");
//// 									for(int m=0;m<3;m++)
//// 									{
//// 										printf("FrontCard[%d]=%d ",m,FrontCard[m]);
//// 									}
//// 									for(int m=0;m<5;m++)
//// 									{
//// 										printf("MidCard[%d]=%d ",m,MidCard[m]);
//// 									}
//// 									for(int m=0;m<5;m++)
//// 									{
//// 										printf("BackCard[%d]=%d ",m,BackCard[m]);
//// 									}
//// 									printf("\n");
//  									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//  									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//  									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//  								}
//  							}
//  						}
//  					}
//  					//散牌
//   					btCardCount1=btCardCount;
//   					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//   					MidCard[0]=btCardData1[0];
//   					MidCard[1]=btCardData1[4];
//   					MidCard[2]=btCardData1[5];
//   					MidCard[3]=btCardData1[6];
//   					MidCard[4]=btCardData1[7];
//   					BackCard[2]=btCardData1[8];
//   					BackCard[3]=btCardData1[9];
//   					BackCard[4]=btCardData1[10];
//   					FrontCard[0]=btCardData1[1];
//   					FrontCard[1]=btCardData1[2];
//   					FrontCard[2]=btCardData1[3];
//  					if(bFirst)
//  					{
//  						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//  						{
//  							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//  							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//  							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//  							bFirst=false;
//  						}
//  					}
//  					else 
//  					{
//  						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//  							IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//  						{
//  							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//  							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//  							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//  						}
//  					}
//  				}
//  			}
//		}
//	}
//	else if(tagCardType.bFlush) //有同花
//	{
//		bool bThreeSame=false;
//		for(int i=0;i<tagCardType.btThreeSame;i++)
//		{
//			CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//			btCardCount=btHandCardCount;
//			for(int j=0;j<3;j++)
//			{
//				FrontCard[j]=btCardData[tagCardType.cbThreeSame[i*3+j]];
//			}
//			RemoveCard(FrontCard,3,btCardData,btCardCount);
//			btCardCount1=btCardCount-=3;
//			CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//			tagCardType1=GetType(btCardData1,btCardCount1);
//			if(tagCardType1.bFlush)    //有同花
//			{
//				for(int j=0;j<tagCardType1.btFlush;j++)
//				{
//					btCardCount1=btCardCount;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);  
//					for(int k=0;k<5;k++)
//					{
//						BackCard[k]=btCardData1[tagCardType1.cbFlush[j*5+k]];
//					}
//					RemoveCard(BackCard,5,btCardData1,btCardCount1);
//					CopyMemory(MidCard,btCardData1,sizeof(MidCard));
//					if(bFirst)
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//						{
//							bThreeSame=true;
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							bFirst=false;
//						}
//					}
//					else 
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//							IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//						{
//							bThreeSame=true;
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							btFrontAllShuiShu=btAllShuiShu;
//						}
//					}
//				}
//			}
//			if(tagCardType1.bStraight)  //有顺子
//			{
//				for(int j=0;j<tagCardType1.btStraight;j++)
//				{
//					btCardCount1=btCardCount;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);  
//					for(int k=0;k<5;k++)
//					{
//						BackCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
//					}
//					RemoveCard(BackCard,5,btCardData1,btCardCount1);
//					CopyMemory(MidCard,btCardData1,sizeof(MidCard));
//					if(bFirst)
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//						{
//							bThreeSame=true;
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							bFirst=false;
//						}
//					}
//					else 
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//							IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//						{
//							bThreeSame=true;
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							btFrontAllShuiShu=btAllShuiShu;
//						}
//					}
//				}
//			}
//			if(tagCardType1.bThreeSame) //有三条
//			{
//				for(int j=0;j<tagCardType1.btThreeSame;j++)
//				{
//					btCardCount1=btCardCount;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);  
//					for(int k=0;k<3;k++)
//					{
//						BackCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
//					}
//					RemoveCard(BackCard,3,btCardData1,btCardCount1);
//					btCardCount2=btCardCount1-=3;
//					CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//					tagCardType2=GetType(btCardData2,btCardCount2);
//					if(tagCardType2.bThreeSame)
//					{
//						for(int k=0;k<tagCardType2.btThreeSame;k++)
//						{
//							for(int m=0;m<3;m++)
//							{
//								MidCard[m]=btCardData2[tagCardType2.cbThreeSame[k*3+m]];
//							}
//							RemoveCard(MidCard,3,btCardData2,btCardCount2);
//							BackCard[3]=btCardData2[2];
//							BackCard[4]=btCardData2[3];
//							MidCard[3]=btCardData2[0];
//							MidCard[4]=btCardData2[1];
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									bThreeSame=true;
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									bThreeSame=true;
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//					}
//				}
//			}
//		}
//		if(bThreeSame==false)
//		{
//			if(tagCardType.bFlush)       //第三敦为同花
//			{
//				for(int i=0;i<tagCardType.btFlush;i++)            
//				{
//					CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//					btCardCount=btHandCardCount;
//					for(int j=0;j<5;j++)                        
//					{
//						BackCard[j]=btCardData[tagCardType.cbFlush[i*5+j]];
//					}
//					RemoveCard(BackCard,5,btCardData,btCardCount);
//					btCardCount1=btCardCount-=5;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//					tagCardType1=GetType(btCardData1,btCardCount1);
//					if(tagCardType1.bFlush)        //剩下同花
//					{
//						for(int j=0;j<tagCardType1.btFlush;j++)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<5;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbFlush[j*5+k]];
//							}
//							RemoveCard(MidCard,5,btCardData1,btCardCount1);
//							CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//					}
//					else if(tagCardType1.bStraight)     //剩下顺子
//					{
//						for(int j=0;j<tagCardType1.btStraight;j++)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<5;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
//							}
//							RemoveCard(MidCard,5,btCardData1,btCardCount1);
//							CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//					}
// 					else if(tagCardType1.bThreeSame)    //剩下三条
// 					{
// 						for(int j=0;j<tagCardType1.btThreeSame;j++)
// 						{
// 							btCardCount1=btCardCount;
// 							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 							for(int k=0;k<3;k++)
// 							{
// 								MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
// 							}
// 							RemoveCard(MidCard,3,btCardData1,btCardCount1);
// 							btCardCount2=btCardCount1-=3;
// 							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
// 							tagCardType2=GetType(btCardData2,btCardCount2);
// 							if(tagCardType2.bThreeSame)  //三条
// 							{
// 								for(int k=0;k<3;k++)
// 								{
// 									FrontCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
// 								}
// 								RemoveCard(FrontCard,3,btCardData2,btCardCount2);
// 								MidCard[3]=btCardData2[0];
// 								MidCard[4]=btCardData2[1];
// 							}
// 							else if(tagCardType2.bTwoPare)  //两对
// 							{
// 								for(int k=0;k<4;k++)
// 								{
// 									if(k<2)
// 									{
// 										btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
// 									}
// 									else 
// 									{
// 										btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
// 									}
// 								}
// 								RemoveCard(btTemp,4,btCardData2,btCardCount2);
// 								FrontCard[2]=btCardData2[0];
// 							}
// 							else if(tagCardType2.bOnePare)  //一对
// 							{
// 								for(int k=0;k<2;k++)
// 								{
// 									btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
// 								}
// 								RemoveCard(btTemp,2,btCardData2,btCardCount2);
// 								FrontCard[2]=btCardData2[0];
// 								MidCard[3]=btCardData2[1];
// 								MidCard[4]=btCardData2[2];
// 							}
// 							else                            //散牌
// 							{
// 								for(int k=0;k<5;k++)
// 								{
// 									if(k<3)
// 									{
// 										FrontCard[k]=btCardData2[k];
// 									}
// 									else
// 									{
// 										MidCard[k]=btCardData2[k];
// 									}
// 								}
// 							}
// 							if(bFirst)
// 							{
// 								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
// 								{
// 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 									bFirst=false;
// 								}
// 							}
// 							else 
// 							{
// 								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
// 									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
// 								{
// 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 								}
// 							}
// 						}
// 					}
// 					else if(tagCardType1.bTwoPare)      //剩下两对
// 					{
//						if(tagCardType1.btOnePare>=3)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
//							btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
//							btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
//							btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
//							btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
//							btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
//							RemoveCard(btTemp,6,btCardData1,btCardCount1);
//							FrontCard[2]=btCardData1[0];
//							MidCard[4]=btCardData1[1];
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//						else
//						{
//							for(int j=0;j<tagCardType1.btTwoPare;j++)
//							{
//								btCardCount1=btCardCount;
//								CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//								for(int k=0;k<4;k++)
//								{
//									MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
//								}
//								RemoveCard(MidCard,4,btCardData1,btCardCount1);
//								btCardCount2=btCardCount1-=4;
//								CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//								tagCardType2=GetType(btCardData2,btCardCount2);
//								if(tagCardType2.bTwoPare)  //两对
//								{
//									for(int k=0;k<4;k++)
//									{
//										if(k<3)
//										{
//											FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
//										}
//										else 
//										{
//											MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
//										}
//									}
//								}
//								else if(tagCardType2.bOnePare)  //一对
//								{
//									for(int k=0;k<2;k++)
//									{
//										btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//									}
//									RemoveCard(btTemp,2,btCardData2,btCardCount2);
//									FrontCard[2]=btCardData2[0];
//									MidCard[4]=btCardData2[1];
//								}
//								else                            //散牌
//								{
//									for(int k=0;k<4;k++)
//									{
//										if(k<3)
//										{
//											FrontCard[k]=btCardData2[k];
//										}
//										else
//										{
//											MidCard[k+1]=btCardData2[k];
//										}
//									}
//								}
//								if(bFirst)
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										bFirst=false;
//									}
//								}
//								else 
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//										IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									}
//								}
//							}
//						}
// 						
// 					}
// 					else if(tagCardType1.bOnePare)      //剩下一对
// 					{
// 						for(int j=0;j<tagCardType1.btOnePare;j++)
// 						{
// 							btCardCount1=btCardCount;
// 							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 							for(int k=0;k<2;k++)
// 							{
// 								MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
// 							}
// 							RemoveCard(MidCard,2,btCardData1,btCardCount1);
// 							btCardCount2=btCardCount1-=2;
// 							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
// 							tagCardType2=GetType(btCardData2,btCardCount2);
// 							if(tagCardType2.bOnePare)  //一对
// 							{
// 								for(int k=0;k<2;k++)
// 								{
// 									btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
// 								}
// 								RemoveCard(btTemp,2,btCardData2,btCardCount2);
// 								FrontCard[2]=btCardData2[0];
// 								MidCard[2]=btCardData2[1];
// 								MidCard[3]=btCardData2[2];
// 								MidCard[4]=btCardData2[3];
// 							}
// 							else                            //散牌
// 							{
// 								for(int k=0;k<6;k++)
// 								{
// 									if(k<3)
// 									{
// 										FrontCard[k]=btCardData2[k];
// 									}
// 									else
// 									{
// 										MidCard[k-1]=btCardData2[k];
// 									}
// 								}
// 							}
// 							if(bFirst)
// 							{
// 								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
// 								{
// 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 									bFirst=false;
// 								}
// 							}
// 							else 
// 							{
// 								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
// 									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
// 								{
// 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 								}
// 							}
// 						}
// 					}
// 					//散牌
// 					btCardCount1=btCardCount;
// 					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 					MidCard[0]=btCardData1[0];
// 					MidCard[1]=btCardData1[4];
// 					MidCard[2]=btCardData1[5];
// 					MidCard[3]=btCardData1[6];
// 					MidCard[4]=btCardData1[7];
// 					FrontCard[0]=btCardData1[1];
// 					FrontCard[1]=btCardData1[2];
// 					FrontCard[2]=btCardData1[3];
//  					if(bFirst)
//  					{
//  						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//  						{
//  							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//  							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//  							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//  							bFirst=false;
//  						}
//  					}
//  					else 
//  					{
//  						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//  							IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//  						{
//  							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//  							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//  							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//  						}
//  					}
// 				}
//			}
// 			if(tagCardType.bStraight)     //第三敦为顺子
// 			{
// 				for(int i=0;i<tagCardType.btStraight;i++)           
// 				{
// 					CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
// 					btCardCount=btHandCardCount;
// 					for(int j=0;j<5;j++)                        
// 					{
// 						BackCard[j]=btCardData[tagCardType.cbStraight[i*5+j]];
// 					}
// 					RemoveCard(BackCard,5,btCardData,btCardCount);
// 					btCardCount1=btCardCount-=5;
// 					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 					tagCardType1=GetType(btCardData1,btCardCount1);
// 					if(tagCardType1.bStraight)     //剩下顺子
// 					{
// 						for(int j=0;j<tagCardType1.btStraight;j++)
// 						{
// 							btCardCount1=btCardCount;
// 							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 							for(int k=0;k<5;k++)
// 							{
// 								MidCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
// 							}
// 							RemoveCard(MidCard,5,btCardData1,btCardCount1);
// 							CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
// 							if(bFirst)
// 							{
// 								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
// 								{
// 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 									bFirst=false;
// 								}
// 							}
// 							else 
// 							{
// 								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
// 									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
// 								{
// 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 								}
// 							}
// 						}
// 					}
// 					else if(tagCardType1.bThreeSame)    //剩下三条
// 					{
// 						for(int j=0;j<tagCardType1.btThreeSame;j++)
// 						{
// 							btCardCount1=btCardCount;
// 							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 							for(int k=0;k<3;k++)
// 							{
// 								MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
// 							}
// 							RemoveCard(MidCard,3,btCardData1,btCardCount1);
// 							btCardCount2=btCardCount1-=3;
// 							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
// 							tagCardType2=GetType(btCardData2,btCardCount2);
// 							if(tagCardType2.bThreeSame)  //三条
// 							{
// 								for(int k=0;k<3;k++)
// 								{
// 									FrontCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
// 								}
// 								RemoveCard(FrontCard,3,btCardData2,btCardCount2);
// 								MidCard[3]=btCardData2[0];
// 								MidCard[4]=btCardData2[1];
// 							}
// 							else if(tagCardType2.bTwoPare)  //两对
// 							{
// 								for(int k=0;k<4;k++)
// 								{
// 									if(k<2)
// 									{
// 										btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
// 									}
// 									else 
// 									{
// 										btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
// 									}
// 								}
// 								RemoveCard(btTemp,4,btCardData2,btCardCount2);
// 								FrontCard[2]=btCardData2[0];
// 							}
// 							else if(tagCardType2.bOnePare)  //一对
// 							{
// 								for(int k=0;k<2;k++)
// 								{
// 									btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
// 								}
// 								RemoveCard(btTemp,2,btCardData2,btCardCount2);
// 								FrontCard[2]=btCardData2[0];
// 								MidCard[3]=btCardData2[1];
// 								MidCard[4]=btCardData2[2];
// 							}
// 							else                            //散牌
// 							{
// 								for(int k=0;k<5;k++)
// 								{
// 									if(k<3)
// 									{
// 										FrontCard[k]=btCardData2[k];
// 									}
// 									else
// 									{
// 										MidCard[k]=btCardData2[k];
// 									}
// 								}
// 							}
// 							if(bFirst)
// 							{
// 								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
// 								{
// 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 									bFirst=false;
// 								}
// 							}
// 							else 
// 							{
// 								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
// 									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
// 								{
// 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 								}
// 							}
// 						}
// 					}
// 					else if(tagCardType1.bTwoPare)      //剩下两对
// 					{
//						if(tagCardType1.btOnePare>=3)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
//							btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
//							btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
//							btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
//							btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
//							btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
//							RemoveCard(btTemp,6,btCardData1,btCardCount1);
//							FrontCard[2]=btCardData1[0];
//							MidCard[4]=btCardData1[1];
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//						else
//						{
//							for(int j=0;j<tagCardType1.btTwoPare;j++)
//							{
//								btCardCount1=btCardCount;
//								CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//								for(int k=0;k<4;k++)
//								{
//									MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
//								}
//								RemoveCard(MidCard,4,btCardData1,btCardCount1);
//								btCardCount2=btCardCount1-=4;
//								CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//								tagCardType2=GetType(btCardData2,btCardCount2);
//								if(tagCardType2.bTwoPare)  //两对
//								{
//									for(int k=0;k<4;k++)
//									{
//										if(k<3)
//										{
//											FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
//										}
//										else 
//										{
//											MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
//										}
//									}
//								}
//								else if(tagCardType2.bOnePare)  //一对
//								{
//									for(int k=0;k<2;k++)
//									{
//										btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//									}
//									RemoveCard(btTemp,2,btCardData2,btCardCount2);
//									FrontCard[2]=btCardData2[0];
//									MidCard[4]=btCardData2[1];
//								}
//								else                            //散牌
//								{
//									for(int k=0;k<4;k++)
//									{
//										if(k<3)
//										{
//											FrontCard[k]=btCardData2[k];
//										}
//										else
//										{
//											MidCard[k+1]=btCardData2[k];
//										}
//									}
//								}
//								if(bFirst)
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										bFirst=false;
//									}
//								}
//								else 
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//										IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									}
//								}
//							}
//						}
// 						
// 					}
// 					else if(tagCardType1.bOnePare)      //剩下一对
// 					{
// 						for(int j=0;j<tagCardType1.btOnePare;j++)
// 						{
// 							btCardCount1=btCardCount;
// 							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 							for(int k=0;k<2;k++)
// 							{
// 								MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
// 							}
// 							RemoveCard(MidCard,2,btCardData1,btCardCount1);
// 							btCardCount2=btCardCount1-=2;
// 							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
// 							tagCardType2=GetType(btCardData2,btCardCount2);
// 							if(tagCardType2.bOnePare)  //一对
// 							{
// 								for(int k=0;k<2;k++)
// 								{
// 									btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
// 								}
// 								RemoveCard(btTemp,2,btCardData2,btCardCount2);
// 								FrontCard[2]=btCardData2[0];
// 								MidCard[2]=btCardData2[1];
// 								MidCard[3]=btCardData2[2];
// 								MidCard[4]=btCardData2[3];
// 							}
// 							else                            //散牌
// 							{
// 								for(int k=0;k<6;k++)
// 								{
// 									if(k<3)
// 									{
// 										FrontCard[k]=btCardData2[k];
// 									}
// 									else
// 									{
// 										MidCard[k-1]=btCardData2[k];
// 									}
// 								}
// 							}
// 							if(bFirst)
// 							{
// 								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
// 								{
// 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 									bFirst=false;
// 								}
// 							}
// 							else 
// 							{
// 								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
// 									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
// 								{
// 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 								}
// 							}
// 						}
// 					}
// 					//散牌
// 					btCardCount1=btCardCount;
// 					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 					MidCard[0]=btCardData1[0];
// 					MidCard[1]=btCardData1[4];
// 					MidCard[2]=btCardData1[5];
// 					MidCard[3]=btCardData1[6];
// 					MidCard[4]=btCardData1[7];
// 					FrontCard[0]=btCardData1[1];
// 					FrontCard[1]=btCardData1[2];
// 					FrontCard[2]=btCardData1[3];
// 					if(bFirst)
// 					{
// 						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
// 						{
// 							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 							bFirst=false;
// 						}
// 					}
// 					else 
// 					{
// 						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
// 							IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
// 						{
// 							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 						}
// 					}
// 				}
// 			}
// 			if(tagCardType.bThreeSame)    //第三敦为三条
// 			{
// 				for(int i=0;i<tagCardType.btThreeSame;i++)            
// 				{
// 					CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
// 					btCardCount=btHandCardCount;
// 					for(int j=0;j<3;j++)                        
// 					{
// 						BackCard[j]=btCardData[tagCardType.cbThreeSame[i*3+j]];
// 					}
// 					RemoveCard(BackCard,3,btCardData,btCardCount);
// 					btCardCount1=btCardCount-=3;
// 					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 					tagCardType1=GetType(btCardData1,btCardCount1);
// 					if(tagCardType1.bThreeSame)    //剩下三条
// 					{
// 						for(int j=0;j<tagCardType1.btThreeSame;j++)
// 						{
// 							btCardCount1=btCardCount;
// 							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 							for(int k=0;k<3;k++)
// 							{
// 								MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
// 							}
// 							RemoveCard(MidCard,3,btCardData1,btCardCount1);
// 							btCardCount2=btCardCount1-=3;
// 							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
// 							tagCardType2=GetType(btCardData2,btCardCount2);
// 							if(tagCardType2.bThreeSame)  //三条
// 							{
// 								for(int k=0;k<3;k++)
// 								{
// 									FrontCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
// 								}
// 								RemoveCard(FrontCard,3,btCardData2,btCardCount2);
// 								MidCard[3]=btCardData2[0];
// 								MidCard[4]=btCardData2[1];
// 								BackCard[3]=btCardData2[2];
// 								BackCard[4]=btCardData2[3];
// 							}
// 							else if(tagCardType2.bTwoPare)  //两对
// 							{
// 								for(int k=0;k<4;k++)
// 								{
// 									if(k<2)
// 									{
// 										btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
// 									}
// 									else 
// 									{
// 										btTemp[k]=BackCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
// 									}
// 								}
// 								RemoveCard(btTemp,4,btCardData2,btCardCount2);
// 								FrontCard[2]=btCardData2[0];
// 								MidCard[3]=btCardData2[1];
// 								MidCard[4]=btCardData2[2];
// 							}
// 							else if(tagCardType2.bOnePare)  //一对
// 							{
// 								for(int k=0;k<2;k++)
// 								{
// 									btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
// 								}
// 								RemoveCard(btTemp,2,btCardData2,btCardCount2);
// 								FrontCard[2]=btCardData2[0];
// 								MidCard[3]=btCardData2[1];
// 								MidCard[4]=btCardData2[2];
// 								BackCard[3]=btCardData2[3];
// 								BackCard[4]=btCardData2[4];
// 							}
// 							else                            //散牌
// 							{
// 								FrontCard[0]=btCardData2[0];
// 								FrontCard[1]=btCardData2[1];
// 								FrontCard[2]=btCardData2[2];
// 								MidCard[3]=btCardData2[3];
// 								MidCard[4]=btCardData2[4];
// 								BackCard[3]=btCardData2[5];
// 								BackCard[4]=btCardData2[6];
// 							}
// 							if(bFirst)
// 							{
// 								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
// 								{
// 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 									bFirst=false;
// 								}
// 							}
// 							else 
// 							{
// 								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
// 									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
// 								{
// 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 								}
// 							}
// 						}
// 					}
// 					else if(tagCardType1.bTwoPare)      //剩下两对
// 					{
//						if(tagCardType1.btOnePare>=3)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
//							btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
//							btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
//							btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
//							btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
//							btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
//							RemoveCard(btTemp,6,btCardData1,btCardCount1);
//							FrontCard[2]=btCardData1[0];
//							MidCard[4]=btCardData1[1];
//							BackCard[3]=btCardData1[2];
//							BackCard[4]=btCardData1[3];
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//						else
//						{
//							for(int j=0;j<tagCardType1.btTwoPare;j++)
//							{
//								btCardCount1=btCardCount;
//								CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//								for(int k=0;k<4;k++)
//								{
//									MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
//								}
//								RemoveCard(MidCard,4,btCardData1,btCardCount1);
//								btCardCount2=btCardCount1-=4;
//								CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//								tagCardType2=GetType(btCardData2,btCardCount2);
//								if(tagCardType2.bTwoPare)  //两对
//								{
//									for(int k=0;k<4;k++)
//									{
//										if(k<3)
//										{
//											btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
//										}
//										else 
//										{
//											btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
//										}
//									}
//									RemoveCard(btTemp,4,btCardData2,btCardCount2);
//									BackCard[3]=btCardData2[0];
//									BackCard[4]=btCardData2[1];
//								}
//								else if(tagCardType2.bOnePare)  //一对
//								{
//									for(int k=0;k<2;k++)
//									{
//										btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//									}
//									RemoveCard(btTemp,2,btCardData2,btCardCount2);
//									FrontCard[2]=btCardData2[0];
//									MidCard[4]=btCardData2[1];
//									BackCard[3]=btCardData2[2];
//									BackCard[4]=btCardData2[3];
//								}
//								else                            //散牌
//								{
//									FrontCard[0]=btCardData2[0];
//									FrontCard[1]=btCardData2[1];
//									FrontCard[2]=btCardData2[2];
//									MidCard[4]=btCardData2[3];
//									BackCard[3]=btCardData2[4];
//									BackCard[4]=btCardData2[5];
//								}
//								if(bFirst)
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										bFirst=false;
//									}
//								}
//								else 
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//										IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									}
//								}
//							}
//						}
// 						
// 					}
// 					else if(tagCardType1.bOnePare)      //剩下一对
// 					{
// 						for(int j=0;j<tagCardType1.btOnePare;j++)
// 						{
// 							btCardCount1=btCardCount;
// 							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 							for(int k=0;k<2;k++)
// 							{
// 								MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
// 							}
// 							RemoveCard(MidCard,2,btCardData1,btCardCount1);
// 							btCardCount2=btCardCount1-=2;
// 							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
// 							tagCardType2=GetType(btCardData2,btCardCount2);
// 							if(tagCardType2.bOnePare)  //一对
// 							{
// 								for(int k=0;k<2;k++)
// 								{
// 									btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
// 								}
// 								RemoveCard(btTemp,2,btCardData2,btCardCount2);
// 								FrontCard[2]=btCardData2[0];
// 								MidCard[2]=btCardData2[1];
// 								MidCard[3]=btCardData2[2];
// 								MidCard[4]=btCardData2[3];
// 								BackCard[3]=btCardData2[4];
// 								BackCard[4]=btCardData2[5];
// 							}
// 							else                            //散牌
// 							{
// 								FrontCard[0]=btCardData2[0];
// 								FrontCard[1]=btCardData2[1];
// 								FrontCard[2]=btCardData2[2];
// 								MidCard[2]=btCardData2[3];
// 								MidCard[3]=btCardData2[4];
// 								MidCard[4]=btCardData2[5];
// 								BackCard[3]=btCardData2[6];
// 								BackCard[4]=btCardData2[7];
// 							}
// 							if(bFirst)
// 							{
// 								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
// 								{
// 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 									bFirst=false;
// 								}
// 							}
// 							else 
// 							{
// 								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
// 									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
// 								{
// 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 								}
// 							}
// 						}
// 					}
// 					//散牌
// 					btCardCount1=btCardCount;
// 					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 					MidCard[0]=btCardData1[0];
// 					MidCard[1]=btCardData1[4];
// 					MidCard[2]=btCardData1[5];
// 					MidCard[3]=btCardData1[6];
// 					MidCard[4]=btCardData1[7];
// 					BackCard[3]=btCardData1[8];
// 					BackCard[4]=btCardData1[9];
// 					FrontCard[0]=btCardData1[1];
// 					FrontCard[1]=btCardData1[2];
// 					FrontCard[2]=btCardData1[3];
// 					if(bFirst)
// 					{
// 						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
// 						{
// 							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 							bFirst=false;
// 						}
// 					}
// 					else 
// 					{
// 						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
// 							IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
// 						{
// 							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 						}
// 					}
// 				}
// 			}
//			if(tagCardType.bTwoPare)      //第三敦为两对
//			{
//				if(tagCardType.btOnePare<4)
//				{
//					for(int i=0;i<tagCardType.btTwoPare;i++)            
//					{
//						CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//						btCardCount=btHandCardCount;
//						for(int j=0;j<4;j++)                        
//						{
//							BackCard[j]=btCardData[tagCardType.cbTwoPare[i*4+j]];
//						}
//						RemoveCard(BackCard,4,btCardData,btCardCount);
//						btCardCount1=btCardCount-=4;
//						CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//						tagCardType1=GetType(btCardData1,btCardCount1);
//						if(tagCardType1.bTwoPare)      //剩下两对
//						{
//							if(tagCardType1.btOnePare>=3)
//							{
//								btCardCount1=btCardCount;
//								CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//								btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
//								btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
//								btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
//								btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
//								btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
//								btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
//								RemoveCard(btTemp,6,btCardData1,btCardCount1);
//								FrontCard[2]=btCardData1[0];
//								MidCard[4]=btCardData1[1];
//								BackCard[4]=btCardData1[2];
//								if(bFirst)
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//										bFirst=false;
//									}
//								}
//								else 
//								{
//									btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//										IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										btFrontAllShuiShu=btAllShuiShu;
//									}
//								}
//							}
//							else
//							{
//								for(int j=0;j<tagCardType1.btTwoPare;j++)
//								{
//									btCardCount1=btCardCount;
//									CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//									for(int k=0;k<4;k++)
//									{
//										MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
//									}
//									RemoveCard(MidCard,4,btCardData1,btCardCount1);
//									btCardCount2=btCardCount1-=4;
//									CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//									tagCardType2=GetType(btCardData2,btCardCount2);
//									if(tagCardType2.bTwoPare)  //两对
//									{
//										for(int k=0;k<4;k++)
//										{
//											if(k<3)
//											{
//												btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
//											}
//											else 
//											{
//												btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
//											}
//										}
//										RemoveCard(btTemp,4,btCardData2,btCardCount2);
//										BackCard[4]=btCardData2[0];
//									}
//									else if(tagCardType2.bOnePare)  //一对
//									{
//										for(int k=0;k<2;k++)
//										{
//											btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//										}
//										RemoveCard(btTemp,2,btCardData2,btCardCount2);
//										FrontCard[2]=btCardData2[0];
//										MidCard[4]=btCardData2[1];
//										BackCard[4]=btCardData2[2];
//									}
//									else                            //散牌
//									{
//										FrontCard[0]=btCardData2[0];
//										FrontCard[1]=btCardData2[1];
//										FrontCard[2]=btCardData2[2];
//										MidCard[4]=btCardData2[3];
//										BackCard[4]=btCardData2[4];
//									}
//									if(bFirst)
//									{
//										if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//										{
//											CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//											CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//											CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//											bFirst=false;
//										}
//									}
//									else 
//									{
//										if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//											IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//										{
//											CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//											CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//											CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										}
//									}
//								}
//							}
//
//						}
//						else if(tagCardType1.bOnePare)      //剩下一对
//						{
//							for(int j=0;j<tagCardType1.btOnePare;j++)
//							{
//								btCardCount1=btCardCount;
//								CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//								for(int k=0;k<2;k++)
//								{
//									MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
//								}
//								RemoveCard(MidCard,2,btCardData1,btCardCount1);
//								btCardCount2=btCardCount1-=2;
//								CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//								tagCardType2=GetType(btCardData2,btCardCount2);
//								if(tagCardType2.bOnePare)  //一对
//								{
//									for(int k=0;k<2;k++)
//									{
//										btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//									}
//									RemoveCard(btTemp,2,btCardData2,btCardCount2);
//									FrontCard[2]=btCardData2[0];
//									MidCard[2]=btCardData2[1];
//									MidCard[3]=btCardData2[2];
//									MidCard[4]=btCardData2[3];
//									BackCard[4]=btCardData2[4];
//								}
//								else                            //散牌
//								{
//									FrontCard[0]=btCardData2[0];
//									FrontCard[1]=btCardData2[1];
//									FrontCard[2]=btCardData2[2];
//									MidCard[2]=btCardData2[3];
//									MidCard[3]=btCardData2[4];
//									MidCard[4]=btCardData2[5];
//									BackCard[4]=btCardData2[6];
//								}
//								if(bFirst)
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										bFirst=false;
//									}
//								}
//								else 
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//										IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									}
//								}
//							}
//						}
//						//散牌
//						btCardCount1=btCardCount;
//						CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//						MidCard[0]=btCardData1[0];
//						MidCard[1]=btCardData1[4];
//						MidCard[2]=btCardData1[5];
//						MidCard[3]=btCardData1[6];
//						MidCard[4]=btCardData1[7];
//						BackCard[4]=btCardData1[8];
//						FrontCard[0]=btCardData1[1];
//						FrontCard[1]=btCardData1[2];
//						FrontCard[2]=btCardData1[3];
//						if(bFirst)
//						{
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								bFirst=false;
//							}
//						}
//						else 
//						{
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//								IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							}
//						}
//					}
//				}
//				else
//				{
//					if(tagCardType.btOnePare==4)
//					{
//						CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//						btCardCount=btHandCardCount;
//						btTemp[0]=BackCard[0]=btCardData[tagCardType.cbOnePare[0]];
//						btTemp[1]=BackCard[1]=btCardData[tagCardType.cbOnePare[1]];
//						btTemp[2]=BackCard[2]=btCardData[tagCardType.cbOnePare[6]];
//						btTemp[3]=BackCard[3]=btCardData[tagCardType.cbOnePare[7]];
//						btTemp[4]=MidCard[0]=btCardData[tagCardType.cbOnePare[2]];
//						btTemp[5]=MidCard[1]=btCardData[tagCardType.cbOnePare[3]];
//						btTemp[6]=MidCard[2]=btCardData[tagCardType.cbOnePare[4]];
//						btTemp[7]=MidCard[3]=btCardData[tagCardType.cbOnePare[5]];
//						RemoveCard(btTemp,8,btCardData,btCardCount);
//						FrontCard[0]=btCardData[0];
//						FrontCard[1]=btCardData[1];
//						FrontCard[2]=btCardData[2];
//						MidCard[4]=btCardData[3];
//						BackCard[4]=btCardData[4];
//						if(GetCardLogicValue(FrontCard[0])==14&&GetCardLogicValue(FrontCard[1])==13)
//						{
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));   
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//						else
//						{
//							CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//							btCardCount=btHandCardCount;
//							btTemp[0]=BackCard[0]=btCardData[tagCardType.cbOnePare[4]];
//							btTemp[1]=BackCard[1]=btCardData[tagCardType.cbOnePare[5]];
//							btTemp[2]=BackCard[2]=btCardData[tagCardType.cbOnePare[6]];
//							btTemp[3]=BackCard[3]=btCardData[tagCardType.cbOnePare[7]];
//							btTemp[4]=MidCard[0]=btCardData[tagCardType.cbOnePare[0]];
//							btTemp[5]=MidCard[1]=btCardData[tagCardType.cbOnePare[1]];
//							btTemp[6]=FrontCard[0]=btCardData[tagCardType.cbOnePare[2]];
//							btTemp[7]=FrontCard[1]=btCardData[tagCardType.cbOnePare[3]];
//							RemoveCard(btTemp,8,btCardData,btCardCount);
//							FrontCard[2]=btCardData[0];
//							MidCard[2]=btCardData[1];
//							MidCard[3]=btCardData[2];
//							MidCard[4]=btCardData[3];
//							BackCard[4]=btCardData[4];
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//					}
//					else if(tagCardType.btOnePare==5)
//					{
//						CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//						btCardCount=btHandCardCount;
//						btTemp[0]=FrontCard[0]=btCardData[tagCardType.cbOnePare[0]];
//						btTemp[1]=FrontCard[1]=btCardData[tagCardType.cbOnePare[1]];
//						btTemp[2]=MidCard[0]=btCardData[tagCardType.cbOnePare[4]];
//						btTemp[3]=MidCard[1]=btCardData[tagCardType.cbOnePare[5]];
//						btTemp[4]=MidCard[2]=btCardData[tagCardType.cbOnePare[6]];
//						btTemp[5]=MidCard[3]=btCardData[tagCardType.cbOnePare[7]];
//						btTemp[6]=BackCard[0]=btCardData[tagCardType.cbOnePare[2]];
//						btTemp[7]=BackCard[1]=btCardData[tagCardType.cbOnePare[3]];
//						btTemp[8]=BackCard[2]=btCardData[tagCardType.cbOnePare[8]];
//						btTemp[9]=BackCard[3]=btCardData[tagCardType.cbOnePare[9]];
//						RemoveCard(btTemp,10,btCardData,btCardCount);
//						FrontCard[2]=btCardData[0];
//						MidCard[4]=btCardData[1];
//						BackCard[4]=btCardData[2];
//						if(bFirst)
//						{
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));   
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								bFirst=false;
//							}
//						}
//						else 
//						{
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//								IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							}
//						}
//					}
//				}
//			}
// 			if(tagCardType.bOnePare)      //第三敦为一对
// 			{
// 				for(int i=0;i<tagCardType.btOnePare;i++)            
// 				{
// 					CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
// 					btCardCount=btHandCardCount;
// 					for(int j=0;j<2;j++)                        
// 					{
// 						BackCard[j]=btCardData[tagCardType.cbOnePare[i*2+j]];
// 					}
// 					RemoveCard(BackCard,2,btCardData,btCardCount);
// 					btCardCount1=btCardCount-=2;
// 					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 					tagCardType1=GetType(btCardData1,btCardCount1);
// 					if(tagCardType1.bOnePare)      //剩下一对
// 					{
// 						for(int j=0;j<tagCardType1.btOnePare;j++)
// 						{
// 							btCardCount1=btCardCount;
// 							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 							for(int k=0;k<2;k++)
// 							{
// 								MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
// 							}
// 							RemoveCard(MidCard,2,btCardData1,btCardCount1);
// 							btCardCount2=btCardCount1-=2;
// 							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
// 							tagCardType2=GetType(btCardData2,btCardCount2);
// 							if(tagCardType2.bOnePare)  //一对
// 							{
// 								for(int k=0;k<2;k++)
// 								{
// 									btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
// 								}
// 								RemoveCard(btTemp,2,btCardData2,btCardCount2);
// 								FrontCard[2]=btCardData2[0];
// 								MidCard[2]=btCardData2[1];
// 								MidCard[3]=btCardData2[2];
// 								MidCard[4]=btCardData2[3];
// 								BackCard[2]=btCardData2[4];
// 								BackCard[3]=btCardData2[5];
// 								BackCard[4]=btCardData2[6];
// 							}
// 							else                            //散牌
// 							{
// 								FrontCard[0]=btCardData2[0];
// 								FrontCard[1]=btCardData2[1];
// 								FrontCard[2]=btCardData2[2];
// 								MidCard[2]=btCardData2[3];
// 								MidCard[3]=btCardData2[4];
// 								MidCard[4]=btCardData2[5];
// 								BackCard[2]=btCardData2[6];
// 								BackCard[3]=btCardData2[7];
// 								BackCard[4]=btCardData2[8];
// 							}
// 							if(bFirst)
// 							{
// 								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
// 								{
// 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 									bFirst=false;
// 								}
// 							}
// 							else 
// 							{
// 								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
// 									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
// 								{
// 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 								}
// 							}
// 						}
// 					}
// 					//散牌
// 					btCardCount1=btCardCount;
// 					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
// 					MidCard[0]=btCardData1[0];
// 					MidCard[1]=btCardData1[4];
// 					MidCard[2]=btCardData1[5];
// 					MidCard[3]=btCardData1[6];
// 					MidCard[4]=btCardData1[7];
// 					BackCard[2]=btCardData1[8];
// 					BackCard[3]=btCardData1[9];
// 					BackCard[4]=btCardData1[10];
// 					FrontCard[0]=btCardData1[1];
// 					FrontCard[1]=btCardData1[2];
// 					FrontCard[2]=btCardData1[3];
// 					if(bFirst)
// 					{
// 						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
// 						{
// 							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 							bFirst=false;
// 						}
// 					}
// 					else 
// 					{
// 						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
// 							IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
// 						{
// 							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
// 							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
// 							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
// 						}
// 					}
// 				}
// 			}
//		}
//	}
//	else if(tagCardType.bStraight)//有顺子
//	{
//		bool bThreeSame=false;
//		for(int i=0;i<tagCardType.btThreeSame;i++)
//		{
//			CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//			btCardCount=btHandCardCount;
//			for(int j=0;j<3;j++)
//			{
//				FrontCard[j]=btCardData[tagCardType.cbThreeSame[i*3+j]];
//			}
//			RemoveCard(FrontCard,3,btCardData,btCardCount);
//			btCardCount1=btCardCount-=3;
//			CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//			tagCardType1=GetType(btCardData1,btCardCount1);
//			if(tagCardType1.bStraight)  //有顺子
//			{
//				for(int j=0;j<tagCardType1.btStraight;j++)
//				{
//					btCardCount1=btCardCount;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);  
//					for(int k=0;k<5;k++)
//					{
//						BackCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
//					}
//					RemoveCard(BackCard,5,btCardData1,btCardCount1);
//					CopyMemory(MidCard,btCardData1,sizeof(MidCard));
//					if(bFirst)
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//						{
//							bThreeSame=true;
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							bFirst=false;
//						}
//					}
//					else 
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//							IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//						{
//							bThreeSame=true;
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							btFrontAllShuiShu=btAllShuiShu;
//						}
//					}
//				}
//			}
//			if(tagCardType1.bThreeSame) //有三条
//			{
//				for(int j=0;j<tagCardType1.btThreeSame;j++)
//				{
//					btCardCount1=btCardCount;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);  
//					for(int k=0;k<3;k++)
//					{
//						BackCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
//					}
//					RemoveCard(BackCard,3,btCardData1,btCardCount1);
//					btCardCount2=btCardCount1-=3;
//					CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//					tagCardType2=GetType(btCardData2,btCardCount2);
//					if(tagCardType2.bThreeSame)
//					{
//						for(int k=0;k<tagCardType2.btThreeSame;k++)
//						{
//							for(int m=0;m<3;m++)
//							{
//								MidCard[m]=btCardData2[tagCardType2.cbThreeSame[k*3+m]];
//							}
//							RemoveCard(MidCard,3,btCardData2,btCardCount2);
//							BackCard[3]=btCardData2[2];
//							BackCard[4]=btCardData2[3];
//							MidCard[3]=btCardData2[0];
//							MidCard[4]=btCardData2[1];
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									bThreeSame=true;
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									bThreeSame=true;
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//					}
//				}
//			}
//		}
//		if(bThreeSame==false)
//		{
//			if(tagCardType.bStraight)     //第三敦为顺子
//			{
//				for(int i=0;i<tagCardType.btStraight;i++)           
//				{
//					CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//					btCardCount=btHandCardCount;
//					for(int j=0;j<5;j++)                        
//					{
//						BackCard[j]=btCardData[tagCardType.cbStraight[i*5+j]];
//					}
//					RemoveCard(BackCard,5,btCardData,btCardCount);
//					btCardCount1=btCardCount-=5;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//					tagCardType1=GetType(btCardData1,btCardCount1);
//					if(tagCardType1.bStraight)     //剩下顺子
//					{
//						for(int j=0;j<tagCardType1.btStraight;j++)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<5;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
//							}
//							RemoveCard(MidCard,5,btCardData1,btCardCount1);
//							CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//					}
//					else if(tagCardType1.bThreeSame)    //剩下三条
//					{
//						for(int j=0;j<tagCardType1.btThreeSame;j++)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<3;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
//							}
//							RemoveCard(MidCard,3,btCardData1,btCardCount1);
//							btCardCount2=btCardCount1-=3;
//							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//							tagCardType2=GetType(btCardData2,btCardCount2);
//							if(tagCardType2.bThreeSame)  //三条
//							{
//								for(int k=0;k<3;k++)
//								{
//									FrontCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
//								}
//								RemoveCard(FrontCard,3,btCardData2,btCardCount2);
//								MidCard[3]=btCardData2[0];
//								MidCard[4]=btCardData2[1];
//							}
//							else if(tagCardType2.bTwoPare)  //两对
//							{
//								for(int k=0;k<4;k++)
//								{
//									if(k<2)
//									{
//										btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
//									}
//									else 
//									{
//										btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
//									}
//								}
//								RemoveCard(btTemp,4,btCardData2,btCardCount2);
//								FrontCard[2]=btCardData2[0];
//							}
//							else if(tagCardType2.bOnePare)  //一对
//							{
//								for(int k=0;k<2;k++)
//								{
//									btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//								}
//								RemoveCard(btTemp,2,btCardData2,btCardCount2);
//								FrontCard[2]=btCardData2[0];
//								MidCard[3]=btCardData2[1];
//								MidCard[4]=btCardData2[2];
//							}
//							else                            //散牌
//							{
//								for(int k=0;k<5;k++)
//								{
//									if(k<3)
//									{
//										FrontCard[k]=btCardData2[k];
//									}
//									else
//									{
//										MidCard[k]=btCardData2[k];
//									}
//								}
//							}
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//					}
//					else if(tagCardType1.bTwoPare)      //剩下两对
//					{
//						if(tagCardType1.btOnePare>=3)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
//							btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
//							btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
//							btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
//							btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
//							btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
//							RemoveCard(btTemp,6,btCardData1,btCardCount1);
//							FrontCard[2]=btCardData1[0];
//							MidCard[4]=btCardData1[1];
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//						else
//						{
//							for(int j=0;j<tagCardType1.btTwoPare;j++)
//							{
//								btCardCount1=btCardCount;
//								CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//								for(int k=0;k<4;k++)
//								{
//									MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
//								}
//								RemoveCard(MidCard,4,btCardData1,btCardCount1);
//								btCardCount2=btCardCount1-=4;
//								CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//								tagCardType2=GetType(btCardData2,btCardCount2);
//								if(tagCardType2.bTwoPare)  //两对
//								{
//									for(int k=0;k<4;k++)
//									{
//										if(k<3)
//										{
//											FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
//										}
//										else 
//										{
//											MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
//										}
//									}
//								}
//								else if(tagCardType2.bOnePare)  //一对
//								{
//									for(int k=0;k<2;k++)
//									{
//										btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//									}
//									RemoveCard(btTemp,2,btCardData2,btCardCount2);
//									FrontCard[2]=btCardData2[0];
//									MidCard[4]=btCardData2[1];
//								}
//								else                            //散牌
//								{
//									for(int k=0;k<4;k++)
//									{
//										if(k<3)
//										{
//											FrontCard[k]=btCardData2[k];
//										}
//										else
//										{
//											MidCard[k+1]=btCardData2[k];
//										}
//									}
//								}
//								if(bFirst)
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										bFirst=false;
//									}
//								}
//								else 
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//										IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									}
//								}
//							}
//						}
//						
//					}
//					else if(tagCardType1.bOnePare)      //剩下一对
//					{
//						for(int j=0;j<tagCardType1.btOnePare;j++)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<2;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
//							}
//							RemoveCard(MidCard,2,btCardData1,btCardCount1);
//							btCardCount2=btCardCount1-=2;
//							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//							tagCardType2=GetType(btCardData2,btCardCount2);
//							if(tagCardType2.bOnePare)  //一对
//							{
//								for(int k=0;k<2;k++)
//								{
//									btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//								}
//								RemoveCard(btTemp,2,btCardData2,btCardCount2);
//								FrontCard[2]=btCardData2[0];
//								MidCard[2]=btCardData2[1];
//								MidCard[3]=btCardData2[2];
//								MidCard[4]=btCardData2[3];
//							}
//							else                            //散牌
//							{
//								for(int k=0;k<6;k++)
//								{
//									if(k<3)
//									{
//										FrontCard[k]=btCardData2[k];
//									}
//									else
//									{
//										MidCard[k-1]=btCardData2[k];
//									}
//								}
//							}
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//					}
//					//散牌
//					btCardCount1=btCardCount;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//					MidCard[0]=btCardData1[0];
//					MidCard[1]=btCardData1[4];
//					MidCard[2]=btCardData1[5];
//					MidCard[3]=btCardData1[6];
//					MidCard[4]=btCardData1[7];
//					FrontCard[0]=btCardData1[1];
//					FrontCard[1]=btCardData1[2];
//					FrontCard[2]=btCardData1[3];
//					if(bFirst)
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//						{
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							bFirst=false;
//						}
//					}
//					else 
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//							IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//						{
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//						}
//					}
//				}
//			}
//			if(tagCardType.bThreeSame)    //第三敦为三条
//			{
//				for(int i=0;i<tagCardType.btThreeSame;i++)            
//				{
//					CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//					btCardCount=btHandCardCount;
//					for(int j=0;j<3;j++)                        
//					{
//						BackCard[j]=btCardData[tagCardType.cbThreeSame[i*3+j]];
//					}
//					RemoveCard(BackCard,3,btCardData,btCardCount);
//					btCardCount1=btCardCount-=3;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//					tagCardType1=GetType(btCardData1,btCardCount1);
//					if(tagCardType1.bThreeSame)    //剩下三条
//					{
//						for(int j=0;j<tagCardType1.btThreeSame;j++)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<3;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
//							}
//							RemoveCard(MidCard,3,btCardData1,btCardCount1);
//							btCardCount2=btCardCount1-=3;
//							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//							tagCardType2=GetType(btCardData2,btCardCount2);
//							if(tagCardType2.bThreeSame)  //三条
//							{
//								for(int k=0;k<3;k++)
//								{
//									FrontCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
//								}
//								RemoveCard(FrontCard,3,btCardData2,btCardCount2);
//								MidCard[3]=btCardData2[0];
//								MidCard[4]=btCardData2[1];
//								BackCard[3]=btCardData2[2];
//								BackCard[4]=btCardData2[3];
//							}
//							else if(tagCardType2.bTwoPare)  //两对
//							{
//								for(int k=0;k<4;k++)
//								{
//									if(k<2)
//									{
//										btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
//									}
//									else 
//									{
//										btTemp[k]=BackCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
//									}
//								}
//								RemoveCard(btTemp,4,btCardData2,btCardCount2);
//								FrontCard[2]=btCardData2[0];
//								MidCard[3]=btCardData2[1];
//								MidCard[4]=btCardData2[2];
//							}
//							else if(tagCardType2.bOnePare)  //一对
//							{
//								for(int k=0;k<2;k++)
//								{
//									btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//								}
//								RemoveCard(btTemp,2,btCardData2,btCardCount2);
//								FrontCard[2]=btCardData2[0];
//								MidCard[3]=btCardData2[1];
//								MidCard[4]=btCardData2[2];
//								BackCard[3]=btCardData2[3];
//								BackCard[4]=btCardData2[4];
//							}
//							else                            //散牌
//							{
//								FrontCard[0]=btCardData2[0];
//								FrontCard[1]=btCardData2[1];
//								FrontCard[2]=btCardData2[2];
//								MidCard[3]=btCardData2[3];
//								MidCard[4]=btCardData2[4];
//								BackCard[3]=btCardData2[5];
//								BackCard[4]=btCardData2[6];
//							}
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//					}
//					else if(tagCardType1.bTwoPare)      //剩下两对
//					{
//						if(tagCardType1.btOnePare>=3)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
//							btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
//							btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
//							btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
//							btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
//							btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
//							RemoveCard(btTemp,6,btCardData1,btCardCount1);
//							FrontCard[2]=btCardData1[0];
//							MidCard[4]=btCardData1[1];
//							BackCard[3]=btCardData1[2];
//							BackCard[4]=btCardData1[3];
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									btFrontAllShuiShu=btAllShuiShu;
//								}
//							}
//						}
//						else
//						{
//							for(int j=0;j<tagCardType1.btTwoPare;j++)
//							{
//								btCardCount1=btCardCount;
//								CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//								for(int k=0;k<4;k++)
//								{
//									MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
//								}
//								RemoveCard(MidCard,4,btCardData1,btCardCount1);
//								btCardCount2=btCardCount1-=4;
//								CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//								tagCardType2=GetType(btCardData2,btCardCount2);
//								if(tagCardType2.bTwoPare)  //两对
//								{
//									for(int k=0;k<4;k++)
//									{
//										if(k<3)
//										{
//											btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
//										}
//										else 
//										{
//											btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
//										}
//									}
//									RemoveCard(btTemp,4,btCardData2,btCardCount2);
//									BackCard[3]=btCardData2[0];
//									BackCard[4]=btCardData2[1];
//								}
//								else if(tagCardType2.bOnePare)  //一对
//								{
//									for(int k=0;k<2;k++)
//									{
//										btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//									}
//									RemoveCard(btTemp,2,btCardData2,btCardCount2);
//									FrontCard[2]=btCardData2[0];
//									MidCard[4]=btCardData2[1];
//									BackCard[3]=btCardData2[2];
//									BackCard[4]=btCardData2[3];
//								}
//								else                            //散牌
//								{
//									FrontCard[0]=btCardData2[0];
//									FrontCard[1]=btCardData2[1];
//									FrontCard[2]=btCardData2[2];
//									MidCard[4]=btCardData2[3];
//									BackCard[3]=btCardData2[4];
//									BackCard[4]=btCardData2[5];
//								}
//								if(bFirst)
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										bFirst=false;
//									}
//								}
//								else 
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//										IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									}
//								}
//							}
//						}
//						
//					}
//					else if(tagCardType1.bOnePare)      //剩下一对
//					{
//						for(int j=0;j<tagCardType1.btOnePare;j++)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<2;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
//							}
//							RemoveCard(MidCard,2,btCardData1,btCardCount1);
//							btCardCount2=btCardCount1-=2;
//							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//							tagCardType2=GetType(btCardData2,btCardCount2);
//							if(tagCardType2.bOnePare)  //一对
//							{
//								for(int k=0;k<2;k++)
//								{
//									btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//								}
//								RemoveCard(btTemp,2,btCardData2,btCardCount2);
//								FrontCard[2]=btCardData2[0];
//								MidCard[2]=btCardData2[1];
//								MidCard[3]=btCardData2[2];
//								MidCard[4]=btCardData2[3];
//								BackCard[3]=btCardData2[4];
//								BackCard[4]=btCardData2[5];
//							}
//							else                            //散牌
//							{
//								FrontCard[0]=btCardData2[0];
//								FrontCard[1]=btCardData2[1];
//								FrontCard[2]=btCardData2[2];
//								MidCard[2]=btCardData2[3];
//								MidCard[3]=btCardData2[4];
//								MidCard[4]=btCardData2[5];
//								BackCard[3]=btCardData2[6];
//								BackCard[4]=btCardData2[7];
//							}
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//					}
//					//散牌
//					btCardCount1=btCardCount;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//					MidCard[0]=btCardData1[0];
//					MidCard[1]=btCardData1[4];
//					MidCard[2]=btCardData1[5];
//					MidCard[3]=btCardData1[6];
//					MidCard[4]=btCardData1[7];
//					BackCard[3]=btCardData1[8];
//					BackCard[4]=btCardData1[9];
//					FrontCard[0]=btCardData1[1];
//					FrontCard[1]=btCardData1[2];
//					FrontCard[2]=btCardData1[3];
//					if(bFirst)
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//						{
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							bFirst=false;
//						}
//					}
//					else 
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//							IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//						{
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//						}
//					}
//				}
//			}
//			if(tagCardType.bTwoPare)      //第三敦为两对
//			{
//				if(tagCardType.btOnePare<4)
//				{
//					for(int i=0;i<tagCardType.btTwoPare;i++)            
//					{
//						CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//						btCardCount=btHandCardCount;
//						for(int j=0;j<4;j++)                        
//						{
//							BackCard[j]=btCardData[tagCardType.cbTwoPare[i*4+j]];
//						}
//						RemoveCard(BackCard,4,btCardData,btCardCount);
//						btCardCount1=btCardCount-=4;
//						CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//						tagCardType1=GetType(btCardData1,btCardCount1);
//						if(tagCardType1.bTwoPare)      //剩下两对
//						{
//							if(tagCardType1.btOnePare>=3)
//							{
//								btCardCount1=btCardCount;
//								CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//								btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
//								btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
//								btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
//								btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
//								btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
//								btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
//								RemoveCard(btTemp,6,btCardData1,btCardCount1);
//								FrontCard[2]=btCardData1[0];
//								MidCard[4]=btCardData1[1];
//								BackCard[4]=btCardData1[2];
//								if(bFirst)
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
//										bFirst=false;
//									}
//								}
//								else 
//								{
//									btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//										IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										btFrontAllShuiShu=btAllShuiShu;
//									}
//								}
//							}
//							else
//							{
//								for(int j=0;j<tagCardType1.btTwoPare;j++)
//								{
//									btCardCount1=btCardCount;
//									CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//									for(int k=0;k<4;k++)
//									{
//										MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
//									}
//									RemoveCard(MidCard,4,btCardData1,btCardCount1);
//									btCardCount2=btCardCount1-=4;
//									CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//									tagCardType2=GetType(btCardData2,btCardCount2);
//									if(tagCardType2.bTwoPare)  //两对
//									{
//										for(int k=0;k<4;k++)
//										{
//											if(k<3)
//											{
//												btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
//											}
//											else 
//											{
//												btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
//											}
//										}
//										RemoveCard(btTemp,4,btCardData2,btCardCount2);
//										BackCard[4]=btCardData2[0];
//									}
//									else if(tagCardType2.bOnePare)  //一对
//									{
//										for(int k=0;k<2;k++)
//										{
//											btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//										}
//										RemoveCard(btTemp,2,btCardData2,btCardCount2);
//										FrontCard[2]=btCardData2[0];
//										MidCard[4]=btCardData2[1];
//										BackCard[4]=btCardData2[2];
//									}
//									else                            //散牌
//									{
//										FrontCard[0]=btCardData2[0];
//										FrontCard[1]=btCardData2[1];
//										FrontCard[2]=btCardData2[2];
//										MidCard[4]=btCardData2[3];
//										BackCard[4]=btCardData2[4];
//									}
//									if(bFirst)
//									{
//										if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//										{
//											CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//											CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//											CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//											bFirst=false;
//										}
//									}
//									else 
//									{
//										if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//											IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//										{
//											CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//											CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//											CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										}
//									}
//								}
//							}
//
//						}
//						else if(tagCardType1.bOnePare)      //剩下一对
//						{
//							for(int j=0;j<tagCardType1.btOnePare;j++)
//							{
//								btCardCount1=btCardCount;
//								CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//								for(int k=0;k<2;k++)
//								{
//									MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
//								}
//								RemoveCard(MidCard,2,btCardData1,btCardCount1);
//								btCardCount2=btCardCount1-=2;
//								CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//								tagCardType2=GetType(btCardData2,btCardCount2);
//								if(tagCardType2.bOnePare)  //一对
//								{
//									for(int k=0;k<2;k++)
//									{
//										btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//									}
//									RemoveCard(btTemp,2,btCardData2,btCardCount2);
//									FrontCard[2]=btCardData2[0];
//									MidCard[2]=btCardData2[1];
//									MidCard[3]=btCardData2[2];
//									MidCard[4]=btCardData2[3];
//									BackCard[4]=btCardData2[4];
//								}
//								else                            //散牌
//								{
//									FrontCard[0]=btCardData2[0];
//									FrontCard[1]=btCardData2[1];
//									FrontCard[2]=btCardData2[2];
//									MidCard[2]=btCardData2[3];
//									MidCard[3]=btCardData2[4];
//									MidCard[4]=btCardData2[5];
//									BackCard[4]=btCardData2[6];
//								}
//								if(bFirst)
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//										bFirst=false;
//									}
//								}
//								else 
//								{
//									if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//										IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//									{
//										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									}
//								}
//							}
//						}
//						//散牌
//						btCardCount1=btCardCount;
//						CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//						MidCard[0]=btCardData1[0];
//						MidCard[1]=btCardData1[4];
//						MidCard[2]=btCardData1[5];
//						MidCard[3]=btCardData1[6];
//						MidCard[4]=btCardData1[7];
//						BackCard[4]=btCardData1[8];
//						FrontCard[0]=btCardData1[1];
//						FrontCard[1]=btCardData1[2];
//						FrontCard[2]=btCardData1[3];
//						if(bFirst)
//						{
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								bFirst=false;
//							}
//						}
//						else 
//						{
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//								IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							}
//						}
//					}
//				}
//				else
//				{
//					if(tagCardType.btOnePare==4)
//					{
//						CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//						btCardCount=btHandCardCount;
//						btTemp[0]=BackCard[0]=btCardData[tagCardType.cbOnePare[0]];
//						btTemp[1]=BackCard[1]=btCardData[tagCardType.cbOnePare[1]];
//						btTemp[2]=BackCard[2]=btCardData[tagCardType.cbOnePare[6]];
//						btTemp[3]=BackCard[3]=btCardData[tagCardType.cbOnePare[7]];
//						btTemp[4]=MidCard[0]=btCardData[tagCardType.cbOnePare[2]];
//						btTemp[5]=MidCard[1]=btCardData[tagCardType.cbOnePare[3]];
//						btTemp[6]=MidCard[2]=btCardData[tagCardType.cbOnePare[4]];
//						btTemp[7]=MidCard[3]=btCardData[tagCardType.cbOnePare[5]];
//						RemoveCard(btTemp,8,btCardData,btCardCount);
//						FrontCard[0]=btCardData[0];
//						FrontCard[1]=btCardData[1];
//						FrontCard[2]=btCardData[2];
//						MidCard[4]=btCardData[3];
//						BackCard[4]=btCardData[4];
//						if(GetCardLogicValue(FrontCard[0])==14&&GetCardLogicValue(FrontCard[1])==13)
//						{
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));   
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//						else
//						{
//							CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//							btCardCount=btHandCardCount;
//							btTemp[0]=BackCard[0]=btCardData[tagCardType.cbOnePare[4]];
//							btTemp[1]=BackCard[1]=btCardData[tagCardType.cbOnePare[5]];
//							btTemp[2]=BackCard[2]=btCardData[tagCardType.cbOnePare[6]];
//							btTemp[3]=BackCard[3]=btCardData[tagCardType.cbOnePare[7]];
//							btTemp[4]=MidCard[0]=btCardData[tagCardType.cbOnePare[0]];
//							btTemp[5]=MidCard[1]=btCardData[tagCardType.cbOnePare[1]];
//							btTemp[6]=FrontCard[0]=btCardData[tagCardType.cbOnePare[2]];
//							btTemp[7]=FrontCard[1]=btCardData[tagCardType.cbOnePare[3]];
//							RemoveCard(btTemp,8,btCardData,btCardCount);
//							FrontCard[2]=btCardData[0];
//							MidCard[2]=btCardData[1];
//							MidCard[3]=btCardData[2];
//							MidCard[4]=btCardData[3];
//							BackCard[4]=btCardData[4];
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//					}
//					else if(tagCardType.btOnePare==5)
//					{
//						CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//						btCardCount=btHandCardCount;
//						btTemp[0]=FrontCard[0]=btCardData[tagCardType.cbOnePare[0]];
//						btTemp[1]=FrontCard[1]=btCardData[tagCardType.cbOnePare[1]];
//						btTemp[2]=MidCard[0]=btCardData[tagCardType.cbOnePare[4]];
//						btTemp[3]=MidCard[1]=btCardData[tagCardType.cbOnePare[5]];
//						btTemp[4]=MidCard[2]=btCardData[tagCardType.cbOnePare[6]];
//						btTemp[5]=MidCard[3]=btCardData[tagCardType.cbOnePare[7]];
//						btTemp[6]=BackCard[0]=btCardData[tagCardType.cbOnePare[2]];
//						btTemp[7]=BackCard[1]=btCardData[tagCardType.cbOnePare[3]];
//						btTemp[8]=BackCard[2]=btCardData[tagCardType.cbOnePare[8]];
//						btTemp[9]=BackCard[3]=btCardData[tagCardType.cbOnePare[9]];
//						RemoveCard(btTemp,10,btCardData,btCardCount);
//						FrontCard[2]=btCardData[0];
//						MidCard[4]=btCardData[1];
//						BackCard[4]=btCardData[2];
//						if(bFirst)
//						{
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));   
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								bFirst=false;
//							}
//						}
//						else 
//						{
//							if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//								IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//							{
//								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							}
//						}
//					}
//				}
//			}
//			if(tagCardType.bOnePare)      //第三敦为一对
//			{
//				for(int i=0;i<tagCardType.btOnePare;i++)            
//				{
//					CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//					btCardCount=btHandCardCount;
//					for(int j=0;j<2;j++)                        
//					{
//						BackCard[j]=btCardData[tagCardType.cbOnePare[i*2+j]];
//					}
//					RemoveCard(BackCard,2,btCardData,btCardCount);
//					btCardCount1=btCardCount-=2;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//					tagCardType1=GetType(btCardData1,btCardCount1);
//					if(tagCardType1.bOnePare)      //剩下一对
//					{
//						for(int j=0;j<tagCardType1.btOnePare;j++)
//						{
//							btCardCount1=btCardCount;
//							CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//							for(int k=0;k<2;k++)
//							{
//								MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
//							}
//							RemoveCard(MidCard,2,btCardData1,btCardCount1);
//							btCardCount2=btCardCount1-=2;
//							CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
//							tagCardType2=GetType(btCardData2,btCardCount2);
//							if(tagCardType2.bOnePare)  //一对
//							{
//								for(int k=0;k<2;k++)
//								{
//									btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
//								}
//								RemoveCard(btTemp,2,btCardData2,btCardCount2);
//								FrontCard[2]=btCardData2[0];
//								MidCard[2]=btCardData2[1];
//								MidCard[3]=btCardData2[2];
//								MidCard[4]=btCardData2[3];
//								BackCard[2]=btCardData2[4];
//								BackCard[3]=btCardData2[5];
//								BackCard[4]=btCardData2[6];
//							}
//							else                            //散牌
//							{
//								FrontCard[0]=btCardData2[0];
//								FrontCard[1]=btCardData2[1];
//								FrontCard[2]=btCardData2[2];
//								MidCard[2]=btCardData2[3];
//								MidCard[3]=btCardData2[4];
//								MidCard[4]=btCardData2[5];
//								BackCard[2]=btCardData2[6];
//								BackCard[3]=btCardData2[7];
//								BackCard[4]=btCardData2[8];
//							}
//							if(bFirst)
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//									bFirst=false;
//								}
//							}
//							else 
//							{
//								if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//									IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//								{
//									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//								}
//							}
//						}
//					}
//					//散牌
//					btCardCount1=btCardCount;
//					CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//					MidCard[0]=btCardData1[0];
//					MidCard[1]=btCardData1[4];
//					MidCard[2]=btCardData1[5];
//					MidCard[3]=btCardData1[6];
//					MidCard[4]=btCardData1[7];
//					BackCard[2]=btCardData1[8];
//					BackCard[3]=btCardData1[9];
//					BackCard[4]=btCardData1[10];
//					FrontCard[0]=btCardData1[1];
//					FrontCard[1]=btCardData1[2];
//					FrontCard[2]=btCardData1[3];
//					if(bFirst)
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//						{
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//							bFirst=false;
//						}
//					}
//					else 
//					{
//						if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//							IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//						{
//							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//						}
//					}
//				}
//			}
//		}
//	}
//	else if(tagCardType.bThreeSame)//有三条
//	{
//		CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//		btCardCount=btHandCardCount;
//		for(int i=0;i<3;i++)
//		{
//			FrontBackCard[i]=btCardData[tagCardType.cbThreeSame[i]];
//		}
//		RemoveCard(FrontBackCard,3,btCardData,btCardCount);
//		btCardCount1=btCardCount-=3;
//		CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
//		FrontFrontCard[0]=btCardData1[1];
//		FrontFrontCard[1]=btCardData1[2];
//		FrontFrontCard[2]=btCardData1[3];
//		FrontMidCard[0]=btCardData1[0];
//		FrontMidCard[1]=btCardData1[4];
//		FrontMidCard[2]=btCardData1[5];
//		FrontMidCard[3]=btCardData1[6];
//		FrontMidCard[4]=btCardData1[7];
//		FrontBackCard[3]=btCardData1[8];
//		FrontBackCard[4]=btCardData1[9];
//
//	}
//	else if(tagCardType.bTwoPare)//有两对
//	{
//		if(tagCardType.btOnePare==2)
//		{
//			CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//			btCardCount=btHandCardCount;
//			btTemp[0]=FrontBackCard[0]=btCardData[tagCardType.cbOnePare[0]];
//			btTemp[1]=FrontBackCard[1]=btCardData[tagCardType.cbOnePare[1]];
//			btTemp[2]=FrontMidCard[0]=btCardData[tagCardType.cbOnePare[2]];
//			btTemp[3]=FrontMidCard[1]=btCardData[tagCardType.cbOnePare[3]];
//			RemoveCard(btTemp,4,btCardData,btCardCount);
//			FrontFrontCard[0]=btCardData[0];
//			FrontFrontCard[1]=btCardData[1];
//			FrontFrontCard[2]=btCardData[2];
//			FrontMidCard[2]=btCardData[3];
//			FrontMidCard[3]=btCardData[4];
//			FrontMidCard[4]=btCardData[5];
//			FrontBackCard[2]=btCardData[6];
//			FrontBackCard[3]=btCardData[7];
//			FrontBackCard[4]=btCardData[8];
//		}
//		else if(tagCardType.btOnePare==3)
//		{
//			CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//			btCardCount=btHandCardCount;
//
//			btTemp[0]=FrontBackCard[0]=btCardData[tagCardType.cbOnePare[0]];
//			btTemp[1]=FrontBackCard[1]=btCardData[tagCardType.cbOnePare[1]];
//			btTemp[2]=FrontMidCard[0]=btCardData[tagCardType.cbOnePare[2]];
//			btTemp[3]=FrontMidCard[1]=btCardData[tagCardType.cbOnePare[3]];
//			btTemp[4]=FrontFrontCard[0]=btCardData[tagCardType.cbOnePare[4]];
//			btTemp[5]=FrontFrontCard[1]=btCardData[tagCardType.cbOnePare[5]];
//			RemoveCard(btTemp,6,btCardData,btCardCount);
//			FrontFrontCard[2]=btCardData[0];
//			FrontMidCard[2]=btCardData[1];
//			FrontMidCard[3]=btCardData[2];
//			FrontMidCard[4]=btCardData[3];
//			FrontBackCard[2]=btCardData[4];
//			FrontBackCard[3]=btCardData[5];
//			FrontBackCard[4]=btCardData[6];
//		}
//		else if(tagCardType.btOnePare==4)
//		{
//			CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//			btCardCount=btHandCardCount;
//			btTemp[0]=BackCard[0]=btCardData[tagCardType.cbOnePare[0]];
//			btTemp[1]=BackCard[1]=btCardData[tagCardType.cbOnePare[1]];
//			btTemp[2]=BackCard[2]=btCardData[tagCardType.cbOnePare[6]];
//			btTemp[3]=BackCard[3]=btCardData[tagCardType.cbOnePare[7]];
//			btTemp[4]=MidCard[0]=btCardData[tagCardType.cbOnePare[2]];
//			btTemp[5]=MidCard[1]=btCardData[tagCardType.cbOnePare[3]];
//			btTemp[6]=MidCard[2]=btCardData[tagCardType.cbOnePare[4]];
//			btTemp[7]=MidCard[3]=btCardData[tagCardType.cbOnePare[5]];
//			RemoveCard(btTemp,8,btCardData,btCardCount);
//			FrontCard[0]=btCardData[0];
//			FrontCard[1]=btCardData[1];
//			FrontCard[2]=btCardData[2];
//			MidCard[4]=btCardData[3];
//			BackCard[4]=btCardData[4];
//			if(GetCardLogicValue(FrontCard[0])==14&&GetCardLogicValue(FrontCard[1])==13)
//			{
//				if(bFirst)
//				{
//					if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//					{
//						CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));   
//						CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//						CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//						bFirst=false;
//					}
//				}
//				else 
//				{
//					if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//						IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//					{
//						CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//						CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//						CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//					}
//				}
//			}
//			else
//			{
//				CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//				btCardCount=btHandCardCount;
//				btTemp[0]=BackCard[0]=btCardData[tagCardType.cbOnePare[4]];
//				btTemp[1]=BackCard[1]=btCardData[tagCardType.cbOnePare[5]];
//				btTemp[2]=BackCard[2]=btCardData[tagCardType.cbOnePare[6]];
//				btTemp[3]=BackCard[3]=btCardData[tagCardType.cbOnePare[7]];
//				btTemp[4]=MidCard[0]=btCardData[tagCardType.cbOnePare[0]];
//				btTemp[5]=MidCard[1]=btCardData[tagCardType.cbOnePare[1]];
//				btTemp[6]=FrontCard[0]=btCardData[tagCardType.cbOnePare[2]];
//				btTemp[7]=FrontCard[1]=btCardData[tagCardType.cbOnePare[3]];
//				RemoveCard(btTemp,8,btCardData,btCardCount);
//				FrontCard[2]=btCardData[0];
//				MidCard[2]=btCardData[1];
//				MidCard[3]=btCardData[2];
//				MidCard[4]=btCardData[3];
//				BackCard[4]=btCardData[4];
//				if(bFirst)
//				{
//					if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
//					{
//						CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//						CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//						CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//						bFirst=false;
//					}
//				}
//				else 
//				{
//					if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
//						IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
//					{
//						CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
//						CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
//						CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
//					}
//				}
//			}
//		}
//		else if(tagCardType.btOnePare==5)
//		{
//			
//			CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
//			btCardCount=btHandCardCount;
//			btTemp[0]=FrontFrontCard[0]=btCardData[tagCardType.cbOnePare[0]];
//			btTemp[1]=FrontFrontCard[1]=btCardData[tagCardType.cbOnePare[1]];
//			btTemp[2]=FrontMidCard[0]=btCardData[tagCardType.cbOnePare[4]];
//			btTemp[3]=FrontMidCard[1]=btCardData[tagCardType.cbOnePare[5]];
//			btTemp[4]=FrontMidCard[2]=btCardData[tagCardType.cbOnePare[6]];
//			btTemp[5]=FrontMidCard[3]=btCardData[tagCardType.cbOnePare[7]];
//			btTemp[6]=FrontBackCard[0]=btCardData[tagCardType.cbOnePare[2]];
//			btTemp[7]=FrontBackCard[1]=btCardData[tagCardType.cbOnePare[3]];
//			btTemp[8]=FrontBackCard[2]=btCardData[tagCardType.cbOnePare[8]];
//			btTemp[9]=FrontBackCard[3]=btCardData[tagCardType.cbOnePare[9]];
//			RemoveCard(btTemp,10,btCardData,btCardCount);
//			FrontFrontCard[2]=btCardData[0];
//			FrontMidCard[4]=btCardData[1];
//			FrontBackCard[4]=btCardData[2];
//		}
//	}
//
//	SortCardList(FrontFrontCard,3);
//	SortCardList(FrontMidCard,5);
//	SortCardList(FrontBackCard,5);
//	CopyMemory(btFrontCard,FrontFrontCard,sizeof(FrontFrontCard));
//	CopyMemory(btMidCard,FrontMidCard,sizeof(FrontMidCard));
//	CopyMemory(btBackCard,FrontBackCard,sizeof(FrontBackCard));
//}
//
//BYTE CGameLogic::ThreeDunAllShuiShu( BYTE btFrontCard[],BYTE btMidCard[],BYTE btBackCard[] )
//{
//	BYTE AllShuiShu=0;
//	tagAnalyseType tagCardType1;
//	tagAnalyseType tagCardType2;
//	tagAnalyseType tagCardType3;
//	ZeroMemory(&tagCardType1,sizeof(tagCardType1));
//	ZeroMemory(&tagCardType2,sizeof(tagCardType2));
//	ZeroMemory(&tagCardType3,sizeof(tagCardType3));
//	tagCardType1=GetType(btFrontCard,3);
//	tagCardType2=GetType(btMidCard,5);
//	tagCardType3=GetType(btBackCard,5);
//	if(tagCardType1.bThreeSame)
//	{
//		AllShuiShu+=3;
//	}
//	else 
//	{
//		AllShuiShu+=1;
//	}
//
//	if(tagCardType2.btFiveSame)
//	{
//		AllShuiShu+=20;
//	}
//	else if(tagCardType2.bStraightFlush)
//	{
//		AllShuiShu+=10;
//	}
//	else if(tagCardType2.bFourSame)
//	{
//		AllShuiShu+=8;
//	}
//	else if(tagCardType2.bGourd)
//	{
//		AllShuiShu+=2;
//	}
//	else 
//	{
//		AllShuiShu+=1;
//	}
//
//    if (tagCardType3.btFiveSame)
//    {
//		AllShuiShu+=10;
//    }
//	if(tagCardType3.bStraightFlush)
//	{
//		AllShuiShu+=5;
//	}
//	else if(tagCardType3.bFourSame)
//	{
//		AllShuiShu+=4;
//	}
//	else 
//	{
//		AllShuiShu+=1;
//	}
//	return AllShuiShu;
//}
//
//bool CGameLogic::IsBiggerThanFront( BYTE btFrontFrontCard[],BYTE btFrontMidCard[],BYTE btFrontBackCard[],BYTE btFrontCard[],BYTE btMidCard[],BYTE btBackCard[])
//{
//	int btFrontShuiShu=ThreeDunAllShuiShu(btFrontFrontCard,btFrontMidCard,btFrontBackCard);
//	int btShuiShu=ThreeDunAllShuiShu(btFrontCard,btMidCard,btBackCard);
//	tagAnalyseType tagFrontFrontCardType;
//	tagAnalyseType tagFrontMidCardType;
//	tagAnalyseType tagFrontBackCardType;
//	tagAnalyseType tagFrontCardType;
//	tagAnalyseType tagMidCardType;
//	tagAnalyseType tagBackCardType;
//	ZeroMemory(&tagFrontFrontCardType,sizeof(tagFrontFrontCardType));
//	ZeroMemory(&tagFrontMidCardType,sizeof(tagFrontMidCardType));
//	ZeroMemory(&tagFrontBackCardType,sizeof(tagFrontBackCardType));
//	ZeroMemory(&tagFrontCardType,sizeof(tagFrontCardType));
//	ZeroMemory(&tagMidCardType,sizeof(tagMidCardType));  
//	ZeroMemory(&tagBackCardType,sizeof(tagBackCardType));
//	tagFrontFrontCardType=GetType(btFrontFrontCard,3);
//	tagFrontMidCardType=GetType(btFrontMidCard,5);
//	tagFrontBackCardType=GetType(btFrontBackCard,5);
//	tagFrontCardType=GetType(btFrontCard,3);
//	tagMidCardType=GetType(btMidCard,5);
//	tagBackCardType=GetType(btBackCard,5);
//	int btFrontWin=0;
//	int btWin=0;
//	int btCompare=0;
//    
//	int btFrontCanWin=0;
//	int btCanWin=0;
//	if(IsSameCardData(btFrontFrontCard,btFrontCard,3,3)==false)
//	{
//		if(!(tagFrontFrontCardType.bThreeSame&&tagFrontCardType.bThreeSame))
//		{
//			if(CompareCard(btFrontFrontCard,btFrontCard,3,3,true))
//			{
//                
//				btCompare++;
//			}
//			else
//			{
//				btCompare--;
//			}
//		}
//	}
//	
//	if(IsSameCardData(btFrontMidCard,btMidCard,5,5)==false)
//	{
//		if(!(tagFrontMidCardType.bThreeSame&&tagMidCardType.bThreeSame))
//		{
//			if(CompareCard(btFrontMidCard,btMidCard,5,5,true))
//			{
//				btCompare++;
//			}
//			else
//			{
//				btCompare--;
//			}
//		}
//		else 
//		{
//			BYTE btSpecialCard[13];
//			ZeroMemory(btSpecialCard,sizeof(btSpecialCard));
//            if(GetCardType(btMidCard,5,btSpecialCard)>GetCardType(btFrontMidCard,5,btSpecialCard))
//			{
//               btCompare++;
//			}
//			else if(GetCardType(btMidCard,5,btSpecialCard)<GetCardType(btFrontMidCard,5,btSpecialCard))
//			{
//               btCompare--;
//			}
//		}
//	}
//
//	if(IsSameCardData(btFrontBackCard,btBackCard,5,5)==false)
//	{
//		if(!(tagFrontBackCardType.bThreeSame&&tagBackCardType.bThreeSame))
//		{
//			if(CompareCard(btFrontBackCard,btBackCard,5,5,true))
//			{
//				btCompare++;
//			}
//			else
//			{
//				btCompare--;
//			}
//		}
//		else 
//		{
//			BYTE btSpecialCard[13];
//			ZeroMemory(btSpecialCard,sizeof(btSpecialCard));
//			if(GetCardType(btBackCard,5,btSpecialCard)>GetCardType(btFrontBackCard,5,btSpecialCard))
//			{
//				btCompare++;
//			}
//			else if(GetCardType(btBackCard,5,btSpecialCard)<GetCardType(btFrontBackCard,5,btSpecialCard))
//			{
//				btCompare--;
//			}
//		}
//	}
//	//前面的牌
//	if(tagFrontFrontCardType.bThreeSame)
//	{
//		btFrontWin+=1;
//		btFrontCanWin+=3;
//	}
//	else if(tagFrontFrontCardType.bOnePare)
//	{
//		btFrontWin+=1;
//		btFrontCanWin+=1;
//	}
//	else
//	{
//		if(GetCardLogicValue(btFrontFrontCard[0])==14)
//		{
//            btFrontWin+=0;
//			btFrontCanWin+=0;
//		}
//		else
//		{
//			btFrontWin+=-1;
//			btFrontCanWin+=-1;
//		}
//		
//	}
//    //第二敦
//	if(tagFrontMidCardType.bFiveSame)
//	{
//		btFrontWin+=1;
//		btFrontCanWin+=20;
//	}
//	if(tagFrontMidCardType.bStraightFlush)
//	{
//		btFrontWin+=1;
//		btFrontCanWin+=10;
//	}
//	else if(tagFrontMidCardType.bFourSame)
//	{
//		btFrontWin+=1;
//		btFrontCanWin+=8;
//	}
//	else if(tagFrontMidCardType.bGourd)
//	{
//		btFrontWin+=1;
//		btFrontCanWin+=5;
//	}
//	else if(tagFrontMidCardType.bFlush)
//	{
//		btFrontWin+=1;
//		btFrontCanWin+=4;
//	}
//	else if(tagFrontMidCardType.bStraight)
//	{
//		btFrontWin+=1;
//		btFrontCanWin+=3;
//	}
//	else if(tagFrontMidCardType.bThreeSame)
//	{
//		btFrontWin+=1;
//		btFrontCanWin+=2;
//	}
//	else if(tagFrontMidCardType.bTwoPare)
//	{
//		if(GetCardLogicValue(btFrontMidCard[tagFrontMidCardType.cbTwoPare[0]])<6)
//		{
//			btFrontWin+=0;
//			btFrontCanWin+=0;
//		}
//		else 
//		{
//			btFrontWin+=1;
//			btFrontCanWin+=1;
//		}
//	}
//	else if(tagFrontMidCardType.bOnePare)
//	{
//		if(GetCardLogicValue(btFrontMidCard[tagFrontMidCardType.cbOnePare[0]])<12)
//		{
//			btFrontWin+=-1;
//			btFrontCanWin+=-1;
//		}
//		else 
//		{
//			btFrontWin+=0;
//			btFrontCanWin+=0;
//		}
//	}
//	else
//	{
//		btFrontWin+=-1;
//		btFrontCanWin+=-2;
//	}
//
//    //第三敦
//	if (tagFrontBackCardType.bFiveSame)
//	{
//		btFrontWin+=1;
//		btFrontCanWin+=10;
//	}
//	if(tagFrontBackCardType.bStraightFlush)
//	{
//		btFrontWin+=1;
//		btFrontCanWin+=5;
//	}
//	else if(tagFrontBackCardType.bFourSame)
//	{
//		btFrontWin+=1;
//		btFrontCanWin+=4;
//	}
//	else if(tagFrontBackCardType.bGourd)
//	{
//		btFrontWin+=1;
//		btFrontCanWin+=3;
//	}
//	else if(tagFrontBackCardType.bFlush)
//	{
//		if(GetCardLogicValue(btFrontBackCard[tagFrontBackCardType.cbFlush[0]])<11)
//		{
//			btFrontWin+=0;
//            btFrontCanWin+=1;
//		}
//		else
//		{
//			btFrontWin+=1;
//			btFrontCanWin+=2;
//		}
//	}
//	else if(tagFrontBackCardType.bStraight)
//	{
//		if(GetCardLogicValue(btFrontBackCard[tagFrontBackCardType.cbStraight[0]])<11)
//		{
//			btFrontWin+=-1;
//			btFrontCanWin+=-1;
//		}
//		else
//		{
//			btFrontWin+=0;
//			btFrontCanWin+=0;
//		}
//	}
//	else
//	{
//		if(tagFrontBackCardType.bThreeSame)
//		{
//           btFrontCanWin+=-2;
//		}
//		else if(tagFrontBackCardType.bTwoPare)
//		{
//			btFrontCanWin+=-3;
//		}
//		else if(tagFrontBackCardType.bOnePare)
//		{
//			btFrontCanWin+=-4;
//		}
//		else 
//		{
//			btFrontCanWin+=-5;
//		}
//		btFrontWin+=-1;
//	}
//	//现在的牌
//	if(tagFrontCardType.bThreeSame)
//	{
//		btWin+=1;
//		btCanWin+=3;
//	}
//	else if(tagFrontCardType.bOnePare)
//	{
//		btWin+=1;
//		btCanWin+=1;
//	}
//	else 
//	{
//		if(GetCardLogicValue(btFrontCard[0])==14)
//		{
//			btWin+=0;
//			btCanWin+=0;
//		}
//		else
//		{
//			btWin+=-1;
//			btCanWin+=-1;
//		}
//	}
//    //第二敦
//	if(tagMidCardType.bFiveSame)
//	{
//		btWin+=1;
//		btCanWin+=20;
//	}
//	if(tagMidCardType.bStraightFlush)
//	{
//		btWin+=1;
//		btCanWin+=10;
//	}
//	else if(tagMidCardType.bFourSame)
//	{
//		btWin+=1;
//		btCanWin+=8;
//	}
//	else if(tagMidCardType.bGourd)
//	{
//		btWin+=1;
//		btCanWin+=5;
//	}
//	else if(tagMidCardType.bFlush)
//	{
//		btWin+=1;
//		btCanWin+=4;
//	}
//	else if(tagMidCardType.bStraight)
//	{
//		btWin+=1;
//		btCanWin+=3;
//	}
//	else if(tagMidCardType.bThreeSame)
//	{
//		btWin+=1;
//		btCanWin+=2;
//	}
//	else if(tagMidCardType.bTwoPare)
//	{
//		if(GetCardLogicValue(btMidCard[tagMidCardType.cbTwoPare[0]])<6)
//		{
//			btWin+=0;
//			btCanWin+=0;
//		}
//		else 
//		{
//			btWin+=1;
//			btCanWin+=1;
//		}
//	}
//	else if(tagMidCardType.bOnePare)
//	{
//		if(GetCardLogicValue(btMidCard[tagMidCardType.cbOnePare[0]])<12)
//		{
//			btWin+=-1;
//			btCanWin+=-1;
//		}
//		else 
//		{
//			btWin+=0;
//			btCanWin+=0;
//		}
//	}
//	else
//	{
//		btWin+=-1;
//		btCanWin+=-2;
//	}
//    //第三敦
//	if(tagBackCardType.bFiveSame)
//	{
//		btWin+=1;
//		btCanWin+=10;
//	}
//	if(tagBackCardType.bStraightFlush)
//	{
//		btWin+=1;
//		btCanWin+=5;
//	}
//	else if(tagBackCardType.bFourSame)
//	{
//		btWin+=1;
//		btCanWin+=4;
//	}
//	else if(tagBackCardType.bGourd)
//	{
//		btWin+=1;
//		btCanWin+=3;
//	}
//	else if(tagBackCardType.bFlush)
//	{
//		if(GetCardLogicValue(btBackCard[tagBackCardType.cbFlush[0]])<11)
//		{
//			btWin+=0;
//			btCanWin+=1;
//		}
//		else
//		{
//			btWin+=1;
//			btCanWin+=2;
//		}
//	}
//	else if(tagBackCardType.bStraight)
//	{
//		if(GetCardLogicValue(btBackCard[tagBackCardType.cbStraight[0]])<11)
//		{
//			btWin+=-1;
//			btCanWin+=-1;
//		}
//		else
//		{
//			btWin+=0;
//			btCanWin+=0;
//		}
//	}
//	else
//	{
//		if(tagBackCardType.bThreeSame)
//		{
//			btCanWin+=-2;
//		}
//		else if(tagBackCardType.bTwoPare)
//		{
//			btCanWin+=-3;
//		}
//		else if(tagBackCardType.bOnePare)
//		{
//			btCanWin+=-4;
//		}
//		else 
//		{
//			btCanWin+=-5;
//		}
//		btWin+=-1;
//	}
//
//	if(btShuiShu==btFrontShuiShu)
//	{
//		if(btWin>btFrontWin)
//		{
//			return true;
//		}
//		else if(btWin==btFrontWin)
//		{
//			if(btCompare>=1)
//			{
//				return true;
//			}
//			else
//			{
//				if(btCanWin>btFrontCanWin)
//				{
//					return true;
//				}
//				else 
//				{
//					return false;
//				}
//			}
//		}
//		else 
//		{
//			return false;
//		}
//	}
//	else if(btShuiShu==btFrontShuiShu+1)
//	{
//		if(btFrontWin-btWin>=4)
//		{
//			return false;
//		}
//		else
//		{
//			return true;
//		}
//	}
//	else if(btShuiShu+1==btFrontShuiShu)
//	{
//		if(btWin-btFrontWin>=4)
//		{
//			return true;
//		}
//		else
//		{
//			return false;
//		}
//	}
//	else if(btShuiShu>btFrontShuiShu)
//	{
//		return true;
//	}
//	else if(btShuiShu<btFrontShuiShu)
//	{
//		return false;
//	}
//	return false;
//}

bool CGameLogic::IsSameCardData( BYTE btFirstCard[],BYTE btNextCard[],BYTE btFirstCount,BYTE btNextCount)
{
   if(btNextCount!=btFirstCount)
   {
	   return false;
   }
   for(int i=0;i<btFirstCount;i++)
   {
      if(btFirstCard[i]!=btNextCard[i])
	  {
         return false;
	  }
   }
   return true;
}

//自动摆牌
void CGameLogic::AutoPutCard(BYTE btHandCardData[],BYTE btHandCardCount,BYTE btFrontCard[],BYTE btMidCard[],BYTE btBackCard[])
{
	//定义变量
	BYTE bCardList[13] = {0};
	memcpy(bCardList, btHandCardData, sizeof(BYTE)*13);
	BYTE bLeftCCount = 13;
	BYTE bTempCard[3][5] = {0};
	BYTE bTempCCount[3] = {0};
	BYTE bSigCCount = 0;		//用于散牌填充时的计数
	BYTE bCardType[3] = {0};	


	//摆牌开始
	for (int i = 0; i < 3; i++)
	{
		bCardType[i] = GetMaxCardData(bCardList, bLeftCCount, bTempCard[i], bTempCCount[i], (i==2?3:5));
		RemoveCard(bTempCard[i], bTempCCount[i], bCardList, bLeftCCount);
		bLeftCCount -= bTempCCount[i];
	}

	ASSERT(bLeftCCount+bTempCCount[0]+bTempCCount[1]+bTempCCount[2] == 13);
	ASSERT(bTempCCount[0]<=5&&bTempCCount[1]<=5&&bTempCCount[2]<=3);

	if (bLeftCCount == 0)
		return;

	SortCardList(bCardList, bLeftCCount, enDescend);


	//散牌填充
	while (bTempCCount[2] < 3)
	{
		bTempCard[2][bTempCCount[2]++] = bCardList[bSigCCount++];
	}
	while (bTempCCount[0] < 5)
	{
		bTempCard[0][bTempCCount[0]++] = bCardList[bSigCCount++];
	}
	while (bTempCCount[1] < 5)
	{
		bTempCard[1][bTempCCount[1]++] = bCardList[bSigCCount++];
	}
	ASSERT(bSigCCount == bLeftCCount);

	//牌组填充
	memcpy(btFrontCard, bTempCard[2], sizeof(BYTE)*3);
	memcpy(btMidCard, bTempCard[1], sizeof(BYTE)*5);
	memcpy(btBackCard, bTempCard[0], sizeof(BYTE)*5);

	//if( bCardType[2] != GetCardType(bTempCard[2], 3) || 
	//	bCardType[0] != GetCardType(bTempCard[0], 5) ||
	//	bCardType[1] != GetCardType(bTempCard[1], 5))
	//	MyMsgBox(_T("前[%d %d (%x %x %x)]  中[%d %d (%x %x %x %x %x)]  后[%d %d (%x %x %x %x %x)]"),
	//		bCardType[2], GetCardType(bTempCard[2], 3), bTempCard[2][0], bTempCard[2][1], bTempCard[2][2], 
	//		bCardType[1], GetCardType(bTempCard[1], 5), bTempCard[1][0], bTempCard[1][1], bTempCard[1][2], bTempCard[1][3], bTempCard[1][4], 
	//		bCardType[0], GetCardType(bTempCard[0], 5), bTempCard[0][0], bTempCard[0][1], bTempCard[0][2], bTempCard[0][3], bTempCard[0][4]);

	return;
}

/****************************************************
*函数名：GetMaxCardData 
*功能：  从得定牌组中抽取出最大牌型的牌	JJ
*参数：	 cbCardData				原牌(3< <=13)		IN
		 cbCardCount			原牌数目			IN
		 cbMaxCardData			取出的最大牌(<=5)	OUT
		 bMaxCardCount			取出牌数目(1<= <=5) OUT
*返回值：最大类型 (用于单元测试做校验,实际无用,不能做为可靠数据)
****************************************************/
BYTE CGameLogic::GetMaxCardData(const BYTE cbCardData[], const BYTE cbCardCount, BYTE bMaxCardData[], BYTE & bMaxCardCount, BYTE bNeedCCount)
{
	//校验数据
	ASSERT(cbCardCount <= 13 || cbCardCount > 3);

	//定义变量
	BYTE bKCount = 0;
	CList<BYTE> evCardList[15];	//0位存王牌,1位保留,其他位按逻辑值存放
	CList<BYTE> evColorList[4];	//方梅红黑
	BYTE bCardArray[13] = {0};
	memcpy(bCardArray, cbCardData, sizeof(BYTE)*cbCardCount);

	SortCardList(bCardArray, cbCardCount, enDescend);

	//分析扑克
	for (int i = 0; i < cbCardCount; i++)
	{
		//保存王牌
		if (bCardArray[i] == 0x41 || bCardArray[i] == 0x42)
		{
			evCardList[0].AddTail(bCardArray[i]);
			continue;
		}

		//保存其他
		BYTE bLogicNum = GetCardLogicValue(bCardArray[i]);
		BYTE bColor = GetCardColor(bCardArray[i]);

		ASSERT(bLogicNum>1 && bLogicNum<15 && bColor>=0 && bColor<=3);
		ASSERT(evCardList[bLogicNum].Find(bCardArray[i]) == NULL);

		evCardList[bLogicNum].AddTail(bCardArray[i]);
		evColorList[bColor].AddTail(bCardArray[i]);
	}

	ASSERT(evCardList[0].GetCount() <= 2);

	//寻找同顺
	if (bNeedCCount == 5)
	{
		for (int i = 0; i < 4; i++)
		{
			if (evColorList[i].GetCount()+evCardList[0].GetCount() >= 5)	//同花+王牌数大于等于5
			{
				BYTE bCount = 0;
				if (evCardList[0].GetCount() >= 0 && evColorList[i].GetCount() >= 5)		//不带王
				{

					if (GetCardValue(evColorList[i].GetHead()) == 1 &&						//A在后同花顺
						GetCardLogicValue(evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-4))) != 5)	
					{
						
						BYTE bFstCard = evColorList[i].GetAt(evColorList[i].FindIndex(0));
						BYTE bLstCard = evColorList[i].GetAt(evColorList[i].FindIndex(4));

						if (GetCardLogicValue(bFstCard) -  GetCardLogicValue(bLstCard) == 4)
						{
							for (int k = 0; k < 5; k++)
								bMaxCardData[k] = evColorList[i].GetAt(evColorList[i].FindIndex(k));
							bMaxCardCount = 5;
							return CT_FIVE_STRAIGHT_FLUSH_BACK_A;
						}
						
					}
					else if (GetCardValue(evColorList[i].GetHead()) == 1 &&						//检查A2345顺
						GetCardLogicValue(evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-4))) == 5)	
					{
						bMaxCardData[0] = evColorList[i].GetHead();
						for (int k = 1; k < 5; k++)
							bMaxCardData[k] = evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-k));
						bMaxCardCount = 5;
						return CT_FIVE_STRAIGHT_FLUSH_FIRST_A;
					}
					else 
					{
						for (int j = 0; j < evColorList[i].GetCount()-4; j++)
						{
							BYTE bFstCard = evColorList[i].GetAt(evColorList[i].FindIndex(j));
							BYTE bLstCard = evColorList[i].GetAt(evColorList[i].FindIndex(j+4));

							if (GetCardLogicValue(bFstCard) -  GetCardLogicValue(bLstCard) == 4)
							{
								for (int k = 0; k < 5; k++)
									bMaxCardData[k] = evColorList[i].GetAt(evColorList[i].FindIndex(j+k));
								bMaxCardCount = 5;
								return CT_FIVE_STRAIGHT_FLUSH_NO_A;
							}
						}
					}

				}
				if (evCardList[0].GetCount() >= 1 && evColorList[i].GetCount() >= 4)		//带单王
				{
					if (GetCardLogicValue(evColorList[i].GetAt(evColorList[i].FindIndex(3))) >=10)	
					{
						bMaxCardData[0] = evCardList[0].GetHead();
						bMaxCardData[1] = evColorList[i].GetHead();
						for (int k = 1; k < 4; k++)
							bMaxCardData[k+1] = evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-k));
						bMaxCardCount = 5;
						return CT_FIVE_STRAIGHT_FLUSH_BACK_A;
					}
					else if (GetCardValue(evColorList[i].GetHead()) == 1 &&						//检查A2345顺
						GetCardLogicValue(evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-3))) <= 5)	
					{
						bMaxCardData[0] = evCardList[0].GetHead();
						bMaxCardData[1] = evColorList[i].GetHead();
						for (int k = 1; k < 4; k++)
							bMaxCardData[k+1] = evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-k));
						bMaxCardCount = 5;
						return CT_FIVE_STRAIGHT_FLUSH_FIRST_A;
					}
					else if (GetCardLogicValue(evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-4))) <= 5)	//检查A2345顺
					{
						bMaxCardData[0] = evCardList[0].GetHead();
						for (int k = 1; k < 5; k++)
							bMaxCardData[k] = evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-k));
						bMaxCardCount = 5;
						return CT_FIVE_STRAIGHT_FLUSH_FIRST_A;
					}
					else
					{
						for (int j = 0; j < evColorList[i].GetCount()-3; j++)
						{
							BYTE bFstCard = evColorList[i].GetAt(evColorList[i].FindIndex(j));
							BYTE bLstCard = evColorList[i].GetAt(evColorList[i].FindIndex(j+3));

							if ( (GetCardLogicValue(bFstCard) -  GetCardLogicValue(bLstCard) == 3) || 
								(GetCardLogicValue(bFstCard) -  GetCardLogicValue(bLstCard) == 4) )
							{
								bMaxCardData[0] = evCardList[0].GetHead();
								for (int k = 0; k < 4; k++)
									bMaxCardData[k+1] = evColorList[i].GetAt(evColorList[i].FindIndex(j+k));
								bMaxCardCount = 5;
								return CT_FIVE_STRAIGHT_FLUSH_NO_A;
							}
						}
					}
				}
				if (evCardList[0].GetCount() == 2 && evColorList[i].GetCount() >= 3)		//带双王
				{
					if (GetCardLogicValue(evColorList[i].GetAt(evColorList[i].FindIndex(2))) >=10)	
					{
						bMaxCardData[0] = evCardList[0].GetHead();
						bMaxCardData[1] = evCardList[0].GetTail();
						for (int k = 1; k < 4; k++)
							bMaxCardData[k+1] = evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-k));
						bMaxCardCount = 5;
						return CT_FIVE_STRAIGHT_FLUSH_BACK_A;
					}
					else if (GetCardValue(evColorList[i].GetHead()) == 1 &&						//检查A2345顺
						GetCardLogicValue(evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-2))) <= 5)	
					{
						bMaxCardData[0] = evCardList[0].GetHead();
						bMaxCardData[1] = evCardList[0].GetTail();
						bMaxCardData[2] = evColorList[i].GetHead();
						for (int k = 1; k < 3; k++)
							bMaxCardData[k+2] = evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-k));
						bMaxCardCount = 5;
						return CT_FIVE_STRAIGHT_FLUSH_FIRST_A;
					}
					else if (GetCardLogicValue(evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-3))) <= 5)	//检查A2345顺
					{
						bMaxCardData[0] = evCardList[0].GetHead();
						bMaxCardData[1] = evCardList[0].GetTail();
						for (int k = 1; k < 4; k++)
							bMaxCardData[k+2] = evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-k));
						bMaxCardCount = 5;
						return CT_FIVE_STRAIGHT_FLUSH_FIRST_A;
					}
					else
					{
						for (int j = 0; j < evColorList[i].GetCount()-2; j++)
						{
							BYTE bFstCard = evColorList[i].GetAt(evColorList[i].FindIndex(j));
							BYTE bLstCard = evColorList[i].GetAt(evColorList[i].FindIndex(j+2));

							if ( (GetCardLogicValue(bFstCard) -  GetCardLogicValue(bLstCard) == 2) ||
								(GetCardLogicValue(bFstCard) -  GetCardLogicValue(bLstCard) == 3) || 
								(GetCardLogicValue(bFstCard) -  GetCardLogicValue(bLstCard) == 4))
							{
								bMaxCardData[0] = evCardList[0].GetHead();
								bMaxCardData[1] = evCardList[0].GetTail();
								for (int k = 0; k < 3; k++)
									bMaxCardData[k+2] = evColorList[i].GetAt(evColorList[i].FindIndex(j+k));
								bMaxCardCount = 5;
								return CT_FIVE_STRAIGHT_FLUSH_NO_A;
							}
						}
					}
				}
			}
		}
	}

	//寻找五相
	if (bNeedCCount == 5)
	{
		for (int i = 14; i > 1; i--)
		{
			if (evCardList[i].GetCount()== 4 && evCardList[0].GetCount() > 0)
			{
				bMaxCardData[0] = evCardList[0].GetAt(evCardList[0].FindIndex(0));
				for (int k = 0; k < evCardList[i].GetCount(); k++)
					bMaxCardData[1+k] = evCardList[i].GetAt(evCardList[i].FindIndex(k));
				bMaxCardCount = 5;
				return CT_FIVE_BOMB;
			}
		}
		for (int i = 14; i > 1; i--)
		{
			if (evCardList[i].GetCount()== 3 && evCardList[0].GetCount() == 2)
			{
				bMaxCardData[0] = 0x42;
				bMaxCardData[1] = 0x41;
				for (int k = 0; k < evCardList[i].GetCount(); k++)
					bMaxCardData[2+k] = evCardList[i].GetAt(evCardList[i].FindIndex(k));
				bMaxCardCount = 5;
				return CT_FIVE_BOMB;
			}
		}
	}

	//寻找炸弹
	if (bNeedCCount == 5)
	{
		for (int i = 14; i > 1; i--)
		{
			if (evCardList[i].GetCount() + evCardList[0].GetCount() >= 4)
			{
				ASSERT(evCardList[i].GetCount()<=4&&evCardList[i].GetCount()>=2);
				int j = 0;
				for (; j < 4 - evCardList[i].GetCount(); j++)
				{
					bMaxCardData[j] = evCardList[0].GetAt(evCardList[0].FindIndex(j));
				}
				for (int k = 0; k < evCardList[i].GetCount(); k++)
					bMaxCardData[j+k] = evCardList[i].GetAt(evCardList[i].FindIndex(k));
				bMaxCardCount = 4;
				return CT_FIVE_FOUR_ONE;
			}
		}
	}

	//寻找葫芦
	if (bNeedCCount == 5)
	{
		for (int i = 14; i > 1; i--)
		{
			if (evCardList[i].GetCount() + evCardList[0].GetCount() == 3)
			{
				ASSERT(evCardList[i].GetCount()<=3&&evCardList[i].GetCount()>=1);
				//寻找一对
				BYTE bDoubleLogicCard = 0;
				for (int k = 2; k < 15; k++)
				{
					if (k == i) continue;
					if (evCardList[k].GetCount() >= 2)
					{
						bDoubleLogicCard = k;
						break;
					}
				}
				if (bDoubleLogicCard == 0)	break;		

				int j = 0;
				for (; j < 3 - evCardList[i].GetCount(); j++)
				{
					bMaxCardData[j] = evCardList[0].GetAt(evCardList[0].FindIndex(j));
				}
				for (int k = 0; k < evCardList[i].GetCount(); k++)
					bMaxCardData[j+k] = evCardList[i].GetAt(evCardList[i].FindIndex(k));
				bMaxCardData[3] = evCardList[bDoubleLogicCard].GetAt(evCardList[bDoubleLogicCard].FindIndex(0));
				bMaxCardData[4] = evCardList[bDoubleLogicCard].GetAt(evCardList[bDoubleLogicCard].FindIndex(1));
				bMaxCardCount = 5;
				return CT_FIVE_THREE_DEOUBLE;
			}
		}
	}

	//寻找同花
	if (bNeedCCount == 5)
	{
		BYTE bPossibleCard[4][5] = {0};	//各个能组成同花的牌组
		CList<BYTE> maxCardColorList;
		for (int i = 0; i < 4; i++)
		{
			if (evColorList[i].GetCount() + evCardList[0].GetCount() >= 5)
			{
				if (evColorList[i].GetCount() >= 5)
				{
					for (int k = 0; k < 5; k++)
					{
						bPossibleCard[i][k] = evColorList[i].GetAt(evColorList[i].FindIndex(k));
					}
				}
				else
				{
					int j = 0;
					for (; j < 5 - evColorList[i].GetCount(); j++)
					{
						bPossibleCard[i][j] = evCardList[0].GetAt(evCardList[0].FindIndex(j));
					}

					for (int k = 0; k < evColorList[i].GetCount(); k++)
					{
						bPossibleCard[i][j + k] = evColorList[i].GetAt(evColorList[i].FindIndex(k));
					}
				}
				maxCardColorList.AddTail(i);
			}
		}
		if (maxCardColorList.GetCount() != 0)		
		{
			BYTE bMax = maxCardColorList.GetAt(maxCardColorList.FindIndex(0));
			for (int i = 1; i < maxCardColorList.GetCount(); i++)
			{
				BYTE bColor = maxCardColorList.GetAt(maxCardColorList.FindIndex(i));
				if (CompareCard(bPossibleCard[bMax], bPossibleCard[bColor], 5, 5, true))
				{
					bMax = bColor;
				}
			}
			memcpy(bMaxCardData, bPossibleCard[bMax], sizeof(BYTE)*5);
			bMaxCardCount = 5;
			return CT_FIVE_FLUSH;
		}
	}

	//寻找顺子
	if (bNeedCCount == 5)
	{
		for (int i = 14; i > 4; i--)
		{
			BYTE bHaveCard[5] = {0};
			for (int k = 0; k < 4; k++)
			{
				bHaveCard[k] = (evCardList[i - k].GetCount()>0);
			}

			bHaveCard[4] = ( ((i == 5)?evCardList[14].GetCount():evCardList[i-4].GetCount()) > 0 );
			BYTE bCount = (bHaveCard[0]?1:0) + (bHaveCard[1]?1:0) + (bHaveCard[2]?1:0) + (bHaveCard[3]?1:0) + (bHaveCard[4]?1:0);
			if (bCount + evCardList[0].GetCount() >= 5)
			{
				ASSERT(bCount>=3&&bCount<=5);
				int j = 0;
				for (; j < 5 - bCount; j++)
				{
					bMaxCardData[j] = evCardList[0].GetAt(evCardList[0].FindIndex(j));
				}
				for (int k = 0; k < 4; k++)
				{
					if (bHaveCard[k])
					{
						bMaxCardData[j++] = evCardList[i-k].GetHead();
					}
				}

				BYTE bFirstCardNum = ( (i == 5)?14:i-4 );
				if (bHaveCard[4])
				{
					bMaxCardData[4] = evCardList[bFirstCardNum].GetHead();
				}

				bMaxCardCount = 5;
				
				return ((i==14)?CT_FIVE_MIXED_FLUSH_BACK_A:( (i == 5)?CT_FIVE_MIXED_FLUSH_FIRST_A:CT_FIVE_MIXED_FLUSH_NO_A ));
			}
		}
	}

	//寻找三条
	for (int i = 14; i > 1; i--)
	{
		if (evCardList[i].GetCount() + evCardList[0].GetCount() == 3)
		{
			ASSERT(evCardList[i].GetCount()<=3&&evCardList[i].GetCount()>=1);

			int j = 0;
			for (; j < 3 - evCardList[i].GetCount(); j++)
			{
				bMaxCardData[j] = evCardList[0].GetAt(evCardList[0].FindIndex(j));
			}
			for (int k = 0; k < evCardList[i].GetCount(); k++)
				bMaxCardData[j+k] = evCardList[i].GetAt(evCardList[i].FindIndex(k));
			bMaxCardCount = 3;
			return CT_THREE;
		}
	}

	//寻找两对
	if (bNeedCCount == 5)
	{
		for (int i = 14; i > 1; i--)
		{
			if (evCardList[i].GetCount() + evCardList[0].GetCount() == 2)
			{
				ASSERT(evCardList[i].GetCount()<=2&&evCardList[i].GetCount()>=0);

				//寻找一对
				BYTE bDoubleLogicCard = 0;
				for (int k = 2; k < 15; k++)
				{
					if (k == i) continue;
					if (evCardList[k].GetCount() >= 2)
					{
						bDoubleLogicCard = k;
						break;
					}
				}
				if (bDoubleLogicCard == 0)	break;	

				int j = 0;
				for (; j < 2 - evCardList[i].GetCount(); j++)
				{
					bMaxCardData[j] = evCardList[0].GetAt(evCardList[0].FindIndex(j));
				}
				for (int k = 0; k < evCardList[i].GetCount(); k++)
					bMaxCardData[j+k] = evCardList[i].GetAt(evCardList[i].FindIndex(k));

				bMaxCardData[2] = evCardList[bDoubleLogicCard].GetAt(evCardList[bDoubleLogicCard].FindIndex(0));
				bMaxCardData[3] = evCardList[bDoubleLogicCard].GetAt(evCardList[bDoubleLogicCard].FindIndex(1));

				bMaxCardCount = 4;
				return CT_FIVE_TWO_DOUBLE;
			}
		}
	}

	//寻找对子
	for (int i = 14; i > 1; i--)
	{
		if (evCardList[i].GetCount() + evCardList[0].GetCount() == 2)
		{
			ASSERT(evCardList[i].GetCount()<=2&&evCardList[i].GetCount()>=0);

			int j = 0;
			for (; j < 2 - evCardList[i].GetCount(); j++)
			{
				bMaxCardData[j] = evCardList[0].GetAt(evCardList[0].FindIndex(j));
			}
			for (int k = 0; k < evCardList[i].GetCount(); k++)
				bMaxCardData[j+k] = evCardList[i].GetAt(evCardList[i].FindIndex(k));

			bMaxCardCount = 2;
			return CT_ONE_DOUBLE;
		}
	}

	//寻找散牌
	for (int i = 14; i > 1; i--)
	{
		if (evCardList[i].GetCount() == 1)
		{
			bMaxCardCount = 1;
			bMaxCardData[0] = evCardList[i].GetHead();
			return CT_SINGLE;
		}
	}

	//MyMsgBox(_T("CGameLogic::GetMaxCardData Error!"));

	return CT_INVALID;
}

bool CGameLogic::IsFlush(const BYTE cbCardData[], const BYTE cbCardCount, BYTE bMaxCardData[], BYTE & bMaxCardCount, BYTE bNeedCCount)
{
	//校验数据
	ASSERT(cbCardCount <= 13 || cbCardCount > 3);

	//定义变量
	BYTE bKCount = 0;
	CList<BYTE> evCardList[15];	//0位存王牌,1位保留,其他位按逻辑值存放
	CList<BYTE> evColorList[4];	//方梅红黑
	BYTE bCardArray[13] = {0};
	memcpy(bCardArray, cbCardData, sizeof(BYTE)*cbCardCount);

	SortCardList(bCardArray, cbCardCount, enDescend);

	//分析扑克
	for (int i = 0; i < cbCardCount; i++)
	{
		//保存王牌
		if (bCardArray[i] == 0x41 || bCardArray[i] == 0x42)
		{
			evCardList[0].AddTail(bCardArray[i]);
			continue;
		}

		//保存其他
		BYTE bLogicNum = GetCardLogicValue(bCardArray[i]);
		BYTE bColor = GetCardColor(bCardArray[i]);

		ASSERT(bLogicNum>1 && bLogicNum<15 && bColor>=0 && bColor<=3);
		ASSERT(evCardList[bLogicNum].Find(bCardArray[i]) == NULL);

		evCardList[bLogicNum].AddTail(bCardArray[i]);
		evColorList[bColor].AddTail(bCardArray[i]);
	}

	ASSERT(evCardList[0].GetCount() <= 2);

	//寻找同花
	BYTE bPossibleCard[4][5] = {0};	//各个能组成同花的牌组
	CList<BYTE> maxCardColorList;
	for (int i = 0; i < 4; i++)
	{
		if (evColorList[i].GetCount() + evCardList[0].GetCount() >= bNeedCCount)
		{
			if (evColorList[i].GetCount() >= bNeedCCount)
			{
				for (int k = 0; k < bNeedCCount; k++)
					bPossibleCard[i][k] = evColorList[i].GetAt(evColorList[i].FindIndex(k));
			}
			else
			{
				int j = 0;
				for (; j < bNeedCCount - evColorList[i].GetCount(); j++)
				{
					bPossibleCard[i][j] = evCardList[0].GetAt(evCardList[0].FindIndex(j));
				}
				for (int k = 0; k < evColorList[i].GetCount(); k++)
					bPossibleCard[i][j+k] = evColorList[i].GetAt(evColorList[i].FindIndex(k));
			}
			maxCardColorList.AddTail(i);
		}
	}
	if (maxCardColorList.GetCount() != 0)		
	{
		BYTE bMax = maxCardColorList.GetAt(maxCardColorList.FindIndex(0));
		for (int i = 1; i < maxCardColorList.GetCount(); i++)
		{
			BYTE bColor = maxCardColorList.GetAt(maxCardColorList.FindIndex(i));
			if (CompareCard(bPossibleCard[bMax], bPossibleCard[bColor], bNeedCCount, bNeedCCount, true))
				bMax = bColor;
		}
		memcpy(bMaxCardData, bPossibleCard[bMax], sizeof(BYTE)*bNeedCCount);
		bMaxCardCount = bNeedCCount;
		return true;
	}
	return false;
}

//是否顺子
bool CGameLogic::IsStraight(const BYTE cbCardData[], const BYTE cbCardCount, BYTE cbMaxCardData[], BYTE & bMaxCardCount, BYTE bNeedCCount)
{
	//校验数据
	ASSERT(cbCardCount <= 13 || cbCardCount > 3);

	//定义变量
	BYTE bKCount = 0;
	CList<BYTE> evCardList[15];	//0位存王牌,1位保留,其他位按逻辑值存放
	CList<BYTE> evColorList[4];	//方梅红黑
	BYTE bCardArray[13] = {0};
	memcpy(bCardArray, cbCardData, sizeof(BYTE)*cbCardCount);

	SortCardList(bCardArray, cbCardCount, enDescend);

	//分析扑克
	for (int i = 0; i < cbCardCount; i++)
	{
		//保存王牌
		if (bCardArray[i] == 0x41 || bCardArray[i] == 0x42)
		{
			evCardList[0].AddTail(bCardArray[i]);
			continue;
		}

		//保存其他
		BYTE bLogicNum = GetCardLogicValue(bCardArray[i]);
		BYTE bColor = GetCardColor(bCardArray[i]);

		ASSERT(bLogicNum>1 && bLogicNum<15 && bColor>=0 && bColor<=3);
		ASSERT(evCardList[bLogicNum].Find(bCardArray[i]) == NULL);

		evCardList[bLogicNum].AddTail(bCardArray[i]);
		evColorList[bColor].AddTail(bCardArray[i]);
	}

	ASSERT(evCardList[0].GetCount() <= 2);

	//寻找顺子
	for (int i = 14; i > bNeedCCount-1; i--)
	{
		BYTE bHaveCard[5] = {0};
		for (int k = 0; k < bNeedCCount-1; k++)
			bHaveCard[k] = (evCardList[i-k].GetCount()>0);
		bHaveCard[bNeedCCount-1] = ( ((i == bNeedCCount)?evCardList[14].GetCount():evCardList[i-bNeedCCount+1].GetCount()) > 0 );

		BYTE bCount = 0;
		for (int m=0;m<bNeedCCount-1;m++)
		{
			bCount += (bHaveCard[m]?1:0) ;
		}

		if (bCount + evCardList[0].GetCount() >= bNeedCCount)
		{
			ASSERT(bCount>=bNeedCCount-2&&bCount<=bNeedCCount);
			int j = 0;
			for (; j < bNeedCCount - bCount; j++)
			{
				cbMaxCardData[j] = evCardList[0].GetAt(evCardList[0].FindIndex(j));
			}
			for (int k = 0; k < bNeedCCount-1; k++)
			{
				if (bHaveCard[k])
					cbMaxCardData[j++] = evCardList[i-k].GetHead();
			}

			BYTE bFirstCardNum = ( (i == bNeedCCount)?14:i-bNeedCCount+1 );
			if (bHaveCard[bNeedCCount-1])
				cbMaxCardData[bNeedCCount-1] = evCardList[bFirstCardNum].GetHead();

			bMaxCardCount = bNeedCCount;

			return true;
		}
	}
	return false;
}

//是否是三同花顺
bool CGameLogic::IsThreeFlushStraight(const BYTE cbCardData[], const BYTE cbCardCount)
{
	//校验数据
	ASSERT(cbCardCount <= 13 || cbCardCount>3);

	BYTE bCardList[13] = {0};
	memcpy(bCardList,cbCardData,sizeof(BYTE)*cbCardCount);
	SortCardList(bCardList,cbCardCount);
	BYTE bLeftCount = cbCardCount;
	BYTE cbStraightFlush[5] = {0};
	BYTE bTempCount = 5;

	tagAnalyseType tagCardType = GetType(bCardList,bLeftCount);
	if (tagCardType.bStraightFlush)
	{
		for (BYTE i = 0;i<tagCardType.btStraightFlush;++i)
		{
			CopyMemory(bCardList,cbCardData,sizeof(bCardList));
			bLeftCount = 13;
			SortCardList(bCardList,13);
			ZeroMemory(cbStraightFlush,sizeof(cbStraightFlush));
			cbStraightFlush[0]=bCardList[tagCardType.cbStraightFlush[i*5]];
			cbStraightFlush[1]=bCardList[tagCardType.cbStraightFlush[i*5+1]];
			cbStraightFlush[2]=bCardList[tagCardType.cbStraightFlush[i*5+2]];
			cbStraightFlush[3]=bCardList[tagCardType.cbStraightFlush[i*5+3]];
			cbStraightFlush[4]=bCardList[tagCardType.cbStraightFlush[i*5+4]];

			//移除第一个同花顺
			RemoveCard(cbStraightFlush, bTempCount, bCardList, bLeftCount);
			bLeftCount -= bTempCount;

			//备份剩余牌
			BYTE bLeftCardList[13] = {0};
			CopyMemory(bLeftCardList,bCardList,bLeftCount);
			BYTE bLeftCount1 =bLeftCount;

			tagAnalyseType tagCardType1 = GetType(bCardList,bLeftCount);
			if (tagCardType1.bStraightFlush)
			{
				for (BYTE j = 0;j<tagCardType1.btStraightFlush;++j)
				{
					//重新赋值
					CopyMemory(bCardList,bLeftCardList,bLeftCount1);
					ZeroMemory(cbStraightFlush,sizeof(cbStraightFlush));
					bLeftCount =bLeftCount1;
					cbStraightFlush[0]=bCardList[tagCardType1.cbStraightFlush[j*5]];
					cbStraightFlush[1]=bCardList[tagCardType1.cbStraightFlush[j*5+1]];
					cbStraightFlush[2]=bCardList[tagCardType1.cbStraightFlush[j*5+2]];
					cbStraightFlush[3]=bCardList[tagCardType1.cbStraightFlush[j*5+3]];
					cbStraightFlush[4]=bCardList[tagCardType1.cbStraightFlush[j*5+4]];
					//移除第二个同花顺
					RemoveCard(cbStraightFlush, bTempCount, bCardList, bLeftCount);
					bLeftCount -= bTempCount;


					//判断剩余3张是否也符合同花顺
					bool bThreeStraightFlush = false;
					SortCardList(bCardList , bLeftCount, enDescend) ;

					if (GetCardLogicValue(bCardList[0]) >=CARD_XW && GetCardLogicValue(bCardList[1]) <CARD_XW)
					{
						if((GetCardColor(bCardList[1]) == GetCardColor(bCardList[2]))&&
							(GetCardLogicValue(bCardList[1])-GetCardLogicValue(bCardList[2])==1 
							|| GetCardLogicValue(bCardList[1])-GetCardLogicValue(bCardList[2])==2
							|| (GetCardLogicValue(bCardList[1]) == 14 &&GetCardLogicValue(bCardList[2])<=3))
							)
						{
							bThreeStraightFlush = true;
						}
					}
					else if (GetCardLogicValue(bCardList[0]) ==CARD_DW && GetCardLogicValue(bCardList[1]) ==CARD_XW)
					{
						bThreeStraightFlush = true;
					}
					else
					{
						if((GetCardColor(bCardList[0]) == GetCardColor(bCardList[1]) && GetCardColor(bCardList[0]) == GetCardColor(bCardList[2]))&&
							((GetCardLogicValue(bCardList[0])==GetCardLogicValue(bCardList[1])+1 && GetCardLogicValue(bCardList[1])==GetCardLogicValue(bCardList[2])+1)
							|| (GetCardLogicValue(bCardList[0]) == 14 &&GetCardLogicValue(bCardList[1])==3 &&GetCardLogicValue(bCardList[2])==2)))
						{
							bThreeStraightFlush = true;
						}
					}
					if (bThreeStraightFlush)
					{
						return true;
					}
				}

			}
		}
	}

	return false;

}



//////////////////////////////////////////////////////////////////////////