I can't seem to get this code to execute...... can somone show me how?.... it keeps looking for an executable ....?

MD5ChecksumDefines.h
=======================================================================================================================
//Magic initialization constants
#define MD5_INIT_STATE_0 0x67452301
#define MD5_INIT_STATE_1 0xefcdab89
#define MD5_INIT_STATE_2 0x98badcfe
#define MD5_INIT_STATE_3 0x10325476

//Constants for Transform routine.
#define MD5_S11  7
#define MD5_S12 12
#define MD5_S13 17
#define MD5_S14 22
#define MD5_S21  5
#define MD5_S22  9
#define MD5_S23 14
#define MD5_S24 20
#define MD5_S31  4
#define MD5_S32 11
#define MD5_S33 16
#define MD5_S34 23
#define MD5_S41  6
#define MD5_S42 10
#define MD5_S43 15
#define MD5_S44 21

//Transformation Constants - Round 1
#define MD5_T01  0xd76aa478 //Transformation Constant 1
#define MD5_T02  0xe8c7b756 //Transformation Constant 2
#define MD5_T03  0x242070db //Transformation Constant 3
#define MD5_T04  0xc1bdceee //Transformation Constant 4
#define MD5_T05  0xf57c0faf //Transformation Constant 5
#define MD5_T06  0x4787c62a //Transformation Constant 6
#define MD5_T07  0xa8304613 //Transformation Constant 7
#define MD5_T08  0xfd469501 //Transformation Constant 8
#define MD5_T09  0x698098d8 //Transformation Constant 9
#define MD5_T10  0x8b44f7af //Transformation Constant 10
#define MD5_T11  0xffff5bb1 //Transformation Constant 11
#define MD5_T12  0x895cd7be //Transformation Constant 12
#define MD5_T13  0x6b901122 //Transformation Constant 13
#define MD5_T14  0xfd987193 //Transformation Constant 14
#define MD5_T15  0xa679438e //Transformation Constant 15
#define MD5_T16  0x49b40821 //Transformation Constant 16

//Transformation Constants - Round 2
#define MD5_T17  0xf61e2562 //Transformation Constant 17
#define MD5_T18  0xc040b340 //Transformation Constant 18
#define MD5_T19  0x265e5a51 //Transformation Constant 19
#define MD5_T20  0xe9b6c7aa //Transformation Constant 20
#define MD5_T21  0xd62f105d //Transformation Constant 21
#define MD5_T22  0x02441453 //Transformation Constant 22
#define MD5_T23  0xd8a1e681 //Transformation Constant 23
#define MD5_T24  0xe7d3fbc8 //Transformation Constant 24
#define MD5_T25  0x21e1cde6 //Transformation Constant 25
#define MD5_T26  0xc33707d6 //Transformation Constant 26
#define MD5_T27  0xf4d50d87 //Transformation Constant 27
#define MD5_T28  0x455a14ed //Transformation Constant 28
#define MD5_T29  0xa9e3e905 //Transformation Constant 29
#define MD5_T30  0xfcefa3f8 //Transformation Constant 30
#define MD5_T31  0x676f02d9 //Transformation Constant 31
#define MD5_T32  0x8d2a4c8a //Transformation Constant 32

//Transformation Constants - Round 3
#define MD5_T33  0xfffa3942 //Transformation Constant 33
#define MD5_T34  0x8771f681 //Transformation Constant 34
#define MD5_T35  0x6d9d6122 //Transformation Constant 35
#define MD5_T36  0xfde5380c //Transformation Constant 36
#define MD5_T37  0xa4beea44 //Transformation Constant 37
#define MD5_T38  0x4bdecfa9 //Transformation Constant 38
#define MD5_T39  0xf6bb4b60 //Transformation Constant 39
#define MD5_T40  0xbebfbc70 //Transformation Constant 40
#define MD5_T41  0x289b7ec6 //Transformation Constant 41
#define MD5_T42  0xeaa127fa //Transformation Constant 42
#define MD5_T43  0xd4ef3085 //Transformation Constant 43
#define MD5_T44  0x04881d05 //Transformation Constant 44
#define MD5_T45  0xd9d4d039 //Transformation Constant 45
#define MD5_T46  0xe6db99e5 //Transformation Constant 46
#define MD5_T47  0x1fa27cf8 //Transformation Constant 47
#define MD5_T48  0xc4ac5665 //Transformation Constant 48

