C++ .net (CLR) use Hotkey for Show/Hide Form

## My VB Code from last year ( was a copy&past from any site script/tutorial site: ##
 
    Implements IMessageFilter
 
    Private Declare Function RegisterHotKey Lib "user32" ( _
        ByVal Hwnd As IntPtr, _
        ByVal ID As Integer, _
        ByVal Modifiers As Integer, _
        ByVal Key As Integer) _
    As Integer
 
    Private Declare Function UnregisterHotKey Lib "user32" ( _
        ByVal Hwnd As IntPtr, _
        ByVal ID As Integer) _
    As Integer
 
    Private Declare Function GlobalAddAtom Lib "kernel32" Alias "GlobalAddAtomA" ( _
        ByVal IDString As String) _
    As Short
 
    Private Declare Function GlobalDeleteAtom Lib "kernel32" ( _
        ByVal Atom As Short) _
    As Short

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

private: System::Void Form1_Load(System::Object *  sender, System::EventArgs *  e)
{
	// Set these when the form loads:
	// Have the form capture keyboard events first.
	this->KeyPreview = true;
	// Assign the event handler to the form.
	this->KeyDown += new System::Windows::Forms::KeyEventHandler(this, FormKeyDown);
	// Assign the event handler to the text box.
	this->textBox1->KeyDown += new System::Windows::Forms::KeyEventHandler(this, TextBoxKeyDown);
}
private: System::Void FormKeyDown(System::Object *  sender, System::Windows::Forms::KeyEventArgs *  e)
{
	if(e->Alt && e->KeyCode == System::Windows::Forms::Keys::F){
		// When the user presses both the 'Alt' key and 'F' key,
		// KeyPreview is set to False, and a message appears.
		// This message is only displayed when KeyPreview is set to True.
		this->KeyPreview = false;
		MessageBox::Show(this,"KeyPreview is True, and this came from the FORM");
	}
}
private: System::Void TextBoxKeyDown(System::Object *  sender, System::Windows::Forms::KeyEventArgs *  e)
{
	if(e->Alt && e->KeyCode == System::Windows::Forms::Keys::F){
		// When the user presses both the 'Alt' key and 'F' key,
		// KeyPreview is set to True, and a message appears.
		// This message is only displayed when KeyPreview is set to False.
		this->KeyPreview = true;
		MessageBox::Show(this,"KeyPreview is False, and this came from the CONTROL");
	}
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:

Dont know what StructLayouts are?
 
        [StructLayout(LayoutKind.Explicit)]
        internal struct RAWINPUT
        {
            [FieldOffset(0)]
            public RAWINPUTHEADER header;
            [FieldOffset(16)]
            public RAWMOUSE mouse;
            [FieldOffset(16)]
            public RAWKEYBOARD keyboard;
            [FieldOffset(16)]
            public RAWHID hid;
        }

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

struct RAWINPUT
        {
            public RAWINPUTHEADER header;
            public RAWMOUSE mouse;
            public RAWKEYBOARD keyboard;
            public RAWHID hid;
        }

                                              

1:
2:
3:
4:
5:
6:
7:

#pragma once
 
using namespace System;
using namespace System::Collections;
using namespace System::IO;
using namespace System::Runtime::InteropServices;
using namespace System::Windows::Forms;
using namespace Microsoft::Win32;
 
namespace test_key
{
 
 
	/// <summary>
	/// Handles raw input from keyboard devices.
	/// </summary>
	public ref class InputDevice sealed
	{
		#pragma region const definitions
 
		// The following constants are defined in Windows.h
 
	private:
		literal int RIDEV_INPUTSINK = 0x00000100;
		literal int RID_INPUT = 0x10000003;
 
		literal int FAPPCOMMAND_MASK = 0xF000;
		literal int FAPPCOMMAND_MOUSE = 0x8000;
		literal int FAPPCOMMAND_OEM = 0x1000;
 
		literal int RIM_TYPEMOUSE = 0;
		literal int RIM_TYPEKEYBOARD = 1;
		literal int RIM_TYPEHID = 2;
 
		literal int RIDI_DEVICENAME = 0x20000007;
 
		literal int WM_KEYDOWN = 0x0100;
		literal int WM_SYSKEYDOWN = 0x0104;
		literal int WM_INPUT = 0x00FF;
		literal int VK_OEM_CLEAR = 0xFE;
		literal int VK_LAST_KEY = VK_OEM_CLEAR; // this is a made up value used as a sentinel
 
		#pragma endregion const definitions
 
		#pragma region structs & enums
 
		/// <summary>
		/// An enum representing the different types of input devices.
		/// </summary>
	public:
		enum class DeviceType
		{
			Key,
			Mouse,
			OEM
		};
 
		/// <summary>
		/// Class encapsulating the information about a
		/// keyboard event, including the device it
		/// originated with and what key was pressed
		/// </summary>
	public:
		ref class DeviceInfo
		{
		public:
			System::String ^deviceName;
			System::String ^deviceType;
			IntPtr deviceHandle;
			System::String ^Name;
			System::String ^source;
			System::UInt16 key;
			System::String ^vKey;
		};
 
		#pragma region Windows.h structure declarations
 
		// The following structures are defined in Windows.h
 
 
		struct RAWINPUTDEVICELIST {
			IntPtr hDevice;
			int dwType;
		}
 
 
		struct RAWINPUT {
			RAWINPUTHEADER header;
			RAWMOUSE mouse;
			RAWKEYBOARD keyboard;
			RAWHID hid;
		}
 
		struct RAWINPUTHEADER {
			int dwType;
			int dwSize;
			IntPtr hDevice;
			int wParam;
		}
 
 
		struct RAWHID {
			int dwSizHid;
			int dwCount;
		}
 
		struct BUTTONSSTR {
			System::UInt16 usButtonFlags;
			System::UInt16 usButtonData;
		}
 
		struct RAWMOUSE {
			System::UInt16 usFlags;
			System::UInt32 ulButtons;
			BUTTONSSTR buttonsStr;
			System::UInt32 ulRawButtons;
			int lLastX;
			int lLastY;
			System::UInt32 ulExtraInformation;
		}
 
		struct RAWKEYBOARD 	{
			System::UInt16 MakeCode;
			System::UInt16 Flags;
			System::UInt16 Reserved;
			System::UInt16 VKey;
			System::UInt32 Message;
			System::UInt32 ExtraInformation;
		}
 
 
		struct RAWINPUTDEVICE {
			System::UInt16 usUsagePage;
			System::UInt16 usUsage;
			int dwFlags;
			IntPtr hwndTarget;
		}
		#pragma endregion Windows.h structure declarations
 
 
		#pragma endregion structs & enums
 
		#pragma region DllImports
 
		[DllImport("User32.dll")]
		static System::UInt32 GetRawInputDeviceList(IntPtr pRawInputDeviceList, System::UInt32 %uiNumDevices, System::UInt32 cbSize);
 
		[DllImport("User32.dll")]
		static System::UInt32 GetRawInputDeviceInfo(IntPtr hDevice, System::UInt32 uiCommand, IntPtr pData, System::UInt32 %pcbSize);
 
		[DllImport("User32.dll")]
		static bool RegisterRawInputDevices(array<RAWINPUTDEVICE> ^pRawInputDevice, System::UInt32 uiNumDevices, System::UInt32 cbSize);
 
		[DllImport("User32.dll")]
		static System::UInt32 GetRawInputData(IntPtr hRawInput, System::UInt32 uiCommand, IntPtr pData, System::UInt32 %pcbSize, System::UInt32 cbSizeHeader);
 
		#pragma endregion DllImports
 
		#pragma region Variables and event handling
 
		/// <summary>
		/// List of keyboard devices. Key: the device handle
		/// Value: the device info class
		/// </summary>
	private:
		Hashtable ^deviceList;
 
		/// <summary>
		/// The delegate to handle KeyPressed events.
		/// </summary>
		/// <param name="sender">The object sending the event.</param>
		/// <param name="e">A set of KeyControlEventArgs information about the key that was pressed and the device it was on.</param>
	public:
		delegate void DeviceEventHandler(System::Object ^sender, KeyControlEventArgs ^e);
 
		/// <summary>
		/// The event raised when InputDevice detects that a key was pressed.
		/// </summary>
		event DeviceEventHandler ^KeyPressed;
 
		/// <summary>
		/// Arguments provided by the handler for the KeyPressed
		/// event.
		/// </summary>
	public:
		ref class KeyControlEventArgs : EventArgs
		{
		private:
			DeviceInfo ^m_deviceInfo;
			DeviceType m_device;
 
		public:
			KeyControlEventArgs(DeviceInfo ^dInfo, DeviceType device)
			{
				m_deviceInfo = dInfo;
				m_device = device;
			}
 
			KeyControlEventArgs()
			{
			}
 
			property DeviceInfo ^Keyboard
			{
				DeviceInfo ^get()
				{
					return m_deviceInfo;
				}
				void set(DeviceInfo ^value)
				{
					m_deviceInfo = value;
				}
			}
 
			property DeviceType Device
			{
				DeviceType get()
				{
					return m_device;
				}
				void set(DeviceType value)
				{
					m_device = value;
				}
			}
		};
 
		#pragma endregion Variables and event handling
 
		#pragma region InputDevice( IntPtr hwnd )
 
		/// <summary>
		/// InputDevice constructor; registers the raw input devices
		/// for the calling window.
		/// </summary>
		/// <param name="hwnd">Handle of the window listening for key presses</param>
	public:
		InputDevice(IntPtr hwnd)
		{
			//Create an array of all the raw input devices we want to 
			//listen to. In this case, only keyboard devices.
			//RIDEV_INPUTSINK determines that the window will continue
			//to receive messages even when it doesn't have the focus.
			InitializeInstanceFields();
			array<RAWINPUTDEVICE> ^rid = gcnew array<RAWINPUTDEVICE>(1);
 
			rid[0].usUsagePage = 0x01;
			rid[0].usUsage = 0x06;
			rid[0].dwFlags = RIDEV_INPUTSINK;
			rid[0].hwndTarget = hwnd;
 
			if(!RegisterRawInputDevices(rid, safe_cast<System::UInt32>(rid->Length), safe_cast<System::UInt32>(Marshal::SizeOf(rid[0]))))
			{
				throw gcnew ApplicationException("Failed to register raw input device(s).");
			}
		}
 
		#pragma endregion InputDevice( IntPtr hwnd )
 
		#pragma region ReadReg( string item, ref bool isKeyboard )
 
		/// <summary>
		/// Reads the Registry to retrieve a friendly description
		/// of the device, and determine whether it is a keyboard.
		/// </summary>
		/// <param name="item">The device name to search for, as provided by GetRawInputDeviceInfo.</param>
		/// <param name="isKeyboard">Determines whether the device's class is "Keyboard".</param>
		/// <returns>The device description stored in the Registry entry's DeviceDesc value.</returns>
	private:
		System::String ^ReadReg(System::String ^item, bool %isKeyboard)
		{
			// Example Device Identification string
			// @"\??\ACPI#PNP0303#3&13c0b0c5&0#{884b96c3-56ef-11d1-bc8c-00a0c91405dd}";
 
			// remove the \??\
			item = item->Substring(4);
 
			array<System::String^> ^split = item->Split('#');
 
			System::String ^id_01 = split[0]; // ACPI (Class code)
			System::String ^id_02 = split[1]; // PNP0303 (SubClass code)
			System::String ^id_03 = split[2]; // 3&13c0b0c5&0 (Protocol code)
			//The final part is the class GUID and is not needed here
 
			//Open the appropriate key as read-only so no permissions
			//are needed.
			RegistryKey ^OurKey = Registry::LocalMachine;
 
			System::String ^findme = System::String::Format("System\\CurrentControlSet\\Enum\\{0}\\{1}\\{2}", id_01, id_02, id_03);
 
			OurKey = OurKey->OpenSubKey(findme, false);
 
			//Retrieve the desired information and set isKeyboard
			System::String ^deviceDesc = safe_cast<System::String^>(OurKey->GetValue("DeviceDesc"));
			System::String ^deviceClass = safe_cast<System::String^>(OurKey->GetValue("Class"));
 
			if(deviceClass->ToUpper()->Equals("KEYBOARD"))
			{
				isKeyboard = true;
			}
			else
			{
				isKeyboard = false;
			}
			return deviceDesc;
		}
 
		#pragma endregion ReadReg( string item, ref bool isKeyboard )
 
		#pragma region int EnumerateDevices()
 
		/// <summary>
		/// Iterates through the list provided by GetRawInputDeviceList,
		/// counting keyboard devices and adding them to deviceList.
		/// </summary>
		/// <returns>The number of keyboard devices found.</returns>
	public:
		int EnumerateDevices()
		{
 
			int NumberOfDevices = 0;
			System::UInt32 deviceCount = 0;
			int dwSize = (Marshal::SizeOf(RAWINPUTDEVICELIST::typeid));
 
			// Get the number of raw input devices in the list,
			// then allocate sufficient memory and get the entire list
			if(GetRawInputDeviceList(IntPtr::Zero, deviceCount, safe_cast<System::UInt32>(dwSize)) == 0)
			{
				IntPtr pRawInputDeviceList = Marshal::AllocHGlobal(safe_cast<int>(dwSize * deviceCount));
				GetRawInputDeviceList(pRawInputDeviceList, deviceCount, safe_cast<System::UInt32>(dwSize));
 
				// Iterate through the list, discarding undesired items
				// and retrieving further information on keyboard devices
				for (int i = 0; i < deviceCount; i++)
				{
					DeviceInfo ^dInfo;
					System::String ^deviceName;
					System::UInt32 pcbSize = 0;
 
					RAWINPUTDEVICELIST rid = safe_cast<RAWINPUTDEVICELIST>(Marshal::PtrToStructure(IntPtr((pRawInputDeviceList.ToInt32() + (dwSize * i))), RAWINPUTDEVICELIST::typeid));
 
					GetRawInputDeviceInfo(rid.hDevice, RIDI_DEVICENAME, IntPtr::Zero, pcbSize);
 
					if (pcbSize > 0)
					{
						IntPtr pData = Marshal::AllocHGlobal(safe_cast<int>(pcbSize));
						GetRawInputDeviceInfo(rid.hDevice, RIDI_DEVICENAME, pData, pcbSize);
						deviceName = safe_cast<System::String^>(Marshal::PtrToStringAnsi(pData));
 
						// Drop the "root" keyboard and mouse devices used for Terminal 
						// Services and the Remote Desktop
						if (deviceName->ToUpper()->Contains("ROOT"))
						{
							continue;
						}
 
						// If the device is identified in the list as a keyboard or 
						// HID device, create a DeviceInfo object to store information 
						// about it
						if (rid.dwType == RIM_TYPEKEYBOARD || rid.dwType == RIM_TYPEHID)
						{
							dInfo = gcnew DeviceInfo();
 
							dInfo->deviceName = safe_cast<System::String^>(Marshal::PtrToStringAnsi(pData));
							dInfo->deviceHandle = rid.hDevice;
							dInfo->deviceType = GetDeviceType(rid.dwType);
 
							// Check the Registry to see whether this is actually a 
							// keyboard, and to retrieve a more friendly description.
							bool IsKeyboardDevice = false;
							System::String ^DeviceDesc = ReadReg(deviceName, IsKeyboardDevice);
							dInfo->Name = DeviceDesc;
 
							// If it is a keyboard and it isn't already in the list,
							// add it to the deviceList hashtable and increase the
							// NumberOfDevices count
							if (!deviceList->Contains(rid.hDevice) && IsKeyboardDevice)
							{
								NumberOfDevices++;
								deviceList->Add(rid.hDevice, dInfo);
							}
						}
						Marshal::FreeHGlobal(pData);
					}
				}
 
 
				Marshal::FreeHGlobal(pRawInputDeviceList);
 
				return NumberOfDevices;
 
			}
			else
			{
				throw gcnew ApplicationException("An error occurred while retrieving the list of devices.");
			}
 
		}
 
		#pragma endregion EnumerateDevices()
 
		#pragma region ProcessInputCommand( Message message )
 
		/// <summary>
		/// Processes WM_INPUT messages to retrieve information about any
		/// keyboard events that occur.
		/// </summary>
		/// <param name="message">The WM_INPUT message to process.</param>
		void ProcessInputCommand(Message message)
		{
			System::UInt32 dwSize = 0;
 
			// First call to GetRawInputData sets the value of dwSize,
			// which can then be used to allocate the appropriate amount of memory,
			// storing the pointer in "buffer".
			GetRawInputData(message.LParam, RID_INPUT, IntPtr::Zero, dwSize, safe_cast<System::UInt32>(Marshal::SizeOf(RAWINPUTHEADER::typeid)));
 
			IntPtr buffer = Marshal::AllocHGlobal(safe_cast<int>(dwSize));
			try
			{
				// Check that buffer points to something, and if so,
				// call GetRawInputData again to fill the allocated memory
				// with information about the input
				if (buffer != IntPtr::Zero && GetRawInputData(message.LParam, RID_INPUT, buffer, dwSize, safe_cast<System::UInt32>(Marshal::SizeOf(RAWINPUTHEADER::typeid))) == dwSize)
				{
					// Store the message information in "raw", then check
					// that the input comes from a keyboard device before
					// processing it to raise an appropriate KeyPressed event.
 
					RAWINPUT raw = safe_cast<RAWINPUT>(Marshal::PtrToStructure(buffer, RAWINPUT::typeid));
 
					if (raw.header.dwType == RIM_TYPEKEYBOARD)
					{
						// Filter for Key Down events and then retrieve information 
						// about the keystroke
						if (raw.keyboard.Message == WM_KEYDOWN || raw.keyboard.Message == WM_SYSKEYDOWN)
						{
 
							System::UInt16 key = raw.keyboard.VKey;
 
							// On most keyboards, "extended" keys such as the arrow or 
							// page keys return two codes - the key's own code, and an
							// "extended key" flag, which translates to 255. This flag
							// isn't useful to us, so it can be disregarded.
							if (key > VK_LAST_KEY)
							{
								return;
							}
 
							// Retrieve information about the device and the
							// key that was pressed.
							DeviceInfo ^dInfo = nullptr;
 
							if (deviceList->Contains(raw.header.hDevice))
							{
								Keys myKey;
 
								dInfo = safe_cast<DeviceInfo^>(deviceList[raw.header.hDevice]);
 
								myKey = safe_cast<Keys>(Enum::Parse(Keys::typeid, Enum::GetName(Keys::typeid, key)));
								dInfo->vKey = myKey.ToString();
								dInfo->key = key;
							}
							else
							{
								System::String ^errMessage = System::String::Format("Handle :{0} was not in hashtable. The device may support more than one handle or usage page, and is probably not a standard keyboard.", raw.header.hDevice);
								throw gcnew ApplicationException(errMessage);
							}
 
							// If the key that was pressed is valid and there
							// was no problem retrieving information on the device,
							// raise the KeyPressed event.
							if (KeyPressed != nullptr && dInfo != nullptr)
							{
								KeyPressed(this, gcnew KeyControlEventArgs(dInfo, GetDevice(message.LParam.ToInt32())));
							}
							else
							{
								System::String ^errMessage = System::String::Format("Received Unknown Key: {0}. Possibly an unknown device", key);
								throw gcnew ApplicationException(errMessage);
							}
						}
					}
				}
			}
			finally
			{
				Marshal::FreeHGlobal(buffer);
			}
		}
 
		#pragma endregion ProcessInputCommand( Message message )
 
		#pragma region DeviceType GetDevice( int param )
 
		/// <summary>
		/// Determines what type of device triggered a WM_INPUT message.
		/// (Used in the ProcessInputCommand method).
		/// </summary>
		/// <param name="param">The LParam from a WM_INPUT message.</param>
		/// <returns>A DeviceType enum value.</returns>
	private:
		DeviceType GetDevice(int param)
		{
			DeviceType deviceType;
 
			switch(safe_cast<int>((safe_cast<System::UInt16>(param >> 16)) & FAPPCOMMAND_MASK))
			{
				case FAPPCOMMAND_OEM:
					deviceType = DeviceType::OEM;
					break;
				case FAPPCOMMAND_MOUSE:
					deviceType = DeviceType::Mouse;
					break;
				default:
					deviceType = DeviceType::Key;
					break;
			}
 
			return deviceType;
		}
 
		#pragma endregion DeviceType GetDevice( int param )
 
		#pragma region ProcessMessage( Message message )
 
		/// <summary>
		/// Filters Windows messages for WM_INPUT messages and calls
		/// ProcessInputCommand if necessary.
		/// </summary>
		/// <param name="message">The Windows message.</param>
	public:
		void ProcessMessage(Message message)
		{
			switch(message.Msg)
			{
				case WM_INPUT:
				{
					ProcessInputCommand(message);
				}
				break;
			}
		}
 
		#pragma endregion ProcessMessage( Message message )
 
		#pragma region GetDeviceType( int device )
 
		/// <summary>
		/// Converts a RAWINPUTDEVICELIST dwType value to a string
		/// describing the device type.
		/// </summary>
		/// <param name="device">A dwType value (RIM_TYPEMOUSE, 
		/// RIM_TYPEKEYBOARD or RIM_TYPEHID).</param>
		/// <returns>A string representation of the input value.</returns>
	private:
		System::String ^GetDeviceType(int device)
		{
			System::String ^deviceType;
			switch(device)
			{
				case RIM_TYPEMOUSE:
					deviceType = "MOUSE";
					break;
				case RIM_TYPEKEYBOARD:
					deviceType = "KEYBOARD";
					break;
				case RIM_TYPEHID:
					deviceType = "HID";
					break;
				default:
					deviceType = "UNKNOWN";
					break;
			}
			return deviceType;
		}
 
		#pragma endregion GetDeviceType( int device )
 
 
	private:
		void InitializeInstanceFields()
		{
			static bool initialized = false;
			if ( ! initialized)
			{
				deviceList = gcnew Hashtable();
			
				initialized = true;
			}
		}
		void m_KeyPressed(System::Object ^sender, InputDevice::KeyControlEventArgs ^e)
		{
			//Replace() is just a cosmetic fix to stop ampersands turning into underlines
			//lbHandle->Text = e->Keyboard->deviceHandle->ToString();
			//lbType->Text = e->Keyboard->deviceType;
			//lbName->Text = e->Keyboard->deviceName->Replace("&", "&&");
			//lbDescription->Text = e->Keyboard.Name;
			//lbKey->Text = e->Keyboard->key->ToString();
			//lbNumKeyboards->Text = NumberOfKeyboards.ToString();
			lbVKey->Text = e->Keyboard->vKey;
		}
	};
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:
363:
364:
365:
366:
367:
368:
369:
370:
371:
372:
373:
374:
375:
376:
377:
378:
379:
380:
381:
382:
383:
384:
385:
386:
387:
388:
389:
390:
391:
392:
393:
394:
395:
396:
397:
398:
399:
400:
401:
402:
403:
404:
405:
406:
407:
408:
409:
410:
411:
412:
413:
414:
415:
416:
417:
418:
419:
420:
421:
422:
423:
424:
425:
426:
427:
428:
429:
430:
431:
432:
433:
434:
435:
436:
437:
438:
439:
440:
441:
442:
443:
444:
445:
446:
447:
448:
449:
450:
451:
452:
453:
454:
455:
456:
457:
458:
459:
460:
461:
462:
463:
464:
465:
466:
467:
468:
469:
470:
471:
472:
473:
474:
475:
476:
477:
478:
479:
480:
481:
482:
483:
484:
485:
486:
487:
488:
489:
490:
491:
492:
493:
494:
495:
496:
497:
498:
499:
500:
501:
502:
503:
504:
505:
506:
507:
508:
509:
510:
511:
512:
513:
514:
515:
516:
517:
518:
519:
520:
521:
522:
523:
524:
525:
526:
527:
528:
529:
530:
531:
532:
533:
534:
535:
536:
537:
538:
539:
540:
541:
542:
543:
544:
545:
546:
547:
548:
549:
550:
551:
552:
553:
554:
555:
556:
557:
558:
559:
560:
561:
562:
563:
564:
565:
566:
567:
568:
569:
570:
571:
572:
573:
574:
575:
576:
577:
578:
579:
580:
581:
582:
583:
584:
585:
586:
587:
588:
589:
590:
591:
592:
593:
594:
595:
596:
597:
598:
599:
600:
601:
602:
603:
604: