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

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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
						{
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
							|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
						{
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
							|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
							{
								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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
								|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
									|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
									|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
									|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
									{
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
										|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
									{
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
										|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
									|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
									|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
									{
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
										|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
							{
								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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
								|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
							{
								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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
								|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
									|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
							{
								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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
								|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
						{
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
							|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
						{
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
							|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
							{
								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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
								|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
									|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
									|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
									|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
									{
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
										|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
									{
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
										|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
									|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
									|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
									{
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
										|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
							{
								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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
								|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
							{
								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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
								|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
									|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
							{
								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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
								|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
						{
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) && (btAllShuiShu>btFrontAllShuiShu
							|| (CompareCard(FrontFrontCard, FrontCard, 3, 3, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
						{
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
						{
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
						{
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
 							{
 								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
 								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
 								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
 								bFirst=false;
 							}
 						}
 						else 
 						{
							if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
 								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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
 							{
 								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
 								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
 								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
 								bFirst=false;
 							}
 						}
 						else 
 						{
							if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
 								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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
 							{
 								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
 								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
 								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
 								bFirst=false;
 							}
 						}
 						else 
 						{
							if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
 								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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
 							{
 								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
 								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
 								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
 								bFirst=false;
 							}
 						}
 						else 
 						{
							if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
 								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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
							{
								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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
								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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
									bFirst=false;
								}
							}
							else 
							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
 							{
 								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
 								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
 								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
 								bFirst=false;
 							}
 						}
 						else 
 						{
							if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
 								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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
 					{
 						CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
 						CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
 						CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
 						bFirst=false;
 					}
 				}
 				else 
 				{
					if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
 						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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
									bFirst=false;
								}
							}
							else 
							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
									bFirst=false;
								}
							}
							else 
							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
									bFirst=false;
								}
							}
							else 
							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
									{
										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
										bFirst=false;
									}
								}
								else 
								{
									if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
									bFirst=false;
								}
							}
							else 
							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
						{
							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
							bFirst=false;
						}
					}
					else 
					{
						if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
									bFirst=false;
								}
							}
							else 
							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
									bFirst=false;
								}
							}
							else 
							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
									{
										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
										bFirst=false;
									}
								}
								else 
								{
									if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
									bFirst=false;
								}
							}
							else 
							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
						{
							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
							bFirst=false;
						}
					}
					else 
					{
						if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
 								{
 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
 									bFirst=false;
 								}
 							}
 							else 
 							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
 									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
									{
										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
										bFirst=false;
									}
								}
								else 
								{
									if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
 								{
 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
 									bFirst=false;
 								}
 							}
 							else 
 							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
 									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
 						{
 							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
 							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
 							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
 							bFirst=false;
 						}
 					}
 					else 
 					{
						if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
 							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
									{
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
										{
											CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
											CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
											CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
											bFirst=false;
										}
									}
									else 
									{
										if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
											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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
									{
										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
										bFirst=false;
									}
								}
								else 
								{
									if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
							{
								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
								bFirst=false;
							}
						}
						else 
						{
							if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
								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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));   
									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
									bFirst=false;
								}
							}
							else 
							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
									bFirst=false;
								}
							}
							else 
							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
							{
								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));   
								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
								bFirst=false;
							}
						}
						else 
						{
							if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
								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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
  								{
  									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
  									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
  									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
  									bFirst=false;
  								}
  							}
  							else 
  							{
								
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
  									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
  						{
  							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
  							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
  							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
  							bFirst=false;
  						}
  					}
  					else 
  					{
						if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
  							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
						{
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
						{
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
									bFirst=false;
								}
							}
							else 
							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
									bFirst=false;
								}
							}
							else 
							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
 								{
 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
 									bFirst=false;
 								}
 							}
 							else 
 							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
 									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
									{
										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
										bFirst=false;
									}
								}
								else 
								{
									if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
 								{
 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
 									bFirst=false;
 								}
 							}
 							else 
 							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
 									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
  						{
  							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
  							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
  							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
  							bFirst=false;
  						}
  					}
  					else 
  					{
						if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
  							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
 								{
 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
 									bFirst=false;
 								}
 							}
 							else 
 							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
 									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
 								{
 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
 									bFirst=false;
 								}
 							}
 							else 
 							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
 									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
									{
										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
										bFirst=false;
									}
								}
								else 
								{
									if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
 								{
 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
 									bFirst=false;
 								}
 							}
 							else 
 							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
 									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
 						{
 							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
 							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
 							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
 							bFirst=false;
 						}
 					}
 					else 
 					{
						if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
 							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
 								{
 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
 									bFirst=false;
 								}
 							}
 							else 
 							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
 									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
									{
										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
										bFirst=false;
									}
								}
								else 
								{
									if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
 								{
 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
 									bFirst=false;
 								}
 							}
 							else 
 							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
 									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
 						{
 							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
 							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
 							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
 							bFirst=false;
 						}
 					}
 					else 
 					{
						if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
 							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
									{
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
										{
											CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
											CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
											CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
											bFirst=false;
										}
									}
									else 
									{
										if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
											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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
									{
										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
										bFirst=false;
									}
								}
								else 
								{
									if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
							{
								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
								bFirst=false;
							}
						}
						else 
						{
							if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
								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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));   
									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
									bFirst=false;
								}
							}
							else 
							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
									bFirst=false;
								}
							}
							else 
							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
							{
								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));   
								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
								bFirst=false;
							}
						}
						else 
						{
							if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
								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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
 								{
 									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
 									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
 									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
 									bFirst=false;
 								}
 							}
 							else 
 							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
 									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
 						{
 							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
 							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
 							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
 							bFirst=false;
 						}
 					}
 					else 
 					{
						if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
 							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
						{
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
									bFirst=false;
								}
							}
							else 
							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
									bFirst=false;
								}
							}
							else 
							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
									{
										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
										bFirst=false;
									}
								}
								else 
								{
									if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
									bFirst=false;
								}
							}
							else 
							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
						{
							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
							bFirst=false;
						}
					}
					else 
					{
						if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
									bFirst=false;
								}
							}
							else 
							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
									{
										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
										bFirst=false;
									}
								}
								else 
								{
									if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
									bFirst=false;
								}
							}
							else 
							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
						{
							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
							bFirst=false;
						}
					}
					else 
					{
						if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
									{
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
										{
											CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
											CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
											CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
											bFirst=false;
										}
									}
									else 
									{
										if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
											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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
									{
										CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
										CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
										CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
										bFirst=false;
									}
								}
								else 
								{
									if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
										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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
							{
								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
								bFirst=false;
							}
						}
						else 
						{
							if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
								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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));   
									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
									bFirst=false;
								}
							}
							else 
							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && 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, m_bClassicRule) && 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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
							{
								CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));   
								CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
								CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
								bFirst=false;
							}
						}
						else 
						{
							if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
								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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
								{
									CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
									CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
									CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
									bFirst=false;
								}
							}
							else 
							{
								if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
									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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
						{
							CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
							CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
							CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
							bFirst=false;
						}
					}
					else 
					{
						if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
							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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
					{
						CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));   
						CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
						CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
						bFirst=false;
					}
				}
				else 
				{
					if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
						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, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule))
					{
						CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
						CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
						CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
						bFirst=false;
					}
				}
				else 
				{
					if (CompareCard(FrontCard, MidCard, 3, 5, m_bClassicRule) && CompareCard(MidCard, BackCard, 5, 5, m_bClassicRule) &&
						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[])
{
	return 0;
	//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, m_bClassicRule))
			{
                
				btCompare++;
			}
			else
			{
				btCompare--;
			}
		}
	}
	
	if(IsSameCardData(btFrontMidCard,btMidCard,5,5)==false)
	{
		if(!(tagFrontMidCardType.bThreeSame&&tagMidCardType.bThreeSame))
		{
			if (CompareCard(btFrontMidCard, btMidCard, 5, 5, m_bClassicRule))
			{
				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, m_bClassicRule))
			{
				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;
}