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

void CAST128::Dec::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const{	word32 t, l, r;	/* Get inblock into l,r */	Block::Get(inBlock)(r)(l);	/* Only do full 16 rounds if key length > 80 bits */	if (!reduced) {		F1(r, l, 15, 16);		F3(l, r, 14, 16);		F2(r, l, 13, 16);		F1(l, r, 12, 16);	}	F3(r, l, 11, 16);	F2(l, r, 10, 16);	F1(r, l,  9, 16);	F3(l, r,  8, 16);	F2(r, l,  7, 16);	F1(l, r,  6, 16);	F3(r, l,  5, 16);	F2(l, r,  4, 16);	F1(r, l,  3, 16);	F3(l, r,  2, 16);	F2(r, l,  1, 16);	F1(l, r,  0, 16);	/* Put l,r into outblock */	Block::Put(xorBlock, outBlock)(l)(r);	/* Wipe clean */	t = l = r = 0;}

  FOR_BLOCKS(length, dst, src, CAST128_BLOCK_SIZE)    {      uint32_t t, l, r;      /* Get inblock into l,r */      l = READ_UINT32(src);      r = READ_UINT32(src+4);      /* Do the work */      F1(l, r,  0);      F2(r, l,  1);      F3(l, r,  2);      F1(r, l,  3);      F2(l, r,  4);      F3(r, l,  5);      F1(l, r,  6);      F2(r, l,  7);      F3(l, r,  8);      F1(r, l,  9);      F2(l, r, 10);      F3(r, l, 11);      /* Only do full 16 rounds if key length > 80 bits */      if (ctx->rounds > 12) {	F1(l, r, 12);	F2(r, l, 13);	F3(l, r, 14);	F1(r, l, 15);      }      /* Put l,r into outblock */      WRITE_UINT32(dst, r);      WRITE_UINT32(dst + 4, l);      /* Wipe clean */      t = l = r = 0;    }

void CAST256::W(const uint8_t i){    g ^= F1(h, Tm[0][i], Tr[0][i]);    f ^= F2(g, Tm[1][i], Tr[1][i]);    e ^= F3(f, Tm[2][i], Tr[2][i]);    d ^= F1(e, Tm[3][i], Tr[3][i]);    c ^= F2(d, Tm[4][i], Tr[4][i]);    b ^= F3(c, Tm[5][i], Tr[5][i]);    a ^= F1(b, Tm[6][i], Tr[6][i]);    h ^= F2(a, Tm[7][i], Tr[7][i]);}

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

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

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;		}	}}

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);}

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;}

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);}

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 test_main(int,char *[]){    bu::quantity<mixed_length> a1(2.0 * mixed_length());    bu::quantity<si_area> a2(a1);    BOOST_CHECK((std::abs(a2.value() - .02) < .0001));    bu::quantity<mixed_length> a3(a2);    BOOST_CHECK((std::abs(a3.value() - 2.0) < .0001));    bu::quantity<mixed_energy_1> e1(2.0 * mixed_energy_1());    bu::quantity<mixed_energy_2> e2(e1);    BOOST_CHECK((std::abs(e2.value() - 20.0) < .0001));    bu::quantity<bu::si::energy> e3(e1);    BOOST_CHECK((std::abs(e3.value() - .0002) < .0001));    bu::quantity<mixed_energy_2> e4(e3);    BOOST_CHECK((std::abs(e4.value() - 20.0) < .0001));    bu::quantity<bu::cgs::force> F0 = 20 * bu::cgs::dyne;    BOOST_CHECK((std::abs(F0.value() - 20.0) < .0001));    bu::quantity<bu::si::force> F3(F0);    BOOST_CHECK((std::abs(F3.value() - 2.0e-4) < .000000001));    bu::quantity<bu::si::force> F5(20 * bu::cgs::dyne);    BOOST_CHECK((std::abs(F5.value() - 2.0e-4) < .000000001));    bu::quantity<bu::si::dimensionless> dimensionless_test1(1.0*bu::cgs::dyne/bu::si::newton);    BOOST_CHECK(dimensionless_test1 == 1e-5);    typedef bu::multiply_typeof_helper<bu::si::length, bu::cgs::length>::type m_cm;    typedef bu::divide_typeof_helper<m_cm, m_cm>::type heterogeneous_dimensionless;    bu::quantity<heterogeneous_dimensionless> dimensionless_test2(1.0*bu::cgs::dyne/bu::si::newton);    BOOST_CHECK(dimensionless_test2.value() == 1e-5);    bu::quantity<bu::divide_typeof_helper<bu::cgs::force, bu::si::force>::type> dimensionless_test3(dimensionless_test2);    BOOST_UNITS_CHECK_CLOSE(dimensionless_test3.value(), 1.0);    //m/cm -> g/kg    bu::quantity<bu::divide_typeof_helper<bu::si::length, bu::cgs::length>::type> dimensionless_test4(2.0 * bu::si::meters / bu::cgs::centimeters);    bu::quantity<bu::divide_typeof_helper<bu::cgs::mass, bu::si::mass>::type> dimensionless_test5(dimensionless_test4);    BOOST_UNITS_CHECK_CLOSE(dimensionless_test5.value(), 2e5);    return(0);}

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);}

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

