Cemu Module one May 6th

[Scoobydooo]

Thanks to ALL cemu coders!



// module 1 for NA (20080502ry v35) May 6th 2009
#define mmB(_p1,numb) \
{ \
BN_zero(s); \
for(int i=0; i<((numb+7)>>3); i++) { \
BN_rshift(x,_p1,i<<6); \
BN_mask_bits(x,64); \
BN_mul(x,x,B,ctx); \
BN_add(s,s,x); \
BN_copy(x,s); \
BN_mask_bits(x,64); \
BN_mul(x,x,J,ctx); \
BN_lshift(C,x,64); \
BN_add(C,C,x); \
BN_rshift(C,C,2); \
BN_add(C,C,s); \
BN_rshift(C,C,52); \
BN_mask_bits(C,12); \
BN_mask_bits(x,64); \
BN_mul(x,x,D,ctx); \
BN_add(s,s,x); \
BN_lshift(y,s,12); \
BN_add(C,C,y); \
BN_mask_bits(C,128); \
BN_rshift(s,s,64); \
BN_copy(Z,s); \
if(BN_cmp(s,D)==1) BN_sub(s,s,D); \
} \
BN_copy(B,s); \
}
// --------------------------------------------------------------------------------------------------------------
{
BIGNUM *A=BN_new(); BIGNUM *B=BN_new(); BIGNUM *C=BN_new(); BIGNUM *D=BN_new(); BIGNUM *DAT=BN_new();
BIGNUM *J=BN_new(); BIGNUM *Z=BN_new(); BIGNUM *v=BN_new(); BN_CTX *ctx=BN_CTX_new();
BIGNUM *s=BN_new(); BIGNUM *x=BN_new(); BIGNUM *y=BN_new();
unsigned char *_a=hw,*_b=&hw[0x10],*_c=&hw[0x20],*_d=&hw[0x30],*_j=&hw[0x40],*_4445=&hw[0x50],*_z=hw;
unsigned int m=0x27+0x72+(A00[4]&0x3F)-0x79;
unsigned char xr=((A00[2]&4)?4:(A00[2]&3))+0x09;
A00[0]|=A00[9];
memset(hw,0,sizeof(hw));
memcpy(hw,A00,0x05);
ExpandInput(hw);
RotateBytes(_a,0x10); BN_bin2bn(_a,0x10,A); RotateBytes(_a,0x10);
RotateBytes(_b,0x10); BN_bin2bn(_b,0x10,B);
RotateBytes(_c,0x10); BN_bin2bn(_c,0x10,C);
RotateBytes(_d,0x10); BN_bin2bn(_d,0x10,D);
RotateBytes(_j,0x08); BN_bin2bn(_j,0x08,J);
RotateBytes(_4445,0x10); BN_bin2bn(_4445,0x10,DAT);
int ti=0;
int tx=0;

printf("0x%4.4X\n",((m<<8)|A00[3]));
switch ((m<<8)|A00[3]) {

case 0x4F53:
case 0x4EC9:
BN_copy(D,B);
BN_copy(Z,D);
memset(_z,0,0x10);
break;
case 0x3963:
case 0x3AB5:
case 0x3B41:
case 0x3B78:
case 0x3974:
BN_rshift(Z,C,64);
BN_lshift(Z,Z,64);
memset(_z,0,0x10);
break;
case 0x3B7B:
case 0x3B7F:
case 0x3B8A:
BN_rshift(Z,C,64);
BN_lshift(Z,Z,64);
memset(_z,0,0x10);
break;
case 0x3967: // 1648
case 0x3986:
case 0x3A58:
case 0x3E68:
case 0x3B6A:
case 0x3B89:
case 0x3E8C:
BN_zero(v);
BN_set_bit(v,((m==0x3B)?128:136));
BN_mod(Z,v,D,ctx);
memset(_z,0,0x10);
break;
case 0x2100 ... 0x21FF:
case 0x39B0:
case 0x3BB0:
case 0x3EAE:
BN_zero(v);
BN_sub(J,v,D);
BN_set_bit(J,0);
BN_set_bit(v,64);
BN_mod_inverse(J,J,v,ctx);
BN_mask_bits(J,64);
BN_mod(D,D,v,ctx);
BN_mul(C,J,D,ctx);
BN_rshift(C,C,64);
BN_mask_bits(C,64);
BN_copy(Z,C);
memset(_z,0,8);
break;
case 0x25AB:
BN_zero(v);
BN_sub(B,v,D);
BN_set_bit(B,0);
BN_set_bit(v,128);
BN_mod_inverse(B,B,v,ctx);
BN_mask_bits(B,128);
BN_mod(D,D,v,ctx);
BN_mul(C,B,D,ctx);
BN_rshift(C,C,128);
BN_mask_bits(C,128);
BN_copy(Z,C);
memset(_z,0,0x10);
break;
case 0x3A75:
BN_mask_bits(B,64);
BN_copy(Z,B);
memset(_z,0,8);
break;
case 0x3846:
mmB(B,16);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
break;
case 0x3E92:
BN_copy(Z,A);
memset(_z,0,0x10);
break;
case 0x3A9C:
case 0x3CAA:
ti=1;
case 0x3E90:
case 0x3E95:
case 0x3C9F:
case 0x3CA5:
case 0x4692:
case 0x3A81:
case 0x3A86:
BN_zero(v);
BN_sub(J,v,D);
BN_set_bit(J,0);
BN_set_bit(v,64);
BN_mod_inverse(J,J,v,ctx);
BN_mask_bits(J,64);
BN_zero(v);
BN_set_bit(v,136);
BN_mod(B,v,D,ctx);
if (m==0x3A) tx=2;
for(int j=0;j<((A00[3]-((m==0x46)?0x82:0x85))>>3)+tx;j++) mmB(B,16);
if (ti) mmB(A,16);
if (xr==0x0C) BN_copy(Z,C);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
break;
case 0x3D55:
{
BN_copy(D,DAT);
BN_zero(v);
BN_sub(J,v,D);
BN_set_bit(J,0);
BN_set_bit(v,64);
BN_mod_inverse(J,J,v,ctx);
BN_mask_bits(J,64);
BN_mod(D,D,v,ctx);
BN_mul(C,J,D,ctx);
BN_rshift(C,C,64);
BN_mask_bits(C,64);
BN_copy(Z,C);
memset(_z,0,0x08);
}
break;
case 0x3D6D:
BN_copy(D,DAT);
BN_zero(v);
BN_sub(J,v,D);
BN_set_bit(J,0);
BN_set_bit(v,64);
BN_mod_inverse(J,J,v,ctx);
BN_mask_bits(J,64);
mmB(B,16);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
break;
case 0x3AC9:
{
int o=1;
unsigned char u8[8];
for (int i=0;i<2;i++) {
memcpy(&u8[1],&_d[o<<3],7);
u8[0] = _d[(o<<3)+7];
memcpy(&_d[o<<3],u8,8);
}
BN_bin2bn(_d,0x10,Z);
memset(_z,0,16);
}
break;
case 0x3AF7:
case 0x394D:
BN_zero(Z);
memset(_z,0,0x10);
break;
case 0x395A:
BN_zero(Z);
BN_set_bit(Z,96);
memset(_z,0,0x10);
break;
case 0x3B5D:
BN_zero(Z);
BN_set_bit(Z,104);
memset(_z,0,0x10);
break;
case 0x22A1:
BN_zero(Z);
BN_set_bit(Z,112);
memset(_z,0,0x10);
break;
case 0x22B4:
{
int shift=hw[0x48];
int exp=hw[0x49] & 0x1F;
if (xr==0x09)
{
BN_copy(Z,J);
memset(_z,0,8);
}
if (xr==0x0A)
{
BN_copy(Z,A);
memset(_z,0,0x10);
}
if (xr==0x0B)
{
if (exp==0)
{
BN_set_word(B, 1);
BN_mod_lshift(B, B, shift, D, ctx);
BN_copy(Z,B);
}
else
{
BN_zero(Z);
BN_set_bit(Z,64);
}
memset(_z,0,0x10);
}
if (xr==0x0D)
{
BN_copy(Z,D);
memset(_z,0,0x10);
}
}
break;
case 0x236E:
ti++;
case 0x2368:
ti++;
case 0x2362:
BN_zero(v);
BN_set_bit(v,136);
BN_mod(B,v,D,ctx);
mmB(B,16);
while(ti--) mmB(B,16);
if (xr==0x0C) BN_copy(Z,C);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
break;
case 0x23A9:
case 0x23AD:
BN_copy(Z,C);
memset(_z,0,0x10);
break;
case 0x23BC:
{
BN_zero(Z);
BN_set_bit(Z,64);
memset(_z,0,0x10);
}
break;
case 0x23C5:
{
BN_zero(Z);
BN_set_bit(Z,32);
memset(_z,0,0x10);
}
break;
case 0x2ECE:
ti++;
case 0x2ECA:
ti++;
BN_rshift(Z,DAT,8<<3);
BN_lshift(Z,Z,8<<3);
BN_add(Z,Z,J);
BN_rshift(Z,Z,ti<<3);
BN_mask_bits(Z,8<<3);
memset(_z,0,8);
break;
case 0x2FCA:
{
ti=1;
BN_rshift(Z,DAT,8<<3);
BN_lshift(Z,Z,8<<3);
BN_add(Z,Z,J);
BN_rshift(Z,Z,ti<<3);
BN_mask_bits(Z,8<<3);
memset(_z,0,8);
}
break;
default:
printf("unhandled module case : %4.4X\n",(m<<8)|A00[3]);
break;
}
BN_bn2bin(Z,_z); RotateBytes(_z,BN_num_bytes(Z));

for (int i=11;i>-1;i--) hw[i]^=hw[i+4]; memset(&hw[4],0,0x7C);
}






