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

/* forward octave */static inline void W(u32 *key, unsigned int i) {	u32 I;	key[6] ^= F1(key[7], Tr[i % 4][0], Tm[i][0]);	key[5] ^= F2(key[6], Tr[i % 4][1], Tm[i][1]);	key[4] ^= F3(key[5], Tr[i % 4][2], Tm[i][2]);	key[3] ^= F1(key[4], Tr[i % 4][3], Tm[i][3]);	key[2] ^= F2(key[3], Tr[i % 4][4], Tm[i][4]);	key[1] ^= F3(key[2], Tr[i % 4][5], Tm[i][5]);	key[0] ^= F1(key[1], Tr[i % 4][6], Tm[i][6]);		key[7] ^= F2(key[0], Tr[i % 4][7], Tm[i][7]);}

static void cast5_encrypt(struct crypto_tfm *tfm, u8 *outbuf, const u8 *inbuf){	struct cast5_ctx *c = crypto_tfm_ctx(tfm);	const __be32 *src = (const __be32 *)inbuf;	__be32 *dst = (__be32 *)outbuf;	u32 l, r, t;	u32 I;			/* used by the Fx macros */	u32 *Km;	u8 *Kr;	Km = c->Km;	Kr = c->Kr;	/* (L0,R0) <-- (m1...m64).  (Split the plaintext into left and	 * right 32-bit halves L0 = m1...m32 and R0 = m33...m64.)	 */	l = be32_to_cpu(src[0]);	r = be32_to_cpu(src[1]);	/* (16 rounds) for i from 1 to 16, compute Li and Ri as follows:	 *  Li = Ri-1;	 *  Ri = Li-1 ^ f(Ri-1,Kmi,Kri), where f is defined in Section 2.2	 * Rounds 1, 4, 7, 10, 13, and 16 use f function Type 1.	 * Rounds 2, 5, 8, 11, and 14 use f function Type 2.	 * Rounds 3, 6, 9, 12, and 15 use f function Type 3.	 */	t = l; l = r; r = t ^ F1(r, Km[0], Kr[0]);	t = l; l = r; r = t ^ F2(r, Km[1], Kr[1]);	t = l; l = r; r = t ^ F3(r, Km[2], Kr[2]);	t = l; l = r; r = t ^ F1(r, Km[3], Kr[3]);	t = l; l = r; r = t ^ F2(r, Km[4], Kr[4]);	t = l; l = r; r = t ^ F3(r, Km[5], Kr[5]);	t = l; l = r; r = t ^ F1(r, Km[6], Kr[6]);	t = l; l = r; r = t ^ F2(r, Km[7], Kr[7]);	t = l; l = r; r = t ^ F3(r, Km[8], Kr[8]);	t = l; l = r; r = t ^ F1(r, Km[9], Kr[9]);	t = l; l = r; r = t ^ F2(r, Km[10], Kr[10]);	t = l; l = r; r = t ^ F3(r, Km[11], Kr[11]);	if (!(c->rr)) {		t = l; l = r; r = t ^ F1(r, Km[12], Kr[12]);		t = l; l = r; r = t ^ F2(r, Km[13], Kr[13]);		t = l; l = r; r = t ^ F3(r, Km[14], Kr[14]);		t = l; l = r; r = t ^ F1(r, Km[15], Kr[15]);	}	/* c1...c64 <-- (R16,L16).  (Exchange final blocks L16, R16 and	 *  concatenate to form the ciphertext.) */	dst[0] = cpu_to_be32(r);	dst[1] = cpu_to_be32(l);}

void ChannelSelector::setCubiePower(bool mode){  if (mode == false) {      digitalWrite(PIN_CUBIEPOWER, LOW);      GLOBALS.cubie_power_enabled = false;      MDISPLAY.showMessage(F2("Power Off"));  }  else {      digitalWrite(PIN_CUBIEPOWER, HIGH);      GLOBALS.cubie_power_enabled = true;      MDISPLAY.showMessage(F2("Power On"));  }}

voidq_promote(    q_expr e){    q_expr leftTerm, rightTerm;    q_expr newTerm;    assert(e != NULL);    assert(e->kind == T_FNC);    assert(e->info.function->tag == Q_EXPR_AND);    leftTerm = q_leftPar(e);    rightTerm = q_rightPar(e);    q_disjunctify(leftTerm);    q_disjunctify(rightTerm);    if (q_isFnc(leftTerm,Q_EXPR_OR)) {        /* e = (A or B) and C ====> e = A and C or B and C */        newTerm = F2(Q_EXPR_AND,q_rightPar(leftTerm),q_exprCopy(rightTerm));        /* e = (A or B) and C; newTerm = B and C */q_promote(newTerm);        q_swapRight(leftTerm,q_swapRight(e,newTerm));        /* e = (A or C) and (B and C); */        q_setTag(leftTerm,Q_EXPR_AND);        /* e = (A and C) and (B and C); */q_promote(leftTerm);        q_setTag(e,Q_EXPR_OR);        /* e = (A and C) or (B and C); */        if (q_isFnc(rightTerm,Q_EXPR_OR)) {            /* e = (A and (C or D)) or (B and (C or D)); */            q_promote(leftTerm);            /* e = (A and C) or (A and D)) or (B and (C or D)); */            q_promote(newTerm);            /* e = ((A and C) or (A and D)) or ((B and C) or (A and D)); */        }    } else {    	if (q_isFnc(rightTerm,Q_EXPR_OR)) {            /* e = A and (B or C) ====> e = A and B or A and C */            newTerm = F2(Q_EXPR_AND,q_exprCopy(leftTerm),q_leftPar(rightTerm));            /* e = A and (B or C); newTerm = A and B */            q_swapLeft(rightTerm,q_swapLeft(e,newTerm));            /* e = (A and B) and (A or C); */            q_setTag(rightTerm,Q_EXPR_AND);            /* e = (A and B) and (A and C); */            q_setTag(e,Q_EXPR_OR);            /* e = (A and B) or (A and C); */    	}    }}