static voidpsc_balance_sub_communicate_fields(struct psc_balance *bal, struct communicate_ctx *ctx,				   struct psc_mfields *mflds_old, struct psc_mfields *mflds_new){  //HACK: Don't communicate output fields if they don't correspond to the domain  //This is needed e.g. for the boosted output which handles its MPI communication internally  //printf("Field: %s/n", flds->f[0].name);    if (ctx->nr_patches_old != mflds_old->nr_patches /* || strncmp(flds->f[0].name, "lab", 3) == 0 */) return;	  assert(ctx->nr_patches_old == mflds_old->nr_patches);  assert(ctx->nr_patches_old > 0);    // send from old local patches  MPI_Request *send_reqs = calloc(ctx->nr_patches_old, sizeof(*send_reqs));  int *nr_patches_new_by_rank = calloc(ctx->mpi_size, sizeof(*nr_patches_new_by_rank));  for (int p = 0; p < ctx->nr_patches_old; p++) {    int new_rank = ctx->send_info[p].rank;    if (new_rank == ctx->mpi_rank || new_rank < 0) {      send_reqs[p] = MPI_REQUEST_NULL;    } else {      fields_t *pf_old = psc_mfields_get_patch(mflds_old, p);      int nn = psc_fields_size(pf_old) * pf_old->nr_comp;      int *ib = pf_old->ib;      void *addr_old = &F3(pf_old, 0, ib[0], ib[1], ib[2]);      int tag = nr_patches_new_by_rank[new_rank]++;      MPI_Isend(addr_old, nn, MPI_FIELDS_REAL, new_rank, tag, ctx->comm, &send_reqs[p]);    }  }  free(nr_patches_new_by_rank);  // recv for new local patches  MPI_Request *recv_reqs = calloc(ctx->nr_patches_new, sizeof(*recv_reqs));  int *nr_patches_old_by_rank = calloc(ctx->mpi_size, sizeof(*nr_patches_new_by_rank));  for (int p = 0; p < ctx->nr_patches_new; p++) {    int old_rank = ctx->recv_info[p].rank;    if (old_rank == ctx->mpi_rank) {      recv_reqs[p] = MPI_REQUEST_NULL;    } else if (old_rank < 0) { //this patch did not exist before      recv_reqs[p] = MPI_REQUEST_NULL;      //Seed new data    } else {      fields_t *pf_new = psc_mfields_get_patch(mflds_new, p);      int nn = psc_fields_size(pf_new) * pf_new->nr_comp;      int *ib = pf_new->ib;      void *addr_new = &F3(pf_new, 0, ib[0], ib[1], ib[2]);      int tag = nr_patches_old_by_rank[old_rank]++;      MPI_Irecv(addr_new, nn, MPI_FIELDS_REAL, old_rank,		tag, ctx->comm, &recv_reqs[p]);    }  }  free(nr_patches_old_by_rank);  static int pr;  if (!pr) {    pr = prof_register("bal flds local", 1., 0, 0);  }  prof_start(pr);  // local fields  // OPT: could keep the alloced arrays, just move pointers...  for (int p = 0; p < ctx->nr_patches_new; p++) {    if (ctx->recv_info[p].rank != ctx->mpi_rank) {      continue;    }    fields_t *pf_old = psc_mfields_get_patch(mflds_old, ctx->recv_info[p].patch);    fields_t *pf_new = psc_mfields_get_patch(mflds_new, p);    assert(pf_old->nr_comp == pf_new->nr_comp);    assert(psc_fields_size(pf_old) == psc_fields_size(pf_new));    int size = psc_fields_size(pf_old) * pf_old->nr_comp;    int *ib = pf_new->ib;    void *addr_new = &F3(pf_new, 0, ib[0], ib[1], ib[2]);    void *addr_old = &F3(pf_old, 0, ib[0], ib[1], ib[2]);    memcpy(addr_new, addr_old, size * sizeof(fields_real_t));  }  prof_stop(pr);  MPI_Waitall(ctx->nr_patches_old, send_reqs, MPI_STATUSES_IGNORE);  MPI_Waitall(ctx->nr_patches_new, recv_reqs, MPI_STATUSES_IGNORE);  free(send_reqs);  free(recv_reqs);}

/* The RIPEMD160 compression function.  Operates on self->buf */static void ripemd160_compress(hash_state *self){    unsigned 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 bufw[16];    for (w=0; w<16; w++)        bufw[w] = LOAD_U32_LITTLE(&self->buf[w*4]);    /* Load the left and right lines with the initial state */    AL = AR = self->h[0];    BL = BR = self->h[1];    CL = CR = self->h[2];    DL = DR = self->h[3];    EL = ER = self->h[4];    /* Round 1 */    round = 0;    for (w = 0; w < 16; w++) { /* left line */        T = ROL(SL[round][w], AL + F1(BL, CL, DL) + bufw[RL[round][w]] + KL[round]) + EL;        AL = EL; EL = DL; DL = ROL(10, CL); CL = BL; BL = T;    }    for (w = 0; w < 16; w++) { /* right line */        T = ROL(SR[round][w], AR + F5(BR, CR, DR) + bufw[RR[round][w]] + KR[round]) + ER;        AR = ER; ER = DR; DR = ROL(10, CR); CR = BR; BR = T;    }    /* Round 2 */    round++;    for (w = 0; w < 16; w++) { /* left line */        T = ROL(SL[round][w], AL + F2(BL, CL, DL) + bufw[RL[round][w]] + KL[round]) + EL;        AL = EL; EL = DL; DL = ROL(10, CL); CL = BL; BL = T;    }    for (w = 0; w < 16; w++) { /* right line */        T = ROL(SR[round][w], AR + F4(BR, CR, DR) + bufw[RR[round][w]] + KR[round]) + ER;        AR = ER; ER = DR; DR = ROL(10, CR); CR = BR; BR = T;    }    /* Round 3 */    round++;    for (w = 0; w < 16; w++) { /* left line */        T = ROL(SL[round][w], AL + F3(BL, CL, DL) + bufw[RL[round][w]] + KL[round]) + EL;        AL = EL; EL = DL; DL = ROL(10, CL); CL = BL; BL = T;    }    for (w = 0; w < 16; w++) { /* right line */        T = ROL(SR[round][w], AR + F3(BR, CR, DR) + bufw[RR[round][w]] + KR[round]) + ER;        AR = ER; ER = DR; DR = ROL(10, CR); CR = BR; BR = T;    }    /* Round 4 */    round++;    for (w = 0; w < 16; w++) { /* left line */        T = ROL(SL[round][w], AL + F4(BL, CL, DL) + bufw[RL[round][w]] + KL[round]) + EL;        AL = EL; EL = DL; DL = ROL(10, CL); CL = BL; BL = T;    }    for (w = 0; w < 16; w++) { /* right line */        T = ROL(SR[round][w], AR + F2(BR, CR, DR) + bufw[RR[round][w]] + KR[round]) + ER;        AR = ER; ER = DR; DR = ROL(10, CR); CR = BR; BR = T;    }    /* Round 5 */    round++;    for (w = 0; w < 16; w++) { /* left line */        T = ROL(SL[round][w], AL + F5(BL, CL, DL) + bufw[RL[round][w]] + KL[round]) + EL;        AL = EL; EL = DL; DL = ROL(10, CL); CL = BL; BL = T;    }    for (w = 0; w < 16; w++) { /* right line */        T = ROL(SR[round][w], AR + F1(BR, CR, DR) + bufw[RR[round][w]] + KR[round]) + ER;        AR = ER; ER = DR; DR = ROL(10, CR); CR = BR; BR = T;    }    /* Final mixing stage */    T = self->h[1] + CL + DR;    self->h[1] = self->h[2] + DL + ER;    self->h[2] = self->h[3] + EL + AR;    self->h[3] = self->h[4] + AL + BR;    self->h[4] = self->h[0] + BL + CR;    self->h[0] = T;    /* Clear the buffer and wipe the temporary variables */    T = AL = BL = CL = DL = EL = AR = BR = CR = DR = ER = 0;    memset(&self->buf, 0, sizeof(self->buf));    self->bufpos = 0;}

		binary_composer(F1 f1 = F1(), F2 f2 = F2(), F3 f3 = F3())			: _f1(f1), _f2(f2), _f3(f3)		{}

/** RIPEMD-128 Compression Function*/void RIPEMD_128::compress_n(const byte input[], u32bit blocks)   {   for(u32bit i = 0; i != blocks; ++i)      {      for(u32bit j = 0; j != 16; ++j)         M[j] = load_le<u32bit>(input, j);      input += HASH_BLOCK_SIZE;      u32bit A1 = digest[0], A2 = A1, B1 = digest[1], B2 = B1,         C1 = digest[2], C2 = C1, D1 = digest[3], D2 = D1;      const u32bit MAGIC2 = 0x5A827999, MAGIC3 = 0x6ED9EBA1,         MAGIC4 = 0x8F1BBCDC, MAGIC5 = 0x50A28BE6,         MAGIC6 = 0x5C4DD124, MAGIC7 = 0x6D703EF3;      F1(A1,B1,C1,D1,M[ 0],11       );   F4(A2,B2,C2,D2,M[ 5], 8,MAGIC5);      F1(D1,A1,B1,C1,M[ 1],14       );   F4(D2,A2,B2,C2,M[14], 9,MAGIC5);      F1(C1,D1,A1,B1,M[ 2],15       );   F4(C2,D2,A2,B2,M[ 7], 9,MAGIC5);      F1(B1,C1,D1,A1,M[ 3],12       );   F4(B2,C2,D2,A2,M[ 0],11,MAGIC5);      F1(A1,B1,C1,D1,M[ 4], 5       );   F4(A2,B2,C2,D2,M[ 9],13,MAGIC5);      F1(D1,A1,B1,C1,M[ 5], 8       );   F4(D2,A2,B2,C2,M[ 2],15,MAGIC5);      F1(C1,D1,A1,B1,M[ 6], 7       );   F4(C2,D2,A2,B2,M[11],15,MAGIC5);      F1(B1,C1,D1,A1,M[ 7], 9       );   F4(B2,C2,D2,A2,M[ 4], 5,MAGIC5);      F1(A1,B1,C1,D1,M[ 8],11       );   F4(A2,B2,C2,D2,M[13], 7,MAGIC5);      F1(D1,A1,B1,C1,M[ 9],13       );   F4(D2,A2,B2,C2,M[ 6], 7,MAGIC5);      F1(C1,D1,A1,B1,M[10],14       );   F4(C2,D2,A2,B2,M[15], 8,MAGIC5);      F1(B1,C1,D1,A1,M[11],15       );   F4(B2,C2,D2,A2,M[ 8],11,MAGIC5);      F1(A1,B1,C1,D1,M[12], 6       );   F4(A2,B2,C2,D2,M[ 1],14,MAGIC5);      F1(D1,A1,B1,C1,M[13], 7       );   F4(D2,A2,B2,C2,M[10],14,MAGIC5);      F1(C1,D1,A1,B1,M[14], 9       );   F4(C2,D2,A2,B2,M[ 3],12,MAGIC5);      F1(B1,C1,D1,A1,M[15], 8       );   F4(B2,C2,D2,A2,M[12], 6,MAGIC5);      F2(A1,B1,C1,D1,M[ 7], 7,MAGIC2);   F3(A2,B2,C2,D2,M[ 6], 9,MAGIC6);      F2(D1,A1,B1,C1,M[ 4], 6,MAGIC2);   F3(D2,A2,B2,C2,M[11],13,MAGIC6);      F2(C1,D1,A1,B1,M[13], 8,MAGIC2);   F3(C2,D2,A2,B2,M[ 3],15,MAGIC6);      F2(B1,C1,D1,A1,M[ 1],13,MAGIC2);   F3(B2,C2,D2,A2,M[ 7], 7,MAGIC6);      F2(A1,B1,C1,D1,M[10],11,MAGIC2);   F3(A2,B2,C2,D2,M[ 0],12,MAGIC6);      F2(D1,A1,B1,C1,M[ 6], 9,MAGIC2);   F3(D2,A2,B2,C2,M[13], 8,MAGIC6);      F2(C1,D1,A1,B1,M[15], 7,MAGIC2);   F3(C2,D2,A2,B2,M[ 5], 9,MAGIC6);      F2(B1,C1,D1,A1,M[ 3],15,MAGIC2);   F3(B2,C2,D2,A2,M[10],11,MAGIC6);      F2(A1,B1,C1,D1,M[12], 7,MAGIC2);   F3(A2,B2,C2,D2,M[14], 7,MAGIC6);      F2(D1,A1,B1,C1,M[ 0],12,MAGIC2);   F3(D2,A2,B2,C2,M[15], 7,MAGIC6);      F2(C1,D1,A1,B1,M[ 9],15,MAGIC2);   F3(C2,D2,A2,B2,M[ 8],12,MAGIC6);      F2(B1,C1,D1,A1,M[ 5], 9,MAGIC2);   F3(B2,C2,D2,A2,M[12], 7,MAGIC6);      F2(A1,B1,C1,D1,M[ 2],11,MAGIC2);   F3(A2,B2,C2,D2,M[ 4], 6,MAGIC6);      F2(D1,A1,B1,C1,M[14], 7,MAGIC2);   F3(D2,A2,B2,C2,M[ 9],15,MAGIC6);      F2(C1,D1,A1,B1,M[11],13,MAGIC2);   F3(C2,D2,A2,B2,M[ 1],13,MAGIC6);      F2(B1,C1,D1,A1,M[ 8],12,MAGIC2);   F3(B2,C2,D2,A2,M[ 2],11,MAGIC6);      F3(A1,B1,C1,D1,M[ 3],11,MAGIC3);   F2(A2,B2,C2,D2,M[15], 9,MAGIC7);      F3(D1,A1,B1,C1,M[10],13,MAGIC3);   F2(D2,A2,B2,C2,M[ 5], 7,MAGIC7);      F3(C1,D1,A1,B1,M[14], 6,MAGIC3);   F2(C2,D2,A2,B2,M[ 1],15,MAGIC7);      F3(B1,C1,D1,A1,M[ 4], 7,MAGIC3);   F2(B2,C2,D2,A2,M[ 3],11,MAGIC7);      F3(A1,B1,C1,D1,M[ 9],14,MAGIC3);   F2(A2,B2,C2,D2,M[ 7], 8,MAGIC7);      F3(D1,A1,B1,C1,M[15], 9,MAGIC3);   F2(D2,A2,B2,C2,M[14], 6,MAGIC7);      F3(C1,D1,A1,B1,M[ 8],13,MAGIC3);   F2(C2,D2,A2,B2,M[ 6], 6,MAGIC7);      F3(B1,C1,D1,A1,M[ 1],15,MAGIC3);   F2(B2,C2,D2,A2,M[ 9],14,MAGIC7);      F3(A1,B1,C1,D1,M[ 2],14,MAGIC3);   F2(A2,B2,C2,D2,M[11],12,MAGIC7);      F3(D1,A1,B1,C1,M[ 7], 8,MAGIC3);   F2(D2,A2,B2,C2,M[ 8],13,MAGIC7);      F3(C1,D1,A1,B1,M[ 0],13,MAGIC3);   F2(C2,D2,A2,B2,M[12], 5,MAGIC7);      F3(B1,C1,D1,A1,M[ 6], 6,MAGIC3);   F2(B2,C2,D2,A2,M[ 2],14,MAGIC7);      F3(A1,B1,C1,D1,M[13], 5,MAGIC3);   F2(A2,B2,C2,D2,M[10],13,MAGIC7);      F3(D1,A1,B1,C1,M[11],12,MAGIC3);   F2(D2,A2,B2,C2,M[ 0],13,MAGIC7);      F3(C1,D1,A1,B1,M[ 5], 7,MAGIC3);   F2(C2,D2,A2,B2,M[ 4], 7,MAGIC7);      F3(B1,C1,D1,A1,M[12], 5,MAGIC3);   F2(B2,C2,D2,A2,M[13], 5,MAGIC7);      F4(A1,B1,C1,D1,M[ 1],11,MAGIC4);   F1(A2,B2,C2,D2,M[ 8],15       );      F4(D1,A1,B1,C1,M[ 9],12,MAGIC4);   F1(D2,A2,B2,C2,M[ 6], 5       );      F4(C1,D1,A1,B1,M[11],14,MAGIC4);   F1(C2,D2,A2,B2,M[ 4], 8       );      F4(B1,C1,D1,A1,M[10],15,MAGIC4);   F1(B2,C2,D2,A2,M[ 1],11       );      F4(A1,B1,C1,D1,M[ 0],14,MAGIC4);   F1(A2,B2,C2,D2,M[ 3],14       );      F4(D1,A1,B1,C1,M[ 8],15,MAGIC4);   F1(D2,A2,B2,C2,M[11],14       );      F4(C1,D1,A1,B1,M[12], 9,MAGIC4);   F1(C2,D2,A2,B2,M[15], 6       );      F4(B1,C1,D1,A1,M[ 4], 8,MAGIC4);   F1(B2,C2,D2,A2,M[ 0],14       );      F4(A1,B1,C1,D1,M[13], 9,MAGIC4);   F1(A2,B2,C2,D2,M[ 5], 6       );      F4(D1,A1,B1,C1,M[ 3],14,MAGIC4);   F1(D2,A2,B2,C2,M[12], 9       );      F4(C1,D1,A1,B1,M[ 7], 5,MAGIC4);   F1(C2,D2,A2,B2,M[ 2],12       );      F4(B1,C1,D1,A1,M[15], 6,MAGIC4);   F1(B2,C2,D2,A2,M[13], 9       );      F4(A1,B1,C1,D1,M[14], 8,MAGIC4);   F1(A2,B2,C2,D2,M[ 9],12       );      F4(D1,A1,B1,C1,M[ 5], 6,MAGIC4);   F1(D2,A2,B2,C2,M[ 7], 5       );      F4(C1,D1,A1,B1,M[ 6], 5,MAGIC4);   F1(C2,D2,A2,B2,M[10],15       );      F4(B1,C1,D1,A1,M[ 2],12,MAGIC4);   F1(B2,C2,D2,A2,M[14], 8       );      D2        = digest[1] + C1 + D2; digest[1] = digest[2] + D1 + A2;      digest[2] = digest[3] + A1 + B2; digest[3] = digest[0] + B1 + C2;      digest[0] = D2;      }   }

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);}

