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

intget_nearest_monitor_rect( int  *x, int *y, int  *width, int  *height ){    SDL_SysWMinfo info;    Display*      display;    int           screen;    SDL_VERSION(&info.version);    if ( !SDL_GetWMInfo(&info) ) {        D( "%s: SDL_GetWMInfo() failed: %s", __FUNCTION__, SDL_GetError());        return -1;    }    if (x11_lib_init() < 0)        return -1;    display = info.info.x11.display;    screen  = FF(XDefaultScreen)(display);    *x      = 0;    *y      = 0;    *width  = FF(XDisplayWidth)(display, screen);    *height = FF(XDisplayHeight)(display, screen);    D("%s: found (x,y,w,h)=(%d,%d,%d,%d)", __FUNCTION__,      *x, *y, *width, *height);    return 0;}

/* common */static void *qpa_audio_init (void){    void*  result = NULL;    D("%s: entering", __FUNCTION__);    pa_lib = dlopen( "libpulse-simple.so", RTLD_NOW );    if (pa_lib == NULL)        pa_lib = dlopen( "libpulse-simple.so.0", RTLD_NOW );    if (pa_lib == NULL) {        D("could not find libpulse on this system/n");        goto Exit;    }    if (pa_dynlink_init(pa_lib) < 0)        goto Fail;    {        pa_sample_spec  ss;        int             error;        pa_simple*      simple;        ss.format   = PA_SAMPLE_U8;        ss.rate     = 44100;        ss.channels = 1;        /* try to open it for playback */        simple = FF(pa_simple_new) (            conf.server,            "qemu",            PA_STREAM_PLAYBACK,            conf.sink,            "pcm.playback",            &ss,            NULL,                   /* channel map */            NULL,                   /* buffering attributes */            &error            );        if (simple == NULL) {            D("%s: error opening open pulse audio library: %s",              __FUNCTION__, FF(pa_strerror)(error));            goto Fail;        }        FF(pa_simple_free)(simple);    }    result = &conf;    goto Exit;Fail:    D("%s: failed to open library/n", __FUNCTION__);    dlclose(pa_lib);Exit:    D("%s: exiting", __FUNCTION__);    return result;}

	void configure_filtergraph(		AVFilterGraph& graph, 		const std::string& filtergraph, 		AVFilterContext& source_ctx, 		AVFilterContext& sink_ctx)	{		AVFilterInOut* outputs = nullptr;		AVFilterInOut* inputs = nullptr;		try		{			if(!filtergraph.empty()) 			{				outputs = avfilter_inout_alloc();				inputs  = avfilter_inout_alloc();				CASPAR_VERIFY(outputs && inputs);				outputs->name       = av_strdup("in");				outputs->filter_ctx = &source_ctx;				outputs->pad_idx    = 0;				outputs->next       = nullptr;				inputs->name        = av_strdup("out");				inputs->filter_ctx  = &sink_ctx;				inputs->pad_idx     = 0;				inputs->next        = nullptr;				FF(avfilter_graph_parse(					&graph, 					filtergraph.c_str(), 					inputs,					outputs,					nullptr));			} 			else 			{				FF(avfilter_link(					&source_ctx, 					0, 					&sink_ctx, 					0));			}			FF(avfilter_graph_config(				&graph, 				nullptr));		}		catch(...)		{			avfilter_inout_free(&outputs);			avfilter_inout_free(&inputs);			throw;		}	}

static int qpa_init_in (HWVoiceIn *hw, struct audsettings *as){    int error;    static pa_sample_spec ss;    struct audsettings obt_as = *as;    PAVoiceIn *pa = (PAVoiceIn *) hw;    ss.format = audfmt_to_pa (as->fmt, as->endianness);    ss.channels = as->nchannels;    ss.rate = as->freq;    obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness);    pa->s = FF(pa_simple_new) (        conf.server,        "qemu",        PA_STREAM_RECORD,        conf.source,        "pcm.capture",        &ss,        NULL,                   /* channel map */        NULL,                   /* buffering attributes */        &error        );    if (!pa->s) {        qpa_logerr (error, "pa_simple_new for capture failed/n");        goto fail1;    }    audio_pcm_init_info (&hw->info, &obt_as);    hw->samples = conf.samples;    pa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);    if (!pa->pcm_buf) {        dolog ("Could not allocate buffer (%d bytes)/n",               hw->samples << hw->info.shift);        goto fail2;    }    if (audio_pt_init (&pa->pt, qpa_thread_in, hw, AUDIO_CAP, AUDIO_FUNC)) {        goto fail3;    }    return 0; fail3:    qemu_free (pa->pcm_buf);    pa->pcm_buf = NULL; fail2:    FF(pa_simple_free) (pa->s);    pa->s = NULL; fail1:    return -1;}