void rubikStep(char *step){	u8 m=0;	for(m=0;step[m]!=0;m++)	{		switch(step[m])		{			case 7:allright90();break;			case 11:F1();break;			case 12:F2();break;			case 13:F3();break;			case 21:B1();break;			case 22:B2();break;			case 23:B3();break;			case 31:R1();break;			case 32:R2();break;			case 33:R3();break;			case 41:L1();break;			case 42:L2();break;			case 43:L3();break;			case 51:U1();break;			case 52:U2();break;			case 53:U3();break;			case 61:D1();break;			case 62:D2();break;			case 63:D3();break;			default:break;		}	}}

/*reverse quad round*/static inline void QBAR (u32 * block, u8 * Kr, u32 * Km) {	u32 I;        block[3] ^= F1(block[0], Kr[3], Km[3]);        block[0] ^= F3(block[1], Kr[2], Km[2]);        block[1] ^= F2(block[2], Kr[1], Km[1]);        block[2] ^= F1(block[3], Kr[0], Km[0]);}

TEST(RecorderTest, ArgRecorderTest) {	TRACER_TRACE(&F2) f2;	auto f2a = tracer::RecordArgs(f2);	int a = 5;	F2(a);	for (int i = a; i >= 0; i--) 		EXPECT_EQ(5 - i, f2a.Arg<0>(i));}

static void cast5_decrypt(void *ctx, u8 * outbuf, const u8 * inbuf){	struct cast5_ctx *c = (struct cast5_ctx *) ctx;	const __be32 *src = (const __be32 *)inbuf;	__be32 *dst = (__be32 *)outbuf;	u32 l, r, t;	u32 I;	u32 *Km;	u8 *Kr;	Km = c->Km;	Kr = c->Kr;	l = be32_to_cpu(src[0]);	r = be32_to_cpu(src[1]);	if (!(c->rr)) {		t = l; l = r; r = t ^ F1(r, Km[15], Kr[15]);		t = l; l = r; r = t ^ F3(r, Km[14], Kr[14]);		t = l; l = r; r = t ^ F2(r, Km[13], Kr[13]);		t = l; l = r; r = t ^ F1(r, Km[12], Kr[12]);		t = l; l = r; r = t ^ F3(r, Km[11], Kr[11]);		t = l; l = r; r = t ^ F2(r, Km[10], Kr[10]);		t = l; l = r; r = t ^ F1(r, Km[9], Kr[9]);		t = l; l = r; r = t ^ F3(r, Km[8], Kr[8]);		t = l; l = r; r = t ^ F2(r, Km[7], Kr[7]);		t = l; l = r; r = t ^ F1(r, Km[6], Kr[6]);		t = l; l = r; r = t ^ F3(r, Km[5], Kr[5]);		t = l; l = r; r = t ^ F2(r, Km[4], Kr[4]);		t = l; l = r; r = t ^ F1(r, Km[3], Kr[3]);		t = l; l = r; r = t ^ F3(r, Km[2], Kr[2]);		t = l; l = r; r = t ^ F2(r, Km[1], Kr[1]);		t = l; l = r; r = t ^ F1(r, Km[0], Kr[0]);	} else {		t = l; l = r; r = t ^ F3(r, Km[11], Kr[11]);		t = l; l = r; r = t ^ F2(r, Km[10], Kr[10]);		t = l; l = r; r = t ^ F1(r, Km[9], Kr[9]);		t = l; l = r; r = t ^ F3(r, Km[8], Kr[8]);		t = l; l = r; r = t ^ F2(r, Km[7], Kr[7]);		t = l; l = r; r = t ^ F1(r, Km[6], Kr[6]);		t = l; l = r; r = t ^ F3(r, Km[5], Kr[5]);		t = l; l = r; r = t ^ F2(r, Km[4], Kr[4]);		t = l; l = r; r = t ^ F1(r, Km[3], Kr[3]);		t = l; l = r; r = t ^ F3(r, Km[2], Kr[2]);		t = l; l = r; r = t ^ F2(r, Km[1], Kr[1]);		t = l; l = r; r = t ^ F1(r, Km[0], Kr[0]);	}	dst[0] = cpu_to_be32(r);	dst[1] = cpu_to_be32(l);}

const char* ChannelSelector::getChannelName(){  if (current_channel>CHANNEL_NONE && current_channel<CHANNEL_LAST) {    return (const char*)channel_names[(int)current_channel];  }  else {    return (const char*)F2("N/A");  }}

int main(){	auto a1 = F1();	auto a2 = F2();	auto a3 = F3();	auto a4 = F4();	auto a5 = F5();    return 0;}

voidcast_decrypt(cast_key* key, u_int8_t* inblock, u_int8_t* outblock){	u_int32_t t, l, r;	/* Get inblock into l,r */	r = ((u_int32_t)inblock[0] << 24) | ((u_int32_t)inblock[1] << 16) |	    ((u_int32_t)inblock[2] << 8) | (u_int32_t)inblock[3];	l = ((u_int32_t)inblock[4] << 24) | ((u_int32_t)inblock[5] << 16) |	    ((u_int32_t)inblock[6] << 8) | (u_int32_t)inblock[7];	/* Do the work */	/* Only do full 16 rounds if key length > 80 bits */	if (key->rounds > 12) {		F1(r, l, 15);		F3(l, r, 14);		F2(r, l, 13);		F1(l, r, 12);	}	F3(r, l, 11);	F2(l, r, 10);	F1(r, l,  9);	F3(l, r,  8);	F2(r, l,  7);	F1(l, r,  6);	F3(r, l,  5);	F2(l, r,  4);	F1(r, l,  3);	F3(l, r,  2);	F2(r, l,  1);	F1(l, r,  0);	/* Put l,r into outblock */	outblock[0] = U8a(l);	outblock[1] = U8b(l);	outblock[2] = U8c(l);	outblock[3] = U8d(l);	outblock[4] = U8a(r);	outblock[5] = U8b(r);	outblock[6] = U8c(r);	outblock[7] = U8d(r);	/* Wipe clean */	t = l = r = 0;}