Scooby

[drwho]

Nagra 2? Whats the point?

[Scoobydooo]

Nagra 2? Whats the point?

What's the point of your post? :rolleyes:


Scooby

[JT]

Thanks again for bringing the modules over scooby.

[smokiejoe]

Anyone have the latest working Module1. I believe it would be from the 5/13.

Thanks

[locoavr]

// module 1 May 18,2009

#define mmB(_p1,numb) \
{ \
BN_zero(s); \
for(int i=0; i<((numb+7)>>3); i++) { \
BN_rshift(x,_p1,i<<6); \
BN_mask_bits(x,64); \
BN_mul(x,x,B,ctx); \
BN_add(s,s,x); \
BN_copy(x,s); \
BN_mask_bits(x,64); \
BN_mul(x,x,J,ctx); \
BN_lshift(C,x,64); \
BN_add(C,C,x); \
BN_rshift(C,C,2); \
BN_add(C,C,s); \
BN_rshift(C,C,52); \
BN_mask_bits(C,12); \
BN_mask_bits(x,64); \
BN_mul(x,x,D,ctx); \
BN_add(s,s,x); \
BN_lshift(y,s,12); \
BN_add(C,C,y); \
BN_mask_bits(C,128); \
BN_rshift(s,s,64); \
BN_copy(Z,s); \
if(BN_cmp(s,D)==1) BN_sub(s,s,D); \
} \
BN_copy(B,s); \
}
// --------------------------------------------------------------------------------------------------------------
{
BIGNUM *A=BN_new(); BIGNUM *B=BN_new(); BIGNUM *C=BN_new(); BIGNUM *D=BN_new(); BIGNUM *DAT=BN_new();
BIGNUM *J=BN_new(); BIGNUM *Z=BN_new(); BIGNUM *v=BN_new(); BN_CTX *ctx=BN_CTX_new();
BIGNUM *s=BN_new(); BIGNUM *x=BN_new(); BIGNUM *y=BN_new();

unsigned char *_a=hw,*_b=&hw[0x10],*_c=&hw[0x20],*_d=&hw[0x30],*_j=&hw[0x40],*_4445=&hw[0x50],*_z=hw;
unsigned int m=0x27+0x72+(A00[4]&0x3F)-0x79;
unsigned char xr=((A00[2]&4)?4:(A00[2]&3))+0x09;
A00[0]|=A00[9];
memset(hw,0,sizeof(hw));
memcpy(hw,A00,0x05);
ExpandInput(hw);
RotateBytes(_a,0x10); BN_bin2bn(_a,0x10,A); RotateBytes(_a,0x10);
RotateBytes(_b,0x10); BN_bin2bn(_b,0x10,B);
RotateBytes(_c,0x10); BN_bin2bn(_c,0x10,C);
RotateBytes(_d,0x10); BN_bin2bn(_d,0x10,D);
RotateBytes(_j,0x08); BN_bin2bn(_j,0x08,J);
RotateBytes(_4445,0x10); BN_bin2bn(_4445,0x10,DAT);
int ti=0;
int tx=0;
int numloops=0;
// printf("0x%4.4X\n",((m<<8)|A00[3]));

switch ((m<<8)|A00[3]) {
case 0x2100 ... 0x21FF://2151,218D
case 0x39B0:
case 0x3BB0:
case 0x3D55:
case 0x3EAE:
if (m==0x3D)BN_copy(D,DAT);//3D55
BN_zero(v);
BN_sub(J,v,D);
BN_set_bit(J,0);
BN_set_bit(v,64);
BN_mod_inverse(J,J,v,ctx);
BN_mask_bits(J,64);
BN_mod(D,D,v,ctx);
BN_mul(C,J,D,ctx);
BN_rshift(C,C,64);
BN_mask_bits(C,64);
BN_copy(Z,C);
memset(_z,0,8);
break;
case 0x22A1:
BN_zero(Z);
BN_set_bit(Z,112);
BN_copy(B,Z);
memset(_z,0,0x10);
break;
case 0x22B4:
case 0x4E00 ... 0x4FFF:
BN_zero(Z);
if (xr==0x0A) BN_copy(Z,A);
if (xr==0x0B) {BN_set_bit(Z,64);BN_copy(B,Z);}
if (m==0x4E)BN_copy(D,B);//4EC9
if (m==0x4F)BN_copy(D,B);//4F53,4FB3
if(A00[3]==0xBC){BN_zero(A);BN_set_bit(A,56);BN_add(A,A,A); BN_copy(Z,A);}//4FBC
if (xr==0x0D) BN_copy(Z,D);
if (xr==0x09) BN_copy(Z,J);
memset(_z,0,((xr==0x09)?8:0x10));
break;
case 0x2350 ... 0x23A8:
BN_zero(v);
BN_set_bit(v,136);
if(A00[3]==0xB0)BN_set_bit(v,104);//23B0
BN_mod(B,v,D,ctx);
numloops=1;//2362
if(A00[3]>=0x66)numloops=2;//2368
if(A00[3]>=0x6E)numloops=3;//236E
for(int j=0; j<numloops;j++){
mmB(B,16);}
if (xr==0x0C) BN_copy(Z,C);
BN_mask_bits(Z,136);
memset(_z,0,0x10);
break;
case 0x23A9 ... 0x23BB://23A9,23AD
BN_copy(Z,C);
memset(_z,0,0x10);
break;
case 0x23BC ... 0x23CC://23C5
BN_zero(Z);
BN_set_bit(Z,32);//64
memset(_z,0,0x10);
break;
case 0x2500 ... 0x025FF://25AB
case 0x2FE2 ... 0x2FFF://could be 2F38 to 2FC9
BN_zero(v);
BN_sub(B,v,D);
BN_set_bit(B,0);
BN_set_bit(v,128);
BN_mod_inverse(B,B,v,ctx);
BN_mask_bits(B,128);
BN_mod(D,D,v,ctx);
BN_mul(C,B,D,ctx);
BN_rshift(C,C,128);
BN_mask_bits(C,128);
BN_copy(Z,C);
memset(_z,0,0x10);
break;
case 0x2E00 ... 0x2FE1:
ti=1;//2FCA,2ECA
if(A00[3]>=0xCB)ti=2;//2ECE
BN_rshift(Z,DAT,8<<3);
BN_lshift(Z,Z,8<<3);
BN_add(Z,Z,J);//xr 9 = xr J
BN_rshift(Z,Z,ti<<3);
BN_mask_bits(Z,8<<3);
memset(_z,0,8);
break;
case 0x32AD:
BN_mod(Z,v,D,ctx);
BN_copy(Z,D);
memset(_z,0,0x10);
break;
case 0x3846:
mmB(B,16);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
break;
case 0x393E:
case 0x3963:
case 0x3967:
case 0x3974:
case 0x3AB5:
case 0x3B41:
case 0x3B78:
case 0x3B7B:
case 0x3B7F:
case 0x3B8A:
case 0x3C62 ... 0x3C8C://3C78
BN_rshift(Z,C,64);
BN_lshift(Z,Z,64);
if (xr==0x0B){BN_zero(v);BN_set_bit(v,136);BN_mod(Z,v ,D,ctx);}//3967B
memset(_z,0,0x10);
break;
case 0x394D:
case 0x3AF7:
BN_zero(Z);
memset(_z,0,0x10);
break;
case 0x395A:
BN_zero(C);
BN_zero(B);
BN_set_bit(B,64);
BN_copy(Z,B);
memset(_z,0,0x10);
break;
case 0x3986:
case 0x3A58:
case 0x3E68:
case 0x3B6A:
case 0x3B89:
case 0x3E8C:
BN_zero(v);
BN_set_bit(v,((m==0x3B)?128:136));
BN_mod(Z,v,D,ctx);
memset(_z,0,0x10);
break;
case 0x3A75:
BN_mask_bits(B,64);
BN_copy(Z,B);
memset(_z,0,8);
break;
case 0x3A9C:
case 0x3CAA:
ti=1;
case 0x3E90:
case 0x3E95:
case 0x3C9F:
case 0x3CA5:
case 0x4692:
case 0x3A81:
case 0x3A86:
BN_zero(v);
BN_sub(J,v,D);
BN_set_bit(J,0);
BN_set_bit(v,64);
BN_mod_inverse(J,J,v,ctx);
BN_mask_bits(J,64);
BN_zero(v);
BN_set_bit(v,136);
BN_mod(B,v,D,ctx);
if (m==0x3A) tx=2;
for(int j=0;j<((A00[3]-((m==0x46)?0x82:0x85))>>3)+tx;j++) mmB(B,16);
if (ti) mmB(A,16);
if (xr==0x0C) BN_copy(Z,C);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
break;
case 0x3AC9:
{int o=1;
unsigned char u8[8];
for (int i=0;i<2;i++) {
memcpy(&u8[1],&_d[o<<3],7);
u8[0] = _d[(o<<3)+7];
memcpy(&_d[o<<3],u8,8);}
BN_bin2bn(_d,0x10,Z);
memset(_z,0,16);}
break;
case 0x3B5D:
BN_zero(Z);
BN_set_bit(Z,104);
memset(_z,0,0x10);
break;
case 0x3D6D:
BN_copy(D,DAT);
BN_zero(v);
BN_sub(J,v,D);
BN_set_bit(J,0);
BN_set_bit(v,64);
BN_mod_inverse(J,J,v,ctx);
BN_mask_bits(J,64);
mmB(B,16);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
break;
case 0x3E92:
BN_copy(Z,A);
memset(_z,0,0x10);
break;

default:
printf("New Map Call: %4.4X\n",(m<<8)|A00[3]);
BN_rshift(Z,C,64);
BN_lshift(Z,Z,64);
if (xr==0x0B){BN_zero(v);BN_set_bit(v,((m==0x3B)?128: 136));BN_mod(Z,v,D,ctx);}//3967B
memset(_z,0,0x10);
break;
}
BN_bn2bin(Z,_z);
if (BN_num_bytes(Z) > 0) RotateBytes(_z,BN_num_bytes(Z));

for (int i=11;i>-1;i--) hw[i]^=hw[i+4]; memset(&hw[4],0,0x7C);
}

