// Remove // of the next line if you want to test this module.
//#define testMBnhash   // main() in this module will be used (-> MB192hash is
                         // tested), and do not change any lines below.

/***** Select a hash-type *****/

//#define MB64hash
//#define MB160hash
//#define MB192hash
//#define MB256hash
//#define MB384hash
//#define MB512hash
//#define MB1024hash
//#define MB2048hash
//#define MB4096hash

#ifdef testMBnhash
  #define MB192hash
#endif

/******************/

#include <stdio.h>
#include <memory.h>

  #ifdef MB64hash
    #define HS_name "MB64h5B"
  #endif
  #ifdef MB160hash
    #define HS_name "MB160h5B"
  #endif
  #ifdef MB192hash
      #define HS_name "MB192h5B"
  #endif
  #ifdef MB256hash
      #define HS_name "MB256h5B"
  #endif
  #ifdef MB384hash
      #define HS_name "MB384h5B"
  #endif
  #ifdef MB512hash
      #define HS_name "MB512h5B"
  #endif
  #ifdef MB1024hash
      #define HS_name "MB1024h5B"
  #endif
  #ifdef MB2048hash
      #define HS_name "MB2048h5B"
  #endif
  #ifdef MB4096hash
      #define HS_name "MB4096h5B"
  #endif

/******************************/
#define  HSBufSize  1024
#define  mIntMSB    0x80000000
#define  mIntBaseM1     0xffffffff
#define  mIntBaseBits   32

#ifdef MB64hash
    #define  HSHashBitSize 64         // L=8(byte)(must be int size)
    #define  HScompXsizeByte 4        // M=4(byte)
    #define  HSCharsInOneComp 2       // E=2(byte)
    #define  HScompEPosByte 2         // P=2(byte)(pos. starting from 1)
    #define  HSshiftByteInOneComp 1   // D=1(byte)
    int  HSscrYsizeByte = 4;          // Q=4(byte)
    int  HSscrBitShiftSize = 6;       // S=6/8(byte)
    int  HSscrBitShiftTimes = 16;
    int  HSHashBgnBit = 16;           // Q/2(byte)
    //----------------------------//
    #define  mIntIntSize    3
    #define  mIntIndexMin   1
    #define  mIntIndexMax   2
    //----------------------------//
#endif

#ifdef MB160hash
    #define  HSHashBitSize 160        // L=20(byte)
    #define  HScompXsizeByte 8        // M=8(byte)
    #define  HSCharsInOneComp 8       // E=8(byte)
    #define  HScompEPosByte 5         // P=5(byte)(pos. starting from 1)
    #define  HSshiftByteInOneComp 4   // D=4(byte)
    int  HSscrYsizeByte = 12;         // Q=12(byte)
    int  HSscrBitShiftSize = 16;      // S=2(byte)
    int  HSscrBitShiftTimes = 16;
    int  HSHashBgnBit = 32;           // not Q/2(byte)
    //----------------------------//
    #define  mIntIntSize    6
    #define  mIntIndexMin   1
    #define  mIntIndexMax   5
    //----------------------------//
#endif

#ifdef MB192hash
    #define  HSHashBitSize 192        // L=24(byte)
    #define  HScompXsizeByte 8        // M=8(byte)
    #define  HSCharsInOneComp 8       // E=8(byte)
    #define  HScompEPosByte 5         // P=5(byte)(pos. starting from 1)
    #define  HSshiftByteInOneComp 4   // D=4(byte)
    int  HSscrYsizeByte = 12;         // Q=12(byte)
    int  HSscrBitShiftSize = 16;      // S=2(byte)
    int  HSscrBitShiftTimes = 16;
    int  HSHashBgnBit = 32;           // not Q/2(byte)
    //----------------------------//
    #define  mIntIntSize    7
    #define  mIntIndexMin   1
    #define  mIntIndexMax   6
    //----------------------------//
#endif

