lyfz_repos/经典版源码/Others/DataSyncSend/SoftKey.cpp

// SoftKey.cpp: implementation of the SoftKey class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "SoftKey.h"
#include "my32.h"
#include "MyLock.h"
#pragma comment (lib,"my32.lib")
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
int g_nDogType=-1;
//////////////////////////////////////////////////////////////////////
// Construction/Destruction TIMEDOG_VERSION BASIC_VERSION CHILD_VERSION
//////////////////////////////////////////////////////////////////////

SoftKey::SoftKey()
{

}

SoftKey::~SoftKey()
{

}

//以下函数用于网络版//////////////////////////////////////////////////////////////

//该函数用于连接服务器
//第一个参数为要连接的服务器名称或IP
//第二个参数为连接使用的通讯端口，开发商可以自定义，但客户端的必须与服务端的端口相同，端口的范围为1024－40000
int SoftKey::ConnectSvr(TCHAR *ServerName,int Port)
{
	return ConnectServer(ServerName,Port);
}

//该函数用于将指定的功能连接添加到服务器,并返回检验码
//第一个参数为授权号储存在加密锁的位置，授权号储存在加密锁的位置在开发工具写入网络授权用户数时自定义输入
//第二个参数用于返回检验码，是用于判断是否为相应的授权，如果该数值与开发工具所得的检验码相符，则为合法授权，否则为非法授权
//检验码由开发工具生成，不同的开发密钥或主锁内置密钥，生成的检验码都不相同且唯一对应
int SoftKey::ConnectAddNew(short Addr,TCHAR *OutVefCode)
{
	//第一参数为连接的功能模块号，如果只一个功能模块，见这里固定使用0,
	//如果是普通网络锁则只能有唯一的一个模块，真正的网络锁支持128个功能模块
	//第二个参数为授权号储存在加密锁的位置，授权号储存在加密锁的位置在开发工具写入网络授权用户数时自定义输入
	//第三个参数为当连接失败时，是否关闭与服务器的连接
	//第四个参数用于返回检验码，是用于判断是否为相应的授权，如果该数值与开发工具所得的检验码相符，则为合法授权，否则为非法授权
	//第五个参数为加密锁所在的设备路径
	return AddConnectNew(0, Addr, FALSE,OutVefCode,KeyPath);
	//注意：第三个参数的使用，如果不是真正的网络锁，这个参数将会忽略，并总是当连接失败时，关闭与服务器的连接
	//如果是真正的网络锁，则为FALSE时，不断开与服务器的连接，
}

//该函数用于将指定的功能连接添加到服务器
//第一个参数为授权号储存在加密锁的位置，授权号储存在加密锁的位置在开发工具写入网络授权用户数时自定义输入
int SoftKey::ConnectAdd(short Addr)
{
	//第一参数为连接的功能模块号，如果只一个功能模块，见这里固定使用0,
	//如果是普通网络锁则只能有唯一的一个模块，真正的网络锁支持128个功能模块
	//第二个参数为授权号储存在加密锁的位置，授权号储存在加密锁的位置在开发工具写入网络授权用户数时自定义输入
	//第三个参数为当连接失败时，是否关闭与服务器的连接
	//第四个参数为加密锁所在的设备路径
	return AddConnectEx(0, Addr, FALSE,KeyPath);
	//注意：第三个参数的使用，如果不是真正的网络锁，这个参数将会忽略，并总是当连接失败时，关闭与服务器的连接
	//如果是真正的网络锁，则为FALSE时，不断开与服务器的连接，
}

//以下函数用于返回当前设置在加密锁中的授权数
//第一个参数与上面相同
long SoftKey::GetKeySetCount(short Addr)
{
	long count;BOOL IsMachine;char OutFum;
	int ret=GetSetCount(Addr,&count,&IsMachine,&OutFum,KeyPath);
	if(ret!=0)return ret;
	return count;
}

//以下函数用于返回当前连接到服务的机器数
short SoftKey::GetIpCount()
{
	//第一参数为连接的功能模块号，如果只一个功能模块，见这里固定使用0
	return GetIpCountByFunNum(0);
}

//以下函数用于返回当前连接到服务的连接数
short SoftKey::GetConCount()
{
	//第一参数为连接的功能模块号，如果只一个功能模块，见这里固定使用0
	return GetConCountByFunNum(0);
}

//以下函数用于断开与服务的连接数
int SoftKey::DisConnect()
{
	return DisconnectServer();
}

//以上函函数用于网络版////////////////////////////////////////////////////////////

//在程序开始运行时，请先调用Ini过程，查找对应的加密锁所在的设备路径；
//如果找到对应的加密锁，会将该路径保存在变量KeyPath中，
//以备其它函数的调用；
int SoftKey::Ini()
{
	MyLock lock("lyfzdogxiao");
	//生成该数组的表达式为：D0=123,D1=123,D2=123,D3=123，由于系统中可能存在多把加密锁，用于查找对应的加密锁
	BYTE f_DecArray[26]={24,0,15,94,36,102,72,216,4,18,103,117,240,15,7,158,250,133,112,95,163,173,44,84,41,86};
	int nRet=FindPort_2(0,f_DecArray,26,KeyPath);
	if(nRet==0)
	{
		g_nDogType=1;
		return 0;
	}
	{
	BYTE f_DecArray[26]={24,0,222,41,26,123,125,46,65,0,144,51,210,220,57,10,86,26,12,8,180,39,138,95,89,124};
	nRet=FindPort_2(0,f_DecArray,26,KeyPath);
	if(nRet==0)
	{
		g_nDogType=0;
		return 0;
	}
	}
	return nRet;
}

