diff --git a/README.md b/README.md new file mode 100644 index 0000000..25204a5 --- /dev/null +++ b/README.md @@ -0,0 +1,58 @@ +ExtIO_H101.dll +=========== + +by Oscar Steila IK1XPV + +Based on original work: + * Winrad specifications for the external I/O DLL by Alberto di Bene I2PHD + + see: [Winrad Extio.dll](http://www.winrad.org/bin/Winrad_Extio.pdf)  + +## Description +CIAOradio H101 was one of the firsts Hamradio SDR receiver by Claudio Re I1RFQ and Oscar Steila IK1XPV in 2004. + +![H101](docs/H101.jpg) + +The ExtIO_H101.dll as been realized to enable the use of many SDR program that uses ExtIO interface with H101 hardware. + +ExtIO_H101 early test using: + +[HDSDR](http://www.hdsdr.de/) + +[SDRsharper](http://www.qsl.net/sdr) + +[WinradF](http://www.adaptableobjects.com/Ham%20Radio/PM-SDR/SDR%20Software/WinradF/WinradF%201.5.zip) + +Copy Extio_H101.dll into the SDR application directory and then select the ExtIO_H101 from the SDR application setup. + +### Required Library + +ExtIO_H101.dll uses RTaudio library +RtAudio: a set of realtime audio i/o C++ classes by Gary P. Scavone + +[The RtAudio Home Page](https://www.music.mcgill.ca/~gary/rtaudio/) + +[Version 4.1.1](http://www.music.mcgill.ca/~gary/rtaudio/release/rtaudio-4.1.1.tar.gz) + +## H101 Historical links: + +[7° Convention Digital & Radio Communications i-LINK Renon 2005 (slides, 2005 - Italian )](http://www.steila.com/CIAOradio/doc/Renon2005.pdf) + +[Ciao Radio H101 - IK1QLD (2005 - Italian )](http://www.brunero.it/drm/ciaoradio/CiaoRadioColor.pdf) + +[Radio & Communication Info: CiaoRadio, la nuova frontiera (provata) (2006 - Italian )](http://radiodxinfo.blogspot.it/2006/01/ciaoradio-la-nuova-frontiera-provata.html) + +[Ham Station IWØHK: Sistel Ciaoradio H101: test-set e ricevitore hf Sdr (2006 - Italian )](http://www.mediasuk.org/iw0hk/articolo_ciaoradio.htm) + +[FUNKAMATEUR 11/2006: Willkommen: CIAO Radio H101 - ein softwaredefinierter Empfanger (2006 - German)](http://www.wimo.com/download/ciaoradio_test_aus_funkamateur_11_06.pdf) + +[www.steila.com/blog](http://www.steila.com/blog/index.php?controller=page&action=view&id_page=2) + +## Thanks to + +Alberto di Bene, I2PHD + +Claudio Re, I1RFQ + +Ivan Guerini, IW2KBK + diff --git a/src/CIAOradio.ico b/src/CIAOradio.ico new file mode 100644 index 0000000..0509d17 Binary files /dev/null and b/src/CIAOradio.ico differ diff --git a/src/ExtIO_H101.cpp b/src/ExtIO_H101.cpp new file mode 100644 index 0000000..4483df7 --- /dev/null +++ b/src/ExtIO_H101.cpp @@ -0,0 +1,1130 @@ +/* ****************************************************************************** + * ExtIO_H101.dll + * Copyleft by Oscar Steila IK1XPV [ik1xpv at gmail.com] + * per GNU I think I'm required to leave the following here: + * + * Based on original work: + * Winrad specifications for the external I/O DLL by Alberto di Bene I2PHD + * see: www.winrad.org/bin/Winrad_Extio.pdf + * see Google for other variations + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include +#include +#include +#include +#include +#include +#include +#include "rtaudio.h" +#include "resource.h" +#include "ExtIO_H101.h" +#include "fifo.h" +#include "Udefines.h" +#include "freqtabH101.h" +#include "settings.h" +#include "SoundUti.h" + + +HMODULE hInst; + +BOOL APIENTRY DllMain(HMODULE hModule, + DWORD ul_reason_for_call, + LPVOID lpReserved + ) +{ + switch (ul_reason_for_call) + { + case DLL_PROCESS_ATTACH: + hInst = hModule; + case DLL_THREAD_ATTACH: + case DLL_THREAD_DETACH: + case DLL_PROCESS_DETACH: + break; + } + return TRUE; +} + + +// PPM correction parameters +#define MAX_PPM 1000 +#define MIN_PPM -1000 +#define MAX_ADC 100 +#define MIN_ADC 1 + +static int ppm_default=0; +static double freq_correction = 1.0; +static int adcx_default = 50; +static long gfreq = 0; + +// sample rate +typedef struct sr { + int value; + TCHAR *name; +} sr_t; + +static sr_t samplerates[] = { + { 48000, TEXT("48 kHz") } +}; +static int samplerate_default=0; // 48 kHz + +// H101 UART over audio channel +#define SERIAL1 ( 0.5f ) +#define SERIAL0 (-0.5f ) + +// Local Oscillator frequency +static long LOfreq; +// DC filter +static float averageI = 0.0f; +static float averageQ = 0.0f; +static float ratio = 0.035f; +static float oneMinusRatio = 1.0f - ratio; +static float cgain = 1.0f / (float)0x7fff; + +// antennas +static TCHAR* antenna[] = { //antenna selector + TEXT("ANT 1"), + TEXT("ANT 2") +}; +static int antenna_idx = 0; + +// attenuator +typedef struct att { + int value; + TCHAR *name; +} att_t; + +static att_t attenuation[] = { + { 0, TEXT(" 0") }, + { 1, TEXT(" - 10") }, + { 2, TEXT(" - 20") } +}; + +static int attenuation_idx = 0; // 0 dB +// IF GAIN +static att_t ifgain[] = { + { 0, TEXT(" - 10") }, + { 1, TEXT(" 0") }, + { 2, TEXT(" + 20") }, + { 3, TEXT(" + 40") } +}; + +static int ifgain_idx = 2; // 0 dB + +const float gainadj[3][4] = { +// H101 ifgain +// -10 0 +20 +40 dB +{ 17.0f , +7.0f , -13.0f , -33.0f }, // att = 0 dB +{ +27.0f , +17.0f , -3.0f , -23.0f }, // att = -10 dB +{ +37.0f , +27.0f , +7.0f , -13.0f } // att = -20 dB + +}; + + +// past io data +static UINT8 _iodata[3]; + +// Audio devices +#define MAX_AUDIODEVICES (64) + +typedef struct soundport { + int index; + TCHAR name[255]; + UINT output; + UINT input; + bool usb; + UINT rate; +} sound_t; + +static std::vector soundPorts; + +/* ExtIO Callback */ +static void (* WinradCallBack)(int, int, float, void *) = NULL; + +#define WINRAD_LOCHANGE 101 +#define WINRAD_STOP 108 +// Dialog callback +static INT_PTR CALLBACK MainDlgProc(HWND, UINT, WPARAM, LPARAM); +HWND h_dialog=NULL; + +int H101CallBack(void *outputBuffer, void *inputBuffer, unsigned int nBufferFrames, + double streamTime, RtAudioStreamStatus status, void *data); +// Audio +RtAudio * adacp = nullptr; // RtAudio class pointer +static int buffer_len = 1024;// audio buffer len +static float *float_buf = nullptr; // Buffer float pointer +static float onesampledelay; // one sample delay to compensate PCM2902 bug +static int deviceAdcId =-1; + +static FifoUchar uartfifo; // uchar fifo to uart audio +static UINT uartbitcnt = 0; // bit count +static UINT idxbit = 0; // bit index +static UINT uartsignal = 0xffff; // uart char bit vector + +#define WriteChar uartfifo.sampleIn /* put data to uart fifo */ + +static int ddsfreq = 0; // dds frequency buffer +static int ddsMHZ = 0; // dds MHz buffer +static bool setEditTextProgramatically = true; + +void DDSfreq(int fdds, bool doit); // program frequency +void WriteIOH101(void); // program IO +void SendPacket(UINT8 *ptdata, UINT16 tdatalen); // prepare and send uart packet + +static Settings H101settings(TEXT("\\ExtIO_H101_dll.ini")); + + + +// string to TCHAR +TCHAR* string2TCHAR(std::string str) { + TCHAR* dest = (TCHAR*)malloc(sizeof(TCHAR) * (str.length() + 1)); + std::wstring wsTmp(str.begin(), str.end()); + if (dest == nullptr) exit(1); + _tcscpy_s((TCHAR *) dest, (str.length() + 1), wsTmp.c_str()); + return dest; +} + + +// enumerate sound devices using RtAudio +bool EnumerateSounds(void) +{ + // Enumerate audio devices + RtAudio audio; + soundPorts.clear(); + soundPorts.reserve(MAX_AUDIODEVICES); + // Determine the number of devices available + unsigned int devices = audio.getDeviceCount(); + // Scan through devices for various capabilities + RtAudio::DeviceInfo info; + sound_t soundx; + bool r = false; + for (unsigned int i = 0; i < devices; i++) + { + info = audio.getDeviceInfo(i); + + if (info.probed == true) { + soundx.index = i; + memcpy(soundx.name, string2TCHAR(info.name), sizeof(soundx.name)); + soundx.output = info.outputChannels; + soundx.input = info.inputChannels; + soundx.usb = (strstr(info.name.c_str(), "USB") != nullptr); + soundPorts.push_back(soundx); + + DbgPrintf("%d %s \n", soundx.index, info.name); + + r = true; + } + } + return r; +} + +void AdviceSoundIn() +{ + TCHAR msgstr[512]; + TCHAR tstri[255]; + ComboBox_GetText((GetDlgItem(h_dialog, IDC_AUDIOIN)), tstri, sizeof(tstri) / sizeof(TCHAR)); + _stprintf_s(msgstr, 512, TEXT("Please\n-open Sound setting (search audio)\n-press the recording tab\n-select the %s device\n-press the properties button\n-press advanced tab\n-select 2 channel, 16 bit, 48KHz (DVD quality) format\n-press levels tab and set volume at maximum (100)\n-restart the SDR program."), tstri); + MessageBox(NULL, msgstr, TEXT("The audio device setting is required"), MB_ICONINFORMATION); +} + +void AdviceSoundOut() +{ + TCHAR msgstr[512]; + TCHAR tstro[255]; + ComboBox_GetText((GetDlgItem(h_dialog, IDC_AUDIOOUT)), tstro, sizeof(tstro) / sizeof(TCHAR)); + _stprintf_s(msgstr, 512, TEXT("Please\n-open Audio setting (search audio)\n-select the %s device\n-press the properties button\n-press advanced tab\n-select 2 channel, 16 bit, 48KHz (DVD quality) format\n-press levels tab and set volume at maximum (100)\n-restart the SDR program."), tstro); + MessageBox(NULL, msgstr, TEXT("The audio device setting is required"), MB_ICONINFORMATION); +} + + + +/* +InitHW + +bool __stdcall __declspec(dllexport) InitHW(char *name, char *model, int& type) + +This entry is the first called by Winrad at startup time, and it is used both to tell to the DLL that it is time to +initialize the hardware, and to get back a descriptive name and model (or Serial Number) of the HW, together with +a type code. + +Parameters : +name - descriptive name of the hardware.Preferably not longer than about 16 characters, as it will be used +in a Winrad menu. +model - model code of the hardware, or its Serial Number.Keep also this field not too long, for the same +reason of the previous one. +type - this is an index code that Winrad uses to identify the hardware type supported by the  DLL. +value : 3 - the hardware does its own digitization and the audio data are returned to Winrad +via the callback device.Data must be in 16?bit  (short) format, little endian. +Return value : + true - everything went well, the HW did initialize, and the return parameters have been filled. + false - the HW did not initialize (error, or powered off, or other reasons). +*/ + +extern "C" +bool LIBRTL_API __stdcall InitHW(char *name, char *model, int& type) +{ + static bool first = true; + +#ifdef _MYDEBUG + if (AllocConsole()) + { + FILE* f; + freopen_s(&f, "CONOUT$", "wt", stdout); + SetConsoleTitle(TEXT("Debug Console H101")); + SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_RED); + DbgPrintf("IK1XPV fecit MMXV\n"); + } +#endif + DbgPrintf("\n-InitHW\n"); + strcpy_s(name, 16, "CIAOradio"); // change with the name of your HW + strcpy_s(model, 16, "H101"); // change with the model of your HW + type = 7; //the hardware does its own digitization.. float32 + if (first) + { + first = false; + LOfreq = -1; // just a default value + memset(_iodata, 0, sizeof(_iodata)); + } + if (!EnumerateSounds()) + return false; + float_buf = (float *) new (std::nothrow) float[buffer_len * 2]; //allocate buffer + WriteChar(SYN); //activate uart + return true; +} +/* +GetStatus +int __stdcall __declspec(dllexport) GetStatus(void) +This entry point is meant to allow the DLL to return a status information to Winrad, upon request. Presently it is +never called by Winrad, though its existence is checked when the DLL is loaded. So it must implemented, even if in +a dummy way. It is meant for future expansions, for complex HW that implement e.g. a preselector or some other +controls other than a simple LO frequency selection. +The return value is an integer that is application dependent. +*/ +extern "C" +int LIBRTL_API __stdcall GetStatus() +{ + DbgPrintf("GetStatus\n"); + /* dummy function */ + return 0; +} +/* +OpenHW +bool __stdcall __declspec(dllexport) OpenHW(void) +This entry is called by Winrad each time the user specifies that Winrad should receive its audio data input through +the hardware managed by this DLL, or, if still using the sound card for this, that the DLL must activate the control +of the external hardware. It can be used by the DLL itself for delayed init tasks, like, e.g., the display of its own GUI, +if the DLL has one. +It has no parameters. +Return value : + true - everything went well.  + false - some error occurred, the external HW cannot be controlled by the DLL code. +*/ +extern "C" +bool LIBRTL_API __stdcall OpenHW() +{ + DbgPrintf("OpenHW\n"); + int r = 0; + + if (r < 0) + return FALSE; + h_dialog = CreateDialog(hInst, MAKEINTRESOURCE(IDD_RTL_SETTINGS), NULL, (DLGPROC)MainDlgProc); + ShowWindow(h_dialog, SW_HIDE); + TCHAR tstri[MAXTCHAR]; + TCHAR tstro[MAXTCHAR]; + ComboBox_GetText((GetDlgItem(h_dialog, IDC_AUDIOIN)), tstri, sizeof(tstri) / sizeof(TCHAR)); + ComboBox_GetText((GetDlgItem(h_dialog, IDC_AUDIOOUT)), tstro, sizeof(tstro) / sizeof(TCHAR)); + if ((_tcsstr(tstri, TEXT("Microphone")) == NULL) || + (_tcsstr(tstri, TEXT("USB Audio CODEC")) == NULL) || + (_tcsstr(tstro, TEXT("Speakers")) == NULL) || + (_tcsstr(tstro, TEXT("USB Audio CODEC")) == NULL)) + { + MessageBox(NULL, +TEXT("Is H101 connected ? \nplease verify and press ok to exit\n\nH101 sound devices are: \nMicrophone (USB Audio CODEC)\nSpeakers (USB Audio CODEC)"), + TEXT("Duplex USB audio device not found"), MB_ICONQUESTION); + ExitProcess(0); // restart required + } + + return TRUE; +} + +/* +SetHWLO +int __stdcall __declspec(dllexport) SetHWLO(long LOfreq) +This entry point is used by Winrad to communicate and control the desired frequency of the external HW via the +DLL. The frequency is expressed in units of Hz. The entry point is called at each change (done by any means) of the +LO value in the Winrad main screen.  +Parameters : +LOfreq +a long integer specifying the frequency the HW LO should be set to, expressed in Hz. +Return values : 0 - The function did complete without errors. +< 0 (a negative number N) - The specified frequency is lower than the minimum that the hardware is capable to generate. The +absolute value of N indicates what is the minimum supported by the HW. +> 0 (a positive number N) - The specified frequency is greater than the maximum that the hardware is capable to generate. The +value of N indicates what is the maximum supported by the HW. +*/ +extern "C" +long LIBRTL_API __stdcall SetHWLO(long freq) +{ + int freque; + gfreq = freq; + DbgPrintf("SetHWLO %d\n", freq); + double nominal =(double) freq * freq_correction; + LOfreq = getfreq((int) nominal, TRUE, &freque); + + DDSfreq((int) LOfreq, TRUE); + + if (LOfreq !=freq ) + WinradCallBack(-1,WINRAD_LOCHANGE,0,NULL); // signal the real LO is different + + return 0; +} +/* + StartHW +  + int __stdcall __declspec(dllexport) StartHW(long freq) + + This entry is called by Winrad each time the user presses the Start button on the Winrad main screen, after having + previously specified that the DLL is in control of the external hardware. + Parameters : + freq - an integer specifying the frequency the HW should be set to, expressed in Hz. + Return value : + An integer specifying how many I/Q pairs are returned by the DLL each time the callback function is + invoked (see later). This information is used of course only when the input data are not coming from the + sound card, but through the callback device. + If the number is negative, that means that an error has occurred,  Winrad interrupts the starting process and + returns to the idle status. The number of I/Q pairs must be at least 512, or an integer multiple of that value +*/ +extern "C" +int LIBRTL_API __stdcall StartHW(long freq) +{ + DbgPrintf("StartHW\n"); + int k,w; + gfreq = freq; + adacp = new RtAudio; + // Set the same number of samples for both input and output. + unsigned int bufferBytes, bufferFrames = buffer_len; + RtAudio::StreamParameters iParams, oParams; + + + TCHAR tstri[255]; + TCHAR tstro[255]; + ComboBox_GetText((GetDlgItem(h_dialog, IDC_AUDIOIN)), tstri,sizeof(tstri)/sizeof(TCHAR)); + ComboBox_GetText((GetDlgItem(h_dialog, IDC_AUDIOOUT)), tstro, sizeof(tstro) / sizeof(TCHAR)); + k = 0; + w = 0; + for (unsigned int i = 0; i < soundPorts.size(); i++) + { + if (_tcscmp(soundPorts[i].name, tstri) == 0) + { + w++; + iParams.deviceId = soundPorts[i].index; + if (soundPorts[i].input > 1) + k++; + else + { + if (Soundsetup(soundPorts[i].name) == 0) + k++; + else + AdviceSoundIn(); + } + + } + if (_tcscmp(soundPorts[i].name, tstro) == 0) + { + w++; + oParams.deviceId = soundPorts[i].index; + if (soundPorts[i].output > 1) + k++; + else + { + if (SoundPlaySetup(soundPorts[i].name) == 0) + k++; + else + AdviceSoundOut(); + } + } + } + if (w != 2) + MessageBox(NULL, TEXT("Is H101 connected ? \nplease verify and press ok to exit\n"), + TEXT("Duplex USB audio device not found"), MB_ICONQUESTION); + if (k != 2) + ExitProcess(0); // restart required + + SetVolume(iParams.deviceId, (float) adcx_default); + SetVolume(oParams.deviceId, 100.0f); + + iParams.nChannels = 2; + oParams.nChannels = 2; + + int srate_idx = ComboBox_GetCurSel(GetDlgItem(h_dialog, IDC_SAMPLERATE)); + try { + adacp->openStream(&oParams, &iParams, RTAUDIO_FLOAT32, samplerates[srate_idx].value, &bufferFrames, &H101CallBack, (void *)&bufferBytes); + } + catch (RtAudioError& e) { + e.printMessage(); + if (adacp->isStreamOpen()) adacp->closeStream(); + return -1; + } + + bufferBytes = bufferFrames * 2 * 4; + + try { + adacp->startStream(); + } + catch (RtAudioError& e) { + e.printMessage(); + return -1; + } + DbgPrintf("\naudioprocessor started \n"); + + { // init H101 + UINT8 writebuf[4]; + writebuf[0] = CTRL_RX; //CTRL byte + writebuf[1] = AT_CONTROLINIT; //CMD byte + writebuf[2] = 0; + SendPacket((unsigned char*)writebuf, 2); + } +// Sleep(200); + SetHWLO(freq); + + deviceAdcId = iParams.deviceId; // salva idx audio in + return buffer_len; +} + + +/* +GetHWLO +long __stdcall __declspec(dllexport) GetHWLO(void) +This entry point is meant to query the external hardware?s set frequency via the DLL.. It is  used by Winrad to +handle a asynchronous status of 101 (see below the callback device), but not checked at startup for its presence. +The return value is the current LO frequency, expressed in units of Hz. +*/ +extern "C" +long LIBRTL_API __stdcall GetHWLO() +{ + double nominal = (double)LOfreq / freq_correction; + DbgPrintf("GetHWLO %e \n", nominal); + return (long) nominal; +} + +/* +GetHWSR +long __stdcall __declspec(dllexport) GetHWSR(void) +This entry point is used to ask the external DLL which is the current value of the sampling rate. If the sampling rate +is changed either by means of a hardware action or because the user specified a new sampling rate in the GUI of the +DLL, Winrad must be informed by using the callback device (described below).  +The return value is the value of the current sampling rate expressed in units of Hz. +*/ +extern "C" +long LIBRTL_API __stdcall GetHWSR() +{ + long srate = 48000; + int srate_idx = ComboBox_GetCurSel(GetDlgItem(h_dialog, IDC_SAMPLERATE)); + if (srate_idx >= 0 && srate_idx < (sizeof(samplerates) / sizeof(samplerates[0]))) + { + srate = (long) samplerates[srate_idx].value; + } + DbgPrintf("GetHWSR %d\n", srate); + return srate; +} + +/* + +StopHW +void __stdcall __declspec(dllexport) StopHW(void) +This entry is called by Winrad each time the user presses the Stop button on the Winrad main screen. It can be used +by the DLL for whatever task might be needed in such an occurrence. If the external HW does not provide the +audio data, being, e.g., just a DDS or some other sort of an oscillator, typically this call is a No?op. The DLL could +also use this call to hide its GUI, if any. +If otherwise the external HW sends the audio data via the USB port, or any other hardware port managed by the +DLL, when this entry is called, the HW should be commanded by the DLL to stop sending data. +It has no parameters and no return value. + +*/ +extern "C" +void LIBRTL_API __stdcall StopHW() +{ + DbgPrintf("StopHW\n"); + if (adacp != nullptr) + { + adacp->stopStream(); + delete adacp; + adacp = nullptr; + } +} + + +/* +CloseHW +void __stdcall __declspec(dllexport) CloseHW(void) +  + This entry is called by Winrad when the User indicates that the control of the external HW is no longer needed or + wanted. This is done in Winrad by choosing ShowOptions | Select Input then selecting either WAV file or Sound + Card. The DLL can use this information to e.g. shut down its GUI interface, if any, and possibly to put the + controlled HW in a idle status. + It has no parameters and no return value. +*/ +extern "C" +void LIBRTL_API __stdcall CloseHW() +{ + DbgPrintf("CloseHW\n"); + if (float_buf != nullptr) + delete(float_buf); + if (h_dialog!= nullptr) + DestroyWindow(h_dialog); +} + +/* +ShowGUI +void __stdcall __declspec(dllexport) ShowGUI(void) +This entry point is used by Winrad to tell the DLL that the user did ask to see the GUI of the DLL itself, if it has one. +The implementation of this call is optional  +It has  no return value. +*/ +extern "C" +void LIBRTL_API __stdcall ShowGUI() +{ + DbgPrintf("ShowGUI\n"); + ShowWindow(h_dialog,SW_SHOW); + SetForegroundWindow(h_dialog); + return; +} + +/* +HideGUI +void __stdcall __declspec(dllexport) HideGUI(void) +This entry point is used by Winrad to tell the DLL that it has to hide its GUI, if it has one. The implementation of +this call is optional  +It has  no return value +*/ +extern "C" +void LIBRTL_API __stdcall HideGUI() +{ + DbgPrintf("HideGUI\n"); + ShowWindow(h_dialog,SW_HIDE); + return; +} + +extern "C" +void LIBRTL_API __stdcall SwitchGUI() +{ + DbgPrintf("SwitchGUI\n"); + if (IsWindowVisible(h_dialog)) + ShowWindow(h_dialog,SW_HIDE); + else + ShowWindow(h_dialog,SW_SHOW); + return; +} + +/* +SetCallback +void __stdcall __declspec(dllexport) SetCallback(void (* Callback)(int, int, float, +short *)) +This entry point is used by Winrad to communicate to the DLL the function address that it should invoke when a +new buffer of audio data is ready, or when an  asynchronous event must be communicated by the DLL. Of course +the new buffer of audio data is only sent by DLLs that control HW that have their own internal digitizers and do +not depend on the soundcard for input. In this case it’s up to the DLL to decide which I/O port is used to read from +the HW the digitized audio data stream. One example is the USB port. If you don’t foresee the need of an +asynchronous communication started from the DLL, simply do a return when Winrad calls this entry point. +The callback function in Winrad that the DLL is expected to call, is defined as follows : +      void extIOCallback(int cnt, int status, float IQoffs, short IQdata[]) + Parameters : + cnt + is the number of samples returned. As the data is complex (I/Q pairs), then there are two 16 bit + values per sample. If negative, then the callback was called just to indicate a status change, no data + returned. Presently Winrad does not use this value, but rather the return value of the StartHW() + API, to allocate the buffers and process the audio data returned by the DLL. The cnt value is + checked only for negative value, meaning a status change. + status + is a status indicator (see the call GetStatus). When the DLL detects a HW change, e.g. a power On or + a power Off, it calls the callback function with a cnt parameter negative, indicating that no data is + returned, but that the call is meant just to indicate a status change. + Currently the status parameter has just two implemented values (apart from those used by the  + SDR?14/SDR?IQ hardware) : + 100 + This status value indicates that a sampling frequency change has taken place, either by a + hardware action, or by an interaction of the user with the DLL GUI.. When Winrad receives + this status, it calls immediately after the GetHWSR() API to know the new sampling rate.  + 101 + This status value indicates that a change of the LO frequency has taken place, either by a + hardware action, or by an interaction of the user with the DLL GUI.. When Winrad receives + this status, it calls immediately after the GetHWLO() API to know the new LO frequency.  + 102 + This status value indicates that the DLL has temporarily blocked any change to the LO + frequency. This may happen, e.g., when the DLL has started recording on a WAV file the + incoming raw data. As the center frequency has been written into the WAV file header, + changing it during the recording would be an error. + 103 + This status value indicates that changes to the LO frequency are again accepted by the DLL + 104        ******************* CURRENTLY NOT IMPLEMENTED YET **************************** + This status value indicates that a change of the LO frequency has taken place, and that + Winrad should act so to keep the Tune frequency unchanged. When Winrad receives this + status, it calls immediately after the GetHWLO() API to know the new LO frequency + 105 + This status value indicates that a change of the Tune frequency has taken place, either by a + hardware action, or by an interaction of the user with the DLL GUI.. When Winrad receives + this status, it calls immediately after the GetTune() API to know the new Tune frequency. + The TuneChanged() API is not called when setting the new Tune frequency +   + 106 + This status value indicates that a change of the demodulation mode has taken place, either + by a hardware action, or by an interaction of the user with the DLL GUI.. When Winrad + receives this status, it calls immediately after the GetMode() API to know the new + demodulation mode.  The ModeChanged() API is not called when setting the new mode. + 107 + This status value indicates that the DLL is asking Winrad to behave as if the user had + pressed the Start button. If Winrad is already started, this is equivalent to a no?op.  + 108 + This status value indicates that the DLL is asking Winrad to behave as if the user had + pressed the Stop button. If Winrad is already stopped, this is equivalent to a no?op.  + 109 + This status value indicates that the DLL is asking Winrad to change the passband limits + and/or the CW pitch. When Winrad receives this status, it calls immediately the GetFilters + API . + Upon request from the DLL writer, the status flag could be managed also for other kinds of + external hardware events. + IQoffs + If the external HW has the capability of determining and providing an offset value which would + cancel or minimize the DC offsets of the two outputs, then the DLL should set this parameter to the + specified value. Otherwise set it to zero. + IQdata + This is a pointer to an array of samples where the DLL is expected to place the digitized audio data + in interleaved format (I?Q?I?Q?I?Q etc.) in little endian ordering.   The number of bytes returned + must be equal to IQpairs * 2 * N, where IQpairs is the return value of the StartHW() API, and N is + the sizeof() of the type of data returned, as specified by the ‘type’ parameter of the InitHW() API. +*/ +extern "C" +void LIBRTL_API __stdcall SetCallback(void (* myCallBack)(int, int, float, void *)) +{ + DbgPrintf("SetCallback\n"); + WinradCallBack = myCallBack; + return; +} + + +// DC filter +// two indipendent I/Q high pass filter to reduce DC +void DCfilterIQ(float fbuf[], int len) +{ + for (int i = 0; i < len *2; i += 2) + { + averageI = averageI * oneMinusRatio +(float) fbuf[i] * ratio; + fbuf[i] -= averageI; + averageQ = averageQ * oneMinusRatio + (float) fbuf[i+1] * ratio; + fbuf[i+1] -= averageQ; + } + +} + +// Pass-through function. +// audio sample processing in front of WinradCallBack +// +int H101CallBack(void *outputBuffer, void *inputBuffer, unsigned int nBufferFrames, + double streamTime, RtAudioStreamStatus status, void *data) +{ + int i; + UINT8 serchar; + float antennactrl; + float adjgain; + adjgain = powf(10.0f, (gainadj[attenuation_idx][ifgain_idx]) / 20.0f); + // The number of input and output channels is equal + + // memcpy(outputBuffer, inputBuffer, *bytes); + // Generate output buffer channel LEFT (antenna switch) + + if (antenna_idx == 0) + antennactrl = 1.0; + else + antennactrl = - 1.0; + + for (i = 0; i < buffer_len; i++) + { + (((float *)outputBuffer)[i*2]) = antennactrl; // left channel + if (++idxbit > BITLEN) + { + idxbit = 0; + if (uartbitcnt <= 0) // no char waiting + { + if (uartfifo.sampleOut(&serchar)) + { + uartsignal = (serchar << 1) | 0x0FE00; // data uchar da inviare + uartbitcnt = 12; + } + } + else + { + uartsignal = (uartsignal >> 1) | 0xFF00; + uartbitcnt--; + } + } + // processing char + if ((uartsignal & 1) == 0) + (((float *)outputBuffer)[ i * 2 + 1 ]) = SERIAL0; // right channel UART 0 output + else + (((float *)outputBuffer)[ i * 2 + 1 ]) = SERIAL1; // right channel UART 1 output + } + + if (uartsignal == 0xffff) // if uart is in use audio in is blanked + { + for (i = 0; i < buffer_len; i++) + { + float_buf[2 * i] = onesampledelay; + onesampledelay = adjgain * (((float *)inputBuffer)[i * 2]); + float_buf[2 * i + 1] = adjgain * -(((float *)inputBuffer)[i * 2 + 1]); + } + } + else + for (i = 0; i < buffer_len*2; i++) + float_buf[i] = 0.0; + + + DCfilterIQ( float_buf, buffer_len); // remove DC + + WinradCallBack(buffer_len*2, 0, 0, (void*)float_buf); // to Winrad + + return 0; +} + +// Dialog message processing +static INT_PTR CALLBACK MainDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + switch (uMsg) + { + case WM_INITDIALOG: + { + HICON hIcon = LoadIcon((HINSTANCE)GetWindowLong(hwndDlg, GWL_HINSTANCE),TEXT("i_config")); + if (hIcon) + { + SendMessage(hwndDlg, WM_SETICON, ICON_SMALL, (LPARAM)hIcon); + } + antenna_idx = H101settings.get_int(TEXT("Antenna"), TEXT("index"),0); + ComboBox_AddString(GetDlgItem(hwndDlg, IDC_ANTENNA), antenna[0]); + ComboBox_AddString(GetDlgItem(hwndDlg, IDC_ANTENNA), antenna[1]); + ComboBox_SetCurSel(GetDlgItem(hwndDlg, IDC_ANTENNA), antenna_idx); + + for (int i = 0; i<(sizeof(attenuation) / sizeof(attenuation[0])); i++) + { + ComboBox_AddString(GetDlgItem(hwndDlg, IDC_ATTENUATOR), attenuation[i].name); + } + attenuation_idx = H101settings.get_int(TEXT("attenuation"), TEXT("index = "), 0); + ComboBox_SetCurSel(GetDlgItem(hwndDlg, IDC_ATTENUATOR), attenuation_idx); + + for (int i = 0; i<(sizeof(ifgain) / sizeof(ifgain[0])); i++) + { + ComboBox_AddString(GetDlgItem(hwndDlg, IDC_IFGAIN), ifgain[i].name); + } + ifgain_idx = H101settings.get_int(TEXT("IF gain"), TEXT("index"), 2); + ComboBox_SetCurSel(GetDlgItem(hwndDlg, IDC_IFGAIN), ifgain_idx); + + for (unsigned int i = 0; i < soundPorts.size(); i++) + { + if (soundPorts[i].usb) + { + if (soundPorts[i].input > 0) + ComboBox_AddString(GetDlgItem(hwndDlg, IDC_AUDIOIN), soundPorts[i].name); + if (soundPorts[i].output > 0) + ComboBox_AddString(GetDlgItem(hwndDlg, IDC_AUDIOOUT), soundPorts[i].name); + } + } + ComboBox_SetCurSel(GetDlgItem(hwndDlg, IDC_AUDIOIN), 0); + ComboBox_SetCurSel(GetDlgItem(hwndDlg, IDC_AUDIOOUT), 0); + + for (int i=0; i<(sizeof(samplerates)/sizeof(samplerates[0]));i++) + { + ComboBox_AddString(GetDlgItem(hwndDlg,IDC_SAMPLERATE),samplerates[i].name); + } + ComboBox_SetCurSel(GetDlgItem(hwndDlg,IDC_SAMPLERATE),samplerate_default); + + SendMessage(GetDlgItem(hwndDlg, IDC_PPM_S), UDM_SETRANGE, (WPARAM)TRUE, (LPARAM)MAX_PPM | (MIN_PPM << 16)); + + { + int corr; + setEditTextProgramatically = true; + corr = H101settings.get_int(TEXT("Freq correction"), TEXT("ppm"), 0); + TCHAR ppm[255]; + _stprintf(ppm, TEXT("%d"), corr); + Edit_SetText(GetDlgItem(hwndDlg, IDC_PPM), ppm); + setEditTextProgramatically = false; + freq_correction = 1.0 + double(corr) / double(1000000.0); + DbgPrintf("freq correction %e\n", freq_correction); + WinradCallBack(-1, WINRAD_LOCHANGE, 0, NULL); // signal the real LO is different + } + SendMessage(GetDlgItem(hwndDlg, IDC_ADC_S), UDM_SETRANGE, (WPARAM)TRUE, (LPARAM)MAX_ADC | (MIN_ADC << 16)); + { + adcx_default = H101settings.get_int(TEXT("ADC in volume correction"), TEXT("volx100"), 50); + if (adcx_default > MAX_ADC) adcx_default = MAX_ADC; + if (adcx_default < MIN_ADC) adcx_default = MIN_ADC; + TCHAR adcx[255]; + _stprintf(adcx, TEXT("%d"), adcx_default); + Edit_SetText(GetDlgItem(hwndDlg, IDC_ADC), adcx); + } + WriteIOH101(); //update + return TRUE; + } + case WM_COMMAND: + switch (GET_WM_COMMAND_ID(wParam, lParam)) + { + case IDC_ANTENNA: + if (GET_WM_COMMAND_CMD(wParam, lParam) == CBN_SELCHANGE) + antenna_idx = ComboBox_GetCurSel(GetDlgItem(hwndDlg, IDC_ANTENNA)); + H101settings.set_int(TEXT("Antenna"), TEXT("index"), antenna_idx); + return TRUE; + + case IDC_SAMPLERATE: + if(GET_WM_COMMAND_CMD(wParam, lParam) == CBN_SELCHANGE) + { + // WinradCallBack(-1,WINRAD_SRCHANGE,0,NULL);// only 48KHz + } + return TRUE; + + case IDC_ATTENUATOR: + if (GET_WM_COMMAND_CMD(wParam, lParam) == CBN_SELCHANGE) + { + attenuation_idx = ComboBox_GetCurSel(GetDlgItem(hwndDlg, IDC_ATTENUATOR)); + WriteIOH101(); + H101settings.set_int(TEXT("attenuation"), TEXT("index"), attenuation_idx); + } + return TRUE; + case IDC_IFGAIN: + if (GET_WM_COMMAND_CMD(wParam, lParam) == CBN_SELCHANGE) + { + ifgain_idx = ComboBox_GetCurSel(GetDlgItem(hwndDlg, IDC_IFGAIN)); + WriteIOH101(); + H101settings.set_int(TEXT("IF gain"), TEXT("index"), ifgain_idx); + } + return TRUE; + + case IDC_PPM: + if (GET_WM_COMMAND_CMD(wParam, lParam) == EN_CHANGE) + { + if (!setEditTextProgramatically) + { + TCHAR ppm[255]; + Edit_GetText((HWND)lParam, ppm, 255); + int corr = _ttoi(ppm); + freq_correction = 1.0 + double(corr) / double(1000000.0); + DbgPrintf("freq correction %e\n", freq_correction); + WinradCallBack(-1, WINRAD_LOCHANGE, 0, NULL); // signal that the real LO is different + H101settings.set_int(TEXT("Freq correction"), TEXT("ppm"), corr); + } + } + return TRUE; + case IDC_ADC: + if (GET_WM_COMMAND_CMD(wParam, lParam) == EN_CHANGE) + { + if (!setEditTextProgramatically) + { + TCHAR adcx[255]; + Edit_GetText((HWND)lParam, adcx, 255); + adcx_default = _ttoi(adcx); + if (adcx_default > MAX_ADC) adcx_default = MAX_ADC; + if (adcx_default < MIN_ADC) adcx_default = MIN_ADC; + DbgPrintf("input adc correction %d /100 \n", adcx_default); + H101settings.set_int(TEXT("ADC in volume correction"), TEXT("volx100"), adcx_default); + if ((adacp != nullptr)&& (deviceAdcId >=0)) + { + SetVolume(deviceAdcId, (float)adcx_default); + } + } + } + return TRUE; + + case IDC_SOUNDD: + { + TCHAR tstri[MAXTCHAR]; + TCHAR tstro[MAXTCHAR]; + ComboBox_GetText((GetDlgItem(h_dialog, IDC_AUDIOIN)), tstri, sizeof(tstri) / sizeof(TCHAR)); + ComboBox_GetText((GetDlgItem(h_dialog, IDC_AUDIOOUT)), tstro, sizeof(tstro) / sizeof(TCHAR)); + WinradCallBack(-1, WINRAD_STOP, 0, NULL); // signal to stop + StopHW(); + if ((Soundsetup(tstri) != 0) || + (SoundPlaySetup(tstro) != 0)) + AdviceSoundIn(); + ShowWindow(h_dialog, SW_HIDE); + MessageBox(NULL, TEXT("\nPlease press Stop and then Play to restart the SDR application\n"), + TEXT("SDR restart is required"), MB_ICONINFORMATION | MB_TOPMOST); + } + return TRUE; + + } + break; + + case WM_CLOSE: + ShowWindow(h_dialog,SW_HIDE); + return TRUE; + break; + + case WM_DESTROY: + h_dialog=NULL; + return TRUE; + break; + } + return FALSE; +} + + + +// CRC16 +void CRC16_Update(UINT16 *crc16, UINT8 *c, INT16 len) +{ + INT16 l; + // Update the CRC + // the CCITT 16bit algorithm (X^16 + X^12 + X^5 + 1). + for (l = 0; l < len; l++) { + *crc16 = (UINT8)(*crc16 >> 8) | (*crc16 << 8); + *crc16 ^= c[l]; + *crc16 ^= (UINT8)(*crc16 & 0xff) >> 4; + *crc16 ^= (*crc16 << 8) << 4; + *crc16 ^= ((*crc16 & 0xff) << 4) << 1; + } +} + +void SendPacket(UINT8 *ptdata, UINT16 tdatalen) +/* +Packet trasmission to H101 +*/ +{ + UINT8 txch; + UINT16 i, crc; + // initial SYN sequence + WriteChar(SYN); + WriteChar(SYN); + WriteChar(SYN); + WriteChar(SYN); + /* packet init */ + WriteChar(DLE); + WriteChar(STX); + // + crc = 0; + for (i = 0; i < tdatalen; i++) + { + txch = ptdata[i]; + WriteChar(txch); + CRC16_Update(&crc, &txch, 1); + + /* if DLE has been transmitted test new char, + if it is DLE a SUB is transmitted, otherwise a DLE is added*/ + if (txch == DLE) + { + i++; + if (i < tdatalen) + { + if (ptdata[i] == DLE) + { + CRC16_Update(&crc, &txch, 1); // bug in boot ? + txch = SUB; + } + else + i--; + } + WriteChar(txch); + } + } + + /* packet end */ + WriteChar(DLE); + WriteChar(ETX); + /* add crc */ + txch = (crc >> 8) & 0xff; + WriteChar(txch); + txch = crc & 0xff; + WriteChar(txch); +} + + +void PrepareAndSendPacket(unsigned char ctrl_byte, unsigned char cmd_byte, UINT8 *SubDataPacket, int nBytes) +{ + UINT8 writebuf[FRAME_SIZE]; //Transparent Data Packet + int k; + writebuf[0] = ctrl_byte; //CTRL byte + writebuf[1] = cmd_byte; //CMD byte + if (nBytes) { + for (k = 0; k 144/2 72000.0 + f1 = (DWORD64)(df * dd * 10000); + ddsw = 0x1000; + ddsw = ddsw << 16; + ddsw = f1; + data[0] = ATM_DDS; + for (i = 1; i <7; i++) + { + data[i] = (UINT8)ddsw; + ddsw = ddsw >> 8; + } + PrepareAndSendPacket(CTRL_RX, AT_CMD, &data[0], 6 + 2); + WriteChar(SYN); + } +} +// Write IO +void WriteIOH101(void) +{ + UINT8 data[6]; + unsigned short iomant = 0x8 + + (attenuation_idx & 0x02) + + ((attenuation_idx & 0x01) << 2); + // iomant |= AntennaA; + + ddsMHZ = ddsfreq / 1000000; + if (ddsMHZ <0) ddsMHZ = 0; + if (ddsMHZ >32) ddsMHZ = 32; + if (ddsMHZ <1) + iomant &= 0xf7; + else + iomant |= 0x08; + + unsigned short iomfiltri = tabfiltri[ddsMHZ]; + data[0] = ATM_IO; //CMD IO + data[1] = (iomant << 4) | ifgain_idx; + data[2] = (iomfiltri >> 8) & 0xff; + data[3] = iomfiltri & 0xff; + + if ((_iodata[0] != data[1]) || // if data change send to UART + (_iodata[1] != data[2]) || + (_iodata[2] != data[3])) + { + +#ifdef _MYDEBUG + DbgPrintf("WriteIOH101\t"); + for (int k = 0; k < 4; k++) + DbgPrintf("%02x\t", data[k]); + DbgPrintf("\n"); +#endif + PrepareAndSendPacket(CTRL_RX, AT_CMD, &data[0], 6 + 2); + _iodata[0] = data[1]; // save data for reference + _iodata[1] = data[2]; + _iodata[2] = data[3]; + } +} \ No newline at end of file diff --git a/src/ExtIO_H101.h b/src/ExtIO_H101.h new file mode 100644 index 0000000..54a16b6 --- /dev/null +++ b/src/ExtIO_H101.h @@ -0,0 +1,13 @@ +// The following ifdef block is the standard way of creating macros which make exporting +// from a DLL simpler. All files within this DLL are compiled with the LIBRTL_EXPORTS +// symbol defined on the command line. This symbol should not be defined on any project +// that uses this DLL. This way any other project whose source files include this file see +// LIBRTL_API functions as being imported from a DLL, whereas this DLL sees symbols +// defined with this macro as being exported. +#ifdef LIBRTL_EXPORTS +#define LIBRTL_API __declspec(dllexport) +#else +#define LIBRTL_API __declspec(dllimport) +#endif + +extern HMODULE hInst; \ No newline at end of file diff --git a/src/ExtIO_H101.rc b/src/ExtIO_H101.rc new file mode 100644 index 0000000..d7503e1 --- /dev/null +++ b/src/ExtIO_H101.rc @@ -0,0 +1,59 @@ + +#include +#include +#include +#include "resource.h" + + + + +// +// Dialog resources +// +LANGUAGE LANG_NEUTRAL, SUBLANG_NEUTRAL +IDD_RTL_SETTINGS DIALOG 0, 0, 196, 236 +STYLE DS_3DLOOK | DS_CENTER | DS_MODALFRAME | DS_SHELLFONT | WS_CAPTION | WS_VISIBLE | WS_POPUP | WS_SYSMENU +EXSTYLE WS_EX_TOPMOST +CAPTION "CIAOradio H101 Config" +FONT 8, "Ms Shell Dlg" +{ + GROUPBOX "Receiver", IDC_STATIC, 5, 5, 185, 130 + LTEXT "ANTENNA", IDC_STATIC, 35, 22, 60, 8 + COMBOBOX IDC_ANTENNA, 100, 20, 50, 60, CBS_DROPDOWNLIST | WS_VSCROLL | CBS_HASSTRINGS + LTEXT "#", IDC_STATIC, 155, 22, 30, 8 + + LTEXT "ATTENUATOR", IDC_STATIC, 35, 42, 55, 8 + COMBOBOX IDC_ATTENUATOR, 100, 40, 50, 60, CBS_DROPDOWNLIST | ES_RIGHT | WS_VSCROLL | CBS_HASSTRINGS + LTEXT "dB", IDC_STATIC, 155, 42, 30, 8 + + LTEXT "IF GAIN", IDC_STATIC, 35, 62, 60, 8 + COMBOBOX IDC_IFGAIN, 100, 60, 50, 60, CBS_DROPDOWNLIST | WS_VSCROLL | CBS_HASSTRINGS + LTEXT "dB", IDC_STATIC, 155, 62, 30, 8 + + + GROUPBOX "Sound device USB-H101", IDC_STATIC, 5, 135, 185, 84 + PUSHBUTTON "Setting", IDC_SOUNDD, 100, 145, 50, 12, NOT WS_TABSTOP | BS_FLAT + + + COMBOBOX IDC_AUDIOIN, 10, 165, 175, 61, CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_VSCROLL | WS_TABSTOP + LTEXT "Input volume ( ADC level ):", IDC_STATIC, 10, 182, 95, 8, SS_LEFT + CTEXT "%", IDC_STATIC, 155, 182, 20, 11, SS_CENTER + EDITTEXT IDC_ADC, 100, 180, 50, 14, ES_RIGHT | ES_AUTOHSCROLL | ES_NUMBER + CONTROL "", IDC_ADC_S, UPDOWN_CLASS, UDS_ALIGNRIGHT | UDS_ARROWKEYS | UDS_AUTOBUDDY | UDS_SETBUDDYINT, 140, 180, 11, 14 + + COMBOBOX IDC_AUDIOOUT, 10, 200, 175, 61, CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_VSCROLL | WS_TABSTOP + + + LTEXT "Sample Rate:", IDC_STATIC, 35, 82, 44, 8, SS_LEFT + COMBOBOX IDC_SAMPLERATE, 100, 80, 50, 60, CBS_DROPDOWNLIST | WS_VSCROLL | CBS_HASSTRINGS + + EDITTEXT IDC_PPM, 100, 100, 50, 14, ES_RIGHT | ES_AUTOHSCROLL | ES_NUMBER + CONTROL "", IDC_PPM_S, UPDOWN_CLASS, UDS_ALIGNRIGHT | UDS_ARROWKEYS | UDS_AUTOBUDDY | UDS_SETBUDDYINT, 140, 100, 11, 14 + LTEXT "Freq. Correction:", IDC_STATIC, 35, 102, 60, 8, SS_LEFT + + CTEXT "ppm", IDC_STATIC,155, 102, 20, 11, SS_CENTER + + LTEXT VERSION, IDC_STATIC, 110, 223, 180, 8, SS_LEFT +} + +I_CONFIG ICON DISCARDABLE "CIAOradio.ico" \ No newline at end of file diff --git a/src/SoundUti.cpp b/src/SoundUti.cpp new file mode 100644 index 0000000..2cdffb2 --- /dev/null +++ b/src/SoundUti.cpp @@ -0,0 +1,589 @@ + +#include +#include "SoundUti.h" + +/* + Pick the Device with idx in the device list eRender, eCapture +*/ +bool PickDevice(int idx, IMMDevice **DeviceToUse) +{ + HRESULT hr; + bool retValue = true; + IMMDeviceEnumerator *deviceEnumerator = NULL; + IMMDeviceCollection *erenderCollection = NULL; + IMMDeviceCollection *ecaptureCollection = NULL; + + hr = CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&deviceEnumerator)); + if (FAILED(hr)) + { + DbgPrintf("Unable to instantiate device enumerator: %x\n", hr); + retValue = false; + goto Exit; + } + + IMMDevice *device = NULL; + + // + // First off, if none of the console switches was specified, use the console device. + // + + // + // The user didn't specify an output device, prompt the user for a device and use that. + // + hr = deviceEnumerator->EnumAudioEndpoints(eRender, DEVICE_STATE_ACTIVE, &erenderCollection); + if (FAILED(hr)) + { + DbgPrintf("Unable to retrieve device collection: %x\n", hr); + retValue = false; + goto Exit; + } + + hr = deviceEnumerator->EnumAudioEndpoints(eCapture, DEVICE_STATE_ACTIVE, &ecaptureCollection); + if (FAILED(hr)) + { + DbgPrintf("Unable to retrieve device collection: %x\n", hr); + retValue = false; + goto Exit; + } + UINT erenderdeviceCount; + UINT ecapturedeviceCount; + + long deviceIndex; + deviceIndex = idx; + + hr = erenderCollection->GetCount(&erenderdeviceCount); + printf("Count erender : %d\n", erenderdeviceCount); + if (FAILED(hr)) + { + DbgPrintf("Unable to get device collection length: %x\n", hr); + retValue = false; + goto Exit; + } + + hr = ecaptureCollection->GetCount(&ecapturedeviceCount); + printf("Count capture : %d\n", ecapturedeviceCount); + if (FAILED(hr)) + { + DbgPrintf("Unable to get device collection length: %x\n", hr); + retValue = false; + goto Exit; + } + + // LPWSTR deviceName = TEXT("test "); + if (deviceIndex < (long)erenderdeviceCount) + { + hr = erenderCollection->Item(deviceIndex, &device); + if (FAILED(hr)) + { + DbgPrintf("Unable to retrieve device %d: %x\n", deviceIndex, hr); + retValue = false; + goto Exit; + } + } + else + { + hr = ecaptureCollection->Item(deviceIndex - erenderdeviceCount, &device); + if (FAILED(hr)) + { + DbgPrintf("Unable to retrieve device %d: %x\n", deviceIndex, hr); + retValue = false; + goto Exit; + } + } + + + + + *DeviceToUse = device; + retValue = true; +Exit: + SafeRelease(&erenderCollection); + SafeRelease(&ecaptureCollection); + SafeRelease(&deviceEnumerator); + + return retValue; +} + + +int SetVolume(UINT idx, float valuex100) +{ + int result = 0; + IMMDevice *device = NULL; + HRESULT hr; + hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED); + if (FAILED(hr)) + { + DbgPrintf("Unable to initialize COM: %x\n", hr); + result = hr; + goto Exit; + } + if (!PickDevice(idx, &device)) + { + result = -1; + goto Exit; + } + IAudioEndpointVolume *endpointVolume; + hr = device->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_INPROC_SERVER, NULL, reinterpret_cast(&endpointVolume)); + if (FAILED(hr)) + { + DbgPrintf("Unable to activate endpoint volume on output device: %x\n", hr); + result = -1; + goto Exit; + } + BOOL currentMute = FALSE; + hr = endpointVolume->SetMute(currentMute, NULL); + if (FAILED(hr)) + { + DbgPrintf("Unable to set mute state: %x\n", hr); + result = -1; + goto Exit; + } + hr = endpointVolume->SetMasterVolumeLevelScalar(valuex100 / 100.0f, NULL); + if (FAILED(hr)) + { + DbgPrintf("Unable to decrease volume: %x\n", hr); + result = -1; + goto Exit; + } + UINT currentStep, stepCount; + hr = endpointVolume->GetVolumeStepInfo(¤tStep, &stepCount); + if (FAILED(hr)) + { + DbgPrintf("Unable to get current volume step: %x\n", hr); + result = -1; + goto Exit; + } + float currentVolume; + hr = endpointVolume->GetMasterVolumeLevelScalar(¤tVolume); + if (FAILED(hr)) + { + DbgPrintf("Unable to get current volume step: %x\n", hr); + result = -1; + goto Exit; + } + hr = endpointVolume->GetMute(¤tMute); + if (FAILED(hr)) + { + DbgPrintf("Unable to retrieve current mute state: %x\n", hr); + result = -1; + goto Exit; + } + DbgPrintf("Current master volume: %f. Step %d of step range 0-%d.\nEndpoint Mute: %S\n", currentVolume, currentStep, stepCount, currentMute ? L"Muted" : L"Unmuted"); +Exit: + SafeRelease(&device); + CoUninitialize(); + return result; +} + +static HWND hwndTarget = NULL; +static TCHAR classSearch[MAXTCHAR]; +static TCHAR textSearchEng[MAXTCHAR]; +static TCHAR textSearchIta[MAXTCHAR]; + + +BOOL CALLBACK DoClassSearchIter(HWND hwnd, LPARAM lParam) +{ + TCHAR Name[MAXTCHAR]; + TCHAR text[MAXTCHAR]; + GetClassName(hwnd, Name, MAXTCHAR); + if (_tcscmp(Name, classSearch) == 0) + { + if (lParam == 0) + { + // class found + hwndTarget = hwnd; + return FALSE; + } + + if (_tcscmp(Name, TEXT("ComboBox")) == 0) + { + SendMessage(hwnd, CB_GETLBTEXT, 0, (LPARAM)text); + if ((_tcsstr(text, textSearchIta) != NULL) || + (_tcsstr(text, textSearchEng) != NULL)) + hwndTarget = hwnd; + return FALSE; + } + + TCHAR text[256]; + GetWindowText(hwnd, text, MAXTCHAR); + _tprintf(TEXT("%s\n"), text); + if ((_tcsstr(text, textSearchIta) != NULL) || + (_tcsstr(text, textSearchEng) != NULL)) + { + hwndTarget = hwnd; + return FALSE; + } + + + } + return TRUE; +} + + +HWND DoContrlSearchTree(HWND hwndRoot, int mode) +{ + hwndTarget = NULL; + // now do it to all the descendants (children, grandchildren, etc.) + EnumChildWindows(hwndRoot, DoClassSearchIter, (LPARAM)mode); + return hwndTarget; +} +HWND DoContrlSearchTree(HWND hwndRoot, TCHAR * classname) +{ + _tcscpy_s(classSearch, classname); + return DoContrlSearchTree(hwndRoot, 0); +} + +HWND DoControlTextSearchTree(HWND hwndRoot, TCHAR * classname, TCHAR * textnameENG, TCHAR * textnameITA) +{ + _tcscpy_s(classSearch, classname); + _tcscpy_s(textSearchEng, textnameENG); + _tcscpy_s(textSearchIta, textnameITA); + return DoContrlSearchTree(hwndRoot, 1); +} + +// close audio config windows with Eng and Ita caption +void CloseSoundConfig() +{ + HWND hw; + hw = FindWindow(NULL, TEXT("Proprietà - Microphone")); + if (hw != NULL) CloseWindow(hw); + hw = FindWindow(NULL, TEXT("Microphone properties")); + if (hw != NULL) CloseWindow(hw); + hw = FindWindow(NULL, TEXT("Proprietà - Speakers")); + if (hw != NULL) CloseWindow(hw); + hw = FindWindow(NULL, TEXT("Speakers properties")); + if (hw != NULL) CloseWindow(hw); + hw = FindWindow(NULL, TEXT("Audio")); + if (hw != NULL) CloseWindow(hw); + hw = FindWindow(NULL, TEXT("Sound")); + if (hw != NULL) CloseWindow(hw); +} + + + +int Soundsetup(TCHAR * name) +{ + + HWND haudio = NULL; + HWND hlistview = NULL; + HWND hpropButton = NULL; + HWND hRecDevice = NULL; + HWND hTabCtrl = NULL; + HWND hTabCombo = NULL; + + CloseSoundConfig(); + // Run mmsys.cpl + int nRet = (int)ShellExecute(0, TEXT("open"), TEXT("rundll32.exe"), TEXT("shell32.dll,Control_RunDLL mmsys.cpl,,1"), 0, SW_SHOWNORMAL); + if (nRet <= 32) { + DWORD dw = GetLastError(); + TCHAR szMsg[MAXTCHAR]; + FormatMessage( + FORMAT_MESSAGE_FROM_SYSTEM, + 0, dw, 0, + szMsg, sizeof(szMsg), + NULL + ); + MessageBox(NULL, szMsg, TEXT("Error launching mmsys.cpl"), MB_ICONINFORMATION); + return -1; + } + // look for Sound window + int retry = 20; + while (retry > 0) + { + Sleep(100); + haudio = FindWindow(NULL, TEXT("Sound")); + if (haudio != NULL) break; + haudio = FindWindow(NULL, TEXT("Audio")); + if (haudio != NULL) break; + retry--; + } + if (haudio == NULL) return -2; // no audio program + Sleep(500); + hlistview = DoContrlSearchTree(haudio, TEXT("SysListView32")); // search for handle + if (hlistview == NULL) return -3; // no audio program + + + if ((_tcsstr(name, TEXT("Microphone")) == NULL) || + (_tcsstr(name, TEXT("USB Audio CODEC")) == NULL)) + return -8; + + int count = (int)SendMessage(hlistview, LVM_GETITEMCOUNT, 0, 0); + int i; + int mikedevice = -1; + LVITEM lvi, *_lvi; + TCHAR item[512], subitem[512]; + TCHAR *_item, *_subitem; + unsigned long pid; + HANDLE process; + + GetWindowThreadProcessId(hlistview, &pid); + process = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_QUERY_INFORMATION, FALSE, pid); + + _lvi = (LVITEM*)VirtualAllocEx(process, NULL, sizeof(LVITEM), MEM_COMMIT, PAGE_READWRITE); + _item = (TCHAR*)VirtualAllocEx(process, NULL, 512, MEM_COMMIT, PAGE_READWRITE); + _subitem = (TCHAR*)VirtualAllocEx(process, NULL, 512, MEM_COMMIT, PAGE_READWRITE); + lvi.cchTextMax = 512; + + for (i = 0; i= 0) + { + lvi.state = LVIS_SELECTED | LVIS_FOCUSED; + lvi.stateMask = LVIS_SELECTED | LVIS_FOCUSED; + WriteProcessMemory(process, _lvi, &lvi, sizeof(LVITEM), NULL); + SendMessage(hlistview, LVM_SETITEMSTATE, (WPARAM)mikedevice, (LPARAM)_lvi); + } + + VirtualFreeEx(process, _lvi, 0, MEM_RELEASE); + VirtualFreeEx(process, _item, 0, MEM_RELEASE); + VirtualFreeEx(process, _subitem, 0, MEM_RELEASE); + + if (mikedevice < 0) return -4; // input device not found + + hpropButton = DoControlTextSearchTree(haudio, TEXT("Button"), TEXT("Properties"), TEXT("Proprietà")); + + + if (hpropButton) + PostMessage(hpropButton, BM_CLICK, (WPARAM)0, (LPARAM)0); // activate the properties window + else + return -5; + Sleep(500); + retry = 20; + while (retry > 0) + { + Sleep(300); + hRecDevice = FindWindow(NULL, TEXT("Proprietà - Microphone")); + if (hRecDevice != NULL) break; + hRecDevice = FindWindow(NULL, TEXT("Microphone properties")); + if (hRecDevice != NULL) break; + retry--; + } + + hTabCtrl = DoContrlSearchTree(hRecDevice, TEXT("SysTabControl32")); // search for handle + + unsigned long pid2; + HANDLE process2; + if (hTabCtrl) + { + GetWindowThreadProcessId(hTabCtrl, &pid2); + process2 = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_QUERY_INFORMATION, FALSE, pid2); + + int ntab = TabCtrl_GetItemCount(hTabCtrl); + _tprintf(TEXT("Tab n %d\n"), ntab); + TabCtrl_SetCurFocus(hTabCtrl, ntab - 1); + + hTabCombo = DoControlTextSearchTree(hRecDevice, TEXT("ComboBox"), TEXT("Channels"), TEXT("Canali")); + + TCHAR text[256]; + SendMessage(hTabCombo, CB_GETLBTEXT, 0, (LPARAM)text); + _tprintf(TEXT("\nCombo %x /t :%s"), hTabCombo, text); + int idx = SendMessage(hTabCombo, CB_GETCOUNT, (WPARAM)0, (LPARAM)0); + _tprintf(TEXT("\nCombo count = %d "), idx); + + SendMessage(hTabCombo, CB_SHOWDROPDOWN, (WPARAM)TRUE, (LPARAM)0); + int xdx = SendMessage(hTabCombo, CB_GETCURSEL, (WPARAM)0, (LPARAM)0); + // Change the combo box to the value higher value + if (xdx != (idx - 1)) + { + SendMessage(hTabCombo, CB_SETCURSEL, (WPARAM)idx - 1, (LPARAM)0); + SendMessage(GetParent(hTabCombo), WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(hTabCombo), CBN_SELENDOK), (LPARAM)(hTabCombo)); + Sleep(1000); + SendMessage(hRecDevice, WM_COMMAND, 1, NULL); + SendMessage(haudio, WM_COMMAND, 1, NULL); + } + } + else + return -6; + Sleep(500); + // close the Sound windows + PostMessage(hRecDevice, WM_CLOSE, 0, 0); + PostMessage(haudio, WM_CLOSE, 0, 0); + return 0; + + +} + + +int SoundPlaySetup(TCHAR * name) +{ + + HWND haudio = NULL; + HWND hlistview = NULL; + HWND hpropButton = NULL; + HWND hRecDevice = NULL; + HWND hTabCtrl = NULL; + HWND hTabCombo = NULL; + + CloseSoundConfig(); + // Run mmsys.cpl + int nRet = (int)ShellExecute(0, TEXT("open"), TEXT("rundll32.exe"), TEXT("shell32.dll,Control_RunDLL mmsys.cpl,,0"), 0, SW_SHOWNORMAL); + if (nRet <= 32) { + DWORD dw = GetLastError(); + TCHAR szMsg[MAXTCHAR]; + FormatMessage( + FORMAT_MESSAGE_FROM_SYSTEM, + 0, dw, 0, + szMsg, sizeof(szMsg), + NULL + ); + MessageBox(NULL, szMsg, TEXT("Error launching mmsys.cpl"), MB_ICONINFORMATION); + return -1; + } + // look for Sound window + int retry = 20; + while (retry > 0) + { + Sleep(100); + haudio = FindWindow(NULL, TEXT("Sound")); + if (haudio != NULL) break; + haudio = FindWindow(NULL, TEXT("Audio")); + if (haudio != NULL) break; + retry--; + } + if (haudio == NULL) return -2; // no audio program + Sleep(500); + hlistview = DoContrlSearchTree(haudio, TEXT("SysListView32")); // search for handle + if (hlistview == NULL) return -3; // no audio program + + + if ((_tcsstr(name, TEXT("Speakers")) == NULL) || + (_tcsstr(name, TEXT("USB Audio CODEC")) == NULL)) + return -8; + + int count = (int)SendMessage(hlistview, LVM_GETITEMCOUNT, 0, 0); + int i; + int spkrsdevice = -1; + LVITEM lvi, *_lvi; + TCHAR item[512], subitem[512]; + TCHAR *_item, *_subitem; + unsigned long pid; + HANDLE process; + + GetWindowThreadProcessId(hlistview, &pid); + process = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_QUERY_INFORMATION, FALSE, pid); + + _lvi = (LVITEM*)VirtualAllocEx(process, NULL, sizeof(LVITEM), MEM_COMMIT, PAGE_READWRITE); + _item = (TCHAR*)VirtualAllocEx(process, NULL, 512, MEM_COMMIT, PAGE_READWRITE); + _subitem = (TCHAR*)VirtualAllocEx(process, NULL, 512, MEM_COMMIT, PAGE_READWRITE); + lvi.cchTextMax = 512; + + for (i = 0; i < count; i++) + { + lvi.iSubItem = 0; + lvi.pszText = _item; + WriteProcessMemory(process, _lvi, &lvi, sizeof(LVITEM), NULL); + SendMessage(hlistview, LVM_GETITEMTEXT, (WPARAM)i, (LPARAM)_lvi); + + lvi.iSubItem = 1; + lvi.pszText = _subitem; + WriteProcessMemory(process, _lvi, &lvi, sizeof(LVITEM), NULL); + SendMessage(hlistview, LVM_GETITEMTEXT, (WPARAM)i, (LPARAM)_lvi); + ReadProcessMemory(process, _item, item, 512, NULL); + ReadProcessMemory(process, _subitem, subitem, 512, NULL); + + if ((_tcsstr(TEXT("Speakers "), item) != NULL) && + (_tcsstr(TEXT("USB Audio CODEC "), subitem) != NULL)) + { + spkrsdevice = i; + _tprintf(TEXT("%s %s\n"), item, subitem); + } + } + + // ListView_SetItemState(hlistview, 0, LVIS_FOCUSED | LVIS_SELECTED, 0x000F); // select device + if (spkrsdevice >= 0) + { + lvi.state = LVIS_SELECTED | LVIS_FOCUSED; + lvi.stateMask = LVIS_SELECTED | LVIS_FOCUSED; + WriteProcessMemory(process, _lvi, &lvi, sizeof(LVITEM), NULL); + SendMessage(hlistview, LVM_SETITEMSTATE, (WPARAM)spkrsdevice, (LPARAM)_lvi); + } + + VirtualFreeEx(process, _lvi, 0, MEM_RELEASE); + VirtualFreeEx(process, _item, 0, MEM_RELEASE); + VirtualFreeEx(process, _subitem, 0, MEM_RELEASE); + + if (spkrsdevice < 0) + return -4; // device not found + + hpropButton = DoControlTextSearchTree(haudio, TEXT("Button"), TEXT("Properties"), TEXT("Proprietà")); + + + if (hpropButton) + PostMessage(hpropButton, BM_CLICK, (WPARAM)0, (LPARAM)0); // activate the properties window + else + return -5; + Sleep(500); + retry = 20; + while (retry > 0) + { + Sleep(300); + hRecDevice = FindWindow(NULL, TEXT("Proprietà - Speakers")); + if (hRecDevice != NULL) break; + hRecDevice = FindWindow(NULL, TEXT("Speakers properties")); + if (hRecDevice != NULL) break; + retry--; + } + + hTabCtrl = DoContrlSearchTree(hRecDevice, TEXT("SysTabControl32")); // search for handle + + unsigned long pid2; + HANDLE process2; + if (hTabCtrl) + { + GetWindowThreadProcessId(hTabCtrl, &pid2); + process2 = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_QUERY_INFORMATION, FALSE, pid2); + + int ntab = TabCtrl_GetItemCount(hTabCtrl); + _tprintf(TEXT("Tab n %d\n"), ntab); + TabCtrl_SetCurFocus(hTabCtrl, ntab - 1); + + hTabCombo = DoControlTextSearchTree(hRecDevice, TEXT("ComboBox"), TEXT("16 bit"), TEXT("16 bit")); + if (hTabCombo == NULL) + return -9; + TCHAR text[256]; + SendMessage(hTabCombo, CB_GETLBTEXT, 0, (LPARAM)text); + _tprintf(TEXT("\nCombo %x /t :%s"), hTabCombo, text); + int idx = SendMessage(hTabCombo, CB_GETCOUNT, (WPARAM)0, (LPARAM)0); + _tprintf(TEXT("\nCombo count = %d "), idx); + + SendMessage(hTabCombo, CB_SHOWDROPDOWN, (WPARAM)TRUE, (LPARAM)0); + int xdx = SendMessage(hTabCombo, CB_GETCURSEL, (WPARAM)0, (LPARAM)0); + // Change the combo box to the value higher value + if (xdx != (idx - 1)) + { + SendMessage(hTabCombo, CB_SETCURSEL, (WPARAM)idx - 1, (LPARAM)0); + SendMessage(GetParent(hTabCombo), WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(hTabCombo), CBN_SELENDOK), (LPARAM)(hTabCombo)); + Sleep(1000); + SendMessage(hRecDevice, WM_COMMAND, 1, NULL); + SendMessage(haudio, WM_COMMAND, 1, NULL); + } + } + else + return -6; + Sleep(500); + // close the Sound windows + PostMessage(hRecDevice, WM_CLOSE, 0, 0); + PostMessage(haudio, WM_CLOSE, 0, 0); + return 0; + + +} diff --git a/src/SoundUti.h b/src/SoundUti.h new file mode 100644 index 0000000..28361cf --- /dev/null +++ b/src/SoundUti.h @@ -0,0 +1,19 @@ +#if !defined SOUNDUTI_H +#define SOUNDUTI_H +#include +#include "ExtIO_H101.h" +#include "settings.h" +#include "EndpointVolume.h" +#include +#include + +#define MAXTCHAR (200) + + +int SetVolume(UINT idx, float valuex100); + +int Soundsetup(TCHAR * name); + +int SoundPlaySetup(TCHAR * name); + +#endif diff --git a/src/Udefines.h b/src/Udefines.h new file mode 100644 index 0000000..81a16cc --- /dev/null +++ b/src/Udefines.h @@ -0,0 +1,75 @@ +#if !defined UDEFINES_H +#define UDEFINES_H +// +// Oscar Steila fecit MM, MMXV +// +#include "udefines.h" + + +#define BITLEN (48000/4800) // n sample in a bit period + +#define FRAME_SIZE 140 + +#define MAXRX 256 + +#define LF 0x0A +#define CR 0x0D +#define SYN 0x16 +#define DLE 0x10 +#define STX 0x02 +#define ETX 0x03 +#define SUB 0x1A + +#define SYNDLESTX 0x161002 + +#define AT_INFO 0x41 +#define AT_ERASE_ALL 0x42 +#define AT_WRITEFLASH 0x43 +#define AT_WRITEEEPROM 0x44 +#define AT_EXCHANGE 0x45 +#define AT_CMD 0x46 +#define AT_CONTROLINIT 0x47 +#define ATRV_PASSW_ERR 15 + + +// valori per CTRL +#define SADR_MASK 0x03 +#define DADR_MASK 0x0c +#define TYPE_MASK 0x30 +#define NEXT_FRAME 0x40 // non gestito in questo protocollo +#define ERROR_FLAG 0x80 + +#define SADR_MCPU 0x0 +#define SADR_ACPU 0x3 +#define DADR_MCPU 0x0 +#define DADR_ACPU 0xC + +#define TYPE_RSP 0x00 +#define TYPE_IND 0x10 +#define TYPE_CMD 0x20 +#define TYPE_CNF 0x30 + +#define CTRL_RX TYPE_CMD + DADR_ACPU + SADR_MCPU //00 + + +typedef enum{ + ATM_NUL = 0, + ATM_DDS, + ATM_IO, + ATM_RST, + ATM_L1, + ATM_L2 +} RISCMD; + +static unsigned short tabfiltri[] = { //0- 33 MHz +0x1ff,0x1fe,0x17b, 0xa1, 0x6e, +0x46, 0x36, 0x29, 0x1f, 0x17, +0x13, 0x0f, 0x0c, 0x0b, 0x09, +0x08, 0x7, 0x6, 0x5, 0x4, +0x4, 0x3, 0x3, 0x2, 0x2, +0x1, 0x1, 0x1, 0x0, 0x0, +0x0, 0x0, 0x0, 0x0 +}; + + +#endif diff --git a/src/exports.def b/src/exports.def new file mode 100644 index 0000000..4d5d33a --- /dev/null +++ b/src/exports.def @@ -0,0 +1,32 @@ +LIBRARY ExtIO_H101 +EXPORTS +CloseHW +GetHWLO +GetHWSR +GetStatus +InitHW +OpenHW +SetCallback +SetHWLO +ShowGUI +HideGUI +SwitchGUI +StartHW +StopHW + +; Samplerate / Bandwidth: +; ExtIoGetSrates +; ExtIoGetActualSrateIdx +; ExtIoSetSrate + +; Settings +; ExtIoGetSetting +; ExtIoSetSetting + +; GetAttenuators +; GetActualAttIdx +; SetAttenuator + +; ExtIoGetAGCs +; ExtIoGetActualAGCidx +; ExtIoSetAGC \ No newline at end of file diff --git a/src/fifo.h b/src/fifo.h new file mode 100644 index 0000000..7a17297 --- /dev/null +++ b/src/fifo.h @@ -0,0 +1,79 @@ +#if !defined FIFOUCHAR_H +#define FIFOUCHAR_H +#include +#include "windows.h" + +class Mutex +{ + friend class Lock; +public: + Mutex () { InitializeCriticalSection (&_critSection); } + ~Mutex () { DeleteCriticalSection (&_critSection); } +private: + void Acquire () + { + EnterCriticalSection (&_critSection); + } + void Release () + { + LeaveCriticalSection (&_critSection); + } + + CRITICAL_SECTION _critSection; +}; + +class Lock +{ +public: + // Acquire the state of the semaphore + Lock ( Mutex& mutex ) + : _mutex(mutex) + { + _mutex.Acquire(); + } + // Release the state of the semaphore + ~Lock () + { + _mutex.Release(); + } +private: + Mutex& _mutex; +}; + + +class FifoUchar +{ +public: + FifoUchar(){;} + virtual ~FifoUchar(){}; + void sampleIn(unsigned char pin) + { + Lock lock (_mutex);; + _queue.push(pin); + } + bool sampleOut(unsigned char* pout) + { + Lock lock (_mutex); + if (_queue.size() < 1) + return false; + *pout =_queue.front(); + _queue.pop(); + return true; + } + int size() + { + return _queue.size(); + } + void clear(void) + { + while (!_queue.empty()) _queue.pop(); + } + + +private: + std::queue _queue; + Mutex _mutex; +}; + + +#endif FIFOUCHAR diff --git a/src/freqtabH101.cpp b/src/freqtabH101.cpp new file mode 100644 index 0000000..550510a --- /dev/null +++ b/src/freqtabH101.cpp @@ -0,0 +1,9987 @@ + + +#include "windows.h" +#include "freqtabH101.h" + +// list of dds frequency with low spurs + +static const int freqtab[] = +{ + 24000, + 25000, + 27000, + 28000, + 29000, + 30000, + 31000, + 32000, + 33000, + 34000, + 35000, + 36000, + 37000, + 38000, + 39000, + 40000, + 41000, + 42000, + 43000, + 44000, + 45000, + 46000, + 47000, + 48000, + 49000, + 54000, + 55000, + 58000, + 59000, + 60000, + 61000, + 62000, + 63000, + 64000, + 65000, + 66000, + 67000, + 68000, + 70000, + 71000, + 72000, + 73000, + 74000, + 75000, + 76000, + 77000, + 78000, + 79000, + 80000, + 81000, + 82000, + 84000, + 85000, + 86000, + 87000, + 88000, + 90000, + 91000, + 93000, + 95000, + 96000, + 97000, + 105000, + 107000, + 108000, + 109000, + 110000, + 111000, + 112000, + 115000, + 120000, + 124000, + 125000, + 128000, + 129000, + 130000, + 131000, + 133000, + 134000, + 135000, + 136000, + 140000, + 141000, + 144000, + 147000, + 149000, + 150000, + 151000, + 157000, + 160000, + 161000, + 165000, + 166000, + 167000, + 168000, + 172000, + 173000, + 174000, + 175000, + 176000, + 177000, + 179000, + 180000, + 181000, + 182000, + 184000, + 185000, + 210000, + 212000, + 216000, + 218000, + 219000, + 220000, + 221000, + 222000, + 224000, + 225000, + 226000, + 227000, + 228000, + 229000, + 231000, + 232000, + 234000, + 236000, + 237000, + 240000, + 241000, + 243000, + 244000, + 245000, + 248000, + 249000, + 250000, + 252000, + 253000, + 256000, + 258000, + 260000, + 261000, + 262000, + 264000, + 265000, + 266000, + 267000, + 269000, + 270000, + 271000, + 272000, + 274000, + 275000, + 276000, + 277000, + 279000, + 280000, + 281000, + 282000, + 288000, + 289000, + 290000, + 292000, + 298000, + 299000, + 300000, + 301000, + 303000, + 304000, + 305000, + 308000, + 310000, + 312000, + 315000, + 316000, + 319000, + 320000, + 321000, + 323000, + 324000, + 325000, + 327000, + 329000, + 330000, + 332000, + 333000, + 336000, + 337000, + 344000, + 345000, + 349000, + 350000, + 352000, + 355000, + 360000, + 368000, + 370000, + 372000, + 375000, + 384000, + 390000, + 393000, + 394000, + 396000, + 400000, + 407000, + 408000, + 409000, + 411000, + 416000, + 420000, + 425000, + 430000, + 431000, + 432000, + 434000, + 436000, + 440000, + 446000, + 448000, + 450000, + 454000, + 456000, + 461000, + 462000, + 465000, + 467000, + 468000, + 470000, + 471000, + 472000, + 474000, + 475000, + 477000, + 478000, + 479000, + 480000, + 481000, + 482000, + 486000, + 487000, + 488000, + 490000, + 493000, + 494000, + 497000, + 498000, + 500000, + 504000, + 505000, + 508000, + 510000, + 511000, + 512000, + 514000, + 516000, + 517000, + 519000, + 520000, + 521000, + 522000, + 525000, + 527000, + 528000, + 529000, + 531000, + 533000, + 534000, + 537000, + 540000, + 541000, + 542000, + 544000, + 545000, + 546000, + 548000, + 550000, + 552000, + 554000, + 557000, + 559000, + 560000, + 561000, + 562000, + 563000, + 564000, + 565000, + 569000, + 570000, + 571000, + 572000, + 573000, + 574000, + 575000, + 576000, + 577000, + 578000, + 581000, + 582000, + 584000, + 588000, + 590000, + 591000, + 592000, + 593000, + 594000, + 596000, + 598000, + 599000, + 600000, + 601000, + 602000, + 604000, + 606000, + 607000, + 608000, + 609000, + 611000, + 614000, + 619000, + 621000, + 623000, + 624000, + 625000, + 629000, + 630000, + 631000, + 635000, + 636000, + 637000, + 638000, + 639000, + 640000, + 641000, + 642000, + 643000, + 644000, + 647000, + 648000, + 649000, + 650000, + 651000, + 652000, + 657000, + 660000, + 661000, + 666000, + 667000, + 668000, + 670000, + 671000, + 672000, + 674000, + 675000, + 677000, + 679000, + 680000, + 682000, + 683000, + 684000, + 685000, + 686000, + 687000, + 688000, + 690000, + 691000, + 692000, + 693000, + 695000, + 696000, + 697000, + 698000, + 700000, + 701000, + 702000, + 703000, + 704000, + 705000, + 707000, + 708000, + 709000, + 711000, + 712000, + 713000, + 714000, + 715000, + 716000, + 717000, + 718000, + 719000, + 720000, + 722000, + 723000, + 724000, + 725000, + 726000, + 727000, + 728000, + 729000, + 730000, + 732000, + 733000, + 734000, + 735000, + 736000, + 737000, + 738000, + 739000, + 740000, + 741000, + 742000, + 744000, + 745000, + 746000, + 748000, + 749000, + 750000, + 751000, + 752000, + 754000, + 755000, + 756000, + 757000, + 759000, + 760000, + 761000, + 763000, + 764000, + 767000, + 768000, + 772000, + 773000, + 774000, + 775000, + 776000, + 777000, + 778000, + 779000, + 780000, + 781000, + 782000, + 783000, + 784000, + 785000, + 786000, + 787000, + 788000, + 789000, + 790000, + 791000, + 792000, + 793000, + 794000, + 795000, + 796000, + 797000, + 798000, + 799000, + 800000, + 801000, + 802000, + 804000, + 805000, + 807000, + 808000, + 810000, + 811000, + 813000, + 814000, + 815000, + 816000, + 818000, + 819000, + 820000, + 821000, + 822000, + 823000, + 825000, + 827000, + 828000, + 829000, + 831000, + 832000, + 833000, + 835000, + 836000, + 837000, + 838000, + 839000, + 840000, + 841000, + 843000, + 844000, + 845000, + 846000, + 849000, + 850000, + 853000, + 854000, + 855000, + 856000, + 858000, + 859000, + 860000, + 862000, + 863000, + 864000, + 865000, + 866000, + 867000, + 868000, + 869000, + 870000, + 872000, + 873000, + 874000, + 875000, + 876000, + 877000, + 879000, + 880000, + 881000, + 882000, + 883000, + 884000, + 885000, + 886000, + 887000, + 888000, + 890000, + 891000, + 892000, + 894000, + 895000, + 896000, + 897000, + 898000, + 899000, + 900000, + 901000, + 902000, + 903000, + 904000, + 905000, + 906000, + 907000, + 908000, + 909000, + 910000, + 911000, + 912000, + 913000, + 914000, + 915000, + 917000, + 918000, + 919000, + 920000, + 921000, + 922000, + 924000, + 925000, + 928000, + 930000, + 931000, + 933000, + 934000, + 936000, + 937000, + 938000, + 939000, + 940000, + 942000, + 943000, + 944000, + 945000, + 946000, + 947000, + 948000, + 949000, + 950000, + 951000, + 952000, + 953000, + 954000, + 955000, + 956000, + 957000, + 958000, + 959000, + 960000, + 961000, + 962000, + 963000, + 964000, + 965000, + 966000, + 967000, + 968000, + 969000, + 970000, + 971000, + 972000, + 974000, + 975000, + 976000, + 977000, + 978000, + 979000, + 980000, + 981000, + 982000, + 984000, + 985000, + 986000, + 987000, + 988000, + 989000, + 990000, + 991000, + 992000, + 994000, + 995000, + 996000, + 997000, + 998000, + 999000, + 1000000, + + 1001000, + 1002000, + 1004000, + 1005000, + 1008000, + 1009000, + 1010000, + 1011000, + 1012000, + 1015000, + 1016000, + 1018000, + 1019000, + 1020000, + 1022000, + 1023000, + 1024000, + 1025000, + 1026000, + 1027000, + 1029000, + 1032000, + 1033000, + 1034000, + 1035000, + 1037000, + 1038000, + 1040000, + 1042000, + 1044000, + 1045000, + 1049000, + 1050000, + 1052000, + 1053000, + 1054000, + 1056000, + 1057000, + 1058000, + 1059000, + 1061000, + 1063000, + 1065000, + 1066000, + 1069000, + 1070000, + 1071000, + 1073000, + 1075000, + 1076000, + 1077000, + 1078000, + 1079000, + 1080000, + 1082000, + 1083000, + 1084000, + 1085000, + 1087000, + 1088000, + 1090000, + 1092000, + 1093000, + 1094000, + 1095000, + 1096000, + 1097000, + 1099000, + 1100000, + 1103000, + 1104000, + 1105000, + 1107000, + 1108000, + 1109000, + 1110000, + 1111000, + 1113000, + 1114000, + 1115000, + 1117000, + 1118000, + 1119000, + 1120000, + 1121000, + 1122000, + 1123000, + 1124000, + 1125000, + 1126000, + 1127000, + 1128000, + 1129000, + 1130000, + 1131000, + 1133000, + 1135000, + 1137000, + 1138000, + 1140000, + 1141000, + 1142000, + 1144000, + 1145000, + 1146000, + 1147000, + 1148000, + 1149000, + 1150000, + 1151000, + 1152000, + 1153000, + 1154000, + 1155000, + 1156000, + 1157000, + 1158000, + 1159000, + 1160000, + 1161000, + 1163000, + 1164000, + 1167000, + 1168000, + 1169000, + 1170000, + 1171000, + 1172000, + 1173000, + 1174000, + 1175000, + 1176000, + 1177000, + 1178000, + 1180000, + 1181000, + 1182000, + 1183000, + 1184000, + 1185000, + 1186000, + 1187000, + 1188000, + 1189000, + 1191000, + 1192000, + 1193000, + 1196000, + 1199000, + 1200000, + 1201000, + 1204000, + 1208000, + 1209000, + 1212000, + 1213000, + 1216000, + 1218000, + 1219000, + 1220000, + 1221000, + 1222000, + 1224000, + 1225000, + 1226000, + 1227000, + 1228000, + 1229000, + 1230000, + 1232000, + 1233000, + 1234000, + 1239000, + 1240000, + 1241000, + 1243000, + 1244000, + 1246000, + 1248000, + 1250000, + 1251000, + 1254000, + 1256000, + 1257000, + 1258000, + 1260000, + 1261000, + 1262000, + 1264000, + 1266000, + 1267000, + 1268000, + 1269000, + 1270000, + 1271000, + 1272000, + 1273000, + 1274000, + 1275000, + 1276000, + 1278000, + 1279000, + 1280000, + 1281000, + 1282000, + 1283000, + 1285000, + 1286000, + 1287000, + 1290000, + 1291000, + 1292000, + 1293000, + 1294000, + 1295000, + 1296000, + 1298000, + 1299000, + + 1300000, + 1301000, + 1303000, + 1304000, + 1305000, + 1307000, + 1308000, + 1310000, + 1312000, + 1313000, + 1317000, + 1318000, + 1319000, + 1320000, + 1323000, + 1325000, + 1327000, + 1329000, + 1330000, + 1331000, + 1332000, + 1333000, + 1335000, + 1336000, + 1337000, + 1340000, + 1341000, + 1342000, + 1343000, + 1344000, + 1347000, + 1348000, + 1349000, + 1350000, + 1351000, + 1353000, + 1357000, + 1358000, + 1359000, + 1360000, + 1361000, + 1362000, + 1363000, + 1364000, + 1366000, + 1367000, + 1368000, + 1370000, + 1373000, + 1374000, + 1375000, + 1376000, + 1379000, + 1380000, + 1381000, + 1382000, + 1383000, + 1384000, + 1385000, + 1387000, + 1390000, + 1392000, + 1394000, + 1395000, + 1396000, + 1397000, + 1399000, + 1400000, + 1401000, + 1402000, + 1403000, + 1405000, + 1406000, + 1407000, + 1408000, + 1409000, + 1410000, + 1411000, + 1413000, + 1414000, + 1416000, + 1417000, + 1419000, + 1422000, + 1423000, + 1424000, + 1427000, + 1428000, + 1429000, + 1432000, + 1436000, + 1438000, + 1440000, + 1441000, + 1443000, + 1444000, + 1445000, + 1446000, + 1447000, + 1448000, + 1449000, + 1450000, + 1451000, + 1452000, + 1453000, + 1456000, + 1457000, + 1458000, + 1461000, + 1463000, + 1464000, + 1466000, + 1467000, + 1468000, + 1469000, + 1470000, + 1472000, + 1473000, + 1474000, + 1475000, + 1476000, + 1478000, + 1479000, + 1480000, + 1481000, + 1483000, + 1484000, + 1485000, + 1486000, + 1487000, + 1488000, + 1489000, + 1490000, + 1491000, + 1492000, + 1493000, + 1494000, + 1495000, + 1496000, + 1497000, + 1498000, + 1499000, + 1500000, + 1501000, + 1502000, + 1503000, + 1504000, + 1505000, + 1506000, + 1507000, + 1508000, + 1509000, + 1510000, + 1511000, + 1512000, + 1513000, + 1514000, + 1515000, + 1517000, + 1518000, + 1520000, + 1521000, + 1523000, + 1525000, + 1526000, + 1527000, + 1528000, + 1529000, + 1530000, + 1531000, + 1533000, + 1534000, + 1535000, + 1536000, + 1538000, + 1539000, + 1541000, + 1542000, + 1543000, + 1544000, + 1545000, + 1546000, + 1547000, + 1550000, + 1551000, + 1552000, + 1553000, + 1555000, + 1556000, + 1557000, + 1558000, + 1559000, + 1560000, + 1562000, + 1563000, + 1564000, + 1566000, + 1567000, + 1568000, + 1569000, + 1570000, + 1571000, + 1572000, + 1573000, + 1574000, + 1575000, + 1576000, + 1577000, + 1578000, + 1580000, + 1581000, + 1582000, + 1583000, + 1584000, + 1585000, + 1586000, + 1587000, + 1588000, + 1589000, + 1590000, + 1591000, + 1592000, + 1593000, + 1594000, + 1595000, + 1596000, + 1597000, + 1598000, + 1599000, + 1600000, + 1601000, + 1602000, + 1604000, + 1605000, + 1607000, + 1608000, + 1610000, + 1611000, + 1613000, + 1614000, + 1615000, + 1616000, + 1617000, + 1619000, + 1620000, + 1622000, + 1623000, + 1625000, + 1626000, + 1628000, + 1629000, + 1630000, + 1631000, + 1632000, + 1633000, + 1634000, + 1635000, + 1636000, + 1637000, + 1638000, + 1640000, + 1642000, + 1643000, + 1644000, + 1645000, + 1646000, + 1648000, + 1649000, + 1650000, + 1651000, + 1653000, + 1654000, + 1656000, + 1657000, + 1658000, + 1659000, + 1660000, + 1661000, + 1662000, + 1663000, + 1664000, + 1665000, + 1666000, + 1667000, + 1669000, + 1670000, + 1671000, + 1672000, + 1673000, + 1674000, + 1675000, + 1676000, + 1677000, + 1678000, + 1679000, + 1680000, + 1683000, + 1685000, + 1686000, + 1687000, + 1688000, + 1689000, + 1691000, + 1692000, + 1693000, + 1696000, + 1698000, + 1700000, + 1701000, + 1703000, + 1704000, + 1705000, + 1706000, + 1707000, + 1708000, + 1709000, + 1710000, + 1711000, + 1716000, + 1717000, + 1718000, + 1720000, + 1721000, + 1725000, + 1726000, + 1727000, + 1728000, + 1730000, + 1731000, + 1733000, + 1734000, + 1737000, + 1738000, + 1740000, + 1744000, + 1745000, + 1747000, + 1748000, + 1750000, + 1751000, + 1752000, + 1753000, + 1754000, + 1755000, + 1757000, + 1759000, + 1760000, + 1761000, + 1762000, + 1763000, + 1764000, + 1765000, + 1766000, + 1768000, + 1769000, + 1770000, + 1771000, + 1772000, + 1773000, + 1774000, + 1775000, + 1776000, + 1779000, + 1780000, + 1781000, + 1782000, + 1783000, + 1784000, + 1785000, + 1789000, + 1790000, + 1792000, + 1794000, + 1795000, + 1796000, + 1797000, + 1798000, + 1799000, + 1800000, + 1801000, + 1802000, + 1803000, + 1804000, + 1805000, + 1806000, + 1807000, + 1808000, + 1809000, + 1810000, + 1812000, + 1813000, + 1815000, + 1816000, + 1818000, + 1819000, + 1820000, + 1821000, + 1822000, + 1824000, + 1825000, + 1828000, + 1829000, + 1830000, + 1831000, + 1833000, + 1834000, + 1837000, + 1838000, + 1839000, + 1840000, + 1841000, + 1843000, + 1845000, + 1847000, + 1848000, + 1849000, + 1850000, + 1851000, + 1852000, + 1856000, + 1859000, + 1860000, + 1861000, + 1866000, + 1867000, + 1868000, + 1869000, + 1871000, + 1872000, + 1873000, + 1874000, + 1875000, + 1876000, + 1878000, + 1880000, + 1881000, + 1883000, + 1884000, + 1885000, + 1886000, + 1888000, + 1889000, + 1890000, + 1892000, + 1893000, + 1894000, + 1896000, + 1897000, + 1898000, + 1899000, + 1900000, + 1902000, + 1905000, + 1906000, + 1907000, + 1908000, + 1910000, + 1912000, + 1915000, + 1917000, + 1918000, + 1919000, + 1920000, + 1921000, + 1922000, + 1923000, + 1924000, + 1925000, + 1928000, + 1929000, + 1932000, + 1934000, + 1935000, + 1936000, + 1937000, + 1939000, + 1940000, + 1942000, + 1943000, + 1944000, + 1945000, + 1947000, + 1949000, + 1950000, + 1951000, + 1952000, + 1953000, + 1954000, + 1955000, + 1956000, + 1957000, + 1958000, + 1960000, + 1961000, + 1962000, + 1963000, + 1966000, + 1967000, + 1968000, + 1969000, + 1970000, + 1972000, + 1973000, + 1975000, + 1979000, + 1980000, + 1982000, + 1983000, + 1984000, + 1986000, + 1987000, + 1988000, + 1990000, + 1991000, + 1992000, + 1993000, + 1994000, + 1995000, + 1996000, + 1997000, + 1998000, + 1999000, + 2000000, + 2001000, + 2002000, + 2003000, + 2004000, + 2005000, + 2006000, + 2009000, + 2010000, + 2011000, + 2013000, + 2015000, + 2016000, + 2017000, + 2019000, + 2020000, + 2022000, + 2023000, + 2025000, + 2027000, + 2029000, + 2030000, + 2031000, + 2032000, + 2033000, + 2035000, + 2036000, + 2038000, + 2039000, + 2040000, + 2041000, + 2042000, + 2044000, + 2045000, + 2046000, + 2047000, + 2048000, + 2050000, + 2051000, + 2052000, + 2053000, + 2054000, + 2055000, + 2056000, + 2058000, + 2060000, + 2061000, + 2063000, + 2064000, + 2065000, + 2066000, + 2070000, + 2071000, + 2073000, + 2075000, + 2076000, + 2079000, + 2080000, + 2081000, + 2082000, + 2083000, + 2084000, + 2085000, + 2088000, + 2089000, + 2092000, + 2093000, + 2095000, + 2096000, + 2098000, + 2099000, + 2100000, + 2102000, + 2104000, + 2105000, + 2107000, + 2109000, + 2111000, + 2112000, + 2113000, + 2114000, + 2115000, + 2117000, + 2118000, + 2119000, + 2120000, + 2121000, + 2122000, + 2125000, + 2126000, + 2127000, + 2130000, + 2131000, + 2132000, + 2134000, + 2135000, + 2136000, + 2138000, + 2139000, + 2140000, + 2141000, + 2142000, + 2144000, + 2145000, + 2146000, + 2148000, + 2150000, + 2151000, + 2152000, + 2154000, + 2155000, + 2157000, + 2158000, + 2159000, + 2160000, + 2161000, + 2163000, + 2164000, + 2165000, + 2166000, + 2167000, + 2168000, + 2169000, + 2170000, + 2171000, + 2172000, + 2173000, + 2174000, + 2175000, + 2176000, + 2177000, + 2178000, + 2179000, + 2180000, + 2183000, + 2184000, + 2185000, + 2186000, + 2187000, + 2188000, + 2189000, + 2190000, + 2191000, + 2192000, + 2194000, + 2195000, + 2197000, + 2198000, + 2199000, + 2200000, + 2201000, + 2203000, + 2206000, + 2208000, + 2209000, + 2210000, + 2211000, + 2213000, + 2214000, + 2215000, + 2216000, + 2217000, + 2218000, + 2220000, + 2221000, + 2222000, + 2223000, + 2224000, + 2225000, + 2226000, + 2227000, + 2228000, + 2229000, + 2230000, + 2231000, + 2232000, + 2234000, + 2235000, + 2236000, + 2237000, + 2238000, + 2239000, + 2240000, + 2241000, + 2242000, + 2244000, + 2245000, + 2246000, + 2247000, + 2248000, + 2249000, + 2250000, + 2251000, + 2252000, + 2253000, + 2254000, + 2256000, + 2258000, + 2260000, + 2261000, + 2262000, + 2263000, + 2265000, + 2266000, + 2267000, + 2268000, + 2269000, + 2271000, + 2272000, + 2274000, + 2275000, + 2276000, + 2277000, + 2278000, + 2279000, + 2280000, + 2281000, + 2282000, + 2283000, + 2284000, + 2287000, + 2288000, + 2289000, + 2290000, + 2291000, + 2292000, + 2295000, + 2296000, + 2297000, + 2298000, + 2299000, + 2300000, + 2301000, + 2302000, + 2304000, + 2305000, + 2306000, + 2307000, + 2308000, + 2309000, + 2310000, + 2312000, + 2314000, + 2315000, + 2316000, + 2317000, + 2318000, + 2319000, + 2320000, + 2321000, + 2322000, + 2324000, + 2325000, + 2327000, + 2328000, + 2329000, + 2331000, + 2333000, + 2334000, + 2335000, + 2336000, + 2338000, + 2339000, + 2340000, + 2343000, + 2344000, + 2345000, + 2346000, + 2347000, + 2348000, + 2349000, + 2350000, + 2352000, + 2354000, + 2355000, + 2356000, + 2358000, + 2359000, + 2360000, + 2362000, + 2363000, + 2364000, + 2365000, + 2366000, + 2367000, + 2368000, + 2369000, + 2370000, + 2371000, + 2372000, + 2373000, + 2374000, + 2375000, + 2376000, + 2377000, + 2378000, + 2381000, + 2382000, + 2384000, + 2386000, + 2387000, + 2389000, + 2391000, + 2394000, + 2395000, + 2396000, + 2397000, + 2398000, + 2399000, + 2400000, + 2404000, + 2405000, + 2407000, + 2409000, + 2411000, + 2412000, + 2413000, + 2414000, + 2415000, + 2416000, + 2417000, + 2418000, + 2419000, + 2423000, + 2424000, + 2425000, + 2429000, + 2430000, + 2431000, + 2432000, + 2433000, + 2434000, + 2435000, + 2436000, + 2437000, + 2438000, + 2440000, + 2442000, + 2443000, + 2444000, + 2446000, + 2448000, + 2450000, + 2451000, + 2452000, + 2453000, + 2455000, + 2456000, + 2457000, + 2458000, + 2460000, + 2463000, + 2464000, + 2465000, + 2466000, + 2467000, + 2468000, + 2469000, + 2470000, + 2471000, + 2472000, + 2473000, + 2475000, + 2477000, + 2479000, + 2480000, + 2481000, + 2482000, + 2484000, + 2488000, + 2490000, + 2491000, + 2492000, + 2493000, + 2494000, + 2496000, + 2498000, + 2499000, + 2500000, + 2501000, + 2502000, + 2504000, + 2505000, + 2507000, + 2508000, + 2510000, + 2511000, + 2512000, + 2513000, + 2514000, + 2515000, + 2517000, + 2520000, + 2522000, + 2523000, + 2524000, + 2525000, + 2528000, + 2529000, + 2530000, + 2531000, + 2534000, + 2535000, + 2536000, + 2537000, + 2538000, + 2539000, + 2540000, + 2541000, + 2544000, + 2545000, + 2546000, + 2548000, + 2549000, + 2550000, + 2551000, + 2552000, + 2554000, + 2555000, + 2556000, + 2557000, + 2560000, + 2561000, + 2562000, + 2567000, + 2568000, + 2570000, + 2571000, + 2572000, + 2573000, + 2574000, + 2575000, + 2576000, + 2577000, + 2579000, + 2580000, + 2581000, + 2582000, + 2586000, + 2587000, + 2588000, + 2589000, + 2590000, + 2591000, + 2592000, + 2593000, + 2596000, + 2598000, + 2599000, + 2600000, + 2602000, + 2603000, + 2604000, + 2605000, + 2606000, + 2608000, + 2609000, + 2610000, + 2611000, + 2612000, + 2614000, + 2615000, + 2616000, + 2617000, + 2619000, + 2620000, + 2621000, + 2624000, + 2625000, + 2626000, + 2627000, + 2628000, + 2629000, + 2631000, + 2632000, + 2634000, + 2635000, + 2636000, + 2637000, + 2638000, + 2639000, + 2640000, + 2641000, + 2643000, + 2645000, + 2646000, + 2648000, + 2650000, + 2651000, + 2652000, + 2653000, + 2656000, + 2657000, + 2659000, + 2660000, + 2661000, + 2662000, + 2663000, + 2664000, + 2665000, + 2669000, + 2670000, + 2671000, + 2672000, + 2673000, + 2674000, + 2675000, + 2677000, + 2678000, + 2680000, + 2682000, + 2683000, + 2684000, + 2685000, + 2686000, + 2688000, + 2689000, + 2691000, + 2692000, + 2695000, + 2696000, + 2697000, + 2698000, + 2699000, + 2700000, + 2701000, + 2703000, + 2705000, + 2707000, + 2708000, + 2709000, + 2712000, + 2714000, + 2715000, + 2716000, + 2718000, + 2719000, + 2720000, + 2721000, + 2722000, + 2723000, + 2724000, + 2725000, + 2728000, + 2729000, + 2730000, + 2731000, + 2732000, + 2734000, + 2735000, + 2736000, + 2738000, + 2740000, + 2741000, + 2744000, + 2745000, + 2748000, + 2749000, + 2750000, + 2751000, + 2752000, + 2753000, + 2755000, + 2758000, + 2759000, + 2760000, + 2762000, + 2763000, + 2764000, + 2767000, + 2768000, + 2770000, + 2771000, + 2773000, + 2774000, + 2775000, + 2776000, + 2778000, + 2781000, + 2783000, + 2784000, + 2790000, + 2791000, + 2792000, + 2794000, + 2795000, + 2798000, + 2799000, + 2800000, + 2802000, + 2804000, + 2806000, + 2808000, + 2809000, + 2810000, + 2812000, + 2813000, + 2814000, + 2815000, + 2816000, + 2817000, + 2819000, + 2820000, + 2821000, + 2822000, + 2825000, + 2826000, + 2828000, + 2829000, + 2831000, + 2832000, + 2833000, + 2835000, + 2837000, + 2838000, + 2839000, + 2840000, + 2841000, + 2843000, + 2844000, + 2846000, + 2847000, + 2848000, + 2849000, + 2850000, + 2851000, + 2852000, + 2853000, + 2856000, + 2860000, + 2862000, + 2863000, + 2865000, + 2867000, + 2868000, + 2869000, + 2871000, + 2872000, + 2874000, + 2875000, + 2876000, + 2878000, + 2879000, + 2880000, + 2881000, + 2882000, + 2883000, + 2885000, + 2886000, + 2887000, + 2891000, + 2894000, + 2895000, + 2896000, + 2897000, + 2898000, + 2899000, + 2900000, + 2902000, + 2904000, + 2905000, + 2906000, + 2907000, + 2908000, + 2910000, + 2911000, + 2912000, + 2913000, + 2917000, + 2920000, + 2921000, + 2922000, + 2923000, + 2924000, + 2925000, + 2926000, + 2928000, + 2929000, + 2930000, + 2931000, + 2932000, + 2933000, + 2934000, + 2935000, + 2937000, + 2938000, + 2940000, + 2944000, + 2945000, + 2946000, + 2947000, + 2950000, + 2952000, + 2953000, + 2955000, + 2957000, + 2960000, + 2962000, + 2965000, + 2966000, + 2970000, + 2971000, + 2972000, + 2973000, + 2974000, + 2975000, + 2976000, + 2977000, + 2978000, + 2979000, + 2980000, + 2984000, + 2985000, + 2986000, + 2987000, + 2988000, + 2990000, + 2991000, + 2992000, + 2993000, + 2994000, + 2995000, + 2996000, + 2997000, + 2998000, + 3000000, + 3002000, + 3003000, + 3004000, + 3005000, + 3006000, + 3007000, + 3008000, + 3010000, + 3012000, + 3013000, + 3014000, + 3015000, + 3016000, + 3017000, + 3020000, + 3022000, + 3023000, + 3024000, + 3025000, + 3026000, + 3028000, + 3030000, + 3031000, + 3032000, + 3034000, + 3035000, + 3036000, + 3037000, + 3039000, + 3040000, + 3041000, + 3042000, + 3043000, + 3046000, + 3047000, + 3048000, + 3049000, + 3050000, + 3053000, + 3054000, + 3055000, + 3056000, + 3057000, + 3058000, + 3060000, + 3061000, + 3062000, + 3063000, + 3065000, + 3066000, + 3067000, + 3068000, + 3069000, + 3070000, + 3071000, + 3072000, + 3073000, + 3075000, + 3076000, + 3078000, + 3079000, + 3080000, + 3081000, + 3082000, + 3083000, + 3085000, + 3086000, + 3087000, + 3088000, + 3090000, + 3091000, + 3093000, + 3094000, + 3095000, + 3096000, + 3098000, + 3100000, + 3103000, + 3104000, + 3105000, + 3107000, + 3108000, + 3109000, + 3110000, + 3112000, + 3113000, + 3114000, + 3116000, + 3118000, + 3119000, + 3120000, + 3121000, + 3123000, + 3124000, + 3125000, + 3126000, + 3127000, + 3128000, + 3129000, + 3132000, + 3133000, + 3135000, + 3136000, + 3137000, + 3141000, + 3142000, + 3144000, + 3145000, + 3146000, + 3147000, + 3148000, + 3149000, + 3150000, + 3151000, + 3152000, + 3153000, + 3156000, + 3157000, + 3159000, + 3160000, + 3161000, + 3162000, + 3163000, + 3164000, + 3166000, + 3167000, + 3168000, + 3169000, + 3171000, + 3172000, + 3173000, + 3174000, + 3175000, + 3176000, + 3177000, + 3178000, + 3179000, + 3180000, + 3181000, + 3182000, + 3183000, + 3185000, + 3186000, + 3187000, + 3188000, + 3189000, + 3191000, + 3192000, + 3193000, + 3194000, + 3195000, + 3196000, + 3197000, + 3198000, + 3200000, + 3202000, + 3203000, + 3204000, + 3205000, + 3206000, + 3207000, + 3208000, + 3209000, + 3210000, + 3211000, + 3212000, + 3214000, + 3215000, + 3216000, + 3217000, + 3218000, + 3219000, + 3220000, + 3221000, + 3222000, + 3223000, + 3225000, + 3226000, + 3227000, + 3228000, + 3229000, + 3230000, + 3232000, + 3233000, + 3235000, + 3237000, + 3239000, + 3240000, + 3241000, + 3245000, + 3246000, + 3249000, + 3250000, + 3252000, + 3255000, + 3256000, + 3257000, + 3259000, + 3260000, + 3263000, + 3264000, + 3265000, + 3268000, + 3269000, + 3270000, + 3271000, + 3274000, + 3275000, + 3276000, + 3277000, + 3278000, + 3279000, + 3280000, + 3284000, + 3285000, + 3286000, + 3287000, + 3288000, + 3289000, + 3290000, + 3291000, + 3292000, + 3293000, + 3295000, + 3296000, + 3297000, + 3300000, + 3301000, + 3302000, + 3303000, + 3305000, + 3307000, + 3308000, + 3309000, + 3312000, + 3313000, + 3314000, + 3315000, + 3316000, + 3320000, + 3321000, + 3322000, + 3324000, + 3325000, + 3326000, + 3327000, + 3328000, + 3330000, + 3331000, + 3332000, + 3334000, + 3335000, + 3336000, + 3338000, + 3340000, + 3341000, + 3342000, + 3343000, + 3346000, + 3347000, + 3348000, + 3350000, + 3351000, + 3352000, + 3356000, + 3357000, + 3359000, + 3360000, + 3361000, + 3362000, + 3364000, + 3365000, + 3367000, + 3368000, + 3369000, + 3370000, + 3371000, + 3372000, + 3374000, + 3375000, + 3376000, + 3377000, + 3378000, + 3379000, + 3381000, + 3382000, + 3383000, + 3384000, + 3385000, + 3386000, + 3387000, + 3389000, + 3390000, + 3392000, + 3393000, + 3395000, + 3397000, + 3398000, + 3399000, + 3400000, + 3401000, + 3402000, + 3404000, + 3405000, + 3406000, + 3407000, + 3408000, + 3411000, + 3413000, + 3414000, + 3416000, + 3418000, + 3419000, + 3420000, + 3421000, + 3422000, + 3423000, + 3424000, + 3425000, + 3431000, + 3432000, + 3433000, + 3434000, + 3435000, + 3437000, + 3439000, + 3440000, + 3441000, + 3442000, + 3446000, + 3450000, + 3453000, + 3455000, + 3456000, + 3457000, + 3458000, + 3459000, + 3460000, + 3461000, + 3462000, + 3463000, + 3465000, + 3466000, + 3468000, + 3469000, + 3471000, + 3472000, + 3473000, + 3475000, + 3476000, + 3477000, + 3479000, + 3480000, + 3482000, + 3483000, + 3487000, + 3488000, + 3492000, + 3493000, + 3494000, + 3495000, + 3496000, + 3497000, + 3499000, + 3500000, + 3501000, + 3502000, + 3503000, + 3504000, + 3505000, + 3506000, + 3507000, + 3508000, + 3509000, + 3510000, + 3511000, + 3513000, + 3514000, + 3515000, + 3517000, + 3518000, + 3519000, + 3520000, + 3521000, + 3522000, + 3524000, + 3525000, + 3526000, + 3528000, + 3532000, + 3533000, + 3535000, + 3540000, + 3543000, + 3544000, + 3546000, + 3547000, + 3549000, + 3550000, + 3552000, + 3553000, + 3554000, + 3557000, + 3558000, + 3559000, + 3560000, + 3561000, + 3562000, + 3563000, + 3564000, + 3566000, + 3567000, + 3569000, + 3570000, + 3571000, + 3573000, + 3575000, + 3576000, + 3577000, + 3578000, + 3580000, + 3581000, + 3583000, + 3584000, + 3585000, + 3586000, + 3587000, + 3588000, + 3589000, + 3591000, + 3592000, + 3593000, + 3596000, + 3598000, + 3599000, + 3600000, + 3601000, + 3602000, + 3604000, + 3608000, + 3612000, + 3614000, + 3616000, + 3620000, + 3621000, + 3622000, + 3624000, + 3625000, + 3626000, + 3629000, + 3630000, + 3631000, + 3632000, + 3636000, + 3637000, + 3638000, + 3640000, + 3641000, + 3644000, + 3645000, + 3646000, + 3648000, + 3650000, + 3651000, + 3653000, + 3655000, + 3658000, + 3660000, + 3662000, + 3663000, + 3665000, + 3666000, + 3668000, + 3669000, + 3670000, + 3671000, + 3672000, + 3673000, + 3674000, + 3675000, + 3676000, + 3677000, + 3679000, + 3680000, + 3681000, + 3683000, + 3684000, + 3685000, + 3687000, + 3688000, + 3689000, + 3690000, + 3695000, + 3696000, + 3697000, + 3698000, + 3699000, + 3700000, + 3701000, + 3703000, + 3704000, + 3705000, + 3707000, + 3708000, + 3710000, + 3711000, + 3712000, + 3713000, + 3715000, + 3717000, + 3720000, + 3725000, + 3727000, + 3729000, + 3731000, + 3732000, + 3734000, + 3735000, + 3736000, + 3738000, + 3739000, + 3741000, + 3742000, + 3743000, + 3744000, + 3745000, + 3746000, + 3748000, + 3749000, + 3750000, + 3751000, + 3752000, + 3754000, + 3756000, + 3757000, + 3760000, + 3761000, + 3762000, + 3763000, + 3766000, + 3768000, + 3769000, + 3770000, + 3772000, + 3775000, + 3776000, + 3777000, + 3779000, + 3780000, + 3781000, + 3782000, + 3784000, + 3786000, + 3787000, + 3788000, + 3791000, + 3792000, + 3793000, + 3795000, + 3796000, + 3799000, + 3800000, + 3801000, + 3803000, + 3808000, + 3809000, + 3810000, + 3811000, + 3815000, + 3816000, + 3817000, + 3820000, + 3824000, + 3825000, + 3827000, + 3828000, + 3829000, + 3833000, + 3835000, + 3836000, + 3837000, + 3838000, + 3839000, + 3840000, + 3841000, + 3842000, + 3843000, + 3844000, + 3845000, + 3847000, + 3848000, + 3850000, + 3853000, + 3855000, + 3856000, + 3858000, + 3859000, + 3860000, + 3861000, + 3863000, + 3864000, + 3865000, + 3866000, + 3867000, + 3868000, + 3869000, + 3870000, + 3872000, + 3873000, + 3875000, + 3876000, + 3878000, + 3879000, + 3880000, + 3884000, + 3885000, + 3886000, + 3888000, + 3889000, + 3890000, + 3891000, + 3894000, + 3897000, + 3898000, + 3899000, + 3900000, + 3901000, + 3902000, + 3903000, + 3904000, + 3905000, + 3906000, + 3909000, + 3912000, + 3916000, + 3917000, + 3919000, + 3920000, + 3921000, + 3922000, + 3925000, + 3926000, + 3927000, + 3928000, + 3929000, + 3930000, + 3932000, + 3933000, + 3934000, + 3935000, + 3936000, + 3937000, + 3938000, + 3940000, + 3944000, + 3946000, + 3947000, + 3949000, + 3950000, + 3957000, + 3958000, + 3959000, + 3960000, + 3961000, + 3962000, + 3963000, + 3964000, + 3965000, + 3966000, + 3968000, + 3969000, + 3971000, + 3972000, + 3973000, + 3974000, + 3975000, + 3977000, + 3979000, + 3980000, + 3981000, + 3984000, + 3987000, + 3988000, + 3989000, + 3990000, + 3991000, + 3992000, + 4000000, + 4002000, + 4003000, + 4004000, + 4005000, + 4006000, + 4007000, + 4008000, + 4009000, + 4010000, + 4011000, + 4012000, + 4013000, + 4015000, + 4017000, + 4019000, + 4020000, + 4022000, + 4023000, + 4025000, + 4026000, + 4027000, + 4029000, + 4030000, + 4031000, + 4032000, + 4033000, + 4034000, + 4035000, + 4036000, + 4037000, + 4038000, + 4039000, + 4040000, + 4041000, + 4044000, + 4047000, + 4049000, + 4050000, + 4051000, + 4053000, + 4055000, + 4056000, + 4057000, + 4060000, + 4061000, + 4062000, + 4064000, + 4065000, + 4066000, + 4067000, + 4069000, + 4070000, + 4071000, + 4074000, + 4075000, + 4076000, + 4078000, + 4080000, + 4082000, + 4084000, + 4086000, + 4087000, + 4088000, + 4089000, + 4090000, + 4092000, + 4094000, + 4095000, + 4096000, + 4097000, + 4099000, + 4100000, + 4101000, + 4102000, + 4103000, + 4104000, + 4108000, + 4110000, + 4111000, + 4112000, + 4115000, + 4116000, + 4117000, + 4118000, + 4119000, + 4120000, + 4121000, + 4122000, + 4123000, + 4124000, + 4125000, + 4126000, + 4127000, + 4128000, + 4132000, + 4133000, + 4135000, + 4136000, + 4137000, + 4139000, + 4140000, + 4141000, + 4142000, + 4145000, + 4146000, + 4147000, + 4149000, + 4150000, + 4151000, + 4152000, + 4153000, + 4155000, + 4156000, + 4157000, + 4158000, + 4159000, + 4160000, + 4162000, + 4164000, + 4165000, + 4166000, + 4167000, + 4168000, + 4170000, + 4171000, + 4172000, + 4175000, + 4176000, + 4177000, + 4178000, + 4179000, + 4180000, + 4181000, + 4183000, + 4185000, + 4187000, + 4189000, + 4190000, + 4191000, + 4192000, + 4193000, + 4195000, + 4196000, + 4197000, + 4198000, + 4199000, + 4200000, + 4201000, + 4203000, + 4204000, + 4205000, + 4207000, + 4208000, + 4209000, + 4210000, + 4211000, + 4212000, + 4213000, + 4214000, + 4215000, + 4217000, + 4218000, + 4219000, + 4220000, + 4221000, + 4223000, + 4224000, + 4225000, + 4226000, + 4229000, + 4230000, + 4233000, + 4234000, + 4236000, + 4237000, + 4239000, + 4240000, + 4242000, + 4247000, + 4248000, + 4250000, + 4254000, + 4256000, + 4257000, + 4259000, + 4260000, + 4261000, + 4262000, + 4264000, + 4265000, + 4266000, + 4268000, + 4270000, + 4272000, + 4275000, + 4276000, + 4277000, + 4278000, + 4280000, + 4281000, + 4282000, + 4283000, + 4284000, + 4288000, + 4290000, + 4291000, + 4292000, + 4293000, + 4294000, + 4295000, + 4296000, + 4298000, + 4299000, + 4300000, + 4301000, + 4303000, + 4304000, + 4305000, + 4306000, + 4307000, + 4309000, + 4310000, + 4311000, + 4312000, + 4313000, + 4315000, + 4316000, + 4317000, + 4319000, + 4320000, + 4321000, + 4324000, + 4325000, + 4326000, + 4327000, + 4329000, + 4330000, + 4332000, + 4334000, + 4335000, + 4336000, + 4337000, + 4340000, + 4341000, + 4342000, + 4343000, + 4344000, + 4346000, + 4347000, + 4348000, + 4350000, + 4351000, + 4352000, + 4353000, + 4355000, + 4356000, + 4357000, + 4358000, + 4360000, + 4366000, + 4367000, + 4368000, + 4369000, + 4370000, + 4372000, + 4373000, + 4374000, + 4375000, + 4376000, + 4378000, + 4380000, + 4382000, + 4383000, + 4384000, + 4385000, + 4386000, + 4387000, + 4388000, + 4389000, + 4391000, + 4392000, + 4393000, + 4394000, + 4396000, + 4398000, + 4399000, + 4400000, + 4401000, + 4402000, + 4403000, + 4404000, + 4405000, + 4406000, + 4407000, + 4409000, + 4410000, + 4411000, + 4412000, + 4413000, + 4414000, + 4415000, + 4416000, + 4417000, + 4418000, + 4419000, + 4420000, + 4422000, + 4423000, + 4424000, + 4425000, + 4426000, + 4427000, + 4429000, + 4430000, + 4432000, + 4433000, + 4434000, + 4435000, + 4438000, + 4439000, + 4440000, + 4442000, + 4443000, + 4445000, + 4446000, + 4447000, + 4450000, + 4451000, + 4452000, + 4453000, + 4454000, + 4455000, + 4456000, + 4458000, + 4463000, + 4464000, + 4466000, + 4467000, + 4468000, + 4470000, + 4473000, + 4474000, + 4475000, + 4476000, + 4477000, + 4480000, + 4482000, + 4485000, + 4488000, + 4489000, + 4490000, + 4491000, + 4494000, + 4496000, + 4497000, + 4498000, + 4499000, + 4500000, + 4501000, + 4502000, + 4503000, + 4505000, + 4506000, + 4507000, + 4508000, + 4509000, + 4511000, + 4512000, + 4514000, + 4515000, + 4516000, + 4517000, + 4518000, + 4519000, + 4520000, + 4521000, + 4522000, + 4523000, + 4524000, + 4525000, + 4526000, + 4527000, + 4529000, + 4530000, + 4531000, + 4532000, + 4534000, + 4535000, + 4536000, + 4537000, + 4538000, + 4539000, + 4540000, + 4543000, + 4544000, + 4546000, + 4547000, + 4549000, + 4550000, + 4553000, + 4556000, + 4558000, + 4559000, + 4560000, + 4563000, + 4564000, + 4565000, + 4566000, + 4567000, + 4568000, + 4569000, + 4570000, + 4573000, + 4575000, + 4576000, + 4581000, + 4584000, + 4585000, + 4589000, + 4590000, + 4591000, + 4592000, + 4593000, + 4595000, + 4599000, + 4600000, + 4605000, + 4607000, + 4608000, + 4609000, + 4610000, + 4611000, + 4612000, + 4613000, + 4614000, + 4617000, + 4618000, + 4619000, + 4620000, + 4621000, + 4623000, + 4625000, + 4626000, + 4627000, + 4628000, + 4629000, + 4630000, + 4631000, + 4632000, + 4633000, + 4634000, + 4635000, + 4636000, + 4637000, + 4638000, + 4639000, + 4640000, + 4641000, + 4644000, + 4648000, + 4649000, + 4650000, + 4651000, + 4655000, + 4656000, + 4658000, + 4659000, + 4662000, + 4663000, + 4665000, + 4666000, + 4668000, + 4671000, + 4672000, + 4674000, + 4675000, + 4676000, + 4680000, + 4681000, + 4682000, + 4684000, + 4685000, + 4687000, + 4688000, + 4689000, + 4690000, + 4691000, + 4692000, + 4693000, + 4697000, + 4698000, + 4699000, + 4700000, + 4704000, + 4705000, + 4707000, + 4708000, + 4709000, + 4710000, + 4711000, + 4712000, + 4713000, + 4716000, + 4717000, + 4719000, + 4720000, + 4722000, + 4723000, + 4725000, + 4726000, + 4728000, + 4732000, + 4733000, + 4736000, + 4739000, + 4740000, + 4742000, + 4746000, + 4747000, + 4748000, + 4750000, + 4752000, + 4757000, + 4760000, + 4761000, + 4763000, + 4764000, + 4765000, + 4768000, + 4769000, + 4770000, + 4771000, + 4773000, + 4774000, + 4775000, + 4776000, + 4777000, + 4778000, + 4779000, + 4781000, + 4783000, + 4785000, + 4786000, + 4787000, + 4788000, + 4791000, + 4793000, + 4794000, + 4797000, + 4800000, + 4805000, + 4806000, + 4807000, + 4809000, + 4812000, + 4813000, + 4814000, + 4815000, + 4817000, + 4818000, + 4819000, + 4820000, + 4822000, + 4824000, + 4825000, + 4826000, + 4827000, + 4828000, + 4829000, + 4830000, + 4831000, + 4832000, + 4833000, + 4837000, + 4838000, + 4840000, + 4841000, + 4847000, + 4848000, + 4849000, + 4850000, + 4853000, + 4855000, + 4858000, + 4859000, + 4860000, + 4861000, + 4863000, + 4864000, + 4867000, + 4869000, + 4870000, + 4871000, + 4872000, + 4873000, + 4874000, + 4875000, + 4876000, + 4877000, + 4879000, + 4880000, + 4882000, + 4883000, + 4884000, + 4886000, + 4887000, + 4888000, + 4890000, + 4891000, + 4892000, + 4893000, + 4894000, + 4895000, + 4896000, + 4897000, + 4900000, + 4901000, + 4902000, + 4903000, + 4905000, + 4907000, + 4908000, + 4911000, + 4912000, + 4913000, + 4914000, + 4916000, + 4920000, + 4921000, + 4922000, + 4924000, + 4925000, + 4926000, + 4927000, + 4928000, + 4929000, + 4930000, + 4931000, + 4932000, + 4935000, + 4936000, + 4937000, + 4938000, + 4939000, + 4943000, + 4944000, + 4945000, + 4946000, + 4947000, + 4948000, + 4949000, + 4950000, + 4951000, + 4952000, + 4953000, + 4954000, + 4955000, + 4958000, + 4959000, + 4960000, + 4963000, + 4964000, + 4967000, + 4968000, + 4969000, + 4970000, + 4971000, + 4972000, + 4975000, + 4979000, + 4980000, + 4982000, + 4983000, + 4984000, + 4985000, + 4986000, + 4988000, + 4989000, + 4992000, + 4993000, + 4994000, + 4996000, + 4997000, + 4998000, + 5000000, + 5001000, + 5002000, + 5003000, + 5004000, + 5007000, + 5008000, + 5009000, + 5010000, + 5013000, + 5014000, + 5016000, + 5019000, + 5020000, + 5022000, + 5024000, + 5025000, + 5026000, + 5028000, + 5030000, + 5031000, + 5033000, + 5034000, + 5036000, + 5038000, + 5040000, + 5041000, + 5043000, + 5044000, + 5045000, + 5047000, + 5048000, + 5049000, + 5050000, + 5051000, + 5054000, + 5055000, + 5056000, + 5057000, + 5058000, + 5059000, + 5060000, + 5061000, + 5062000, + 5063000, + 5064000, + 5065000, + 5066000, + 5069000, + 5070000, + 5071000, + 5072000, + 5074000, + 5075000, + 5076000, + 5078000, + 5079000, + 5080000, + 5082000, + 5083000, + 5084000, + 5088000, + 5092000, + 5093000, + 5094000, + 5096000, + 5097000, + 5098000, + 5099000, + 5100000, + 5101000, + 5102000, + 5103000, + 5105000, + 5107000, + 5108000, + 5110000, + 5112000, + 5113000, + 5114000, + 5115000, + 5117000, + 5120000, + 5121000, + 5123000, + 5124000, + 5125000, + 5127000, + 5129000, + 5130000, + 5135000, + 5136000, + 5138000, + 5139000, + 5140000, + 5145000, + 5146000, + 5147000, + 5148000, + 5150000, + 5152000, + 5153000, + 5154000, + 5155000, + 5158000, + 5160000, + 5161000, + 5162000, + 5163000, + 5164000, + 5165000, + 5167000, + 5168000, + 5171000, + 5172000, + 5173000, + 5174000, + 5175000, + 5176000, + 5177000, + 5178000, + 5181000, + 5183000, + 5184000, + 5185000, + 5186000, + 5187000, + 5188000, + 5190000, + 5191000, + 5192000, + 5195000, + 5198000, + 5199000, + 5200000, + 5201000, + 5203000, + 5206000, + 5207000, + 5208000, + 5209000, + 5210000, + 5211000, + 5213000, + 5214000, + 5216000, + 5218000, + 5220000, + 5222000, + 5223000, + 5224000, + 5225000, + 5227000, + 5228000, + 5232000, + 5233000, + 5235000, + 5237000, + 5238000, + 5239000, + 5240000, + 5241000, + 5243000, + 5244000, + 5245000, + 5247000, + 5248000, + 5250000, + 5251000, + 5252000, + 5254000, + 5255000, + 5256000, + 5258000, + 5259000, + 5260000, + 5261000, + 5262000, + 5264000, + 5265000, + 5266000, + 5267000, + 5269000, + 5270000, + 5271000, + 5272000, + 5274000, + 5275000, + 5276000, + 5277000, + 5280000, + 5281000, + 5282000, + 5284000, + 5286000, + 5287000, + 5290000, + 5291000, + 5292000, + 5293000, + 5295000, + 5297000, + 5298000, + 5299000, + 5300000, + 5303000, + 5304000, + 5305000, + 5306000, + 5307000, + 5310000, + 5311000, + 5312000, + 5313000, + 5314000, + 5315000, + 5317000, + 5318000, + 5319000, + 5320000, + 5322000, + 5323000, + 5324000, + 5325000, + 5326000, + 5327000, + 5328000, + 5329000, + 5338000, + 5340000, + 5341000, + 5342000, + 5343000, + 5344000, + 5345000, + 5348000, + 5349000, + 5350000, + 5351000, + 5352000, + 5355000, + 5358000, + 5359000, + 5360000, + 5361000, + 5363000, + 5365000, + 5367000, + 5369000, + 5370000, + 5371000, + 5372000, + 5374000, + 5375000, + 5376000, + 5377000, + 5378000, + 5382000, + 5384000, + 5385000, + 5386000, + 5387000, + 5390000, + 5391000, + 5392000, + 5393000, + 5395000, + 5396000, + 5397000, + 5398000, + 5400000, + 5402000, + 5403000, + 5405000, + 5407000, + 5408000, + 5409000, + 5410000, + 5411000, + 5415000, + 5417000, + 5418000, + 5420000, + 5421000, + 5424000, + 5425000, + 5427000, + 5428000, + 5430000, + 5431000, + 5432000, + 5433000, + 5436000, + 5437000, + 5438000, + 5440000, + 5441000, + 5442000, + 5443000, + 5444000, + 5445000, + 5446000, + 5447000, + 5448000, + 5450000, + 5451000, + 5452000, + 5453000, + 5457000, + 5459000, + 5460000, + 5463000, + 5464000, + 5465000, + 5467000, + 5468000, + 5469000, + 5470000, + 5472000, + 5473000, + 5474000, + 5475000, + 5476000, + 5478000, + 5479000, + 5480000, + 5482000, + 5485000, + 5487000, + 5488000, + 5489000, + 5490000, + 5491000, + 5493000, + 5496000, + 5497000, + 5498000, + 5499000, + 5500000, + 5501000, + 5503000, + 5504000, + 5505000, + 5507000, + 5509000, + 5510000, + 5515000, + 5516000, + 5518000, + 5520000, + 5521000, + 5523000, + 5525000, + 5526000, + 5527000, + 5529000, + 5531000, + 5535000, + 5536000, + 5540000, + 5541000, + 5542000, + 5544000, + 5545000, + 5546000, + 5548000, + 5549000, + 5550000, + 5552000, + 5553000, + 5554000, + 5555000, + 5556000, + 5557000, + 5559000, + 5560000, + 5562000, + 5563000, + 5564000, + 5568000, + 5573000, + 5574000, + 5575000, + 5577000, + 5579000, + 5580000, + 5583000, + 5584000, + 5590000, + 5592000, + 5593000, + 5594000, + 5596000, + 5597000, + 5598000, + 5600000, + 5602000, + 5603000, + 5605000, + 5607000, + 5609000, + 5610000, + 5612000, + 5614000, + 5615000, + 5616000, + 5618000, + 5619000, + 5620000, + 5623000, + 5624000, + 5625000, + 5626000, + 5628000, + 5629000, + 5630000, + 5631000, + 5632000, + 5634000, + 5635000, + 5638000, + 5640000, + 5641000, + 5642000, + 5643000, + 5645000, + 5649000, + 5650000, + 5652000, + 5653000, + 5654000, + 5655000, + 5657000, + 5661000, + 5662000, + 5664000, + 5665000, + 5666000, + 5668000, + 5669000, + 5670000, + 5671000, + 5672000, + 5676000, + 5677000, + 5679000, + 5680000, + 5681000, + 5682000, + 5683000, + 5686000, + 5687000, + 5688000, + 5691000, + 5692000, + 5693000, + 5694000, + 5696000, + 5698000, + 5699000, + 5700000, + 5701000, + 5702000, + 5704000, + 5706000, + 5707000, + 5709000, + 5711000, + 5712000, + 5713000, + 5716000, + 5718000, + 5720000, + 5724000, + 5725000, + 5726000, + 5728000, + 5730000, + 5731000, + 5732000, + 5735000, + 5736000, + 5737000, + 5738000, + 5741000, + 5744000, + 5746000, + 5747000, + 5748000, + 5749000, + 5750000, + 5751000, + 5753000, + 5754000, + 5756000, + 5757000, + 5758000, + 5759000, + 5760000, + 5761000, + 5762000, + 5763000, + 5764000, + 5765000, + 5766000, + 5770000, + 5771000, + 5772000, + 5775000, + 5776000, + 5779000, + 5784000, + 5787000, + 5788000, + 5790000, + 5792000, + 5794000, + 5795000, + 5796000, + 5798000, + 5800000, + 5803000, + 5805000, + 5808000, + 5811000, + 5812000, + 5813000, + 5814000, + 5815000, + 5817000, + 5819000, + 5820000, + 5821000, + 5822000, + 5823000, + 5824000, + 5825000, + 5826000, + 5827000, + 5831000, + 5832000, + 5833000, + 5839000, + 5840000, + 5844000, + 5847000, + 5849000, + 5850000, + 5852000, + 5853000, + 5855000, + 5856000, + 5857000, + 5858000, + 5859000, + 5860000, + 5861000, + 5863000, + 5864000, + 5866000, + 5868000, + 5869000, + 5870000, + 5873000, + 5874000, + 5875000, + 5876000, + 5879000, + 5880000, + 5881000, + 5886000, + 5888000, + 5889000, + 5893000, + 5894000, + 5897000, + 5899000, + 5900000, + 5901000, + 5903000, + 5904000, + 5905000, + 5906000, + 5909000, + 5910000, + 5911000, + 5914000, + 5915000, + 5916000, + 5919000, + 5920000, + 5925000, + 5927000, + 5928000, + 5929000, + 5930000, + 5932000, + 5933000, + 5935000, + 5936000, + 5939000, + 5940000, + 5941000, + 5942000, + 5946000, + 5948000, + 5949000, + 5950000, + 5951000, + 5952000, + 5953000, + 5954000, + 5956000, + 5957000, + 5958000, + 5959000, + 5960000, + 5961000, + 5962000, + 5963000, + 5967000, + 5970000, + 5971000, + 5972000, + 5973000, + 5975000, + 5976000, + 5979000, + 5980000, + 5981000, + 5982000, + 5984000, + 5985000, + 5986000, + 5987000, + 5988000, + 6000000, + 6012000, + 6013000, + 6014000, + 6015000, + 6016000, + 6018000, + 6019000, + 6020000, + 6021000, + 6022000, + 6023000, + 6024000, + 6025000, + 6027000, + 6030000, + 6033000, + 6038000, + 6039000, + 6040000, + 6041000, + 6043000, + 6045000, + 6046000, + 6047000, + 6048000, + 6049000, + 6050000, + 6051000, + 6052000, + 6053000, + 6055000, + 6058000, + 6060000, + 6061000, + 6064000, + 6067000, + 6068000, + 6070000, + 6071000, + 6072000, + 6073000, + 6075000, + 6080000, + 6083000, + 6084000, + 6085000, + 6088000, + 6089000, + 6090000, + 6091000, + 6092000, + 6093000, + 6094000, + 6096000, + 6099000, + 6100000, + 6101000, + 6102000, + 6103000, + 6105000, + 6107000, + 6110000, + 6112000, + 6114000, + 6116000, + 6117000, + 6120000, + 6123000, + 6124000, + 6125000, + 6126000, + 6127000, + 6129000, + 6130000, + 6131000, + 6132000, + 6134000, + 6135000, + 6139000, + 6140000, + 6141000, + 6142000, + 6144000, + 6145000, + 6166000, + 6167000, + 6168000, + 6170000, + 6173000, + 6174000, + 6175000, + 6176000, + 6179000, + 6180000, + 6183000, + 6185000, + 6186000, + 6187000, + 6189000, + 6190000, + 6191000, + 6192000, + 6195000, + 6197000, + 6199000, + 6200000, + 6203000, + 6205000, + 6206000, + 6208000, + 6210000, + 6211000, + 6213000, + 6215000, + 6216000, + 6218000, + 6220000, + 6221000, + 6225000, + 6226000, + 6228000, + 6230000, + 6233000, + 6235000, + 6236000, + 6237000, + 6238000, + 6239000, + 6240000, + 6241000, + 6242000, + 6243000, + 6246000, + 6247000, + 6249000, + 6250000, + 6251000, + 6252000, + 6253000, + 6255000, + 6256000, + 6257000, + 6258000, + 6259000, + 6263000, + 6264000, + 6268000, + 6270000, + 6272000, + 6274000, + 6275000, + 6278000, + 6280000, + 6281000, + 6284000, + 6287000, + 6288000, + 6289000, + 6290000, + 6292000, + 6294000, + 6296000, + 6297000, + 6299000, + 6300000, + 6301000, + 6302000, + 6304000, + 6305000, + 6306000, + 6308000, + 6311000, + 6312000, + 6313000, + 6317000, + 6318000, + 6320000, + 6323000, + 6324000, + 6325000, + 6327000, + 6329000, + 6331000, + 6332000, + 6334000, + 6336000, + 6339000, + 6343000, + 6346000, + 6349000, + 6350000, + 6351000, + 6352000, + 6355000, + 6356000, + 6360000, + 6361000, + 6362000, + 6363000, + 6364000, + 6365000, + 6366000, + 6368000, + 6369000, + 6370000, + 6371000, + 6372000, + 6374000, + 6375000, + 6376000, + 6377000, + 6378000, + 6379000, + 6380000, + 6381000, + 6382000, + 6384000, + 6385000, + 6387000, + 6390000, + 6391000, + 6392000, + 6395000, + 6397000, + 6398000, + 6400000, + 6403000, + 6404000, + 6405000, + 6406000, + 6407000, + 6408000, + 6412000, + 6416000, + 6418000, + 6420000, + 6421000, + 6422000, + 6424000, + 6425000, + 6427000, + 6430000, + 6432000, + 6434000, + 6435000, + 6436000, + 6438000, + 6440000, + 6441000, + 6444000, + 6446000, + 6447000, + 6450000, + 6451000, + 6452000, + 6454000, + 6455000, + 6456000, + 6458000, + 6459000, + 6460000, + 6463000, + 6464000, + 6465000, + 6470000, + 6471000, + 6473000, + 6474000, + 6475000, + 6476000, + 6477000, + 6478000, + 6479000, + 6480000, + 6482000, + 6483000, + 6484000, + 6485000, + 6488000, + 6489000, + 6490000, + 6491000, + 6492000, + 6497000, + 6498000, + 6499000, + 6500000, + 6501000, + 6503000, + 6504000, + 6508000, + 6509000, + 6510000, + 6511000, + 6512000, + 6515000, + 6516000, + 6517000, + 6518000, + 6519000, + 6520000, + 6521000, + 6523000, + 6524000, + 6525000, + 6526000, + 6527000, + 6528000, + 6530000, + 6531000, + 6533000, + 6535000, + 6536000, + 6537000, + 6540000, + 6541000, + 6542000, + 6543000, + 6547000, + 6549000, + 6550000, + 6551000, + 6552000, + 6553000, + 6554000, + 6557000, + 6558000, + 6560000, + 6565000, + 6567000, + 6568000, + 6569000, + 6570000, + 6572000, + 6573000, + 6574000, + 6575000, + 6576000, + 6577000, + 6578000, + 6579000, + 6584000, + 6585000, + 6586000, + 6589000, + 6590000, + 6592000, + 6593000, + 6594000, + 6595000, + 6597000, + 6598000, + 6600000, + 6603000, + 6605000, + 6606000, + 6607000, + 6608000, + 6609000, + 6610000, + 6611000, + 6613000, + 6614000, + 6615000, + 6616000, + 6617000, + 6618000, + 6619000, + 6622000, + 6624000, + 6625000, + 6626000, + 6627000, + 6629000, + 6630000, + 6631000, + 6633000, + 6635000, + 6637000, + 6639000, + 6640000, + 6641000, + 6642000, + 6643000, + 6645000, + 6647000, + 6648000, + 6649000, + 6650000, + 6651000, + 6653000, + 6654000, + 6655000, + 6656000, + 6660000, + 6661000, + 6663000, + 6665000, + 6670000, + 6671000, + 6672000, + 6673000, + 6674000, + 6675000, + 6677000, + 6678000, + 6680000, + 6681000, + 6682000, + 6683000, + 6684000, + 6685000, + 6686000, + 6688000, + 6689000, + 6690000, + 6691000, + 6693000, + 6694000, + 6695000, + 6696000, + 6697000, + 6699000, + 6700000, + 6701000, + 6703000, + 6705000, + 6707000, + 6708000, + 6709000, + 6710000, + 6711000, + 6712000, + 6714000, + 6718000, + 6719000, + 6720000, + 6721000, + 6723000, + 6724000, + 6725000, + 6728000, + 6730000, + 6731000, + 6733000, + 6734000, + 6736000, + 6739000, + 6740000, + 6741000, + 6742000, + 6743000, + 6744000, + 6745000, + 6748000, + 6750000, + 6751000, + 6752000, + 6753000, + 6754000, + 6756000, + 6757000, + 6758000, + 6759000, + 6760000, + 6761000, + 6763000, + 6764000, + 6766000, + 6768000, + 6774000, + 6775000, + 6776000, + 6778000, + 6779000, + 6780000, + 6781000, + 6784000, + 6786000, + 6787000, + 6788000, + 6789000, + 6790000, + 6792000, + 6793000, + 6794000, + 6795000, + 6796000, + 6797000, + 6799000, + 6800000, + 6804000, + 6809000, + 6810000, + 6812000, + 6814000, + 6816000, + 6817000, + 6823000, + 6824000, + 6825000, + 6828000, + 6829000, + 6831000, + 6833000, + 6834000, + 6835000, + 6840000, + 6841000, + 6846000, + 6847000, + 6848000, + 6850000, + 6851000, + 6852000, + 6861000, + 6862000, + 6863000, + 6864000, + 6865000, + 6870000, + 6873000, + 6874000, + 6875000, + 6876000, + 6880000, + 6881000, + 6882000, + 6884000, + 6885000, + 6888000, + 6893000, + 6896000, + 6897000, + 6898000, + 6899000, + 6900000, + 6901000, + 6906000, + 6907000, + 6908000, + 6910000, + 6912000, + 6916000, + 6918000, + 6920000, + 6924000, + 6925000, + 6926000, + 6927000, + 6929000, + 6930000, + 6931000, + 6932000, + 6936000, + 6937000, + 6938000, + 6939000, + 6942000, + 6944000, + 6945000, + 6949000, + 6950000, + 6951000, + 6952000, + 6953000, + 6956000, + 6957000, + 6959000, + 6960000, + 6961000, + 6966000, + 6967000, + 6975000, + 6976000, + 6980000, + 6984000, + 6988000, + 6990000, + 6991000, + 6993000, + 6997000, + 6998000, + 7000000, + 7001000, + 7002000, + 7004000, + 7005000, + 7006000, + 7007000, + 7008000, + 7009000, + 7010000, + 7015000, + 7016000, + 7017000, + 7018000, + 7019000, + 7020000, + 7023000, + 7025000, + 7026000, + 7027000, + 7028000, + 7030000, + 7032000, + 7036000, + 7038000, + 7040000, + 7043000, + 7044000, + 7048000, + 7050000, + 7051000, + 7056000, + 7057000, + 7061000, + 7063000, + 7064000, + 7067000, + 7068000, + 7069000, + 7071000, + 7072000, + 7073000, + 7074000, + 7075000, + 7080000, + 7081000, + 7083000, + 7084000, + 7085000, + 7087000, + 7088000, + 7089000, + 7092000, + 7094000, + 7097000, + 7098000, + 7099000, + 7100000, + 7101000, + 7103000, + 7104000, + 7105000, + 7106000, + 7107000, + 7108000, + 7109000, + 7110000, + 7112000, + 7113000, + 7114000, + 7115000, + 7116000, + 7119000, + 7120000, + 7123000, + 7125000, + 7126000, + 7127000, + 7128000, + 7129000, + 7131000, + 7132000, + 7133000, + 7134000, + 7146000, + 7148000, + 7150000, + 7151000, + 7152000, + 7157000, + 7159000, + 7160000, + 7162000, + 7163000, + 7165000, + 7166000, + 7168000, + 7170000, + 7173000, + 7175000, + 7176000, + 7178000, + 7179000, + 7184000, + 7189000, + 7193000, + 7194000, + 7195000, + 7200000, + 7205000, + 7207000, + 7211000, + 7213000, + 7214000, + 7216000, + 7217000, + 7222000, + 7223000, + 7224000, + 7225000, + 7230000, + 7232000, + 7236000, + 7239000, + 7240000, + 7241000, + 7242000, + 7243000, + 7244000, + 7246000, + 7247000, + 7248000, + 7250000, + 7251000, + 7252000, + 7255000, + 7257000, + 7260000, + 7264000, + 7267000, + 7272000, + 7275000, + 7276000, + 7277000, + 7279000, + 7280000, + 7282000, + 7283000, + 7287000, + 7289000, + 7290000, + 7293000, + 7295000, + 7296000, + 7297000, + 7300000, + 7307000, + 7308000, + 7311000, + 7312000, + 7313000, + 7314000, + 7318000, + 7319000, + 7320000, + 7321000, + 7323000, + 7325000, + 7326000, + 7327000, + 7328000, + 7331000, + 7335000, + 7337000, + 7343000, + 7344000, + 7345000, + 7346000, + 7350000, + 7351000, + 7354000, + 7359000, + 7360000, + 7363000, + 7365000, + 7368000, + 7369000, + 7371000, + 7373000, + 7375000, + 7378000, + 7379000, + 7380000, + 7381000, + 7382000, + 7387000, + 7389000, + 7390000, + 7391000, + 7392000, + 7393000, + 7396000, + 7397000, + 7398000, + 7399000, + 7400000, + 7401000, + 7402000, + 7405000, + 7406000, + 7407000, + 7409000, + 7410000, + 7411000, + 7413000, + 7415000, + 7416000, + 7417000, + 7424000, + 7425000, + 7427000, + 7431000, + 7435000, + 7437000, + 7439000, + 7440000, + 7443000, + 7446000, + 7450000, + 7453000, + 7454000, + 7456000, + 7458000, + 7461000, + 7464000, + 7465000, + 7466000, + 7468000, + 7469000, + 7470000, + 7472000, + 7475000, + 7476000, + 7479000, + 7480000, + 7484000, + 7485000, + 7486000, + 7488000, + 7489000, + 7494000, + 7496000, + 7500000, + 7502000, + 7503000, + 7505000, + 7508000, + 7511000, + 7512000, + 7514000, + 7517000, + 7520000, + 7524000, + 7525000, + 7530000, + 7536000, + 7537000, + 7538000, + 7539000, + 7540000, + 7541000, + 7544000, + 7546000, + 7547000, + 7549000, + 7550000, + 7552000, + 7554000, + 7560000, + 7561000, + 7568000, + 7571000, + 7575000, + 7576000, + 7577000, + 7581000, + 7583000, + 7584000, + 7590000, + 7592000, + 7594000, + 7596000, + 7600000, + 7601000, + 7602000, + 7605000, + 7606000, + 7607000, + 7608000, + 7613000, + 7615000, + 7616000, + 7617000, + 7620000, + 7621000, + 7622000, + 7625000, + 7630000, + 7631000, + 7632000, + 7633000, + 7638000, + 7639000, + 7640000, + 7642000, + 7643000, + 7644000, + 7647000, + 7648000, + 7650000, + 7651000, + 7653000, + 7654000, + 7656000, + 7657000, + 7659000, + 7661000, + 7666000, + 7668000, + 7669000, + 7670000, + 7671000, + 7675000, + 7676000, + 7679000, + 7680000, + 7682000, + 7685000, + 7687000, + 7689000, + 7694000, + 7695000, + 7697000, + 7700000, + 7701000, + 7704000, + 7706000, + 7709000, + 7710000, + 7712000, + 7717000, + 7718000, + 7720000, + 7725000, + 7728000, + 7731000, + 7732000, + 7737000, + 7738000, + 7740000, + 7743000, + 7744000, + 7747000, + 7748000, + 7749000, + 7750000, + 7751000, + 7752000, + 7753000, + 7757000, + 7758000, + 7759000, + 7761000, + 7762000, + 7763000, + 7768000, + 7769000, + 7770000, + 7771000, + 7772000, + 7775000, + 7776000, + 7777000, + 7778000, + 7780000, + 7782000, + 7783000, + 7785000, + 7787000, + 7789000, + 7793000, + 7794000, + 7796000, + 7797000, + 7798000, + 7800000, + 7802000, + 7804000, + 7808000, + 7809000, + 7810000, + 7811000, + 7816000, + 7817000, + 7818000, + 7820000, + 7821000, + 7822000, + 7823000, + 7824000, + 7825000, + 7828000, + 7829000, + 7830000, + 7831000, + 7832000, + 7833000, + 7835000, + 7836000, + 7838000, + 7839000, + 7840000, + 7841000, + 7842000, + 7845000, + 7847000, + 7848000, + 7850000, + 7851000, + 7854000, + 7855000, + 7858000, + 7860000, + 7863000, + 7864000, + 7868000, + 7871000, + 7872000, + 7874000, + 7875000, + 7876000, + 7877000, + 7879000, + 7880000, + 7881000, + 7882000, + 7883000, + 7885000, + 7887000, + 7890000, + 7891000, + 7892000, + 7893000, + 7894000, + 7896000, + 7897000, + 7898000, + 7900000, + 7901000, + 7903000, + 7904000, + 7905000, + 7908000, + 7918000, + 7919000, + 7920000, + 7922000, + 7924000, + 7925000, + 7927000, + 7928000, + 7929000, + 7931000, + 7932000, + 7933000, + 7935000, + 7936000, + 7938000, + 7939000, + 7943000, + 7944000, + 7945000, + 7950000, + 7953000, + 7954000, + 7955000, + 7956000, + 7957000, + 7958000, + 7960000, + 7963000, + 7964000, + 7965000, + 7967000, + 7968000, + 7971000, + 7973000, + 7975000, + 7977000, + 7978000, + 7979000, + 7980000, + 7981000, + 7982000, + 7983000, + 7984000, + 7985000, + 7986000, + 7987000, + 7988000, + 7989000, + 7991000, + 7992000, + 8000000, + 8008000, + 8009000, + 8010000, + 8011000, + 8012000, + 8014000, + 8016000, + 8017000, + 8018000, + 8019000, + 8020000, + 8021000, + 8025000, + 8026000, + 8028000, + 8029000, + 8031000, + 8032000, + 8033000, + 8039000, + 8040000, + 8041000, + 8043000, + 8044000, + 8045000, + 8046000, + 8049000, + 8050000, + 8053000, + 8055000, + 8058000, + 8059000, + 8060000, + 8064000, + 8065000, + 8066000, + 8067000, + 8070000, + 8072000, + 8074000, + 8075000, + 8076000, + 8080000, + 8081000, + 8083000, + 8088000, + 8089000, + 8094000, + 8095000, + 8096000, + 8098000, + 8100000, + 8101000, + 8103000, + 8109000, + 8110000, + 8111000, + 8112000, + 8113000, + 8114000, + 8119000, + 8120000, + 8122000, + 8125000, + 8128000, + 8130000, + 8131000, + 8132000, + 8134000, + 8135000, + 8136000, + 8138000, + 8141000, + 8142000, + 8145000, + 8147000, + 8150000, + 8152000, + 8153000, + 8154000, + 8156000, + 8159000, + 8160000, + 8161000, + 8163000, + 8167000, + 8169000, + 8171000, + 8172000, + 8175000, + 8176000, + 8177000, + 8180000, + 8183000, + 8184000, + 8185000, + 8187000, + 8189000, + 8190000, + 8193000, + 8194000, + 8196000, + 8197000, + 8199000, + 8200000, + 8202000, + 8203000, + 8204000, + 8208000, + 8212000, + 8214000, + 8218000, + 8220000, + 8222000, + 8223000, + 8224000, + 8225000, + 8227000, + 8252000, + 8254000, + 8255000, + 8256000, + 8259000, + 8261000, + 8263000, + 8270000, + 8272000, + 8273000, + 8274000, + 8275000, + 8277000, + 8278000, + 8280000, + 8281000, + 8284000, + 8285000, + 8287000, + 8288000, + 8289000, + 8292000, + 8293000, + 8294000, + 8295000, + 8297000, + 8298000, + 8300000, + 8301000, + 8302000, + 8303000, + 8304000, + 8306000, + 8310000, + 8311000, + 8313000, + 8314000, + 8316000, + 8318000, + 8320000, + 8322000, + 8323000, + 8324000, + 8325000, + 8326000, + 8328000, + 8329000, + 8330000, + 8331000, + 8332000, + 8334000, + 8336000, + 8337000, + 8340000, + 8342000, + 8344000, + 8346000, + 8349000, + 8350000, + 8351000, + 8352000, + 8354000, + 8356000, + 8358000, + 8359000, + 8360000, + 8361000, + 8362000, + 8365000, + 8366000, + 8369000, + 8370000, + 8371000, + 8373000, + 8375000, + 8376000, + 8378000, + 8379000, + 8380000, + 8382000, + 8383000, + 8384000, + 8385000, + 8386000, + 8387000, + 8388000, + 8390000, + 8392000, + 8393000, + 8394000, + 8395000, + 8396000, + 8400000, + 8403000, + 8404000, + 8405000, + 8406000, + 8407000, + 8408000, + 8409000, + 8411000, + 8412000, + 8413000, + 8415000, + 8416000, + 8419000, + 8420000, + 8422000, + 8423000, + 8424000, + 8425000, + 8426000, + 8427000, + 8428000, + 8429000, + 8430000, + 8431000, + 8434000, + 8435000, + 8436000, + 8437000, + 8438000, + 8439000, + 8440000, + 8441000, + 8442000, + 8446000, + 8447000, + 8448000, + 8449000, + 8450000, + 8453000, + 8455000, + 8458000, + 8460000, + 8461000, + 8462000, + 8463000, + 8466000, + 8467000, + 8468000, + 8472000, + 8473000, + 8474000, + 8475000, + 8476000, + 8477000, + 8478000, + 8479000, + 8480000, + 8482000, + 8483000, + 8484000, + 8486000, + 8487000, + 8488000, + 8489000, + 8490000, + 8491000, + 8495000, + 8496000, + 8497000, + 8498000, + 8499000, + 8500000, + 8501000, + 8502000, + 8503000, + 8506000, + 8508000, + 8510000, + 8511000, + 8512000, + 8515000, + 8517000, + 8520000, + 8521000, + 8522000, + 8523000, + 8524000, + 8525000, + 8527000, + 8531000, + 8532000, + 8535000, + 8536000, + 8538000, + 8539000, + 8541000, + 8543000, + 8544000, + 8545000, + 8547000, + 8549000, + 8550000, + 8551000, + 8552000, + 8553000, + 8554000, + 8555000, + 8556000, + 8557000, + 8559000, + 8560000, + 8561000, + 8562000, + 8563000, + 8564000, + 8566000, + 8567000, + 8568000, + 8581000, + 8596000, + 8598000, + 8600000, + 8601000, + 8605000, + 8606000, + 8608000, + 8609000, + 8610000, + 8612000, + 8614000, + 8616000, + 8617000, + 8620000, + 8621000, + 8623000, + 8624000, + 8625000, + 8626000, + 8627000, + 8630000, + 8631000, + 8632000, + 8634000, + 8638000, + 8639000, + 8640000, + 8641000, + 8643000, + 8645000, + 8647000, + 8648000, + 8650000, + 8651000, + 8652000, + 8653000, + 8655000, + 8657000, + 8658000, + 8659000, + 8662000, + 8663000, + 8664000, + 8669000, + 8670000, + 8672000, + 8673000, + 8675000, + 8676000, + 8677000, + 8679000, + 8680000, + 8682000, + 8683000, + 8684000, + 8685000, + 8687000, + 8688000, + 8691000, + 8692000, + 8693000, + 8694000, + 8695000, + 8697000, + 8699000, + 8700000, + 8701000, + 8703000, + 8704000, + 8705000, + 8708000, + 8709000, + 8710000, + 8712000, + 8713000, + 8714000, + 8715000, + 8716000, + 8719000, + 8720000, + 8721000, + 8725000, + 8730000, + 8732000, + 8733000, + 8734000, + 8735000, + 8736000, + 8739000, + 8740000, + 8741000, + 8743000, + 8744000, + 8747000, + 8748000, + 8749000, + 8750000, + 8751000, + 8755000, + 8756000, + 8758000, + 8760000, + 8761000, + 8763000, + 8764000, + 8765000, + 8767000, + 8768000, + 8769000, + 8771000, + 8772000, + 8775000, + 8777000, + 8778000, + 8779000, + 8782000, + 8784000, + 8785000, + 8786000, + 8787000, + 8788000, + 8790000, + 8791000, + 8795000, + 8796000, + 8797000, + 8800000, + 8803000, + 8804000, + 8805000, + 8806000, + 8807000, + 8808000, + 8810000, + 8811000, + 8812000, + 8813000, + 8815000, + 8818000, + 8819000, + 8820000, + 8821000, + 8822000, + 8825000, + 8826000, + 8827000, + 8828000, + 8829000, + 8831000, + 8832000, + 8833000, + 8834000, + 8835000, + 8836000, + 8837000, + 8838000, + 8839000, + 8840000, + 8844000, + 8845000, + 8846000, + 8847000, + 8848000, + 8849000, + 8850000, + 8851000, + 8852000, + 8853000, + 8854000, + 8855000, + 8856000, + 8858000, + 8859000, + 8861000, + 8862000, + 8863000, + 8864000, + 8866000, + 8867000, + 8871000, + 8873000, + 8875000, + 8876000, + 8879000, + 8880000, + 8882000, + 8883000, + 8884000, + 8885000, + 8886000, + 8887000, + 8888000, + 8890000, + 8891000, + 8892000, + 8894000, + 8895000, + 8896000, + 8897000, + 8900000, + 8901000, + 8902000, + 8904000, + 8905000, + 8906000, + 8908000, + 8909000, + 8910000, + 8915000, + 8916000, + 8917000, + 8918000, + 8919000, + 8920000, + 8921000, + 8922000, + 8924000, + 8925000, + 8926000, + 8927000, + 8928000, + 8929000, + 8931000, + 8932000, + 8933000, + 8934000, + 8935000, + 8936000, + 8937000, + 8939000, + 8940000, + 8942000, + 8943000, + 8945000, + 8946000, + 8947000, + 8948000, + 8950000, + 8951000, + 8952000, + 8953000, + 8954000, + 8956000, + 8958000, + 8960000, + 8961000, + 8962000, + 8963000, + 8964000, + 8966000, + 8968000, + 8969000, + 8970000, + 8971000, + 8975000, + 8976000, + 8977000, + 8978000, + 8979000, + 8980000, + 8981000, + 8982000, + 8983000, + 8984000, + 8985000, + 8986000, + 8987000, + 8988000, + 8989000, + 8990000, + 8991000, + 8992000, + 8993000, + 8994000, + 9000000, + 9005000, + 9008000, + 9009000, + 9011000, + 9013000, + 9014000, + 9015000, + 9016000, + 9017000, + 9018000, + 9021000, + 9023000, + 9024000, + 9025000, + 9029000, + 9030000, + 9035000, + 9036000, + 9037000, + 9040000, + 9045000, + 9047000, + 9048000, + 9050000, + 9052000, + 9053000, + 9054000, + 9055000, + 9056000, + 9060000, + 9062000, + 9065000, + 9066000, + 9069000, + 9070000, + 9072000, + 9075000, + 9076000, + 9077000, + 9080000, + 9083000, + 9088000, + 9089000, + 9090000, + 9094000, + 9095000, + 9096000, + 9097000, + 9100000, + 9108000, + 9112000, + 9115000, + 9116000, + 9117000, + 9118000, + 9120000, + 9122000, + 9125000, + 9126000, + 9129000, + 9130000, + 9131000, + 9132000, + 9134000, + 9135000, + 9138000, + 9141000, + 9144000, + 9145000, + 9146000, + 9148000, + 9150000, + 9152000, + 9160000, + 9163000, + 9164000, + 9165000, + 9166000, + 9167000, + 9168000, + 9171000, + 9173000, + 9174000, + 9175000, + 9179000, + 9180000, + 9182000, + 9183000, + 9184000, + 9185000, + 9186000, + 9187000, + 9190000, + 9192000, + 9193000, + 9194000, + 9198000, + 9200000, + 9201000, + 9202000, + 9209000, + 9210000, + 9211000, + 9217000, + 9218000, + 9219000, + 9222000, + 9224000, + 9225000, + 9226000, + 9229000, + 9236000, + 9240000, + 9241000, + 9242000, + 9243000, + 9245000, + 9247000, + 9248000, + 9249000, + 9250000, + 9252000, + 9275000, + 9276000, + 9280000, + 9281000, + 9285000, + 9287000, + 9288000, + 9292000, + 9293000, + 9295000, + 9296000, + 9299000, + 9300000, + 9301000, + 9302000, + 9305000, + 9312000, + 9315000, + 9316000, + 9317000, + 9320000, + 9324000, + 9325000, + 9329000, + 9330000, + 9336000, + 9341000, + 9342000, + 9343000, + 9344000, + 9349000, + 9350000, + 9351000, + 9354000, + 9357000, + 9359000, + 9360000, + 9362000, + 9363000, + 9365000, + 9367000, + 9369000, + 9370000, + 9371000, + 9373000, + 9374000, + 9375000, + 9376000, + 9379000, + 9383000, + 9384000, + 9386000, + 9390000, + 9395000, + 9396000, + 9397000, + 9398000, + 9400000, + 9401000, + 9403000, + 9406000, + 9408000, + 9413000, + 9419000, + 9420000, + 9422000, + 9423000, + 9425000, + 9426000, + 9432000, + 9433000, + 9434000, + 9435000, + 9439000, + 9440000, + 9442000, + 9443000, + 9446000, + 9448000, + 9449000, + 9450000, + 9452000, + 9456000, + 9458000, + 9463000, + 9464000, + 9467000, + 9475000, + 9476000, + 9478000, + 9481000, + 9497000, + 9498000, + 9500000, + 9503000, + 9504000, + 9506000, + 9507000, + 9510000, + 9512000, + 9513000, + 9520000, + 9522000, + 9523000, + 9525000, + 9528000, + 9531000, + 9533000, + 9536000, + 9539000, + 9543000, + 9546000, + 9548000, + 9549000, + 9550000, + 9552000, + 9554000, + 9556000, + 9557000, + 9558000, + 9560000, + 9562000, + 9563000, + 9568000, + 9569000, + 9570000, + 9572000, + 9573000, + 9575000, + 9576000, + 9581000, + 9583000, + 9585000, + 9586000, + 9587000, + 9593000, + 9624000, + 9625000, + 9626000, + 9627000, + 9630000, + 9632000, + 9633000, + 9635000, + 9638000, + 9640000, + 9642000, + 9644000, + 9648000, + 9649000, + 9650000, + 9651000, + 9659000, + 9660000, + 9664000, + 9665000, + 9668000, + 9671000, + 9672000, + 9675000, + 9676000, + 9685000, + 9687000, + 9690000, + 9695000, + 9696000, + 9700000, + 9701000, + 9704000, + 9705000, + 9706000, + 9707000, + 9712000, + 9713000, + 9717000, + 9720000, + 9723000, + 9725000, + 9727000, + 9728000, + 9729000, + 9731000, + 9732000, + 9734000, + 9738000, + 9741000, + 9743000, + 9744000, + 9745000, + 9747000, + 9750000, + 9755000, + 9759000, + 9760000, + 9762000, + 9764000, + 9765000, + 9766000, + 9767000, + 9768000, + 9769000, + 9771000, + 9773000, + 9775000, + 9776000, + 9779000, + 9780000, + 9781000, + 9787000, + 9792000, + 9794000, + 9795000, + 9799000, + 9800000, + 9805000, + 9810000, + 9816000, + 9821000, + 9822000, + 9823000, + 9824000, + 9825000, + 9826000, + 9828000, + 9831000, + 9832000, + 9834000, + 9835000, + 9837000, + 9838000, + 9840000, + 9842000, + 9844000, + 9845000, + 9850000, + 9851000, + 9853000, + 9854000, + 9855000, + 9856000, + 9858000, + 9859000, + 9860000, + 9861000, + 9862000, + 9864000, + 9865000, + 9870000, + 9872000, + 9873000, + 9874000, + 9875000, + 9876000, + 9879000, + 9880000, + 9881000, + 9887000, + 9888000, + 9892000, + 9894000, + 9895000, + 9896000, + 9899000, + 9900000, + 9901000, + 9904000, + 9906000, + 9908000, + 9910000, + 9912000, + 9915000, + 9917000, + 9918000, + 9919000, + 9920000, + 9921000, + 9922000, + 9924000, + 9925000, + 9926000, + 9929000, + 9930000, + 9932000, + 9933000, + 9934000, + 9935000, + 9936000, + 9937000, + 9941000, + 9942000, + 9944000, + 9945000, + 9948000, + 9949000, + 9950000, + 9952000, + 9953000, + 9955000, + 9956000, + 9957000, + 9958000, + 9959000, + 9960000, + 9965000, + 9967000, + 9968000, + 9970000, + 9972000, + 9975000, + 9976000, + 9977000, + 9978000, + 9981000, + 9982000, + 9983000, + 9984000, + 9985000, + 9986000, + 9987000, + 9988000, + 9990000, + 9991000, + 9992000, + 9993000, + 9995000, + 9996000, + 10004000, + 10007000, + 10009000, + 10011000, + 10014000, + 10018000, + 10020000, + 10021000, + 10023000, + 10025000, + 10026000, + 10027000, + 10031000, + 10032000, + 10034000, + 10035000, + 10039000, + 10040000, + 10042000, + 10043000, + 10044000, + 10045000, + 10049000, + 10050000, + 10052000, + 10055000, + 10056000, + 10058000, + 10059000, + 10062000, + 10075000, + 10076000, + 10077000, + 10078000, + 10082000, + 10083000, + 10086000, + 10089000, + 10093000, + 10094000, + 10095000, + 10101000, + 10102000, + 10103000, + 10104000, + 10107000, + 10109000, + 10114000, + 10116000, + 10117000, + 10120000, + 10125000, + 10128000, + 10129000, + 10131000, + 10133000, + 10134000, + 10135000, + 10137000, + 10139000, + 10140000, + 10144000, + 10145000, + 10150000, + 10152000, + 10161000, + 10164000, + 10165000, + 10170000, + 10175000, + 10177000, + 10181000, + 10184000, + 10188000, + 10193000, + 10194000, + 10200000, + 10203000, + 10208000, + 10210000, + 10211000, + 10214000, + 10217000, + 10219000, + 10220000, + 10221000, + 10224000, + 10225000, + 10230000, + 10233000, + 10234000, + 10241000, + 10243000, + 10248000, + 10249000, + 10250000, + 10252000, + 10253000, + 10254000, + 10258000, + 10259000, + 10260000, + 10267000, + 10269000, + 10271000, + 10273000, + 10274000, + 10275000, + 10277000, + 10279000, + 10280000, + 10300000, + 10304000, + 10309000, + 10320000, + 10321000, + 10325000, + 10327000, + 10331000, + 10332000, + 10336000, + 10343000, + 10344000, + 10346000, + 10349000, + 10350000, + 10355000, + 10360000, + 10368000, + 10375000, + 10380000, + 10392000, + 10397000, + 10400000, + 10404000, + 10410000, + 10416000, + 10425000, + 10432000, + 10433000, + 10437000, + 10440000, + 10441000, + 10446000, + 10450000, + 10456000, + 10459000, + 10464000, + 10470000, + 10475000, + 10476000, + 10480000, + 10485000, + 10488000, + 10496000, + 10500000, + 10506000, + 10508000, + 10512000, + 10520000, + 10522000, + 10525000, + 10528000, + 10530000, + 10532000, + 10536000, + 10543000, + 10546000, + 10548000, + 10559000, + 10560000, + 10568000, + 10573000, + 10575000, + 10580000, + 10582000, + 10584000, + 10590000, + 10592000, + 10595000, + 10596000, + 10598000, + 10600000, + 10604000, + 10605000, + 10608000, + 10609000, + 10610000, + 10618000, + 10620000, + 10622000, + 10624000, + 10625000, + 10628000, + 10632000, + 10638000, + 10640000, + 10644000, + 10647000, + 10648000, + 10650000, + 10656000, + 10664000, + 10675000, + 10680000, + 10681000, + 10684000, + 10685000, + 10687000, + 10688000, + 10691000, + 10697000, + 10698000, + 10700000, + 10702000, + 10704000, + 10708000, + 10709000, + 10710000, + 10711000, + 10716000, + 10719000, + 10720000, + 10722000, + 10724000, + 10725000, + 10726000, + 10728000, + 10729000, + 10732000, + 10734000, + 10740000, + 10750000, + 10752000, + 10755000, + 10756000, + 10757000, + 10760000, + 10761000, + 10762000, + 10764000, + 10765000, + 10767000, + 10769000, + 10770000, + 10772000, + 10773000, + 10774000, + 10775000, + 10776000, + 10777000, + 10781000, + 10783000, + 10784000, + 10786000, + 10792000, + 10794000, + 10795000, + 10796000, + 10800000, + 10803000, + 10804000, + 10814000, + 10816000, + 10820000, + 10821000, + 10822000, + 10824000, + 10825000, + 10830000, + 10832000, + 10836000, + 10837000, + 10840000, + 10841000, + 10843000, + 10844000, + 10845000, + 10847000, + 10848000, + 10849000, + 10850000, + 10853000, + 10854000, + 10855000, + 10860000, + 10861000, + 10862000, + 10864000, + 10865000, + 10867000, + 10869000, + 10870000, + 10872000, + 10875000, + 10876000, + 10878000, + 10879000, + 10880000, + 10883000, + 10884000, + 10885000, + 10886000, + 10890000, + 10891000, + 10894000, + 10895000, + 10896000, + 10897000, + 10900000, + 10901000, + 10904000, + 10905000, + 10912000, + 10913000, + 10914000, + 10915000, + 10916000, + 10920000, + 10921000, + 10925000, + 10926000, + 10928000, + 10930000, + 10931000, + 10932000, + 10934000, + 10935000, + 10936000, + 10937000, + 10940000, + 10944000, + 10946000, + 10948000, + 10950000, + 10951000, + 10952000, + 10953000, + 10954000, + 10955000, + 10958000, + 10960000, + 10961000, + 10964000, + 10965000, + 10966000, + 10967000, + 10968000, + 10969000, + 10997000, + 10998000, + 11000000, + 11002000, + 11003000, + 11004000, + 11005000, + 11006000, + 11007000, + 11008000, + 11010000, + 11011000, + 11015000, + 11016000, + 11019000, + 11020000, + 11021000, + 11025000, + 11029000, + 11030000, + 11031000, + 11033000, + 11037000, + 11038000, + 11040000, + 11041000, + 11042000, + 11044000, + 11048000, + 11050000, + 11051000, + 11052000, + 11053000, + 11054000, + 11064000, + 11067000, + 11070000, + 11071000, + 11072000, + 11073000, + 11074000, + 11075000, + 11080000, + 11081000, + 11083000, + 11085000, + 11088000, + 11089000, + 11091000, + 11092000, + 11095000, + 11097000, + 11100000, + 11104000, + 11105000, + 11112000, + 11113000, + 11114000, + 11115000, + 11119000, + 11120000, + 11121000, + 11124000, + 11125000, + 11126000, + 11130000, + 11136000, + 11137000, + 11146000, + 11150000, + 11152000, + 11158000, + 11159000, + 11160000, + 11164000, + 11168000, + 11174000, + 11175000, + 11176000, + 11179000, + 11181000, + 11184000, + 11185000, + 11190000, + 11191000, + 11194000, + 11195000, + 11196000, + 11197000, + 11200000, + 11204000, + 11205000, + 11208000, + 11211000, + 11213000, + 11216000, + 11217000, + 11218000, + 11223000, + 11224000, + 11225000, + 11231000, + 11232000, + 11233000, + 11240000, + 11245000, + 11250000, + 11252000, + 11255000, + 11256000, + 11264000, + 11268000, + 11270000, + 11271000, + 11275000, + 11279000, + 11280000, + 11282000, + 11285000, + 11289000, + 11296000, + 11300000, + 11304000, + 11310000, + 11311000, + 11315000, + 11319000, + 11320000, + 11321000, + 11325000, + 11328000, + 11331000, + 11332000, + 11338000, + 11340000, + 11342000, + 11345000, + 11350000, + 11352000, + 11353000, + 11356000, + 11357000, + 11360000, + 11366000, + 11370000, + 11372000, + 11375000, + 11376000, + 11378000, + 11379000, + 11383000, + 11391000, + 11392000, + 11396000, + 11400000, + 11405000, + 11407000, + 11412000, + 11417000, + 11419000, + 11422000, + 11423000, + 11424000, + 11425000, + 11430000, + 11432000, + 11435000, + 11437000, + 11440000, + 11443000, + 11448000, + 11450000, + 11456000, + 11457000, + 11460000, + 11462000, + 11464000, + 11467000, + 11468000, + 11470000, + 11472000, + 11473000, + 11475000, + 11480000, + 11482000, + 11483000, + 11488000, + 11490000, + 11496000, + 11498000, + 11499000, + 11500000, + 11501000, + 11502000, + 11509000, + 11512000, + 11517000, + 11518000, + 11519000, + 11520000, + 11521000, + 11523000, + 11525000, + 11527000, + 11529000, + 11537000, + 11544000, + 11546000, + 11547000, + 11550000, + 11551000, + 11552000, + 11554000, + 11560000, + 11564000, + 11565000, + 11567000, + 11568000, + 11574000, + 11575000, + 11576000, + 11579000, + 11580000, + 11581000, + 11584000, + 11585000, + 11588000, + 11592000, + 11596000, + 11597000, + 11599000, + 11600000, + 11609000, + 11610000, + 11611000, + 11615000, + 11616000, + 11618000, + 11625000, + 11626000, + 11627000, + 11628000, + 11630000, + 11634000, + 11638000, + 11639000, + 11642000, + 11644000, + 11648000, + 11649000, + 11650000, + 11651000, + 11653000, + 11655000, + 11658000, + 11659000, + 11663000, + 11664000, + 11666000, + 11667000, + 11670000, + 11671000, + 11675000, + 11680000, + 11681000, + 11686000, + 11688000, + 11694000, + 11695000, + 11697000, + 11698000, + 11699000, + 11700000, + 11701000, + 11706000, + 11710000, + 11712000, + 11714000, + 11717000, + 11718000, + 11720000, + 11722000, + 11723000, + 11725000, + 11726000, + 11729000, + 11730000, + 11731000, + 11732000, + 11735000, + 11736000, + 11737000, + 11743000, + 11744000, + 11747000, + 11750000, + 11751000, + 11752000, + 11753000, + 11754000, + 11757000, + 11759000, + 11760000, + 11762000, + 11763000, + 11767000, + 11768000, + 11770000, + 11771000, + 11772000, + 11773000, + 11775000, + 11776000, + 11779000, + 11783000, + 11784000, + 11785000, + 11787000, + 11788000, + 11789000, + 11790000, + 11791000, + 11792000, + 11793000, + 11794000, + 11795000, + 11796000, + 11797000, + 11799000, + 11800000, + 11801000, + 11802000, + 11805000, + 11806000, + 11807000, + 11808000, + 11809000, + 11810000, + 11811000, + 11813000, + 11815000, + 11818000, + 11819000, + 11820000, + 11825000, + 11827000, + 11828000, + 11829000, + 11832000, + 11833000, + 11834000, + 11835000, + 11836000, + 11837000, + 11838000, + 11840000, + 11841000, + 11847000, + 11849000, + 11850000, + 11851000, + 11853000, + 11854000, + 11855000, + 11856000, + 11858000, + 11863000, + 11864000, + 11866000, + 11867000, + 11870000, + 11872000, + 11873000, + 11875000, + 11876000, + 11877000, + 11878000, + 11880000, + 11882000, + 11883000, + 11885000, + 11887000, + 11891000, + 11892000, + 11896000, + 11897000, + 11898000, + 11900000, + 11902000, + 11903000, + 11904000, + 11905000, + 11906000, + 11908000, + 11909000, + 11910000, + 11912000, + 11913000, + 11914000, + 11915000, + 11916000, + 11917000, + 11919000, + 11920000, + 11921000, + 11923000, + 11924000, + 11925000, + 11926000, + 11928000, + 11930000, + 11931000, + 11932000, + 11933000, + 11934000, + 11935000, + 11936000, + 11937000, + 11938000, + 11939000, + 11940000, + 11941000, + 11942000, + 11943000, + 11944000, + 11945000, + 11946000, + 11947000, + 11949000, + 11950000, + 11951000, + 11952000, + 11953000, + 11955000, + 11956000, + 11958000, + 11959000, + 11960000, + 11961000, + 11962000, + 11963000, + 11964000, + 11965000, + 11967000, + 11968000, + 11969000, + 11970000, + 11971000, + 11972000, + 11975000, + 11976000, + 11977000, + 12037000, + 12038000, + 12040000, + 12041000, + 12044000, + 12045000, + 12046000, + 12047000, + 12048000, + 12050000, + 12053000, + 12055000, + 12056000, + 12057000, + 12059000, + 12060000, + 12064000, + 12065000, + 12066000, + 12068000, + 12071000, + 12072000, + 12073000, + 12075000, + 12076000, + 12077000, + 12079000, + 12080000, + 12082000, + 12083000, + 12085000, + 12087000, + 12088000, + 12090000, + 12091000, + 12092000, + 12094000, + 12095000, + 12096000, + 12097000, + 12099000, + 12100000, + 12103000, + 12104000, + 12105000, + 12106000, + 12112000, + 12117000, + 12118000, + 12120000, + 12123000, + 12124000, + 12125000, + 12126000, + 12127000, + 12128000, + 12130000, + 12131000, + 12136000, + 12137000, + 12139000, + 12144000, + 12145000, + 12146000, + 12149000, + 12150000, + 12151000, + 12153000, + 12157000, + 12160000, + 12166000, + 12167000, + 12168000, + 12173000, + 12175000, + 12177000, + 12178000, + 12180000, + 12187000, + 12188000, + 12189000, + 12191000, + 12192000, + 12193000, + 12195000, + 12198000, + 12199000, + 12200000, + 12203000, + 12204000, + 12205000, + 12206000, + 12209000, + 12210000, + 12211000, + 12214000, + 12215000, + 12217000, + 12221000, + 12224000, + 12225000, + 12227000, + 12228000, + 12229000, + 12230000, + 12234000, + 12237000, + 12239000, + 12240000, + 12242000, + 12246000, + 12247000, + 12249000, + 12251000, + 12252000, + 12254000, + 12256000, + 12259000, + 12260000, + 12263000, + 12264000, + 12266000, + 12270000, + 12271000, + 12275000, + 12277000, + 12278000, + 12280000, + 12281000, + 12282000, + 12283000, + 12284000, + 12285000, + 12310000, + 12311000, + 12312000, + 12313000, + 12314000, + 12317000, + 12319000, + 12320000, + 12321000, + 12322000, + 12323000, + 12325000, + 12326000, + 12327000, + 12328000, + 12330000, + 12332000, + 12333000, + 12335000, + 12336000, + 12337000, + 12339000, + 12347000, + 12348000, + 12361000, + 12362000, + 12365000, + 12366000, + 12370000, + 12373000, + 12374000, + 12377000, + 12378000, + 12380000, + 12381000, + 12382000, + 12383000, + 12384000, + 12385000, + 12386000, + 12388000, + 12391000, + 12392000, + 12393000, + 12394000, + 12395000, + 12396000, + 12397000, + 12398000, + 12399000, + 12400000, + 12404000, + 12405000, + 12407000, + 12408000, + 12411000, + 12412000, + 12413000, + 12415000, + 12416000, + 12418000, + 12419000, + 12420000, + 12421000, + 12422000, + 12424000, + 12425000, + 12426000, + 12427000, + 12431000, + 12432000, + 12433000, + 12435000, + 12436000, + 12437000, + 12438000, + 12440000, + 12441000, + 12443000, + 12447000, + 12448000, + 12449000, + 12450000, + 12451000, + 12452000, + 12455000, + 12456000, + 12459000, + 12460000, + 12463000, + 12464000, + 12465000, + 12468000, + 12469000, + 12470000, + 12471000, + 12472000, + 12473000, + 12475000, + 12476000, + 12479000, + 12480000, + 12481000, + 12484000, + 12486000, + 12487000, + 12488000, + 12489000, + 12492000, + 12494000, + 12498000, + 12499000, + 12500000, + 12501000, + 12502000, + 12504000, + 12506000, + 12508000, + 12509000, + 12510000, + 12511000, + 12512000, + 12513000, + 12515000, + 12517000, + 12518000, + 12519000, + 12520000, + 12523000, + 12524000, + 12525000, + 12526000, + 12527000, + 12528000, + 12530000, + 12533000, + 12534000, + 12536000, + 12538000, + 12539000, + 12540000, + 12541000, + 12542000, + 12544000, + 12547000, + 12548000, + 12550000, + 12551000, + 12552000, + 12553000, + 12555000, + 12556000, + 12557000, + 12559000, + 12560000, + 12561000, + 12563000, + 12564000, + 12565000, + 12567000, + 12568000, + 12569000, + 12570000, + 12573000, + 12574000, + 12575000, + 12576000, + 12578000, + 12579000, + 12580000, + 12581000, + 12582000, + 12583000, + 12584000, + 12585000, + 12587000, + 12588000, + 12589000, + 12591000, + 12592000, + 12593000, + 12594000, + 12595000, + 12596000, + 12597000, + 12600000, + 12602000, + 12603000, + 12604000, + 12605000, + 12608000, + 12609000, + 12611000, + 12614000, + 12615000, + 12616000, + 12619000, + 12621000, + 12622000, + 12623000, + 12624000, + 12625000, + 12626000, + 12627000, + 12629000, + 12630000, + 12633000, + 12634000, + 12635000, + 12636000, + 12638000, + 12640000, + 12641000, + 12643000, + 12646000, + 12647000, + 12648000, + 12649000, + 12650000, + 12653000, + 12654000, + 12656000, + 12657000, + 12658000, + 12659000, + 12662000, + 12663000, + 12664000, + 12665000, + 12666000, + 12668000, + 12669000, + 12670000, + 12671000, + 12672000, + 12675000, + 12677000, + 12678000, + 12680000, + 12685000, + 12689000, + 12690000, + 12691000, + 12692000, + 12694000, + 12695000, + 12696000, + 12698000, + 12700000, + 12701000, + 12702000, + 12703000, + 12704000, + 12708000, + 12709000, + 12710000, + 12715000, + 12716000, + 12717000, + 12719000, + 12720000, + 12721000, + 12722000, + 12723000, + 12725000, + 12728000, + 12729000, + 12730000, + 12731000, + 12732000, + 12733000, + 12734000, + 12736000, + 12737000, + 12742000, + 12743000, + 12744000, + 12745000, + 12746000, + 12748000, + 12750000, + 12752000, + 12754000, + 12755000, + 12756000, + 12757000, + 12759000, + 12760000, + 12761000, + 12762000, + 12763000, + 12764000, + 12765000, + 12768000, + 12771000, + 12772000, + 12775000, + 12776000, + 12780000, + 12782000, + 12783000, + 12784000, + 12787000, + 12788000, + 12789000, + 12790000, + 12792000, + 12793000, + 12794000, + 12798000, + 12800000, + 12802000, + 12804000, + 12807000, + 12808000, + 12809000, + 12810000, + 12812000, + 12813000, + 12816000, + 12817000, + 12820000, + 12823000, + 12824000, + 12825000, + 12827000, + 12828000, + 12831000, + 12832000, + 12833000, + 12835000, + 12836000, + 12838000, + 12839000, + 12840000, + 12841000, + 12842000, + 12843000, + 12846000, + 12848000, + 12849000, + 12850000, + 12852000, + 12853000, + 12854000, + 12855000, + 12859000, + 12861000, + 12862000, + 12863000, + 12864000, + 12865000, + 12867000, + 12869000, + 12870000, + 12871000, + 12872000, + 12874000, + 12875000, + 12876000, + 12877000, + 12880000, + 12881000, + 12882000, + 12883000, + 12885000, + 12886000, + 12887000, + 12888000, + 12891000, + 12892000, + 12893000, + 12894000, + 12895000, + 12896000, + 12897000, + 12898000, + 12900000, + 12901000, + 12902000, + 12904000, + 12905000, + 12907000, + 12908000, + 12909000, + 12910000, + 12911000, + 12912000, + 12915000, + 12918000, + 12919000, + 12920000, + 12921000, + 12925000, + 12926000, + 12927000, + 12928000, + 12929000, + 12930000, + 12931000, + 12936000, + 12937000, + 12938000, + 12939000, + 12940000, + 12941000, + 12942000, + 12943000, + 12944000, + 12945000, + 12946000, + 12947000, + 12948000, + 12949000, + 12950000, + 12951000, + 12953000, + 12954000, + 12956000, + 12957000, + 12959000, + 12960000, + 12961000, + 12963000, + 12964000, + 12965000, + 12966000, + 12967000, + 12968000, + 12974000, + 12975000, + 12976000, + 12978000, + 12979000, + 12980000, + 12981000, + 12983000, + 12984000, + 12985000, + 12987000, + 12989000, + 12990000, + 12991000, + 12992000, + 12993000, + 12994000, + 12995000, + 12996000, + 12997000, + 12998000, + 13000000, + 13005000, + 13007000, + 13008000, + 13013000, + 13018000, + 13020000, + 13023000, + 13024000, + 13025000, + 13056000, + 13061000, + 13063000, + 13065000, + 13066000, + 13071000, + 13074000, + 13075000, + 13080000, + 13084000, + 13088000, + 13093000, + 13094000, + 13095000, + 13098000, + 13100000, + 13103000, + 13109000, + 13110000, + 13114000, + 13119000, + 13120000, + 13121000, + 13123000, + 13125000, + 13127000, + 13128000, + 13129000, + 13131000, + 13138000, + 13140000, + 13141000, + 13147000, + 13148000, + 13150000, + 13151000, + 13152000, + 13159000, + 13160000, + 13165000, + 13166000, + 13170000, + 13175000, + 13176000, + 13177000, + 13178000, + 13184000, + 13186000, + 13189000, + 13195000, + 13200000, + 13206000, + 13214000, + 13216000, + 13219000, + 13224000, + 13225000, + 13228000, + 13229000, + 13230000, + 13233000, + 13236000, + 13239000, + 13240000, + 13244000, + 13248000, + 13249000, + 13250000, + 13255000, + 13258000, + 13259000, + 13260000, + 13265000, + 13267000, + 13268000, + 13269000, + 13270000, + 13272000, + 13275000, + 13280000, + 13281000, + 13282000, + 13284000, + 13289000, + 13290000, + 13294000, + 13295000, + 13296000, + 13300000, + 13303000, + 13308000, + 13309000, + 13312000, + 13313000, + 13316000, + 13319000, + 13320000, + 13325000, + 13327000, + 13336000, + 13339000, + 13343000, + 13344000, + 13345000, + 13346000, + 13350000, + 13354000, + 13355000, + 13356000, + 13357000, + 13358000, + 13359000, + 13360000, + 13363000, + 13365000, + 13368000, + 13369000, + 13398000, + 13399000, + 13400000, + 13406000, + 13407000, + 13408000, + 13409000, + 13410000, + 13414000, + 13415000, + 13416000, + 13417000, + 13419000, + 13425000, + 13427000, + 13428000, + 13431000, + 13432000, + 13434000, + 13438000, + 13439000, + 13440000, + 13445000, + 13447000, + 13448000, + 13449000, + 13450000, + 13451000, + 13452000, + 13455000, + 13456000, + 13457000, + 13460000, + 13461000, + 13462000, + 13464000, + 13466000, + 13470000, + 13471000, + 13472000, + 13473000, + 13475000, + 13478000, + 13479000, + 13480000, + 13481000, + 13482000, + 13484000, + 13486000, + 13487000, + 13488000, + 13489000, + 13491000, + 13492000, + 13493000, + 13495000, + 13496000, + 13497000, + 13500000, + 13504000, + 13505000, + 13506000, + 13507000, + 13512000, + 13513000, + 13516000, + 13519000, + 13520000, + 13522000, + 13523000, + 13525000, + 13526000, + 13528000, + 13530000, + 13531000, + 13533000, + 13534000, + 13536000, + 13541000, + 13542000, + 13545000, + 13548000, + 13549000, + 13550000, + 13556000, + 13557000, + 13560000, + 13561000, + 13562000, + 13563000, + 13567000, + 13568000, + 13569000, + 13570000, + 13571000, + 13572000, + 13573000, + 13574000, + 13575000, + 13576000, + 13577000, + 13578000, + 13580000, + 13581000, + 13583000, + 13584000, + 13589000, + 13590000, + 13592000, + 13593000, + 13594000, + 13595000, + 13596000, + 13597000, + 13598000, + 13600000, + 13603000, + 13605000, + 13606000, + 13607000, + 13608000, + 13609000, + 13611000, + 13614000, + 13619000, + 13620000, + 13621000, + 13623000, + 13624000, + 13625000, + 13626000, + 13627000, + 13632000, + 13633000, + 13634000, + 13635000, + 13638000, + 13639000, + 13640000, + 13641000, + 13645000, + 13646000, + 13648000, + 13649000, + 13650000, + 13651000, + 13652000, + 13653000, + 13654000, + 13656000, + 13657000, + 13658000, + 13659000, + 13661000, + 13662000, + 13663000, + 13664000, + 13665000, + 13666000, + 13667000, + 13668000, + 13669000, + 13670000, + 13673000, + 13674000, + 13675000, + 13678000, + 13679000, + 13680000, + 13681000, + 13682000, + 13683000, + 13684000, + 13685000, + 13687000, + 13688000, + 13689000, + 13691000, + 13692000, + 13693000, + 13695000, + 13696000, + 13697000, + 13699000, + 13700000, + 13702000, + 13703000, + 13704000, + 13705000, + 13706000, + 13707000, + 13708000, + 13709000, + 13710000, + 13741000, + 13742000, + 13743000, + 13745000, + 13746000, + 13748000, + 13749000, + 13750000, + 13751000, + 13752000, + 13753000, + 13754000, + 13755000, + 13757000, + 13759000, + 13760000, + 13761000, + 13762000, + 13763000, + 13766000, + 13767000, + 13770000, + 13771000, + 13772000, + 13773000, + 13775000, + 13776000, + 13777000, + 13781000, + 13782000, + 13783000, + 13788000, + 13789000, + 13791000, + 13792000, + 13794000, + 13795000, + 13796000, + 13798000, + 13800000, + 13802000, + 13803000, + 13804000, + 13805000, + 13807000, + 13809000, + 13811000, + 13813000, + 13815000, + 13816000, + 13819000, + 13820000, + 13824000, + 13825000, + 13826000, + 13827000, + 13828000, + 13831000, + 13832000, + 13833000, + 13835000, + 13836000, + 13837000, + 13838000, + 13840000, + 13841000, + 13842000, + 13843000, + 13844000, + 13845000, + 13848000, + 13849000, + 13850000, + 13851000, + 13853000, + 13854000, + 13855000, + 13856000, + 13857000, + 13858000, + 13860000, + 13862000, + 13863000, + 13864000, + 13865000, + 13868000, + 13869000, + 13871000, + 13872000, + 13873000, + 13874000, + 13875000, + 13876000, + 13877000, + 13878000, + 13879000, + 13880000, + 13882000, + 13883000, + 13884000, + 13885000, + 13887000, + 13888000, + 13889000, + 13890000, + 13891000, + 13892000, + 13893000, + 13894000, + 13896000, + 13897000, + 13898000, + 13899000, + 13900000, + 13903000, + 13904000, + 13905000, + 13906000, + 13907000, + 13908000, + 13910000, + 13911000, + 13912000, + 13914000, + 13915000, + 13918000, + 13919000, + 13920000, + 13921000, + 13922000, + 13923000, + 13924000, + 13925000, + 13928000, + 13929000, + 13930000, + 13931000, + 13932000, + 13933000, + 13934000, + 13937000, + 13938000, + 13939000, + 13940000, + 13943000, + 13944000, + 13945000, + 13947000, + 13948000, + 13949000, + 13950000, + 13951000, + 13952000, + 13955000, + 13957000, + 13959000, + 13960000, + 13961000, + 13963000, + 13965000, + 13966000, + 13967000, + 13968000, + 13969000, + 13971000, + 13972000, + 13974000, + 13975000, + 13979000, + 13980000, + 13981000, + 13982000, + 13983000, + 13984000, + 13985000, + 13987000, + 13988000, + 13989000, + 13990000, + 13992000, + 13993000, + 13994000, + 13995000, + 13996000, + 14010000, + 14016000, + 14023000, + 14052000, + 14088000, + 14112000, + 14136000, + 14144000, + 14150000, + 14163000, + 14173000, + 14189000, + 14200000, + 14244000, + 14250000, + 14272000, + 14300000, + 14325000, + 14334000, + 14364000, + 14376000, + 14440000, + 14448000, + 14450000, + 14453000, + 14460000, + 14494000, + 14520000, + 14544000, + 14560000, + 14568000, + 14610000, + 14625000, + 14640000, + 14784000, + 14789000, + 14808000, + 14825000, + 14856000, + 14868000, + 14880000, + 14895000, + 14900000, + 14904000, + 14910000, + 14912000, + 14928000, + 14930000, + 14932000, + 14944000, + 14948000, + 14950000, + 14952000, + 14975000, + 14985000, + 15012000, + 15024000, + 15025000, + 15029000, + 15030000, + 15050000, + 15125000, + 15136000, + 15144000, + 15150000, + 15156000, + 15160000, + 15165000, + 15167000, + 15168000, + 15172000, + 15175000, + 15180000, + 15200000, + 15210000, + 15216000, + 15250000, + 15270000, + 15278000, + 15288000, + 15296000, + 15297000, + 15300000, + 15301000, + 15312000, + 15320000, + 15321000, + 15325000, + 15328000, + 15330000, + 15331000, + 15338000, + 15350000, + 15474000, + 15475000, + 15480000, + 15482000, + 15488000, + 15491000, + 15500000, + 15504000, + 15505000, + 15509000, + 15510000, + 15511000, + 15513000, + 15520000, + 15525000, + 15528000, + 15540000, + 15550000, + 15551000, + 15569000, + 15571000, + 15575000, + 15576000, + 15584000, + 15588000, + 15594000, + 15600000, + 15609000, + 15615000, + 15616000, + 15618000, + 15623000, + 15624000, + 15625000, + 15648000, + 15650000, + 15660000, + 15666000, + 15671000, + 15672000, + 15680000, + 15685000, + 15686000, + 15690000, + 15695000, + 15696000, + 15698000, + 15700000, + 15705000, + 15712000, + 15715000, + 15720000, + 15723000, + 15725000, + 15732000, + 15736000, + 15840000, + 15841000, + 15843000, + 15854000, + 15855000, + 15858000, + 15862000, + 15863000, + 15865000, + 15869000, + 15875000, + 15876000, + 15879000, + 15881000, + 15882000, + 15885000, + 15887000, + 15897000, + 15898000, + 15900000, + 15904000, + 15910000, + 15912000, + 15913000, + 15922000, + 15924000, + 15925000, + 15930000, + 15933000, + 15936000, + 15937000, + 15938000, + 15942000, + 15946000, + 15948000, + 15950000, + 15952000, + 15954000, + 15955000, + 15968000, + 15973000, + 15980000, + 16149000, + 16264000, + 16272000, + 16275000, + 16280000, + 16289000, + 16290000, + 16296000, + 16300000, + 16325000, + 16335000, + 16341000, + 16353000, + 16368000, + 16373000, + 16374000, + 16380000, + 16384000, + 16385000, + 16387000, + 16391000, + 16392000, + 16394000, + 16395000, + 16400000, + 16549000, + 16613000, + 16674000, + 16684000, + 16685000, + 16691000, + 16692000, + 16708000, + 16853000, + 16860000, + 16875000, + 16877000, + 16880000, + 16884000, + 16890000, + 16895000, + 16901000, + 16920000, + 16965000, + 16975000, + 17093000, + 17765000, + 18925000, + 19004000, + 19092000, + 19100000, + 19104000, + 19140000, + 19160000, + 19168000, + 19170000, + 19176000, + 19232000, + 19236000, + 19260000, + 19272000, + 19275000, + 19280000, + 19289000, + 19290000, + 19296000, + 19308000, + 19321000, + 19325000, + 19344000, + 19352000, + 19360000, + 19368000, + 19380000, + 19392000, + 19395000, + 19403000, + 19410000, + 19424000, + 19425000, + 19427000, + 19440000, + 19456000, + 19470000, + 19475000, + 19480000, + 19488000, + 19500000, + 19512000, + 19525000, + 19590000, + 19608000, + 19613000, + 19616000, + 19620000, + 19624000, + 19632000, + 19640000, + 19648000, + 19660000, + 19665000, + 19675000, + 19680000, + 19700000, + 19704000, + 19710000, + 19712000, + 19720000, + 19723000, + 19728000, + 19740000, + 19750000, + 19752000, + 19755000, + 19760000, + 19775000, + 19788000, + 19824000, + 19825000, + 19830000, + 19836000, + 19845000, + 19848000, + 19860000, + 19875000, + 19896000, + 19899000, + 19908000, + 19920000, + 19925000, + 19935000, + 19936000, + 19939000, + 19944000, + 19960000, + 19962000, + 19971000, + 19975000, + 19980000, + 19988000, + 19991000, + 19992000, + 20008000, + 20009000, + 20010000, + 20011000, + 20012000, + 20013000, + 20015000, + 20016000, + 20024000, + 20025000, + 20026000, + 20027000, + 20028000, + 20032000, + 20036000, + 20040000, + 20042000, + 20043000, + 20050000, + 20052000, + 20058000, + 20061000, + 20062000, + 20063000, + 20064000, + 20068000, + 20069000, + 20070000, + 20075000, + 20076000, + 20079000, + 20080000, + 20082000, + 20083000, + 20085000, + 20087000, + 20088000, + 20091000, + 20095000, + 20096000, + 20097000, + 20101000, + 20107000, + 20112000, + 20115000, + 20120000, + 20124000, + 20125000, + 20128000, + 20130000, + 20131000, + 20136000, + 20137000, + 20138000, + 20141000, + 20150000, + 20151000, + 20158000, + 20160000, + 20161000, + 20162000, + 20167000, + 20168000, + 20169000, + 20173000, + 20175000, + 20176000, + 20179000, + 20184000, + 20186000, + 20190000, + 20191000, + 20192000, + 20193000, + 20196000, + 20200000, + 20202000, + 20205000, + 20208000, + 20213000, + 20215000, + 20217000, + 20219000, + 20220000, + 20223000, + 20224000, + 20225000, + 20227000, + 20228000, + 20232000, + 20233000, + 20236000, + 20237000, + 20240000, + 20247000, + 20250000, + 20274000, + 20275000, + 20279000, + 20280000, + 20281000, + 20288000, + 20295000, + 20296000, + 20298000, + 20300000, + 20301000, + 20304000, + 20305000, + 20315000, + 20318000, + 20320000, + 20322000, + 20323000, + 20324000, + 20325000, + 20327000, + 20328000, + 20329000, + 20331000, + 20336000, + 20340000, + 20344000, + 20345000, + 20349000, + 20350000, + 20351000, + 20352000, + 20353000, + 20355000, + 20360000, + 20367000, + 20370000, + 20371000, + 20372000, + 20375000, + 20376000, + 20379000, + 20380000, + 20384000, + 20385000, + 20388000, + 20395000, + 20407000, + 20411000, + 20412000, + 20414000, + 20416000, + 20419000, + 20421000, + 20422000, + 20423000, + 20424000, + 20425000, + 20427000, + 20428000, + 20430000, + 20434000, + 20437000, + 20440000, + 20460000, + 20461000, + 20463000, + 20465000, + 20469000, + 20475000, + 20476000, + 20479000, + 20480000, + 20484000, + 20490000, + 20494000, + 20496000, + 20498000, + 20500000, + 20504000, + 20508000, + 20512000, + 20520000, + 20524000, + 20525000, + 20534000, + 20544000, + 20547000, + 20550000, + 20556000, + 20560000, + 20561000, + 20563000, + 20564000, + 20565000, + 20566000, + 20568000, + 20575000, + 20576000, + 20577000, + 20580000, + 20583000, + 20592000, + 20600000, + 20604000, + 20607000, + 20608000, + 20610000, + 20616000, + 20617000, + 20619000, + 20625000, + 20628000, + 20629000, + 20641000, + 20650000, + 20654000, + 20655000, + 20660000, + 20664000, + 20670000, + 20672000, + 20675000, + 20680000, + 20681000, + 20688000, + 20691000, + 20692000, + 20700000, + 20704000, + 20712000, + 20719000, + 20720000, + 20725000, + 20730000, + 20736000, + 20737000, + 20745000, + 20746000, + 20747000, + 20750000, + 20758000, + 20760000, + 20764000, + 20768000, + 20771000, + 20772000, + 20775000, + 20776000, + 20784000, + 20790000, + 20792000, + 20796000, + 20800000, + 20812000, + 20816000, + 20818000, + 20820000, + 20823000, + 20825000, + 20828000, + 20832000, + 20835000, + 20840000, + 20844000, + 20850000, + 20856000, + 20857000, + 20862000, + 20864000, + 20868000, + 20871000, + 20875000, + 20878000, + 20880000, + 20896000, + 20900000, + 20906000, + 20910000, + 20915000, + 20916000, + 20918000, + 20920000, + 20925000, + 20926000, + 20928000, + 20940000, + 20943000, + 20945000, + 20948000, + 20950000, + 20952000, + 20958000, + 20959000, + 20960000, + 20964000, + 20970000, + 20972000, + 20974000, + 20976000, + 20988000, + 20992000, + 20993000, + 20994000, + 21000000, + 21007000, + 21012000, + 21015000, + 21016000, + 21018000, + 21023000, + 21024000, + 21025000, + 21026000, + 21030000, + 21040000, + 21048000, + 21050000, + 21060000, + 21072000, + 21075000, + 21076000, + 21080000, + 21088000, + 21089000, + 21090000, + 21096000, + 21100000, + 21105000, + 21106000, + 21112000, + 21118000, + 21125000, + 21132000, + 21136000, + 21144000, + 21150000, + 21152000, + 21160000, + 21161000, + 21168000, + 21175000, + 21180000, + 21184000, + 21192000, + 21195000, + 21200000, + 21206000, + 21210000, + 21216000, + 21225000, + 21228000, + 21240000, + 21248000, + 21250000, + 21262000, + 21264000, + 21270000, + 21275000, + 21276000, + 21280000, + 21284000, + 21285000, + 21288000, + 21300000, + 21312000, + 21320000, + 21330000, + 21336000, + 21344000, + 21345000, + 21348000, + 21350000, + 21360000, + 21362000, + 21375000, + 21376000, + 21390000, + 21400000, + 21408000, + 21420000, + 21425000, + 21432000, + 21440000, + 21450000, + 21456000, + 21465000, + 21472000, + 21475000, + 21480000, + 21484000, + 21492000, + 21520000, + 21525000, + 21528000, + 21536000, + 21540000, + 21550000, + 21552000, + 21555000, + 21560000, + 21564000, + 21568000, + 21570000, + 21575000, + 21576000, + 21624000, + 21625000, + 21630000, + 21632000, + 21636000, + 21640000, + 21645000, + 21648000, + 21650000, + 21660000, + 21664000, + 21672000, + 21675000, + 21680000, + 21690000, + 21700000, + 21708000, + 21720000, + 21725000, + 21728000, + 21735000, + 21750000, + 21760000, + 21768000, + 21780000, + 21792000, + 21800000, + 21810000, + 21816000, + 21824000, + 21825000, + 21840000, + 21850000, + 21852000, + 21856000, + 21864000, + 21870000, + 21875000, + 21880000, + 21900000, + 21912000, + 21915000, + 21920000, + 21924000, + 21925000, + 21930000, + 21950000, + 21952000, + 21960000, + 21975000, + 21984000, + 21990000, + 21996000, + 22000000, + 22005000, + 22008000, + 22009000, + 22016000, + 22020000, + 22025000, + 22030000, + 22032000, + 22040000, + 22048000, + 22050000, + 22056000, + 22062000, + 22065000, + 22068000, + 22075000, + 22095000, + 22100000, + 22112000, + 22120000, + 22125000, + 22128000, + 22140000, + 22144000, + 22150000, + 22152000, + 22160000, + 22170000, + 22175000, + 22176000, + 22185000, + 22200000, + 22208000, + 22212000, + 22224000, + 22225000, + 22230000, + 22240000, + 22245000, + 22248000, + 22250000, + 22260000, + 22272000, + 22275000, + 22280000, + 22290000, + 22296000, + 22300000, + 22304000, + 22320000, + 22325000, + 22336000, + 22344000, + 22350000, + 22356000, + 22360000, + 22365000, + 22368000, + 22375000, + 22380000, + 22392000, + 22410000, + 22416000, + 22425000, + 22428000, + 22432000, + 22440000, + 22450000, + 22455000, + 22470000, + 22475000, + 22480000, + 22488000, + 22500000, + 22512000, + 22520000, + 22525000, + 22528000, + 22536000, + 22550000, + 22560000, + 22575000, + 22584000, + 22590000, + 22592000, + 22600000, + 22608000, + 22620000, + 22624000, + 22625000, + 22632000, + 22635000, + 22640000, + 22644000, + 22650000, + 22675000, + 22680000, + 22688000, + 22700000, + 22704000, + 22710000, + 22716000, + 22720000, + 22725000, + 22728000, + 22740000, + 22750000, + 22752000, + 22760000, + 22770000, + 22775000, + 22776000, + 22800000, + 22815000, + 22816000, + 22824000, + 22825000, + 22840000, + 22848000, + 22850000, + 22872000, + 22875000, + 22880000, + 22890000, + 22896000, + 22900000, + 22905000, + 22912000, + 22920000, + 22925000, + 22932000, + 22944000, + 22950000, + 22960000, + 22968000, + 22975000, + 22976000, + 22980000, + 22992000, + 23000000, + 23004000, + 23008000, + 23010000, + 23016000, + 23025000, + 23050000, + 23064000, + 23075000, + 23080000, + 23088000, + 23100000, + 23104000, + 23112000, + 23120000, + 23125000, + 23130000, + 23136000, + 23150000, + 23160000, + 23168000, + 23175000, + 23184000, + 23190000, + 23220000, + 23225000, + 23232000, + 23240000, + 23250000, + 23256000, + 23265000, + 23275000, + 23280000, + 23300000, + 23304000, + 23310000, + 23320000, + 23328000, + 23340000, + 23350000, + 23355000, + 23360000, + 23364000, + 23370000, + 23375000, + 23376000, + 23392000, + 23400000, + 23425000, + 23430000, + 23440000, + 23445000, + 23448000, + 23450000, + 23456000, + 23460000, + 23472000, + 23475000, + 23480000, + 23488000, + 23490000, + 23496000, + 23500000, + 23544000, + 23550000, + 23552000, + 23560000, + 23568000, + 23575000, + 23580000, + 23584000, + 23592000, + 23600000, + 23610000, + 23616000, + 23625000, + 23640000, + 23648000, + 23650000, + 23652000, + 23664000, + 23670000, + 23675000, + 23700000, + 23715000, + 23720000, + 23724000, + 23725000, + 23730000, + 23736000, + 23744000, + 23750000, + 23760000, + 23775000, + 23776000, + 23784000, + 23790000, + 23800000, + 23805000, + 23820000, + 23832000, + 23840000, + 23850000, + 23856000, + 23868000, + 23872000, + 23875000, + 23880000, + 23895000, + 23900000, + 23904000, + 23910000, + 23920000, + 23925000, + 23928000, + 23936000, + 23940000, + 23950000, + 23952000, + 23960000, + 23968000, + 23970000, + 23976000, + 24050000, + 24060000, + 24064000, + 24072000, + 24075000, + 24080000, + 24084000, + 24090000, + 24096000, + 24120000, + 24125000, + 24128000, + 24144000, + 24156000, + 24160000, + 24165000, + 24175000, + 24180000, + 24200000, + 24210000, + 24216000, + 24224000, + 24225000, + 24228000, + 24240000, + 24250000, + 24255000, + 24256000, + 24270000, + 24275000, + 24280000, + 24288000, + 24325000, + 24330000, + 24336000, + 24345000, + 24350000, + 24360000, + 24375000, + 24400000, + 24408000, + 24416000, + 24420000, + 24425000, + 24448000, + 24450000, + 24456000, + 24510000, + 24512000, + 24516000, + 24520000, + 24608000, + 24640000, + 24648000, + 24650000, + 24690000, + 24696000, + 24700000, + 24704000, + 24736000, + 24744000, + 24750000, + 24792000, + 24795000, + 24804000, + 24810000, + 24816000, + 24825000, + 24832000, + 24840000, + 24850000, + 24853000, + 24864000, + 24870000, + 24875000, + 24876000, + 24880000, + 24885000, + 24888000, + 24896000, + 24900000, + 24912000, + 24920000, + 24925000, + 24928000, + 24930000, + 24936000, + 24948000, + 24950000, + 24975000, + 24984000, + 24990000, + 24992000, + 25000000, + 25008000, + 25020000, + 25024000, + 25025000, + 25032000, + 25040000, + 25050000, + 25056000, + 25065000, + 25075000, + 25080000, + 25088000, + 25093000, + 25100000, + 25104000, + 25110000, + 25125000, + 25128000, + 25140000, + 25150000, + 25152000, + 25155000, + 25160000, + 25170000, + 25175000, + 25176000, + 25184000, + 25200000, + 25206000, + 25216000, + 25224000, + 25225000, + 25230000, + 25236000, + 25240000, + 25245000, + 25248000, + 25250000, + 25260000, + 25272000, + 25275000, + 25290000, + 25296000, + 25300000, + 25308000, + 25312000, + 25320000, + 25325000, + 25350000, + 25360000, + 25368000, + 25375000, + 25376000, + 25380000, + 25392000, + 25416000, + 25425000, + 25440000, + 25450000, + 25452000, + 25457000, + 25464000, + 25472000, + 25475000, + 25480000, + 25488000, + 25500000, + 25512000, + 25515000, + 25520000, + 25524000, + 25525000, + 25530000, + 25536000, + 25550000, + 25560000, + 25568000, + 25575000, + 25584000, + 25590000, + 25596000, + 25605000, + 25608000, + 25620000, + 25625000, + 25632000, + 25640000, + 25650000, + 25656000, + 25664000, + 25668000, + 25675000, + 25680000, + 25695000, + 25696000, + 25700000, + 25704000, + 25710000, + 25720000, + 25725000, + 25728000, + 25740000, + 25750000, + 25752000, + 25754000, + 25760000, + 25770000, + 25776000, + 25785000, + 25792000, + 25800000, + 25812000, + 25824000, + 25825000, + 25830000, + 25840000, + 25848000, + 25850000, + 25860000, + 25872000, + 25875000, + 25884000, + 25888000, + 25890000, + 25896000, + 25900000, + 25903000, + 25925000, + 25944000, + 25950000, + 25952000, + 25956000, + 25960000, + 25965000, + 25968000, + 25975000, + 25980000, + 25984000, + 25992000, + 26016000, + 26025000, + 26028000, + 26040000, + 26048000, + 26050000, + 26055000, + 26064000, + 26070000, + 26075000, + 26080000, + 26088000, + 26100000, + 26112000, + 26120000, + 26125000, + 26130000, + 26136000, + 26144000, + 26150000, + 26160000, + 26172000, + 26175000, + 26176000, + 26184000, + 26190000, + 26200000, + 26208000, + 26220000, + 26225000, + 26232000, + 26235000, + 26250000, + 26256000, + 26272000, + 26275000, + 26280000, + 26300000, + 26304000, + 26310000, + 26316000, + 26325000, + 26328000, + 26336000, + 26340000, + 26352000, + 26360000, + 26368000, + 26370000, + 26375000, + 26376000, + 26388000, + 26415000, + 26424000, + 26425000, + 26430000, + 26432000, + 26438000, + 26440000, + 26448000, + 26450000, + 26460000, + 26464000, + 26472000, + 26475000, + 26480000, + 26490000, + 26500000, + 26505000, + 26518000, + 26520000, + 26525000, + 26528000, + 26532000, + 26544000, + 26550000, + 26559000, + 26560000, + 26568000, + 26575000, + 26580000, + 26592000, + 26595000, + 26600000, + 26604000, + 26610000, + 26616000, + 26640000, + 26650000, + 26656000, + 26664000, + 26670000, + 26676000, + 26680000, + 26685000, + 26688000, + 26700000, + 26712000, + 26720000, + 26725000, + 26730000, + 26736000, + 26748000, + 26750000, + 26752000, + 26760000, + 26775000, + 26777000, + 26784000, + 26790000, + 26808000, + 26820000, + 26825000, + 26832000, + 26838000, + 26840000, + 26848000, + 26850000, + 26851000, + 26856000, + 26865000, + 26868000, + 26875000, + 26892000, + 26900000, + 26904000, + 26910000, + 26912000, + 26920000, + 26925000, + 26928000, + 26940000, + 26944000, + 26950000, + 26951000, + 26952000, + 26955000, + 26960000, + 26964000, + 26967000, + 26970000, + 26975000, + 26976000, + 26977000, + 27000000, + 27001000, + 27008000, + 27024000, + 27025000, + 27030000, + 27036000, + 27040000, + 27045000, + 27048000, + 27050000, + 27060000, + 27075000, + 27080000, + 27090000, + 27096000, + 27100000, + 27104000, + 27108000, + 27120000, + 27125000, + 27135000, + 27136000, + 27144000, + 27150000, + 27160000, + 27168000, + 27175000, + 27180000, + 27192000, + 27232000, + 27240000, + 27250000, + 27264000, + 27270000, + 27275000, + 27280000, + 27296000, + 27300000, + 27312000, + 27320000, + 27324000, + 27325000, + 27328000, + 27330000, + 27336000, + 27350000, + 27360000, + 27375000, + 27384000, + 27390000, + 27392000, + 27396000, + 27400000, + 27403000, + 27405000, + 27457000, + 27475000, + 27480000, + 27488000, + 27495000, + 27500000, + 27504000, + 27525000, + 27528000, + 27540000, + 27550000, + 27552000, + 27560000, + 27570000, + 27575000, + 27576000, + 27584000, + 27585000, + 27612000, + 27616000, + 27624000, + 27625000, + 27672000, + 27675000, + 27680000, + 27684000, + 27690000, + 27696000, + 27712000, + 27720000, + 27750000, + 27756000, + 27760000, + 27765000, + 27768000, + 27775000, + 27776000, + 27780000, + 27792000, + 27800000, + 27808000, + 27810000, + 27816000, + 27825000, + 27828000, + 27850000, + 27855000, + 27864000, + 27870000, + 27872000, + 27875000, + 27880000, + 27888000, + 27900000, + 27904000, + 27912000, + 27920000, + 27925000, + 27930000, + 27945000, + 27950000, + 27960000, + 27968000, + 27975000, + 27984000, + 28008000, + 28020000, + 28025000, + 28035000, + 28040000, + 28044000, + 28050000, + 28056000, + 28080000, + 28096000, + 28100000, + 28104000, + 28110000, + 28120000, + 28125000, + 28128000, + 28140000, + 28150000, + 28152000, + 28170000, + 28175000, + 28176000, + 28188000, + 28192000, + 28200000, + 28224000, + 28225000, + 28230000, + 28240000, + 28248000, + 28256000, + 28260000, + 28272000, + 28275000, + 28280000, + 28288000, + 28290000, + 28296000, + 28300000, + 28305000, + 28325000, + 28332000, + 28344000, + 28350000, + 28352000, + 28360000, + 28368000, + 28375000, + 28380000, + 28384000, + 28392000, + 28395000, + 28400000, + 28403000, + 28404000, + 28410000, + 28416000, + 28425000, + 28440000, + 28448000, + 28450000, + 28464000, + 28470000, + 28475000, + 28485000, + 28488000, + 28500000, + 28512000, + 28520000, + 28525000, + 28530000, + 28536000, + 28544000, + 28550000, + 28560000, + 28575000, + 28576000, + 28584000, + 28590000, + 28620000, + 28625000, + 28632000, + 28640000, + 28650000, + 28656000, + 28665000, + 28692000, + 28720000, + 28725000, + 28728000, + 28736000, + 28740000, + 28750000, + 28752000, + 28755000, + 28760000, + 28764000, + 28824000, + 28825000, + 28832000, + 28836000, + 28840000, + 28845000, + 28848000, + 28860000, + 28864000, + 28872000, + 28875000, + 28880000, + 28896000, + 28908000, + 28920000, + 28935000, + 28960000, + 28968000, + 28975000, + 28980000, + 28992000, + 29000000, + 29010000, + 29016000, + 29024000, + 29050000, + 29056000, + 29064000, + 29070000, + 29075000, + 29080000, + 29088000, + 29100000, + 29125000, + 29130000, + 29136000, + 29150000, + 29152000, + 29160000, + 29190000, + 29196000, + 29200000, + 29208000, + 29216000, + 29220000, + 29232000, + 29250000, + 29275000, + 29295000, + 29304000, + 29312000, + 29320000, + 29325000, + 29344000, + 29350000, + 29352000, + 29360000, + 29370000, + 29375000, + 29385000, + 29400000, + 29412000, + 29424000, + 29425000, + 29430000, + 29460000, + 29490000, + 29496000, + 29504000, + 29544000, + 29565000, + 29575000, + 29592000, + 29632000, + 29680000, + 29696000, + 29725000, + 29775000, + 29790000, + 29850000, + 29940000, + 30000000, + 36000000 +}; + +static int _last; +bool _clean; +extern "C" +bool isclean(void) { return _clean; } +extern "C" +int getfreq( int nominal, bool mode, int *fcorr) +{ + int x,y, min, nturns; + double corr; + int retval; + corr = 1.0; + + int idxmax =sizeof(freqtab)/sizeof(int)-1; + int delta = freqtab[idxmax]-freqtab[0]; + if (_last <0) _last=0; + if (_last >idxmax) _last = idxmax; + + if ((nominal < freqtab[0])) + { + _clean =TRUE; + return nominal; // if freq = 33000000) + { + _clean = FALSE; + retval = 33000000; + return retval; + } + + if ((nominal > freqtab[0]) && + (nominal < freqtab[idxmax])) + { + x = _last; + y = freqtab[x]-nominal; + min =100000; + nturns =0; + if (y >0) + { + while (freqtab[x]>= nominal) + x--; + } + else + { + while (freqtab[x] <= nominal) + x++; + x--; + } + + { + if (mode ==TRUE) + { + if (y >0) + { + while (freqtab[x]>= nominal) + x--; + } + else + { + while (freqtab[x] <= nominal) + x++; + } + _last = x; + } + else + { + if (y >0) + { + while (freqtab[x]>= nominal) + x--; + } + else + { + while (freqtab[x]<= nominal) + x++; + x--; + } + _last = x; + } + if (abs(nominal-freqtab[x])<15000) + { + _clean =TRUE; + retval = freqtab[_last]; + *fcorr =(int) ((double) retval * corr); + return retval; + } + else + { + _clean =FALSE; + retval = nominal; + *fcorr =(int) ((double) retval * corr); + return retval; + } + } + } + else + { + _clean =FALSE; + retval = nominal; + *fcorr =(int) ((double) retval * corr); + return retval; + } +} + + diff --git a/src/freqtabH101.h b/src/freqtabH101.h new file mode 100644 index 0000000..15cd0f3 --- /dev/null +++ b/src/freqtabH101.h @@ -0,0 +1,8 @@ +#if !defined FREQTABH101_H +#define FREQTABH101_H +extern "C" +int getfreq(int nominal, bool mode, int* fcorr); +extern "C" +bool isclean(void); + +#endif diff --git a/src/resource.h b/src/resource.h new file mode 100644 index 0000000..86f8750 --- /dev/null +++ b/src/resource.h @@ -0,0 +1,26 @@ +#ifndef IDC_STATIC +#define IDC_STATIC (-1) +#endif + +#define VERSION "ExtIO_H101.dll ver 0.12" + +#define IDD_RTL_SETTINGS 100 +#define IDC_SAMPLERATE 1000 +#define IDC_GAIN 1001 +#define IDC_PLL 1002 +#define IDC_TUNERAGC 1004 +#define IDC_RTLAGC 1005 +#define IDC_GAINVALUE 1006 +#define IDC_DEVICE 1007 +#define IDC_PPM 1009 +#define IDC_OFFSET 1010 +#define IDC_PPM_S 1011 +#define IDC_DIRECT 1013 +#define IDC_AUDIOIN 1014 +#define IDC_AUDIOOUT 1015 +#define IDC_ANTENNA 1016 +#define IDC_ATTENUATOR 1017 +#define IDC_IFGAIN 1018 +#define IDC_ADC 1019 +#define IDC_ADC_S 1020 +#define IDC_SOUNDD 1021 diff --git a/src/settings.cpp b/src/settings.cpp new file mode 100644 index 0000000..38ef4d6 --- /dev/null +++ b/src/settings.cpp @@ -0,0 +1,38 @@ + +#include "Settings.h" + +Settings::Settings(const TCHAR * ini_name) +{ + GetEnvironmentVariable(TEXT("APPDATA"), filename, sizeof filename); + _tcscat_s(filename, ini_name); +} + +void Settings::set(const TCHAR * section, const TCHAR * key, const TCHAR * value) +{ + WritePrivateProfileString(section, key , value, filename); +} + +void Settings::set_int(const TCHAR * section, const TCHAR * key, const int value) +{ + TCHAR data[255]; + _stprintf( data, TEXT("%d"), value); + WritePrivateProfileString(section, key, data, filename); +} + +TCHAR * Settings::get(const TCHAR * section, const TCHAR * key, const TCHAR * defaultvalue) +{ + GetPrivateProfileString(section, key, defaultvalue, tResult, sizeof(tResult), filename); + return tResult; +} + +const int Settings::get_int(const TCHAR * section, const TCHAR * key, const int defaultvalue) +{ + TCHAR default[255]; + int dato; + _stprintf( default, TEXT("%d"), defaultvalue); + GetPrivateProfileString(section, key, default, tResult, sizeof(tResult), filename); + _stscanf(tResult, TEXT("%d"), &dato); + return dato; +} + + diff --git a/src/settings.h b/src/settings.h new file mode 100644 index 0000000..7cefa61 --- /dev/null +++ b/src/settings.h @@ -0,0 +1,58 @@ +#ifndef __SETTING_H__ +#define __SETTING_H__ + +#include +#include +#include +#include +#include +#include + +#define MAXKEYLENGHT 255 +#define MAXPATH 512 + +//#define _MYDEBUG // Activate a debug console + +#ifdef __cplusplus +inline void null_func(char *format, ...) { } +#define DbgEmpty null_func +#define TbgPrintf null_func +#else +#define DbgEmpty { } +#endif + +#ifdef _MYDEBUG +/* Debug Trace Enabled */ +#include +#define DbgPrintf printf +#define TbgPrintf _tprintf +#else +/* Debug Trace Disabled */ +#define DbgPrintf DbgEmpty +#endif + +template void SafeRelease(T **ppT) +{ + if (*ppT) + { + (*ppT)->Release(); + *ppT = NULL; + } +} + +class Settings +{ +public: + Settings(const TCHAR * ini_name); // Application inifile name.... + void set(const TCHAR * section, const TCHAR * key, const TCHAR * value); // TCHAR string + void set_int(const TCHAR * section, const TCHAR * key, const int value); // int + TCHAR* get(const TCHAR * section, const TCHAR * key, const TCHAR * defaultvalue); + const int get_int(const TCHAR * section, const TCHAR * key, const int defaultvalue); +//private: + TCHAR filename[MAXPATH]; + TCHAR tResult[255]; +}; + + + +#endif __SETTING_H__