#ifdef MB256hash
    #define  HSHashBitSize 256        // L=32(byte)(must be int size)
    #define  HScompXsizeByte 8        // M=8(byte)
    #define  HSCharsInOneComp 8       // E=8(byte)
    #define  HScompEPosByte 5         // P=5(byte)(pos. starting from 1)
    #define  HSshiftByteInOneComp 4   // D=4(byte)
    int  HSscrYsizeByte = 12;         // Q=12(byte)
    int  HSscrBitShiftSize = 24;      // S=3(byte)
    int  HSscrBitShiftTimes = 16;
    int  HSHashBgnBit = 32;           // not Q/2(byte)
    //----------------------------//
    #define  mIntIntSize    9
    #define  mIntIndexMin   1
    #define  mIntIndexMax   8
    //----------------------------//
#endif

#ifdef MB384hash
    #define  HSHashBitSize 384        // L=48(byte)(must be int size)
    #define  HScompXsizeByte 12       // M=12(byte)
    #define  HSCharsInOneComp 16      // E=16(byte)
    #define  HScompEPosByte 9         // P=9(byte)(pos. starting from 1)
    #define  HSshiftByteInOneComp 8   // D=8(byte)
    int  HSscrYsizeByte = 12;         // Q=12(byte)
    int  HSscrBitShiftSize = 32;      // S=4(byte)
    int  HSscrBitShiftTimes = 16;
    int  HSHashBgnBit = 48;           // Q/2(byte)
    //----------------------------//
    #define  mIntIntSize    13
    #define  mIntIndexMin   1
    #define  mIntIndexMax   12
    //----------------------------//
#endif

#ifdef MB512hash
    #define  HSHashBitSize 512        // L=64(byte)(must be int size)
    #define  HScompXsizeByte 12       // M=12(byte)
    #define  HSCharsInOneComp 16      // E=16(byte)
    #define  HScompEPosByte 9         // P=9(byte)(pos. starting from 1)
    #define  HSshiftByteInOneComp 8   // D=8(byte)
    int  HSscrYsizeByte = 16;         // Q=16(byte)
    int  HSscrBitShiftSize = 48;      // S=6(byte)
    int  HSscrBitShiftTimes = 16;
    int  HSHashBgnBit = 62;           // Q/2(byte)
    //----------------------------//
    #define  mIntIntSize    17
    #define  mIntIndexMin   1
    #define  mIntIndexMax   16
    //----------------------------//
#endif

#ifdef MB1024hash
    #define  HSHashBitSize 1024       // L=128(byte)(must be int size)
    #define  HScompXsizeByte 20       // M=20(byte)
    #define  HSCharsInOneComp 32      // E=32(byte)
    #define  HScompEPosByte 17        // P=17(byte)(pos. starting from 1)
    #define  HSshiftByteInOneComp 16  // D=16(byte)
    int  HSscrYsizeByte = 28;         // Q=28(byte)
    int  HSscrBitShiftSize = 96;      // S=12(byte)
    int  HSscrBitShiftTimes = 16;
    int  HSHashBgnBit = 112;          // Q/2(byte)
    //----------------------------//
    #define  mIntIntSize    33
    #define  mIntIndexMin   1
    #define  mIntIndexMax   32
    //----------------------------//
#endif

#ifdef MB2048hash
    #define  HSHashBitSize 2048       // L=256(byte)(must be int size)
    #define  HScompXsizeByte 36       // M=36(byte)
    #define  HSCharsInOneComp 64      // E=64(byte)
    #define  HScompEPosByte 33        // P=33(byte)(pos. starting from 1)
    #define  HSshiftByteInOneComp 32  // D=32(byte)
    int  HSscrYsizeByte = 52;         // Q=52(byte)
    int  HSscrBitShiftSize = 192;     // S=24(byte)
    int  HSscrBitShiftTimes = 16;
    int  HSHashBgnBit = 208;          // Q/2(byte)
    //----------------------------//
    #define  mIntIntSize    65
    #define  mIntIndexMin   1
    #define  mIntIndexMax   64
    //----------------------------//
#endif

#ifdef MB4096hash
    #define  HSHashBitSize 4096       // L=512(byte)(must be int size)
    #define  HScompXsizeByte 68       // M=68(byte)
    #define  HSCharsInOneComp 128     // E=128(byte)
    #define  HScompEPosByte 65        // P=65(byte)(pos. starting from 1)
    #define  HSshiftByteInOneComp 64  // D=64(byte)
    int  HSscrYsizeByte = 96;         // Q=96(byte)
    int  HSscrBitShiftSize = 384;     // S=48(byte)
    int  HSscrBitShiftTimes = 16;
    int  HSHashBgnBit = 384;          // Q/2(byte)
    //----------------------------//
    #define  mIntIntSize    129
    #define  mIntIndexMin   1
    #define  mIntIndexMax   128
    //----------------------------//