static q_exprq_deNot(    q_expr e){    q_expr r;    if (e == NULL) {        return NULL;    }    if (e->kind == T_FNC) {        switch (e->info.function->tag) {        case Q_EXPR_LIKE:                                    r = e; break;        case Q_EXPR_EQ:   e->info.function->tag = Q_EXPR_NE; r = e; break;        case Q_EXPR_NE:   e->info.function->tag = Q_EXPR_EQ; r = e; break;        case Q_EXPR_LT:   e->info.function->tag = Q_EXPR_GE; r = e; break;        case Q_EXPR_LE:   e->info.function->tag = Q_EXPR_GT; r = e; break;        case Q_EXPR_GT:   e->info.function->tag = Q_EXPR_LE; r = e; break;        case Q_EXPR_GE:   e->info.function->tag = Q_EXPR_LT; r = e; break;        case Q_EXPR_NOT:            r = q_takePar(e,0);            q_dispose(e);        break;        case Q_EXPR_AND:            r = F2(Q_EXPR_OR,q_removeNots(q_takePar(e,0)),q_removeNots(q_takePar(e,1)));            q_dispose(e);        break;        case Q_EXPR_OR:            r = F2(Q_EXPR_AND,q_removeNots(q_takePar(e,0)),q_removeNots(q_takePar(e,1)));            q_dispose(e);        break;        default:            assert(FALSE);            r = e;        break;        }    } else {        r = e;    }    return r;}