/** RIPEMD-160 Compression Function*/void RIPEMD_160::compress_n(const uint8_t input[], size_t blocks)   {   const uint32_t MAGIC2 = 0x5A827999, MAGIC3 = 0x6ED9EBA1,                MAGIC4 = 0x8F1BBCDC, MAGIC5 = 0xA953FD4E,                MAGIC6 = 0x50A28BE6, MAGIC7 = 0x5C4DD124,                MAGIC8 = 0x6D703EF3, MAGIC9 = 0x7A6D76E9;   for(size_t i = 0; i != blocks; ++i)      {      load_le(m_M.data(), input, m_M.size());      uint32_t A1 = m_digest[0], A2 = A1, B1 = m_digest[1], B2 = B1,             C1 = m_digest[2], C2 = C1, D1 = m_digest[3], D2 = D1,             E1 = m_digest[4], E2 = E1;      F1(A1,B1,C1,D1,E1,m_M[ 0],11       );  F5(A2,B2,C2,D2,E2,m_M[ 5], 8,MAGIC6);      F1(E1,A1,B1,C1,D1,m_M[ 1],14       );  F5(E2,A2,B2,C2,D2,m_M[14], 9,MAGIC6);      F1(D1,E1,A1,B1,C1,m_M[ 2],15       );  F5(D2,E2,A2,B2,C2,m_M[ 7], 9,MAGIC6);      F1(C1,D1,E1,A1,B1,m_M[ 3],12       );  F5(C2,D2,E2,A2,B2,m_M[ 0],11,MAGIC6);      F1(B1,C1,D1,E1,A1,m_M[ 4], 5       );  F5(B2,C2,D2,E2,A2,m_M[ 9],13,MAGIC6);      F1(A1,B1,C1,D1,E1,m_M[ 5], 8       );  F5(A2,B2,C2,D2,E2,m_M[ 2],15,MAGIC6);      F1(E1,A1,B1,C1,D1,m_M[ 6], 7       );  F5(E2,A2,B2,C2,D2,m_M[11],15,MAGIC6);      F1(D1,E1,A1,B1,C1,m_M[ 7], 9       );  F5(D2,E2,A2,B2,C2,m_M[ 4], 5,MAGIC6);      F1(C1,D1,E1,A1,B1,m_M[ 8],11       );  F5(C2,D2,E2,A2,B2,m_M[13], 7,MAGIC6);      F1(B1,C1,D1,E1,A1,m_M[ 9],13       );  F5(B2,C2,D2,E2,A2,m_M[ 6], 7,MAGIC6);      F1(A1,B1,C1,D1,E1,m_M[10],14       );  F5(A2,B2,C2,D2,E2,m_M[15], 8,MAGIC6);      F1(E1,A1,B1,C1,D1,m_M[11],15       );  F5(E2,A2,B2,C2,D2,m_M[ 8],11,MAGIC6);      F1(D1,E1,A1,B1,C1,m_M[12], 6       );  F5(D2,E2,A2,B2,C2,m_M[ 1],14,MAGIC6);      F1(C1,D1,E1,A1,B1,m_M[13], 7       );  F5(C2,D2,E2,A2,B2,m_M[10],14,MAGIC6);      F1(B1,C1,D1,E1,A1,m_M[14], 9       );  F5(B2,C2,D2,E2,A2,m_M[ 3],12,MAGIC6);      F1(A1,B1,C1,D1,E1,m_M[15], 8       );  F5(A2,B2,C2,D2,E2,m_M[12], 6,MAGIC6);      F2(E1,A1,B1,C1,D1,m_M[ 7], 7,MAGIC2);  F4(E2,A2,B2,C2,D2,m_M[ 6], 9,MAGIC7);      F2(D1,E1,A1,B1,C1,m_M[ 4], 6,MAGIC2);  F4(D2,E2,A2,B2,C2,m_M[11],13,MAGIC7);      F2(C1,D1,E1,A1,B1,m_M[13], 8,MAGIC2);  F4(C2,D2,E2,A2,B2,m_M[ 3],15,MAGIC7);      F2(B1,C1,D1,E1,A1,m_M[ 1],13,MAGIC2);  F4(B2,C2,D2,E2,A2,m_M[ 7], 7,MAGIC7);      F2(A1,B1,C1,D1,E1,m_M[10],11,MAGIC2);  F4(A2,B2,C2,D2,E2,m_M[ 0],12,MAGIC7);      F2(E1,A1,B1,C1,D1,m_M[ 6], 9,MAGIC2);  F4(E2,A2,B2,C2,D2,m_M[13], 8,MAGIC7);      F2(D1,E1,A1,B1,C1,m_M[15], 7,MAGIC2);  F4(D2,E2,A2,B2,C2,m_M[ 5], 9,MAGIC7);      F2(C1,D1,E1,A1,B1,m_M[ 3],15,MAGIC2);  F4(C2,D2,E2,A2,B2,m_M[10],11,MAGIC7);      F2(B1,C1,D1,E1,A1,m_M[12], 7,MAGIC2);  F4(B2,C2,D2,E2,A2,m_M[14], 7,MAGIC7);      F2(A1,B1,C1,D1,E1,m_M[ 0],12,MAGIC2);  F4(A2,B2,C2,D2,E2,m_M[15], 7,MAGIC7);      F2(E1,A1,B1,C1,D1,m_M[ 9],15,MAGIC2);  F4(E2,A2,B2,C2,D2,m_M[ 8],12,MAGIC7);      F2(D1,E1,A1,B1,C1,m_M[ 5], 9,MAGIC2);  F4(D2,E2,A2,B2,C2,m_M[12], 7,MAGIC7);      F2(C1,D1,E1,A1,B1,m_M[ 2],11,MAGIC2);  F4(C2,D2,E2,A2,B2,m_M[ 4], 6,MAGIC7);      F2(B1,C1,D1,E1,A1,m_M[14], 7,MAGIC2);  F4(B2,C2,D2,E2,A2,m_M[ 9],15,MAGIC7);      F2(A1,B1,C1,D1,E1,m_M[11],13,MAGIC2);  F4(A2,B2,C2,D2,E2,m_M[ 1],13,MAGIC7);      F2(E1,A1,B1,C1,D1,m_M[ 8],12,MAGIC2);  F4(E2,A2,B2,C2,D2,m_M[ 2],11,MAGIC7);      F3(D1,E1,A1,B1,C1,m_M[ 3],11,MAGIC3);  F3(D2,E2,A2,B2,C2,m_M[15], 9,MAGIC8);      F3(C1,D1,E1,A1,B1,m_M[10],13,MAGIC3);  F3(C2,D2,E2,A2,B2,m_M[ 5], 7,MAGIC8);      F3(B1,C1,D1,E1,A1,m_M[14], 6,MAGIC3);  F3(B2,C2,D2,E2,A2,m_M[ 1],15,MAGIC8);      F3(A1,B1,C1,D1,E1,m_M[ 4], 7,MAGIC3);  F3(A2,B2,C2,D2,E2,m_M[ 3],11,MAGIC8);      F3(E1,A1,B1,C1,D1,m_M[ 9],14,MAGIC3);  F3(E2,A2,B2,C2,D2,m_M[ 7], 8,MAGIC8);      F3(D1,E1,A1,B1,C1,m_M[15], 9,MAGIC3);  F3(D2,E2,A2,B2,C2,m_M[14], 6,MAGIC8);      F3(C1,D1,E1,A1,B1,m_M[ 8],13,MAGIC3);  F3(C2,D2,E2,A2,B2,m_M[ 6], 6,MAGIC8);      F3(B1,C1,D1,E1,A1,m_M[ 1],15,MAGIC3);  F3(B2,C2,D2,E2,A2,m_M[ 9],14,MAGIC8);      F3(A1,B1,C1,D1,E1,m_M[ 2],14,MAGIC3);  F3(A2,B2,C2,D2,E2,m_M[11],12,MAGIC8);      F3(E1,A1,B1,C1,D1,m_M[ 7], 8,MAGIC3);  F3(E2,A2,B2,C2,D2,m_M[ 8],13,MAGIC8);      F3(D1,E1,A1,B1,C1,m_M[ 0],13,MAGIC3);  F3(D2,E2,A2,B2,C2,m_M[12], 5,MAGIC8);      F3(C1,D1,E1,A1,B1,m_M[ 6], 6,MAGIC3);  F3(C2,D2,E2,A2,B2,m_M[ 2],14,MAGIC8);      F3(B1,C1,D1,E1,A1,m_M[13], 5,MAGIC3);  F3(B2,C2,D2,E2,A2,m_M[10],13,MAGIC8);      F3(A1,B1,C1,D1,E1,m_M[11],12,MAGIC3);  F3(A2,B2,C2,D2,E2,m_M[ 0],13,MAGIC8);      F3(E1,A1,B1,C1,D1,m_M[ 5], 7,MAGIC3);  F3(E2,A2,B2,C2,D2,m_M[ 4], 7,MAGIC8);      F3(D1,E1,A1,B1,C1,m_M[12], 5,MAGIC3);  F3(D2,E2,A2,B2,C2,m_M[13], 5,MAGIC8);      F4(C1,D1,E1,A1,B1,m_M[ 1],11,MAGIC4);  F2(C2,D2,E2,A2,B2,m_M[ 8],15,MAGIC9);      F4(B1,C1,D1,E1,A1,m_M[ 9],12,MAGIC4);  F2(B2,C2,D2,E2,A2,m_M[ 6], 5,MAGIC9);      F4(A1,B1,C1,D1,E1,m_M[11],14,MAGIC4);  F2(A2,B2,C2,D2,E2,m_M[ 4], 8,MAGIC9);      F4(E1,A1,B1,C1,D1,m_M[10],15,MAGIC4);  F2(E2,A2,B2,C2,D2,m_M[ 1],11,MAGIC9);      F4(D1,E1,A1,B1,C1,m_M[ 0],14,MAGIC4);  F2(D2,E2,A2,B2,C2,m_M[ 3],14,MAGIC9);      F4(C1,D1,E1,A1,B1,m_M[ 8],15,MAGIC4);  F2(C2,D2,E2,A2,B2,m_M[11],14,MAGIC9);      F4(B1,C1,D1,E1,A1,m_M[12], 9,MAGIC4);  F2(B2,C2,D2,E2,A2,m_M[15], 6,MAGIC9);      F4(A1,B1,C1,D1,E1,m_M[ 4], 8,MAGIC4);  F2(A2,B2,C2,D2,E2,m_M[ 0],14,MAGIC9);      F4(E1,A1,B1,C1,D1,m_M[13], 9,MAGIC4);  F2(E2,A2,B2,C2,D2,m_M[ 5], 6,MAGIC9);      F4(D1,E1,A1,B1,C1,m_M[ 3],14,MAGIC4);  F2(D2,E2,A2,B2,C2,m_M[12], 9,MAGIC9);      F4(C1,D1,E1,A1,B1,m_M[ 7], 5,MAGIC4);  F2(C2,D2,E2,A2,B2,m_M[ 2],12,MAGIC9);      F4(B1,C1,D1,E1,A1,m_M[15], 6,MAGIC4);  F2(B2,C2,D2,E2,A2,m_M[13], 9,MAGIC9);      F4(A1,B1,C1,D1,E1,m_M[14], 8,MAGIC4);  F2(A2,B2,C2,D2,E2,m_M[ 9],12,MAGIC9);      F4(E1,A1,B1,C1,D1,m_M[ 5], 6,MAGIC4);  F2(E2,A2,B2,C2,D2,m_M[ 7], 5,MAGIC9);      F4(D1,E1,A1,B1,C1,m_M[ 6], 5,MAGIC4);  F2(D2,E2,A2,B2,C2,m_M[10],15,MAGIC9);      F4(C1,D1,E1,A1,B1,m_M[ 2],12,MAGIC4);  F2(C2,D2,E2,A2,B2,m_M[14], 8,MAGIC9);      F5(B1,C1,D1,E1,A1,m_M[ 4], 9,MAGIC5);  F1(B2,C2,D2,E2,A2,m_M[12], 8       );      F5(A1,B1,C1,D1,E1,m_M[ 0],15,MAGIC5);  F1(A2,B2,C2,D2,E2,m_M[15], 5       );      F5(E1,A1,B1,C1,D1,m_M[ 5], 5,MAGIC5);  F1(E2,A2,B2,C2,D2,m_M[10],12       );      F5(D1,E1,A1,B1,C1,m_M[ 9],11,MAGIC5);  F1(D2,E2,A2,B2,C2,m_M[ 4], 9       );      F5(C1,D1,E1,A1,B1,m_M[ 7], 6,MAGIC5);  F1(C2,D2,E2,A2,B2,m_M[ 1],12       );      F5(B1,C1,D1,E1,A1,m_M[12], 8,MAGIC5);  F1(B2,C2,D2,E2,A2,m_M[ 5], 5       );      F5(A1,B1,C1,D1,E1,m_M[ 2],13,MAGIC5);  F1(A2,B2,C2,D2,E2,m_M[ 8],14       );      F5(E1,A1,B1,C1,D1,m_M[10],12,MAGIC5);  F1(E2,A2,B2,C2,D2,m_M[ 7], 6       );      F5(D1,E1,A1,B1,C1,m_M[14], 5,MAGIC5);  F1(D2,E2,A2,B2,C2,m_M[ 6], 8       );      F5(C1,D1,E1,A1,B1,m_M[ 1],12,MAGIC5);  F1(C2,D2,E2,A2,B2,m_M[ 2],13       );      F5(B1,C1,D1,E1,A1,m_M[ 3],13,MAGIC5);  F1(B2,C2,D2,E2,A2,m_M[13], 6       );      F5(A1,B1,C1,D1,E1,m_M[ 8],14,MAGIC5);  F1(A2,B2,C2,D2,E2,m_M[14], 5       );      F5(E1,A1,B1,C1,D1,m_M[11],11,MAGIC5);  F1(E2,A2,B2,C2,D2,m_M[ 0],15       );      F5(D1,E1,A1,B1,C1,m_M[ 6], 8,MAGIC5);  F1(D2,E2,A2,B2,C2,m_M[ 3],13       );//.........这里部分代码省略.........

static void sha_transform(SshSHAContext *context, const unsigned char *block){  static SshUInt32 W[80];  SshUInt32 a, b, c, d, e, f;  a = context->A;  b = context->B;  c = context->C;  d = context->D;  e = context->E;#if 1    /* Unroll as much as one can, removing unneccessary copying etc.     What actually happens is that the compiler must interleave all these     operations some efficient way. On processors with only few registers     it might be better to implement the table generation before actual     'nonlinear' operations. On Intel processors that might be the case,     although one never knows without trying. */#define TABLE_IN(i)                  /  W[i] = SSH_GET_32BIT(block); block += 4;#define TABLE_MORE(i, t)                           /  t = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]; /  W[i] = ROLL_1(t);                                                  #define NONLINEAR1(F, a, b, c, d, e, f, i) /  TABLE_IN(i);         /  f = ROLL_5(a);       /  f += F(b, c, d);     /  b = ROLL_30(b);      /  f += e + W[i];#define NONLINEAR2(F, a, b, c, d, e, f, i) /  TABLE_MORE(i, f);    /  f = ROLL_5(a);       /  f += F(b, c, d);     /  b = ROLL_30(b);      /  f += e + W[i];    NONLINEAR1(F1, a, b, c, d, e, f,  0);  NONLINEAR1(F1, f, a, b, c, d, e,  1);  NONLINEAR1(F1, e, f, a, b, c, d,  2);  NONLINEAR1(F1, d, e, f, a, b, c,  3);  NONLINEAR1(F1, c, d, e, f, a, b,  4);  NONLINEAR1(F1, b, c, d, e, f, a,  5);  NONLINEAR1(F1, a, b, c, d, e, f,  6);  NONLINEAR1(F1, f, a, b, c, d, e,  7);  NONLINEAR1(F1, e, f, a, b, c, d,  8);  NONLINEAR1(F1, d, e, f, a, b, c,  9);  NONLINEAR1(F1, c, d, e, f, a, b, 10);  NONLINEAR1(F1, b, c, d, e, f, a, 11);  NONLINEAR1(F1, a, b, c, d, e, f, 12);  NONLINEAR1(F1, f, a, b, c, d, e, 13);  NONLINEAR1(F1, e, f, a, b, c, d, 14);  NONLINEAR1(F1, d, e, f, a, b, c, 15);  NONLINEAR2(F1, c, d, e, f, a, b, 16);  NONLINEAR2(F1, b, c, d, e, f, a, 17);  NONLINEAR2(F1, a, b, c, d, e, f, 18);  NONLINEAR2(F1, f, a, b, c, d, e, 19);    NONLINEAR2(F2, e, f, a, b, c, d, 20);  NONLINEAR2(F2, d, e, f, a, b, c, 21);  NONLINEAR2(F2, c, d, e, f, a, b, 22);  NONLINEAR2(F2, b, c, d, e, f, a, 23);  NONLINEAR2(F2, a, b, c, d, e, f, 24);  NONLINEAR2(F2, f, a, b, c, d, e, 25);  NONLINEAR2(F2, e, f, a, b, c, d, 26);  NONLINEAR2(F2, d, e, f, a, b, c, 27);  NONLINEAR2(F2, c, d, e, f, a, b, 28);  NONLINEAR2(F2, b, c, d, e, f, a, 29);  NONLINEAR2(F2, a, b, c, d, e, f, 30);  NONLINEAR2(F2, f, a, b, c, d, e, 31);  NONLINEAR2(F2, e, f, a, b, c, d, 32);  NONLINEAR2(F2, d, e, f, a, b, c, 33);  NONLINEAR2(F2, c, d, e, f, a, b, 34);  NONLINEAR2(F2, b, c, d, e, f, a, 35);  NONLINEAR2(F2, a, b, c, d, e, f, 36);  NONLINEAR2(F2, f, a, b, c, d, e, 37);  NONLINEAR2(F2, e, f, a, b, c, d, 38);  NONLINEAR2(F2, d, e, f, a, b, c, 39);    NONLINEAR2(F3, c, d, e, f, a, b, 40);  NONLINEAR2(F3, b, c, d, e, f, a, 41);  NONLINEAR2(F3, a, b, c, d, e, f, 42);  NONLINEAR2(F3, f, a, b, c, d, e, 43);  NONLINEAR2(F3, e, f, a, b, c, d, 44);  NONLINEAR2(F3, d, e, f, a, b, c, 45);  NONLINEAR2(F3, c, d, e, f, a, b, 46);  NONLINEAR2(F3, b, c, d, e, f, a, 47);  NONLINEAR2(F3, a, b, c, d, e, f, 48);  NONLINEAR2(F3, f, a, b, c, d, e, 49);  NONLINEAR2(F3, e, f, a, b, c, d, 50);  NONLINEAR2(F3, d, e, f, a, b, c, 51);  NONLINEAR2(F3, c, d, e, f, a, b, 52);  NONLINEAR2(F3, b, c, d, e, f, a, 53);  NONLINEAR2(F3, a, b, c, d, e, f, 54);  NONLINEAR2(F3, f, a, b, c, d, e, 55);//.........这里部分代码省略.........

static voiddo_push_part_1st_xz(int p, fields_t *pf, struct psc_particles *pp){#define S0X(off) s0x[off+1]#define S0Z(off) s0z[off+1]#define S1X(off) s1x[off+1]#define S1Z(off) s1z[off+1]  particle_real_t s0x[4] = {}, s0z[4] = {}, s1x[4], s1z[4];  particle_real_t dt = ppsc->dt;  particle_real_t xl = .5f * dt;  particle_real_t zl = .5f * dt;  particle_real_t dqs = .5f * ppsc->coeff.eta * dt;  particle_real_t fnqs = sqr(ppsc->coeff.alpha) * ppsc->coeff.cori / ppsc->coeff.eta;  particle_real_t fnqxs = ppsc->patch[p].dx[0] * fnqs / dt;  particle_real_t fnqzs = ppsc->patch[p].dx[2] * fnqs / dt;  particle_real_t dxi = 1.f / ppsc->patch[p].dx[0];  particle_real_t dzi = 1.f / ppsc->patch[p].dx[2];  for (int n = 0; n < pp->n_part; n++) {    particle_t *part = particles_get_one(pp, n);    // x^n, p^n -> x^(n+.5), p^n    particle_real_t root = 1.f / particle_real_sqrt(1.f + sqr(part->pxi) + sqr(part->pyi) + sqr(part->pzi));    particle_real_t vxi = part->pxi * root;    particle_real_t vyi = part->pyi * root;    particle_real_t vzi = part->pzi * root;    part->xi += vxi * xl;    part->zi += vzi * zl;    particle_real_t u = part->xi * dxi;    particle_real_t w = part->zi * dzi;    int lg1 = particle_real_fint(u);    int lg3 = particle_real_fint(w);    particle_real_t h1 = u - lg1;    particle_real_t h3 = w - lg3;    particle_real_t g0x = 1.f - h1;    particle_real_t g0z = 1.f - h3;    particle_real_t g1x = h1;    particle_real_t g1z = h3;    // CHARGE DENSITY FORM FACTOR AT (n+.5)*dt     S0X(+0) = g0x;    S0X(+1) = g1x;    S0Z(+0) = g0z;    S0Z(+1) = g1z;    u = part->xi * dxi - .5f;    w = part->zi * dzi - .5f;    int lh1 = particle_real_fint(u);    int lh3 = particle_real_fint(w);    h1 = u - lh1;    h3 = w - lh3;    particle_real_t h0x = 1.f - h1;    particle_real_t h0z = 1.f - h3;    particle_real_t h1x = h1;    particle_real_t h1z = h3;    // FIELD INTERPOLATION#define INTERPOLATE_FIELD(m, gx, gz)					/    (gz##0z*(gx##0x*F3(pf, m, l##gx##1  ,0,l##gz##3  ) +			/	     gx##1x*F3(pf, m, l##gx##1+1,0,l##gz##3  )) +			/     gz##1z*(gx##0x*F3(pf, m, l##gx##1  ,0,l##gz##3+1) +			/	     gx##1x*F3(pf, m, l##gx##1+1,0,l##gz##3+1)))			/          particle_real_t exq = INTERPOLATE_FIELD(EX, h, g);    particle_real_t eyq = INTERPOLATE_FIELD(EY, g, g);    particle_real_t ezq = INTERPOLATE_FIELD(EZ, g, h);    particle_real_t hxq = INTERPOLATE_FIELD(HX, g, h);    particle_real_t hyq = INTERPOLATE_FIELD(HY, h, h);    particle_real_t hzq = INTERPOLATE_FIELD(HZ, h, g);     // c x^(n+.5), p^n -> x^(n+1.0), p^(n+1.0)     particle_real_t dq = dqs * part->qni / part->mni;    particle_real_t pxm = part->pxi + dq*exq;    particle_real_t pym = part->pyi + dq*eyq;    particle_real_t pzm = part->pzi + dq*ezq;    root = dq / particle_real_sqrt(1.f + pxm*pxm + pym*pym + pzm*pzm);    particle_real_t taux = hxq*root;    particle_real_t tauy = hyq*root;    particle_real_t tauz = hzq*root;    particle_real_t tau = 1.f / (1.f + taux*taux + tauy*tauy + tauz*tauz);    particle_real_t pxp = ((1.f+taux*taux-tauy*tauy-tauz*tauz)*pxm + 		(2.f*taux*tauy+2.f*tauz)*pym + 		(2.f*taux*tauz-2.f*tauy)*pzm)*tau;    particle_real_t pyp = ((2.f*taux*tauy-2.f*tauz)*pxm +		(1.f-taux*taux+tauy*tauy-tauz*tauz)*pym +		(2.f*tauy*tauz+2.f*taux)*pzm)*tau;    particle_real_t pzp = ((2.f*taux*tauz+2.f*tauy)*pxm +		(2.f*tauy*tauz-2.f*taux)*pym +//.........这里部分代码省略.........

static voiddo_genc_push_part_xyz(int p, fields_t *pf, struct psc_particles *pp){#define S0X(off) s0x[off+2]#define S0Y(off) s0y[off+2]#define S0Z(off) s0z[off+2]#define S1X(off) s1x[off+2]#define S1Y(off) s1y[off+2]#define S1Z(off) s1z[off+2]  creal s0x[5] = {}, s0y[5] = {}, s0z[5] = {}, s1x[5], s1y[5], s1z[5];  creal dt = ppsc->dt;  creal xl = .5f * dt;  creal yl = .5f * dt;  creal zl = .5f * dt;  creal dqs = .5f * ppsc->coeff.eta * dt;  creal fnqs = sqr(ppsc->coeff.alpha) * ppsc->coeff.cori / ppsc->coeff.eta;  creal fnqxs = ppsc->patch[p].dx[0] * fnqs / dt;  creal fnqys = ppsc->patch[p].dx[1] * fnqs / dt;  creal fnqzs = ppsc->patch[p].dx[2] * fnqs / dt;  creal dxi = 1.f / ppsc->patch[p].dx[0];  creal dyi = 1.f / ppsc->patch[p].dx[1];  creal dzi = 1.f / ppsc->patch[p].dx[2];  int n_part = pp->n_part;  for (int n = 0; n < n_part; n++) {    particle_t *part = particles_get_one(pp, n);    // x^n, p^n -> x^(n+.5), p^n    creal root = 1.f / creal_sqrt(1.f + sqr(part->pxi) + sqr(part->pyi) + sqr(part->pzi));    creal vxi = part->pxi * root;    creal vyi = part->pyi * root;    creal vzi = part->pzi * root;    part->xi += vxi * xl;    part->yi += vyi * yl;    part->zi += vzi * zl;    creal u = part->xi * dxi;    creal v = part->yi * dyi;    creal w = part->zi * dzi;    int j1 = particle_real_nint(u);    int j2 = particle_real_nint(v);    int j3 = particle_real_nint(w);    creal h1 = j1-u;    creal h2 = j2-v;    creal h3 = j3-w;    creal gmx=.5f*(.5f+h1)*(.5f+h1);    creal gmy=.5f*(.5f+h2)*(.5f+h2);    creal gmz=.5f*(.5f+h3)*(.5f+h3);    creal g0x=.75f-h1*h1;    creal g0y=.75f-h2*h2;    creal g0z=.75f-h3*h3;    creal g1x=.5f*(.5f-h1)*(.5f-h1);    creal g1y=.5f*(.5f-h2)*(.5f-h2);    creal g1z=.5f*(.5f-h3)*(.5f-h3);    // CHARGE DENSITY FORM FACTOR AT (n+.5)*dt     S0X(-1) = .5f*(1.5f-creal_abs(h1-1.f))*(1.5f-creal_abs(h1-1.f));    S0X(+0) = .75f-creal_abs(h1)*creal_abs(h1);    S0X(+1) = .5f*(1.5f-creal_abs(h1+1.f))*(1.5f-creal_abs(h1+1.f));    S0Y(-1) = .5f*(1.5f-creal_abs(h2-1.f))*(1.5f-creal_abs(h2-1.f));    S0Y(+0) = .75f-creal_abs(h2)*creal_abs(h2);    S0Y(+1) = .5f*(1.5f-creal_abs(h2+1.f))*(1.5f-creal_abs(h2+1.f));    S0Z(-1) = .5f*(1.5f-creal_abs(h3-1.f))*(1.5f-creal_abs(h3-1.f));    S0Z(+0) = .75f-creal_abs(h3)*creal_abs(h3);    S0Z(+1) = .5f*(1.5f-creal_abs(h3+1.f))*(1.5f-creal_abs(h3+1.f));    u = part->xi * dxi - .5f;    v = part->yi * dyi - .5f;    w = part->zi * dzi - .5f;    int l1 = particle_real_nint(u);    int l2 = particle_real_nint(v);    int l3 = particle_real_nint(w);    h1 = l1-u;    h2 = l2-v;    h3 = l3-w;    creal hmx=.5f*(.5f+h1)*(.5f+h1);    creal hmy=.5f*(.5f+h2)*(.5f+h2);    creal hmz=.5f*(.5f+h3)*(.5f+h3);    creal h0x=.75f-h1*h1;    creal h0y=.75f-h2*h2;    creal h0z=.75f-h3*h3;    creal h1x=.5f*(.5f-h1)*(.5f-h1);    creal h1y=.5f*(.5f-h2)*(.5f-h2);    creal h1z=.5f*(.5f-h3)*(.5f-h3);    // FIELD INTERPOLATION#define INTERP_3D(m, gx, gy, gz, lx, ly, lz)				/    (gz##mz*(gy##my*(gx##mx*F3(pf, m, lx-1,ly-1,lz-1) +			/		     gx##0x*F3(pf, m, lx  ,ly-1,lz-1) +			/		     gx##1x*F3(pf, m, lx+1,ly-1,lz-1)) +			/	     gy##0y*(gx##mx*F3(pf, m, lx-1,ly  ,lz-1) +			/		     gx##0x*F3(pf, m, lx  ,ly  ,lz-1) +			/		     gx##1x*F3(pf, m, lx+1,ly  ,lz-1)) +			///.........这里部分代码省略.........

int main()//Declare and initialize Variables inside main function{        char fileName[BUFFER_SIZE];        int i,j,rows,cols,user_input=0,Value1=0,loop=1;        char ci;//Print out menuwhile (loop = 1){       // printf("Please select an option:/n");       // printf("1) Read in a picture file and process it./n");       // printf("2) Read in two picture files and subtract the second picture from the first./n");        printf("Read in a pic and apply the sobelfunc function to it.                           Use a grayscale pic saved as a *.pgm in your computer                           Please enter the number 3 on your keyboard and then hit the enter key                        /n");      //  printf("4) Exit./n");        scanf("%d", &user_input);//Read in an image and prompt user to enter a value for the image         if (user_input == 1){        printf("enter image filename in the format *.pgm: ");        scanf("%s", fileName);        img = readpic(fileName);        printf("Successfully read image file '%s'/n", fileName);                printf("Enter a value for the picture: ");        scanf("%d", &Value1);        system("pause");        F3(img, numRows, numCols, Value1);        F4(img, numRows, numCols, Value1);        printf("Enter image filename for output: ");        scanf("%s", fileName);        writeoutpic(fileName,img);        free(img);        img = NULL;                                  }//Read in two images and subtract the second from the first        else if (user_input == 2) {        printf("Enter first image filename: ");          scanf("%s", fileName);       //   temppicx = readpic(fileName);                    printf("Enter second image filename: ");          scanf("%s", fileName);         // temppicy = readpic(fileName);                  //  sobelout = setImage();             //   subtractpixels(sobelout, temppicx, temppicy);          printf("Enter image filename for output: ");          scanf("%s", fileName);         // writeoutpic(fileName,sobelout);              free(temppicx);          temppicx = NULL;             free(temppicy);          temppicy = NULL;                                           }//Read in a picture and apply the sobelfunc function to it        else if (user_input == 3){        printf("Enter pic filename (*.pgm, example dog.pgm): ");                scanf("%s", fileName);                img = readpic(fileName);                  sobelout= setdImage();                                                          candid = setImage();                  sobelout= setdImage();                temppicx= setdImage();                temppicy= setdImage();                                finaly= setImage();                sobelout2=setImage();                                cannyfunc(img,sobelout,temppicx,temppicy,candid,finaly);                printf("Enter mag filename for output: ");                scanf("%s", fileName);for(i=0;i<numRows;i++) for (j=0;j<numCols;j++) sobelout2[i][j]= (int) sobelout[i][j];              writeoutpic(fileName,sobelout2);                                                     printf("Enter peaks filename for output: ");                scanf("%s", fileName);               writeoutpic(fileName,candid);                 printf("Enter final filename for output: ");                scanf("%s", fileName);             writeoutpic(fileName,finaly);                    //.........这里部分代码省略.........

s32 main(s32 argc, const char* argv[]){	padInfo padinfo;	padData paddata;	ioPadInit(7);	int Bx=0;	int By=0;	pngData *png = new pngData;		NoRSX *GFX = new NoRSX(RESOLUTION_AUTO, RESOLUTION_1280x720); //set defined screen resolution You can change it to:						    			  //RESOLUTION_720x480 | RESOLUTION_720x576 | RESOLUTION_1280x720 | RESOLUTION_1920x1080	Image IMG(GFX);	Background BG(GFX);	Object OBJ(GFX);	Bitmap BMap(GFX);	MsgDialog Msg(GFX);	NoRSX_Bitmap Precalculated_Layer;			BMap.GenerateBitmap(&Precalculated_Layer); //Initialize the Bitmap		Font F1(Sans_ttf,Sans_ttf_size ,GFX);   //Loaded from Memory	Font F2("/dev_flash/data/font/SCE-PS3-VR-R-LATIN2.TTF" ,GFX);  //Loaded from File!	Font F3(JPN ,GFX);  //I'm Using PS3 Original Fonts! These are the available on the ps3: LATIN2 | JPN | KOR | CGB | KANA		IMG.LoadPNG_Buf(NoRSX_Image_png,NoRSX_Image_png_size, png);	png = IMG.ResizeImage(png, 500, 500); //pngData* IMG.ResizeImage(pngData*, new width, new height)	u32 imgX =(GFX->width/2)-(png->width/2), imgY = (GFX->height/2)-(png->height/2);	BG.MonoBitmap(0xb4e83a,&Precalculated_Layer); //a green hex color (you can use hex colors insted of COLOR_XXXXXXX)//	IMG.DrawIMGtoBitmap(imgX,imgY,png,&Precalculated_Layer);	OBJ.CircleToBitmap(500,500,50,COLOR_YELLOW,&Precalculated_Layer);	F1.PrintfToBitmap(150,200,&Precalculated_Layer,COLOR_RED,"Screen %d x %d",GFX->width,GFX->height);	F1.PrintfToBitmap(150,250,&Precalculated_Layer,COLOR_BLUE, 35,"Press X to exit! (Start to skip Message Dialogs and exit)");	F2.PrintfToBitmap(150,300,&Precalculated_Layer,COLOR_GREEN,60,"FreeType2 with TTF support :)");	F3.PrintfToBitmap(150,500,&Precalculated_Layer,"Written by deroad");	int frame=0;	/*	// Bitmap		GFX->AppStart();	while(GFX->GetAppStatus()){		static time_t starttime = 0;		double fps = 0;		if (starttime == 0) starttime = time (NULL);		else fps = frame / difftime (time (NULL), starttime);		ioPadGetInfo(&padinfo);		if(padinfo.status[0]){			ioPadGetData(0, &paddata);			if(paddata.BTN_CROSS){				GFX->AppExit();			}			if(paddata.BTN_START){				GFX->AppExit();				goto end;			}		}		BMap.DrawBitmap(&Precalculated_Layer);		IMG.DrawIMG(imgX,imgY,png);		F1.Printf(150,100,COLOR_RED,60,"FPS %f", fps);		GFX->Flip();		frame ++;	}	*/	GFX->AppStart();	while(GFX->GetAppStatus()){		static time_t starttime = 0;		double fps = 0;		if (starttime == 0) starttime = time (NULL);		else fps = frame / difftime (time (NULL), starttime);		ioPadGetInfo(&padinfo);		if(padinfo.status[0]){			ioPadGetData(0, &paddata);			if(paddata.BTN_TRIANGLE){				GFX->AppExit();			}			if(paddata.BTN_START){				GFX->AppExit();				goto end;			}		}		BG.Mono(0xb4e83a);		F1.Printf(150,100,COLOR_RED,60,"FPS %f", fps);		F1.Printf(150,200,COLOR_RED,"Screen %d x %d",GFX->width,GFX->height);		F1.Printf(150,250,COLOR_BLUE, 35,"Press /// to exit! (Start to skip Message Dialogs and exit)");		F2.Printf(150,300,COLOR_GREEN,60,"FreeType2 with TTF support :)");		F3.Printf(150,500,"Written by deroad");		IMG.DrawIMG(imgX,imgY,png);//.........这里部分代码省略.........