#endif

/********************** type def for mInt *********************/
typedef struct
    {
    unsigned int mIdgt[mIntIntSize];
    } mInt;
typedef struct
    {
    unsigned int mIdgt[1+mIntIndexMax*2];
    } mIntD;

#ifndef MB_LLHL
#define MB_LLHL
typedef struct                    /* Intel's MPU only */
    {
    unsigned int L;
    unsigned int H;
    } uiHL;
typedef union
    {
    unsigned long long int I;
    uiHL HL;
    } uiLLHL;
typedef union
    {
    unsigned long long int I;
    uiHL HL;
    double Dbl;
    } uiLLHL_Dbl;
#endif

typedef union
    {
    unsigned int  ui[mIntIntSize];
    unsigned char uc[mIntIntSize*sizeof(int)];
    } HS;
typedef union
    {
    unsigned int  ui[1+mIntIndexMax*2];
    unsigned char uc[(1+mIntIndexMax*2)*sizeof(int)];
    } HSD;
/*************** constant for hashing *********************/
//1.2718281828459...  MSB = 1   BaseForm[N[1+E/10,1500]*8,16]
unsigned int HSconst1_4800bits[1+5*5*6] =
    {
    0,

    0xa2cb4411,    0xba257552,    0x232c1139,    0xa172a5c9,    0xf8252780,
    0xc2d5d7b7,    0x88603e0d,    0x04140a65,    0x8f50b929,    0x3a8572fe,
    0xb2a32d7a,    0x47027df8,    0x314d239a,    0x22f4137e,    0xf72c9fc4,
    0x5dff7aad,    0x073d976c,    0xac9ae2f6,    0x8113e111,    0x0c629efd,
    0x8aab03df,    0xb3118ea4,    0x51a968e3,    0x602e1be4,    0xc6ee1b92,

    0x30c994e3,    0x9f96ab53,    0x7155fb0a,    0xa355c20f,    0xdb3ee518,
    0x8c022380,    0x8a3a98ad,    0x29ce8842,    0x56f4fa65,    0x8b7bc557,
    0xe02b30e1,    0x9f764087,    0x2c71dc64,    0x22de2f94,    0xad7d589e,
    0x9bce54c1,    0xc9354916,    0x860098f9,    0xf5fe6095,    0xc00a675c,
    0x3b3da313,    0x837d661f,    0x61e780cc,    0xb60fd070,    0x9630804d,

    0x8d993f05,    0x75afef7d,    0x725798f2,    0x6fc06ccd,    0xf44fc9e7,
    0x190480bd,    0x5afd753a,    0xf38a2ffe,    0xe81573a4,    0xe0398ff8,
    0xf93ddf0b,    0xe10500ab,    0xf270fdc6,    0x31ec0071,    0xad24165b,
    0x91615b67,    0xe55e9f6e,    0x1d3197fc,    0x784f5698,    0x8d1af838,
    0xefcc6a35,    0x1a9d83b0,    0x2403cf50,    0xbf40b1da,    0x9765da76,

    0xfa2b0f90,    0xadca2d39,    0x49fddbff,    0xdf561a22,    0x5285fe1f,
    0xc815d58d,    0xd3a47202,    0xbbf439eb,    0x1f02c892,    0x05f31eda,
    0x2ac0db42,    0xcef29015,    0x98772c63,    0x0c056cfc,    0x732ab918,
    0xd460d2a2,    0x47b93963,    0x7c7caa27,    0x0475fdcb,    0xe509c860,
    0xfab4de57,    0xbc19130d,    0x5e1fe29e,    0x7e47296c,    0x4433d99a,

    0x819778ba,    0xb2d6c27e,    0xe371281a,    0xfcbda382,    0x2f7b9f99,
    0xd5ec7b3d,    0x5501799b,    0xb6b37027,    0x4927e4fe,    0xb055ccd8,
    0x01d51eba,    0x3d8f1be5,    0x386c583f,    0x7d0cccd8,    0xd542f621,
    0xfeb5cef5,    0x9bb3b6c2,    0xc2f51929,    0x82f52445,    0x4cb4edaf,
    0x0f8abb43,    0x97404d60,    0x5ae8667f,    0xac692b66,    0xcf32adbe,

    0x0dcd7c18,    0x7614b2a2,    0x71aa3ba5,    0x3a58740d,    0x5bcaa621,
    0x3f2410d6,    0xebe46dc1,    0xb6b25f7a,    0x89f365dc,    0x23e94f3d,
    0x75b005a5,    0x5c55ce11,    0x98f6627d,    0x1f0645a6,    0x0fa79a6c,
    0xa4e6a7ff,    0x0f65f0e4,    0xbaa0e397,    0xeebb7b69,    0xbe77706f,
    0xc57a402b,    0x5336301d,    0x3dcdd060,    0x9bbfc066,    0x652d86e2
    };

