example code to write to a sound card

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Threading;
using System.IO;
 
namespace SoundDB
{
public class WaveFile
    {
 
        #region PRIVATE_FIELDS
 
        private String chunkID;
        private int chunkSize;
        private String format;
        private String subchunk1ID;
        private int subchunk1Size;
        private short audioFormat;
        private short numChannels;
        private int sampleRate;
        private int byteRate;
        private short blockAlign;
        private short bitsPerSample;
        private String subchunk2ID;
        private int subchunk2Size;
 
        private String waveFile;
        private int silentLevel;
 
        public byte[] fullSoundData;
 
        private short[] soundDataCh1;
        private short[] soundDataCh2;
 
        private int startIndex;
        private int playLength;
 
        #endregion
 
        #region PUBLIC_PROPERTIES
 
        public String ChunkID
        {
            get { return chunkID; }
            set { chunkID = value; }
        }
 
        public int ChunkSize
        {
            get { return chunkSize; }
            set { chunkSize = value; }
        }
 
        public String Format
        {
            get { return format; }
            set { format = value; }
        }
 
        public String Subchunk1ID
        {
            get { return subchunk1ID; }
            set { subchunk1ID = value; }
        }
 
        public int Subchunk1Size
        {
            get { return subchunk1Size; }
            set { subchunk1Size = value; }
        }
 
        public short AudioFormat
        {
            get { return audioFormat; }
            set { audioFormat = value; }
        }
 
        public short NumChannels
        {
            get { return numChannels; }
            set { numChannels = value; }
        }
 
        public int SampleRate
        {
            get { return sampleRate; }
            set { sampleRate = value; }
        }
 
        public int ByteRate
        {
            get { return byteRate; }
            set { byteRate = value; }
        }
 
        public short BlockAlign
        {
            get { return blockAlign; }
            set { blockAlign = value; }
        }
 
        public short BitsPerSample
        {
            get { return bitsPerSample; }
        }
 
        public String Subchunk2ID
        {
            get { return subchunk2ID; }
            set { subchunk2ID = value; }
        }
 
        public int Subchunk2Size
        {
            get { return subchunk2Size; }
            set { subchunk2Size = value; }
        }
 
        public String WaveFileName
        {
            get { return waveFile; }
            set { waveFile = value; }
        }
 
        public short[] SoundDataCh1
        {
            get { return soundDataCh1; }
            set { soundDataCh1 = value; }
        }
 
        public short[] SoundDataCh2
        {
            get { return soundDataCh2; }
            set { soundDataCh2 = value; }
        }
 
        public int SilentLevel
        {
            get { return silentLevel; }
            set { silentLevel = value; }
        }
 
        public byte[] FullSoundData
        {
            get { return fullSoundData; }
            set { fullSoundData = value; }
        }
 
 
        public int StartIndex
        {
            get { return startIndex; }
            set { startIndex = value; }
        }
 
 
        public int PlayLength
        {
            get { return playLength; }
            set { playLength = value; }
        }
 
        #endregion
 
       /// <summary>
       /// TODO
       /// </summary>
       /// <param name="theWaveFile"></param>
        public WaveFile(String theWaveFile)
        {
            try
            {
                waveFile = theWaveFile;
 
                using (FileStream fs = new FileStream(waveFile, FileMode.Open, FileAccess.Read))
                {
                    using (BinaryReader br = new BinaryReader(fs))
                    {
                        LoadWaveFileData(br);
                        br.Close();
                        fs.Close();
                    }
                }
            }
            catch (IOException e)
            {
                //TODO handle better...
                System.Windows.Forms.MessageBox.Show(e.Message);
            }
            catch (Exception e)
            {
                System.Windows.Forms.MessageBox.Show(e.Message);
            }
 
        }
 