//Transformation Constants - Round 4
#define MD5_T49  0xf4292244 //Transformation Constant 49
#define MD5_T50  0x432aff97 //Transformation Constant 50
#define MD5_T51  0xab9423a7 //Transformation Constant 51
#define MD5_T52  0xfc93a039 //Transformation Constant 52
#define MD5_T53  0x655b59c3 //Transformation Constant 53
#define MD5_T54  0x8f0ccc92 //Transformation Constant 54
#define MD5_T55  0xffeff47d //Transformation Constant 55
#define MD5_T56  0x85845dd1 //Transformation Constant 56
#define MD5_T57  0x6fa87e4f //Transformation Constant 57
#define MD5_T58  0xfe2ce6e0 //Transformation Constant 58
#define MD5_T59  0xa3014314 //Transformation Constant 59
#define MD5_T60  0x4e0811a1 //Transformation Constant 60
#define MD5_T61  0xf7537e82 //Transformation Constant 61
#define MD5_T62  0xbd3af235 //Transformation Constant 62
#define MD5_T63  0x2ad7d2bb //Transformation Constant 63
#define MD5_T64  0xeb86d391 //Transformation Constant 64


//Null data (except for first BYTE) used to finalise the checksum calculation
static unsigned char PADDING[64] = {
  0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

==========================================================================================================================
resource.h
==========================================================================================================================
//{{NO_DEPENDENCIES}}
// Microsoft Developer Studio generated include file.
// Used by MD5.rc
//

// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE        101
#define _APS_NEXT_COMMAND_VALUE         40001
#define _APS_NEXT_CONTROL_VALUE         1000
#define _APS_NEXT_SYMED_VALUE           101
#endif
#endif
============================================================================================================================
StdAfx.h
============================================================================================================================
// stdafx.h : include file for standard system include files,
//  or project specific include files that are used frequently, but
//      are changed infrequently
//

#if !defined(AFX_STDAFX_H__EA97A192_032A_11D4_A4DA_000000000000__INCLUDED_)
#define AFX_STDAFX_H__EA97A192_032A_11D4_A4DA_000000000000__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#define VC_EXTRALEAN            // Exclude rarely-used stuff from Windows headers

#include <afx.h>
#include <afxwin.h>

// TODO: reference additional headers your program requires here

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_STDAFX_H__EA97A192_032A_11D4_A4DA_000000000000__INCLUDED_)
============================================================================================================================
MD5Checksum.cpp
============================================================================================================================
#include "stdafx.h"
#include "MD5Checksum.h"
#include "MD5ChecksumDefines.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif


CString CMD5Checksum::GetMD5(const CString& strFilePath)
{
      //open the file as a binary file in readonly mode, denying write access
      CFile File(strFilePath, CFile::modeRead | CFile::shareDenyWrite | CFile::typeBinary);

      //the file has been successfully opened, so now get and return its checksum
      return GetMD5(File);
}


CString CMD5Checksum::GetMD5(CFile& File)
{
      try
      {
            CMD5Checksum MD5Checksum;            //checksum object      
            int nLength = 0;                        //number of bytes read from the file
            const int nBufferSize = 1024;      //checksum the file in blocks of 1024 bytes
            BYTE Buffer[nBufferSize];            //buffer for data read from the file

            //checksum the file in blocks of 1024 bytes
            while ((nLength = File.Read( Buffer, nBufferSize )) > 0 )
            {
                  MD5Checksum.Update( Buffer, nLength );
            }

            //finalise the checksum and return it
            return MD5Checksum.Final();
      }

      //report any file exceptions in debug mode only
      catch (CFileException* e )
      {
            TRACE0("CMD5Checksum::GetMD5: CFileException caught");      
            throw e;
      }
}


CString CMD5Checksum::GetMD5(BYTE* pBuf, UINT nLength)
{
      //entry invariants
      AfxIsValidAddress(pBuf,nLength,FALSE);

      //calculate and return the checksum
      CMD5Checksum MD5Checksum;
      MD5Checksum.Update( pBuf, nLength );
      return MD5Checksum.Final();
}


DWORD CMD5Checksum::RotateLeft(DWORD x, int n)
{
      //check that DWORD is 4 bytes long - true in Visual C++ 6 and 32 bit Windows
      ASSERT( sizeof(x) == 4 );

      //rotate and return x
      return (x << n) | (x >> (32-n));
}