// for HS compression
HS  HScompXM, HScompFM;
unsigned int  HSCharLenOld, HSInCharNo;

int  HSxorStartPosInt, HSxorEndPosInt, HSxorSizeInt;
int  HSxorStartPosC, HSxorStartPosCrev;
HS   HSstoreCharsInOneComp;
int  HSxorClrStartPosIntrev;
int  HSCmpShift_IntSize, HSCmpShift_ByteSize, HSCmpShift_ByteSizeC;

/******** to debug mInt ********/
void DumpMint(mInt *M, char c)
    {
    int  i;
    printf("%c ", c);
    for (i=mIntIndexMin-1; i<=mIntIndexMax; i++)
        {printf("%08x ", M->mIdgt[i]);}
    printf("\n");
    }
void DumpMintD(mIntD *MD, char c)
    {
    int  i;
    printf("%c ", c);
    for (i=mIntIndexMin-1; i<=mIntIndexMax*2; i++)
        {printf("%08x ", MD->mIdgt[i]);}
    printf("\n");
    }
/*===============================================================*/
int mIntMUL_HL(mInt *U, mInt *V, mIntD *UVD)
    {
    uiLLHL LLHLu, LLHLv, LLHLw;
    int i, j, iPj;
    unsigned long long int c, uv;
    uiLLHL LLMulAddWk;

    if (U->mIdgt[mIntIndexMin-1] != 0) {return(1);}
    if (V->mIdgt[mIntIndexMin-1] != 0) {return(2);}

    memset(UVD, 0, sizeof(mIntD));

    LLHLu.I = 0;
    LLHLv.I = 0;
    LLHLw.I = 0;

    for (j=mIntIndexMax; j>=mIntIndexMin; j--)       /* V */
        {
        if (V->mIdgt[j] == 0)
            {
            UVD->mIdgt[j] = 0;
            continue;
            }

        c=0;
        LLHLv.HL.L = V->mIdgt[j];
        for (i=mIntIndexMax; i>=mIntIndexMin; i--)   /* U */
            {
            iPj = i+j;
            LLHLu.HL.L = U->mIdgt[i];
            uv = LLHLv.I * LLHLu.I;   /* u*v */
            LLMulAddWk.I = (uv & mIntBaseM1);
            LLHLw.HL.L = UVD->mIdgt[iPj];
            LLMulAddWk.I += LLHLw.I;
            LLMulAddWk.I += c;
            UVD->mIdgt[iPj] = LLMulAddWk.HL.L;
            c = (uv >> mIntBaseBits);
            c += (LLMulAddWk.I >> mIntBaseBits);
            }
        UVD->mIdgt[j] = (unsigned int)c;
        }

    return(0);
    }