        /// <summary>
        /// TODO
        /// </summary>
        /// <param name="theWaveFile"></param>
        public WaveFile(byte[] theWaveFile)
        {
            try
            {
                waveFile = "";
 
                using (MemoryStream Ms = new MemoryStream(theWaveFile, 0, theWaveFile.Length))
                {
                    using (BinaryReader br = new BinaryReader(Ms))
                    {
                        LoadWaveFileData(br);
                        br.Close();
                        Ms.Close();
                    }
                }
            }
            catch (IOException e)
            {
                System.Windows.Forms.MessageBox.Show(e.Message);
            }
            catch (Exception e)
            {
                System.Windows.Forms.MessageBox.Show(e.Message);
            }
 
        }
 
        private void LoadWaveFileData(BinaryReader theBR)
        {
            ASCIIEncoding encoding = new ASCIIEncoding();
 
            chunkID = encoding.GetString(theBR.ReadBytes(4));
            chunkSize = theBR.ReadInt32();
            format = encoding.GetString(theBR.ReadBytes(4));
            subchunk1ID = encoding.GetString(theBR.ReadBytes(4));
            subchunk1Size = theBR.ReadInt32();
            audioFormat = theBR.ReadInt16();
            numChannels = theBR.ReadInt16();
            sampleRate = theBR.ReadInt32();
            byteRate = theBR.ReadInt32();
            blockAlign = theBR.ReadInt16();
            bitsPerSample = theBR.ReadInt16();
            subchunk2ID = encoding.GetString(theBR.ReadBytes(4));
            subchunk2Size = theBR.ReadInt32();
 
            startIndex = 0;
            playLength = subchunk2Size;
 
            if (chunkID != "RIFF" || format != "WAVE" || subchunk1ID != "fmt ")
            {
                throw new IOException("Not a valid WAVE file.");
            }
 
            if (bitsPerSample != 8 && bitsPerSample != 16)
            {
                throw new IOException("This WAVE file format is not supported. (8 or 16 bits per sample)");
            }
 
            if (numChannels != 1 && numChannels != 2)
            {
                throw new IOException("This WAVE file format is not supported. (Maximum 2 channels)");
            }
 
            if (audioFormat != 1)
            {
                throw new IOException("This WAVE file format is not supported. (Only PCM data)");
            }
 
            silentLevel = 0;
            if (bitsPerSample == 8)
                silentLevel = 128;
 
            int bytesPerSample = bitsPerSample / 8;
 
            soundDataCh1 = new short[subchunk2Size / bytesPerSample / numChannels];
            soundDataCh2 = null;
            if (numChannels == 2)
                soundDataCh2 = new short[subchunk2Size / bytesPerSample / numChannels];
 
 
            for (int i = 0; i < (subchunk2Size / bytesPerSample / numChannels); i++)
            {
                if (bitsPerSample == 8)
                {
                    soundDataCh1[i] = theBR.ReadByte();
                    if (numChannels == 2)
                    {
                        soundDataCh2[i] = theBR.ReadByte();
                    }
                }
                else
                {
                    soundDataCh1[i] = theBR.ReadInt16();
                    if (numChannels == 2)
                    {
                        soundDataCh2[i] = theBR.ReadInt16();
                    }
                }
            }
 
            theBR.BaseStream.Position = theBR.BaseStream.Position - subchunk2Size;
            fullSoundData = theBR.ReadBytes(subchunk2Size);
        }
 
        /// <summary>
        /// TODO
        /// </summary>
        /// <returns></returns>
        public float GetLengthInBytes()
        {
            return subchunk2Size;
        }
 
        /// <summary>
        /// TODO
        /// </summary>
        /// <returns></returns>
        public float GetLengthInSeconds()
        {
            //TODO  clean up
            float retLength = 0;
            retLength = (float)playLength / (float)bitsPerSample / (float)sampleRate / (float)numChannels * 8;
            return retLength;
        }
 
    }
 
    class WinmmPlayer : IWavePlayer
    {
        #region PRIVATE FIELDS AND CONSTANTS
 