void CMD5Checksum::FF( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T)
{
      DWORD F = (B & C) | (~B & D);
      A += F + X + T;
      A = RotateLeft(A, S);
      A += B;
}


void CMD5Checksum::GG( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T)
{
      DWORD G = (B & D) | (C & ~D);
      A += G + X + T;
      A = RotateLeft(A, S);
      A += B;
}


void CMD5Checksum::HH( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T)
{
      DWORD H = (B ^ C ^ D);
      A += H + X + T;
      A = RotateLeft(A, S);
      A += B;
}


void CMD5Checksum::II( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T)
{
      DWORD I = (C ^ (B | ~D));
      A += I + X + T;
      A = RotateLeft(A, S);
      A += B;
}



void CMD5Checksum::ByteToDWord(DWORD* Output, BYTE* Input, UINT nLength)
{
      //entry invariants
      ASSERT( nLength % 4 == 0 );
      ASSERT( AfxIsValidAddress(Output, nLength/4, TRUE) );
      ASSERT( AfxIsValidAddress(Input, nLength, FALSE) );

      //initialisations
      UINT i=0;      //index to Output array
      UINT j=0;      //index to Input array

      //transfer the data by shifting and copying
      for ( ; j < nLength; i++, j += 4)
      {
            Output[i] = (ULONG)Input[j]                  |
                              (ULONG)Input[j+1] << 8      |
                              (ULONG)Input[j+2] << 16 |
                              (ULONG)Input[j+3] << 24;
      }
}