/*****************/
void MBhashInit(void)
    {
    int HScompXsizeInt, HScompXsizeByteRmdr, wk;
    unsigned long long int uiWk;

    int InitValBytes;
    int A=sizeof(mInt), B=sizeof(HSconst1_4800bits);
    if (A>B)
        {InitValBytes=B;}
      else
        {InitValBytes=A;}
    memset(&HScompFM, 0, sizeof(mInt));
    memcpy(&HScompFM, HSconst1_4800bits, InitValBytes);
    //DumpMint((mInt *)&HScompFM, 'f');    //debug

    memset(&HScompXM, 0, sizeof(mInt));
    HScompXsizeInt = HScompXsizeByte/(mIntBaseBits/8);
    HScompXsizeByteRmdr = HScompXsizeByte%(mIntBaseBits/8);
    //printf("HScompXsizeByte : %d  HScompXsizeInt : %d  HScompXsizeByteRmdr : %d\n",
    //        HScompXsizeByte, HScompXsizeInt, HScompXsizeByteRmdr);  //debug
    if (HScompXsizeByteRmdr)
        {
        HScompXsizeInt++;
        memcpy(&HScompXM, &HSconst1_4800bits, (HScompXsizeInt+1)*(mIntBaseBits/8));
        wk = ((mIntBaseBits/8)-HScompXsizeByteRmdr)*8;
        HScompXM.ui[HScompXsizeInt] >>= wk;
        HScompXM.ui[HScompXsizeInt] <<= HScompXsizeByteRmdr*8;
        uiWk = mIntMSB;
        uiWk >>= (HScompXsizeByteRmdr*8-1);
        HScompXM.ui[HScompXsizeInt] |= uiWk;    //LSB
        }
      else
        {
        memcpy(&HScompXM, &HSconst1_4800bits, (HScompXsizeInt+1)*(mIntBaseBits/8));
        HScompXM.ui[HScompXsizeInt] |= 1;         //LSB
        }
    HScompXM.ui[mIntIndexMin] |= mIntMSB;         //MSB
    //DumpMint((mInt *)&HScompXM, 'x');    //debug

    HSxorStartPosInt = ((HScompEPosByte-1)/(mIntBaseBits/8))+1;
    HSxorSizeInt = ((HSCharsInOneComp*3)/2)/(mIntBaseBits/8);
    if ( ((HSCharsInOneComp*3)/2) % (mIntBaseBits/8) ) {HSxorSizeInt++;}
    HSxorEndPosInt = HSxorStartPosInt+HSxorSizeInt-1;
    if (HSxorEndPosInt>mIntIndexMax) {printf("HSxorEndPosInt>mIntIndexMax\n");}
    HSxorStartPosC = HScompEPosByte-1+(mIntBaseBits/8);
    HSxorStartPosCrev = mIntIntSize*(mIntBaseBits/8) - HSxorStartPosC -1;
    HSxorClrStartPosIntrev = mIntIndexMax - HSxorStartPosInt - HSxorSizeInt + 1;

    //printf("HScompEPosByte : %d   HSCharsInOneComp : %d   EXT-HSCharsInOneComp %d\n",
    //        HScompEPosByte, HSCharsInOneComp, (HSCharsInOneComp*3)/2);  //debug
    //printf("HSxorStartPosInt : %d  HSxorEndPosInt : %d  HSxorSizeInt: %d\n",
    //        HSxorStartPosInt, HSxorEndPosInt, HSxorSizeInt); //debug
    //printf("HSxorStartPosC : %d  HSxorStartPosCrev : %d\n", HSxorStartPosC, HSxorStartPosCrev); //debug
    //printf("HSxorClrStartPosIntrev : %d  HScompXsizeByte %d\n", HSxorClrStartPosIntrev, HScompXsizeByte); //debug

    HSCmpShift_IntSize = HSshiftByteInOneComp/(mIntBaseBits/8);
    HSCmpShift_ByteSize = HSshiftByteInOneComp % (mIntBaseBits/8);
    HSCmpShift_ByteSizeC = (mIntBaseBits/8)- HSCmpShift_ByteSize;
    //printf("HSCmpShift_IntSize : %d  HSCmpShift_ByteSize : %d  HSCmpShift_ByteSizeC : %d\n",
    //        HSCmpShift_IntSize, HSCmpShift_ByteSize, HSCmpShift_ByteSizeC);  //debug

    memset(&HSstoreCharsInOneComp, 0, sizeof(mInt));
    //memset(&HSstoreCharsInOneComp, 0xff, sizeof(mInt));  //debug
    //DumpMint((mInt *)&HSstoreCharsInOneComp, 's');    //debug

    HSCharLenOld=HSBufSize;
    HSInCharNo=0;
    }
