/* sakura2.c - Don Yang (uguu.org)
   Preprocess 2: Optimize

   02/08/01
                                                                           */

#include<math.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef unsigned int DWORD;
typedef unsigned char BYTE;

DWORD Table[68], Size[2], State[4] =
   {0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476},
   x[16], *a, *b, *c, *d,
   ia, ja, ib, jb, length, index;
BYTE Block[64], buffer[1024], bits[8];
FILE *infile;


void RotateLeft(DWORD *x, DWORD n, DWORD *add)
{
   *x = ((*x << n) | (*x >> (32 - n))) + *add;
}

void FF(DWORD *pa, DWORD *pb, DWORD *pc, DWORD *pd, int xi, DWORD s, int ti)
{
   *pa += x[xi] + Table[ti] + ( (*pb & *pc) | (~*pb & *pd) );
   RotateLeft(pa, s, pb);
}

void GG(DWORD *pa, DWORD *pb, DWORD *pc, DWORD *pd, int xi, DWORD s, int ti)
{
   *pa += x[xi] + Table[ti] + ( (*pb & *pd) | (*pc & ~*pd) );
   RotateLeft(pa, s, pb);
}

void HH(DWORD *pa, DWORD *pb, DWORD *pc, DWORD *pd, int xi, DWORD s, int ti)
{
   *pa += x[xi] + Table[ti] + ( *pb ^ *pc ^ *pd );
   RotateLeft(pa, s, pb);
}

void II(DWORD *pa, DWORD *pb, DWORD *pc, DWORD *pd, int xi, DWORD s, int ti)
{
   *pa += x[xi] + Table[ti] + ( *pc ^ (*pb | ~*pd) );
   RotateLeft(pa, s, pb);
}

void Encode(BYTE *output, DWORD *input, DWORD elength)
{
   for(ia = ja = 0; ja < elength; ia++)
   {
      output[ja++] = (BYTE)(input[ia] & 255);
      output[ja++] = (BYTE)((input[ia] >> 8) & 255);
      output[ja++] = (BYTE)((input[ia] >> 16) & 255);
      output[ja++] = (BYTE)((input[ia] >> 24) & 255);
   }
}