int SoftKey::RectFitDes(long *D0, long *D1,long *D2, long *D3,long *D4, long *D5,long *D6, long *D7,
				double *F0, double *F1,double *F2, double *F3,double *F4, double *F5,double *F6, double *F7,
				char *S0, char *S1,char *S2, char *S3,char *S4, char *S5,char *S6, char *S7)
{
	MyLock lock("lyfzdogxiao");
#ifdef ENTERPRISE_VERSION
	{
#ifdef CHILD_VERSION
  BYTE DecArray[90]={86,0,48,25,74,214,194,185,72,20,112,237,96,247,242,22,244,74,246,211,49,121,148,113,18,185,176,126,104,255,162,
43,151,140,252,180,26,90,71,254,196,64,93,218,156,212,41,213,145,127,207,74,250,224,28,39,253,159,72,25,56,198,
197,101,133,36,70,226,167,212,81,243,129,47,163,63,182,147,6,148,95,205,180,17,182,58,3,255,228,234};

  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 90,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
#else
  BYTE DecArray[90]={86,0,175,104,227,2,4,203,59,73,23,1,166,30,109,164,105,234,125,175,24,69,65,207,30,210,87,246,166,78,184,
234,8,6,76,6,129,43,104,216,99,88,228,161,190,102,15,115,111,64,146,80,243,71,50,235,236,41,213,104,45,229,
144,26,214,218,181,222,63,220,227,47,107,112,157,51,127,147,28,182,196,131,18,187,65,166,45,157,144,103};

  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 90,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
#endif
	}
#endif

	//以下是将自定义的加密表达式送到加密锁中进行运算
#ifdef CHILD_VERSION
#ifdef TIMEDOG_VERSION
 BYTE DecArray[90]={86,0,8,186,56,132,130,147,19,0,148,176,218,242,32,84,51,9,228,101,56,173,237,103,30,25,103,10,92,46,10,
240,105,181,58,126,196,158,123,46,141,41,151,227,195,153,214,201,52,38,57,97,61,76,186,106,76,166,144,183,160,251,
183,130,130,198,121,182,160,91,170,169,202,37,217,97,6,22,157,52,217,218,229,51,207,204,161,238,116,216};
#else
#ifdef BASIC_VERSION
BYTE DecArray[90]={86,0,102,132,209,17,93,118,219,200,220,202,174,106,112,103,188,149,85,153,82,50,27,238,33,242,89,69,250,76,138,
9,194,28,80,14,152,69,59,15,98,222,187,133,36,70,150,11,174,240,195,210,90,40,239,205,208,85,229,131,39,119,
135,106,121,183,213,114,2,51,127,86,107,155,83,182,83,193,178,154,169,174,101,67,117,104,223,37,198,197};
#else
 BYTE DecArray[90]={86,0,120,63,128,19,200,91,211,126,85,24,68,76,254,3,136,114,46,120,220,36,65,215,3,214,231,180,170,161,135,
126,226,98,78,15,235,208,133,39,0,195,176,51,139,54,117,241,49,87,26,178,64,160,220,57,62,46,17,39,4,186,
26,23,17,243,246,207,111,108,155,12,241,177,250,59,78,216,113,215,202,176,6,216,155,32,42,80,123,223};
#endif
#endif
#else
#ifdef TIMEDOG_VERSION
 BYTE DecArray[90]={86,0,243,95,132,0,194,123,32,132,109,124,28,24,80,107,155,39,247,184,22,73,180,59,72,2,53,49,21,238,209,
84,181,210,232,209,89,224,166,53,58,227,15,40,25,118,8,228,162,28,227,219,115,59,182,195,54,61,31,162,114,164,
119,244,89,53,23,206,41,99,210,80,93,61,232,6,180,72,78,106,85,163,246,105,144,56,131,197,113,179};
#else
#ifdef BASIC_VERSION
 BYTE DecArray[90]={86,0,221,187,101,124,44,55,52,217,87,17,11,46,66,199,234,153,19,129,167,130,229,186,255,241,60,36,253,141,235,
133,109,214,225,78,221,50,170,20,121,177,204,6,244,209,116,88,139,155,146,198,36,91,133,120,190,65,157,255,48,244,
26,168,26,83,74,42,49,32,32,117,78,152,124,104,73,229,76,218,14,241,92,39,148,5,131,213,218,125};
#else
  BYTE DecArray[90]={86,0,149,91,215,80,77,53,45,20,132,240,11,0,0,117,106,197,49,144,35,216,176,6,155,130,69,57,0,65,39,
108,235,160,132,165,134,239,157,173,105,145,119,105,228,212,14,245,255,79,25,25,148,86,176,251,235,85,242,41,252,28,
115,154,46,24,134,251,12,23,26,164,211,133,182,192,15,183,215,226,210,181,78,59,28,130,190,66,166,50};
#endif
#endif
#endif
  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 90,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
}

int SoftKey::decryptlong1(long *D0, long *D1,long *D2, long *D3,long *D4, long *D5,long *D6, long *D7,
				double *F0, double *F1,double *F2, double *F3,double *F4, double *F5,double *F6, double *F7,
				TCHAR *S0, TCHAR *S1,TCHAR *S2, TCHAR *S3,TCHAR *S4, TCHAR *S5,TCHAR *S6, TCHAR *S7)
{
	MyLock lock("lyfzdogxiao");
#ifdef ENTERPRISE_VERSION
	{
#ifdef CHILD_VERSION
   BYTE DecArray[170]={165,0,25,131,122,71,3,205,14,171,240,207,237,75,226,68,133,100,42,119,89,131,79,104,158,17,172,239,4,158,201,
51,62,51,144,28,74,128,177,168,48,66,174,233,121,104,33,50,54,226,240,207,237,75,226,68,133,100,42,119,89,131,
79,104,158,17,172,239,4,158,201,51,62,51,74,62,166,100,160,209,41,169,100,163,204,131,22,138,40,138,240,207,237,
75,226,68,133,100,42,119,89,131,79,104,158,17,172,239,4,158,201,51,62,51,124,147,182,219,147,127,203,239,96,130,
26,114,86,64,9,104,240,207,237,75,226,68,133,100,42,119,89,131,79,104,158,17,172,239,4,158,201,51,62,51,202,
67,223,93,246,98,107,137,147,104,49,74,127,38,148,231};

  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 170,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
#else
  BYTE DecArray[170]={165,0,4,142,1,153,125,221,118,2,78,101,1,144,68,206,192,52,67,9,243,20,9,195,153,15,22,217,243,79,177,
22,24,171,204,99,98,149,205,76,24,219,45,134,233,22,26,200,197,190,78,101,1,144,68,206,192,52,67,9,243,20,
9,195,153,15,22,217,243,79,177,22,24,171,137,19,235,6,63,246,200,5,178,74,249,91,54,252,29,254,78,101,1,
144,68,206,192,52,67,9,243,20,9,195,153,15,22,217,243,79,177,22,24,171,206,35,154,175,111,179,82,107,187,129,
15,127,134,115,209,3,78,101,1,144,68,206,192,52,67,9,243,20,9,195,153,15,22,217,243,79,177,22,24,171,250,
141,93,68,207,5,13,175,100,204,29,253,77,168,94,78};

  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 170,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
#endif
	}
#endif
	//以下是将自定义的加密表达式送到加密锁中进行运算
#ifdef CHILD_VERSION
#ifdef TIMEDOG_VERSION
  BYTE DecArray[170]={165,0,11,125,54,84,125,151,86,3,180,168,178,208,21,79,62,90,51,31,88,128,180,105,53,137,230,254,244,50,195,
49,167,143,25,28,158,33,41,23,40,58,163,126,229,176,220,2,2,227,180,168,178,208,21,79,62,90,51,31,88,128,
180,105,53,137,230,254,244,50,195,49,167,143,237,226,226,111,100,171,98,124,146,136,146,107,145,15,172,225,180,168,178,
208,21,79,62,90,51,31,88,128,180,105,53,137,230,254,244,50,195,49,167,143,161,132,12,118,221,132,12,75,221,30,
103,173,224,17,185,66,180,168,178,208,21,79,62,90,51,31,88,128,180,105,53,137,230,254,244,50,195,49,167,143,83,
136,192,28,64,251,188,249,205,247,63,205,233,29,115,113};
#else
#ifdef BASIC_VERSION
 BYTE DecArray[170]={165,0,240,79,162,111,98,116,120,194,20,1,114,225,235,178,15,165,142,82,11,142,204,78,169,225,88,254,80,93,3,
204,59,244,152,203,88,236,121,126,40,135,141,51,0,70,125,204,137,51,20,1,114,225,235,178,15,165,142,82,11,142,
204,78,169,225,88,254,80,93,3,204,59,244,179,179,152,20,51,15,94,228,32,61,90,28,113,129,128,229,20,1,114,
225,235,178,15,165,142,82,11,142,204,78,169,225,88,254,80,93,3,204,59,244,160,47,250,110,81,29,4,120,42,216,
216,131,215,204,189,223,20,1,114,225,235,178,15,165,142,82,11,142,204,78,169,225,88,254,80,93,3,204,59,244,60,
191,236,44,139,91,39,50,171,141,220,144,229,175,169,150};
#else
  BYTE DecArray[170]={165,0,39,17,78,36,5,114,6,49,146,79,198,84,191,217,198,153,144,173,180,184,44,225,36,118,122,209,81,114,4,
250,146,139,174,196,218,218,197,63,98,254,189,107,59,153,124,115,248,169,146,79,198,84,191,217,198,153,144,173,180,184,
44,225,36,118,122,209,81,114,4,250,146,139,252,218,175,92,102,56,239,118,7,223,54,163,150,109,122,180,146,79,198,
84,191,217,198,153,144,173,180,184,44,225,36,118,122,209,81,114,4,250,146,139,40,108,5,177,180,32,80,240,8,28,
238,208,1,203,204,136,146,79,198,84,191,217,198,153,144,173,180,184,44,225,36,118,122,209,81,114,4,250,146,139,111,
32,62,1,224,8,243,138,120,102,209,255,59,170,11,53};
#endif
#endif
#else
#ifdef TIMEDOG_VERSION
BYTE DecArray[170]={165,0,79,91,142,100,134,124,58,20,172,200,12,124,89,151,248,238,26,85,137,146,119,58,76,194,151,239,204,104,18,
166,208,54,229,132,154,130,165,233,127,237,121,111,139,223,37,148,235,216,172,200,12,124,89,151,248,238,26,85,137,146,
119,58,76,194,151,239,204,104,18,166,208,54,85,39,166,132,46,59,83,11,218,236,231,227,2,44,249,126,172,200,12,
124,89,151,248,238,26,85,137,146,119,58,76,194,151,239,204,104,18,166,208,54,185,183,19,110,144,243,169,221,112,233,
17,2,212,198,183,93,172,200,12,124,89,151,248,238,26,85,137,146,119,58,76,194,151,239,204,104,18,166,208,54,105,
230,230,11,142,5,159,227,25,182,120,11,247,158,109,230};
#else
#ifdef BASIC_VERSION
 BYTE DecArray[170]={165,0,71,43,15,100,71,205,51,122,232,64,71,233,81,148,4,7,27,32,35,254,62,187,72,30,55,3,126,161,141,
216,198,62,249,11,169,167,123,231,49,135,188,19,30,174,223,197,149,33,232,64,71,233,81,148,4,7,27,32,35,254,
62,187,72,30,55,3,126,161,141,216,198,62,49,163,65,143,173,198,205,136,113,73,178,226,130,133,159,76,232,64,71,
233,81,148,4,7,27,32,35,254,62,187,72,30,55,3,126,161,141,216,198,62,95,108,68,0,194,125,69,239,200,176,
123,245,196,233,17,143,232,64,71,233,81,148,4,7,27,32,35,254,62,187,72,30,55,3,126,161,141,216,198,62,171,
49,99,52,160,61,36,205,230,223,130,152,234,29,68,220};
#else
  BYTE DecArray[170]={165,0,164,190,254,15,9,230,2,98,122,176,52,109,67,223,68,28,43,234,81,194,222,186,147,103,208,77,54,9,144,
66,118,79,14,143,23,132,119,111,159,192,217,16,143,158,41,92,150,66,122,176,52,109,67,223,68,28,43,234,81,194,
222,186,147,103,208,77,54,9,144,66,118,79,254,82,44,124,0,114,234,81,130,3,98,74,142,253,141,187,122,176,52,
109,67,223,68,28,43,234,81,194,222,186,147,103,208,77,54,9,144,66,118,79,168,103,233,233,147,136,160,109,232,163,
173,207,255,31,10,196,122,176,52,109,67,223,68,28,43,234,81,194,222,186,147,103,208,77,54,9,144,66,118,79,55,
253,148,121,117,10,174,206,199,247,144,181,255,94,3,130};
#endif
#endif
#endif
  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 170,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
}