        private WaveFile myWaveFile;
        private IntPtr mWaveOutDeviceHndl;
        private WAVEFORMATEX mWAVEFORMATEX;
        private Thread mPlayThread;
        private bool mCurrentlyPlaying;
        private bool mCurrentlyPaused;
        private bool mCurrentlyStopped;
        private SoundDataBuffer mSoundDataBuffers; // Implements IDispose
        private WinmmWrap.WinProcDelegate mCustomWaveOutProc;
        private const int NUM_OF_BUFFERS = 5;
        private const int BUFFER_SIZE = 8 * 1024; 
 
        #endregion
 
        public WinmmPlayer(WaveFile theWaveFile)
        {
            try
            {
                myWaveFile = theWaveFile;
                mCurrentlyPlaying = false;
                mCurrentlyPaused = false;
                mCurrentlyStopped = false;
                
                mCustomWaveOutProc = new WinmmWrap.WinProcDelegate(this.WaveOutProc);
                mWAVEFORMATEX = new WAVEFORMATEX(myWaveFile.SampleRate, myWaveFile.BitsPerSample, myWaveFile.NumChannels, myWaveFile.AudioFormat);
 
                int retVal = WinmmWrap.waveOutOpen(out mWaveOutDeviceHndl, -1, mWAVEFORMATEX, mCustomWaveOutProc, 0, WinmmWrap.CALLBACK_FUNCTION);
                if (retVal != WinmmWrap.MMSYSERR_NOERROR)
                    throw new Exception("waveOutOpen Error Returened: " + retVal.ToString());
 
                // LOAD BUFFERS IN CIRCULAR QUEU
                mSoundDataBuffers = new SoundDataBuffer(BUFFER_SIZE, mWaveOutDeviceHndl);
                SoundDataBuffer prevBuffer = mSoundDataBuffers;
                for (int i = 1; i < NUM_OF_BUFFERS; i++)
                {
                    SoundDataBuffer tempBuf = new SoundDataBuffer(BUFFER_SIZE, mWaveOutDeviceHndl);
                    prevBuffer.NextBuffer = tempBuf;
                    prevBuffer = tempBuf;
                }
                prevBuffer.NextBuffer = mSoundDataBuffers;
 
            }
            catch (Exception anyE)
            {
                System.Windows.Forms.MessageBox.Show(anyE.Message);
                //throw;
            }
 
        }
 
        public bool Play()
        {
            mCurrentlyStopped = false;
            
            if (mCurrentlyPaused)
            {
                mCurrentlyPaused = !(WinmmWrap.waveOutRestart(mWaveOutDeviceHndl) == WinmmWrap.MMSYSERR_NOERROR);
            }
 
            if (!mCurrentlyPlaying)
            {
                mPlayThread = new Thread(new ThreadStart(ThreadPlay));
                mPlayThread.Start();
                mCurrentlyPlaying = true;
            }
            return mCurrentlyPlaying;
        }
 
        private void ThreadPlay()
        {
            //TODO make more thread safe...
            bool atEndOfSound = false;
            SoundDataBuffer currentBufferToPlay = mSoundDataBuffers;
 
            using (MemoryStream soundDataStream = new MemoryStream(myWaveFile.FullSoundData, myWaveFile.StartIndex, myWaveFile.PlayLength))
            {
                soundDataStream.Position = 0;
 
                while (atEndOfSound == false && mCurrentlyStopped == false)
                {
                    currentBufferToPlay.NextBuffer.WaitForBufferToFinishPlaying();
                    currentBufferToPlay = currentBufferToPlay.NextBuffer;
                    lock (currentBufferToPlay)
                    {
                        int numBytesRead = currentBufferToPlay.LoadAndPlayBuffer(soundDataStream);
                        //Console.Write(numBytesRead.ToString() + "\n");
                        if (numBytesRead != BUFFER_SIZE)
                            atEndOfSound = true;
                    }
                }
 
                if (!mCurrentlyStopped)
                {
                    currentBufferToPlay = mSoundDataBuffers;
                    while (currentBufferToPlay.NextBuffer != mSoundDataBuffers)
                    {
                        currentBufferToPlay.WaitForBufferToFinishPlaying();
                        currentBufferToPlay = currentBufferToPlay.NextBuffer;
                    }
                    mSoundDataBuffers.WaitForBufferToFinishPlaying();
                }
                bool finishedPlaying = !(WinmmWrap.waveOutReset(mWaveOutDeviceHndl) == WinmmWrap.MMSYSERR_NOERROR);
                Thread.Sleep(200); // Allow all painting to finish before sayong we are done playing...
                mCurrentlyPlaying = finishedPlaying;
            }
        }
 
