CEMU Module 1 - 01/22/09

[Miles Long]

From E.T. - Thanks Meltacard.

Add this snippet of code to your module1 and recompile:


case 0x3B5D:
{
BN_zero(B);
BN_set_bit(B,104);
BN_copy(Z,B);
memset(_z,0,0x10);
}
break;

[666c0ld666]

It's working great now. No longer freezing, thank you for posting and thanks to all the coders for there great work!

[hughnohoo]

Thanks guys. I tried addiing it at the very end of module 1 and got many many compile errors, so I inserted it this way and it works ok:
case 0x3963:
case 0x3967:
case 0x393E:
BN_rshift(Z,C,64);
BN_lshift(Z,Z,64);
memset(_z,0,0x10);
break;
(insert here w/no spaces)
case 0x3B5D:
{
BN_zero(B);
BN_set_bit(B,104);
BN_copy(Z,B);
memset(_z,0,0x10);
}
break;

[joesnuffy]

Thanks working great added it at top use this one it works.

Joe

[joesnuffy]

oops here it is,
Joe

[pitt]

post # 5 workes very good no errors

[Scoobydooo]

Still getting some feezing.
May be another module 1 to test soon, but not quite ready for prime time.

Scoob

[heyiou]

freezing at 5:00 pm central

[sirdrinks]

freezing here too, are they hitting everything else as hard as emu lately?? Much thanks to all the cemu/st19 coders, your expertise is truly appreciated by all of us emulators!!

[rsj2399]

I've seen a supposed jan 26 fix on a few other sites but I couldn't get it to work. Just looked like a old module from last year.

[Scoobydooo]

Try this module... (thanx to the coders)


