自学教程：C++ II函数代码示例

void CPSRawDlg::OnSet() {	CString str;    int usedLen;    uint16 data[MAX_HEX_DATA];	uint16 key_num = m_spin_key.GetPos();	m_ed_str.GetWindowText(str);    if (GetHexData<uint16>(str, data, MAX_HEX_DATA, &usedLen, 4))    {	    if ((m_raw_len != -1) && (usedLen != m_raw_len))	    {		    if (MessageBox(II("The length of the data you have entered does not match the length previously read.  Proceed with write?"), II("Mismatch in entry length"), MB_YESNO | MB_ICONWARNING) == IDNO)			    return;	    }	    if (m_helper->psbc_set_pres_or_raw_if_different(key_num, data, usedLen))        {            OnRead();        }        else        {            MessageBox(II("Set failed"));        }    }    else    {        MessageBox(II("The value is not valid. Enter a hexadecimal string"));    }	m_changed = false;}

void CPSRawDlg::OnRead() {	uint16 data[256];	uint16 len;	uint16 key_num;	key_num = m_spin_key.GetPos();	if (m_helper->psbc_get_pres_or_raw(key_num, data, 256, &len))	{		ichar str[1024];		int i;		str[0] =II('/0');		ASSERT(len < 100);		for (i = 0; i < len; i++)		{			isprintf(str + istrlen(str), 1024 - istrlen(str), II("%04x") , data[i]);			if (i < len - 1)	  		    isprintf(str + istrlen(str), 1024 - istrlen(str), II(" "));		}		m_ed_str.SetWindowText(str);		m_changed = false;		m_raw_len = len;		m_present = true;	}	else	{		m_present = false;		m_ed_str.SetWindowText(II("0000"));	}	m_caption_present.ShowWindow(!m_present);		}		