int SoftKey::decryptlong2(long *D0, long *D1,long *D2, long *D3,long *D4, long *D5,long *D6, long *D7,
				double *F0, double *F1,double *F2, double *F3,double *F4, double *F5,double *F6, double *F7,
				TCHAR *S0, TCHAR *S1,TCHAR *S2, TCHAR *S3,TCHAR *S4, TCHAR *S5,TCHAR *S6, TCHAR *S7)
{
	MyLock lock("lyfzdogxiao");
#ifdef ENTERPRISE_VERSION
	{
#ifdef CHILD_VERSION
   BYTE DecArray[170]={165,0,210,210,33,70,121,171,133,43,240,207,237,75,226,68,133,100,42,119,89,131,79,104,158,17,172,239,4,158,201,
51,62,51,228,149,182,232,78,13,229,56,22,248,32,93,197,234,134,174,240,207,237,75,226,68,133,100,42,119,89,131,
79,104,158,17,172,239,4,158,201,51,62,51,238,15,175,245,3,59,144,212,247,174,105,76,213,137,240,199,240,207,237,
75,226,68,133,100,42,119,89,131,79,104,158,17,172,239,4,158,201,51,62,51,65,61,120,239,91,201,27,108,9,240,
161,123,224,80,18,69,240,207,237,75,226,68,133,100,42,119,89,131,79,104,158,17,172,239,4,158,201,51,62,51,200,
90,100,42,87,82,79,120,147,104,49,74,127,38,148,231};

  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 170,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
#else
  BYTE DecArray[170]={165,0,67,180,12,197,9,113,209,88,78,101,1,144,68,206,192,52,67,9,243,20,9,195,153,15,22,217,243,79,177,
22,24,171,138,113,42,144,243,7,55,180,225,147,9,42,51,149,218,111,78,101,1,144,68,206,192,52,67,9,243,20,
9,195,153,15,22,217,243,79,177,22,24,171,108,101,119,142,255,124,177,74,122,20,211,146,25,168,205,45,78,101,1,
144,68,206,192,52,67,9,243,20,9,195,153,15,22,217,243,79,177,22,24,171,69,62,112,81,80,56,77,132,3,106,
166,136,147,0,13,57,78,101,1,144,68,206,192,52,67,9,243,20,9,195,153,15,22,217,243,79,177,22,24,171,1,
131,10,253,200,92,148,137,100,204,29,253,77,168,94,78};

  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 170,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
#endif
	}
#endif
	//以下是将自定义的加密表达式送到加密锁中进行运算
#ifdef CHILD_VERSION
#ifdef TIMEDOG_VERSION
   BYTE DecArray[170]={165,0,152,236,214,51,199,222,167,49,180,168,178,208,21,79,62,90,51,31,88,128,180,105,53,137,230,254,244,50,195,
49,167,143,194,235,120,154,159,123,116,146,63,13,13,109,142,165,47,180,180,168,178,208,21,79,62,90,51,31,88,128,
180,105,53,137,230,254,244,50,195,49,167,143,184,174,118,175,242,123,110,186,254,101,157,221,227,3,30,64,180,168,178,
208,21,79,62,90,51,31,88,128,180,105,53,137,230,254,244,50,195,49,167,143,138,26,47,201,99,3,62,53,254,214,
137,146,96,67,89,51,180,168,178,208,21,79,62,90,51,31,88,128,180,105,53,137,230,254,244,50,195,49,167,143,198,
7,111,120,20,218,255,69,205,247,63,205,233,29,115,113};
#else
#ifdef BASIC_VERSION
  BYTE DecArray[170]={165,0,239,52,176,152,37,192,137,107,20,1,114,225,235,178,15,165,142,82,11,142,204,78,169,225,88,254,80,93,3,
204,59,244,229,208,186,89,135,153,91,168,245,154,98,56,140,200,136,91,20,1,114,225,235,178,15,165,142,82,11,142,
204,78,169,225,88,254,80,93,3,204,59,244,51,41,193,136,191,5,243,248,58,82,168,85,60,184,212,116,20,1,114,
225,235,178,15,165,142,82,11,142,204,78,169,225,88,254,80,93,3,204,59,244,79,29,193,87,15,194,177,20,119,185,
250,29,75,251,125,172,20,1,114,225,235,178,15,165,142,82,11,142,204,78,169,225,88,254,80,93,3,204,59,244,190,
101,132,70,7,154,86,49,171,141,220,144,229,175,169,150};
#else
  BYTE DecArray[170]={165,0,143,141,64,31,233,225,236,16,146,79,198,84,191,217,198,153,144,173,180,184,44,225,36,118,122,209,81,114,4,
250,146,139,253,137,190,226,151,244,37,220,41,167,167,195,207,136,244,8,146,79,198,84,191,217,198,153,144,173,180,184,
44,225,36,118,122,209,81,114,4,250,146,139,85,201,232,250,180,84,84,3,56,235,141,149,200,63,91,92,146,79,198,
84,191,217,198,153,144,173,180,184,44,225,36,118,122,209,81,114,4,250,146,139,169,247,88,162,201,147,4,52,220,204,
179,113,195,91,131,3,146,79,198,84,191,217,198,153,144,173,180,184,44,225,36,118,122,209,81,114,4,250,146,139,238,
234,0,171,101,193,187,243,120,102,209,255,59,170,11,53};
#endif
#endif
#else
#ifdef TIMEDOG_VERSION
	//以下是将自定义的加密表达式送到加密锁中进行运算
  BYTE DecArray[170]={165,0,150,87,74,55,92,103,172,150,172,200,12,124,89,151,248,238,26,85,137,146,119,58,76,194,151,239,204,104,18,
166,208,54,99,144,153,174,33,208,106,21,218,19,105,74,18,59,83,20,172,200,12,124,89,151,248,238,26,85,137,146,
119,58,76,194,151,239,204,104,18,166,208,54,53,243,104,66,43,255,114,7,198,63,62,251,49,55,102,60,172,200,12,
124,89,151,248,238,26,85,137,146,119,58,76,194,151,239,204,104,18,166,208,54,45,177,104,64,42,84,44,140,212,239,
50,220,185,255,228,164,172,200,12,124,89,151,248,238,26,85,137,146,119,58,76,194,151,239,204,104,18,166,208,54,33,
6,13,30,252,41,122,17,25,182,120,11,247,158,109,230};
#else
#ifdef BASIC_VERSION
  BYTE DecArray[170]={165,0,45,78,61,72,131,221,207,126,232,64,71,233,81,148,4,7,27,32,35,254,62,187,72,30,55,3,126,161,141,
216,198,62,189,137,251,123,193,159,241,62,76,210,23,13,234,68,134,135,232,64,71,233,81,148,4,7,27,32,35,254,
62,187,72,30,55,3,126,161,141,216,198,62,8,50,183,30,22,106,123,73,87,209,118,16,10,137,187,110,232,64,71,
233,81,148,4,7,27,32,35,254,62,187,72,30,55,3,126,161,141,216,198,62,32,255,82,228,116,170,240,204,36,169,
112,19,56,92,232,133,232,64,71,233,81,148,4,7,27,32,35,254,62,187,72,30,55,3,126,161,141,216,198,62,34,
110,207,248,35,87,241,109,230,223,130,152,234,29,68,220};
#else
  BYTE DecArray[170]={165,0,174,152,65,82,73,111,7,20,122,176,52,109,67,223,68,28,43,234,81,194,222,186,147,103,208,77,54,9,144,
66,118,79,228,191,229,189,250,220,18,230,77,43,29,91,238,118,10,181,122,176,52,109,67,223,68,28,43,234,81,194,
222,186,147,103,208,77,54,9,144,66,118,79,74,105,140,162,189,116,189,85,83,45,231,206,83,11,214,157,122,176,52,
109,67,223,68,28,43,234,81,194,222,186,147,103,208,77,54,9,144,66,118,79,53,36,238,70,53,34,166,17,96,196,
118,46,103,70,51,41,122,176,52,109,67,223,68,28,43,234,81,194,222,186,147,103,208,77,54,9,144,66,118,79,139,
135,90,152,73,123,140,79,199,247,144,181,255,94,3,130};
#endif
#endif
#endif
  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 170,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
}