void		re_init_frac(t_mlx *f){	FF(coef) = 0.78;	FF(zoom) = 0;	FF(r) = 5;	FF(g) = 10;	FF(b) = 5;	if (ft_strcmp(f->name, "Mandelbrot") == 0)		ini_mandelbrot(f);	else if (ft_strcmp(f->name, "Julia") == 0)		ini_julia(f);	else if (ft_strcmp(f->name, "Burning-Ship") == 0)		ini_burning(f);}

intget_monitor_resolution( int  *px_dpi, int  *py_dpi ){    SDL_SysWMinfo info;    Display*      display;    int           screen;    int           width, width_mm, height, height_mm, xdpi, ydpi;    SDL_VERSION(&info.version);    if ( !SDL_GetWMInfo(&info) ) {        D( "%s: SDL_GetWMInfo() failed: %s", __FUNCTION__, SDL_GetError());        return -1;    }    if (x11_lib_init() < 0)        return -1;    display = info.info.x11.display;    screen  = FF(XDefaultScreen)(display);    width     = FF(XDisplayWidth)(display, screen);    width_mm  = FF(XDisplayWidthMM)(display, screen);    height    = FF(XDisplayHeight)(display, screen);    height_mm = FF(XDisplayHeightMM)(display, screen);    if (width_mm <= 0 || height_mm <= 0) {        D( "%s: bad screen dimensions: width_mm = %d, height_mm = %d",                __FUNCTION__, width_mm, height_mm);        return -1;    }    D( "%s: found screen width=%d height=%d width_mm=%d height_mm=%d",            __FUNCTION__, width, height, width_mm, height_mm );    xdpi = width  * MM_PER_INCH / width_mm;    ydpi = height * MM_PER_INCH / height_mm;    if (xdpi < 20 || xdpi > 400 || ydpi < 20 || ydpi > 400) {        D( "%s: bad resolution: xpi=%d ydpi=%d", __FUNCTION__,                xdpi, ydpi );        return -1;    }    *px_dpi = xdpi;    *py_dpi = ydpi;    return 0;}

void		init_env(t_mlx *f){	f->wid = WID;	f->hig = HIG;	FF(r) = 5;	FF(g) = 10;	FF(b) = 5;	FF(zoom) = 0;	f->crt_img = 0;	FF(julia) = 1;	f->motion = 0;	f->mlx = mlx_init();	f->win = mlx_new_window(f->mlx, f->wid, f->hig, f->name);	ini_img(f);}