/*****************/
int MBhashCompress(unsigned char *HSBuf, int CharLen)
    {
    int  i, j, k, p, kekka;
    HSD  HSWkMD;
    int  storeCharPos, mod3;

    if (CharLen==0) {return(1);}
    if (CharLen<0)
        {
        printf("Err: CharLen<0 (%d) \n", CharLen);
        return(2);
        }
    if (HSCharLenOld != HSBufSize)
        {
        printf("Err: Previous CharLen(%d) != HSBufSize(%d)\n", HSCharLenOld, HSBufSize);
        return(3);
        }
    HSCharLenOld = CharLen;

    for(j=0; j<CharLen; j+=HSCharsInOneComp)
        {
        memset(&HSstoreCharsInOneComp.ui[HSxorClrStartPosIntrev], 0, HSxorSizeInt*(mIntBaseBits/8));
        //DumpMint((mInt *)&HSstoreCharsInOneComp, 'S');    //debug
        mod3 = 0;
        storeCharPos = HSxorStartPosCrev;
        if (j+HSCharsInOneComp <= CharLen)
            {
            for (i=j; i<j+HSCharsInOneComp; i++)
                {
                HSstoreCharsInOneComp.uc[storeCharPos] = HSBuf[i];
                storeCharPos--;
                mod3++;
                if ((mod3 % 3)==2) {storeCharPos--; mod3++;}
                }
            HSInCharNo += HSCharsInOneComp;
            }
          else
            {
            for (i=j; i<CharLen; i++)
                {
                HSstoreCharsInOneComp.uc[storeCharPos] = HSBuf[i];
                storeCharPos--;
                mod3++;
                if ((mod3 % 3)==2) {storeCharPos--; mod3++;}
                HSInCharNo++;
                }
            }
        //DumpMint((mInt *)&HSstoreCharsInOneComp, 't');    //debug
        //memset(&HScompFM, 0, sizeof(mInt));  //debug
        for (i=0; i<HSxorSizeInt; i++)
            {
            HScompFM.ui[HSxorStartPosInt+i] 
                 ^= HSstoreCharsInOneComp.ui[mIntIndexMax-HSxorStartPosInt-i];
            }
          
        HScompFM.ui[mIntIndexMin] |= mIntMSB;
        HScompFM.ui[mIntIndexMax] |= 1;       //LSB
        // MSB, LSB=1 of HScompXM is in MBhashInit

        //DumpMint((mInt *)&HScompFM, 'f');   //debug
        //DumpMint((mInt *)&HScompXM, 'x');   //debug
        kekka = mIntMUL_HL((mInt *)&HScompFM, (mInt *)&HScompXM, (mIntD *)&HSWkMD);  //multiply
        if (kekka != 0)
            {
            printf("mIntMUL_HL != 0 : %d\n", kekka);
            return(kekka);
            }
        //DumpMintD((mIntD *)&HSWkMD, 'd');   //debug

        for (i=1; i<=mIntIndexMax; i++)
            {
            if (HSCmpShift_ByteSize==0)
                {
                HScompFM.ui[i]  = HSWkMD.ui[i+HSCmpShift_IntSize];
                }
              else
                {
                HScompFM.ui[i]  = (HSWkMD.ui[i+HSCmpShift_IntSize]<<(HSCmpShift_ByteSize*8));
                HScompFM.ui[i]  |= (HSWkMD.ui[i+HSCmpShift_IntSize+1]>>(HSCmpShift_ByteSizeC*8));
                }  
            }
        //DumpMint((mInt *)&HScompFM, 'F');   //debug
        }

    return(0);
    }