int SoftKey::decryptlong3(long *D0, long *D1,long *D2, long *D3,long *D4, long *D5,long *D6, long *D7,
				double *F0, double *F1,double *F2, double *F3,double *F4, double *F5,double *F6, double *F7,
				TCHAR *S0, TCHAR *S1,TCHAR *S2, TCHAR *S3,TCHAR *S4, TCHAR *S5,TCHAR *S6, TCHAR *S7)
{
	MyLock lock("lyfzdogxiao");
#ifdef ENTERPRISE_VERSION
	{
#ifdef CHILD_VERSION
   BYTE DecArray[170]={165,0,207,246,139,7,249,220,110,141,66,159,191,240,45,61,112,162,171,69,177,162,72,29,214,102,172,67,185,197,254,
84,162,140,160,37,102,168,217,130,152,160,203,217,254,163,135,83,23,139,134,203,213,140,239,32,88,116,52,201,148,240,
185,52,40,101,217,3,13,226,102,4,30,234,127,176,95,93,109,5,230,77,106,190,85,125,127,76,161,91,106,136,42,
20,238,165,45,190,182,156,3,108,200,190,102,213,68,130,163,195,241,111,53,156,187,50,23,94,45,141,32,220,109,131,
238,245,24,189,252,47,122,141,52,162,204,95,3,228,242,5,247,87,145,175,255,208,17,196,98,96,202,223,20,17,215,
8,207,141,190,173,210,64,147,104,49,74,127,38,148,231};

  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 170,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
#else
  BYTE DecArray[170]={165,0,22,43,177,196,157,143,209,35,171,105,117,50,248,245,231,179,219,209,109,165,94,125,237,117,76,100,2,107,225,
192,225,150,71,1,228,101,128,127,57,203,240,211,179,245,202,218,108,165,115,150,137,21,121,245,151,226,100,1,236,118,
2,200,146,217,201,5,137,48,185,200,69,183,196,79,40,220,138,142,231,101,74,132,252,215,152,219,145,40,189,149,119,
152,144,87,157,77,160,138,94,121,197,10,248,35,89,190,243,199,70,64,99,227,206,240,141,253,217,229,76,230,22,159,
62,45,188,159,58,70,243,245,111,136,153,61,98,33,8,26,55,23,141,214,99,116,101,196,100,91,151,101,46,119,130,
97,238,86,189,122,110,208,100,204,29,253,77,168,94,78};

  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 170,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
#endif
	}
#endif
	//以下是将自定义的加密表达式送到加密锁中进行运算
#ifdef CHILD_VERSION
#ifdef TIMEDOG_VERSION
  BYTE DecArray[170]={165,0,39,94,28,233,95,42,58,248,24,113,123,52,228,108,10,156,156,111,3,7,32,201,228,230,116,149,126,244,238,
42,82,146,62,104,234,191,60,250,129,8,159,24,14,104,16,236,76,81,99,235,20,38,244,225,202,204,127,39,56,230,
238,141,134,158,70,233,124,42,234,14,103,49,142,209,127,78,119,199,40,191,30,140,24,57,246,26,170,238,223,34,156,
162,20,120,176,228,133,162,94,155,59,108,55,34,91,162,39,111,187,22,190,86,161,144,86,32,244,169,38,204,223,36,
142,242,42,50,178,1,196,47,35,93,33,112,133,196,73,130,206,53,150,14,224,248,229,0,68,250,95,150,151,50,243,
235,15,121,175,170,13,100,205,247,63,205,233,29,115,113};
#else
#ifdef BASIC_VERSION
 BYTE DecArray[170]={165,0,85,58,254,166,207,19,30,209,187,233,3,240,152,72,116,211,3,117,46,104,139,20,93,21,122,44,144,36,105,
127,3,79,234,119,38,110,36,182,1,212,150,157,84,35,130,88,201,27,143,205,110,24,70,248,146,62,65,240,165,238,
91,60,125,114,207,128,193,60,169,249,5,50,247,110,71,238,116,154,74,83,148,228,165,32,44,161,159,29,195,179,253,
201,195,14,112,160,157,159,240,83,245,58,171,27,42,167,250,27,102,158,154,161,141,140,153,177,28,114,170,30,83,119,
105,209,112,8,241,82,133,68,239,54,246,35,172,51,237,179,208,38,194,153,77,165,62,58,77,191,211,133,251,172,106,
56,148,209,25,128,90,1,171,141,220,144,229,175,169,150};
#else
 BYTE DecArray[170]={165,0,124,64,225,174,136,4,54,53,158,201,252,146,133,11,170,190,23,16,83,157,241,11,83,189,205,68,161,102,155,
70,11,167,246,120,164,81,2,19,163,195,151,22,208,69,123,160,229,14,123,167,191,216,163,223,247,61,236,38,35,10,
242,62,54,122,25,181,232,29,189,239,29,219,243,122,177,69,232,124,116,97,184,113,250,37,69,202,101,66,244,126,217,
195,248,173,206,12,113,163,199,147,195,10,171,42,1,92,84,129,160,216,2,191,211,177,16,133,62,239,52,245,151,33,
7,92,239,142,130,98,247,236,20,160,105,131,43,30,159,90,168,105,129,219,77,66,43,168,19,152,130,195,151,56,185,
224,129,230,84,4,174,130,120,102,209,255,59,170,11,53};
#endif
#endif
#else
#ifdef TIMEDOG_VERSION
BYTE DecArray[170]={165,0,120,116,120,158,192,117,146,56,210,149,192,112,40,33,253,99,178,245,85,253,0,65,57,26,225,180,27,229,43,
220,250,37,235,47,160,80,111,137,169,200,237,221,82,8,112,22,188,60,230,253,6,160,23,0,119,16,137,216,181,42,
243,138,16,110,40,192,48,119,164,249,187,110,16,202,152,8,244,95,65,110,148,233,83,193,212,221,88,137,211,253,77,
45,200,83,2,5,163,151,6,29,76,15,69,146,2,135,218,87,106,252,64,40,111,106,103,16,32,34,106,61,22,223,
38,26,173,142,70,95,175,5,152,18,122,80,219,99,84,247,183,169,48,104,189,212,148,139,161,113,243,150,119,178,95,
142,227,152,194,225,160,92,25,182,120,11,247,158,109,230};
#else
#ifdef BASIC_VERSION
  BYTE DecArray[170]={165,0,129,205,179,26,180,187,101,206,26,79,155,231,163,126,144,49,165,24,132,220,226,190,126,118,102,249,32,135,83,
85,243,125,210,39,94,59,214,63,255,69,108,160,198,54,239,103,54,45,187,127,164,131,117,213,42,116,232,180,57,179,
171,96,234,166,142,83,13,243,77,146,242,161,61,44,104,94,223,66,112,31,228,152,16,15,84,40,131,232,154,192,30,
58,116,114,145,251,117,75,186,214,104,171,255,130,46,185,103,34,43,23,41,91,247,6,7,243,14,211,13,68,7,231,
188,77,143,23,119,10,59,159,10,71,98,248,138,144,130,93,88,190,212,169,126,99,134,178,7,2,9,195,155,45,52,
68,104,226,118,76,186,156,230,223,130,152,234,29,68,220};
#else
  BYTE DecArray[170]={165,0,153,241,212,244,200,60,193,53,210,142,3,173,196,2,195,7,16,40,220,101,208,41,140,171,139,149,200,61,83,
13,121,156,231,123,126,56,94,103,188,229,54,208,175,212,226,155,49,26,180,198,97,78,172,4,234,175,196,32,223,190,
22,122,124,83,188,146,26,181,95,177,147,81,227,140,128,86,130,215,144,6,223,92,242,21,91,16,149,51,26,227,210,
236,194,193,116,184,101,160,91,211,98,19,243,51,129,229,244,240,92,25,131,8,110,44,167,20,174,135,73,104,109,95,
74,134,167,157,203,225,208,181,253,185,24,243,84,0,41,163,96,81,5,163,132,133,197,251,136,170,117,194,158,209,62,
170,15,220,234,172,227,86,199,247,144,181,255,94,3,130};
#endif
#endif
#endif
  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 170,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
}