        void WaveOutProc(IntPtr hdrvr, int uMsg, int dwUser, ref WAVEHDR wavhdr, int dwParam2)
        {
            //System.Windows.Forms.MessageBox.Show(uMsg.ToString());
            if (uMsg == WinmmWrap.MM_WOM_DONE)
            {
                try
                {
                    GCHandle h = (GCHandle)wavhdr.dwUser;
                    SoundDataBuffer buf = (SoundDataBuffer)h.Target;
                    buf.FinishedPlaying();
                }
                catch
                {
                }
            }
        }
 
        public bool Pause()
        {
            if (mCurrentlyPlaying)
            {
                if (mCurrentlyPaused)
                {
                    mCurrentlyPaused = !(WinmmWrap.waveOutRestart(mWaveOutDeviceHndl) == WinmmWrap.MMSYSERR_NOERROR);
                }
                else
                {
                    mCurrentlyPaused = WinmmWrap.waveOutPause(mWaveOutDeviceHndl) == WinmmWrap.MMSYSERR_NOERROR;
                }
            }
            return mCurrentlyPaused;
        }
 
        public bool Stop()
        {
            mCurrentlyStopped = true;
            if (mCurrentlyPaused)
            {
                mCurrentlyPaused = !(WinmmWrap.waveOutReset(mWaveOutDeviceHndl) == WinmmWrap.MMSYSERR_NOERROR);
                mCurrentlyPlaying = mCurrentlyPaused;
            }
            return mCurrentlyStopped;
        }
 
        public int GetPositionInBytes()
        {
            //TODO null check...
            MMTIME a = new MMTIME();
            a.wType = WinmmWrap.TIME_BYTES;
            if (mWaveOutDeviceHndl != IntPtr.Zero)
                WinmmWrap.waveOutGetPosition(mWaveOutDeviceHndl, ref a, Marshal.SizeOf(a));
            return a.u;
        }
 
        public bool IsPlaying()
        {
            return !mCurrentlyPaused && mCurrentlyPlaying;
        }
 
        //TODO implement proper dispose patern...
        public void Dispose() { return; }
 
    }
 
    internal class SoundDataBuffer : IDisposable
    {
        //TODO make class more thread safe...
        #region CLASS FIELDS AND PROPERTIES
        
        private byte[] mSoundData;
        private int mBufferSize;
        private AutoResetEvent mCurrentlyInQueu = new AutoResetEvent(false);
        private bool mCurrentlyInQueuB;
        private WAVEHDR mWAVEHDR;
        private GCHandle mWAVEHDR_HNDL;
        private GCHandle mWAVEHDR_DATA_HNDL;
        private IntPtr mWaveOutDeviceHndl;
        private SoundDataBuffer nextBuffer;
        internal SoundDataBuffer NextBuffer
        {
            get { return nextBuffer; }
            set { nextBuffer = value; }
        } 
        #endregion
 