[pitt]

i tryed to make the modual that locavr posted but i keep getting invalid suffix A00

took out every A00 i could find still no go.what should i be looking for

[vivaurbana]

One bad line line in copy above, don't know why it does this sometimes.

// module 1 May 19,2009

#define mmB(_p1,numb) \
{ \
BN_zero(s); \
for(int i=0; i<((numb+7)>>3); i++) { \
BN_rshift(x,_p1,i<<6); \
BN_mask_bits(x,64); \
BN_mul(x,x,B,ctx); \
BN_add(s,s,x); \
BN_copy(x,s); \
BN_mask_bits(x,64); \
BN_mul(x,x,J,ctx); \
BN_lshift(C,x,64); \
BN_add(C,C,x); \
BN_rshift(C,C,2); \
BN_add(C,C,s); \
BN_rshift(C,C,52); \
BN_mask_bits(C,12); \
BN_mask_bits(x,64); \
BN_mul(x,x,D,ctx); \
BN_add(s,s,x); \
BN_lshift(y,s,12); \
BN_add(C,C,y); \
BN_mask_bits(C,128); \
BN_rshift(s,s,64); \
BN_copy(Z,s); \
if(BN_cmp(s,D)==1) BN_sub(s,s,D); \
} \
BN_copy(B,s); \
}
// --------------------------------------------------------------------------------------------------------------
{
BIGNUM *A=BN_new(); BIGNUM *B=BN_new(); BIGNUM *C=BN_new(); BIGNUM *D=BN_new(); BIGNUM *DAT=BN_new();
BIGNUM *J=BN_new(); BIGNUM *Z=BN_new(); BIGNUM *v=BN_new(); BN_CTX *ctx=BN_CTX_new();
BIGNUM *s=BN_new(); BIGNUM *x=BN_new(); BIGNUM *y=BN_new();

unsigned char *_a=hw,*_b=&hw[0x10],*_c=&hw[0x20],*_d=&hw[0x30],*_j=&hw[0x40],*_4445=&hw[0x50],*_z=hw;
unsigned int m=0x27+0x72+(A00[4]&0x3F)-0x79;
unsigned char xr=((A00[2]&4)?4:(A00[2]&3))+0x09;
A00[0]|=A00[9];
memset(hw,0,sizeof(hw));
memcpy(hw,A00,0x05);
ExpandInput(hw);
RotateBytes(_a,0x10); BN_bin2bn(_a,0x10,A); RotateBytes(_a,0x10);
RotateBytes(_b,0x10); BN_bin2bn(_b,0x10,B);
RotateBytes(_c,0x10); BN_bin2bn(_c,0x10,C);
RotateBytes(_d,0x10); BN_bin2bn(_d,0x10,D);
RotateBytes(_j,0x08); BN_bin2bn(_j,0x08,J);
RotateBytes(_4445,0x10); BN_bin2bn(_4445,0x10,DAT);
int ti=0;
int tx=0;
int numloops=0;
// printf("0x%4.4X\n",((m<<8)|A00[3]));

switch ((m<<8)|A00[3]) {
case 0x2100 ... 0x21FF://2151,218D
case 0x39B0:
case 0x3BB0:
case 0x3D55:
case 0x3EAE:
if (m==0x3D)BN_copy(D,DAT);//3D55
BN_zero(v);
BN_sub(J,v,D);
BN_set_bit(J,0);
BN_set_bit(v,64);
BN_mod_inverse(J,J,v,ctx);
BN_mask_bits(J,64);
BN_mod(D,D,v,ctx);
BN_mul(C,J,D,ctx);
BN_rshift(C,C,64);
BN_mask_bits(C,64);
BN_copy(Z,C);
memset(_z,0,8);
break;
case 0x22A1:
BN_zero(Z);
BN_set_bit(Z,112);
BN_copy(B,Z);
memset(_z,0,0x10);
break;
case 0x22B4:
case 0x3200 ... 0x32FF://32AD
case 0x4E00 ... 0x4FFF:
BN_zero(Z);
if (m==0x4E)BN_copy(D,B);//4EC9
if (m==0x4F){BN_copy(D,B);//4F53,4FB3
if(A00[3]==0xBC)BN_zero(A);BN_set_bit(A,57);}//4FBC
if (xr==0x0A) BN_copy(Z,A);
if (xr==0x0B) {BN_set_bit(Z,64);BN_copy(B,Z);}
if (xr==0x0D) BN_copy(Z,D);//32AD
if (xr==0x09) BN_copy(Z,J);
memset(_z,0,((xr==0x09)?8:0x10));
break;
case 0x2350 ... 0x23A8:
BN_zero(v);
BN_set_bit(v,136);
if(A00[3]==0xB0)BN_set_bit(v,104);//23B0
BN_mod(B,v,D,ctx);
numloops=1;//2362
if(A00[3]>=0x66)numloops=2;//2368
if(A00[3]>=0x6E)numloops=3;//236E
for(int j=0; j<numloops;j++){
mmB(B,16);}
if (xr==0x0C) BN_copy(Z,C);
BN_mask_bits(Z,136);
memset(_z,0,0x10);
break;
case 0x23A9 ... 0x23BB://23A9,23AD
BN_copy(Z,C);
memset(_z,0,0x10);
break;
case 0x23BC ... 0x23CC://23C5
BN_zero(Z);
BN_set_bit(Z,32);//64
memset(_z,0,0x10);
break;
case 0x2500 ... 0x025FF://25AB
case 0x2FE2 ... 0x2FFF://could be 2F38 to 2FC9
BN_zero(v);
BN_sub(B,v,D);
BN_set_bit(B,0);
BN_set_bit(v,128);
BN_mod_inverse(B,B,v,ctx);
BN_mask_bits(B,128);
BN_mod(D,D,v,ctx);
BN_mul(C,B,D,ctx);
BN_rshift(C,C,128);
BN_mask_bits(C,128);
BN_copy(Z,C);
memset(_z,0,0x10);
break;
case 0x2E00 ... 0x2FE1:
ti=1;//2FCA,2ECA
if(A00[3]>=0xCB)ti=2;//2ECE
BN_rshift(Z,DAT,8<<3);
BN_lshift(Z,Z,8<<3);
BN_add(Z,Z,J);//xr 9 = xr J
BN_rshift(Z,Z,ti<<3);
BN_mask_bits(Z,8<<3);
memset(_z,0,8);
break;
case 0x3846:
mmB(B,16);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
break;
case 0x393E:
case 0x3963:
case 0x3967:
case 0x3974:
case 0x3AB5:
case 0x3B41:
case 0x3B78:
case 0x3B7B:
case 0x3B7F:
case 0x3B8A:
case 0x3C62 ... 0x3C8C://3C78
BN_rshift(Z,C,64);
BN_lshift(Z,Z,64);
if (xr==0x0B){BN_zero(v);BN_set_bit(v,136);BN_mod(Z,v ,D,ctx);}//3967B
memset(_z,0,0x10);
break;
case 0x394D:
case 0x3AF7:
BN_zero(Z);
memset(_z,0,0x10);
break;
case 0x395A:
BN_zero(C);
BN_zero(B);
BN_set_bit(B,64);
BN_copy(Z,B);
memset(_z,0,0x10);
break;
case 0x3986:
case 0x3A58:
case 0x3E68:
case 0x3B6A:
case 0x3B89:
case 0x3E8C:
BN_zero(v);
BN_set_bit(v,((m==0x3B)?128:136));
BN_mod(Z,v,D,ctx);
memset(_z,0,0x10);
break;
case 0x3A75:
BN_mask_bits(B,64);
BN_copy(Z,B);
memset(_z,0,8);
break;
case 0x3A9C:
case 0x3CAA:
ti=1;
case 0x3E90:
case 0x3E95:
case 0x3C9F:
case 0x3CA5:
case 0x4692:
case 0x3A81:
case 0x3A86:
BN_zero(v);
BN_sub(J,v,D);
BN_set_bit(J,0);
BN_set_bit(v,64);
BN_mod_inverse(J,J,v,ctx);
BN_mask_bits(J,64);
BN_zero(v);
BN_set_bit(v,136);
BN_mod(B,v,D,ctx);
if (m==0x3A) tx=2;
for(int j=0;j<((A00[3]-((m==0x46)?0x82:0x85))>>3)+tx;j++) mmB(B,16);
if (ti) mmB(A,16);
if (xr==0x0C) BN_copy(Z,C);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
break;
case 0x3AC9:
{int o=1;
unsigned char u8[8];
for (int i=0;i<2;i++) {
memcpy(&u8[1],&_d[o<<3],7);
u8[0] = _d[(o<<3)+7];
memcpy(&_d[o<<3],u8,8);}
BN_bin2bn(_d,0x10,Z);
memset(_z,0,16);}
break;
case 0x3B5D:
BN_zero(Z);
BN_set_bit(Z,104);
memset(_z,0,0x10);
break;
case 0x3D6D:
BN_copy(D,DAT);
BN_zero(v);
BN_sub(J,v,D);
BN_set_bit(J,0);
BN_set_bit(v,64);
BN_mod_inverse(J,J,v,ctx);
BN_mask_bits(J,64);
mmB(B,16);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
break;
case 0x3E92:
BN_copy(Z,A);
memset(_z,0,0x10);
break;

default:
printf("New Map Call: %4.4X\n",(m<<8)|A00[3]);
BN_rshift(Z,C,64);
BN_lshift(Z,Z,64);
if (xr==0x0B){BN_zero(v);BN_set_bit(v,((m==0x3B)?128: 136));BN_mod(Z,v,D,ctx);}//3967B
memset(_z,0,0x10);
break;
}
BN_bn2bin(Z,_z);
if (BN_num_bytes(Z) > 0) RotateBytes(_z,BN_num_bytes(Z));

for (int i=11;i>-1;i--) hw[i]^=hw[i+4]; memset(&hw[4],0,0x7C);
}