void TFfGGen::GenFFGraphs(const double& FProb, const double& BProb, const TStr& FNm) {	const int NRuns = 10;	const int NNodes = 10000;	TGStat::NDiamRuns = 10;	//const double FProb = 0.35, BProb = 0.20;  // ff1	//const double FProb = 0.37, BProb = 0.32;  // ff2	//const double FProb = 0.37, BProb = 0.325; // ff22	//const double FProb = 0.37, BProb = 0.33;  // ff3	//const double FProb = 0.37, BProb = 0.35;  // ff4	//const double FProb = 0.38, BProb = 0.35;  // ff5	TVec<PGStatVec> GAtTmV;	TFfGGen FF(false, 1, FProb, BProb, 1.0, 0, 0);	for (int r = 0; r < NRuns; r++) {		PGStatVec GV = TGStatVec::New(tmuNodes, TGStat::AllStat());		FF.GenGraph(NNodes, GV, true);		for (int i = 0; i < GV->Len(); i++) {			if (i == GAtTmV.Len()) {				GAtTmV.Add(TGStatVec::New(tmuNodes, TGStat::AllStat()));			}			GAtTmV[i]->Add(GV->At(i));		}		IAssert(GAtTmV.Len() == GV->Len());	}	PGStatVec AvgStat = TGStatVec::New(tmuNodes, TGStat::AllStat());	for (int i = 0; i < GAtTmV.Len(); i++) {		AvgStat->Add(GAtTmV[i]->GetAvgGStat(false));	}	AvgStat->PlotAllVsX(gsvNodes, FNm, TStr::Fmt("Forest Fire: F:%g  B:%g (%d runs)", FProb, BProb, NRuns));	AvgStat->Last()->PlotAll(FNm, TStr::Fmt("Forest Fire: F:%g  B:%g (%d runs)", FProb, BProb, NRuns));}

void load_calibration_file(int N) {	QString path=QString("%1/isosplit_calibration_%2.txt").arg(s_calibration_dir).arg(N);	QFile FF(path);	if (FF.open(QFile::ReadOnly|QFile::Text)) {		QString txt=QString(FF.readAll());		FF.close();		QList<QString> lines=txt.split("/n");		if (lines.count()>10) {			calibration_file CF;			CF.curve_len=lines[0].toInt();			CF.num_trials=lines[1].toInt();			for (int j=0; j<CF.curve_len; j++) {				QString line=lines.value(2+j);				QList<QString> tmp=line.split(",");				if (tmp.count()!=2) return;				CF.avg << tmp.value(0).toDouble();				CF.stdev << tmp.value(1).toDouble();			}			for (int j=0; j<CF.num_trials; j++) {				QString line=lines.value(2+CF.curve_len+j);				CF.scores << line.toDouble();			}			s_calibration_files[N]=CF;		}		else return;	}}

/* common */static void *qesd_audio_init (void){    void*    result = NULL;    D("%s: entering", __FUNCTION__);    if (esd_lib == NULL) {        int  fd;        esd_lib = dlopen( "libesd.so", RTLD_NOW );        if (esd_lib == NULL)            esd_lib = dlopen( "libesd.so.0", RTLD_NOW );        if (esd_lib == NULL) {            D("could not find libesd on this system");            goto Exit;        }        if (esd_dynlink_init(esd_lib) < 0)            goto Fail;        fd = FF(esd_open_sound)(conf.dac_host);        if (fd < 0) {            D("%s: could not open direct sound server connection, trying localhost",              __FUNCTION__);            fd = FF(esd_open_sound)("localhost");            if (fd < 0) {                D("%s: could not open localhost sound server connection", __FUNCTION__);                goto Fail;            }        }        D("%s: EsounD server connection succeeded", __FUNCTION__);        /* FF(esd_close)(fd); */    }    result = &conf;    goto Exit;Fail:    D("%s: failed to open library", __FUNCTION__);    dlclose(esd_lib);    esd_lib = NULL;Exit:    return  result;}

QString read_text_file(QString path) {	QFile FF(path);	if (!FF.open(QFile::Text|QFile::ReadOnly)) {		return "";	}	QString ret=QString(FF.readAll());	FF.close();	return ret;}

	void push(const std::shared_ptr<AVFrame>& frame)	{				if (fast_path())			fast_path_.push(frame);		else			FF(av_buffersrc_add_frame(				video_graph_in_, 				frame.get()));	}

int main(){#ifndef ONLINE_JUDGE    freopen("in.txt","r",stdin);//    freopen("textout.txt", "w", stdout);#endif    while(scanf("%d %d",&n,&m)!=EOF){        int num11=0,num10=0,num01=0,num00=0;        for(i=0;i<n;i++)            for(j=0;j<m;j++){                scanf("%s",f[i][j].a);                if(f[i][j].a[0]=='1' && f[i][j].a[1]=='1') num11++;                else if(f[i][j].a[0]=='1' && f[i][j].a[1]=='0') num10++;                else if(f[i][j].a[0]=='0' && f[i][j].a[1]=='1') num01++;                else num00++;            }        i=1;j=1;flag=1;        FF(num11,"11");        //FF(num10,i,j,flag,"10");        //FF(num01,i,j,flag,"01");        int ii,jj;num10=num10+num01;        char aa[3]="10",bb[3]="01";        ii=i;jj=j;        while(num10--){            if(num10==-1) break;            if(ii==1 || f[ii-1][jj].a[0]=='0' ||(f[ii-1][jj].a[0]=='1' && f[ii-1][jj].a[1]=='1') )                strcpy(f[ii][jj].a,aa);            else strcpy(f[ii][jj].a,bb);            if(flag==1){                jj++;                if(jj==(m+1)){ii++;jj=m;flag=2;}            }            else{                jj--;                if(jj==0){ii++;jj=1;flag=1;}            }        }        i=ii;j=jj;        FF(num00,"00");        Print();    }    return 0;}

static void GCC_FMT_ATTR (2, 3) qpa_logerr (int err, const char *fmt, ...){    va_list ap;    va_start (ap, fmt);    AUD_vlog (AUDIO_CAP, fmt, ap);    va_end (ap);    AUD_log (AUDIO_CAP, "Reason: %s/n", FF(pa_strerror) (err));}

void FF(int i,int j){	int k;	for(k=0;k<4;k++)		if( !(map[i][j] & wall[k]) && !room[i+dir[k][0]][j+dir[k][1]]){			room[i+dir[k][0]][j+dir[k][1]]=num;			count[num]++;			FF(i+dir[k][0],j+dir[k][1]);		}}

int FAR_FileRead(farfile_t hFile, void* buffer, int size){	FARfileobj_t* pFile = FF(hFile);	int* pPos = &pFile->pos;	FAR_RawSeek(pFile->a, pFile->base + *pPos, SEEK_SET);	int diff = pFile->size - *pPos;	if (size > diff) size = diff;	int rc = FAR_RawRead(pFile->a, buffer, size);	*pPos += rc;	return rc;}

std::shared_ptr<AVFrame> make_av_audio_frame(const core::const_frame& frame, const core::video_format_desc& format_desc){    auto av_frame = alloc_frame();    const auto& buffer = frame.audio_data();    // TODO (fix) Use sample_format_desc.    av_frame->channels       = format_desc.audio_channels;    av_frame->channel_layout = av_get_default_channel_layout(av_frame->channels);    av_frame->sample_rate    = format_desc.audio_sample_rate;    av_frame->format         = AV_SAMPLE_FMT_S32;    av_frame->nb_samples     = static_cast<int>(buffer.size() / av_frame->channels);    FF(av_frame_get_buffer(av_frame.get(), 32));    std::memcpy(av_frame->data[0], buffer.data(), buffer.size() * sizeof(buffer.data()[0]));    return av_frame;}

void onEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t *data, size_t len){  static String tmps = "";  if(type == WS_EVT_CONNECT){    //client connected    DEBUG_MSG_OPAQWEBSOCKET(FF("ws[%s][%u] connect/n"), server->url(), client->id());    //client->printf("Hello Client %u :)", client->id());    client->ping();  } else if(type == WS_EVT_DISCONNECT){    //client disconnected    DEBUG_MSG_OPAQWEBSOCKET(FF("ws[%s][%u] disconnect: %u/n"), server->url(), client->id());  } else if(type == WS_EVT_ERROR){    //error was received from the other end    DEBUG_MSG_OPAQWEBSOCKET(FF("ws[%s][%u] error(%u): %s/n"), server->url(), client->id(), *((uint16_t*)arg), (char*)data);  } else if(type == WS_EVT_PONG){    //pong message was received (in response to a ping request maybe)    DEBUG_MSG_OPAQWEBSOCKET(FF("ws[%s][%u] pong[%u]: %s/n"), server->url(), client->id(), len, (len)?(char*)data:"");  } else if(type == WS_EVT_DATA){    //data packet    AwsFrameInfo * info = (AwsFrameInfo*)arg;    if(info->final && info->index == 0 && info->len == len){      //the whole message is in a single frame and we got all of it's data      DEBUG_MSG_OPAQWEBSOCKET(FF("ws[%s][%u] %s-message[%llu]: "), server->url(), client->id(), (info->opcode == WS_TEXT)?"text":"binary", info->len);      if(info->opcode == WS_TEXT){        data[len] = 0;        DEBUG_MSG_OPAQWEBSOCKET(FF("%s/n"), (char*)data);        parseTextMessage(client, data, len);              } else {        for(size_t i=0; i < info->len; i++){          DEBUG_MSG_OPAQWEBSOCKET(FF("%02x "), data[i]);        }        DEBUG_MSG_OPAQWEBSOCKET(FF("/n"));      }          } else {      //message is comprised of multiple frames or the frame is split into multiple packets      if(info->index == 0){

static void qpa_fini_in (HWVoiceIn *hw){    void *ret;    PAVoiceIn *pa = (PAVoiceIn *) hw;    audio_pt_lock (&pa->pt, AUDIO_FUNC);    pa->done = 1;    audio_pt_unlock_and_signal (&pa->pt, AUDIO_FUNC);    audio_pt_join (&pa->pt, &ret, AUDIO_FUNC);    if (pa->s) {        FF(pa_simple_free) (pa->s);        pa->s = NULL;    }    audio_pt_fini (&pa->pt, AUDIO_FUNC);    qemu_free (pa->pcm_buf);    pa->pcm_buf = NULL;}

int main(){	FILE *fin,*fout;	int M,N;	int i,j,x,y;	char d;	int ans=0,big=0;	fin = fopen("castle.in","r");	fout = fopen("castle.out","w");	fscanf(fin,"%d%d",&M,&N);	for(i=0;i<N;i++)		for(j=0;j<M;j++)			fscanf(fin,"%d",&map[i][j]);	memset(room,0,sizeof(room));	memset(count,0,sizeof(count));	for(i=0;i<N;i++)		for(j=0;j<M;j++)			if(!room[i][j]){				num++;				room[i][j]=num;				count[num]++;				FF(i,j);				if(count[num]>big)					big=count[num];			}	for(i=0;i<M;i++)		for(j=N-1;j>=0;j--){			if(j!=0 && (room[j][i] != room[j-1][i]) && (count[room[j][i]]+count[room[j-1][i]] >ans)){				ans=count[room[j][i]]+count[room[j-1][i]];				x=j,y=i;				d='N';			}			if(i!=M-1 && (room[j][i] != room[j][i+1]) && (count[room[j][i]]+count[room[j][i+1]] >ans)){				ans = count[room[j][i]] + count[room[j][i+1]];					x=j,y=i;				d='E';			}		}	fprintf(fout,"%d/n%d/n%d/n",num,big,ans);	fprintf(fout,"%d %d %c/n",x+1,y+1,d);	return 0;}

int FAR_FileSeek(farfile_t hFile, int pos, int mode){	FARfileobj_t* pFile = FF(hFile);	int size = pFile->size;	switch (mode)	{		case SEEK_SET:			break;		case SEEK_CUR:			pos += pFile->pos;			break;		case SEEK_END:			pos += pFile->size;			break;	}	if (pos > size) pos = size;	if (pos < 0) pos = 0;	pFile->pos = pos;	return pos;}

QString compute_the_file_hash(const QString& path, int num_bytes){    // Do not printf here!    QCryptographicHash hash(QCryptographicHash::Sha1);    QFile FF(path);    if (!FF.open(QFile::ReadOnly))        return "";    int num_bytes_processed = 0;    while ((!FF.atEnd()) && ((num_bytes == 0) || (num_bytes_processed < num_bytes))) {        QByteArray tmp = FF.read(10000);        if (num_bytes != 0) {            if (num_bytes_processed + tmp.count() > num_bytes) {                tmp = tmp.mid(0, num_bytes - num_bytes_processed);            }        }        hash.addData(tmp);        num_bytes_processed += tmp.count();    }    QString ret = QString(hash.result().toHex());    return ret;}

int main(int argc, char* argv[]) {  printf("ForestFire. build: %s, %s. Start time: %s/n/n", __TIME__, __DATE__, TExeTm::GetCurTm());  Env = TEnv(argc, argv, TNotify::StdNotify);  Env.PrepArgs("Forest Fire");  TExeTm ExeTm;  Try  const TStr OutFNm = Env.GetIfArgPrefixStr("-o:", "graph.txt", "Output graph file name");  const int NNodes = Env.GetIfArgPrefixInt("-n:", 10000, "Number of nodes (size of the generated graph)");  const double FwdProb = Env.GetIfArgPrefixFlt("-f:", 0.35, "Forward burning probability");  const double BckProb = Env.GetIfArgPrefixFlt("-b:", 0.32, "Backward burning probability");  const int StartNodes = Env.GetIfArgPrefixInt("-s:", 1, "Start graph with S isolated nodes");  const double Take2AmbProb = Env.GetIfArgPrefixFlt("-a:", 0.0, "Probability of a new node choosing 2 ambassadors");  const double OrphanProb = Env.GetIfArgPrefixFlt("-op:", 0.0, "Probability of a new node being an orphan (node with zero out-degree)");  // generate forest fire graph  TFfGGen::TimeLimitSec = -1;  TFfGGen FF(false, StartNodes, FwdProb, BckProb, 1.0, Take2AmbProb, OrphanProb);  FF.GenGraph(NNodes, false);  TSnap::SaveEdgeList(FF.GetGraph(), OutFNm, FF.GetParamStr());  Catch  printf("/nrun time: %s (%s)/n", ExeTm.GetTmStr(), TSecTm::GetCurTm().GetTmStr().CStr());  return 0;}

void		display(t_mlx *f){	mlx_string_put(f->mlx, f->win, 5, 1, BLANC, "Fractal :");	mlx_string_put(f->mlx, f->win, 100, 1, BLANC, f->name);	if (ft_strcmp(f->name, "Julia") == 0)		mlx_string_put(f->mlx, f->win, 160, 1, BLANC, ft_itoa(FF(julia)));	mlx_string_put(f->mlx, f->win, 5, 26, BLANC, "Iterate (</>):");	mlx_string_put(f->mlx, f->win, 160, 26, BLANC, ft_itoa(FF(it)));	mlx_string_put(f->mlx, f->win, 5, 46, BLANC, "Zoom (-/+):");	mlx_string_put(f->mlx, f->win, 130, 46, BLANC, ft_itoa(FF(zoom)));	mlx_string_put(f->mlx, f->win, 5, 66, BLANC, "Rouge (E-/R+):");	mlx_string_put(f->mlx, f->win, 160, 66, BLANC, ft_itoa(FF(r)));	mlx_string_put(f->mlx, f->win, 5, 86, BLANC, "Vert (F-/G+):");	mlx_string_put(f->mlx, f->win, 160, 86, BLANC, ft_itoa(FF(g)));	mlx_string_put(f->mlx, f->win, 5, 106, BLANC, "Bleu (V-/B+):");	mlx_string_put(f->mlx, f->win, 160, 106, BLANC, ft_itoa(FF(b)));}

void TNetInfBs::GenerateGroundTruth(const int& TNetwork, const int& NNodes, const int& NEdges, const TStr& NetworkParams) {	  TKronMtx SeedMtx;	  TStr MtxNm;	  switch (TNetwork) {	  // 2-dimension kronecker network	  case 0:		  printf("Kronecker graph for Ground Truth/n");		  SeedMtx = TKronMtx::GetMtx(NetworkParams.CStr()); // 0.5,0.5,0.5,0.5		  printf("/n*** Seed matrix:/n");		  SeedMtx.Dump();		  GroundTruth = TKronMtx::GenFastKronecker(SeedMtx, (int)TMath::Log2(NNodes), NEdges, true, 0);		  break;	  // forest fire network	  case 1:		  printf("Forest Fire graph for Ground Truth/n");		  TStrV NetworkParamsV; NetworkParams.SplitOnAllCh(';', NetworkParamsV);		  TFfGGen FF(true, // BurnExpFireP					 NetworkParamsV[0].GetInt(), // StartNNodes (1)					 NetworkParamsV[1].GetFlt(), // ForwBurnProb (0.2)					 NetworkParamsV[2].GetFlt(), // BackBurnProb (0.17)					 NetworkParamsV[3].GetInt(), // DecayProb (1)					 NetworkParamsV[4].GetInt(), // Take2AmbasPrb (0)					 NetworkParamsV[5].GetInt()); // OrphanPrb (0)		  FF.GenGraph(NNodes, false);		  GroundTruth = FF.GetGraph();		  break;	  }}

static int  md4_compress(hash_state *md, unsigned char *buf)#endif{    ulong32 x[16], a, b, c, d;    int i;    /* copy state */    a = md->md4.state[0];    b = md->md4.state[1];    c = md->md4.state[2];    d = md->md4.state[3];    /* copy the state into 512-bits into W[0..15] */    for (i = 0; i < 16; i++) {        LOAD32L(x[i], buf + (4*i));    }    /* Round 1 */    FF (a, b, c, d, x[ 0], S11); /* 1 */    FF (d, a, b, c, x[ 1], S12); /* 2 */    FF (c, d, a, b, x[ 2], S13); /* 3 */    FF (b, c, d, a, x[ 3], S14); /* 4 */    FF (a, b, c, d, x[ 4], S11); /* 5 */    FF (d, a, b, c, x[ 5], S12); /* 6 */    FF (c, d, a, b, x[ 6], S13); /* 7 */    FF (b, c, d, a, x[ 7], S14); /* 8 */    FF (a, b, c, d, x[ 8], S11); /* 9 */    FF (d, a, b, c, x[ 9], S12); /* 10 */    FF (c, d, a, b, x[10], S13); /* 11 */    FF (b, c, d, a, x[11], S14); /* 12 */    FF (a, b, c, d, x[12], S11); /* 13 */    FF (d, a, b, c, x[13], S12); /* 14 */    FF (c, d, a, b, x[14], S13); /* 15 */    FF (b, c, d, a, x[15], S14); /* 16 */    /* Round 2 */    GG (a, b, c, d, x[ 0], S21); /* 17 */    GG (d, a, b, c, x[ 4], S22); /* 18 */    GG (c, d, a, b, x[ 8], S23); /* 19 */    GG (b, c, d, a, x[12], S24); /* 20 */    GG (a, b, c, d, x[ 1], S21); /* 21 */    GG (d, a, b, c, x[ 5], S22); /* 22 */    GG (c, d, a, b, x[ 9], S23); /* 23 */    GG (b, c, d, a, x[13], S24); /* 24 */    GG (a, b, c, d, x[ 2], S21); /* 25 */    GG (d, a, b, c, x[ 6], S22); /* 26 */    GG (c, d, a, b, x[10], S23); /* 27 */    GG (b, c, d, a, x[14], S24); /* 28 */    GG (a, b, c, d, x[ 3], S21); /* 29 */    GG (d, a, b, c, x[ 7], S22); /* 30 */    GG (c, d, a, b, x[11], S23); /* 31 */    GG (b, c, d, a, x[15], S24); /* 32 */    /* Round 3 */    HH (a, b, c, d, x[ 0], S31); /* 33 */    HH (d, a, b, c, x[ 8], S32); /* 34 */    HH (c, d, a, b, x[ 4], S33); /* 35 */    HH (b, c, d, a, x[12], S34); /* 36 */    HH (a, b, c, d, x[ 2], S31); /* 37 */    HH (d, a, b, c, x[10], S32); /* 38 */    HH (c, d, a, b, x[ 6], S33); /* 39 */    HH (b, c, d, a, x[14], S34); /* 40 */    HH (a, b, c, d, x[ 1], S31); /* 41 */    HH (d, a, b, c, x[ 9], S32); /* 42 */    HH (c, d, a, b, x[ 5], S33); /* 43 */    HH (b, c, d, a, x[13], S34); /* 44 */    HH (a, b, c, d, x[ 3], S31); /* 45 */    HH (d, a, b, c, x[11], S32); /* 46 */    HH (c, d, a, b, x[ 7], S33); /* 47 */    HH (b, c, d, a, x[15], S34); /* 48 */    /* Update our state */    md->md4.state[0] = md->md4.state[0] + a;    md->md4.state[1] = md->md4.state[1] + b;    md->md4.state[2] = md->md4.state[2] + c;    md->md4.state[3] = md->md4.state[3] + d;    return CRYPT_OK;}

gmx_bool parse_common_args(int *argc, char *argv[], unsigned long Flags,                           int nfile, t_filenm fnm[], int npargs, t_pargs *pa,                           int ndesc, const char **desc,                           int nbugs, const char **bugs,                           gmx_output_env_t **oenv){    /* This array should match the order of the enum in oenv.h */    const char *const xvg_formats[] = { "xmgrace", "xmgr", "none" };    // Handle the flags argument, which is a bit field    // The FF macro returns whether or not the bit is set#define FF(arg) ((Flags & arg) == arg)    try    {        double                          tbegin        = 0.0, tend = 0.0, tdelta = 0.0;        bool                            bBeginTimeSet = false, bEndTimeSet = false, bDtSet = false;        bool                            bView         = false;        int                             xvgFormat     = 0;        gmx::OptionsAdapter             adapter(*argc, argv);        gmx::Options                    options(NULL, NULL);        gmx::OptionsBehaviorCollection  behaviors(&options);        gmx::FileNameOptionManager      fileOptManager;        fileOptManager.disableInputOptionChecking(                FF(PCA_NOT_READ_NODE) || FF(PCA_DISABLE_INPUT_FILE_CHECKING));        options.addManager(&fileOptManager);        if (FF(PCA_CAN_SET_DEFFNM))        {            fileOptManager.addDefaultFileNameOption(&options, "deffnm");        }        if (FF(PCA_CAN_BEGIN))        {            options.addOption(                    gmx::DoubleOption("b")                        .store(&tbegin).storeIsSet(&bBeginTimeSet).timeValue()                        .description("First frame (%t) to read from trajectory"));        }        if (FF(PCA_CAN_END))        {            options.addOption(                    gmx::DoubleOption("e")                        .store(&tend).storeIsSet(&bEndTimeSet).timeValue()                        .description("Last frame (%t) to read from trajectory"));        }        if (FF(PCA_CAN_DT))        {            options.addOption(                    gmx::DoubleOption("dt")                        .store(&tdelta).storeIsSet(&bDtSet).timeValue()                        .description("Only use frame when t MOD dt = first time (%t)"));        }        gmx::TimeUnit  timeUnit = gmx::TimeUnit_Default;        if (FF(PCA_TIME_UNIT))        {            std::shared_ptr<gmx::TimeUnitBehavior> timeUnitBehavior(                    new gmx::TimeUnitBehavior());            timeUnitBehavior->setTimeUnitStore(&timeUnit);            timeUnitBehavior->setTimeUnitFromEnvironment();            timeUnitBehavior->addTimeUnitOption(&options, "tu");            behaviors.addBehavior(timeUnitBehavior);        }        if (FF(PCA_CAN_VIEW))        {            options.addOption(                    gmx::BooleanOption("w").store(&bView)                        .description("View output [REF].xvg[ref], [REF].xpm[ref], "                                     "[REF].eps[ref] and [REF].pdb[ref] files"));        }        bool bXvgr = false;        for (int i = 0; i < nfile; i++)        {            bXvgr = bXvgr || (fnm[i].ftp == efXVG);        }        xvgFormat = gmx::getDefaultXvgFormat(xvg_formats);        if (bXvgr)        {            options.addOption(                    gmx::EnumIntOption("xvg").enumValue(xvg_formats)                        .store(&xvgFormat)                        .description("xvg plot formatting"));        }        /* Now append the program specific arguments */        for (int i = 0; i < nfile; i++)        {            adapter.filenmToOptions(&options, &fnm[i]);        }        for (int i = 0; i < npargs; i++)        {            adapter.pargsToOptions(&options, &pa[i]);        }        const gmx::CommandLineHelpContext *context =            gmx::GlobalCommandLineHelpContext::get();        if (context != NULL)        {            GMX_RELEASE_ASSERT(gmx_node_rank() == 0,//.........这里部分代码省略.........

void md4_process_block(uint32_t state[4], const uint32_t block[MD4_BLOCK_SIZE / 4]){    unsigned a, b, c, d;    a = state[0];    b = state[1];    c = state[2];    d = state[3];    FF(a, b, c, d, block[0], 3);   /* 1 */    FF(d, a, b, c, block[1], 7);   /* 2 */    FF(c, d, a, b, block[2], 11);  /* 3 */    FF(b, c, d, a, block[3], 19);  /* 4 */    FF(a, b, c, d, block[4], 3);   /* 5 */    FF(d, a, b, c, block[5], 7);   /* 6 */    FF(c, d, a, b, block[6], 11);  /* 7 */    FF(b, c, d, a, block[7], 19);  /* 8 */    FF(a, b, c, d, block[8], 3);   /* 9 */    FF(d, a, b, c, block[9], 7);   /* 10 */    FF(c, d, a, b, block[10], 11); /* 11 */    FF(b, c, d, a, block[11], 19); /* 12 */    FF(a, b, c, d, block[12], 3);  /* 13 */    FF(d, a, b, c, block[13], 7);  /* 14 */    FF(c, d, a, b, block[14], 11); /* 15 */    FF(b, c, d, a, block[15], 19); /* 16 */    GG(a, b, c, d, block[0], 3);   /* 17 */    GG(d, a, b, c, block[4], 5);   /* 18 */    GG(c, d, a, b, block[8], 9);   /* 19 */    GG(b, c, d, a, block[12], 13); /* 20 */    GG(a, b, c, d, block[1], 3);   /* 21 */    GG(d, a, b, c, block[5], 5);   /* 22 */    GG(c, d, a, b, block[9], 9);   /* 23 */    GG(b, c, d, a, block[13], 13); /* 24 */    GG(a, b, c, d, block[2], 3);   /* 25 */    GG(d, a, b, c, block[6], 5);   /* 26 */    GG(c, d, a, b, block[10], 9);  /* 27 */    GG(b, c, d, a, block[14], 13); /* 28 */    GG(a, b, c, d, block[3], 3);   /* 29 */    GG(d, a, b, c, block[7], 5);   /* 30 */    GG(c, d, a, b, block[11], 9);  /* 31 */    GG(b, c, d, a, block[15], 13); /* 32 */    HH(a, b, c, d, block[0], 3);   /* 33 */    HH(d, a, b, c, block[8], 9);   /* 34 */    HH(c, d, a, b, block[4], 11);  /* 35 */    HH(b, c, d, a, block[12], 15); /* 36 */    HH(a, b, c, d, block[2], 3);   /* 37 */    HH(d, a, b, c, block[10], 9);  /* 38 */    HH(c, d, a, b, block[6], 11);  /* 39 */    HH(b, c, d, a, block[14], 15); /* 40 */    HH(a, b, c, d, block[1], 3);   /* 41 */    HH(d, a, b, c, block[9], 9);   /* 42 */    HH(c, d, a, b, block[5], 11);  /* 43 */    HH(b, c, d, a, block[13], 15); /* 44 */    HH(a, b, c, d, block[3], 3);   /* 45 */    HH(d, a, b, c, block[11], 9);  /* 46 */    HH(c, d, a, b, block[7], 11);  /* 47 */    HH(b, c, d, a, block[15], 15); /* 48 */    state[0] += a;    state[1] += b;    state[2] += c;    state[3] += d;}

/** 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();      }   }