Strange algorithm

[Copax]

The M calculator gives the same code to M052441 and also to M150528. Code is 1514.
Isn't it a little strange ? What algorithm is this ? :hmmmm2:

[GMXcool]

const lpf: array[0..99] of byte = (
9, 5, 3, 4, 8, 7, 2, 6, 1, 0,
2, 1, 5, 6, 9, 3, 7, 0, 4, 8,
0, 4, 7, 3, 1, 9, 6, 5, 8, 2,
5, 6, 4, 1, 2, 8, 0, 9, 3, 7,
6, 3, 1, 2, 0, 5, 4, 8, 7, 9,
4, 0, 8, 7, 6, 1, 9, 3, 2, 5,
7, 8, 0, 5, 3, 2, 1, 4, 9, 6,
1, 9, 6, 8, 7, 4, 5, 2, 0, 3,
3, 2, 9, 0, 4, 6, 8, 7, 5, 1,
8, 7, 2, 9, 5, 0, 3, 1, 6, 4
);

function TfmFordM.calcCode;
var
k5, j5, i5, l4, k4, j4, i4, l3, k3, j3, i3, l2, k2, j2, i2, l1, k1, j1, i1 : integer;
j, k, l: integer;
byte0, byte1, byte2, byte3, byte4, byte5, byte6, byte7, byte8, byte9, byte10: byte;
begin
k4 := serial div $186a0;
serial := serial mod $186a0;
j4 := serial div 10000;
serial := serial mod 10000;
i4 := serial div 1000;
serial := serial mod 1000;
l3 := serial div 100;
serial := serial mod 100;
k3 := serial div 10;
serial := serial mod 10;
j3 := serial;
i3 := j3 * 10 + 5;
byte5 := lpf[i3];
i3 := k3 * 10 + 3;
byte6 := lpf[i3];
i3 := l3 * 10 + 8;
byte7 := lpf[i3];
i3 := i4 * 10 + 2;
byte8 := lpf[i3];
i3 := j4 * 10 + 1;
byte9 := lpf[i3];
i3 := k4 * 10 + 6;
byte10 := lpf[i3];
l2 := 0;
i3 := byte6 * 10 + byte5;
j := lpf[i3];
inc( j );
i3 := byte10 * 10 + byte6;
k := lpf[i3];
inc( k );
l := j * k;
i3 := byte8 * 10 + byte7;
j := lpf[i3];
inc( j );
i3 := l2 * 10 + byte9;
k := lpf[i3];
inc( k );
i1 := j * k;
i3 := byte5 * 10 + byte8;
byte0 := lpf[i3];
j1 := l + i1 + byte0;
k1 := j1 mod 10;
i3 := k1 * 10 + 5;
byte1 := lpf[i3];
i3 := byte6 * 10 + byte5;
j := lpf[i3];
inc( j );
i3 := byte9 * 10 + byte8;
k := lpf[i3];
inc( k );
l := j * k;
i3 := byte9 * 10 + byte6;
j := lpf[i3];
inc( j );
i3 := l2 * 10 + byte7;
k := lpf[i3];
inc( k );
i1 := j * k;
i3 := byte5 * 10 + byte10;
byte0 := lpf[i3];
j1 := l + i1 + byte0;
k1 := j1 mod 10;
i3 := k1 * 10 + 1;
byte2 := lpf[i3];
i3 := byte6 * 10 + byte5;
j := lpf[i3];
inc( j );
i3 := byte8 * 10 + byte6;
k := lpf[i3];
inc( k );
l := j * k;
i3 := byte7 * 10 + byte10;
j := lpf[i3];
inc( j );
i3 := l2 * 10 + byte8;
k := lpf[i3];
inc( k );
i1 := j * k;
i3 := byte5 * 10 + byte9;
byte0 := lpf[i3];
j1 := l + i1 + byte0;
k1 := j1 mod 10;
i3 := k1 * 10 + 8;
byte3 := lpf[i3];
i3 := byte6 * 10 + byte5;
j := lpf[i3];
inc( j );
i3 := byte10 * 10 + byte7;
k := lpf[i3];
inc( k );
l := j * k;
i3 := byte7 * 10 + l2;
j := lpf[i3];
inc( j );
i3 := byte6 * 10 + byte9;
k := lpf[i3];
inc( k );
i1 := j * k;
i3 := byte8 * 10 + byte5;
byte0 := lpf[i3];
j1 := l + i1 + byte0;
k1 := j1 mod 10;
i3 := k1 * 10 + 0;
byte4 := lpf[i3];
l1 := (byte1 + 1) * (byte2 + 1) + 105;
i2 := (byte2 + 1) * (byte4 + 1) + 102;
j2 := (byte1 + 1) * (byte3 + 1) + 103;
k2 := (byte3 + 1) * (byte4 + 1) + 108;
l4 := ((l1 mod 10 + l1 div 10) mod 10 + byte5) mod 10;
i5 := ((i2 mod 10 + i2 div 10) mod 10 + byte5) mod 10;
j5 := ((j2 mod 10 + j2 div 10) mod 10 + byte5) mod 10;
k5 := ((k2 mod 10 + k2 div 10) mod 10 + byte5) mod 10;
calcCode := Chr( ord( '0' ) + k5 ) + Chr( ord( '0' ) + j5 ) + Chr( ord( '0' ) + i5 ) + Chr( ord( '0' ) + l4 );
end;

[bonus2010]

The M calculator gives the same code to M052441 and also to M150528. Code is 1514.
Isn't it a little strange ? What algorithm is this ? :hmmmm2:

Having looked at M algo, no really strange... you've got one million serial numbers... so not surprising two serial numbers give same code.

Here's becker four digit code for serial number xxxx3361 and xxxx1326 >>>> both 6765.

Gotta admit.... still confused too. :hmmmm2:




.