void CMD5Checksum::Transform(BYTE Block[64])
{
      //initialise local data with current checksum
      ULONG a = m_lMD5[0];
      ULONG b = m_lMD5[1];
      ULONG c = m_lMD5[2];
      ULONG d = m_lMD5[3];

      //copy BYTES from input 'Block' to an array of ULONGS 'X'
      ULONG X[16];
      ByteToDWord( X, Block, 64 );

      //Perform Round 1 of the transformation
      FF (a, b, c, d, X[ 0], MD5_S11, MD5_T01);
      FF (d, a, b, c, X[ 1], MD5_S12, MD5_T02);
      FF (c, d, a, b, X[ 2], MD5_S13, MD5_T03);
      FF (b, c, d, a, X[ 3], MD5_S14, MD5_T04);
      FF (a, b, c, d, X[ 4], MD5_S11, MD5_T05);
      FF (d, a, b, c, X[ 5], MD5_S12, MD5_T06);
      FF (c, d, a, b, X[ 6], MD5_S13, MD5_T07);
      FF (b, c, d, a, X[ 7], MD5_S14, MD5_T08);
      FF (a, b, c, d, X[ 8], MD5_S11, MD5_T09);
      FF (d, a, b, c, X[ 9], MD5_S12, MD5_T10);
      FF (c, d, a, b, X[10], MD5_S13, MD5_T11);
      FF (b, c, d, a, X[11], MD5_S14, MD5_T12);
      FF (a, b, c, d, X[12], MD5_S11, MD5_T13);
      FF (d, a, b, c, X[13], MD5_S12, MD5_T14);
      FF (c, d, a, b, X[14], MD5_S13, MD5_T15);
      FF (b, c, d, a, X[15], MD5_S14, MD5_T16);

      //Perform Round 2 of the transformation
      GG (a, b, c, d, X[ 1], MD5_S21, MD5_T17);
      GG (d, a, b, c, X[ 6], MD5_S22, MD5_T18);
      GG (c, d, a, b, X[11], MD5_S23, MD5_T19);
      GG (b, c, d, a, X[ 0], MD5_S24, MD5_T20);
      GG (a, b, c, d, X[ 5], MD5_S21, MD5_T21);
      GG (d, a, b, c, X[10], MD5_S22, MD5_T22);
      GG (c, d, a, b, X[15], MD5_S23, MD5_T23);
      GG (b, c, d, a, X[ 4], MD5_S24, MD5_T24);
      GG (a, b, c, d, X[ 9], MD5_S21, MD5_T25);
      GG (d, a, b, c, X[14], MD5_S22, MD5_T26);
      GG (c, d, a, b, X[ 3], MD5_S23, MD5_T27);
      GG (b, c, d, a, X[ 8], MD5_S24, MD5_T28);
      GG (a, b, c, d, X[13], MD5_S21, MD5_T29);
      GG (d, a, b, c, X[ 2], MD5_S22, MD5_T30);
      GG (c, d, a, b, X[ 7], MD5_S23, MD5_T31);
      GG (b, c, d, a, X[12], MD5_S24, MD5_T32);

      //Perform Round 3 of the transformation
      HH (a, b, c, d, X[ 5], MD5_S31, MD5_T33);
      HH (d, a, b, c, X[ 8], MD5_S32, MD5_T34);
      HH (c, d, a, b, X[11], MD5_S33, MD5_T35);
      HH (b, c, d, a, X[14], MD5_S34, MD5_T36);
      HH (a, b, c, d, X[ 1], MD5_S31, MD5_T37);
      HH (d, a, b, c, X[ 4], MD5_S32, MD5_T38);
      HH (c, d, a, b, X[ 7], MD5_S33, MD5_T39);
      HH (b, c, d, a, X[10], MD5_S34, MD5_T40);
      HH (a, b, c, d, X[13], MD5_S31, MD5_T41);
      HH (d, a, b, c, X[ 0], MD5_S32, MD5_T42);
      HH (c, d, a, b, X[ 3], MD5_S33, MD5_T43);
      HH (b, c, d, a, X[ 6], MD5_S34, MD5_T44);
      HH (a, b, c, d, X[ 9], MD5_S31, MD5_T45);
      HH (d, a, b, c, X[12], MD5_S32, MD5_T46);
      HH (c, d, a, b, X[15], MD5_S33, MD5_T47);
      HH (b, c, d, a, X[ 2], MD5_S34, MD5_T48);

      //Perform Round 4 of the transformation
      II (a, b, c, d, X[ 0], MD5_S41, MD5_T49);
      II (d, a, b, c, X[ 7], MD5_S42, MD5_T50);
      II (c, d, a, b, X[14], MD5_S43, MD5_T51);
      II (b, c, d, a, X[ 5], MD5_S44, MD5_T52);
      II (a, b, c, d, X[12], MD5_S41, MD5_T53);
      II (d, a, b, c, X[ 3], MD5_S42, MD5_T54);
      II (c, d, a, b, X[10], MD5_S43, MD5_T55);
      II (b, c, d, a, X[ 1], MD5_S44, MD5_T56);
      II (a, b, c, d, X[ 8], MD5_S41, MD5_T57);
      II (d, a, b, c, X[15], MD5_S42, MD5_T58);
      II (c, d, a, b, X[ 6], MD5_S43, MD5_T59);
      II (b, c, d, a, X[13], MD5_S44, MD5_T60);
      II (a, b, c, d, X[ 4], MD5_S41, MD5_T61);
      II (d, a, b, c, X[11], MD5_S42, MD5_T62);
      II (c, d, a, b, X[ 2], MD5_S43, MD5_T63);
      II (b, c, d, a, X[ 9], MD5_S44, MD5_T64);

      //add the transformed values to the current checksum
      m_lMD5[0] += a;
      m_lMD5[1] += b;
      m_lMD5[2] += c;
      m_lMD5[3] += d;
}


CMD5Checksum::CMD5Checksum()
{
      // zero members
      memset( m_lpszBuffer, 0, 64 );
      m_nCount[0] = m_nCount[1] = 0;

      // Load magic state initialization constants
      m_lMD5[0] = MD5_INIT_STATE_0;
      m_lMD5[1] = MD5_INIT_STATE_1;
      m_lMD5[2] = MD5_INIT_STATE_2;
      m_lMD5[3] = MD5_INIT_STATE_3;
}


void CMD5Checksum::DWordToByte(BYTE* Output, DWORD* Input, UINT nLength )
{
      //entry invariants
      ASSERT( nLength % 4 == 0 );
      ASSERT( AfxIsValidAddress(Output, nLength, TRUE) );
      ASSERT( AfxIsValidAddress(Input, nLength/4, FALSE) );

      //transfer the data by shifting and copying
      UINT i = 0;
      UINT j = 0;
      for ( ; j < nLength; i++, j += 4)
      {
            Output[j] =   (UCHAR)(Input[i] & 0xff);
            Output[j+1] = (UCHAR)((Input[i] >> 8) & 0xff);
            Output[j+2] = (UCHAR)((Input[i] >> 16) & 0xff);
            Output[j+3] = (UCHAR)((Input[i] >> 24) & 0xff);
      }
}