int SoftKey::decryptlong4(long *D0, long *D1,long *D2, long *D3,long *D4, long *D5,long *D6, long *D7,
				double *F0, double *F1,double *F2, double *F3,double *F4, double *F5,double *F6, double *F7,
				TCHAR *S0, TCHAR *S1,TCHAR *S2, TCHAR *S3,TCHAR *S4, TCHAR *S5,TCHAR *S6, TCHAR *S7)
{
	MyLock lock("lyfzdogxiao");
#ifdef ENTERPRISE_VERSION
	{
#ifdef CHILD_VERSION
   BYTE DecArray[170]={165,0,222,100,12,154,215,30,142,101,65,120,43,177,31,74,93,3,159,218,232,130,75,72,20,120,77,35,171,245,251,
132,124,200,201,83,39,36,8,159,101,6,20,30,87,190,100,106,245,227,216,42,213,63,80,32,200,33,198,85,38,119,
252,108,87,154,190,255,198,15,245,171,96,114,33,90,146,217,0,181,29,242,20,30,87,190,100,106,245,227,135,219,146,
20,172,164,170,40,205,79,213,65,84,174,87,151,234,225,109,74,57,182,249,21,173,62,41,188,36,177,183,109,132,99,
42,84,192,174,174,115,36,46,188,0,151,63,132,253,243,139,252,52,167,15,91,121,154,100,14,134,131,134,168,18,172,
105,253,184,86,211,143,11,147,104,49,74,127,38,148,231};

  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 170,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
#else
  BYTE DecArray[170]={165,0,47,238,40,90,230,16,229,106,1,151,5,223,93,222,175,103,120,116,66,151,37,250,185,63,12,154,210,130,125,
81,93,5,85,119,32,15,231,10,76,235,93,163,18,174,143,31,76,39,77,178,110,251,76,72,226,77,211,235,110,204,
96,235,0,60,96,70,227,210,39,83,73,110,131,77,204,7,67,142,189,16,93,163,18,174,143,31,76,39,216,179,104,
74,35,149,194,35,121,23,14,142,111,20,82,176,143,29,156,145,230,170,72,20,118,98,56,126,171,253,198,14,22,97,
182,184,246,35,55,228,218,198,59,127,95,99,226,122,175,186,148,36,74,87,138,157,171,80,17,180,169,204,37,191,232,
186,147,113,107,182,169,149,100,204,29,253,77,168,94,78};

  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 170,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
#endif
	}
#endif
	//以下是将自定义的加密表达式送到加密锁中进行运算
#ifdef CHILD_VERSION
#ifdef TIMEDOG_VERSION
  BYTE DecArray[170]={165,0,155,36,108,29,239,177,248,109,158,204,35,145,151,54,246,181,65,82,47,181,165,227,179,58,34,124,219,147,2,
187,20,190,135,28,194,114,8,55,227,207,101,71,212,245,186,140,77,72,51,73,107,9,168,36,176,77,144,98,138,254,
93,212,181,194,174,38,218,17,90,214,129,169,180,217,232,233,154,239,105,154,101,71,212,245,186,140,77,72,117,31,31,
94,51,162,116,126,23,198,7,92,161,150,172,69,191,218,175,60,118,199,146,89,104,36,207,40,99,144,193,90,150,88,
27,200,242,36,39,212,212,75,209,78,196,131,65,17,99,98,118,14,196,141,147,157,149,184,169,237,210,230,145,173,117,
6,157,33,108,201,150,122,205,247,63,205,233,29,115,113};
#else
#ifdef BASIC_VERSION
 BYTE DecArray[170]={165,0,132,7,184,103,168,20,238,203,14,205,60,163,74,103,242,197,156,233,7,103,217,71,130,127,171,7,50,61,15,
20,162,52,83,149,35,120,134,107,64,88,92,92,147,192,177,222,47,175,94,178,207,148,213,253,177,6,139,224,85,127,
225,140,221,250,8,110,61,93,3,204,109,193,140,174,83,226,195,214,11,116,92,92,147,192,177,222,47,175,23,254,230,
32,230,166,252,8,244,123,202,64,187,108,170,45,16,200,46,15,85,149,107,106,147,42,123,198,171,212,76,114,116,231,
44,62,143,129,173,134,205,57,167,58,19,171,55,130,155,193,27,72,17,48,14,125,139,229,51,238,3,2,200,68,211,
192,21,112,205,8,103,190,171,141,220,144,229,175,169,150};
#else
  BYTE DecArray[170]={165,0,4,68,109,78,48,133,125,79,69,233,236,222,133,238,125,244,231,155,69,97,39,207,53,147,221,142,151,32,142,
247,110,59,51,53,76,171,15,202,83,133,87,205,177,135,188,56,167,255,184,254,87,35,198,246,31,102,47,255,65,52,
186,182,252,225,197,126,68,89,193,179,29,140,242,232,63,231,235,149,52,43,87,205,177,135,188,56,167,255,176,140,141,
52,144,233,51,152,181,28,219,181,242,192,144,97,29,153,143,142,158,179,44,226,216,53,211,10,24,60,20,110,244,16,
235,83,149,71,143,129,83,151,232,21,86,167,102,132,112,237,198,16,254,113,143,172,231,81,44,3,200,170,8,120,245,
9,66,152,164,170,253,203,120,102,209,255,59,170,11,53};
#endif
#endif
#else
#ifdef TIMEDOG_VERSION
//以下是将自定义的加密表达式送到加密锁中进行运算
  BYTE DecArray[170]={165,0,207,71,24,147,24,85,146,162,42,84,182,39,165,79,251,45,226,194,108,39,122,34,241,166,184,148,79,11,157,
2,150,185,245,188,132,179,227,142,52,201,220,142,122,194,121,26,142,196,43,154,219,192,10,212,43,198,93,70,156,186,
12,212,234,204,0,71,223,146,68,8,193,95,208,145,240,87,30,177,112,246,220,142,122,194,121,26,142,196,129,212,7,
202,246,72,77,57,118,83,108,49,20,112,112,223,138,32,109,170,194,117,26,125,219,140,232,10,23,55,200,237,173,214,
49,176,252,100,7,88,44,143,136,40,189,139,241,223,136,47,131,207,212,21,69,239,249,138,206,104,84,151,88,53,85,
190,113,211,25,67,238,189,25,182,120,11,247,158,109,230};
#else
#ifdef BASIC_VERSION
 BYTE DecArray[170]={165,0,113,221,220,135,230,93,63,87,252,227,210,218,153,238,20,93,168,96,229,178,14,65,175,5,28,144,176,156,242,
38,52,223,163,175,226,149,175,30,241,204,195,181,62,2,69,53,126,65,242,211,249,74,251,156,169,61,241,73,170,77,
232,133,37,130,105,137,213,157,164,75,85,103,213,236,201,122,37,142,218,71,195,181,62,2,69,53,126,65,39,221,154,
88,228,26,136,251,156,186,137,42,252,98,196,63,54,186,142,43,125,35,16,212,106,62,185,219,228,9,93,13,106,148,
135,84,116,111,186,104,44,240,131,140,247,99,45,21,115,145,102,139,64,96,98,134,65,12,117,83,202,237,248,213,140,
120,233,173,122,25,204,255,230,223,130,152,234,29,68,220};
#else
  BYTE DecArray[170]={165,0,180,54,88,11,249,124,230,232,137,34,214,101,153,152,75,15,68,235,16,211,200,14,19,217,254,68,124,30,7,
245,27,106,191,95,41,148,21,3,238,128,199,185,13,113,21,248,159,79,219,253,253,16,173,57,229,191,32,199,33,137,
0,68,89,229,151,31,9,1,180,104,193,64,225,126,107,131,114,14,145,222,199,185,13,113,21,248,159,79,1,171,157,
120,191,193,189,148,96,218,128,33,111,64,169,98,218,53,61,118,213,169,235,197,214,72,219,29,16,59,140,171,162,155,
247,109,121,134,220,51,206,241,120,245,42,168,208,177,49,191,93,145,36,149,164,12,73,209,178,241,1,249,209,86,84,
44,240,213,135,85,182,244,199,247,144,181,255,94,3,130};
#endif
#endif
#endif
  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 170,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
}

