Не работает программа под win32api

      // ProgN.cpp : Defines the entry point for the application.
      //
       
      #include "stdafx.h"
      #include "ProgN.h"
      #define MAX_LOADSTRING 100
       
      // Global Variables:
      HINSTANCE hInst;                                // current instance
      TCHAR szTitle[MAX_LOADSTRING];                  // The title bar text
      TCHAR szWindowClass[MAX_LOADSTRING];            // the main window class name
       
      // Forward declarations of functions included in this code module:
      ATOM                MyRegisterClass(HINSTANCE hInstance);
      BOOL                InitInstance(HINSTANCE, int);
      LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
      INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
       
      WCHAR wName[]           =L"Processes";
      WCHAR cName[]           =L"Windowsclass";
      WCHAR lpszAppName[]     =L"Application";
      HINSTANCE hInstance;
       
      HWND hwnd;
      HMENU hMenu;
      HDC hDC;
       
      static HWND hList = NULL;
      static HWND hList2 = NULL;
       
       
       
      int APIENTRY _tWinMain(HINSTANCE hInstance,
                           HINSTANCE hPrevInstance,
                           LPTSTR    lpCmdLine,
                           int       nCmdShow)
      {
          UNREFERENCED_PARAMETER(hPrevInstance);
          UNREFERENCED_PARAMETER(lpCmdLine);
       
          // TODO: Place code here.
          MSG msg;
          HACCEL hAccelTable;
       
          // Initialize global strings
          LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
          LoadString(hInstance, IDC_PROGN, szWindowClass, MAX_LOADSTRING);
          MyRegisterClass(hInstance);
       
          // Perform application initialization:
          if (!InitInstance (hInstance, nCmdShow))
          {
              return FALSE;
          }
       
          hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_PROGN));
       
          // Main message loop:
          while (GetMessage(&msg, NULL, 0, 0))
          {
              if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
              {
                  TranslateMessage(&msg);
                  DispatchMessage(&msg);
              }
          }
       
          return (int) msg.wParam;
      }
       
       
       
      //
      //  FUNCTION: MyRegisterClass()
      //
      //  PURPOSE: Registers the window class.
      //
      //  COMMENTS:
      //
      //    This function and its usage are only necessary if you want this code
      //    to be compatible with Win32 systems prior to the 'RegisterClassEx'
      //    function that was added to Windows 95. It is important to call this function
      //    so that the application will get 'well formed' small icons associated
      //    with it.
      //
      ATOM MyRegisterClass(HINSTANCE hInstance)
      {
          WNDCLASSEX wcex;
       
          wcex.cbSize = sizeof(WNDCLASSEX);
       
          wcex.style          = CS_HREDRAW | CS_VREDRAW;
          wcex.lpfnWndProc    = WndProc;
          wcex.cbClsExtra     = 0;
          wcex.cbWndExtra     = 0;
          wcex.hInstance      = hInstance;
          wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_PROGN));
          wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
          wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
          wcex.lpszMenuName   = MAKEINTRESOURCE(IDC_PROGN);
          wcex.lpszClassName  = szWindowClass;
          wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
       
          return RegisterClassEx(&wcex);
      }
       
      //
      //   FUNCTION: InitInstance(HINSTANCE, int)
      //
      //   PURPOSE: Saves instance handle and creates main window
      //
      //   COMMENTS:
      //
      //        In this function, we save the instance handle in a global variable and
      //        create and display the main program window.
      //
      BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
      {
         HWND hWnd;
       
         hInst = hInstance; // Store instance handle in our global variable
       
         hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
            CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
       
         if (!hWnd)
         {
            return FALSE;
         }
       
         ShowWindow(hWnd, nCmdShow);
         UpdateWindow(hWnd);
       
         return TRUE;
      }
       
      //
      //  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
      //
      //  PURPOSE:  Processes messages for the main window.
      //
      //  WM_COMMAND  - process the application menu
      //  WM_PAINT    - Paint the main window
      //  WM_DESTROY  - post a quit message and return
      //
      //
      LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
      {
          int wmId, wmEvent;
          PAINTSTRUCT ps;
          HDC hdc;
       
          switch (message)
          {
       
          case WM_COMMAND:
              wmId    = LOWORD(wParam);
              wmEvent = HIWORD(wParam);
              switch( LOWORD( wParam ) )
                      {
                          case ID_EXECUTE:
                              {
                                  if(ProcessNumber<Max)
                                  {
                                      StartupInfo.cb          =sizeof(STARTUPINFO);
                                      StartupInfo.lpReserved  =NULL;
                                      StartupInfo.lpDesktop   =NULL;
                                      StartupInfo.lpTitle     =NULL;
                                      StartupInfo.dwFlags     =STARTF_USESHOWWINDOW;
                                      StartupInfo.wShowWindow =SW_SHOWNORMAL;
                                      StartupInfo.cbReserved2 =0;
                                      StartupInfo.lpReserved2 =NULL;
       
                                      if(CreateProcess(L"NOTEPAD.EXE",
                                                          L"D:\\Documents and Settings\\Admin\\Мои документы\\Visual Studio 2005\\Projects\\KillCopy.Projects\\Lesson 1\\README.txt",
                                                          NULL, NULL, FALSE,
                                                          0, NULL, NULL,
                                                          &StartupInfo,
                                                          &(ProcessInformation[ProcessNumber])))
                                      {
                                          ProcessNumber++;
                                          wsprintf(wMyMessage,
                                              L"hProcess is %x\nhThread is %x\ndwProcessId is %x\ndwThreadId is %x.",
                                              ProcessInformation[ProcessNumber-1].hProcess,
                                              ProcessInformation[ProcessNumber-1].hThread,
                                              ProcessInformation[ProcessNumber-1].dwProcessId,
                                              ProcessInformation[ProcessNumber-1].dwThreadId);
                                          MessageBox(hwnd, wMyMessage, L"Process is created", MB_OK);
                                          EnableMenuItem(hMenu, ID_OTHER_DESTROYPROCESS, MF_BYCOMMAND | MF_ENABLED);
                                      }
                                      else
                                          MessageBox(hwnd, L"Cannot create process", L"Process creation", MB_OK);
                                  }
                                  else
                                      MessageBox(hwnd, L"Too many created processes...", L"ProcessCreation", MB_OK);
                              }
                              break;
                          case ID_TEST_EXIT:
                              {
                                  PostQuitMessage(0);
                                  return 0;
                              }
                              break;
                          case ID_OTHER_DESTROYPROCESS:
                              {
                                  if(TerminateProcess(ProcessInformation[ProcessNumber-1].hProcess, 0))
                                  {
                                      ProcessNumber--;
                                      if(!ProcessNumber)
                                      {
                                          EnableMenuItem(hMenu, ID_OTHER_DESTROYPROCESS, MF_BYCOMMAND | MF_GRAYED);
                                      }
                                      else
                                          MessageBox(hwnd, L"Cannot terminate process", L"Process termination", MB_OK);
                                  }
                                  else
                                      MessageBox(hwnd, L"No more processes to destroy", L"Process termination", MB_OK);
                              }
                              break;
                      }
              // Parse the menu selections:
              switch (wmId)
              {
              case IDM_ABOUT:
                  DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
                  break;
              case IDM_EXIT:
                  DestroyWindow(hWnd);
                  break;
              default:
                  return DefWindowProc(hWnd, message, wParam, lParam);
              }
              break;
          case WM_PAINT:
              hdc = BeginPaint(hWnd, &ps);
              // TODO: Add any drawing code here...
              EndPaint(hWnd, &ps);
              break;
          case WM_CREATE:
                  {
                      hDC=GetDC(hwnd);
                      hMenu=GetSubMenu(GetMenu(hwnd), 0);
       
                      hList  = CreateWindowEx( WS_EX_CLIENTEDGE, L"LISTBOX", L"",
                                             LBS_STANDARD | LBS_NOINTEGRALHEIGHT | LBS_DISABLENOSCROLL |
                                             WS_CHILD | WS_VISIBLE,
                                             5, 25, 350, 400,
                                             hwnd, NULL,
                                             hInstance
                                             , NULL );
       
                      hList2 = CreateWindowEx( WS_EX_CLIENTEDGE, L"LISTBOX", L"",
                                             LBS_STANDARD | LBS_NOINTEGRALHEIGHT | LBS_DISABLENOSCROLL |
                                             WS_CHILD | WS_VISIBLE,
                                             375, 25, 350, 400,
                                             hwnd, NULL,
                                             hInstance
                                             , NULL );
                  }
                  break;
       
       
          case WM_DESTROY:
              PostQuitMessage(0);
              break;
          default:
              return DefWindowProc(hWnd, message, wParam, lParam);
          }
          return 0;
      }
       
      // Message handler for about box.
      INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
      {
          UNREFERENCED_PARAMETER(lParam);
          switch (message)
          {
          case WM_INITDIALOG:
              return (INT_PTR)TRUE;
       
          case WM_COMMAND:
              if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
              {
                  EndDialog(hDlg, LOWORD(wParam));
                  return (INT_PTR)TRUE;
              }
              break;
          }
          return (INT_PTR)FALSE;
      }