/****************/
int MBhashGenVal(HS *HashValueM)
    {
    int  i, j, k, mIntResult;
    int  HSBitShift_IntSize, HSBitShift_BitSizeRmdr, HSBitShift_BitSizeRmdrC;
    int  HSHashBgnInt, HSHashBgnBitRmdr;
    HS   scrFM, scrYM;
    HSD  scrWk1MD;

    int  wk1, wk2;
    int  HScompEPosByteRmdr;
    unsigned int uiWk1;
    int HSscrYsizeByteRmdr, HSscrYsizeInt, pointYIntPos;
    uiLLHL uiLLHL1, uiLLHL2;

    HSscrYsizeInt = HSscrYsizeByte/(mIntBaseBits/8);
    HSscrYsizeByteRmdr = HSscrYsizeByte % (mIntBaseBits/8);
    //printf("HSscrYsizeByte : %d  HSscrYsizeInt : %d  HSscrYsizeBytreRmdr : %d\n",
    //        HSscrYsizeByte, HSscrYsizeInt, HSscrYsizeByteRmdr);  //debug

    memcpy(&scrFM, &HScompFM, sizeof(mInt));
    //DumpMint((mInt *)&scrFM, 'f');   //debug

    // xor HSInCharNo
    //memset(&scrFM, 0, sizeof(mInt));  //debug
    //HSInCharNo = 0xf123456d;  //debug
    uiWk1 = HSInCharNo;
    HScompEPosByteRmdr = ((HScompEPosByte-1)%(mIntBaseBits/8));
    if (HScompEPosByteRmdr == 0)
        {
        scrFM.ui[HSxorStartPosInt]  ^= HSInCharNo;
        }
      else
        {
        wk1 = HScompEPosByteRmdr*8;
        uiWk1 >>= wk1;
        scrFM.ui[HSxorStartPosInt]  ^= uiWk1;
        uiWk1 = HSInCharNo;
        wk2 = ( ( (mIntBaseBits/8) - HScompEPosByteRmdr ) )*8;
        uiWk1 <<= wk2;
        scrFM.ui[HSxorStartPosInt+1]  ^= uiWk1;
        }
    //DumpMint((mInt *)&scrFM, 'g');   //debug

    // prepare scrYM
    memset(&scrYM, 0, sizeof(mInt));
    //memset(&scrFM, 0x01, sizeof(mInt));  //debug
    //DumpMint((mInt *)&scrYM, 'Y');   //debug
    //DumpMint((mInt *)&scrFM, 'F');   //debug
    if (HSscrYsizeByteRmdr==0)
        {
        //** SSInhash
        //for (i=0; i<mIntIndexMax; i++)
        //    {
        //    scrYM.ui[mIntIndexMin+(i % HSscrYsizeInt)] ^= scrFM.ui[mIntIndexMin+i];
        //    }
        //** MBnhash
        for (i=0; i<HSscrYsizeInt; i++)
            {
            scrYM.ui[mIntIndexMin+i] = scrFM.ui[mIntIndexMin+i];
            }
        scrYM.ui[HSscrYsizeInt] |= 1;    //LSB (HSscrYsizeByteRmdr=0)
        }
      else
        {
        //** SSInhash
        //printf("Err : HSscrYsizeByte must be of int size\n");
        //** MBnhash
        for (i=0; i<=HSscrYsizeInt; i++)
            {
            scrYM.ui[mIntIndexMin+i] = scrFM.ui[mIntIndexMin+i];
            }
        wk2 = ( ( (mIntBaseBits/8) - HSscrYsizeByteRmdr ) )*8;
        scrYM.ui[mIntIndexMin+HSscrYsizeInt] >>= wk2;
        scrYM.ui[mIntIndexMin+HSscrYsizeInt] |= 1;   //LSB (HSscrYsizeByteRmdr!=0)
        scrYM.ui[mIntIndexMin+HSscrYsizeInt] <<= wk2;
        
        }
    //DumpMint((mInt *)&scrYM, 'y');   //debug
    //memset(&scrYM, 0, sizeof(mInt));  //debug
    scrYM.ui[mIntIndexMin] |= mIntMSB;
    //DumpMint((mInt *)&scrYM, 'Y');   //debug

    // scramble main
    HSBitShift_IntSize = HSscrBitShiftSize / mIntBaseBits;
    HSBitShift_BitSizeRmdr = HSscrBitShiftSize % mIntBaseBits;
    HSBitShift_BitSizeRmdrC = mIntBaseBits-HSBitShift_BitSizeRmdr;
    //printf("HSBitShift_IntSize : %d  HSBitShift_BitSizeRmdr : %d\n",
    //        HSBitShift_IntSize, HSBitShift_BitSizeRmdr);  //debug
    //printf("HSBitShift_BitSizeRmdrC : %d\n", HSBitShift_BitSizeRmdrC); //debug
    for (i=1; i<=HSscrBitShiftTimes; i++)
    //for (i=1; i<=1; i++)  //debug
        {
        //memset(&scrFM, 0, sizeof(mInt));  //debug
        scrFM.ui[mIntIndexMin] |= mIntMSB;
        scrFM.ui[mIntIndexMax] |= 1;
        //DumpMint((mInt *)&scrFM, 'f');   //debug
        mIntResult = mIntMUL_HL((mInt *)&scrFM, (mInt *)&scrYM, (mIntD *)&scrWk1MD);
        if (mIntResult != 0) {return(3000+mIntResult);}
        //DumpMintD((mIntD *)&scrWk1MD, 'D');   //debug
        
        for (j=1; j<=mIntIndexMax; j++)
            {
            if (HSBitShift_BitSizeRmdr==0)
                {
                scrFM.ui[j]  = scrWk1MD.ui[j+HSBitShift_IntSize];
                }
              else
                {
                scrFM.ui[j]  = (scrWk1MD.ui[j+HSBitShift_IntSize]<<HSBitShift_BitSizeRmdr);
                scrFM.ui[j]  |= (scrWk1MD.ui[j+HSBitShift_IntSize+1]>>HSBitShift_BitSizeRmdrC);
                }  
            }
        //DumpMint((mInt *)&scrFM, 'F');   //debug
        }
    //DumpMint((mInt *)&scrFM, 'F');   //debug

    // take out random number
    //DumpMintD((mIntD *)&scrWk1MD, 'D');   //debug
    HSHashBgnInt = HSHashBgnBit/mIntBaseBits;
    HSHashBgnBitRmdr = HSHashBgnBit % mIntBaseBits;
    //printf("HSHashBgnBit : %d  HSHashBgnInt : %d  HSHashBgnBitRmdr : %d\n",
    //        HSHashBgnBit, HSHashBgnInt, HSHashBgnBitRmdr); //debug
    for (j=1; j<=mIntIndexMax; j++)
        {
        if (HSHashBgnBitRmdr==0)
            {
            HashValueM->ui[j] = scrWk1MD.ui[j+HSHashBgnInt];
            }
          else
            {
            HashValueM->ui[j] = (scrWk1MD.ui[HSHashBgnInt+j] << HSHashBgnBitRmdr);
            HashValueM->ui[j] |= (scrWk1MD.ui[HSHashBgnInt+j+1] >> (mIntBaseBits-HSHashBgnBitRmdr));
            }
        }
    
    HashValueM->ui[mIntIndexMin-1]=0;
    //DumpMint((mInt *)HashValueM, 'H');   //debug

    return(0);
    }