int SoftKey::decryptpiccount(long *D0, long *D1,long *D2, long *D3,long *D4, long *D5,long *D6, long *D7,
				double *F0, double *F1,double *F2, double *F3,double *F4, double *F5,double *F6, double *F7,
				TCHAR *S0, TCHAR *S1,TCHAR *S2, TCHAR *S3,TCHAR *S4, TCHAR *S5,TCHAR *S6, TCHAR *S7)
{
	MyLock lock("lyfzdogxiao");
#ifdef ENTERPRISE_VERSION
	{
#ifdef CHILD_VERSION
   BYTE DecArray[50]={45,0,147,104,82,196,215,216,235,204,56,13,195,1,177,190,15,72,223,218,142,47,162,116,18,34,12,131,107,125,196,
251,42,90,236,117,73,75,87,42,179,93,147,104,49,74,127,38,148,231};

  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 50,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
#else
  BYTE DecArray[50]={45,0,222,103,159,172,40,167,208,6,203,158,190,21,65,71,160,175,159,13,41,58,57,72,44,94,139,248,99,104,178,
235,173,27,130,130,27,199,66,18,134,83,100,204,29,253,77,168,94,78};

  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 50,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
#endif
	}
#endif
	//以下是将自定义的加密表达式送到加密锁中进行运算
#ifdef CHILD_VERSION
#ifdef TIMEDOG_VERSION
  BYTE DecArray[50]={45,0,43,6,201,164,135,37,130,47,2,48,90,234,242,156,147,192,119,180,50,34,85,169,72,191,202,66,85,82,39,
200,8,159,179,47,151,126,97,19,235,221,205,247,63,205,233,29,115,113};
#else
#ifdef BASIC_VERSION
  BYTE DecArray[50]={45,0,104,72,196,228,86,183,93,190,212,217,91,67,194,132,126,210,242,191,214,157,37,200,204,138,125,216,49,28,105,
17,240,66,236,90,212,194,66,118,101,92,171,141,220,144,229,175,169,150};
#else
  BYTE DecArray[50]={45,0,241,71,71,7,110,131,28,231,9,67,28,223,84,66,141,81,46,172,54,16,25,237,57,222,80,176,37,124,68,
9,0,65,197,217,187,200,46,217,156,139,120,102,209,255,59,170,11,53};
#endif
#endif
#else
#ifdef TIMEDOG_VERSION
 BYTE DecArray[50]={45,0,21,168,239,151,123,91,187,179,173,129,81,46,197,20,153,207,237,163,251,74,201,3,249,210,210,0,87,197,246,
242,1,6,60,44,112,3,135,143,185,19,25,182,120,11,247,158,109,230};
#else
#ifdef BASIC_VERSION
  BYTE DecArray[50]={45,0,119,72,174,75,229,164,87,225,179,67,217,187,206,101,148,215,132,252,237,128,210,252,110,4,193,42,112,158,204,
138,28,119,85,211,237,158,99,1,100,192,230,223,130,152,234,29,68,220};
#else
  BYTE DecArray[50]={45,0,132,187,191,188,64,66,211,45,83,131,136,64,230,26,226,83,230,131,52,138,212,85,35,172,41,230,18,91,203,
152,137,147,53,117,7,70,253,219,237,232,199,247,144,181,255,94,3,130};
#endif
#endif
#endif
  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 50,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
}