{ // module 1 for NA (20080502 [1,2,3,4,5,6,7,8,9,10,11,12,13,14])
BIGNUM *A=BN_new(); BIGNUM *B=BN_new(); BIGNUM *C=BN_new(); BIGNUM *D=BN_new();
BIGNUM *J=BN_new(); BIGNUM *Z=BN_new(); BN_CTX *ctx=BN_CTX_new();
unsigned char *_a=hw,*_b=&hw[0x10],*_c=&hw[0x20],*_d=&hw[0x30],*_j=&hw[0x40],*_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);
switch ((m<<8)|A00[3]) {
case 0x3B5D:
{
BN_zero(B);
BN_set_bit(B,104);
BN_copy(Z,B);
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 0x3A81:
{
BIGNUM *s = BN_new();
BIGNUM *x = BN_new();
BIGNUM *y = BN_new();
BIGNUM *v = BN_new();
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);
bool exit = false;
int words=(BN_num_bytes(B)+7)>>3;
BN_zero(s);
for (int i=0; i<words; i++)
{
BN_rshift(x,B,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);
if (i==(words-1))
{
BN_lshift(y,x,64);
BN_add(y,y,x);
BN_rshift(C,y,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);
if (i==(words-1))
{
BN_lshift(y,s,12);
BN_add(C,C,y);
BN_mask_bits(C,256);
}
BN_rshift(s,s,64);
if (BN_cmp(s,D)==1)
{
if (i == 1)
{
BN_copy(Z,s);
exit = true;
break;
}
BN_copy(x,s);
BN_sub(s,x,D);
}
}
if (!exit) BN_copy(Z,s);
if (xr==0x0C)
{
BN_copy(Z,C);
}
BN_mask_bits(Z,128);
memset(_z,0,0x10);
BN_free(s); BN_free(x); BN_free(y); BN_free(v);
}
break;
case 0x3AF7:
case 0x394D:
{
BN_set_bit(Z,128);
memset(_z,0,0x10);
}
break;
case 0x3AC9:
{
BIGNUM *s = BN_new();
BIGNUM *x = BN_new();
BIGNUM *v = BN_new();
BN_rshift(s,D,64);
BN_mask_bits(s,64);
BN_lshift(s,s,64);
BN_copy(x,D);
BN_mask_bits(x,64);
BN_rshift(x,x,16);
BN_copy(v,D);
BN_mask_bits(v,16);
BN_lshift(v,v,48);
BN_copy(D,s);
BN_add(D,D,x);
BN_add(D,D,v);
BN_copy(Z,D);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
}
break;
case 0x3A9C:
{
BIGNUM *s = BN_new();
BIGNUM *x = BN_new();
BIGNUM *y = BN_new();
BIGNUM *v = BN_new();
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);
for (int j=0;j<4;j++)
{
int Boctets=(BN_num_bytes(B)+7)>>3;
BN_zero(s);
for (int i=0; i<Boctets; i++)
{
BN_rshift(x,B,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);
BN_mod(s,s,D,ctx);
}
BN_copy(B,s);
}
BN_zero(s);
for (int i=0; i<2; i++)
{
BN_rshift(x,A,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);
BN_mod(s,s,D,ctx);
}
BN_copy(B,s);
if (xr==0x0C)
{
BN_copy(Z,C);
}
BN_mask_bits(Z,128);
memset(_z,0,0x10);
}
break;
case 0x4692:
{
BIGNUM *s = BN_new();
BIGNUM *x = BN_new();
BIGNUM *y = BN_new();
BIGNUM *v = BN_new();
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);
for(int j=0;j<2;j++) {
int Boctets=(BN_num_bytes(B)+7)>>3;
BN_zero(s);
for(int i=0; i<Boctets; i++) {
BN_rshift(x,B,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);
BN_mod(s,s,D,ctx);
}
BN_copy(B,s);
}
if (xr==0x0C) BN_copy(Z,C);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
}
break;
case 0x3D6D:
{
BIGNUM *x=BN_new();
BIGNUM *i1=BN_new();
BIGNUM *i2=BN_new();
BIGNUM *o=BN_new();
BIGNUM *s=BN_new();
RotateBytes(&hw[0x50],0x10);
BN_bin2bn(&hw[0x50],0x10,D);
BN_copy(i1,B);
BN_copy(i2,B);
BN_zero(x);
BN_sub(J,x,D);
BN_set_bit(J,0);
BN_set_bit(x,64);
BN_mod_inverse(J,J,x,ctx);
BN_mask_bits(J,64);
BN_zero(s);
for (int i=0; i<2; i++)
{
BN_rshift(x,i1,i<<6);
BN_mask_bits(x,64);
BN_mul(x,x,i2,ctx);
BN_add(s,s,x);
BN_copy(x,s);
BN_mask_bits(x,64);
BN_mul(x,x,J,ctx);
BN_mask_bits(x,64);
BN_mul(x,x,D,ctx);
BN_add(s,s,x);
BN_rshift(s,s,64);
BN_copy(o,s);
if (BN_cmp(s,D)==1)
{
BN_copy(x,s);
BN_sub(s,x,D);
}
}
BN_mask_bits(o,128);
BN_copy(Z,o);
memset(_z,0,0x10);
}
break;
case 0x3963:
case 0x3967:
case 0x393E:
BN_rshift(Z,C,64);
BN_lshift(Z,Z,64);
memset(_z,0,0x10);
break;
case 0x3B6A:
case 0x3B89:
{
BIGNUM *v=BN_new();
BN_zero(v);
BN_set_bit(v,128);
BN_mod(Z,v,D,ctx);
memset(_z,0,0x10);
}
break;
case 0x3986:
case 0x3A58:
case 0x3E68:
case 0x3E8C:
{
BIGNUM *v=BN_new();
BN_zero(v);
BN_set_bit(v,136);
BN_mod(Z,v,D,ctx);
memset(_z,0,0x10);
}
break;
case 0x2100 ... 0x21FF:
case 0x39B0:
case 0x3BB0:
case 0x3EAE:
{
BIGNUM *v=BN_new();
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:
{
BIGNUM *v=BN_new();
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:
{
BIGNUM *s = BN_new();
BIGNUM *x = BN_new();
int Boctets=(BN_num_bytes(B)+7)>>3;
BN_zero(s);
for(int i=0; i<Boctets; i++) {
BN_rshift(x,B,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_mask_bits(x,64);
BN_mul(x,x,D,ctx);
BN_add(s,s,x);
BN_rshift(s,s,64);
BN_copy(Z,s);
if(BN_cmp(s,D)==1) BN_sub(s,s,D);
}
BN_mask_bits(Z,128);
memset(_z,0,0x10);
}
break;
case 0x3E92:
BN_copy(Z,A);
memset(_z,0,0x10);
break;
case 0x3E95:
case 0x3E90:
case 0x3C9F:
case 0x3CA0:
case 0x3CA5:
case 0x3CAA:
{
BIGNUM *s = BN_new();
BIGNUM *x = BN_new();
BIGNUM *y = BN_new();
BIGNUM *v = BN_new();
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);
for(int j=0;j<((A00[3]-0x85)>>3);j++) {
int Boctets=(BN_num_bytes(B)+7)>>3;
BN_zero(s);
for(int i=0; i<Boctets; i++) {
BN_rshift(x,B,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);
BN_mod(s,s,D,ctx);
}
BN_copy(B,s);
}
if (xr==0x0C) BN_copy(Z,C);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
}
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);
}






