#ifdef WIN32
#include <windows.h>
#define delay(a) Sleep((a))

#else

#define INCL_BASE
#define INCL_DOSSEMAPHORES

#include <os2.h>
#define delay(a) DosSleep((a))

#endif

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MAX_THREADS 32

#ifdef WIN32
//
// - hStartOfRace is a manual reset event that is signalled when
//   all of the threads are supposed to cut loose and begin working
//
// - hEndOfRace is a manual reset event that is signalled once the end time
//   has been retrieved and it is ok for the threads to exit
//

HANDLE hStartOfRace;
HANDLE hEndOfRace;


//
// - ThreadReadyDoneEvents are an array of autoclearing events. The threads
//   initially signal these events once they have reached their start routines
//   and are ready to being processing. Once they are done processing, they
//   signal thier event to indicate that they are done processing.
//
// - ThreadHandles are an array of thread handles to the worker threads. The
//   main thread waits on these to know when all of the threads have exited.
//

HANDLE ThreadReadyDoneEvents[MAX_THREADS];
HANDLE ThreadHandles[MAX_THREADS];

DWORD WorkerThread(PVOID ThreadIndex);
DWORD ThreadId;
DWORD StartTicks, EndTicks;
HANDLE IoHandle;
#else
/*
// - hStartOfRace is a manual reset event that is signalled when
//   all of the threads are supposed to cut loose and begin working
//
// - hEndOfRace is a manual reset event that is signalled once the end time
//   has been retrieved and it is ok for the threads to exit
*/

HEV hStartOfRace;
HEV hEndOfRace;


/*
// - ThreadReadyDoneEvents are an array of autoclearing events. The threads
//   initially signal these events once they have reached their start routines
//   and are ready to being processing. Once they are done processing, they
//   signal thier event to indicate that they are done processing.
//
// - ThreadHandles are an array of thread handles to the worker threads. The
//   main thread waits on these to know when all of the threads have exited.
*/

SEMRECORD ThreadReadyDoneEvents1[MAX_THREADS];
SEMRECORD ThreadReadyDoneEvents2[MAX_THREADS];
TID ThreadHandles[MAX_THREADS];
HMUX MuxWait1;
HMUX MuxWait2;

VOID WorkerThread(PVOID ThreadIndex);
#pragma linkage(WorkerThread,system)

#define _CRTAPI1

APIRET rv1, rv2;
clock_t StartTicks, EndTicks;
#define ExitProcess(a) DosExit(EXIT_PROCESS,(a))
#define GetTickCount clock
HFILE IoHandle;
HMTX MutexHandle;
#endif

#define SIXTY_FOUR_K    (64*1024)
#define SIXTEEN_K       (16*1024)
unsigned int InitialBuffer[SIXTY_FOUR_K/sizeof(unsigned int)];
#define NUMBER_OF_WRITES ((1024*1024*8)/SIXTY_FOUR_K)
#define BUFFER_MAX  (64*1024)
#define FILE_SIZE ((1024*1024*8)-BUFFER_MAX)

/*
// Each thread has a THREAD_WORK structure. This contains the address
// of the cells that this thread is responsible for, and the number of
// cells it is supposed to process.
*/

typedef struct _THREAD_WORK {
    unsigned long *CellVector;
    int NumberOfCells;
    int RecalcResult;
    char ReadBuffer[BUFFER_MAX];
    char SortedBuffer[BUFFER_MAX];
#ifdef WIN32
    OVERLAPPED Overlapped;
#else
    HFILE IoHandle;
#endif
} THREAD_WORK, *PTHREAD_WORK;

THREAD_WORK ThreadWork[MAX_THREADS];
#define ONE_MB      (1024*1024)

unsigned long Mb = 4;
int NumberOfThreads = 1;
unsigned long ExpectedRecalcValue;
unsigned long ActualRecalcValue;
unsigned long ContentionValue;
int fMemoryContention;
int fIoMode;
int fSortToo;
int WorkIndex;
int BufferSize;

void
SortTheBuffer(
    unsigned int *Destination,
    unsigned int *Source,
    int DwordCount
    );

unsigned int
Random (
    unsigned int nMaxValue
    )
{
    return(((2 * rand() * nMaxValue + RAND_MAX) / RAND_MAX - 1) / 2);
}