int SoftKey::checktime(long *D0, long *D1,long *D2, long *D3,long *D4, long *D5,long *D6, long *D7,
				double *F0, double *F1,double *F2, double *F3,double *F4, double *F5,double *F6, double *F7,
				char *S0, char *S1,char *S2, char *S3,char *S4, char *S5,char *S6, char *S7)
{
	//以下是将自定义的加密表达式送到加密锁中进行运算
#ifdef CHILD_VERSION
 BYTE DecArray[50]={42,0,216,74,84,129,170,161,101,132,224,254,25,137,65,28,233,158,195,123,11,72,11,236,67,83,141,41,29,134,59,
211,181,155,69,49,196,198,31,71,28,114,207,121,153,36,41,0,84,188};
#else
 BYTE DecArray[50]={42,0,131,64,244,171,201,133,126,20,4,70,82,123,76,209,159,224,142,117,56,107,68,249,254,173,226,222,246,164,227,
8,98,117,118,223,118,228,252,31,58,180,85,106,81,59,161,72,50,255};
#endif
  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 50,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
}

int SoftKey::timedog1(long *D0, long *D1,long *D2, long *D3,long *D4, long *D5,long *D6, long *D7,
				double *F0, double *F1,double *F2, double *F3,double *F4, double *F5,double *F6, double *F7,
				char *S0, char *S1,char *S2, char *S3,char *S4, char *S5,char *S6, char *S7)
{
	//以下是将自定义的加密表达式送到加密锁中进行运算
#ifdef CHILD_VERSION
BYTE DecArray[58]={49,0,175,209,28,104,147,167,146,125,206,91,185,10,215,168,127,79,88,63,64,200,187,234,230,66,116,252,103,232,84,
137,133,21,79,226,150,120,0,183,117,45,196,3,251,19,92,208,12,119,255,202,141,79,220,172,110,237};
#else
	//以下是将自定义的加密表达式送到加密锁中进行运算
  BYTE DecArray[58]={49,0,129,66,42,22,38,72,238,144,234,221,236,202,147,255,60,18,6,118,169,229,169,222,249,105,155,25,184,29,213,
5,51,90,89,32,80,201,61,18,97,253,240,158,133,174,137,248,73,65,2,166,149,130,58,231,198,78};

#endif
  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 58,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
}

int SoftKey::timedog2(long *D0, long *D1,long *D2, long *D3,long *D4, long *D5,long *D6, long *D7,
				double *F0, double *F1,double *F2, double *F3,double *F4, double *F5,double *F6, double *F7,
				char *S0, char *S1,char *S2, char *S3,char *S4, char *S5,char *S6, char *S7)
{
	//以下是将自定义的加密表达式送到加密锁中进行运算
#ifdef CHILD_VERSION
BYTE DecArray[66]={60,0,150,120,112,153,195,252,95,208,24,113,123,52,228,108,10,156,25,101,63,108,66,137,189,145,150,157,21,30,66,
108,47,81,144,227,126,160,129,36,237,242,30,218,144,168,248,24,131,126,0,47,3,37,200,210,180,54,174,139,55,118,
239,59,5,194};
#else
   BYTE DecArray[66]={60,0,1,198,80,227,80,4,154,253,210,149,192,112,40,33,253,99,117,243,64,239,89,59,210,173,91,92,194,31,199,
87,91,8,221,218,84,119,22,245,179,131,121,82,6,173,138,151,237,24,216,88,86,12,200,38,129,217,117,212,114,73,
109,140,85,68};
#endif
  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 66,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
}

int SoftKey::getdata(long *D0, long *D1,long *D2, long *D3,long *D4, long *D5,long *D6, long *D7,
				double *F0, double *F1,double *F2, double *F3,double *F4, double *F5,double *F6, double *F7,
				char *S0, char *S1,char *S2, char *S3,char *S4, char *S5,char *S6, char *S7)
{
	if(g_nDogType==0)
	{
	//以下是将自定义的加密表达式送到加密锁中进行运算
  BYTE DecArray[82]={73,0,94,220,40,182,30,120,56,193,78,101,1,144,68,206,192,52,67,9,243,20,9,195,153,15,22,217,243,79,177,
22,24,171,185,157,172,67,117,124,153,165,3,41,218,47,149,150,48,152,75,250,204,253,92,53,121,147,242,140,80,66,
34,194,16,109,237,17,222,161,96,8,11,194,140,223,143,91,236,189,190,244};

  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 82,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
	}
	else
	{
BYTE DecArray[82]={73,0,229,36,223,222,213,46,70,55,240,207,237,75,226,68,133,100,42,119,89,131,79,104,158,17,172,239,4,158,201,
51,62,51,94,232,14,124,81,64,100,141,187,85,156,59,205,116,200,24,108,218,145,22,7,36,45,7,156,255,170,130,
165,140,99,216,120,72,171,196,27,49,138,199,248,48,186,230,74,19,154,203};

  //这里对数据进行初始化工作
  //...
  return CalEx(DecArray, 82,D0,D1,D2,D3,D4,D5,D6,D7,
	  F0,F1,F2,F3,F4,F5,F6,F7,S0,S1,S2,S3,S4,S5,S6,S7,KeyPath,20000);
	}
}

//addtofile...请不要修改这里