        public SoundDataBuffer(int theBufferSize , IntPtr theWaveOutDeviceHndl)
        {
            //TODO try block...
            mSoundData = new byte[theBufferSize];
            mWAVEHDR = new WAVEHDR();
            mWAVEHDR_HNDL = GCHandle.Alloc(mWAVEHDR, GCHandleType.Pinned);
            mWAVEHDR.dwUser = (IntPtr)GCHandle.Alloc(this);
            mWAVEHDR_DATA_HNDL =GCHandle.Alloc(mSoundData, GCHandleType.Pinned);
            mWAVEHDR.lpData = mWAVEHDR_DATA_HNDL.AddrOfPinnedObject();
            mBufferSize = theBufferSize;
            mWAVEHDR.dwBufferLength = mBufferSize;
            mWaveOutDeviceHndl = theWaveOutDeviceHndl;
            mCurrentlyInQueuB = false;
 
            int headPrepRetVal = WinmmWrap.waveOutPrepareHeader(mWaveOutDeviceHndl, ref mWAVEHDR, Marshal.SizeOf(mWAVEHDR));
            //System.Windows.Forms.MessageBox.Show(headPrepRetVal.ToString());
        }
 
        public void WaitForBufferToFinishPlaying()
        {
            if (mCurrentlyInQueuB)
            {
                mCurrentlyInQueu.WaitOne();
            }
            else
            {
                Thread.Sleep(0);
            }
        }
 
        public int LoadAndPlayBuffer(MemoryStream theDataStream)
        {
            //TODO try block....
            int numBytesRead = 0;
            numBytesRead = theDataStream.Read(mSoundData, 0, mBufferSize);
            Marshal.Copy(mSoundData, 0, mWAVEHDR.lpData, numBytesRead);
            mWAVEHDR.dwBufferLength = numBytesRead;
            mCurrentlyInQueu.Reset();
            int writeRetVal = WinmmWrap.waveOutWrite(mWaveOutDeviceHndl, ref mWAVEHDR, Marshal.SizeOf(mWAVEHDR));
            //System.Windows.Forms.MessageBox.Show(writeRetVal.ToString());
            mCurrentlyInQueuB =  writeRetVal == WinmmWrap.MMSYSERR_NOERROR;
            return numBytesRead;
        }
 
        public void FinishedPlaying()
        {
            mCurrentlyInQueuB = false;
            mCurrentlyInQueu.Set();            
        }
 
        //TODO implement proper dispose patern...
        ~SoundDataBuffer()
        {
            //Dispose();
        }
 
        public void Dispose()
        {
            if (mWAVEHDR.lpData != IntPtr.Zero)
            {
                WinmmWrap.waveOutUnprepareHeader(mWaveOutDeviceHndl, ref mWAVEHDR, Marshal.SizeOf(mWAVEHDR));
                mWAVEHDR_HNDL.Free();
                mWAVEHDR.lpData = IntPtr.Zero;
            }
            mCurrentlyInQueu.Close();
            if (mWAVEHDR_DATA_HNDL.IsAllocated)
                mWAVEHDR_DATA_HNDL.Free();
 
            GC.SuppressFinalize(this);
        }
    }
 
    /////////////////////////////////////////
    //  NATIVE STRUCTURES AND WRAPPER CLASS
    /////////////////////////////////////////
 
    [StructLayout(LayoutKind.Sequential)]
    internal class WAVEFORMATEX
    {
        public short wFormatTag;
        public short nChannels;
        public int nSamplesPerSec;
        public int nAvgBytesPerSec;
        public short nBlockAlign;
        public short wBitsPerSample;
        public short cbSize;
 
        public WAVEFORMATEX(int theSampleRate, int theBitsPerSample, int theNumChannels, short theAudioFormat)
        {
            wFormatTag = theAudioFormat;
            nChannels = (short)theNumChannels;
            nSamplesPerSec = theSampleRate;
            wBitsPerSample = (short)theBitsPerSample;
            cbSize = 0;
 
            nBlockAlign = (short)(theNumChannels * (theBitsPerSample / 8));
            nAvgBytesPerSec = nSamplesPerSec * nBlockAlign;
        }
    }
 