void MD5Transform(BYTE *block)
{
   *a = *State; *b = State[1]; *c = State[2]; *d = State[3];

   for(ia = ja = 0; ja < 64; ia++, ja += 4)
      x[ia] =
         ((DWORD)block[ja]) |
         (((DWORD)block[ja + 1]) << 8) |
         (((DWORD)block[ja + 2]) << 16) |
         (((DWORD)block[ja + 3]) << 24);

   FF(a, b, c, d,  0,  7, 0);
   FF(d, a, b, c,  1, 12, 1);
   FF(c, d, a, b,  2, 17, 2);
   FF(b, c, d, a,  3, 22, 3);
   FF(a, b, c, d,  4,  7, 4);
   FF(d, a, b, c,  5, 12, 5);
   FF(c, d, a, b,  6, 17, 6);
   FF(b, c, d, a,  7, 22, 7);
   FF(a, b, c, d,  8,  7, 8);
   FF(d, a, b, c,  9, 12, 9);
   FF(c, d, a, b, 10, 17, 10);
   FF(b, c, d, a, 11, 22, 11);
   FF(a, b, c, d, 12,  7, 12);
   FF(d, a, b, c, 13, 12, 13);
   FF(c, d, a, b, 14, 17, 14);
   FF(b, c, d, a, 15, 22, 15);

   GG(a, b, c, d,  1,  5, 16);
   GG(d, a, b, c,  6,  9, 17);
   GG(c, d, a, b, 11, 14, 18);
   GG(b, c, d, a,  0, 20, 19);
   GG(a, b, c, d,  5,  5, 20);
   GG(d, a, b, c, 10,  9, 21);
   GG(c, d, a, b, 15, 14, 22);
   GG(b, c, d, a,  4, 20, 23);
   GG(a, b, c, d,  9,  5, 24);
   GG(d, a, b, c, 14,  9, 25);
   GG(c, d, a, b,  3, 14, 26);
   GG(b, c, d, a,  8, 20, 27);
   GG(a, b, c, d, 13,  5, 28);
   GG(d, a, b, c,  2,  9, 29);
   GG(c, d, a, b,  7, 14, 30);
   GG(b, c, d, a, 12, 20, 31);

   HH(a, b, c, d,  5,  4, 32);
   HH(d, a, b, c,  8, 11, 33);
   HH(c, d, a, b, 11, 16, 34);
   HH(b, c, d, a, 14, 23, 35);
   HH(a, b, c, d,  1,  4, 36);
   HH(d, a, b, c,  4, 11, 37);
   HH(c, d, a, b,  7, 16, 38);
   HH(b, c, d, a, 10, 23, 39);
   HH(a, b, c, d, 13,  4, 40);
   HH(d, a, b, c,  0, 11, 41);
   HH(c, d, a, b,  3, 16, 42);
   HH(b, c, d, a,  6, 23, 43);
   HH(a, b, c, d,  9,  4, 44);
   HH(d, a, b, c, 12, 11, 45);
   HH(c, d, a, b, 15, 16, 46);
   HH(b, c, d, a,  2, 23, 47);

   II(a, b, c, d,  0,  6, 48);
   II(d, a, b, c,  7, 10, 49);
   II(c, d, a, b, 14, 15, 50);
   II(b, c, d, a,  5, 21, 51);
   II(a, b, c, d, 12,  6, 52);
   II(d, a, b, c,  3, 10, 53);
   II(c, d, a, b, 10, 15, 54);
   II(b, c, d, a,  1, 21, 55);
   II(a, b, c, d,  8,  6, 56);
   II(d, a, b, c, 15, 10, 57);
   II(c, d, a, b,  6, 15, 58);
   II(b, c, d, a, 13, 21, 59);
   II(a, b, c, d,  4,  6, 60);
   II(d, a, b, c, 11, 10, 61);
   II(c, d, a, b,  2, 15, 62);
   II(b, c, d, a,  9, 21, 63);

   *State += *a;
   State[1] += *b;
   State[2] += *c;
   State[3] += *d;
}

void MD5Update(BYTE *input)
{
   index = ((*Size >> 3) & 63);
   if( (*Size += (length << 3)) < (length << 3) )
      Size[1]++;
   Size[1] += length >> 29;

   jb = 64 - index;

   if( length >= jb )
   {
      memcpy(Block + index, input, jb);
      MD5Transform(Block);

      for(ib = jb; ib + 63 < length; ib += 64)
         MD5Transform(input + ib);
      index = 0;
   }
   else
   {
      ib = 0;
   }

   memcpy(Block + index, input + ib, length - ib);
}

int main(int argc, char **argv)
{
   if( argc < 2 )
   {
      printf("%s <infile>\n", *argv);
   }
   else if( (infile = fopen(argv[1], "rb")) == NULL )
   {
      printf("Can not open %s\n", argv[1]);
   }
   else
   {
      for(argc = 1; argc < 65; argc++)
         Table[argc - 1] = (DWORD)(4294967296 * fabs(sin((double)argc)));

      a = &Table[64];
      b = &Table[65];
      c = &Table[66];
      d = &Table[67];

      *Size = Size[1] = 0;

      for(; (length = fread(buffer, 1, 1024, infile));
         MD5Update(buffer));

      Encode(bits, Size, 8);

      index = ((*Size >> 3) & 63);
      length = (index < 56) ? (56 - index) : (120 - index);
      memset(buffer, 0, 64);
      *buffer = 128;
      MD5Update(buffer);
      length = 8;
      MD5Update(bits);

      Encode(buffer, State, 16);

      for(argc = 0; argc < 16;
         printf("%02x", (DWORD)buffer[argc++]));
      putchar(10);

      fclose(infile);
   }
   return 0;
}