void  SoftKey::GetErrInfo(long err,TCHAR  *ErrInfo )
{
switch(err) 
{
		case -1:
    strcat(ErrInfo, "未找到返回结果变量");
		break;
		case -2:
    strcat(ErrInfo, "未找到 = 符号");
		break;
		case -3:
    strcat(ErrInfo, "代表没有找到相应常数");
		break;
		case -5:
    strcat(ErrInfo, "代表找不到字符串的第一个双引号");
		break;
		case -6:
    strcat(ErrInfo, "代表找不到字符串的第二个双引号");
		break;
		case -7:
    strcat(ErrInfo, "IF语句没有找到goto字符");
		break;
		case -8:
    strcat(ErrInfo, "IF语句没有找到第一个比较字符");
		break;
		case -9:
    strcat(ErrInfo, "IF语句没有找到比较符号");
		break;
		case -10:
    strcat(ErrInfo, "两边变量类型不相符");
		break;
		case -11:
    strcat(ErrInfo, "没有找到NOT符号");
		break;
		case -12:
    strcat(ErrInfo, "不是整形变量");
		break;
		case -13:
    strcat(ErrInfo, "代表没有找到相应整形常数");
		break;
		case -14:
    strcat(ErrInfo, "代表没有找到相应字符串常数");
		break;
		case -15:
    strcat(ErrInfo, "代表没有找到相应浮点常数");
		break;
		case -16:
    strcat(ErrInfo, "代表不支持这个运算");
		break;
		case -17:
    strcat(ErrInfo, "代表没有左边括号");
		break;
		case -18:
    strcat(ErrInfo, "代表没有变量");
		break;
		case -19:
    strcat(ErrInfo, "代表没“，”");
		break;
		case -20:
    strcat(ErrInfo, "代表没有右边括号");
		break;
		case -21:
    strcat(ErrInfo, "代表常数超过指这定的范围");
		break;
		case -22:
    strcat(ErrInfo, "代表储存器的地址超过指定的范围，整数不能超过EEPROM_LEN-4，浮点不能超过30720-8");
		break;
		case -23:
    strcat(ErrInfo, "代表储存器的地址超过指定的范围，字符串不能超过EEPROM_LEN-LEN，其中LEN为字符串的长度");
		break;
		case -24:
    strcat(ErrInfo, "除法中，被除数不能为0");
		break;
		case -25:
    strcat(ErrInfo, "未知错误");
		break;
		case -26:
    strcat(ErrInfo, "第二个变量不在指定的位置");
		break;
		case -27:
    strcat(ErrInfo, "字符串常量超过指定的长度");
		break;
		case -28:
    strcat(ErrInfo, "不是字符串变量");
		break;
		case -29:
    strcat(ErrInfo, "没有第三个变量");
		break;
		case -30:
    strcat(ErrInfo, "GOTO的标识语句不能全为数字");
		break;
		case -31:
    strcat(ErrInfo, "不能打开ENC文件");
		break;
		case -32:
    strcat(ErrInfo, "不能读ENC文件");
		break;
		case -33:
    strcat(ErrInfo, "GOTO CALL不能找到指定的跳转位置");
		break;
		case -34:
    strcat(ErrInfo, "智能卡运算中，未知数据类型");
		break;
		case -35:
    strcat(ErrInfo, "智能卡运算中，未知代码类型");
		break;
		case -36:
    strcat(ErrInfo, "字符串长度超出50");
		break;
		case -37:
    strcat(ErrInfo, "RIGHT操作时超长，负长");
		break;
		case -38:
    strcat(ErrInfo, "标识重复");
		break;
		case -39:
    strcat(ErrInfo, "程序堆栈溢出");
		break;
		case -40:
    strcat(ErrInfo, "堆栈溢出");
		break;
		case -41:
    strcat(ErrInfo, "不能建立编译文件，请查看文件是否有只读属性，或被其它文件打开");
		break;
		case -42:
    strcat(ErrInfo, "不能写文件，请查看文件是否有只读属性，或被其它文件打开");
		break;
		case -43:
    strcat(ErrInfo, "程序被中途使用END语句结束");
		break;
		case -44:
    strcat(ErrInfo, "程序跳转到外部的空间");
		break;
		case -45:
    strcat(ErrInfo, "传送数据失败");
		break;
		case -46:
    strcat(ErrInfo, "程序超出运算次数，可能是死循环");
		break;
		case -47:
    strcat(ErrInfo, "写密码不正确");
		break;
		case -48:
    strcat(ErrInfo, "读密码不正确");
		break;
		case -49:
    strcat(ErrInfo, "读写EEPROM时，地址溢出");
		break;
		case -50:
    strcat(ErrInfo, "USB操作失败，可能是没有找到相关的指令");
		break;
		case -51:
    strcat(ErrInfo, "打开USB文件句柄失败");
		break;
		case -52:
    strcat(ErrInfo, "使用加密锁加密自定义表达式，生成加密代码时生产错误");
		break;
		case -53:
    strcat(ErrInfo, "无法打开usb设备，可能驱动程序没有安装或没有插入加密锁。");
		break;
		case -63 :
	strcat(ErrInfo, "不能打开指定的文件。");
		break;
		case -64:
	strcat(ErrInfo, "不能建立指定的文件。");
		break;
		case -65:
   // strcat(ErrInfo, "验证码错误，可能是输入解密密钥错误，或注册授权码错误");
    strcat(ErrInfo, "注册授权码错误!");
	    break;
		case -66:
    strcat(ErrInfo,  "执行TIMEOUT函数或UPDATE函数时，输入的ID与锁ID不相符");
	    break;
		case -67:
//	strcat(ErrInfo,  "执行TIMEOUT函数时，智能卡运行函数已到期");
#ifdef BESTGIFT
	strcat(ErrInfo,  "加密锁已过期，请报告机器码给礼品王并索取新的注册授权码!");
#else
	strcat(ErrInfo,  "加密锁已过期，请报告机器码给经销商并索取新的注册授权码!");
#endif

		break;
		case -68:
    strcat(ErrInfo, "操作浮点运算时，输入的参数将会导致返回值是一个无穷值");
		break;
		case -69:
    strcat(ErrInfo,  "代表没足够的变量参数");
		break;
		case -70:
    strcat(ErrInfo,  "返回变量与函数不相符");
		break;
		case -71:
    strcat(ErrInfo,  "浮点数转换字符串时，要转换的数据太大。");
		break;
		case  -72: 
	strcat(ErrInfo,  "初始化服务器错误");
		break;
		case   -73: 
	strcat(ErrInfo,  "对缓冲区进行MD5运算时错误");
		break;
		case  -74 :
	strcat(ErrInfo,  "MD5验证IPVAR错误");
		break;
		case  -75 :
	strcat(ErrInfo,  "MD5验证IPCount错误");
		break;
		case  -76 :
	strcat(ErrInfo,  "没有找到对应的SOCKET连接");
		break;
		case  -77: 
	strcat(ErrInfo,  "没有找到要删除的对应的SOCKET连接");
		break;
		case  -78 :
	strcat(ErrInfo,  "没有找到要删除的对应的功能模块号连接");
		break;
		case -79: 
	strcat(ErrInfo,  "没有找到要增加的对应的功能模块号连接");
		break;	
		case  -80: 
	strcat(ErrInfo,  "用户数已超过限制的授权数量");
		break;
		case  -81:
	strcat(ErrInfo,  "找不到对应的INI文件条目");
		break;
		case  -82:
	strcat(ErrInfo,  "没有进行初始化服务工作。");
		break;
		case -252:
	strcat(ErrInfo, "密码不正确");
	    break;
		case -1088:
	strcat(ErrInfo, "发送数据错误");
	    break;
		case -1089:
	strcat(ErrInfo, "获取数据错误");
	    break;
		case -1092:
	strcat(ErrInfo, "找不到对应的服务端操作码");
	    break;
		case -1093:
	strcat(ErrInfo, "表示连接服务时错误");
	    break;
		case -1095:
	strcat(ErrInfo, "获取主机名称失败");
	    break;
		case -1097:
	strcat(ErrInfo, "建立套字接错误");
	    break;
		case -1098:
	strcat(ErrInfo, "绑定套字节端口错误");
	    break;
		case -1099:
	strcat(ErrInfo, "表示无效连接，不能进行相关的操作。");
	    break;
		case -2002:
	strcat(ErrInfo, "表示监听时产生错误");
	    break;
		case -2003:
	strcat(ErrInfo, "表示发送的数据长度与接收的数据长度不相符");
	    break;
		case -2005:
	strcat(ErrInfo, "表示当前服务不存在任何连接");
	    break;
		case -2006:
	strcat(ErrInfo, "表示当前查询节点超出集合范范围");
	    break;
		case -2009:
	strcat(ErrInfo, "表示关闭连接错误");
	    break;
		case -1052:
    strcat(ErrInfo, "可能是输入的授权号不正确。");
		break;
		case -1053:
    strcat(ErrInfo,"系统上没有任何智能锁。");
		break;
	default:
		  strcat(ErrInfo, "未知错误代码");
	}
}