int iisdigit(iint c){#if !defined(_WINCE) && !defined(_WIN32_WCE)    return ICHAR_SELECT(isdigit, iswdigit)(c);#else    return ((c >= II('0')) && (c <= II('9')));#endif}

void CPSRawDlg::OnDelete() {	if (MessageBox(II("Are you sure you want to clear this key?"), II("Confirm delete key"), MB_ICONWARNING | MB_YESNO) == IDYES)	{		uint16 key_num = m_spin_key.GetPos();		if (!m_helper->psbc_clr(key_num))        {            MessageBox(II("Delete failed"));        }	}}

/* ionosphere residuals ------------------------------------------------------*/static int res_iono(const obsd_t *obs, int n, const nav_t *nav,                    const double *rs, const double *rr, const double *pos,                    const double *azel, const pcv_t *pcv, const ekf_t *ekf,                    double *phw, double *v, double *H, double *R){    double *sig,P1,P2,L1,L2,c_iono=1.0-SQR(lam[1]/lam[0]);    double LG,PG,antdel[3]={0},dant[NFREQ]={0};    int i,j,nv=0,sat;        sig=mat(1,2*n);        for (i=0;i<n;i++) {        if (!raw_obs(obs+i,nav,&P1,&P2,&L1,&L2)||azel[i*2+1]<MIN_EL) continue;                sat=obs[i].sat;                /* ionosphere-LC model */        LG=-c_iono*ekf->x[II(sat)]+ekf->x[IB(sat)];        PG= c_iono*ekf->x[II(sat)]+nav->cbias[sat-1][0];                /* receiver antenna phase center offset and variation */        if (pcv) {            antmodel(pcv,antdel,azel+i*2,dant);            LG+=dant[0]-dant[1];            PG+=dant[0]-dant[1];        }        /* phase windup correction */        windupcorr(obs[i].time,rs+i*6,rr,phw+obs[i].sat-1);        LG+=(lam[0]-lam[1])*phw[obs[i].sat-1];                /* residuals of ionosphere (geometriy-free) LC */        v[nv  ]=(L1-L2)-LG;#if 0        v[nv+1]=(P1-P2)-PG;#else        v[nv+1]=0.0;#endif        for (j=0;j<ekf->nx*2;j++) H[ekf->nx*nv+j]=0.0;        H[ekf->nx*nv    +II(sat)]=-c_iono;        H[ekf->nx*nv    +IB(sat)]=1.0;        H[ekf->nx*(nv+1)+II(sat)]=c_iono;                sig[nv  ]=sig_err(azel+i*2);        sig[nv+1]=RATIO_ERR*sig[nv];        nv+=2;    }    for (i=0;i<nv;i++) for (j=0;j<nv;j++) {        R[i+j*nv]=i==j?SQR(sig[i]):0.0;    }    free(sig);    return nv;}

/* temporal update of states --------------------------------------------------*/static void ud_state(const obsd_t *obs, int n, const nav_t *nav,                     const double *pos, const double *azel, ekf_t *ekf,                     sstat_t *sstat){    double P1,P2,L1,L2,PG,LG,tt,F[4]={0},Q[2]={0};    double x[2]={0},P[2],c_iono=1.0-SQR(lam[1]/lam[0]);    int i,sat,slip;        for (i=0;i<n;i++) {                /* raw pseudorange and phase range */        if (!raw_obs(obs+i,nav,&P1,&P2,&L1,&L2)||azel[i*2+1]<MIN_EL) continue;                sat=obs[i].sat;        tt=timediff(obs[i].time,sstat[sat-1].time);        LG=L1-L2;        PG=P1-P2;        slip=(obs[i].LLI[0]&3)||(obs[i].LLI[1]&3);        slip|=fabs(LG-sstat[sat-1].LG)>THRES_LG;                if (fabs(tt)>MAXGAP_IONO) {#if 1            x[0]=PG/c_iono;#else            x[0]=ionmodel(obs[i].time,nav->ion_gps,pos,azel+i*2);#endif            x[1]=1E-6;            P[0]=VAR_IONO;            P[1]=VAR_IONR;            ekf_init(ekf,x,P,II(sat),2);        }        else {            F[0]=F[3]=1.0;            F[2]=tt;            Q[0]=PRN_IONO*fabs(tt);            Q[1]=PRN_IONR*fabs(tt);            ekf_pred(ekf,F,Q,II(sat),2);        }        if (tt>MAXGAP_BIAS||slip) {            x[0]=LG+PG;            P[0]=VAR_BIAS;            ekf_init(ekf,x,P,IB(sat),1);        }        sstat[sat-1].time=obs[i].time;        sstat[sat-1].azel[0]=azel[i*2];        sstat[sat-1].azel[1]=azel[i*2+1];        sstat[sat-1].slip=slip;        sstat[sat-1].LG=LG;        sstat[sat-1].PG=PG;    }}

static bool f14h_mc0_mce(u16 ec, u8 xec){	u8 r4	 = R4(ec);	bool ret = true;	if (MEM_ERROR(ec)) {		if (TT(ec) != TT_DATA || LL(ec) != LL_L1)			return false;		switch (r4) {		case R4_DRD:		case R4_DWR:			pr_cont("Data/Tag parity error due to %s./n",				(r4 == R4_DRD ? "load/hw prf" : "store"));			break;		case R4_EVICT:			pr_cont("Copyback parity error on a tag miss./n");			break;		case R4_SNOOP:			pr_cont("Tag parity error during snoop./n");			break;		default:			ret = false;		}	} else if (BUS_ERROR(ec)) {		if ((II(ec) != II_MEM && II(ec) != II_IO) || LL(ec) != LL_LG)			return false;		pr_cont("System read data error on a ");		switch (r4) {		case R4_RD:			pr_cont("TLB reload./n");			break;		case R4_DWR:			pr_cont("store./n");			break;		case R4_DRD:			pr_cont("load./n");			break;		default:			ret = false;		}	} else {		ret = false;	}	return ret;}

/* temporal update of states --------------------------------------------------*/static void udstate(const obsd_t *obs, int n, const nav_t *nav, double *x,                    double *P, int nx, ssat_t *ssat){    gtime_t time;    double tt;    int i,sat;        for (i=0;i<n;i++) {        sat=obs[i].sat        time=ssat[sat-1].time;                if (!time.time) {            init_iono(obs+i,nav,x,P,nx);            init_bias(obs+i,nav,x,P,nx);        }        else {            tt=timediff(obs[i].time,time);                        P[II(sat)*(nx+1)]+=PRN_IONO*fabs(tt);                        if (det_slip(obs+i,nav,ssat)||fabs(tt)>MAXGAP_BIAS) {                init_bias(obs+i,nav,x,P,nx);            }        }        ssat[sat-1].time=time;    }}

BOOL CSmallPolygonsVisDlg::OnInitDialog(){	CDialogEx::OnInitDialog();	// Set the icon for this dialog.  The framework does this automatically	//  when the application's main window is not a dialog	SetIcon(m_hIcon, TRUE);			// Set big icon	SetIcon(m_hIcon, FALSE);		// Set small icon	IISet s;	for (int i = 0; i < 100; ++i) {		int x = (rand() * MAX_COORDINATE) / (RAND_MAX + 1);		int y = (rand() * MAX_COORDINATE) / (RAND_MAX + 1);		s.insert(II(x, y));	}	int N = 10;	int Np = s.size();	std::vector<int> points;	for (auto p : s) {		points.push_back(p.first);		points.push_back(p.second);	}	m_sp.init(points, N);	m_sp.findTriangles();	m_sp.chooseFirstPolygon();	for (int i = 0; i < 100; ++i) {		m_sp.chooseNextVertex();	}	return TRUE;  // return TRUE  unless you set the focus to a control}

void process(int vtx){	taken[vtx] = 1;	for(int j=0; j<(int)adjList[vtx].size(); j++){		II v = adjList[vtx][j];		if(!taken[v.first]) pq.push(II(-v.second,-v.first));	}}

void recorreIzqDerAVL( AVL *a, AVL *aux, int *band ){  if( !(*a) -> der )  {    *aux = *a;    *a = (*a) -> izq;  }else      {        recorreIzqDerAVL( &(*a) -> der, aux, band );                if( *band )        {          if( (*a) -> fe == 0 )          {            (*a) -> fe == -1;            *band = 0;                    }else              {                if( (*a) -> fe == 1 )                     (*a) -> fe = 0;                else                     if( (*a) -> izq -> fe <= 0 )                     {                        if( (*a) -> izq -> fe == 0 )                           *band = 0;                                                   II( a );                     }else                           ID( a );               }          }        }}

int buscarDerechaAVL( AVL *a, int dato, int *band ){   int retAux;      retAux = eliminaAVL( &(*a)->der, dato, band );      if( *band )   {      if( (*a) -> fe == 0 )      {         (*a) -> fe = -1;         *band = 0;      }else          if( (*a) -> fe == 1 )               (*a) -> fe = 0;          else             {               if( (*a) -> der -> fe <= 0 )               {                  if( (*a) -> der -> fe == 0 )                      *band = 0;                                     II( a );               }else                   ID( a );                }   }      return( retAux );}

bool mrpt::vision::pnp::ppnp::compute_pose(	Eigen::Matrix3d& R, Eigen::Vector3d& t, int n){	double tol = 0.00001;	Eigen::MatrixXd I = Eigen::MatrixXd::Identity(n, n), A(n, n), Y(n, 3),					E(n, 3), E_old(n, 3), U, V,					I3 = Eigen::MatrixXd::Identity(3, 3), PR,					Z = Eigen::MatrixXd::Zero(n, n);	Eigen::VectorXd e(n), II(n), c(3), Zmindiag(n);	e.fill(1);	II.fill(1.0 / ((double)n));	A = I - e * e.transpose() / n;	double err = std::numeric_limits<double>::infinity();	E_old.fill(1000);	int cnt = 0;	while (err > tol)	{		Eigen::JacobiSVD<Eigen::MatrixXd> svd(			P.transpose() * Z * A * S,			Eigen::ComputeThinU | Eigen::ComputeThinV);		U = svd.matrixU();		V = svd.matrixV();		I3(2, 2) = (U * V.transpose()).determinant();		R = U * I3 * V.transpose();		PR = P * R;		c = (S - Z * PR).transpose() * II;		Y = S - e * c.transpose();		Zmindiag = ((PR * Y.transpose()).diagonal()).array() /				   ((P.array() * P.array()).rowwise().sum()).array();		for (int i = 0; i < n; i++)			if (Zmindiag(i) < 0) Zmindiag(i) = 0;		Z = Zmindiag.asDiagonal();		E = Y - Z * PR;		err = (E - E_old).norm();		E_old = E;		cnt++;	}	t = -R * c;	return true;}

long istrtol(const ichar *nptr, ichar **endptr, int base){#if !defined _WINCE && !defined _WIN32_WCE    return ICHAR_SELECT(strtol, wcstol)(nptr, endptr, base);#else//  ASSERT(base == 10);  const ichar *p = nptr;  if (*p == II('-'))  {      p++;      return 0L - (long)istrtoul(p, endptr, base);  }  if (*p == II('+'))      p++;  return (long) istrtoul(p, endptr, base);#endif}

void BMatSetZero(BMat& C, BMat& mat) {  for(int I = 0; I < (int)C.size(); I++) {    pair<Irrep, Irrep> II(I, I);    MatrixXcd& CII = C[II];    mat[II] = MatrixXcd::Zero(CII.rows(), CII.cols());  }  }

/* initizlize ionosphere parameter --------------------------------------------*/static void init_iono(const obsd_t *obs, const double *azel, double *x,                      double *P, int nx){    double map,iono;    if (obs->P[0]==0||obs->P[1]==0) return;    map=ionmapf(pos,azel);    iono=(obs->P[0]-obs->P[1])/map;    initx(x,P,nx,II(obs->sat),iono,VAR_IONO);}

 void dijkstra(int src, IV &dis) {     set<II> q;     dis = IV(n, INF);     BV vis(n);     q.insert(II(0, src));     dis[src] = 0;     while (! q.empty()) {         II p = *(q.begin()); q.erase(q.begin());         int d = p.first, v = p.second;         if (vis[v]) continue;         vis[v] = true;         For (EL, e, adj[v]) {             int d2 = d + e->w;             if (d2 < dis[e->v]) {                 dis[e->v] = d2;                 q.insert(II(d2, e->v));             }         }     }

/* output ionosphere parameters ----------------------------------------------*/static void out_iono(gtime_t time, const ekf_t *ekf, const sstat_t *sstat,                     FILE *fp){    double tow;    char id[64];    int sat,week;        tow=time2gpst(time,&week);        for (sat=1;sat<=MAXSAT;sat++) {        if (sstat[sat-1].time.time==0||            timediff(time,sstat[sat-1].time)>MAXGAP_IONO) continue;        satno2id(sat,id);        fprintf(fp,"%s %4d %6.0f %-3s %d %8.4f %9.6f %7.4f %6.1f %5.1f %7.3f %11.3f/n",                STEC_RID,week,tow,id,sstat[sat-1].slip,                ekf->x[II(sat)],ekf->x[II(sat)+1],                sqrt(ekf->P[II(sat)*(ekf->nx+1)]),sstat[sat-1].azel[0]*R2D,                sstat[sat-1].azel[1]*R2D, sstat[sat-1].PG,sstat[sat-1].LG);    }}

int insAVL( AVL *a, int dato, int *band ){  int ret;    if( !*a )    ret = *band = creaNodoAVL( a , dato );  else    {       if( dato < (*a) -> info )       {         ret = insAVL( &(*a) -> izq, dato, band );                  if( *band )           if( (*a) -> fe == 0 )              (*a) -> fe = -1;           else               if( (*a ) -> fe == 1 )                  *band = (*a) -> fe = 0;               else                  {                    if( (*a) -> izq -> fe > 0 )                         ID( a );                    else                         II( a );                                        *band = 0;                  }         }else             if( dato > (*a) -> info )             {               ret = insAVL( &(*a) -> der, dato, band );                              if( *band )                  if( (*a) -> fe == 0 )                      (*a) -> fe = 1;               else                  if( (*a ) -> fe == -1 )                      *band = (*a) -> fe = 0;                  else                     {                       if( (*a) -> der -> fe >= 0 )                            DD( a );                       else                            DI( a );                                              *band = 0;             }         }else               ret = *band = 0;    }        return( ret );  }

void dgDynamicBodyAsymetric::SetMassMatrix(dgFloat32 mass, const dgMatrix& inertia){	//dgVector II;	m_principalAxis = inertia;	dgVector II (m_principalAxis.EigenVectors());	dgMatrix massMatrix(dgGetIdentityMatrix());	massMatrix[0][0] = II[0];	massMatrix[1][1] = II[1];	massMatrix[2][2] = II[2];	dgBody::SetMassMatrix(mass, massMatrix);}

 void calcRanks() {     II list[MAX_STUDENTS];     for ( int i = 0; i < si_cnt; ++ i )         list[i] = II(si_list[i].getSum(), i);     sort(list, list + si_cnt, greater<II>());     for ( int i = 0; i < si_cnt; ++ i ) {         if ( i > 0 && list[i].first == list[i - 1].first )             ranks[list[i].second] = ranks[list[i - 1].second];         else             ranks[list[i].second] = i + 1;     } }

/* ionosphere residuals ------------------------------------------------------*/static int res_iono(const obsd_t *obs, int n, const double *azel,                    const double *x, int nx, double *v, double *H, double *R){    double *sig,L1,L2,P1,P2,map;    int i,j,nv=0,sat;        sig=mat(1,2*n);        for (i=0;i<n;i++) {        sat=obs[i].sat;        L1=obs->L[0]*lam[0];        L2=obs->L[1]*lam[1];        P1=obs->P[0];        P2=obs->P[1];        if (L1==0||L2==0||P1==0||P2==0) continue;                /* ionosphere mapping function */        map=ionmapf(pos,azel+i*2);                /* residuals of ionosphere (geometriy-free) LC */        v[nv  ]=(L1-L2)+map*x[II(sat)]-x[IB(sat)];        v[nv+1]=(P1-P2)-map*x[II(sat)];                /* partial derivatives */        for (j=0;j<nx;j++) H[nx*nv+j]=0.0;        H[nx*nv    +II(sat)]=-map;        H[nx*nv    +IB(sat)]=1.0;        H[nx*(nv+1)+IB(sat)]=map;                /* standard deviation of error */        sig[nv  ]=std_err(azel);        sig[nv+1]=sig[nv]*RATIO_ERR;        nv+=2;    }    for (i=0;i<nv;i++) for (j=0;j<nv;j++) {        R[i+j*nv]=i==j?SQR(sig[i]):0.0;    }    free(sig);    return nv;}

 int prim_mst(int src) {     IIS q;     IV dis(n, INF);     BV flg(n);     dis[src] = 0;     q.insert(II(0, src));     int mst = 0;     while (! q.empty()) {         int d = q.begin()->first;         int v = q.begin()->second;         q.erase(q.begin());         if (flg[v]) continue;         flg[v] = true;         mst += d;         For (EL, e, adj[v])             if (!flg[e->v] && e->w < dis[e->v]) {                 dis[e->v] = e->w;                 q.insert(II(dis[e->v], e->v));             }     }     return mst; }

void DecodeCallBack::onTransportFailure (FailureMode f) {    {#ifdef THREADING_WORKAROUND        CriticalSection::Lock cs_lock (cs);#endif        printTimestamp ();        iprintlf(II("*** HCI TRANSPORT FAILED ***  (failureMode: "));        printByValue(transportErrors_d, f, 16, "Unknown transport error");        iprintlf(II(")"));#ifdef DONT_COMPLETELY_SCREW_UP_ANYONE_EXPECTING_NORMAL_END_OF_LINE_TERMINATORS        printlf("/n");#else        printf ("/r"); printlfOnly ("/n");        fflush (stdout);    }    if (auto_rawlog)    {        parseCmd("rawlog", true);    }#endif}

/* output ionosphere parameters ----------------------------------------------*/static int out_iono(gtime_t time, const double *x, const double *P, int nx,                    FILE *fp){    double tow;    char id[64];    int i,week;        tow=time2gpst(time,&week);        for (i=0;i<MAXSAT;i++) {        sat2id(i+1,id);        fprintf(fp,"$ION,%d,%.3f,%d,%s,%.1f,%.4f,%4f/n",week,tow,0,id,                ssat[i].azel[1]*R2D,x[II(i+1)],0);    }}

unsigned long istrtoul(const ichar *nptr, ichar **endptr, int base){#if !defined _WINCE && !defined _WIN32_WCE    return ICHAR_SELECT(strtoul, wcstoul)(nptr, endptr, base);#else    const ichar *p = nptr;    unsigned long val = 0;    // ASSERT(base == 10);    while (iisdigit(*p))    {        val = val * 10;        val = val + ((*p) - II('0'));        p++;    }    if (endptr)        *endptr = (ichar *)p;    return val;#endif}

/** MD5 Compression Function*/void MD5::compress_n(const byte input[], size_t blocks)   {   u32bit A = digest[0], B = digest[1], C = digest[2], D = digest[3];   for(size_t i = 0; i != blocks; ++i)      {      load_le(&M[0], input, M.size());      FF(A,B,C,D,M[ 0], 7,0xD76AA478);   FF(D,A,B,C,M[ 1],12,0xE8C7B756);      FF(C,D,A,B,M[ 2],17,0x242070DB);   FF(B,C,D,A,M[ 3],22,0xC1BDCEEE);      FF(A,B,C,D,M[ 4], 7,0xF57C0FAF);   FF(D,A,B,C,M[ 5],12,0x4787C62A);      FF(C,D,A,B,M[ 6],17,0xA8304613);   FF(B,C,D,A,M[ 7],22,0xFD469501);      FF(A,B,C,D,M[ 8], 7,0x698098D8);   FF(D,A,B,C,M[ 9],12,0x8B44F7AF);      FF(C,D,A,B,M[10],17,0xFFFF5BB1);   FF(B,C,D,A,M[11],22,0x895CD7BE);      FF(A,B,C,D,M[12], 7,0x6B901122);   FF(D,A,B,C,M[13],12,0xFD987193);      FF(C,D,A,B,M[14],17,0xA679438E);   FF(B,C,D,A,M[15],22,0x49B40821);      GG(A,B,C,D,M[ 1], 5,0xF61E2562);   GG(D,A,B,C,M[ 6], 9,0xC040B340);      GG(C,D,A,B,M[11],14,0x265E5A51);   GG(B,C,D,A,M[ 0],20,0xE9B6C7AA);      GG(A,B,C,D,M[ 5], 5,0xD62F105D);   GG(D,A,B,C,M[10], 9,0x02441453);      GG(C,D,A,B,M[15],14,0xD8A1E681);   GG(B,C,D,A,M[ 4],20,0xE7D3FBC8);      GG(A,B,C,D,M[ 9], 5,0x21E1CDE6);   GG(D,A,B,C,M[14], 9,0xC33707D6);      GG(C,D,A,B,M[ 3],14,0xF4D50D87);   GG(B,C,D,A,M[ 8],20,0x455A14ED);      GG(A,B,C,D,M[13], 5,0xA9E3E905);   GG(D,A,B,C,M[ 2], 9,0xFCEFA3F8);      GG(C,D,A,B,M[ 7],14,0x676F02D9);   GG(B,C,D,A,M[12],20,0x8D2A4C8A);      HH(A,B,C,D,M[ 5], 4,0xFFFA3942);   HH(D,A,B,C,M[ 8],11,0x8771F681);      HH(C,D,A,B,M[11],16,0x6D9D6122);   HH(B,C,D,A,M[14],23,0xFDE5380C);      HH(A,B,C,D,M[ 1], 4,0xA4BEEA44);   HH(D,A,B,C,M[ 4],11,0x4BDECFA9);      HH(C,D,A,B,M[ 7],16,0xF6BB4B60);   HH(B,C,D,A,M[10],23,0xBEBFBC70);      HH(A,B,C,D,M[13], 4,0x289B7EC6);   HH(D,A,B,C,M[ 0],11,0xEAA127FA);      HH(C,D,A,B,M[ 3],16,0xD4EF3085);   HH(B,C,D,A,M[ 6],23,0x04881D05);      HH(A,B,C,D,M[ 9], 4,0xD9D4D039);   HH(D,A,B,C,M[12],11,0xE6DB99E5);      HH(C,D,A,B,M[15],16,0x1FA27CF8);   HH(B,C,D,A,M[ 2],23,0xC4AC5665);      II(A,B,C,D,M[ 0], 6,0xF4292244);   II(D,A,B,C,M[ 7],10,0x432AFF97);      II(C,D,A,B,M[14],15,0xAB9423A7);   II(B,C,D,A,M[ 5],21,0xFC93A039);      II(A,B,C,D,M[12], 6,0x655B59C3);   II(D,A,B,C,M[ 3],10,0x8F0CCC92);      II(C,D,A,B,M[10],15,0xFFEFF47D);   II(B,C,D,A,M[ 1],21,0x85845DD1);      II(A,B,C,D,M[ 8], 6,0x6FA87E4F);   II(D,A,B,C,M[15],10,0xFE2CE6E0);      II(C,D,A,B,M[ 6],15,0xA3014314);   II(B,C,D,A,M[13],21,0x4E0811A1);      II(A,B,C,D,M[ 4], 6,0xF7537E82);   II(D,A,B,C,M[11],10,0xBD3AF235);      II(C,D,A,B,M[ 2],15,0x2AD7D2BB);   II(B,C,D,A,M[ 9],21,0xEB86D391);      A = (digest[0] += A);      B = (digest[1] += B);      C = (digest[2] += C);      D = (digest[3] += D);      input += hash_block_size();      }   }

void MD5::Transform(const uint8_t Block[64], int& error){        uint32_t a = m_lMD5[0];        uint32_t b = m_lMD5[1];        uint32_t c = m_lMD5[2];        uint32_t d = m_lMD5[3];        uint32_t X[16];        ByteToUINT( X, Block, 64, error);        //Round 1 Transformation        FF (a, b, c, d, X[ 0], MD5_S11, MD5_T01);        FF (d, a, b, c, X[ 1], MD5_S12, MD5_T02);        FF (c, d, a, b, X[ 2], MD5_S13, MD5_T03);        FF (b, c, d, a, X[ 3], MD5_S14, MD5_T04);        FF (a, b, c, d, X[ 4], MD5_S11, MD5_T05);        FF (d, a, b, c, X[ 5], MD5_S12, MD5_T06);        FF (c, d, a, b, X[ 6], MD5_S13, MD5_T07);        FF (b, c, d, a, X[ 7], MD5_S14, MD5_T08);        FF (a, b, c, d, X[ 8], MD5_S11, MD5_T09);        FF (d, a, b, c, X[ 9], MD5_S12, MD5_T10);        FF (c, d, a, b, X[10], MD5_S13, MD5_T11);        FF (b, c, d, a, X[11], MD5_S14, MD5_T12);        FF (a, b, c, d, X[12], MD5_S11, MD5_T13);        FF (d, a, b, c, X[13], MD5_S12, MD5_T14);        FF (c, d, a, b, X[14], MD5_S13, MD5_T15);        FF (b, c, d, a, X[15], MD5_S14, MD5_T16);        //Round 2 Transformation        GG (a, b, c, d, X[ 1], MD5_S21, MD5_T17);        GG (d, a, b, c, X[ 6], MD5_S22, MD5_T18);        GG (c, d, a, b, X[11], MD5_S23, MD5_T19);        GG (b, c, d, a, X[ 0], MD5_S24, MD5_T20);        GG (a, b, c, d, X[ 5], MD5_S21, MD5_T21);        GG (d, a, b, c, X[10], MD5_S22, MD5_T22);        GG (c, d, a, b, X[15], MD5_S23, MD5_T23);        GG (b, c, d, a, X[ 4], MD5_S24, MD5_T24);        GG (a, b, c, d, X[ 9], MD5_S21, MD5_T25);        GG (d, a, b, c, X[14], MD5_S22, MD5_T26);        GG (c, d, a, b, X[ 3], MD5_S23, MD5_T27);        GG (b, c, d, a, X[ 8], MD5_S24, MD5_T28);        GG (a, b, c, d, X[13], MD5_S21, MD5_T29);        GG (d, a, b, c, X[ 2], MD5_S22, MD5_T30);        GG (c, d, a, b, X[ 7], MD5_S23, MD5_T31);        GG (b, c, d, a, X[12], MD5_S24, MD5_T32);        //Round 3 Transformation        HH (a, b, c, d, X[ 5], MD5_S31, MD5_T33);        HH (d, a, b, c, X[ 8], MD5_S32, MD5_T34);        HH (c, d, a, b, X[11], MD5_S33, MD5_T35);        HH (b, c, d, a, X[14], MD5_S34, MD5_T36);        HH (a, b, c, d, X[ 1], MD5_S31, MD5_T37);        HH (d, a, b, c, X[ 4], MD5_S32, MD5_T38);        HH (c, d, a, b, X[ 7], MD5_S33, MD5_T39);        HH (b, c, d, a, X[10], MD5_S34, MD5_T40);        HH (a, b, c, d, X[13], MD5_S31, MD5_T41);        HH (d, a, b, c, X[ 0], MD5_S32, MD5_T42);        HH (c, d, a, b, X[ 3], MD5_S33, MD5_T43);        HH (b, c, d, a, X[ 6], MD5_S34, MD5_T44);        HH (a, b, c, d, X[ 9], MD5_S31, MD5_T45);        HH (d, a, b, c, X[12], MD5_S32, MD5_T46);        HH (c, d, a, b, X[15], MD5_S33, MD5_T47);        HH (b, c, d, a, X[ 2], MD5_S34, MD5_T48);        //Round 4 Transformation        II (a, b, c, d, X[ 0], MD5_S41, MD5_T49);        II (d, a, b, c, X[ 7], MD5_S42, MD5_T50);        II (c, d, a, b, X[14], MD5_S43, MD5_T51);        II (b, c, d, a, X[ 5], MD5_S44, MD5_T52);        II (a, b, c, d, X[12], MD5_S41, MD5_T53);        II (d, a, b, c, X[ 3], MD5_S42, MD5_T54);        II (c, d, a, b, X[10], MD5_S43, MD5_T55);        II (b, c, d, a, X[ 1], MD5_S44, MD5_T56);        II (a, b, c, d, X[ 8], MD5_S41, MD5_T57);        II (d, a, b, c, X[15], MD5_S42, MD5_T58);        II (c, d, a, b, X[ 6], MD5_S43, MD5_T59);        II (b, c, d, a, X[13], MD5_S44, MD5_T60);        II (a, b, c, d, X[ 4], MD5_S41, MD5_T61);        II (d, a, b, c, X[11], MD5_S42, MD5_T62);        II (c, d, a, b, X[ 2], MD5_S43, MD5_T63);        II (b, c, d, a, X[ 9], MD5_S44, MD5_T64);        m_lMD5[0] += a;        m_lMD5[1] += b;        m_lMD5[2] += c;        m_lMD5[3] += d;}

static int  rmd128_compress(hash_state *md, unsigned char *buf)#endif{   ulong32 aa,bb,cc,dd,aaa,bbb,ccc,ddd,X[16];   int i;      /* load words X */   for (i = 0; i < 16; i++){      LOAD32L(X[i], buf + (4 * i));   }   /* load state */   aa = aaa = md->rmd128.state[0];   bb = bbb = md->rmd128.state[1];   cc = ccc = md->rmd128.state[2];   dd = ddd = md->rmd128.state[3];   /* round 1 */   FF(aa, bb, cc, dd, X[ 0], 11);   FF(dd, aa, bb, cc, X[ 1], 14);   FF(cc, dd, aa, bb, X[ 2], 15);   FF(bb, cc, dd, aa, X[ 3], 12);   FF(aa, bb, cc, dd, X[ 4],  5);   FF(dd, aa, bb, cc, X[ 5],  8);   FF(cc, dd, aa, bb, X[ 6],  7);   FF(bb, cc, dd, aa, X[ 7],  9);   FF(aa, bb, cc, dd, X[ 8], 11);   FF(dd, aa, bb, cc, X[ 9], 13);   FF(cc, dd, aa, bb, X[10], 14);   FF(bb, cc, dd, aa, X[11], 15);   FF(aa, bb, cc, dd, X[12],  6);   FF(dd, aa, bb, cc, X[13],  7);   FF(cc, dd, aa, bb, X[14],  9);   FF(bb, cc, dd, aa, X[15],  8);                                /* round 2 */   GG(aa, bb, cc, dd, X[ 7],  7);   GG(dd, aa, bb, cc, X[ 4],  6);   GG(cc, dd, aa, bb, X[13],  8);   GG(bb, cc, dd, aa, X[ 1], 13);   GG(aa, bb, cc, dd, X[10], 11);   GG(dd, aa, bb, cc, X[ 6],  9);   GG(cc, dd, aa, bb, X[15],  7);   GG(bb, cc, dd, aa, X[ 3], 15);   GG(aa, bb, cc, dd, X[12],  7);   GG(dd, aa, bb, cc, X[ 0], 12);   GG(cc, dd, aa, bb, X[ 9], 15);   GG(bb, cc, dd, aa, X[ 5],  9);   GG(aa, bb, cc, dd, X[ 2], 11);   GG(dd, aa, bb, cc, X[14],  7);   GG(cc, dd, aa, bb, X[11], 13);   GG(bb, cc, dd, aa, X[ 8], 12);   /* round 3 */   HH(aa, bb, cc, dd, X[ 3], 11);   HH(dd, aa, bb, cc, X[10], 13);   HH(cc, dd, aa, bb, X[14],  6);   HH(bb, cc, dd, aa, X[ 4],  7);   HH(aa, bb, cc, dd, X[ 9], 14);   HH(dd, aa, bb, cc, X[15],  9);   HH(cc, dd, aa, bb, X[ 8], 13);   HH(bb, cc, dd, aa, X[ 1], 15);   HH(aa, bb, cc, dd, X[ 2], 14);   HH(dd, aa, bb, cc, X[ 7],  8);   HH(cc, dd, aa, bb, X[ 0], 13);   HH(bb, cc, dd, aa, X[ 6],  6);   HH(aa, bb, cc, dd, X[13],  5);   HH(dd, aa, bb, cc, X[11], 12);   HH(cc, dd, aa, bb, X[ 5],  7);   HH(bb, cc, dd, aa, X[12],  5);   /* round 4 */   II(aa, bb, cc, dd, X[ 1], 11);   II(dd, aa, bb, cc, X[ 9], 12);   II(cc, dd, aa, bb, X[11], 14);   II(bb, cc, dd, aa, X[10], 15);   II(aa, bb, cc, dd, X[ 0], 14);   II(dd, aa, bb, cc, X[ 8], 15);   II(cc, dd, aa, bb, X[12],  9);   II(bb, cc, dd, aa, X[ 4],  8);   II(aa, bb, cc, dd, X[13],  9);   II(dd, aa, bb, cc, X[ 3], 14);   II(cc, dd, aa, bb, X[ 7],  5);   II(bb, cc, dd, aa, X[15],  6);   II(aa, bb, cc, dd, X[14],  8);   II(dd, aa, bb, cc, X[ 5],  6);   II(cc, dd, aa, bb, X[ 6],  5);   II(bb, cc, dd, aa, X[ 2], 12);   /* parallel round 1 */   III(aaa, bbb, ccc, ddd, X[ 5],  8);    III(ddd, aaa, bbb, ccc, X[14],  9);   III(ccc, ddd, aaa, bbb, X[ 7],  9);   III(bbb, ccc, ddd, aaa, X[ 0], 11);   III(aaa, bbb, ccc, ddd, X[ 9], 13);   III(ddd, aaa, bbb, ccc, X[ 2], 15);   III(ccc, ddd, aaa, bbb, X[11], 15);   III(bbb, ccc, ddd, aaa, X[ 4],  5);   III(aaa, bbb, ccc, ddd, X[13],  7);   III(ddd, aaa, bbb, ccc, X[ 6],  7);//.........这里部分代码省略.........

//对于每个block进行转换void MD5::encryptWithBlock(const uint8_t block[64]) {    	uint32_t a = state[0], b = state[1], c = state[2], d = state[3], x[16];    	decode(block, x, 64);    	/* Round 1 */	FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */	FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */	FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */	FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */	FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */	FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */	FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */	FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */	FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */	FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */	FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */	FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */	FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */	FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */	FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */	FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */    	/* Round 2 */	GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */	GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */	GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */	GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */	GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */	GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */	GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */	GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */	GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */	GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */	GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */	GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */	GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */	GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */	GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */	GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */    	/* Round 3 */	HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */	HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */	HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */	HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */	HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */	HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */	HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */	HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */	HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */	HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */	HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */	HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */	HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */	HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */	HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */	HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */    	/* Round 4 */	II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */	II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */	II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */	II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */	II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */	II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */	II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */	II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */	II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */	II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */	II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */	II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */	II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */	II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */	II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */	II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */    	state[0] += a;	state[1] += b;	state[2] += c;	state[3] += d;}