[locoavr]

// module 1 for NA (20080502ry v35)

#define mmB(_p1,numb) \
{ \
BN_zero(s); \
for(int i=0; i<((numb+7)>>3); i++) { \
BN_rshift(x,_p1,i<<6); \
BN_mask_bits(x,64); \
BN_mul(x,x,B,ctx); \
BN_add(s,s,x); \
BN_copy(x,s); \
BN_mask_bits(x,64); \
BN_mul(x,x,J,ctx); \
BN_lshift(C,x,64); \
BN_add(C,C,x); \
BN_rshift(C,C,2); \
BN_add(C,C,s); \
BN_rshift(C,C,52); \
BN_mask_bits(C,12); \
BN_mask_bits(x,64); \
BN_mul(x,x,D,ctx); \
BN_add(s,s,x); \
BN_lshift(y,s,12); \
BN_add(C,C,y); \
BN_mask_bits(C,128); \
BN_rshift(s,s,64); \
BN_copy(Z,s); \
if(BN_cmp(s,D)==1) BN_sub(s,s,D); \
} \
BN_copy(B,s); \
}
// --------------------------------------------------------------------------------------------------
{
BIGNUM *A=BN_new(); BIGNUM *B=BN_new(); BIGNUM *C=BN_new(); BIGNUM *D=BN_new(); BIGNUM *DAT=BN_new();
BIGNUM *J=BN_new(); BIGNUM *Z=BN_new(); BIGNUM *v=BN_new(); BN_CTX *ctx=BN_CTX_new();
BIGNUM *s=BN_new(); BIGNUM *x=BN_new(); BIGNUM *y=BN_new();

unsigned char *_a=hw,*_b=&hw[0x10],*_c=&hw[0x20],*_d=&hw[0x30],*_j=&hw[0x40],*_4445=&hw[0x50],*_z=hw;
unsigned int m=0x27+0x72+(A00[4]&0x3F)-0x79;
unsigned char xr=((A00[2]-1)&3)+0x0A;
A00[0]|=A00[9];
memset(hw,0,sizeof(hw));
memcpy(hw,A00,0x05);
ExpandInput(hw);
RotateBytes(_a,0x10); BN_bin2bn(_a,0x10,A); RotateBytes(_a,0x10);
RotateBytes(_b,0x10); BN_bin2bn(_b,0x10,B);
RotateBytes(_c,0x10); BN_bin2bn(_c,0x10,C);
RotateBytes(_d,0x10); BN_bin2bn(_d,0x10,D);
RotateBytes(_j,0x08); BN_bin2bn(_j,0x08,J);
RotateBytes(_4445,0x10); BN_bin2bn(_4445,0x10,DAT);
int ti=0;
int tx=0;

// printf("0x%4.4X\n",((m<<8)|A00[3]));

switch ((m<<8)|A00[3]) {
case 0x3963:
case 0x3967:
case 0x3B41:
case 0x3B7B:
case 0x3B7F:
case 0x3B8A:
BN_rshift(Z,C,64);
BN_lshift(Z,Z,64);
memset(_z,0,0x10);
break;
case 0x3986:
case 0x3A58:
case 0x3E68:
case 0x3B6A:
case 0x3B89:
case 0x3E8C:
BN_zero(v);
BN_set_bit(v,((m==0x3B)?128:136));
BN_mod(Z,v,D,ctx);
memset(_z,0,0x10);
break;
case 0x2100 ... 0x21FF:
case 0x39B0:
case 0x3BB0:
case 0x3EAE:
case 0x46BC
BN_zero(v);
BN_sub(J,v,D);
BN_set_bit(J,0);
BN_set_bit(v,64);
BN_mod_inverse(J,J,v,ctx);
BN_mask_bits(J,64);
BN_mod(D,D,v,ctx);
BN_mul(C,J,D,ctx);
BN_rshift(C,C,64);
BN_mask_bits(C,64);
BN_copy(Z,C);
memset(_z,0,8);
break;
case 0x4FCA:
BN_set_bit(Z,41);
memset(_z,0,0x10);
break;
case 0x25AB:
BN_zero(v);
BN_sub(B,v,D);
BN_set_bit(B,0);
BN_set_bit(v,128);
BN_mod_inverse(B,B,v,ctx);
BN_mask_bits(B,128);
BN_mod(D,D,v,ctx);
BN_mul(C,B,D,ctx);
BN_rshift(C,C,128);
BN_mask_bits(C,128);
BN_copy(Z,C);
memset(_z,0,0x10);
break;
case 0x3A75:
BN_mask_bits(B,64);
BN_copy(Z,B);
memset(_z,0,8);
break;
case 0x32AD:
case 0x32B3:
BN_copy(Z,D);
memset(_z,0,0x10);
break;
case 0x3846:
mmB(B,16);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
break;
case 0x3E92:
BN_copy(Z,A);
memset(_z,0,0x10);
break;
case 0x3A9C:
case 0x3CAA:
ti=1;
case 0x3E90:
case 0x3E95:
case 0x3C9F:
case 0x3CA5:
case 0x4692:
case 0x3A81:
case 0x3A86:
BN_zero(v);
BN_sub(J,v,D);
BN_set_bit(J,0);
BN_set_bit(v,64);
BN_mod_inverse(J,J,v,ctx);
BN_mask_bits(J,64);
BN_zero(v);
BN_set_bit(v,136);
BN_mod(B,v,D,ctx);
if (m==0x3A) tx=2;
for(int j=0;j<((A00[3]-((m==0x46)?0x82:0x85))>>3)+tx;j++) mmB(B,16);
if (ti) mmB(A,16);
if (xr==0x0C) BN_copy(Z,C);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
break;
case 0x3D6D:
BN_copy(D,DAT);
BN_zero(v);
BN_sub(J,v,D);
BN_set_bit(J,0);
BN_set_bit(v,64);
BN_mod_inverse(J,J,v,ctx);
BN_mask_bits(J,64);
mmB(B,16);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
break;
case 0x3AC9:
{
int o=1;
unsigned char u8[8];
for (int i=0;i<2;i++) {
memcpy(&u8[1],&_d[o<<3],7);
u8[0] = _d[(o<<3)+7];
memcpy(&_d[o<<3],u8,8);
}
BN_bin2bn(_d,0x10,Z);
memset(_z,0,16);
}
break;
case 0x3AF7:
case 0x394D:
case 0x3B4F:
BN_zero(Z);
memset(_z,0,0x10);
break;
case 0x395A:
BN_zero(Z);
BN_set_bit(Z,96);
memset(_z,0,0x10);
break;
case 0x3B5D:
BN_zero(Z);
BN_set_bit(Z,104);
memset(_z,0,0x10);
break;
case 0x2368:
ti = 1;
case 0x2362:
BN_zero(v);
BN_set_bit(v,136);
BN_mod(B,v,D,ctx);
mmB(B,16);
if (ti) mmB(B,16);
if (xr==0x0C) BN_copy(Z,C);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
break;
case 0x23A9:
BN_copy(Z,C);
memset(_z,0,0x10);
break;
case 0x23B4:
BN_zero(Z);
BN_set_bit(Z,88);
memset(_z,0,0x10);
break;
case 0x2ECE:
ti=2;
BN_rshift(Z,DAT,8<<3);
BN_lshift(Z,Z,8<<3);
BN_add(Z,Z,J);
BN_rshift(Z,Z,ti<<3);
BN_mask_bits(Z,8<<3);
memset(_z,0,8);
break;
case 0x4FBC:
BN_set_bit(Z,57);
memset(_z,0,0x10);
break;

default:
printf("unhandled module case : %4.4X\n",(m<<8)|A00[3]);
break;
}
BN_bn2bin(Z,_z); RotateBytes(_z,BN_num_bytes(Z));

for (int i=11;i>-1;i--) hw[i]^=hw[i+4]; memset(&hw[4],0,0x7C);
}