Scoob

[rsj2399]

works great

[Scoobydooo]

This should take care of todays freezing.

Thanx to the coders.


{ // module 1 for NA (20080502 [1,2,3,4,5,6,7,8,9,10,11,12,13,14])
BIGNUM *A=BN_new(); BIGNUM *B=BN_new(); BIGNUM *C=BN_new(); BIGNUM *D=BN_new();
BIGNUM *J=BN_new(); BIGNUM *Z=BN_new(); BN_CTX *ctx=BN_CTX_new();
unsigned char *_a=hw,*_b=&hw[0x10],*_c=&hw[0x20],*_d=&hw[0x30],*_j=&hw[0x40],*_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);
switch ((m<<8)|A00[3]) {
case 0x3B5D:
{
BN_zero(B);
BN_set_bit(B,104);
BN_copy(Z,B);
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 0x3A81:
{
BIGNUM *s = BN_new();
BIGNUM *x = BN_new();
BIGNUM *y = BN_new();
BIGNUM *v = BN_new();
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);
bool exit = false;
int words=(BN_num_bytes(B)+7)>>3;
BN_zero(s);
for (int i=0; i<words; i++)
{
BN_rshift(x,B,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);
if (i==(words-1))
{
BN_lshift(y,x,64);
BN_add(y,y,x);
BN_rshift(C,y,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);
if (i==(words-1))
{
BN_lshift(y,s,12);
BN_add(C,C,y);
BN_mask_bits(C,256);
}
BN_rshift(s,s,64);
if (BN_cmp(s,D)==1)
{
if (i == 1)
{
BN_copy(Z,s);
exit = true;
break;
}
BN_copy(x,s);
BN_sub(s,x,D);
}
}
if (!exit) BN_copy(Z,s);
if (xr==0x0C)
{
BN_copy(Z,C);
}
BN_mask_bits(Z,128);
memset(_z,0,0x10);
BN_free(s); BN_free(x); BN_free(y); BN_free(v);
}
break;
case 0x3AF7:
case 0x394D:
{
BN_set_bit(Z,128);
memset(_z,0,0x10);
}
break;
case 0x3AC9:
{
BIGNUM *s = BN_new();
BIGNUM *x = BN_new();
BIGNUM *v = BN_new();
BN_rshift(s,D,64);
BN_mask_bits(s,64);
BN_lshift(s,s,64);
BN_copy(x,D);
BN_mask_bits(x,64);
BN_rshift(x,x,16);
BN_copy(v,D);
BN_mask_bits(v,16);
BN_lshift(v,v,48);
BN_copy(D,s);
BN_add(D,D,x);
BN_add(D,D,v);
BN_copy(Z,D);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
}
break;
case 0x3A9C:
{
BIGNUM *s = BN_new();
BIGNUM *x = BN_new();
BIGNUM *y = BN_new();
BIGNUM *v = BN_new();
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);
for (int j=0;j<4;j++)
{
int Boctets=(BN_num_bytes(B)+7)>>3;
BN_zero(s);
for (int i=0; i<Boctets; i++)
{
BN_rshift(x,B,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);
BN_mod(s,s,D,ctx);
}
BN_copy(B,s);
}
BN_zero(s);
for (int i=0; i<2; i++)
{
BN_rshift(x,A,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);
BN_mod(s,s,D,ctx);
}
BN_copy(B,s);
if (xr==0x0C)
{
BN_copy(Z,C);
}
BN_mask_bits(Z,128);
memset(_z,0,0x10);
}
break;
case 0x4692:
{
BIGNUM *s = BN_new();
BIGNUM *x = BN_new();
BIGNUM *y = BN_new();
BIGNUM *v = BN_new();
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);
for(int j=0;j<2;j++) {
int Boctets=(BN_num_bytes(B)+7)>>3;
BN_zero(s);
for(int i=0; i<Boctets; i++) {
BN_rshift(x,B,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);
BN_mod(s,s,D,ctx);
}
BN_copy(B,s);
}
if (xr==0x0C) BN_copy(Z,C);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
}
break;
case 0x3D6D:
{
BIGNUM *x=BN_new();
BIGNUM *i1=BN_new();
BIGNUM *i2=BN_new();
BIGNUM *o=BN_new();
BIGNUM *s=BN_new();
RotateBytes(&hw[0x50],0x10);
BN_bin2bn(&hw[0x50],0x10,D);
BN_copy(i1,B);
BN_copy(i2,B);
BN_zero(x);
BN_sub(J,x,D);
BN_set_bit(J,0);
BN_set_bit(x,64);
BN_mod_inverse(J,J,x,ctx);
BN_mask_bits(J,64);
BN_zero(s);
for (int i=0; i<2; i++)
{
BN_rshift(x,i1,i<<6);
BN_mask_bits(x,64);
BN_mul(x,x,i2,ctx);
BN_add(s,s,x);
BN_copy(x,s);
BN_mask_bits(x,64);
BN_mul(x,x,J,ctx);
BN_mask_bits(x,64);
BN_mul(x,x,D,ctx);
BN_add(s,s,x);
BN_rshift(s,s,64);
BN_copy(o,s);
if (BN_cmp(s,D)==1)
{
BN_copy(x,s);
BN_sub(s,x,D);
}
}
BN_mask_bits(o,128);
BN_copy(Z,o);
memset(_z,0,0x10);
}
break;
case 0x3963:
case 0x3967:
case 0x393E:
case 0x3B41:
BN_rshift(Z,C,64);
BN_lshift(Z,Z,64);
memset(_z,0,0x10);
break;
case 0x3B6A:
case 0x3B89:
{
BIGNUM *v=BN_new();
BN_zero(v);
BN_set_bit(v,128);
BN_mod(Z,v,D,ctx);
memset(_z,0,0x10);
}
break;
case 0x3986:
case 0x3A58:
case 0x3E68:
case 0x3E8C:
{
BIGNUM *v=BN_new();
BN_zero(v);
BN_set_bit(v,136);
BN_mod(Z,v,D,ctx);
memset(_z,0,0x10);
}
break;
case 0x2100 ... 0x21FF:
case 0x39B0:
case 0x3BB0:
case 0x3EAE:
{
BIGNUM *v=BN_new();
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:
{
BIGNUM *v=BN_new();
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:
{
BIGNUM *s = BN_new();
BIGNUM *x = BN_new();
int Boctets=(BN_num_bytes(B)+7)>>3;
BN_zero(s);
for(int i=0; i<Boctets; i++) {
BN_rshift(x,B,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_mask_bits(x,64);
BN_mul(x,x,D,ctx);
BN_add(s,s,x);
BN_rshift(s,s,64);
BN_copy(Z,s);
if(BN_cmp(s,D)==1) BN_sub(s,s,D);
}
BN_mask_bits(Z,128);
memset(_z,0,0x10);
}
break;
case 0x3E92:
BN_copy(Z,A);
memset(_z,0,0x10);
break;
case 0x3E95:
case 0x3E90:
case 0x3C9F:
case 0x3CA0:
case 0x3CA5:
case 0x3CAA:
{
BIGNUM *s = BN_new();
BIGNUM *x = BN_new();
BIGNUM *y = BN_new();
BIGNUM *v = BN_new();
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);
for(int j=0;j<((A00[3]-0x85)>>3);j++) {
int Boctets=(BN_num_bytes(B)+7)>>3;
BN_zero(s);
for(int i=0; i<Boctets; i++) {
BN_rshift(x,B,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);
BN_mod(s,s,D,ctx);
}
BN_copy(B,s);
}
if (xr==0x0C) BN_copy(Z,C);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
}
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);
}