int _CRTAPI1
main(
    int argc,
    char *argv[],
    char *envp[]
    )
{
    int i;
    int fShowUsage;
    char c, *p, *whocares;
    unsigned long *CellVector;
    int NumberOfDwords;
    int CNumberOfDwords;
    int DwordsPerThread;
    char *Answer;
    unsigned long x;

    fShowUsage = 0;
    fMemoryContention = 0;
    fIoMode = 0;
    fSortToo = 0;
    WorkIndex = 10;
    BufferSize = 1024;

    if (argc <= 1) {
        goto showUsage;
        }

    while (--argc) {
        p = *++argv;
        if (*p == '/' || *p == '-') {
            while (c = *++p)
            switch (toupper( c )) {
            case '?':
                fShowUsage = 1;
                goto showUsage;
                break;

            case 'M':
                if (!argc--) {
                    fShowUsage = 1;
                    goto showUsage;
                    }
                argv++;
                Mb = strtoul(*argv,&whocares,10);
                if ( Mb == 0 ) {
                    Mb = 1;
                    }
                break;

            case 'C':
                fMemoryContention = 1;
                break;

            case 'I':
                fIoMode = 1;
                break;

            case 'S':
                fSortToo = 1;
                break;

            case 'T':
                if (!argc--) {
                    fShowUsage = 1;
                    goto showUsage;
                    }
                argv++;
                NumberOfThreads = strtoul(*argv,&whocares,10);
                if ( NumberOfThreads > MAX_THREADS ) {
                    fShowUsage = 1;
                    goto showUsage;
                    }
                break;

            case 'W':
                if (!argc--) {
                    fShowUsage = 1;
                    goto showUsage;
                    }
                argv++;
                WorkIndex = strtoul(*argv,&whocares,10);
                break;

            case 'B':
                if (!argc--) {
                    fShowUsage = 1;
                    goto showUsage;
                    }
                argv++;
                BufferSize = strtoul(*argv,&whocares,10) * 1024;
                if ( BufferSize > BUFFER_MAX ) {
                    BufferSize = BUFFER_MAX;
                    }
                break;

            default:
                fprintf( stderr, "MTBNCH: Invalid switch - /%c\n", c );
                goto showUsage;
                break;
                }
            }
        }

showUsage:
    if ( fShowUsage ) {
        fprintf(stderr,"usage: MTBNCH\n" );
        fprintf(stderr,"              [-?] display this message\n" );
        fprintf(stderr,"              [-t n] use n threads for benchmark (less than 32)\n" );
        fprintf(stderr,"              [-m n] use an n Mb spreadsheet size (default 4)\n" );
        fprintf(stderr,"              [-c] cause memory contention on each loop iteration\n" );
        fprintf(stderr,"              [-i] do I/O in each loop iteration\n" );
        fprintf(stderr,"              [-s] after each I/O sort the buffer\n" );
        fprintf(stderr,"              [-w n] The lower the number, the more I/O is done\n" );
        ExitProcess(1);
        }

    /*
    // Prepare the race events. These are manual reset events.
    */
#ifdef WIN32
    hStartOfRace = CreateEvent(NULL,TRUE,FALSE,NULL);
    hEndOfRace = CreateEvent(NULL,TRUE,FALSE,NULL);

    if ( !hStartOfRace || !hEndOfRace ) {
#else
    rv1 = DosCreateEventSem(NULL,&hStartOfRace,0,FALSE);
    rv2 = DosCreateEventSem(NULL,&hEndOfRace,0,FALSE);
    if ( rv1 || rv2 ) {
#endif
        fprintf(stderr,"MTBNCH: Race Event Creation Failed\n");
        ExitProcess(1);
        }

    if ( fIoMode ) {
        /*
        // In I/O mode, we create a large file and fill it with random
        // values
        */
        srand(1);
#ifdef WIN32
        DeleteFile("mtbnch.dat");

        IoHandle = CreateFile(
                    "mtbnch.dat",
                    GENERIC_READ | GENERIC_WRITE,
                    FILE_SHARE_READ | FILE_SHARE_WRITE,
                    NULL,
                    OPEN_ALWAYS,
                    FILE_FLAG_DELETE_ON_CLOSE | FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
                    NULL
                    );
        if ( IoHandle == INVALID_HANDLE_VALUE ) {
            fprintf(stderr, "mtbnch: Error opening file %d\n",GetLastError());
            exit(1);
            }

        //
        // Initialize the file with random data
        //
        {
            DWORD lc;
            INT i;
            BOOL b;
            int WriteCount;

            ThreadWork[0].Overlapped.Offset = 0;
            for (WriteCount = 0; WriteCount < NUMBER_OF_WRITES; WriteCount++){

                for(lc=0;lc<SIXTEEN_K;lc++){
                    InitialBuffer[lc] = (DWORD)rand();
                    }

                b = WriteFile(IoHandle,InitialBuffer,sizeof(InitialBuffer),&lc,&ThreadWork[0].Overlapped);

                if ( !b && GetLastError() != ERROR_IO_PENDING ) {
                    fprintf(stderr, "mtbnch: Error in pre-write %d\n",GetLastError());
                    exit(1);
                    }
                b = GetOverlappedResult(
                        IoHandle,
                        &ThreadWork[0].Overlapped,
                        &lc,
                        TRUE
                        );
                if ( !b || lc != sizeof(InitialBuffer) ) {
                    fprintf(stderr, "mtbnch: Wait for pre-write failed %d\n",GetLastError());
                    exit(1);
                    }
                ThreadWork[0].Overlapped.Offset += lc;
                }
        }
#else
        {
            ULONG ulAction;
            ULONG lc;
            int i;
            int WriteCount;

            DosDelete("mtbnch.dat");
            rv1 = DosOpen(
                    "mtbnch.dat",
                    &IoHandle,
                    &ulAction,
                    0,
                    0,
                    0x10,
                    OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYNONE,
                    0
                    );
            if ( rv1 ) {
                fprintf(stderr, "mtbnch: open failed %d\n",rv1);
                exit(1);
                }

            for (WriteCount = 0; WriteCount < NUMBER_OF_WRITES; WriteCount++){

                for(lc=0;lc<SIXTEEN_K;lc++){
                    InitialBuffer[lc] = rand();
                    }

                rv1 = DosWrite(IoHandle,InitialBuffer,sizeof(InitialBuffer),&lc);

                if ( rv1 || lc != sizeof(InitialBuffer) ) {
                    fprintf(stderr, "mtbnch: Error in pre-write %d %d\n",rv1,lc);
                    exit(1);
                    }
                }
            rv1 = DosCreateMutexSem(NULL,&MutexHandle,0,FALSE);
            if ( rv1 ) {
                fprintf(stderr, "mtbnch: mutex create failed %d\n",rv1);
                exit(1);
                }
        }
#endif
        srand(1);
        }

    /*
    // Prepare the ready done events. These are auto clearing events
    */

    for(i=0; i<NumberOfThreads; i++ ) {
#ifdef WIN32
        ThreadReadyDoneEvents[i] = CreateEvent(NULL,FALSE,FALSE,NULL);
        if ( !ThreadReadyDoneEvents[i] ) {
            fprintf(stderr,"MTBNCH: Ready Done Event Creation Failed %d\n",GetLastError());
#else
        rv1 = DosCreateEventSem(NULL,(HEV *)&ThreadReadyDoneEvents1[i].hsemCur,0,FALSE);
        rv2 = DosCreateEventSem(NULL,(HEV *)&ThreadReadyDoneEvents2[i].hsemCur,0,FALSE);
        if ( rv1 || rv2 ) {
            fprintf(stderr,"MTBNCH: Ready Done Event Creation Failed %d %d\n",rv1,rv2);
#endif
            ExitProcess(1);
            }
        }
#ifndef WIN32

    rv1 = DosCreateMuxWaitSem(NULL,&MuxWait1,NumberOfThreads,&ThreadReadyDoneEvents1[0],DCMW_WAIT_ALL);
    rv2 = DosCreateMuxWaitSem(NULL,&MuxWait2,NumberOfThreads,&ThreadReadyDoneEvents2[0],DCMW_WAIT_ALL);
    if ( rv1 || rv2) {
        fprintf(stderr,"MTBNCH: Mux Wait Semaphore Creation Failed %d\n",rv1,rv2);
        ExitProcess(1);
        }
#endif

    /*
    // Allocate and initialize the CellVector
    */
#ifdef WIN32
    CellVector = (PDWORD)VirtualAlloc(NULL,Mb*ONE_MB,MEM_COMMIT,PAGE_READWRITE);
    if ( !CellVector ) {
        fprintf(stderr,"MTBNCH: Cell Vector Allocation Failed %d\n",GetLastError());
#else
    rv1 = DosAllocMem((PVOID)&CellVector,Mb*ONE_MB,PAG_COMMIT | PAG_READ | PAG_WRITE);
    if ( rv1 ) {
        fprintf(stderr,"MTBNCH: Cell Vector Allocation Failed %d\n",rv1);
#endif
        ExitProcess(1);
        }

    NumberOfDwords = (Mb*ONE_MB) / sizeof(unsigned long);
    if ( fIoMode ) {
        NumberOfDwords = NumberOfDwords / (2*(BufferSize/1024));
        }
    CNumberOfDwords = NumberOfDwords;
    DwordsPerThread = NumberOfDwords / NumberOfThreads;

    /*
    // Initialize the Cell Vector
    */

    for(i=0, ExpectedRecalcValue=0; i<NumberOfDwords; i++ ){
        ExpectedRecalcValue += i;
        CellVector[i] = i;
        }

    /*
    // Partition the work to the worker threads
    */

    for(i=0; i<NumberOfThreads; i++ ){
        ThreadWork[i].CellVector = &CellVector[i*DwordsPerThread];
        ThreadWork[i].NumberOfCells = DwordsPerThread;
        NumberOfDwords -= DwordsPerThread;

        /*
        // If we have a remainder, give the remaining work to the last thread
        */

        if ( NumberOfDwords < DwordsPerThread ) {
            ThreadWork[i].NumberOfCells += NumberOfDwords;
            }
        }

    /*
    // Create the worker threads
    */

    for(i=0; i<NumberOfThreads; i++ ) {
#ifdef WIN32
        ThreadHandles[i] = CreateThread(
                                NULL,
                                0,
                                WorkerThread,
                                (PVOID)i,
                                0,
                                &ThreadId
                                );
        if ( !ThreadHandles[i] ) {
            fprintf(stderr,"MTBNCH: Worker Thread Creation Failed %d\n",GetLastError());
            ExitProcess(1);
            }
#else
        rv1 = DosCreateThread(&ThreadHandles[i],WorkerThread,i,0,8192);
        if ( rv1 ) {
            fprintf(stderr,"MTBNCH: Worker Thread Creation Failed %d\n",rv1);
            ExitProcess(1);
            }
#endif
        }

    /*
    // All of the worker threads will signal thier ready done event
    // when they are idle and ready to proceed. Once all events have been
    // set, then setting the hStartOfRaceEvent will begin the recalc
    */
#ifdef WIN32
    i = WaitForMultipleObjects(
            NumberOfThreads,
            ThreadReadyDoneEvents,
            TRUE,
            INFINITE
            );

    if ( i == WAIT_FAILED ) {
        fprintf(stderr,"MTBNCH: Wait for threads to stabalize Failed %d\n",GetLastError());
#else
    rv1 = DosWaitMuxWaitSem(MuxWait1,SEM_INDEFINITE_WAIT,&x);
    if ( rv1 ) {
        fprintf(stderr,"MTBNCH: Wait for threads to stabalize Failed %d\n",rv1);
#endif
        ExitProcess(1);
        }

    /*
    // Everthing is set to begin the recalc operation
    */

    StartTicks = GetTickCount();
#ifdef WIN32
    if ( !SetEvent(hStartOfRace) ) {
        fprintf(stderr,"MTBNCH: SetEvent(hStartOfRace) Failed %d\n",GetLastError());
#else
    rv1 = DosPostEventSem(hStartOfRace);
    if ( rv1 ) {
        fprintf(stderr,"MTBNCH: DosPostEventSem(hStartOfRace) Failed %d\n",rv1);
#endif
        ExitProcess(1);
        }

    /*
    // Now just wait for the recalc to complete
    */

#ifdef WIN32
    i = WaitForMultipleObjects(
            NumberOfThreads,
            ThreadReadyDoneEvents,
            TRUE,
            INFINITE
            );

    if ( i == WAIT_FAILED ) {
        fprintf(stderr,"MTBNCH: Wait for threads to complete Failed %d\n",GetLastError());
#else
    rv1 = DosWaitMuxWaitSem(MuxWait2,SEM_INDEFINITE_WAIT,&x);
    if ( rv1 ) {
        fprintf(stderr,"MTBNCH: Wait for threads to stabalize Failed %d\n",rv1);
#endif
        ExitProcess(1);
        }

    if ( fIoMode ) {
        EndTicks = GetTickCount();
        fprintf(stdout,"MTBNCH: %d Complete in %dms\n",
            NumberOfThreads,
            EndTicks-StartTicks
            );
        }
    else {
        /*
        // Now pick up the individual recalc values
        */

        for(i=0, ActualRecalcValue = 0; i<NumberOfThreads; i++ ){
            ActualRecalcValue += ThreadWork[i].RecalcResult;
            }

        EndTicks = GetTickCount();

        if ( fMemoryContention ) {
            if ( ContentionValue == (Mb*ONE_MB) / sizeof(unsigned long) ) {
                if ( ActualRecalcValue == ExpectedRecalcValue ) {
                    Answer = "Correct";
                    }
                else {
                    Answer = "Recalc Failure";
                    }
                }
            else {
                Answer = "Contention Failure";
                }
            }
        else {
            if ( ActualRecalcValue == ExpectedRecalcValue ) {
                Answer = "Correct";
                }
            else {
                Answer = "Recalc Failure";
                }
            }


        fprintf(stdout,"MTBNCH: %d Thread Recalc complete in %dms, Answer = %s\n",
            NumberOfThreads,
            EndTicks-StartTicks,
            Answer
            );
        }

    ExitProcess(2);
}

/*
// The worker threads perform the recalc operation on their
// assigned cells. They begin by setting their ready done event
// to indicate that they are ready to begin the recalc. Then they
// wait until the hStartOfRace event is signaled. Once this occurs, they
// do their part of the recalc and when done they signal their ready done
// event and then wait on the hEndOfRaceEvent
*/

#ifdef WIN32
DWORD
#else
VOID
#endif
WorkerThread(
    PVOID ThreadIndex
    )
{

    unsigned long Me;
    unsigned long *MyCellVectorBase;
    unsigned long *CurrentCellVector;
    unsigned long MyRecalcValue;
    unsigned long MyNumberOfCells;
    unsigned long i,j;
    char *ReadBuffer;
    char *SortedBuffer;
    int MemoryContention;
    unsigned int offset;
    unsigned int nbytes;
#ifdef WIN32
    HANDLE hEvent;
    BOOL b;
#else
    ULONG ulNew;
    APIRET rv;
#endif

    Me = (unsigned long)ThreadIndex;
    MyRecalcValue = 0;
    MyCellVectorBase = ThreadWork[Me].CellVector;
    MyNumberOfCells = ThreadWork[Me].NumberOfCells;
    MemoryContention = fMemoryContention;
    ReadBuffer = &ThreadWork[Me].ReadBuffer;
    SortedBuffer = &ThreadWork[Me].SortedBuffer;

    /*
    // Signal that I am ready to go
    */
#ifdef WIN32
    hEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
    ThreadWork[Me].Overlapped.hEvent = hEvent;
    if ( !SetEvent(ThreadReadyDoneEvents[Me]) ) {
        fprintf(stderr,"MTBNCH: (1) SetEvent(ThreadReadyDoneEvent[%d]) Failed %d\n",Me,GetLastError());
#else
    if ( fIoMode ) {
        ULONG ulAction;
        rv = DosOpen(
                "mtbnch.dat",
                &ThreadWork[Me].IoHandle,
                &ulAction,
                0,
                0,
                0x01,
                OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYNONE,
                0
                );
        if ( rv ) {
            fprintf(stderr, "mtbnch: open failed %d\n",rv1);
            exit(1);
            }
        }
    rv = DosPostEventSem((HEV)ThreadReadyDoneEvents1[Me].hsemCur);
    if ( rv ) {
        fprintf(stderr,"MTBNCH: (1) SetEvent(ThreadReadyDoneEvent[%d]) Failed %d\n",Me,rv);
#endif
        ExitProcess(1);
        }

    /*
    // Wait for the master to release us to do the recalc
    */

#ifdef WIN32
    i = WaitForSingleObject(hStartOfRace,INFINITE);
    if ( i == WAIT_FAILED ) {
        fprintf(stderr,"MTBNCH: Thread %d Wait for start of recalc Failed %d\n",Me,GetLastError());
#else
    rv = DosWaitEventSem(hStartOfRace,SEM_INDEFINITE_WAIT);
    if ( rv ) {
        fprintf(stderr,"MTBNCH: Thread %d Wait for start of recalc Failed %d\n",Me,rv);
#endif
        ExitProcess(1);
        }

    /*
    // perform the recalc operation
    */

    for (i=0, CurrentCellVector = MyCellVectorBase,j=0; i<MyNumberOfCells; i++ ) {
        MyRecalcValue += *CurrentCellVector++;
        if ( j == WorkIndex ) {
            j = 0;

            /*
            // Every 15 cells, do a random read from the file
            */

            if ( fIoMode ) {
                offset = Random(FILE_SIZE/BUFFER_MAX)*BUFFER_MAX;
#ifdef WIN32
                ThreadWork[Me].Overlapped.Offset = offset;
                b = ReadFile(
                        IoHandle,
                        ReadBuffer,
                        BufferSize,
                        &nbytes,
                        &ThreadWork[Me].Overlapped
                        );
                if ( !b && GetLastError() != ERROR_IO_PENDING ) {
                    fprintf(stderr, "mtbnch: Error in client read %d\n",GetLastError());
                    exit(1);
                    }
                b = GetOverlappedResult(
                        IoHandle,
                        &ThreadWork[Me].Overlapped,
                        &nbytes,
                        TRUE
                        );
                if ( !b ) {
                    fprintf(stderr, "mtbnch: Wait for read failed %d\n",GetLastError());
                    exit(1);
                    }
#else
                rv = DosSetFilePtr(ThreadWork[Me].IoHandle,offset,0,&ulNew);
                if ( rv ) {
                    fprintf(stderr, "mtbnch: Error in seek %d Offset %x\n",rv,offset);
                    exit(1);
                    }
                rv = DosRead(ThreadWork[Me].IoHandle,ReadBuffer,BufferSize,&nbytes);
                if ( rv || nbytes != BufferSize ) {
                    fprintf(stderr, "mtbnch: Error in client read %d\n",rv);
                    exit(1);
                    }
#endif
                SortTheBuffer((unsigned int *)SortedBuffer,(unsigned int *)ReadBuffer,nbytes>>2);
                }
            }
        else {
            j++;
            }
        if ( MemoryContention ) {
#ifdef WIN32
            InterlockedIncrement(&ContentionValue);
#else
            DosEnterCritSec();
            ContentionValue++;
            DosExitCritSec();
#endif
            }
        }
    ThreadWork[Me].RecalcResult = MyRecalcValue;

    /*
    // Signal that I am done and then wait for further instructions
    */

#ifdef WIN32
    if ( !SetEvent(ThreadReadyDoneEvents[Me]) ) {
        fprintf(stderr,"MTBNCH: (2) SetEvent(ThreadReadyDoneEvent[%d]) Failed %d\n",Me,GetLastError());
#else
    rv = DosPostEventSem((HEV)ThreadReadyDoneEvents2[Me].hsemCur);
    if ( rv ) {
        fprintf(stderr,"MTBNCH: (1) SetEvent(ThreadReadyDoneEvent2[%d]) Failed %d\n",Me,rv);
#endif
        ExitProcess(1);
        }

#ifdef WIN32
    i = WaitForSingleObject(hEndOfRace,INFINITE);
    if ( i == WAIT_FAILED ) {
        fprintf(stderr,"MTBNCH: Thread %d Wait for end of recalc Failed %d\n",Me,GetLastError());
#else
    rv = DosWaitEventSem(hEndOfRace,SEM_INDEFINITE_WAIT);
    if ( rv ) {
        fprintf(stderr,"MTBNCH: Thread %d Wait for end of recalc Failed %d\n",Me,rv);
#endif
        ExitProcess(1);
        }

#ifdef WIN32
    return MyRecalcValue;
#endif
}

int
#ifdef WIN32
_CRTAPI1
#endif
DwordComp(const void *e1,const void *e2)
{
    unsigned long *p1;
    unsigned long *p2;

    p1 = (unsigned long *)e1;
    p2 = (unsigned long *)e2;

    return (*p1 - *p2);
}

void
SortTheBuffer(
    unsigned int *Destination,
    unsigned int *Source,
    int DwordCount
    )

{
    int i;

    for(i=0;i<1;i++){
        memcpy(Destination,Source,DwordCount<<2);
        qsort((void *)Destination,(size_t)DwordCount,(size_t)sizeof(unsigned int),DwordComp);
        }
}