/********************* testMBnhash ***********************/


     // MBnhash should be used such as
     //
     //      unsigned char Msg_Buf[HSBufSize]        // HSBufSize=1024
     //      HS   HashValue;                         // store hash value
     //
     //      MBhashInit();                          //initialize MBhash
     //      MBhashCompress(Msg_Buf, HSBufSize);    //send data to MBhash
     //      .....
     //      MBhashCompress(Msg_Buf, HSBufSize);
     //      MBhashCompress(Msg_Buf, kk);           // 0 < kk <= HSBufSize
     //      MBhashGenVal(&HashValue);              //generate a hash value


#ifdef testMBnhash
int main()
    {
    int  i;
    unsigned char Msg_Buf[HSBufSize] = "01234567";   // HSBufSize=1024
    HS   HashValue;

    for (i=8; i<HSBufSize; i++)
        {Msg_Buf[i]=Msg_Buf[i-8];}

    MBhashInit();                                   //initialize MBhash

    MBhashCompress(Msg_Buf, 1024);                  //send data to MBhash
    MBhashCompress(Msg_Buf, 1024);                  //send data to MBhash
    MBhashCompress(Msg_Buf, 8);                     //send data to MBhash

    MBhashGenVal(&HashValue);                       //generate a hash value

    printf("\n=== Result is ===\n\n");
    printf("MBnhash = [%s] \n", HS_name);      //show MBhash name

    for (i=1; i<=mIntIndexMax; i++)                  //show hash value
        {printf( "%08x ", HashValue.ui[i]);}          //(using unsigned int)
    printf("\n");
    printf("6d486cbd eafcb5da 3cfe19a4 6822d1cd 0acfaa02 a4e87751 (should be)\n");

    return(0);
    }
#endif