void CAST5decrypt(const PGPUInt8 *in, PGPUInt8 *out, const PGPUInt32 *xkey){	PGPUInt32 l, r, t;	r = (PGPUInt32) in[0]<<24 | (PGPUInt32) in[1]<<16 | 		(PGPUInt32) in[2]<<8 | in[3];	l = (PGPUInt32) in[4]<<24 | (PGPUInt32) in[5]<<16 | 		(PGPUInt32) in[6]<<8 | in[7];	t = F1(l, xkey, 15); r ^= G1(t);	t = F3(r, xkey, 14); l ^= G3(t);	t = F2(l, xkey, 13); r ^= G2(t);	t = F1(r, xkey, 12); l ^= G1(t);	// Start here if only doing 12 rounds	t = F3(l, xkey, 11); r ^= G3(t);	t = F2(r, xkey, 10); l ^= G2(t);	t = F1(l, xkey,  9); r ^= G1(t);	t = F3(r, xkey,  8); l ^= G3(t);	t = F2(l, xkey,  7); r ^= G2(t);	t = F1(r, xkey,  6); l ^= G1(t);	t = F3(l, xkey,  5); r ^= G3(t);	t = F2(r, xkey,  4); l ^= G2(t);	t = F1(l, xkey,  3); r ^= G1(t);	t = F3(r, xkey,  2); l ^= G3(t);	t = F2(l, xkey,  1); r ^= G2(t);	t = F1(r, xkey,  0); l ^= G1(t);	out[0]	= (PGPUInt8) B0(l);	out[1]	= (PGPUInt8) B1(l);	out[2]	= (PGPUInt8) B2(l);	out[3]	= (PGPUInt8) B3(l);	out[4]	= (PGPUInt8) B0(r);	out[5]	= (PGPUInt8) B1(r);	out[6]	= (PGPUInt8) B2(r);	out[7]	= (PGPUInt8) B3(r);}

static void bf_e_block(uint32_t *p_xl, uint32_t *p_xr){  uint32_t temp;  uint32_t xl = *p_xl;  uint32_t xr = *p_xr;  F1(0) F2(1) F1(2) F2(3) F1(4) F2(5) F1(6) F2(7)  F1(8) F2(9) F1(10) F2(11) F1(12) F2(13) F1(14) F2(15)  xl ^= pax[16];  xr ^= pax[17];  temp = xl;  xl = xr;  xr = temp;  *p_xl = xl;  *p_xr = xr;}

voidVector_Drive(vector V, double omega){	vector F1(-1.000,0.000), F2(0.500,-0.866), F3(0.866,0.500);	double omega1, omega2, omega3, b=0.090, r=0.020, h=0;	omega1 = ( F1*V + b*omega ) / r;	// F1*V is overloaded dot product	omega2 = ( F2*V + b*omega ) / r;	omega3 = ( F3*V + b*omega ) / r;	// makes sure that given path is physically possible	if ( (omega1>6) || (omega2>6) || (omega3>6) || (omega1<-6) || (omega2<-6) || (omega3<-6) )		DisplayTxt("Vectors: ERROR!");	else 		Drive(Vel_To_Value(omega1),Vel_To_Value(omega2),Vel_To_Value(omega3));}

/* * Encrypt the 8 bytes at *in into the 8 bytes at *out using the expanded * key schedule from *xkey. */static voidCAST5encrypt(PGPByte const *in, PGPByte *out, PGPUInt32 const *xkey){	PGPUInt32 l, r, t;	l = (PGPUInt32)		in[0]<<24 | (PGPUInt32)in[1]<<16 | (PGPUInt32)in[2]<<8 | in[3];	r = (PGPUInt32)		in[4]<<24 | (PGPUInt32)in[5]<<16 | (PGPUInt32)in[6]<<8 | in[7];	t = F1(r, xkey,  0); l ^= G1(t);	t = F2(l, xkey,  1); r ^= G2(t);	t = F3(r, xkey,  2); l ^= G3(t);	t = F1(l, xkey,  3); r ^= G1(t);	t = F2(r, xkey,  4); l ^= G2(t);	t = F3(l, xkey,  5); r ^= G3(t);	t = F1(r, xkey,  6); l ^= G1(t);	t = F2(l, xkey,  7); r ^= G2(t);	t = F3(r, xkey,  8); l ^= G3(t);	t = F1(l, xkey,  9); r ^= G1(t);	t = F2(r, xkey, 10); l ^= G2(t);	t = F3(l, xkey, 11); r ^= G3(t);	/* Stop here if only doing 12 rounds */	t = F1(r, xkey, 12); l ^= G1(t);	t = F2(l, xkey, 13); r ^= G2(t);	t = F3(r, xkey, 14); l ^= G3(t);	t = F1(l, xkey, 15); r ^= G1(t);	out[0] = B0(r);	out[1] = B1(r);	out[2] = B2(r);	out[3] = B3(r);	out[4] = B0(l);	out[5] = B1(l);	out[6] = B2(l);	out[7] = B3(l);}

seconlevel_f4::seconlevel_f4(QWidget *parent) :    QWidget(parent),    ui(new Ui::seconlevel_f4){    ui->setupUi(this);    group = new GroupDialog(parent);    group->hide();    connect(group ,SIGNAL(finished(int)) ,this ,SLOT(f1_Done(int)));    autotab = new AutoDialog(parent);    autotab->hide();    connect(autotab ,SIGNAL(finished(int)) ,this ,SLOT(f2_Done(int)));    jump = new JumpDialog(parent);    jump->hide();    connect(jump ,SIGNAL(finished(int)) ,this ,SLOT(f6_Done(int)));    connect(ui->pushButton_F1,SIGNAL(clicked()),this ,SLOT(F1()));    ui->pushButton_F1->setCheckable(true);    connect(ui->pushButton_F2,SIGNAL(clicked()),this ,SLOT(F2()));    ui->pushButton_F2->setCheckable(true);    connect(ui->pushButton_F3,SIGNAL(clicked()),this ,SLOT(F3()));    ui->pushButton_F3->setCheckable(true);    connect(ui->pushButton_F4,SIGNAL(clicked()),this ,SLOT(F4()));    ui->pushButton_F4->setCheckable(true);    connect(ui->pushButton_F5,SIGNAL(clicked()),this ,SLOT(F5()));    ui->pushButton_F5->setCheckable(true);    connect(ui->pushButton_F6,SIGNAL(clicked()),this ,SLOT(F6()));    ui->pushButton_F6->setCheckable(true);    connect(ui->pushButton_F7,SIGNAL(clicked()),this ,SLOT(F7()));    ui->pushButton_F7->setCheckable(true);    connect(this ,SIGNAL(enter(int)),parent ,SLOT(funcbarUpdate(int)));    connect(ui->pushButton_F8,SIGNAL(clicked()),this ,SLOT(F8()));    /*数据表模式改变信号*/    connect(this ,SIGNAL(stateChange(char)) ,parent ,SLOT(tableStateUpdate(char)));    /*段选信号*/    connect(this ,SIGNAL(selectRows(bool)) ,parent ,SLOT(tableSelect(bool)));    setFocusPolicy(Qt::NoFocus);}

int main() {  typedef OKlib::Literals::Literals_int literal_type;  typedef std::vector<literal_type> clause_type;  typedef std::vector<clause_type> clause_set1_type;  typedef OKlib::InputOutput::RawDimacsCLSAdaptor<literal_type, clause_set1_type> InputClsadaptor;  InputClsadaptor F1;  OKlib::InputOutput::StandardDIMACSInput<InputClsadaptor>(std::cin, F1);  const InputClsadaptor::int_type n = F1.stat.parameter_n;  typedef std::list<clause_type> clause_set2_type;  clause_set2_type F2(F1.clause_set.begin(), F1.clause_set.end());  F1.clause_set.clear();  if (F2.size() >= 2) {    clause_set2_type F_removed;    typedef clause_set2_type::iterator clause_iterator;    const clause_iterator F2end = F2.end();    for (struct {clause_iterator Ci, next;} l = {F2.begin(), boost::next(F2.begin())}; l.Ci != F2end; l.Ci = l.next) {      l.next = boost::next(l.Ci);      F_removed.splice(F_removed.begin(), F2, l.Ci);      typedef OKlib::Satisfiability::Reductions::UnitClausePropagation::CLSAdaptorUcpW<          OKlib::Satisfiability::ProblemInstances::Clauses::WatchedLiterals_mono<literal_type>,          OKlib::Satisfiability::Assignments::TotalAssignments::BAssignmentWithQueue<literal_type> >        Ucp;      Ucp U;      OKlib::InputOutput::ListTransfer<Ucp>(F2, U, n);      const Ucp::assignment_type f(U.assignment());      if (U.contradicting_uclause()) continue;      bool removable = true;      const clause_iterator Frend = F_removed.end();      for (clause_iterator Di = F_removed.begin(); Di != Frend; ++Di, U.contradicting_uclause() = false) {        U.set_assignments(f);        const clause_type& D = *Di;        typedef clause_type::const_iterator literal_iterator;        for (literal_iterator xi = D.begin(); xi != D.end(); ++xi)          U.push_unit_clause(-*xi);        if (not U.perform_ucp()) { removable = false; break; }      }      if (not removable) F2.splice(l.next, F_removed, F_removed.begin());    }  }  {   typedef OKlib::InputOutput::CLSAdaptorDIMACSOutput<literal_type> OutputClsadaptor;   OutputClsadaptor out(std::cout);   OKlib::InputOutput::ListTransfer<OutputClsadaptor>(F2, out, "");  }}

int g(unsigned char *in,int i,dword *h){	dword h0,h1,h2,h3,h4,a,b,c,d,e,temp;	unsigned char *kp;	dword w[80];	kp = in;	h0 = WORD(kp); kp += 4;	h1 = WORD(kp); kp += 4;	h2 = WORD(kp); kp += 4;	h3 = WORD(kp); kp += 4;	h4 = WORD(kp); kp += 4;	w[0] = i;	for (i=1;i<16;i++) w[i] = 0;	for (i=16;i<80;i++) w[i] = w[i-3]^w[i-8]^w[i-14]^w[i-16];	a = h0; b = h1; c = h2; d = h3; e = h4;	for(i=0;i<20;i++)	{		temp = ROT27(a) + F1(b, c, d) + e + w[i] + 0x5a827998;		e = d; d = c; c = ROT2(b); b = a; a = temp;	}	for (i=20;i<40;i++)	{		temp = ROT27(a) + F2(b, c, d) + e + w[i] + 0x6ef9eba1;		e = d; d = c; c = ROT2(b); b = a; a = temp;	}	for (i=40;i<60;i++)	{		temp = ROT27(a) + F3(b, c, d) + e + w[i] + 0x7f1cbcdc;		e = d; d = c; c = ROT2(b); b = a; a = temp;	}	for (i=60;i<80;i++)	{		temp = ROT27(a) + F4(b, c, d) + e + w[i] + 0xaa62d1d6;		e = d; d = c; c = ROT2(b); b = a; a = temp;	}	h[0] = h0+a; h[1] = h1+b; h[2] = h2+c; h[3] = h3+d; h[4] = h4+e;	return (ALG_OK);}

void sha256_transform (uint32 *buf, uint32 const *in){  uint32 w[64] ;  unsigned int i = 0 ;  register uint32 a = buf[0], b = buf[1], c = buf[2], d = buf[3], e = buf[4], f = buf[5], g = buf[6], h = buf[7] ;  for (; i < 16 ; i++) w[i] = in[i] ;  for (; i < 64 ; i++)    w[i] = SMALLSIGMA1(w[i-2]) + w[i-7] + SMALLSIGMA0(w[i-15]) + w[i-16] ;  for (i = 0 ; i < 64 ; i++)  {    uint32 temp1 = h + CAPITALSIGMA1(e) + F1(e, f, g) + sha256_constants[i] + w[i] ;    uint32 temp2 = CAPITALSIGMA0(a) + F2(a, b, c) ;    h = g ; g = f ; f = e ; e = d + temp1 ;    d = c ; c = b ; b = a ; a = temp1 + temp2 ;  }  buf[0] += a ; buf[1] += b ; buf[2] += c ; buf[3] += d ;  buf[4] += e ; buf[5] += f ; buf[6] += g ; buf[7] += h ;}

void ChannelSelector::setAmpPower(bool mode){  MDISPLAY.showMessage(F2("Processing ..."));  uint8_t cmd = 0;  if (mode) {    // power on amp      cmd = (uint8_t)(CMD_PWR_AMP_ON);    Wire.beginTransmission(ADDR_PWR);    Wire.write(cmd);    Wire.endTransmission(true);      delay(2000);    // set mute off    cmd = (uint8_t)(CMD_VOL_MUTE_OFF);    Wire.beginTransmission(ADDR_VOLUME);    Wire.write(cmd);    Wire.endTransmission(true);      delay(1000);  }  else {    // set mute on    cmd = (uint8_t)(CMD_VOL_MUTE_ON);    Wire.beginTransmission(ADDR_VOLUME);    Wire.write(cmd);    Wire.endTransmission(true);      delay(1000);    // power off amp    cmd = (uint8_t)(CMD_PWR_AMP_OFF);    Wire.beginTransmission(ADDR_PWR);    Wire.write(cmd);    Wire.endTransmission(true);      delay(2000);      }    GLOBALS.amp_power_enabled = mode;  }

int main(){    std_setup();        ml_random rng;                {		// output analytic solution		        grid2D<double, double > F1( 500, -10.0, 10.0, 500, -10.0, 10.0 );        grid2D<double, double > F2( F1 );        grid2D<double, double > G1( F1 );        grid2D<double, double > G2( F1 );                F1 = V_1;        F2 = V_2;                laplacian_2d_hdaf Del2;        Del2.init( F1.n1, F1.n2, F1.b1-F1.a1, F1.b2-F1.a2, 24, 24, .5, .5 );                Del2.execute( F1.array, G1.array );        Del2.execute( F2.array, G2.array );                        plotGrid2D_1( F1,  "/workspace/output/scratch/F1.png", color_map_green );        plotGrid2D_1( F2,  "/workspace/output/scratch/F2.png", color_map_green );        plotGrid2D_1( G1,  "/workspace/output/scratch/G1.png", color_map_error );        plotGrid2D_1( G2,  "/workspace/output/scratch/G2.png", color_map_error );	}                            std_exit();}

int main() {    int t,i,j,k;    int x[M][M], y[M][M];    int x3[M][M][M];    for (i = 1 ; i<=M; i++) {        for (j = 1; j<=M; j++) {            for (k = 1; k<=3; k++) {                src(&(x3[i][j][k]));            }        }    }    for (i = 1 ; i<=M; i++) {        for (j = 1; j<=M; j++) {            for (k = 1; k<=3; k++) {                if (k <= 2) {                    F1(&(x3[i][j][k]), &(x3[i][j][k]));                } else {                    F2(&(x3[i][j][k]), &(x3[i][j][k]));                }            }        }    }    for (i = 1 ; i<=M; i++) {        for (j = 1; j<=M; j++) {            for (k = 1; k<=3; k++) {                sink(&(x3[i][j][k]));            }        }    }    return 0;}

Eigen::MatrixXd TimeIntegrator::GeneralisedAlpha(Eigen::MatrixXd &K, Eigen::MatrixXd &M, double &del, double &gam, double &alphaf, double &alpham){    Eigen::MatrixXd U,V,A;    U.setZero(K.rows(),_nstep+1);    V.setZero(K.rows(),_nstep+1); A.setZero(K.rows(),_nstep+1);    Eigen::VectorXd F = Eigen::VectorXd::Zero(K.rows());    Eigen::VectorXd F2 = Eigen::VectorXd::Zero(K.rows());    // Loop over time steps    for (int istep=0; istep<_nstep; ++istep)    {        if (istep==_nstep-1)            break;        for (int i=0; i<_napp.rows(); ++i)        {            F(_napp(i)) = F1(istep);            F2(_napp(i)) = F1(istep+1);        }        U.col(istep+1) = ((1-alpham)/_dt/_dt/gam*M+(1-alphaf)*K).llt().solve((1-alphaf)*F2+alphaf*F+((1-alpham)/_dt/_dt/gam*M-alphaf*K)*U.col(istep)+(1-alpham)/_dt/gam*M*V.col(istep)+((1-alpham)*(1.0/2.0/gam-1)-alpham)*M*A.col(istep));        A.col(istep+1) = 1.0/(_dt*_dt*gam)*(U.col(istep+1)-U.col(istep))-1.0/(_dt*gam)*V.col(istep)+(1-1.0/(2.0*gam))*A.col(istep);        V.col(istep+1) = V.col(istep)+_dt*(del*A.col(istep+1)+(1-del)*A.col(istep));    }    return U;}

static voidsha1_step(struct sha1_ctxt *ctxt){	uint32_t	a, b, c, d, e;	size_t t, s;	uint32_t	tmp;#if !WORDS_BIGENDIAN	struct sha1_ctxt tctxt;	memmove(&tctxt.m.b8[0], &ctxt->m.b8[0], 64);	ctxt->m.b8[0] = tctxt.m.b8[3]; ctxt->m.b8[1] = tctxt.m.b8[2];	ctxt->m.b8[2] = tctxt.m.b8[1]; ctxt->m.b8[3] = tctxt.m.b8[0];	ctxt->m.b8[4] = tctxt.m.b8[7]; ctxt->m.b8[5] = tctxt.m.b8[6];	ctxt->m.b8[6] = tctxt.m.b8[5]; ctxt->m.b8[7] = tctxt.m.b8[4];	ctxt->m.b8[8] = tctxt.m.b8[11]; ctxt->m.b8[9] = tctxt.m.b8[10];	ctxt->m.b8[10] = tctxt.m.b8[9]; ctxt->m.b8[11] = tctxt.m.b8[8];	ctxt->m.b8[12] = tctxt.m.b8[15]; ctxt->m.b8[13] = tctxt.m.b8[14];	ctxt->m.b8[14] = tctxt.m.b8[13]; ctxt->m.b8[15] = tctxt.m.b8[12];	ctxt->m.b8[16] = tctxt.m.b8[19]; ctxt->m.b8[17] = tctxt.m.b8[18];	ctxt->m.b8[18] = tctxt.m.b8[17]; ctxt->m.b8[19] = tctxt.m.b8[16];	ctxt->m.b8[20] = tctxt.m.b8[23]; ctxt->m.b8[21] = tctxt.m.b8[22];	ctxt->m.b8[22] = tctxt.m.b8[21]; ctxt->m.b8[23] = tctxt.m.b8[20];	ctxt->m.b8[24] = tctxt.m.b8[27]; ctxt->m.b8[25] = tctxt.m.b8[26];	ctxt->m.b8[26] = tctxt.m.b8[25]; ctxt->m.b8[27] = tctxt.m.b8[24];	ctxt->m.b8[28] = tctxt.m.b8[31]; ctxt->m.b8[29] = tctxt.m.b8[30];	ctxt->m.b8[30] = tctxt.m.b8[29]; ctxt->m.b8[31] = tctxt.m.b8[28];	ctxt->m.b8[32] = tctxt.m.b8[35]; ctxt->m.b8[33] = tctxt.m.b8[34];	ctxt->m.b8[34] = tctxt.m.b8[33]; ctxt->m.b8[35] = tctxt.m.b8[32];	ctxt->m.b8[36] = tctxt.m.b8[39]; ctxt->m.b8[37] = tctxt.m.b8[38];	ctxt->m.b8[38] = tctxt.m.b8[37]; ctxt->m.b8[39] = tctxt.m.b8[36];	ctxt->m.b8[40] = tctxt.m.b8[43]; ctxt->m.b8[41] = tctxt.m.b8[42];	ctxt->m.b8[42] = tctxt.m.b8[41]; ctxt->m.b8[43] = tctxt.m.b8[40];	ctxt->m.b8[44] = tctxt.m.b8[47]; ctxt->m.b8[45] = tctxt.m.b8[46];	ctxt->m.b8[46] = tctxt.m.b8[45]; ctxt->m.b8[47] = tctxt.m.b8[44];	ctxt->m.b8[48] = tctxt.m.b8[51]; ctxt->m.b8[49] = tctxt.m.b8[50];	ctxt->m.b8[50] = tctxt.m.b8[49]; ctxt->m.b8[51] = tctxt.m.b8[48];	ctxt->m.b8[52] = tctxt.m.b8[55]; ctxt->m.b8[53] = tctxt.m.b8[54];	ctxt->m.b8[54] = tctxt.m.b8[53]; ctxt->m.b8[55] = tctxt.m.b8[52];	ctxt->m.b8[56] = tctxt.m.b8[59]; ctxt->m.b8[57] = tctxt.m.b8[58];	ctxt->m.b8[58] = tctxt.m.b8[57]; ctxt->m.b8[59] = tctxt.m.b8[56];	ctxt->m.b8[60] = tctxt.m.b8[63]; ctxt->m.b8[61] = tctxt.m.b8[62];	ctxt->m.b8[62] = tctxt.m.b8[61]; ctxt->m.b8[63] = tctxt.m.b8[60];#endif	a = H(0); b = H(1); c = H(2); d = H(3); e = H(4);	for (t = 0; t < 20; t++) {		s = t & 0x0f;		if (t >= 16) {			W(s) = S(1, W((s+13) & 0x0f) ^ W((s+8) & 0x0f) ^ W((s+2) & 0x0f) ^ W(s));		}		tmp = S(5, a) + F0(b, c, d) + e + W(s) + K(t);		e = d; d = c; c = S(30, b); b = a; a = tmp;	}	for (t = 20; t < 40; t++) {		s = t & 0x0f;		W(s) = S(1, W((s+13) & 0x0f) ^ W((s+8) & 0x0f) ^ W((s+2) & 0x0f) ^ W(s));		tmp = S(5, a) + F1(b, c, d) + e + W(s) + K(t);		e = d; d = c; c = S(30, b); b = a; a = tmp;	}	for (t = 40; t < 60; t++) {		s = t & 0x0f;		W(s) = S(1, W((s+13) & 0x0f) ^ W((s+8) & 0x0f) ^ W((s+2) & 0x0f) ^ W(s));		tmp = S(5, a) + F2(b, c, d) + e + W(s) + K(t);		e = d; d = c; c = S(30, b); b = a; a = tmp;	}	for (t = 60; t < 80; t++) {		s = t & 0x0f;		W(s) = S(1, W((s+13) & 0x0f) ^ W((s+8) & 0x0f) ^ W((s+2) & 0x0f) ^ W(s));		tmp = S(5, a) + F3(b, c, d) + e + W(s) + K(t);		e = d; d = c; c = S(30, b); b = a; a = tmp;	}	H(0) = H(0) + a;	H(1) = H(1) + b;	H(2) = H(2) + c;	H(3) = H(3) + d;	H(4) = H(4) + e;	memset(&ctxt->m.b8[0], 0, 64);}

static void reconstruct(double *x, double *y, int len){  double *temp_1, *temp_2;  double *even, *odd;  int i, n_half, n_unrol;  n_half = len >> 1;  even = x;  odd = x + n_half;  temp_1 = y;  temp_2 = y + n_half;  n_unrol = n_half & 0xfffffff8;  for (i = 0; i < n_unrol; i += 8) {    even[i + 0] /= NORM_FACTOR;    even[i + 1] /= NORM_FACTOR;    even[i + 2] /= NORM_FACTOR;    even[i + 3] /= NORM_FACTOR;    even[i + 4] /= NORM_FACTOR;    even[i + 5] /= NORM_FACTOR;    even[i + 6] /= NORM_FACTOR;    even[i + 7] /= NORM_FACTOR;    odd[i + 0] *= NORM_FACTOR;    odd[i + 1] *= NORM_FACTOR;    odd[i + 2] *= NORM_FACTOR;    odd[i + 3] *= NORM_FACTOR;    odd[i + 4] *= NORM_FACTOR;    odd[i + 5] *= NORM_FACTOR;    odd[i + 6] *= NORM_FACTOR;    odd[i + 7] *= NORM_FACTOR;  }  for (; i < n_half; i++) {    even[i] /= NORM_FACTOR;    odd[i] *= NORM_FACTOR;  }  PHI3(odd, temp_1, temp_2, n_half);  for (i = 0; i < n_unrol; i += 8) {    even[i + 0] -= temp_1[i + 0];    even[i + 1] -= temp_1[i + 1];    even[i + 2] -= temp_1[i + 2];    even[i + 3] -= temp_1[i + 3];    even[i + 4] -= temp_1[i + 4];    even[i + 5] -= temp_1[i + 5];    even[i + 6] -= temp_1[i + 6];    even[i + 7] -= temp_1[i + 7];  }  for (; i < n_half; i++) even[i] -= temp_1[i];  F2(even, temp_1, temp_2, n_half);  for (i = 0; i < n_unrol; i += 8) {    odd[i + 0] += temp_1[i + 0];    odd[i + 1] += temp_1[i + 1];    odd[i + 2] += temp_1[i + 2];    odd[i + 3] += temp_1[i + 3];    odd[i + 4] += temp_1[i + 4];    odd[i + 5] += temp_1[i + 5];    odd[i + 6] += temp_1[i + 6];    odd[i + 7] += temp_1[i + 7];  }  for (; i < n_half; i++) odd[i] += temp_1[i];  for (i = 0; i < n_unrol; i += 8) {    y[((i + 0) << 1)] = even[i + 0];    y[((i + 1) << 1)] = even[i + 1];    y[((i + 2) << 1)] = even[i + 2];    y[((i + 3) << 1)] = even[i + 3];    y[((i + 4) << 1)] = even[i + 4];    y[((i + 5) << 1)] = even[i + 5];    y[((i + 6) << 1)] = even[i + 6];    y[((i + 7) << 1)] = even[i + 7];    y[((i + 0) << 1) + 1] = odd[i + 0];    y[((i + 1) << 1) + 1] = odd[i + 1];    y[((i + 2) << 1) + 1] = odd[i + 2];    y[((i + 3) << 1) + 1] = odd[i + 3];    y[((i + 4) << 1) + 1] = odd[i + 4];    y[((i + 5) << 1) + 1] = odd[i + 5];    y[((i + 6) << 1) + 1] = odd[i + 6];    y[((i + 7) << 1) + 1] = odd[i + 7];  }  for (; i < n_half; i++) {    y[(i << 1)] = even[i];    y[(i << 1) + 1] = odd[i];  }}

void compareDataCard(		     TString channel="muTau",		     TString year="2011",		     TString Group1="CERN",		     TString Path1="/afs/cern.ch/user/b/benitezj/public/datacards/2011/Aug4",		     TString File1="muTauSM_svfitmass",		     TString Group2="Saclay",		     TString Path2="/afs/cern.ch/user/b/bianchi/public/Roger/datacards2011v3",		     TString File2="muTauSM"		     ){  TFile F1(Path1+"/"+File1+".root","read");  TFile F2(Path2+"/"+File2+".root","read");    F1.ls();  F2.ls();  TString fname="Diff_"+channel+"_"+year+"_"+Group1+"_"+Group2;  TCanvas C(fname);    C.Print(TString(C.GetName())+".pdf[");    //cout<<" | 0jet_low Data | 0jet_low ZTT | 0jet_low W | 0jet_low QCD | 0jet_low TT | 0jet_low  ggH | 0jet_low  qqH | Boosted_high Data | Boosted_high ZTT | Boosted_high W | Boosted_high QCD | Boosted_high TT | Boosted_high ggH | Boosted_high qqH | VBF Data| VBF ZTT | VBF W | VBF QCD | VBF TT | VBF qqH | VBF ggH |"<<endl;//   drawCategory(&C,Group1,&F1,Group2,&F2,channel,"0jet_low",1);//   drawCategory(&C,Group1,&F1,Group2,&F2,channel,"0jet_high",0);//   drawCategory(&C,Group1,&F1,Group2,&F2,channel,"boost_low",0);//   drawCategory(&C,Group1,&F1,Group2,&F2,channel,"boost_high",1);//   drawCategory(&C,Group1,&F1,Group2,&F2,channel,"vbf",1);  drawSample(&C,Group1,&F1,Group2,&F2,channel,"data_obs",0);  drawSample(&C,Group1,&F1,Group2,&F2,channel,"ZTT",0);  drawSample(&C,Group1,&F1,Group2,&F2,channel,"W",0);  drawSample(&C,Group1,&F1,Group2,&F2,channel,"QCD",0);  drawSample(&C,Group1,&F1,Group2,&F2,channel,"TT",0);  drawSample(&C,Group1,&F1,Group2,&F2,channel,"ZL",0);  drawSample(&C,Group1,&F1,Group2,&F2,channel,"ZJ",0);  drawSample(&C,Group1,&F1,Group2,&F2,channel,"ZLL",0);  drawSample(&C,Group1,&F1,Group2,&F2,channel,"VV",0);  drawSample(&C,Group1,&F1,Group2,&F2,channel,"ggH125",0);  drawSample(&C,Group1,&F1,Group2,&F2,channel,"qqH125",0);  drawSample(&C,Group1,&F1,Group2,&F2,channel,"VH125",0);//   drawSignalDiff(&C,Group1,&F1,Group2,&F2,channel,"boost_high","ggH");//   drawSignalDiff(&C,Group1,&F1,Group2,&F2,channel,"boost_high","qqH");//   drawSignalDiff(&C,Group1,&F1,Group2,&F2,channel,"boost_high","VH");//   drawSignalDiff(&C,Group1,&F1,Group2,&F2,channel,"vbf","ggH");//   drawSignalDiff(&C,Group1,&F1,Group2,&F2,channel,"vbf","qqH");//   drawSignalDiff(&C,Group1,&F1,Group2,&F2,channel,"vbf","VH");  //drawSample(&C,Group1,&F1,Group2,&F2,channel,"ZTT_CMS_scale_t_mutau_8TeVUp",0);  //drawSample(&C,Group1,&F1,Group2,&F2,channel,"ZTT_CMS_scale_t_mutau_8TeVDown",0);  C.Print(TString(C.GetName())+".pdf]");    //cout<<"|"<<endl;//   gROOT->ProcessLine(".q");}

/* The RIPEMD160 compression function. */static inline void rmd160_compress(struct rmd160_ctx *ctx, uint32_t *buf){    uint8_t w, round;    uint32_t T;    uint32_t AL, BL, CL, DL, EL;    /* left line */    uint32_t AR, BR, CR, DR, ER;    /* right line */    uint32_t X[16];    /* Byte-swap the buffer if we're on a big-endian machine */    cpu_to_le32_array(X, buf, 16);    /* Load the left and right lines with the initial state */    AL = AR = ctx->h[0];    BL = BR = ctx->h[1];    CL = CR = ctx->h[2];    DL = DR = ctx->h[3];    EL = ER = ctx->h[4];    /* Round 1 */    round = 0;    for (w = 0; w < 16; w++) { /* left line */        T = rol32(AL + F1(BL, CL, DL) + X[RL[round][w]] + KL[round], SL[round][w]) + EL;        AL = EL; EL = DL; DL = rol32(CL, 10); CL = BL; BL = T;    }    for (w = 0; w < 16; w++) { /* right line */        T = rol32(AR + F5(BR, CR, DR) + X[RR[round][w]] + KR[round], SR[round][w]) + ER;        AR = ER; ER = DR; DR = rol32(CR, 10); CR = BR; BR = T;    }    /* Round 2 */    round++;    for (w = 0; w < 16; w++) { /* left line */        T = rol32(AL + F2(BL, CL, DL) + X[RL[round][w]] + KL[round], SL[round][w]) + EL;        AL = EL; EL = DL; DL = rol32(CL, 10); CL = BL; BL = T;    }    for (w = 0; w < 16; w++) { /* right line */        T = rol32(AR + F4(BR, CR, DR) + X[RR[round][w]] + KR[round], SR[round][w]) + ER;        AR = ER; ER = DR; DR = rol32(CR, 10); CR = BR; BR = T;    }    /* Round 3 */    round++;    for (w = 0; w < 16; w++) { /* left line */        T = rol32(AL + F3(BL, CL, DL) + X[RL[round][w]] + KL[round], SL[round][w]) + EL;        AL = EL; EL = DL; DL = rol32(CL, 10); CL = BL; BL = T;    }    for (w = 0; w < 16; w++) { /* right line */        T = rol32(AR + F3(BR, CR, DR) + X[RR[round][w]] + KR[round], SR[round][w]) + ER;        AR = ER; ER = DR; DR = rol32(CR, 10); CR = BR; BR = T;    }    /* Round 4 */    round++;    for (w = 0; w < 16; w++) { /* left line */        T = rol32(AL + F4(BL, CL, DL) + X[RL[round][w]] + KL[round], SL[round][w]) + EL;        AL = EL; EL = DL; DL = rol32(CL, 10); CL = BL; BL = T;    }    for (w = 0; w < 16; w++) { /* right line */        T = rol32(AR + F2(BR, CR, DR) + X[RR[round][w]] + KR[round], SR[round][w]) + ER;        AR = ER; ER = DR; DR = rol32(CR, 10); CR = BR; BR = T;    }    /* Round 5 */    round++;    for (w = 0; w < 16; w++) { /* left line */        T = rol32(AL + F5(BL, CL, DL) + X[RL[round][w]] + KL[round], SL[round][w]) + EL;        AL = EL; EL = DL; DL = rol32(CL, 10); CL = BL; BL = T;    }    for (w = 0; w < 16; w++) { /* right line */        T = rol32(AR + F1(BR, CR, DR) + X[RR[round][w]] + KR[round], SR[round][w]) + ER;        AR = ER; ER = DR; DR = rol32(CR, 10); CR = BR; BR = T;    }    /* Final mixing stage */    T = ctx->h[1] + CL + DR;    ctx->h[1] = ctx->h[2] + DL + ER;    ctx->h[2] = ctx->h[3] + EL + AR;    ctx->h[3] = ctx->h[4] + AL + BR;    ctx->h[4] = ctx->h[0] + BL + CR;    ctx->h[0] = T;}