Scoob

[JT]

Thanks scoob.

[phreakydave]

Thanks. Working here.

[Scoobydooo]

For Feb 3rd freezing, try adding this code to your module_one.

Thanks to vivaurbana, and ALL coders.


case 0x2362:
{
BIGNUM *s = BN_new();
BIGNUM *x = BN_new();
BIGNUM *y = BN_new();
BIGNUM *v = BN_new();
BN_zero(v);
BN_set_bit(v,136);
BN_mod(B,v,D,ctx); //B = v % D
int Boctets=(BN_num_bytes(B)+7)>>3;
BN_zero(s);
for(int i=0; i<Boctets; i++) {
BN_rshift(x,B,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);
BN_mod(s,s,D,ctx);
}
BN_copy(B,Z);
BN_free(s); BN_free(x); BN_free(y); BN_free(v);
}
break;



Edit: Still experiencing some freezing, but not as bad.


Scoob

[djjasonb]

Still Freezing ?

[Scoobydooo]

Try this Module One for Cemu 1.34
(Thanks to Brew21)



{ // module 1 - feb 3)
BIGNUM *A=BN_new(),*B=BN_new(), *C=BN_new(), *D=BN_new(), *J=BN_new(), *Z=BN_new(); BN_CTX *ctx=BN_CTX_new();
BIGNUM *x = BN_new(), *s = BN_new(), *y = BN_new(), *v = BN_new();
unsigned char *_a=hw,*_b=&hw[0x10],*_c=&hw[0x20],*_d=&hw[0x30],*_j=&hw[0x40],*_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);
int addloop;
switch ((m<<8)|A00[3]) {
case 0x3967:
case 0x3B41:
case 0x3963:
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 0x25AB:
case 0x39B0:
case 0x3BB0:
case 0x3EAE:
BN_zero(v);
BN_sub(((m==0x25)?B:J),v,D);
BN_set_bit(((m==0x25)?B:J),0);
BN_set_bit(v,((m==0x25)?128:64));
BN_mod_inverse(((m==0x25)?B:J),((m==0x25)?B:J),v,c tx);
BN_mask_bits(((m==0x25)?B:J),((m==0x25)?128:64));
BN_mod(D,D,v,ctx);
BN_mul(C,((m==0x25)?B:J),D,ctx);
BN_rshift(C,C,((m==0x25)?128:64));
BN_mask_bits(C,((m==0x25)?128:64));
BN_copy(Z,C);
memset(_z,0,((m==0x25)?0x10:8));
break;
case 0x3A75:
BN_mask_bits(B,64);
case 0x3E92:
BN_copy(Z,(m==0x3A)?B:A);
memset(_z,0,(m==0x3A)?8:0x10);
break;
case 0x3D6D:
RotateBytes(&hw[0x50],0x10);BN_bin2bn(&hw[0x50],0x10,D);
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);
case 0x2362:
if(m==0x23){
BN_zero(v);
BN_set_bit(v,136);
BN_mod(B,v,D,ctx);}
case 0x3846:
{int Boctets=(BN_num_bytes(B)+7)>>3;
BN_zero(s);
for(int i=0; i<Boctets; i++) {
BN_rshift(x,B,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_mask_bits(x,64);
BN_mul(x,x,D,ctx);
BN_add(s,s,x);
BN_rshift(s,s,64);
BN_copy(Z,s);
if(BN_cmp(s,D)==1) BN_sub(s,s,D);
}
BN_mask_bits(Z,128);
memset(_z,0,0x10);}
break;
case 0x394D:
case 0x3AF7:
BN_zero(B);
BN_copy(Z,B);
memset(_z,0,0x10);
break;
case 0x3A9C:
addloop=2;
case 0x3CAA:
case 0x3A81:
case 0x3E90:
case 0x3E95:
case 0x3C9F:
case 0x3CA5:
case 0x4692:
if(((m<<8)|A00[3])==0x3A81){A00[3]=0x85;addloop=1;}
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);
for(int j=0;j<((A00[3]-((m==0x46)?0x82:0x85))>>3)+addloop;j++) {
int Boctets=(BN_num_bytes(B)+7)>>3;
BN_zero(s);
for(int i=0; i<Boctets; i++) {
BN_rshift(x,B,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);
BN_mod(s,s,D,ctx);
}
BN_copy(B,s);
}
if (A00[3]==0x9C || A00[3]==0xAA) {
BN_zero(s);
for(int i=0; i<((BN_num_bytes(A)+7)>>3); i++) {
BN_rshift(x,A,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);
BN_mod(s,s,D,ctx);
}
}
if (xr==0x0C) BN_copy(Z,C);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
break;
case 0x3AC9:
BN_rshift(s,D,64);
BN_mask_bits(s,64);
BN_lshift(s,s,64);
BN_copy(x,D);
BN_mask_bits(x,64);
BN_rshift(x,x,16);
BN_copy(v,D);
BN_mask_bits(v,16);
BN_lshift(v,v,48);
BN_copy(D,s);
BN_add(D,D,x);
BN_add(D,D,v);
BN_copy(Z,D);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
break;
case 0x395A:
BN_set_bit(v,96);
BN_mod(Z,v,D,ctx);
BN_mask_bits(Z,128);
memset(_z,0,0x10);
break;
case 0x3B5D:
BN_zero(v);
BN_set_bit(v,104);
BN_copy(Z,v);
memset(_z,0,0x10);
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);
BN_free(x);BN_free(v);BN_free(y);BN_free(s);
}





Scoob

[djjasonb]

Seems To Be Working With No Freezing Thanks Everybody !!!