CString CMD5Checksum::Final()
{
      //Save number of bits
      BYTE Bits[8];
      DWordToByte( Bits, m_nCount, 8 );

      //Pad out to 56 mod 64.
      UINT nIndex = (UINT)((m_nCount[0] >> 3) & 0x3f);
      UINT nPadLen = (nIndex < 56) ? (56 - nIndex) : (120 - nIndex);
      Update( PADDING, nPadLen );

      //Append length (before padding)
      Update( Bits, 8 );

      //Store final state in 'lpszMD5'
      const int nMD5Size = 16;
      unsigned char lpszMD5[ nMD5Size ];
      DWordToByte( lpszMD5, m_lMD5, nMD5Size );

      //Convert the hexadecimal checksum to a CString
      CString strMD5;
      for ( int i=0; i < nMD5Size; i++)
      {
            CString Str;
            if (lpszMD5[i] == 0) {
                  Str = CString("00");
            }
            else if (lpszMD5[i] <= 15)       {
                  Str.Format("0%x",lpszMD5[i]);
            }
            else {
                  Str.Format("%x",lpszMD5[i]);
            }

            ASSERT( Str.GetLength() == 2 );
            strMD5 += Str;
      }
      ASSERT( strMD5.GetLength() == 32 );
      return strMD5;
}


void CMD5Checksum::Update( BYTE* Input,      ULONG nInputLen )
{
      //Compute number of bytes mod 64
      UINT nIndex = (UINT)((m_nCount[0] >> 3) & 0x3F);

      //Update number of bits
      if ( ( m_nCount[0] += nInputLen << 3 )  <  ( nInputLen << 3) )
      {
            m_nCount[1]++;
      }
      m_nCount[1] += (nInputLen >> 29);

      //Transform as many times as possible.
      UINT i=0;            
      UINT nPartLen = 64 - nIndex;
      if (nInputLen >= nPartLen)       
      {
            memcpy( &m_lpszBuffer[nIndex], Input, nPartLen );
            Transform( m_lpszBuffer );
            for (i = nPartLen; i + 63 < nInputLen; i += 64)
            {
                  Transform( &Input[i] );
            }
            nIndex = 0;
      }
      else
      {
            i = 0;
      }

      // Buffer remaining input
      memcpy( &m_lpszBuffer[nIndex], &Input[i], nInputLen-i);
}

===========================================================================================================================
MD5Checksum.h
===========================================================================================================================
#if !defined(AFX_MD5CHECKSUM_H__2BC7928E_4C15_11D3_B2EE_A4A60E20D2C3__INCLUDED_)
#define AFX_MD5CHECKSUM_H__2BC7928E_4C15_11D3_B2EE_A4A60E20D2C3__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CMD5Checksum  
{
public:
      //interface functions for the RSA MD5 calculation
      static CString GetMD5(BYTE* pBuf, UINT nLength);
      static CString GetMD5(CFile& File);
      static CString GetMD5(const CString& strFilePath);

protected:
      //constructor/destructor
      CMD5Checksum();
      virtual ~CMD5Checksum() {};

      //RSA MD5 implementation
      void Transform(BYTE Block[64]);
      void Update(BYTE* Input, ULONG nInputLen);
      CString Final();
      inline DWORD RotateLeft(DWORD x, int n);
      inline void FF( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T);
      inline void GG( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T);
      inline void HH( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T);
      inline void II( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T);

      //utility functions
      inline void DWordToByte(BYTE* Output, DWORD* Input, UINT nLength);
      inline void ByteToDWord(DWORD* Output, BYTE* Input, UINT nLength);

private:
      BYTE  m_lpszBuffer[64];            //input buffer
      ULONG m_nCount[2];                  //number of bits, modulo 2^64 (lsb first)
      ULONG m_lMD5[4];                  //MD5 checksum
};

#endif // !defined(AFX_MD5CHECKSUM_H__2BC7928E_4C15_11D3_B2EE_A4A60E20D2C3__INCLUDED_)
==============================================================================================================================
StdAfx.cpp
==============================================================================================================================

// stdafx.cpp : source file that includes just the standard includes
//      MD5.pch will be the pre-compiled header
//      stdafx.obj will contain the pre-compiled type information

#include "stdafx.h"
===========================================================================================================================