    [StructLayout(LayoutKind.Sequential)]
    internal struct WAVEHDR
    {
        public IntPtr lpData; // pointer to locked data buffer
        public int dwBufferLength; // length of data buffer
        public int dwBytesRecorded; // used for input only
        public IntPtr dwUser; // for client's use
        public int dwFlags; // assorted flags (see defines)
        public int dwLoops; // loop control counter
        public IntPtr lpNext; // PWaveHdr, reserved for driver
        public int reserved; // reserved for driver
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
    internal struct MMTIME
    {
        public int wType;
        public int u;
        public int x;
    }
 
    internal static class WinmmWrap
    {
        // CONSTANTS
        public const int MMSYSERR_NOERROR = 0; // no error
        public const int MM_WOM_OPEN = 0x3BB;
        public const int MM_WOM_CLOSE = 0x3BC;
        public const int MM_WOM_DONE = 0x3BD;
        public const int CALLBACK_FUNCTION = 0x00030000;    // dwCallback is a FARPROC 
        public const int CALLBACK_NULL = 0x0;
        public const int CALLBACK_TASK = 0x20000;
        public const int CALLBACK_TYPEMASK = 0x70000;
        public const int CALLBACK_WINDOW = 0x10000;
        public const int TIME_MS = 0x0001;      // time in milliseconds 
        public const int TIME_SAMPLES = 0x0002; // number of wave samples 
        public const int TIME_BYTES = 0x0004;   // current byte offset 
 
        // WINPROC DELEGATE
        public delegate void WinProcDelegate(IntPtr hdrvr, int uMsg, int dwUser, ref WAVEHDR wavhdr, int dwParam2);
 
        // NATIVE WINMM METHODS
        [DllImport("winmm.dll")]
        public static extern int waveOutGetNumDevs();
        [DllImport("winmm.dll")]
        public static extern int waveOutPrepareHeader(IntPtr hWaveOut, ref WAVEHDR lpWaveOutHdr, int uSize);
        [DllImport("winmm.dll")]
        public static extern int waveOutUnprepareHeader(IntPtr hWaveOut, ref WAVEHDR lpWaveOutHdr, int uSize);
        [DllImport("winmm.dll")]
        public static extern int waveOutWrite(IntPtr hWaveOut, ref WAVEHDR lpWaveOutHdr, int uSize);
        [DllImport("winmm.dll")]
        public static extern int waveOutOpen(out IntPtr hWaveOut, int uDeviceID, WAVEFORMATEX lpFormat, WinProcDelegate dwCallback, int dwInstance, int dwFlags);
        [DllImport("winmm.dll")]
        public static extern int waveOutReset(IntPtr hWaveOut);
        [DllImport("winmm.dll")]
        public static extern int waveOutClose(IntPtr hWaveOut);
        [DllImport("winmm.dll")]
        public static extern int waveOutPause(IntPtr hWaveOut);
        [DllImport("winmm.dll")]
        public static extern int waveOutRestart(IntPtr hWaveOut);
        [DllImport("winmm.dll")]
        public static extern int waveOutGetPosition(IntPtr hWaveOut, ref MMTIME lpInfo, int uSize);
        [DllImport("winmm.dll")]
        public static extern int waveOutSetVolume(IntPtr hWaveOut, int dwVolume);
        [DllImport("winmm.dll")]
        public static extern int waveOutGetVolume(IntPtr hWaveOut, out int dwVolume);
    }
}
                                              

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:
605:
606:
607:
608:
609:
610:
611:
612:
613:
614:
615:
616:
617:
618:
619:
620:
621:
622:
623:
624:
625:
626:
627:
628:
629:
630:
631:
632:
633:
634:
635:
636:
637:
638:
639:
640:
641:
642:
643:
644:
645:
646:
647:
648:
649:
650:
651:
652:
653:
654:
655:
656:
657:
658:
659:
660:
661:
662:
663:
664:
665:
666:
667:
668:
669:
670:
671:
672:
673:
674:
675:
676:
677:
678:
679:
680:
681:
682:
683:
684:
685:
686:
687:
688:
689:
690:
691:
692: